sean-m
/
Vanara
mirror of https://github.com/dahall/Vanara.git
1
0
Fork 0
Code Issues Releases Wiki Activity
Vanara/PInvoke/Shell32/ShlObj.cs

2789 lines
155 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

using System;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.ComTypes;
using System.Security;
using System.Text;
using Vanara.InteropServices;
using static Vanara.PInvoke.AdvApi32;
using static Vanara.PInvoke.ComCtl32;
using static Vanara.PInvoke.Kernel32;
using static Vanara.PInvoke.Ole32;
using static Vanara.PInvoke.ShlwApi;
// 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
{
[SuppressUnmanagedCodeSecurity]
public static partial class Shell32
{
// Defined in wingdi.h
private const int LF_FACESIZE = 32;
/// <summary>A flag that controls how PifMgr_CloseProperties operates.</summary>
[PInvokeData("shlobj_core.h", MSDNShortId = "fd50d4f8-87c8-4162-9e88-3c8592b929fa")]
public enum CLOSEPROPS
{
/// <summary>No options specified.</summary>
CLOSEPROPS_NONE = 0x0000,
/// <summary>Abandon cached data.</summary>
CLOSEPROPS_DISCARD = 0x0001
}
/// <summary>Used for options in SHOpenFolderAndSelectItems.</summary>
[PInvokeData("Shlobj.h", MSDNShortId = "bb762232")]
public enum OFASI : uint
{
/// <summary>No options.</summary>
OFASI_NONE = 0,
/// <summary>
/// Select an item and put its name in edit mode. This flag can only be used when a single item is being selected. For multiple item selections, it
/// is ignored.
/// </summary>
OFASI_EDIT = 1,
/// <summary>
/// Select the item or items on the desktop rather than in a Windows Explorer window. Note that if the desktop is obscured behind open windows, it
/// will not be made visible.
/// </summary>
OFASI_OPENDESKTOP = 2
}
/// <summary>A flag that controls how PifMgr_OpenProperties operates.</summary>
[PInvokeData("shlobj_core.h", MSDNShortId = "0bc11528-7278-4765-b3cb-671ba82c9155")]
public enum OPENPROPS
{
/// <summary>No options specified.</summary>
OPENPROPS_NONE = 0x0000,
/// <summary>
/// Ignore any existing .pif files and get the properties from win.ini or _Default.pif. This flag is ignored on Windows NT,
/// Windows 2000, and Windows XP.
/// </summary>
OPENPROPS_INHIBITPIF = 0x8000
}
/// <summary>Return values for PathCleanupSpec.</summary>
[PInvokeData("shlobj_core.h", MSDNShortId = "593fd2b7-44ae-4309-a185-97e42f3cc0fa")]
[Flags]
public enum PCS : uint
{
/// <summary>The cleaned path is not a valid file name. This flag is always returned in conjunction with PCS_PATHTOOLONG.</summary>
PCS_FATAL = 0x80000000,
/// <summary>Replaced one or more invalid characters.</summary>
PCS_REPLACEDCHAR = 0x00000001,
/// <summary>Removed one or more invalid characters.</summary>
PCS_REMOVEDCHAR = 0x00000002,
/// <summary>The returned path is truncated.</summary>
PCS_TRUNCATED = 0x00000004,
/// <summary>
/// The function failed because the input path specified at is too long to allow the formation of a valid file name from . When this
/// flag is returned, it is always accompanied by the PCS_FATAL flag.
/// </summary>
PCS_PATHTOOLONG = 0x00000008,
}
/// <summary>Flags for PathResolve.</summary>
[PInvokeData("shlobj_core.h", MSDNShortId = "84bf0b56-513f-4ac6-b2cf-11f0c471da1e")]
[Flags]
public enum PRF
{
/// <summary>Return TRUE if the file's existence is verified; otherwise FALSE.</summary>
PRF_VERIFYEXISTS = 0x0001,
/// <summary>Look for the specified path with the following extensions appended: .pif, .com, .bat, .cmd, .lnk, and .exe.</summary>
PRF_TRYPROGRAMEXTENSIONS = 0x0002 | PRF_VERIFYEXISTS,
/// <summary>Look first in the directory or directories specified by dirs.</summary>
PRF_FIRSTDIRDEF = 0x0004,
/// <summary>Ignore .lnk files.</summary>
PRF_DONTFINDLNK = 0x0008,
/// <summary>Require an absolute (full) path.</summary>
PRF_REQUIREABSOLUTE = 0x0010
}
/// <summary>Flags that direct the handling of the item from which you're retrieving the info tip text. This value is commonly zero (QITIPF_DEFAULT).</summary>
[PInvokeData("Shlobj.h", MSDNShortId = "bb761357")]
public enum QITIP
{
/// <summary>No special handling.</summary>
QITIPF_DEFAULT = 0x00000000,
/// <summary>Provide the name of the item in ppwszTip rather than the info tip text.</summary>
QITIPF_USENAME = 0x00000001,
/// <summary>If the item is a shortcut, retrieve the info tip text of the shortcut rather than its target.</summary>
QITIPF_LINKNOTARGET = 0x00000002,
/// <summary>If the item is a shortcut, retrieve the info tip text of the shortcut's target.</summary>
QITIPF_LINKUSETARGET = 0x00000004,
/// <summary>Search the entire namespace for the information. This value can result in a delayed response time.</summary>
QITIPF_USESLOWTIP = 0x00000008, // Flag says it's OK to take a long time generating tip
/// <summary><c>Windows Vista and later.</c> Put the info tip on a single line.</summary>
QITIPF_SINGLELINE = 0x00000010,
}
/// <summary><para>Indicates whether to enable or disable Async Register and Deregister for SHChangeNotifyRegisterThread.</para></summary>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/ne-shlobj_core-scnrt_status
// typedef enum SCNRT_STATUS { SCNRT_ENABLE , SCNRT_DISABLE } ;
[PInvokeData("shlobj_core.h", MSDNShortId = "31fd993b-d8cb-40cc-9f31-15711dba1b10")]
public enum SCNRT_STATUS
{
/// <summary>Enable Async Register and Deregister for SHChangeNotifyRegisterThread.</summary>
SCNRT_ENABLE,
/// <summary>Disable Async Register and Deregister for SHChangeNotifyRegisterThread.</summary>
SCNRT_DISABLE,
}
/// <summary>
/// Indicates the interpretation of the data passed by SHAddToRecentDocs in its pv parameter to identify the item whose usage statistics are being tracked.
/// </summary>
[PInvokeData("Shlobj.h", MSDNShortId = "dd378453")]
public enum SHARD
{
/// <summary>
/// <c>Windows 7 and later.</c> The pv parameter points to a SHARDAPPIDINFO structure that pairs an IShellItem that identifies the item with an
/// AppUserModelID that associates it with a particular process or application.
/// </summary>
SHARD_APPIDINFO = 4,
/// <summary>
/// <c>Windows 7 and later.</c> The pv parameter points to a SHARDAPPIDINFOIDLIST structure that pairs an absolute PIDL that identifies the item with
/// an AppUserModelID that associates it with a particular process or application.
/// </summary>
SHARD_APPIDINFOIDLIST = 5,
/// <summary>
/// <c>Windows 7 and later.</c> The pv parameter points to a SHARDAPPIDINFOLINK structure that pairs an IShellLink that identifies the item with an
/// AppUserModelID that associates it with a particular process or application.
/// </summary>
SHARD_APPIDINFOLINK = 7,
/// <summary><c>Windows 7 and later.</c> The pv parameter is an interface pointer to an IShellLink object.</summary>
SHARD_LINK = 6,
/// <summary>The pv parameter points to a null-terminated ANSI string with the path and file name of the object.</summary>
SHARD_PATHA = 2,
/// <summary>The pv parameter points to a null-terminated Unicode string with the path and file name of the object.</summary>
SHARD_PATHW = 3,
/// <summary>The pv parameter points to a PIDL that identifies the document's file object. PIDLs that identify non-file objects are not accepted.</summary>
SHARD_PIDL = 1,
/// <summary><c>Windows 7 and later.</c> The pv parameter is an interface pointer to an IShellItem object.</summary>
SHARD_SHELLITEM = 8
}
/// <summary>Events used in SHChangeNotify.</summary>
[PInvokeData("Shlobj_core.h")]
[Flags]
public enum SHCNE : uint
{
/// <summary>
/// The name of a nonfolder item has changed. SHCNF_IDLIST or SHCNF_PATH must be specified in uFlags. dwItem1 contains the
/// previous PIDL or name of the item. dwItem2 contains the new PIDL or name of the item.
/// </summary>
SHCNE_RENAMEITEM = 0x00000001,
/// <summary>
/// A nonfolder item has been created. SHCNF_IDLIST or SHCNF_PATH must be specified in uFlags. dwItem1 contains the item that was
/// created. dwItem2 is not used and should be NULL.
/// </summary>
SHCNE_CREATE = 0x00000002,
/// <summary>
/// A nonfolder item has been deleted. SHCNF_IDLIST or SHCNF_PATH must be specified in uFlags. dwItem1 contains the item that was
/// deleted. dwItem2 is not used and should be NULL.
/// </summary>
SHCNE_DELETE = 0x00000004,
/// <summary>
/// A folder has been created. SHCNF_IDLIST or SHCNF_PATH must be specified in uFlags. dwItem1 contains the folder that was
/// created. dwItem2 is not used and should be NULL.
/// </summary>
SHCNE_MKDIR = 0x00000008,
/// <summary>
/// A folder has been removed. SHCNF_IDLIST or SHCNF_PATH must be specified in uFlags. dwItem1 contains the folder that was
/// removed. dwItem2 is not used and should be NULL.
/// </summary>
SHCNE_RMDIR = 0x00000010,
/// <summary>
/// Storage media has been inserted into a drive. SHCNF_IDLIST or SHCNF_PATH must be specified in uFlags. dwItem1 contains the
/// root of the drive that contains the new media. dwItem2 is not used and should be NULL.
/// </summary>
SHCNE_MEDIAINSERTED = 0x00000020,
/// <summary>
/// Storage media has been removed from a drive. SHCNF_IDLIST or SHCNF_PATH must be specified in uFlags. dwItem1 contains the
/// root of the drive from which the media was removed. dwItem2 is not used and should be NULL.
/// </summary>
SHCNE_MEDIAREMOVED = 0x00000040,
/// <summary>
/// A drive has been removed. SHCNF_IDLIST or SHCNF_PATH must be specified in uFlags. dwItem1 contains the root of the drive that
/// was removed. dwItem2 is not used and should be NULL.
/// </summary>
SHCNE_DRIVEREMOVED = 0x00000080,
/// <summary>
/// A drive has been added. SHCNF_IDLIST or SHCNF_PATH must be specified in uFlags. dwItem1 contains the root of the drive that
/// was added. dwItem2 is not used and should be NULL.
/// </summary>
SHCNE_DRIVEADD = 0x00000100,
/// <summary>
/// A folder on the local computer is being shared via the network. SHCNF_IDLIST or SHCNF_PATH must be specified in uFlags.
/// dwItem1 contains the folder that is being shared. dwItem2 is not used and should be NULL.
/// </summary>
SHCNE_NETSHARE = 0x00000200,
/// <summary>
/// A folder on the local computer is no longer being shared via the network. SHCNF_IDLIST or SHCNF_PATH must be specified in
/// uFlags. dwItem1 contains the folder that is no longer being shared. dwItem2 is not used and should be NULL.
/// </summary>
SHCNE_NETUNSHARE = 0x00000400,
/// <summary>
/// The attributes of an item or folder have changed. SHCNF_IDLIST or SHCNF_PATH must be specified in uFlags. dwItem1 contains
/// the item or folder that has changed. dwItem2 is not used and should be NULL.
/// </summary>
SHCNE_ATTRIBUTES = 0x00000800,
/// <summary>
/// The contents of an existing folder have changed, but the folder still exists and has not been renamed. SHCNF_IDLIST or
/// SHCNF_PATH must be specified in uFlags. dwItem1 contains the folder that has changed. dwItem2 is not used and should be NULL.
/// If a folder has been created, deleted, or renamed, use SHCNE_MKDIR, SHCNE_RMDIR, or SHCNE_RENAMEFOLDER, respectively.
/// </summary>
SHCNE_UPDATEDIR = 0x00001000,
/// <summary>
/// An existing item (a folder or a nonfolder) has changed, but the item still exists and has not been renamed. SHCNF_IDLIST or
/// SHCNF_PATH must be specified in uFlags. dwItem1 contains the item that has changed. dwItem2 is not used and should be NULL.
/// If a nonfolder item has been created, deleted, or renamed, use SHCNE_CREATE, SHCNE_DELETE, or SHCNE_RENAMEITEM, respectively, instead.
/// </summary>
SHCNE_UPDATEITEM = 0x00002000,
/// <summary>
/// The computer has disconnected from a server. SHCNF_IDLIST or SHCNF_PATH must be specified in uFlags. dwItem1 contains the
/// server from which the computer was disconnected. dwItem2 is not used and should be NULL.
/// </summary>
SHCNE_SERVERDISCONNECT = 0x00004000,
/// <summary>
/// An image in the system image list has changed. SHCNF_DWORD must be specified in uFlags. dwItem2 contains the index in the
/// system image list that has changed. dwItem1 is not used and should be NULL.
/// </summary>
SHCNE_UPDATEIMAGE = 0x00008000,
/// <summary>
/// A drive has been added. SHCNF_IDLIST or SHCNF_PATH must be specified in uFlags. dwItem1 contains the root of the drive that
/// was added. dwItem2 is not used and should be NULL.
/// </summary>
SHCNE_DRIVEADDGUI = 0x00010000,
/// <summary>
/// The name of a folder has changed. SHCNF_IDLIST or SHCNF_PATH must be specified in uFlags. dwItem1 contains the previous PIDL
/// or name of the folder. dwItem2 contains the new PIDL or name of the folder.
/// </summary>
SHCNE_RENAMEFOLDER = 0x00020000,
/// <summary>
/// The amount of free space on a drive has changed. SHCNF_IDLIST or SHCNF_PATH must be specified in uFlags. dwItem1 contains the
/// root of the drive on which the free space changed. dwItem2 is not used and should be NULL.
/// </summary>
SHCNE_FREESPACE = 0x00040000,
/// <summary>Not currently used.</summary>
SHCNE_EXTENDED_EVENT = 0x04000000,
/// <summary>
/// A file type association has changed. SHCNF_IDLIST must be specified in the uFlags parameter. dwItem1 and dwItem2 are not used
/// and must be NULL. This event should also be sent for registered protocols.
/// </summary>
SHCNE_ASSOCCHANGED = 0x08000000,
/// <summary>All disk related events.</summary>
SHCNE_DISKEVENTS = 0x0002381F,
/// <summary>All global events.</summary>
SHCNE_GLOBALEVENTS = 0x0C0581E0,
/// <summary>All events.</summary>
SHCNE_ALLEVENTS = 0x7FFFFFFF,
/// <summary>
/// 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.
/// </summary>
SHCNE_INTERRUPT = 0x80000000,
}
/// <summary>Flags used in SHChangeNotify.</summary>
[PInvokeData("Shlobj_core.h")]
[Flags]
public enum SHCNF : uint
{
/// <summary>
/// dwItem1 and dwItem2 are the addresses of ITEMIDLIST structures that represent the item(s) affected by the change. Each
/// ITEMIDLIST must be relative to the desktop folder.
/// </summary>
SHCNF_IDLIST = 0x0000,
/// <summary>
/// dwItem1 and dwItem2 are the addresses of null-terminated strings of maximum length MAX_PATH that contain the full path names
/// of the items affected by the change.
/// </summary>
SHCNF_PATHA = 0x0001,
/// <summary>
/// dwItem1 and dwItem2 are the addresses of null-terminated strings that represent the friendly names of the printer(s) affected
/// by the change.
/// </summary>
SHCNF_PRINTERA = 0x0002,
/// <summary>The dwItem1 and dwItem2 parameters are DWORD values.</summary>
SHCNF_DWORD = 0x0003,
/// <summary>
/// dwItem1 and dwItem2 are the addresses of null-terminated strings of maximum length MAX_PATH that contain the full path names
/// of the items affected by the change.
/// </summary>
SHCNF_PATHW = 0x0005,
/// <summary>
/// dwItem1 and dwItem2 are the addresses of null-terminated strings that represent the friendly names of the printer(s) affected
/// by the change.
/// </summary>
SHCNF_PRINTERW = 0x0006,
/// <summary>Indicates that a type is defined.</summary>
SHCNF_TYPE = 0x00FF,
/// <summary>
/// The function should not return until the notification has been delivered to all affected components. As this flag modifies
/// other data-type flags, it cannot be used by itself.
/// </summary>
SHCNF_FLUSH = 0x1000,
/// <summary>
/// The function should begin delivering notifications to all affected components but should return as soon as the notification
/// process has begun. As this flag modifies other data-type flags, it cannot by used by itself. This flag includes SHCNF_FLUSH.
/// </summary>
SHCNF_FLUSHNOWAIT = 0x3000,
/// <summary>Notify clients registered for all children.</summary>
SHCNF_NOTIFYRECURSIVE = 0x10000
}
/// <summary>Receives a value that determines what type the item is in <see cref="SHDESCRIPTIONID"/>.</summary>
[PInvokeData("Shlobj_core.h", MSDNShortId = "bb759775")]
public enum SHDID
{
/// <summary>The item is a registered item on the desktop.</summary>
SHDID_ROOT_REGITEM = 1,
/// <summary>The item is a file.</summary>
SHDID_FS_FILE = 2,
/// <summary>The item is a folder.</summary>
SHDID_FS_DIRECTORY = 3,
/// <summary>The item is an unidentified item in the file system.</summary>
SHDID_FS_OTHER = 4,
/// <summary>The item is a 3.5-inch floppy drive.</summary>
SHDID_COMPUTER_DRIVE35 = 5,
/// <summary>The item is a 5.25-inch floppy drive.</summary>
SHDID_COMPUTER_DRIVE525 = 6,
/// <summary>The item is a removable disk.</summary>
SHDID_COMPUTER_REMOVABLE = 7,
/// <summary>The item is a fixed hard disk.</summary>
SHDID_COMPUTER_FIXED = 8,
/// <summary>The item is a drive that is mapped to a network share.</summary>
SHDID_COMPUTER_NETDRIVE = 9,
/// <summary>The item is a CD-ROM drive.</summary>
SHDID_COMPUTER_CDROM = 10,
/// <summary>The item is a RAM disk.</summary>
SHDID_COMPUTER_RAMDISK = 11,
/// <summary>The item is an unidentified system device.</summary>
SHDID_COMPUTER_OTHER = 12,
/// <summary>The item is a network domain.</summary>
SHDID_NET_DOMAIN = 13,
/// <summary>The item is a network server.</summary>
SHDID_NET_SERVER = 14,
/// <summary>The item is a network share.</summary>
SHDID_NET_SHARE = 15,
/// <summary>Not currently used.</summary>
SHDID_NET_RESTOFNET = 16,
/// <summary>The item is an unidentified network resource.</summary>
SHDID_NET_OTHER = 17,
/// <summary>Windows XP and later. Not currently used.</summary>
SHDID_COMPUTER_IMAGING = 18,
/// <summary>Windows XP and later. Not currently used.</summary>
SHDID_COMPUTER_AUDIO = 19,
/// <summary>Windows XP and later. The item is the system shared documents folder.</summary>
SHDID_COMPUTER_SHAREDDOCS = 20,
/// <summary>Windows Vista and later. The item is a mobile device, such as a personal digital assistant (PDA).</summary>
SHDID_MOBILE_DEVICE = 21,
}
/// <summary>The format in which the data is being requested.</summary>
[PInvokeData("Shlobj.h", MSDNShortId = "bb762174")]
public enum SHGetDataFormat
{
/// <summary>Format used for file system objects. The pv parameter is the address of a WIN32_FIND_DATA structure.</summary>
[CorrespondingType(typeof(WIN32_FIND_DATA), CorrepsondingAction.Get)]
SHGDFIL_FINDDATA = 1,
/// <summary>Format used for network resources. The pv parameter is the address of a NETRESOURCE structure.</summary>
// TODO: Define NETRESOURCE (https://msdn.microsoft.com/en-us/library/windows/desktop/aa385353(v=vs.85).aspx)
//[CorrespondingType(typeof(NETRESOURCE), CorrepsondingAction.Get)]
SHGDFIL_NETRESOURCE = 2,
/// <summary>Version 4.71. Format used for network resources. The pv parameter is the address of an SHDESCRIPTIONID structure.</summary>
[CorrespondingType(typeof(SHDESCRIPTIONID), CorrepsondingAction.Get)]
SHGDFIL_DESCRIPTIONID = 3
}
/// <summary>Flags used by <see cref="SHGetFolderPath"/>.</summary>
[PInvokeData("Shlobj.h", MSDNShortId = "bb762181")]
public enum SHGFP
{
/// <summary>Retrieve the folder's current path.</summary>
SHGFP_TYPE_CURRENT = 0,
/// <summary>Retrieve the folder's default path.</summary>
SHGFP_TYPE_DEFAULT = 1
}
/// <summary>Used by SHGetImageList.</summary>
[PInvokeData("Shlobj.h", MSDNShortId = "bb762185")]
public enum SHIL
{
/// <summary>
/// The image size is normally 32x32 pixels. However, if the Use large icons option is selected from the Effects section of the Appearance tab in
/// Display Properties, the image is 48x48 pixels.
/// </summary>
SHIL_LARGE = 0,
/// <summary>These images are the Shell standard small icon size of 16x16, but the size can be customized by the user.</summary>
SHIL_SMALL = 1,
/// <summary>These images are the Shell standard extra-large icon size. This is typically 48x48, but the size can be customized by the user.</summary>
SHIL_EXTRALARGE = 2,
/// <summary>These images are the size specified by GetSystemMetrics called with SM_CXSMICON and GetSystemMetrics called with SM_CYSMICON.</summary>
SHIL_SYSSMALL = 3,
/// <summary>Windows Vista and later. The image is normally 256x256 pixels.</summary>
SHIL_JUMBO = 4,
}
/// <summary>
/// CSIDL (constant special item ID list) values provide a unique system-independent way to identify special folders used frequently by applications, but
/// which may not have the same name or location on any given system. For example, the system folder may be "C:\Windows" on one system and "C:\Winnt" on
/// another. These constants are defined in Shlobj.h.
/// </summary>
[PInvokeData("Shlobj.h", MSDNShortId = "bb762494")]
internal enum CSIDL
{
CSIDL_ADMINTOOLS = 0x0030,
CSIDL_CDBURN_AREA = 0x003b,
CSIDL_COMMON_ADMINTOOLS = 0x002f,
CSIDL_COMMON_DESKTOPDIRECTORY = 0x0019,
CSIDL_COMMON_DOCUMENTS = 0x002e,
CSIDL_COMMON_MUSIC = 0x0035,
CSIDL_COMMON_OEM_LINKS = 0x003a,
CSIDL_COMMON_PICTURES = 0x0036,
CSIDL_COMMON_PROGRAMS = 0X0017,
CSIDL_COMMON_STARTMENU = 0x0016,
CSIDL_COMMON_STARTUP = 0x0018,
CSIDL_COMMON_TEMPLATES = 0x002d,
CSIDL_COMMON_VIDEO = 0x0037,
CSIDL_FLAG_CREATE = 0x8000, // force folder creation in SHGetFolderPath
CSIDL_FLAG_DONT_VERIFY = 0x4000, // return an unverified folder path
CSIDL_FONTS = 0x0014, // windows\fonts
CSIDL_MYVIDEO = 0x000e, // "My Videos" folder
CSIDL_NETHOOD = 0x0013, // %APPDATA%\Microsoft\Windows\Network Shortcuts
CSIDL_PRINTHOOD = 0x001b, // %APPDATA%\Microsoft\Windows\Printer Shortcuts
CSIDL_PROFILE = 0x0028, // %USERPROFILE% (%SystemDrive%\Users\%USERNAME%)
CSIDL_PROGRAM_FILES_COMMONX86 = 0x002c, // x86 Program Files\Common on RISC
CSIDL_PROGRAM_FILESX86 = 0x002a, // x86 C:\Program Files on RISC
CSIDL_RESOURCES = 0x0038, // %windir%\Resources
CSIDL_RESOURCES_LOCALIZED = 0x0039, // %windir%\resources\0409 (code page)
CSIDL_SYSTEMX86 = 0x0029, // %windir%\system32
CSIDL_WINDOWS = 0x0024, // GetWindowsDirectory()
}
/// <summary>
/// <para>Retrieves the value for a given property key using the file association information provided by the Namespace Extensions.</para>
/// </summary>
/// <param name="psf">
/// <para>Type: <c>IShellFolder*</c></para>
/// <para>A pointer to the shell folder for which the details of the property key of the file association are being retrieved.</para>
/// </param>
/// <param name="pidl">
/// <para>Type: <c>PCUITEMID_CHILD</c></para>
/// <para>The PIDL of the child item for which the file associations are being requested.</para>
/// </param>
/// <param name="pkey">
/// <para>Type: <c>PROPERTYKEY*</c></para>
/// <para>A pointer to the property key that is being retrieved.</para>
/// </param>
/// <param name="pv">
/// <para>Type: <c>VARIANT*</c></para>
/// <para>When this function returns, contains the details of the given property key.</para>
/// </param>
/// <param name="pfFoundPropKey">
/// <para>Type: <c>BOOL*</c></para>
/// <para>When this function returns, contains a flag that is <c>TRUE</c> if the property key was found, otherwise <c>FALSE</c>.</para>
/// </param>
/// <returns>
/// <para>Type: <c>HRESULT</c></para>
/// <para>If this function succeeds, it returns <c>S_OK</c>. Otherwise, it returns an <c>HRESULT</c> error code.</para>
/// </returns>
/// <remarks>
/// <para>
/// This function is to be used only by implementers of IShellFolder Namespace Extensions. Other calling applications should use
/// IShellFolder2::GetDetailsEx to get a value for a PROPERTYKEY. This function is to be used by implementers of <c>IShellFolder</c>
/// Namespace Extensions.
/// </para>
/// <para>The provided namespace extension must support the use of this API in one of the following three ways.</para>
/// <list type="number">
/// <item>
/// If the provided Namespace Extensions supports retrieving an IQueryAssociations interface for the item by implementing
/// IShellFolder::GetUIObjectOf(..., <c>IID_IQueryAssociations</c>, ...), then <c>AssocGetDetailsOfPropKey</c> will use the provided
/// file associations API to retrieve the value for the property key.
/// </item>
/// <item>
/// If the provided namespace extension returns <c>SFGAO_FILESYSTEM</c> for the item from IShellFolder::GetAttributesOf and provides
/// a parsing name for the item, then <c>AssocGetDetailsOfPropKey</c> will use the standard file system associations to retrieve the
/// value for the property key.
/// </item>
/// <item>
/// If the provided namespace extension returns <c>SFGAO_FOLDER</c> | <c>SFGAO_BROWSABLE</c> for the item from
/// IShellFolder::GetAttributesOf, then <c>AssocGetDetailsOfPropKey</c> will use the file association for folders (
/// <c>ASSOCCLASS_FOLDER</c>) to retrieve the value for the property key.
/// </item>
/// </list>
/// <para>
/// If the ShellFolder being implemented contains items that are extensible through the file associations mechanism, then you can use
/// this function to retrieve
/// </para>
/// <para>PropertyKeys</para>
/// <para>
/// that are declared for a given file association. For example, if a given Shell folder drives a details pane and you want the
/// properties displayed in that pane to be governed by third party file name extensions, then you can use this function to return
/// </para>
/// <para>PKEY_PropList_PreviewDetails</para>
/// <para>
/// . This key has a value that is declared in the registry for that file name extension with a semicolon delimited list of
/// properties. There is a list of file name extension defined properties in the registry. This list includes but is not limited to
/// the following:
/// </para>
/// <list type="bullet">
/// <item><c>PKEY_PropList_PreviewDetails</c></item>
/// <item><c>PKEY_PropList_PreviewTitle</c></item>
/// <item><c>PKEY_PropList_FullDetails</c></item>
/// <item><c>PKEY_PropList_TileInfo</c></item>
/// <item><c>PKEY_PropList_ExtendedTileInfo</c></item>
/// <item><c>PKEY_PropList_InfoTip</c></item>
/// <item><c>PKEY_PropList_QuickTip</c></item>
/// <item><c>PKEY_PropList_FileOperationPrompt</c></item>
/// <item><c>PKEY_PropList_ConflictPrompt</c></item>
/// <item><c>PKEY_PropList_SetDefaultsFor</c></item>
/// <item><c>PKEY_PropList_NonPersonal</c></item>
/// <item><c>PKEY_NewMenuPreferredTypes</c></item>
/// <item><c>PKEY_NewMenuAllowedTypes</c></item>
/// </list>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-assocgetdetailsofpropkey
// SHSTDAPI AssocGetDetailsOfPropKey( IShellFolder *psf, PCUITEMID_CHILD pidl, const PROPERTYKEY *pkey, VARIANT *pv, BOOL *pfFoundPropKey );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "f13af5f4-1b6a-419c-a042-e05c9ec51d02")]
public static extern HRESULT AssocGetDetailsOfPropKey(IShellFolder psf, PIDL pidl, ref PROPERTYKEY pkey, ref object pv, [MarshalAs(UnmanagedType.Bool)] ref bool pfFoundPropKey);
/// <summary><para>[This function is available through Windows XP Service Pack 2 (SP2) and Windows Server 2003. It might be altered or unavailable in subsequent versions of Windows.]</para><para>Creates an <c>Open</c> dialog box so that the user can specify the drive, directory, and name of a file to open.</para></summary><param name="hwnd"><para>Type: <c>HWND</c></para><para>A handle to the window that owns the dialog box. This member can be any valid window handle, or it can be <c>NULL</c> if the dialog box has no owner.</para></param><param name="pszFilePath"><para>Type: <c>PWSTR</c></para><para>A null-terminated Unicode string that contains a file name used to initialize the File Name edit control. This string corresponds to the OPENFILENAME structure&#39;s <c>lpstrFile</c> member and is used in exactly the same way.</para></param><param name="cchFilePath"><para>Type: <c>UINT</c></para><para>The number of characters in , including the terminating null character.</para></param><param name="pszWorkingDir"><para>Type: <c>PCWSTR</c></para><para>The fully qualified file path of the initial directory. This string corresponds to the OPENFILENAME structure&#39;s <c>lpstrInitialDir</c> member and is used in exactly the same way.</para></param><param name="pszDefExt"><para>Type: <c>PCWSTR</c></para><para>A null-terminated Unicode string that contains the default file name extension. This extension is added to if the user does not specify an extension. The string should not contain any &#39;.&#39; characters. If this string is <c>NULL</c> and the user fails to type an extension, no extension is appended.</para></param><param name="pszFilters"><para>Type: <c>PCWSTR</c></para><para>A null-terminated Unicode string that defines the filter. This string corresponds to the OPENFILENAME structure&#39;s <c>lpstrFilter</c> member and is used in exactly the same way.</para></param><param name="pszTitle"><para>TBD</para></param><returns><para>Type: <c>BOOL</c></para><para>If the user specifies a file name and clicks <c>OK</c>, the return value is <c>TRUE</c>. The buffer that points to contains the full path and file name that the user specifies. If the user cancels or closes the <c>Open</c> dialog box or an error occurs, the return value is <c>FALSE</c>.</para></returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj/nf-shlobj-getfilenamefrombrowse
// BOOL GetFileNameFromBrowse( HWND hwnd, PWSTR pszFilePath, UINT cchFilePath, PCWSTR pszWorkingDir, PCWSTR pszDefExt, PCWSTR pszFilters, PCWSTR pszTitle );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj.h", MSDNShortId = "1f075051-18c8-4ec2-b010-f983ba2d3303")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool GetFileNameFromBrowse(HandleRef hwnd, [MarshalAs(UnmanagedType.LPWStr)] string pszFilePath, uint cchFilePath, [MarshalAs(UnmanagedType.LPWStr)] string pszWorkingDir, [MarshalAs(UnmanagedType.LPWStr)] string pszDefExt, [MarshalAs(UnmanagedType.LPWStr)] string pszFilters, [MarshalAs(UnmanagedType.LPWStr)] string pszTitle);
/// <summary>
/// <para>Appends or prepends an SHITEMID structure to an ITEMIDLIST structure.</para>
/// </summary>
/// <param name="pidl">
/// <para>Type: <c>PIDLIST_RELATIVE</c></para>
/// <para>A pointer to an ITEMIDLIST structure. When the function returns, the SHITEMID structure specified by is appended or prepended.</para>
/// </param>
/// <param name="pmkid">
/// <para>Type: <c>LPSHITEMID</c></para>
/// <para>A pointer to a SHITEMID structure to be appended or prepended to .</para>
/// </param>
/// <param name="fAppend">
/// <para>Type: <c>BOOL</c></para>
/// <para>Value that is set to <c>TRUE</c> to append to . Set this value to <c>FALSE</c> to prepend to .</para>
/// </param>
/// <returns>
/// <para>Type: <c>PIDLIST_RELATIVE</c></para>
/// <para>Returns the ITEMIDLIST structure specified by , with appended or prepended. Returns <c>NULL</c> on failure.</para>
/// </returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-ilappendid
// PIDLIST_RELATIVE ILAppendID( PIDLIST_RELATIVE pidl, LPCSHITEMID pmkid, BOOL fAppend );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "d1bb5993-fe23-42d4-a2c5-8e54e6e37d09")]
public static extern IntPtr ILAppendID(IntPtr pidl, ref SHITEMID pmkid, [MarshalAs(UnmanagedType.Bool)] bool fAppend);
/// <summary><para>Determines whether a specified ITEMIDLIST structure is the child of another <c>ITEMIDLIST</c> structure.</para></summary><param name="pidlParent"><para>Type: <c>PCIDLIST_ABSOLUTE</c></para><para>A pointer to the parent ITEMIDLIST structure.</para></param><param name="pidlChild"><para>Type: <c>PCIDLIST_ABSOLUTE</c></para><para>A pointer to the child ITEMIDLIST structure.</para></param><returns><para>Type: <c>PUIDLIST_RELATIVE</c></para><para>Returns a pointer to the child&#39;s simple ITEMIDLIST structure if is a child of . The returned structure consists of , minus the SHITEMID structures that make up . Returns <c>NULL</c> if is not a child of .</para><para><c>Note</c> The returned pointer is a pointer into the existing parent structure. It is an alias for . No new memory is allocated in association with the returned pointer. It is not the caller&#39;s responsibility to free the returned value.</para></returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-ilfindchild
// PUIDLIST_RELATIVE ILFindChild( PIDLIST_ABSOLUTE pidlParent, PCIDLIST_ABSOLUTE pidlChild );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "4f07e989-ae74-4cf4-b3d9-0f59f2653095")]
public static extern IntPtr ILFindChild(IntPtr pidlParent, IntPtr pidlChild);
/// <summary>
/// <para>[</para>
/// <para>ILLoadFromStreamEx(IStream*, PIDLIST_ABSOLUTE*)</para>
/// <para>
/// is available for use in the operating systems specified in the Requirements section. It may be altered or unavailable in
/// subsequent versions.]
/// </para>
/// <para>Loads an absolute ITEMIDLIST from an IStream.</para>
/// </summary>
/// <param name="pstm">
/// <para>Type: <c>IStream*</c></para>
/// <para>A pointer to the IStream interface from which the absolute ITEMIDLIST loads.</para>
/// </param>
/// <param name="pidl">
/// <para>TBD</para>
/// </param>
/// <returns>
/// <para>Type: <c>HRESULT</c></para>
/// <para>If this function succeeds, it returns <c>S_OK</c>. Otherwise, it returns an <c>HRESULT</c> error code.</para>
/// </returns>
/// <remarks>
/// <para>For use where STRICT_TYPED_ITEMIDS is defined.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-illoadfromstreamex
// SHSTDAPI ILLoadFromStreamEx( IStream *pstm, PIDLIST_RELATIVE *pidl );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "6fb735b6-a8c3-439e-9f20-4fda8f008b28")]
public static extern HRESULT ILLoadFromStreamEx(IStream pstm, out IntPtr pidl);
/// <summary>
/// <para>Saves an ITEMIDLIST structure to a stream.</para>
/// </summary>
/// <param name="pstm">
/// <para>Type: <c>IStream *</c></para>
/// <para>A pointer to the IStream interface where the ITEMIDLIST is saved.</para>
/// </param>
/// <param name="pidl">
/// <para>Type: <c>PCUIDLIST_RELATIVE</c></para>
/// <para>A pointer to the ITEMIDLIST structure to be saved.</para>
/// </param>
/// <returns>
/// <para>Type: <c>HRESULT</c></para>
/// <para>Returns S_OK if successful, or a COM error value otherwise.</para>
/// </returns>
/// <remarks>
/// <para>The stream must be opened for writing, or <c>ILSaveToStream</c> returns an error.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-ilsavetostream
// SHSTDAPI ILSaveToStream( IStream *pstm, PCUIDLIST_RELATIVE pidl );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "40d5ce57-58dc-4c79-8fe6-5412e3d7dc64")]
public static extern HRESULT ILSaveToStream(IStream pstm, IntPtr pidl);
/// <summary>
/// <para>
/// [This function is available through Windows XP Service Pack 2 (SP2) and Windows Server 2003. It might be altered or unavailable
/// in subsequent versions of Windows. Use
/// </para>
/// <para>GetDriveType</para>
/// <para>or</para>
/// <para>WNetGetConnection</para>
/// <para>instead.]</para>
/// <para>Tests whether a drive is a network drive.</para>
/// </summary>
/// <param name="iDrive">
/// <para>Type: <c>int</c></para>
/// <para>An integer that indicates which drive letter you want to test. Set it to 0 for A:, 1 for B:, and so on.</para>
/// </param>
/// <returns>
/// <para>Type: <c>int</c></para>
/// <para>This function returns one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return value</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>0</term>
/// <term>The specified drive is not a network drive.</term>
/// </item>
/// <item>
/// <term>1</term>
/// <term>The specified drive is a network drive that is properly connected.</term>
/// </item>
/// <item>
/// <term>2</term>
/// <term>The specified drive is a network drive that is disconnected or in an error state.</term>
/// </item>
/// </list>
/// </returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-isnetdrive
// int IsNetDrive( int iDrive );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "44e02665-648a-4cf0-9dc0-038e54d08a49")]
public static extern int IsNetDrive(int iDrive);
/// <summary>
/// <para>[IsUserAnAdmin is available for use in the operating systems specified in the Requirements section. It may be altered or unavailable in
/// subsequent versions.]
/// </para>
/// <para>Tests whether the current user is a member of the Administrator's group.</para>
/// </summary>
/// <returns>
/// <para>Type: <c>BOOL</c></para>
/// <para>Returns <c>TRUE</c> if the user is a member of the Administrator's group; otherwise, <c>FALSE</c>.</para>
/// </returns>
/// <remarks>
/// <para>
/// This function is a wrapper for CheckTokenMembership. It is recommended to call that function directly to determine Administrator
/// group status rather than calling <c>IsUserAnAdmin</c>.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-isuseranadmin
// BOOL IsUserAnAdmin( );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "fe698d32-32f6-4b2b-ad0c-5d9ec815177f")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool IsUserAnAdmin();
/// <summary>
/// <para>
/// [OpenRegStream is available for use in the operating systems specified in the Requirements section. It may be altered or
/// unavailable in subsequent versions. Instead, use SHOpenRegStream2 or SHOpenRegStream.]
/// </para>
/// <para>Opens a registry value and supplies an IStream interface that can be used to read from or write to the value.</para>
/// </summary>
/// <param name="hkey">
/// <para>Type: <c>HKEY</c></para>
/// <para>A handle to the key that is currently open.</para>
/// </param>
/// <param name="pszSubkey">
/// <para>Type: <c>PCWSTR</c></para>
/// <para>A null-terminated Unicode string that specifies the name of the subkey.</para>
/// </param>
/// <param name="pszValue">
/// <para>Type: <c>PCWSTR</c></para>
/// <para>A null-terminated Unicode string that specifies the value to be accessed.</para>
/// </param>
/// <param name="grfMode">
/// <para>Type: <c>DWORD</c></para>
/// <para>The type of access for the stream. This can be one of the following values.</para>
/// <para>STGM_READ</para>
/// <para>Open the stream for reading.</para>
/// <para>STGM_WRITE</para>
/// <para>Open the stream for writing.</para>
/// <para>STGM_READWRITE</para>
/// <para>Open the stream for reading and writing.</para>
/// </param>
/// <returns>
/// <para>Type: <c>IStream*</c></para>
/// <para>Returns the address of an IStream interface if successful, or <c>NULL</c> otherwise.</para>
/// </returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-openregstream
// IStream * OpenRegStream( HKEY hkey, PCWSTR pszSubkey, PCWSTR pszValue, DWORD grfMode );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "e1e35c94-84ac-4aa1-b2a1-47b37a7f224e")]
public static extern IStream OpenRegStream(IntPtr hkey, [MarshalAs(UnmanagedType.LPWStr)] string pszSubkey, [MarshalAs(UnmanagedType.LPWStr)] string pszValue, STGM grfMode);
/// <summary>
/// <para>[PathCleanupSpec is available for use in the operating systems specified in the Requirements section. It may be altered or unavailable in
/// subsequent versions.]
/// </para>
/// <para>
/// Removes illegal characters from a file or directory name. Enforces the 8.3 filename format on drives that do not support long
/// file names.
/// </para>
/// </summary>
/// <param name="pszDir">
/// <para>Type: <c>PCWSTR</c></para>
/// <para>
/// A pointer to a null-terminated buffer that contains the fully qualified path of the directory that will contain the file or
/// directory named at . The path must not exceed MAX_PATH characters in length, including the terminating null character. This path
/// is not altered.
/// </para>
/// <para>This value can be <c>NULL</c>.</para>
/// </param>
/// <param name="pszSpec">
/// <para>Type: <c>PWSTR</c></para>
/// <para>
/// A pointer to a null-terminated buffer that contains the file or directory name to be cleaned. In the case of a file, include the
/// file's extension. Note that because '' is considered an invalid character and will be removed, this buffer cannot contain a path
/// more than one directory deep.
/// </para>
/// <para>On exit, the buffer contains a null-terminated string that includes the cleaned name.</para>
/// <para>This buffer should be at least MAX_PATH characters in length to avoid the possibility of a buffer overrun.</para>
/// </param>
/// <returns>
/// <para>Type: <c>int</c></para>
/// <para>Returns one or more of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PCS_REPLACEDCHAR</term>
/// <term>Replaced one or more invalid characters.</term>
/// </item>
/// <item>
/// <term>PCS_REMOVEDCHAR</term>
/// <term>Removed one or more invalid characters.</term>
/// </item>
/// <item>
/// <term>PCS_TRUNCATED</term>
/// <term>The returned path is truncated.</term>
/// </item>
/// <item>
/// <term>PCS_PATHTOOLONG</term>
/// <term>
/// The function failed because the input path specified at is too long to allow the formation of a valid file name from . When this
/// flag is returned, it is always accompanied by the PCS_FATAL flag.
/// </term>
/// </item>
/// <item>
/// <term>PCS_FATAL</term>
/// <term>The cleaned path is not a valid file name. This flag is always returned in conjunction with PCS_PATHTOOLONG.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>The following are considered invalid characters in all names.</para>
/// <para>
/// Control characters are also considered invalid. If long file names are not supported, the semi-colon (;) and comma (,) characters
/// are also invalid.
/// </para>
/// <para>
/// The drive named in is checked to determine whether its file system supports long file names. If it does not, the name at is
/// truncated to the 8.3 format and the PCS_TRUNCATED value returned. If is <c>NULL</c>, the drive on which Windows is installed is
/// used to determine long file name support.
/// </para>
/// <para>
/// If the full path—the number of characters in the path at plus the number of characters in the cleaned name at —exceeds MAX_PATH –
/// 1 (to account for the terminating null character), the function returns PCS_PATHTOOLONG.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-pathcleanupspec
// int PathCleanupSpec( PCWSTR pszDir, PWSTR pszSpec );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "593fd2b7-44ae-4309-a185-97e42f3cc0fa")]
public static extern PCS PathCleanupSpec([MarshalAs(UnmanagedType.LPWStr)] string pszDir, [MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszSpec);
/// <summary>
/// <para>[PathGetShortPath is available for use in the operating systems specified in the Requirements section. It may be altered or unavailable in
/// subsequent versions.]
/// </para>
/// <para>Retrieves the short path form of a specified input path.</para>
/// </summary>
/// <param name="pszLongPath">
/// <para>Type: <c>PWSTR</c></para>
/// <para>
/// A pointer to a null-terminated, Unicode string that contains the long path. When the function returns, it contains the equivalent
/// short path.
/// </para>
/// </param>
/// <returns>
/// <para>This function does not return a value.</para>
/// </returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-pathgetshortpath
// void PathGetShortPath( PWSTR pszLongPath );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "f374a575-3fbf-4bed-aa76-76ed81e01d60")]
public static extern void PathGetShortPath([MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszLongPath);
/// <summary>
/// <para>
/// [PathIsExe is available for use in the operating systems specified in the Requirements section. It may be altered or unavailable
/// in subsequent versions.]
/// </para>
/// <para>Determines whether a file is an executable by examining the file name extension.</para>
/// </summary>
/// <param name="pszPath">
/// <para>TBD</para>
/// </param>
/// <returns>
/// <para>Type: <c>BOOL</c></para>
/// <para>Returns <c>TRUE</c> if the file name extension is .cmd, .bat, .pif, .scf, .exe, .com, or .scr; otherwise, <c>FALSE</c>.</para>
/// </returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-pathisexe
// BOOL PathIsExe( PCWSTR pszPath );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "54e9dae7-f9c4-48b8-9b91-32ed21365fb7")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool PathIsExe([MarshalAs(UnmanagedType.LPWStr)] string pszPath);
/// <summary>
/// <para>
/// [PathIsSlow is available for use in the operating systems specified in the Requirements section. It may be altered or unavailable
/// in subsequent versions.]
/// </para>
/// <para>Determines whether a file path is a high-latency network connection.</para>
/// </summary>
/// <param name="pszFile">
/// <para>Type: <c>LPCTSTR</c></para>
/// <para>A pointer to a null-terminated string that contains the fully qualified path of the file.</para>
/// </param>
/// <param name="dwAttr">
/// <para>TBD</para>
/// </param>
/// <returns>
/// <para>Type: <c>BOOL</c></para>
/// <para>Returns <c>TRUE</c> if the connection is high-latency; otherwise, <c>FALSE</c>.</para>
/// </returns>
/// <remarks>
/// <para>
/// A path is considered slow if the MultinetGetConnectionPerformance function returns a dwSpeed of 400 or less in its
/// NETCONNECTINFOSTRUCT structure—this is the speed of the media to the network resource, in 100 bits-per-second (bps)—or if
/// FILE_ATTRIBUTE_OFFLINE is set on the file.
/// </para>
/// <para>Note that network conditions can impact function performance time.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj/nf-shlobj-pathisslowa
// BOOL PathIsSlowA( LPCSTR pszFile, DWORD dwAttr );
[DllImport(Lib.Shell32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("shlobj.h", MSDNShortId = "f848a098-9248-453b-a957-77c35d70e528")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool PathIsSlow(string pszFile, uint dwAttr);
/// <summary>
/// <para>Creates a unique path name from a template.</para>
/// </summary>
/// <param name="pszUniqueName">
/// <para>Type: <c>PWSTR</c></para>
/// <para>
/// A buffer that receives a null-terminated Unicode string that contains the unique path name. It should be at least MAX_PATH
/// characters in length.
/// </para>
/// </param>
/// <param name="cchMax">
/// <para>Type: <c>UINT</c></para>
/// <para>The number of characters in the buffer pointed to by .</para>
/// </param>
/// <param name="pszTemplate">
/// <para>Type: <c>PCWSTR</c></para>
/// <para>
/// A null-terminated Unicode string that contains a template that is used to construct the unique name. This template is used for
/// drives that require file names with the 8.3 format. This string should be no more than MAX_PATH characters in length, including
/// the terminating null character.
/// </para>
/// </param>
/// <param name="pszLongPlate">
/// <para>Type: <c>PCWSTR</c></para>
/// <para>
/// A null-terminated Unicode string that contains a template that is used to construct the unique name. This template is used for
/// drives that support long file names. This string should be no more than MAX_PATH characters in length, including the terminating
/// null character.
/// </para>
/// </param>
/// <param name="pszDir">
/// <para>Type: <c>PCWSTR</c></para>
/// <para>
/// A null-terminated string that contains the directory in which the new file resides. This string should be no more than MAX_PATH
/// characters in length, including the terminating null character.
/// </para>
/// </param>
/// <returns>
/// <para>Type: <c>BOOL</c></para>
/// <para>Returns <c>TRUE</c> if successful; otherwise, <c>FALSE</c>.</para>
/// </returns>
/// <remarks>
/// <para>
/// This function generates a new unique file name based on the templates specified by , for drives that require the 8.3 format, and
/// for drives that support long file names. For example, if you specify "My New Filename" for , <c>PathMakeUniqueName</c> returns
/// names such as "My New Filename (1)", "My New Filename (2)", and so on.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-pathmakeuniquename
// BOOL PathMakeUniqueName( PWSTR pszUniqueName, UINT cchMax, PCWSTR pszTemplate, PCWSTR pszLongPlate, PCWSTR pszDir );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "8456ae0c-e83c-43d0-a86a-1861a373d237")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool PathMakeUniqueName([MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszUniqueName, uint cchMax, [MarshalAs(UnmanagedType.LPWStr)] string pszTemplate, [MarshalAs(UnmanagedType.LPWStr)] string pszLongPlate, [MarshalAs(UnmanagedType.LPWStr)] string pszDir);
/// <summary>
/// <para>
/// [PathResolve is available for use in the operating systems specified in the Requirements section. It may be altered or
/// unavailable in subsequent versions.]
/// </para>
/// <para>Converts a relative or unqualified path name to a fully qualified path name.</para>
/// </summary>
/// <param name="pszPath">
/// <para>Type: <c>PWSTR</c></para>
/// <para>
/// A null-terminated Unicode string that contains the path to resolve. When the function returns, the string contains the
/// corresponding fully qualified path. This buffer should be at least MAX_PATH characters long.
/// </para>
/// </param>
/// <param name="dirs">
/// <para>Type: <c>PZPCWSTR</c></para>
/// <para>
/// A pointer to an optional null-terminated array of directories to be searched first in the case that the path cannot be resolved
/// from . This value can be <c>NULL</c>.
/// </para>
/// </param>
/// <param name="fFlags">
/// <para>Type: <c>UINT</c></para>
/// <para>Flags that specify how the function operates.</para>
/// <para>PRF_VERIFYEXISTS</para>
/// <para>Return <c>TRUE</c> if the file's existence is verified; otherwise <c>FALSE</c>.</para>
/// <para>PRF_TRYPROGRAMEXTENSIONS</para>
/// <para>Look for the specified path with the following extensions appended: .pif, .com, .bat, .cmd, .lnk, and .exe.</para>
/// <para>PRF_FIRSTDIRDEF</para>
/// <para>Look first in the directory or directories specified by .</para>
/// <para>PRF_DONTFINDLNK</para>
/// <para>Ignore .lnk files.</para>
/// <para>PRF_REQUIREABSOLUTE</para>
/// <para>Require an absolute (full) path.</para>
/// </param>
/// <returns>
/// <para>Type: <c>int</c></para>
/// <para>
/// Returns <c>TRUE</c>, unless PRF_VERIFYEXISTS is set. If that flag is set, the function returns <c>TRUE</c> if the file is
/// verified to exist and <c>FALSE</c> otherwise. It also sets an ERROR_FILE_NOT_FOUND error code that you can retrieve by calling GetLastError.
/// </para>
/// </returns>
/// <remarks>
/// <para>
/// A <c>FALSE</c> return value does not necessarily mean that the file does not exist. It might mean that the function is simply
/// unable to find the file from the supplied information.
/// </para>
/// <para>If <c>PathResolve</c> cannot resolve the path specified in , it calls PathFindOnPath using and as the parameters.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-pathresolve
// int PathResolve( PWSTR pszPath, PZPCWSTR dirs, UINT fFlags );
[DllImport(Lib.Shell32, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
[PInvokeData("shlobj_core.h", MSDNShortId = "84bf0b56-513f-4ac6-b2cf-11f0c471da1e")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool PathResolve(StringBuilder pszPath, string[] dirs, PRF fFlags);
/// <summary>
/// <para>Creates a unique filename based on an existing filename.</para>
/// </summary>
/// <param name="pszUniqueName">
/// <para>Type: <c>PWSTR</c></para>
/// <para>
/// A string buffer that receives a null-terminated Unicode string that contains the fully qualified path of the unique file name.
/// This buffer should be at least MAX_PATH characters long to avoid causing a buffer overrun.
/// </para>
/// </param>
/// <param name="pszPath">
/// <para>Type: <c>PCWSTR</c></para>
/// <para>
/// A null-terminated Unicode string that contains the fully qualified path of folder that will contain the new file. If is set to
/// <c>NULL</c>, this string must contain a full destination path, ending with the long file name that the new file name will be base on.
/// </para>
/// </param>
/// <param name="pszShort">
/// <para>Type: <c>PCWSTR</c></para>
/// <para>
/// A null-terminated Unicode string that contains the short file name that the unique name will be based on. Set this value to
/// <c>NULL</c> to create a name based on the long file name.
/// </para>
/// </param>
/// <param name="pszFileSpec">
/// <para>Type: <c>PCWSTR</c></para>
/// <para>A null-terminated Unicode string that contains the long file name that the unique name will be based on.</para>
/// </param>
/// <returns>
/// <para>Type: <c>BOOL</c></para>
/// <para>Returns <c>TRUE</c> if a unique name was successfully created; otherwise <c>FALSE</c>.</para>
/// </returns>
/// <remarks>
/// <para>
/// If the generated path exceeds MAX_PATH characters, this function may return a truncated string in
/// <c>PathYetAnotherMakeUniqueName</c>. In that case, the function returns <c>FALSE</c>.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-pathyetanothermakeuniquename
// BOOL PathYetAnotherMakeUniqueName( PWSTR pszUniqueName, PCWSTR pszPath, PCWSTR pszShort, PCWSTR pszFileSpec );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true, CharSet = CharSet.Unicode)]
[PInvokeData("shlobj_core.h", MSDNShortId = "1f76ecfa-6f2f-4dde-b05e-4252c92660d9")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool PathYetAnotherMakeUniqueName(StringBuilder pszUniqueName, string pszPath, string pszShort, string pszFileSpec);
/// <summary>
/// <para>
/// [PickIconDlg is available for use in the operating systems specified in the Requirements section. It may be altered or
/// unavailable in subsequent versions.]
/// </para>
/// <para>
/// Displays a dialog box that allows the user to choose an icon from the selection available embedded in a resource such as an
/// executable or DLL file.
/// </para>
/// </summary>
/// <param name="hwnd">
/// <para>Type: <c>HWND</c></para>
/// <para>The handle of the parent window. This value can be <c>NULL</c>.</para>
/// </param>
/// <param name="pszIconPath">
/// <para>Type: <c>PWSTR</c></para>
/// <para>
/// A pointer to a string that contains the null-terminated, fully qualified path of the default resource that contains the icons. If
/// the user chooses a different resource in the dialog, this buffer contains the path of that file when the function returns. This
/// buffer should be at least MAX_PATH characters in length, or the returned path may be truncated. You should verify that the path
/// is valid before using it.
/// </para>
/// </param>
/// <param name="cchIconPath">
/// <para>Type: <c>UINT</c></para>
/// <para>The number of characters in , including the terminating <c>NULL</c> character.</para>
/// </param>
/// <param name="piIconIndex">
/// <para>Type: <c>int*</c></para>
/// <para>
/// A pointer to an integer that on entry specifies the index of the initial selection and, when this function returns successfully,
/// receives the index of the icon that was selected.
/// </para>
/// </param>
/// <returns>
/// <para>Type: <c>int</c></para>
/// <para>Returns 1 if successful; otherwise, 0.</para>
/// </returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-pickicondlg
// int PickIconDlg( HWND hwnd, PWSTR pszIconPath, UINT cchIconPath, int *piIconIndex );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "3dfcda10-26d8-495d-8c92-7ff16da098c1")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool PickIconDlg(HandleRef hwnd, [MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszIconPath, uint cchIconPath, ref int piIconIndex);
/// <summary>
/// [PifMgr_CloseProperties is available for use in the operating systems specified in the Requirements section.It may be altered or unavailable in subsequent versions.]
/// <para>Closes application properties that were opened with PifMgr_OpenProperties.</para></summary>
/// <param name="hProps">A handle to the application's properties. This parameter should be set to the value that is returned by PifMgr_OpenProperties.</param>
/// <param name="flOpt">A flag that specifies how the function operates.</param>
/// <returns>Returns NULL if successful. If unsuccessful, the functions returns the handle to the application properties that was passed as hProps.</returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-pifmgr_closeproperties
// HANDLE PifMgr_CloseProperties(HANDLE hProps, UINT flOpt);
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "fd50d4f8-87c8-4162-9e88-3c8592b929fa")]
public static extern IntPtr PifMgr_CloseProperties(IntPtr hProps, CLOSEPROPS flOpt);
/// <summary>
/// [PifMgr_GetProperties is available for use in the operating systems specified in the Requirements section.It may be altered or unavailable in subsequent versions.]
/// <para>Returns a specified block of data from a .pif file.</para></summary>
/// <param name="hProps">A handle to an application's properties. This parameter should be set to the value that is returned by PifMgr_OpenProperties.</param>
/// <param name="pszGroup">A null-terminated string that contains the property group name. It can be one of the following, or any other name that corresponds to a valid .pif extension.</param>
/// <param name="lpProps">When this function returns, contains a pointer to a PROPPRG structure.</param>
/// <param name="cbProps">The size of the buffer, in bytes, pointed to by lpProps.</param>
/// <param name="flOpt">Set this parameter to GETPROPS_NONE.</param>
/// <returns>Returns NULL if successful. If unsuccessful, the function returns the handle to the application properties that were passed as hProps.</returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-pifmgr_getproperties
// int PifMgr_GetProperties( HANDLE hProps, PCSTR pszGroup, void* lpProps, int cbProps, UINT flOpt );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true, CharSet = CharSet.Ansi)]
[PInvokeData("shlobj_core.h")]
public static extern int PifMgr_GetProperties(IntPtr hProps, string pszGroup, IntPtr lpProps, int cbProps, uint flOpt = 0);
/// <summary>
/// <para>
/// [PifMgr_OpenProperties is available for use in the operating systems specified in the Requirements section. It may be altered or
/// unavailable in subsequent versions.]
/// </para>
/// <para>Opens the .pif file associated with a Microsoft MS-DOS application, and returns a handle to the application's properties.</para>
/// </summary>
/// <param name="pszApp">
/// <para>Type: <c>PCWSTR</c></para>
/// <para>A null-terminated Unicode string that contains the application's name.</para>
/// </param>
/// <param name="pszPIF">
/// <para>TBD</para>
/// </param>
/// <param name="hInf">
/// <para>Type: <c>UINT</c></para>
/// <para>
/// A handle to the application's .inf file. Set this value to zero if there is no .inf file. Set this value to -1 to prevent the
/// .inf file from being processed.
/// </para>
/// </param>
/// <param name="flOpt">
/// <para>Type: <c>UINT</c></para>
/// <para>A flag that controls how the function operates.</para>
/// <para>OPENPROPS_INHIBITPIF</para>
/// <para>
/// Ignore any existing .pif files and get the properties from win.ini or _Default.pif. This flag is ignored on Windows NT, Windows
/// 2000, and Windows XP.
/// </para>
/// <para>OPENPROPS_NONE</para>
/// <para>No options specified.</para>
/// </param>
/// <returns>
/// <para>Type: <c>HANDLE</c></para>
/// <para>Returns a handle to the application's properties. Use this handle when you call the related .pif functions.</para>
/// </returns>
/// <remarks>
/// <para>
/// You should not think of <c>PifMgr_OpenProperties</c> as a function that opens a file somewhere. The .pif file does not remain
/// open after this call. It is more useful to think of the function as a property structure allocator that you can initialize using
/// disk data. The primary reason why this function fails is because of low memory or inability to open the specified .pif file.
/// </para>
/// <para>
/// If no .pif file exists, the function still allocates a data block in memory and initializes it with data from _Default.pif or its
/// internal defaults. If the function looks for a .pif file name but does not find it, it constructs a name and saves it in its
/// internal .pif data structure. This guarantees that if PifMgr_SetProperties is called, the data is saved to disk.
/// </para>
/// <para>If the function does not find the .pif file, it searches for it in the following order.</para>
/// <list type="number">
/// <item>Searches the current directory.</item>
/// <item>Searches the specified directory.</item>
/// <item>Searches in .pif directory.</item>
/// <item>Searches the folders specified by the PATH environment variable.</item>
/// </list>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-pifmgr_openproperties
// HANDLE PifMgr_OpenProperties( PCWSTR pszApp, PCWSTR pszPIF, UINT hInf, UINT flOpt );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "0bc11528-7278-4765-b3cb-671ba82c9155")]
public static extern IntPtr PifMgr_OpenProperties([MarshalAs(UnmanagedType.LPWStr)] string pszApp, [MarshalAs(UnmanagedType.LPWStr)] string pszPIF, uint hInf, OPENPROPS flOpt);
/// <summary>
/// [PifMgr_SetProperties is available for use in the operating systems specified in the Requirements section.It may be altered or unavailable in subsequent versions.]
/// <para>Assigns values to a block of data from a .pif file.</para></summary>
/// <param name="hProps">A handle to the application's properties. This parameter should be set to the value that is returned by PifMgr_OpenProperties.</param>
/// <param name="pszGroup">A null-terminated ANSI string containing the property group name. It can be one of the following, or any other name that corresponds to a valid .pif extension.</param>
/// <param name="lpProps">A property group record buffer that holds the data.</param>
/// <param name="cbProps">The size of the buffer, in bytes, pointed to by lpProps.</param>
/// <param name="flOpt">Always SETPROPS_NONE.</param>
/// <returns>Returns the amount of information transferred, in bytes. Returns zero if the group cannot be found or an error occurs.</returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-pifmgr_setproperties
// int PifMgr_SetProperties(HANDLE hProps, PCSTR pszGroup, const void* lpProps, int cbProps, UINT flOpt );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true, CharSet = CharSet.Ansi)]
[PInvokeData("shlobj_core.h")]
public static extern int PifMgr_SetProperties(IntPtr hProps, string pszGroup, IntPtr lpProps, int cbProps, uint flOpt = 0);
/// <summary><para>[ReadCabinetState is available for use in the operating systems specified in the Requirements section. It may be altered or unavailable in subsequent versions.]</para><para>Fills a CABINETSTATE structure with information from the registry.</para></summary><param name="pcs"><para>Type: <c>CABINETSTATE*</c></para><para>When this function returns, contains a pointer to a CABINETSTATE structure that contains either information pulled from the registry or default information.</para></param><param name="cLength"><para>Type: <c>int</c></para><para>The size of the structure pointed to by , in bytes.</para></param><returns><para>Type: <c>BOOL</c></para><para>Returns <c>TRUE</c> if the returned structure contains information from the registry. Returns <c>FALSE</c> if the structure contains default information.</para></returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-readcabinetstate
// BOOL ReadCabinetState( CABINETSTATE *pcs, int cLength );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "0f0c6a10-588f-4c79-b73b-cf0bf9336ffc")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool ReadCabinetState(ref CABINETSTATE pcs, int cLength);
/// <summary>
/// <para>
/// [RealDriveType is available for use in the operating systems specified in the Requirements section. It may be altered or
/// unavailable in subsequent versions.]
/// </para>
/// <para>Determines the drive type based on the drive number.</para>
/// </summary>
/// <param name="iDrive">
/// <para>Type: <c>int</c></para>
/// <para>The number of the drive that you want to test. "A:" corresponds to 0, "B:" to 1, and so on.</para>
/// </param>
/// <param name="fOKToHitNet">
/// <para>Type: <c>BOOL</c></para>
/// <para>Reserved. Must be set to 0.</para>
/// </param>
/// <returns>
/// <para>Type: <c>int</c></para>
/// <para>Returns one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>DRIVE_UNKNOWN</term>
/// <term>The drive type cannot be determined.</term>
/// </item>
/// <item>
/// <term>DRIVE_NO_ROOT_DIR</term>
/// <term>The root path is invalid. For example, no volume is mounted at the path.</term>
/// </item>
/// <item>
/// <term>DRIVE_REMOVABLE</term>
/// <term>The disk can be removed from the drive.</term>
/// </item>
/// <item>
/// <term>DRIVE_FIXED</term>
/// <term>The disk cannot be removed from the drive.</term>
/// </item>
/// <item>
/// <term>DRIVE_REMOTE</term>
/// <term>The drive is a remote (network) drive.</term>
/// </item>
/// <item>
/// <term>DRIVE_CDROM</term>
/// <term>The drive is a CD-ROM drive.</term>
/// </item>
/// <item>
/// <term>DRIVE_RAMDISK</term>
/// <term>The drive is a RAM disk.</term>
/// </item>
/// </list>
/// </returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-realdrivetype
// int RealDriveType( int iDrive, BOOL fOKToHitNet );
// public static extern int RealDriveType(int iDrive, [MarshalAs(UnmanagedType.Bool)] bool fOKToHitNet);
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "c4e55b50-637a-446f-aa9c-7d8c71d8071c")]
public static extern DRIVE_TYPE RealDriveType(int iDrive, [MarshalAs(UnmanagedType.Bool)] bool fOKToHitNet);
/// <summary>
/// <para>
/// [This function is available through Windows XP Service Pack 2 (SP2) and Windows Server 2003. It might be altered or unavailable
/// in subsequent versions of Windows.]
/// </para>
/// <para>
/// Displays a dialog box that prompts the user to restart Windows. When the user clicks the button, the function calls ExitWindowsEx
/// to attempt to restart Windows.
/// </para>
/// </summary>
/// <param name="hwnd">
/// <para>TBD</para>
/// </param>
/// <param name="pszPrompt">
/// <para>Type: <c>PCWSTR</c></para>
/// <para>A null-terminated Unicode string that contains the text that displays in the dialog box which prompts the user.</para>
/// </param>
/// <param name="dwReturn">
/// <para>TBD</para>
/// </param>
/// <returns>
/// <para>Type: <c>int</c></para>
/// <para>Returns the identifier of the button that was pressed to close the dialog box.</para>
/// </returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-restartdialog
// int RestartDialog( HWND hwnd, PCWSTR pszPrompt, DWORD dwReturn );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "ec1e3c11-9960-482c-8461-72c4d41dff3c")]
public static extern int RestartDialog(HandleRef hwnd, [MarshalAs(UnmanagedType.LPWStr)] string pszPrompt, uint dwReturn);
/// <summary>
/// <para>
/// [This function is available through Windows XP Service Pack 2 (SP2) and Windows Server 2003. It might be altered or unavailable
/// in subsequent versions of Windows.]
/// </para>
/// <para>
/// Displays a dialog box that asks the user to restart Windows. When the user clicks the button, the function calls ExitWindowsEx to
/// attempt to restart Windows.
/// </para>
/// </summary>
/// <param name="hwnd">
/// <para>TBD</para>
/// </param>
/// <param name="pszPrompt">
/// <para>Type: <c>PCWSTR</c></para>
/// <para>A null-terminated string that contains the text that displays in the dialog box to prompt the user.</para>
/// </param>
/// <param name="dwReturn">
/// <para>TBD</para>
/// </param>
/// <param name="dwReasonCode">
/// <para>Type: <c>DWORD</c></para>
/// <para>
/// <c>Windows XP:</c> Specifies the reason for initiating the shutdown. For more information, see System Shutdown Reason Codes.
/// </para>
/// <para><c>Windows 2000:</c> This parameter is ignored.</para>
/// </param>
/// <returns>
/// <para>Type: <c>int</c></para>
/// <para>Returns the identifier of the button that was pressed to close the dialog box.</para>
/// </returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-restartdialogex
// int RestartDialogEx( HWND hwnd, PCWSTR pszPrompt, DWORD dwReturn, DWORD dwReasonCode );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "32bc232f-6cc4-4f19-9d33-ba7ad28dfd59")]
public static extern int RestartDialogEx(HandleRef hwnd, [MarshalAs(UnmanagedType.LPWStr)] string pszPrompt, uint dwReturn, uint dwReasonCode);
/// <summary>
/// Notifies the system that an item has been accessed, for the purposes of tracking those items used most recently and most frequently. This function
/// can also be used to clear all usage data.
/// </summary>
/// <param name="uFlags">A value from the SHARD enumeration that indicates the form of the information pointed to by the pv parameter.</param>
/// <param name="pv">
/// A pointer to data that identifies the item that has been accessed. The item can be specified in this parameter in one of the following forms:
/// <list type="bullet">
/// <item><definition>A null-terminated string that contains the path and file name of the item.</definition></item>
/// <item><definition>A PIDL that identifies the item's file object.</definition></item>
/// <item>
/// <definition>Windows 7 and later only. A SHARDAPPIDINFO, SHARDAPPIDINFOIDLIST, or SHARDAPPIDINFOLINK structure that identifies the item through an
/// AppUserModelID. See Application User Model IDs (AppUserModelIDs) for more information.</definition>
/// </item>
/// <item><definition>Windows 7 and later only. An IShellLink object that identifies the item through a shortcut.</definition></item>
/// </list>
/// <para>Set this parameter to NULL to clear all usage data on all items.</para>
/// </param>
[DllImport(Lib.Shell32, ExactSpelling = true)]
[SecurityCritical, SuppressUnmanagedCodeSecurity]
[PInvokeData("Shlobj.h", MSDNShortId = "bb762105")]
public static extern void SHAddToRecentDocs(SHARD uFlags, IShellLinkW pv);
/// <summary>
/// Notifies the system that an item has been accessed, for the purposes of tracking those items used most recently and most frequently. This function
/// can also be used to clear all usage data.
/// </summary>
/// <param name="uFlags">A value from the SHARD enumeration that indicates the form of the information pointed to by the pv parameter.</param>
/// <param name="pv">
/// A pointer to data that identifies the item that has been accessed. The item can be specified in this parameter in one of the following forms:
/// <list type="bullet">
/// <item><definition>A null-terminated string that contains the path and file name of the item.</definition></item>
/// <item><definition>A PIDL that identifies the item's file object.</definition></item>
/// <item>
/// <definition>Windows 7 and later only. A SHARDAPPIDINFO, SHARDAPPIDINFOIDLIST, or SHARDAPPIDINFOLINK structure that identifies the item through an
/// AppUserModelID. See Application User Model IDs (AppUserModelIDs) for more information.</definition>
/// </item>
/// <item><definition>Windows 7 and later only. An IShellLink object that identifies the item through a shortcut.</definition></item>
/// </list>
/// <para>Set this parameter to NULL to clear all usage data on all items.</para>
/// </param>
[DllImport(Lib.Shell32, ExactSpelling = true)]
[SecurityCritical, SuppressUnmanagedCodeSecurity]
[PInvokeData("Shlobj.h", MSDNShortId = "bb762105")]
public static extern void SHAddToRecentDocs(SHARD uFlags, [MarshalAs(UnmanagedType.LPWStr)] string pv);
/// <summary>
/// Notifies the system that an item has been accessed, for the purposes of tracking those items used most recently and most frequently. This function
/// can also be used to clear all usage data.
/// </summary>
/// <param name="uFlags">A value from the SHARD enumeration that indicates the form of the information pointed to by the pv parameter.</param>
/// <param name="pv">
/// A pointer to data that identifies the item that has been accessed. The item can be specified in this parameter in one of the following forms:
/// <list type="bullet">
/// <item><definition>A null-terminated string that contains the path and file name of the item.</definition></item>
/// <item><definition>A PIDL that identifies the item's file object.</definition></item>
/// <item>
/// <definition>Windows 7 and later only. A SHARDAPPIDINFO, SHARDAPPIDINFOIDLIST, or SHARDAPPIDINFOLINK structure that identifies the item through an
/// AppUserModelID. See Application User Model IDs (AppUserModelIDs) for more information.</definition>
/// </item>
/// <item><definition>Windows 7 and later only. An IShellLink object that identifies the item through a shortcut.</definition></item>
/// </list>
/// <para>Set this parameter to NULL to clear all usage data on all items.</para>
/// </param>
[DllImport(Lib.Shell32, ExactSpelling = true)]
[SecurityCritical, SuppressUnmanagedCodeSecurity]
[PInvokeData("Shlobj.h", MSDNShortId = "bb762105")]
public static extern void SHAddToRecentDocs(SHARD uFlags, PIDL pv);
/// <summary>
/// <para>
/// Given a Shell namespace item specified in the form of a folder, and an item identifier list relative to that folder, this
/// function binds to the parent of the namespace item and optionally returns a pointer to the final component of the item identifier list.
/// </para>
/// </summary>
/// <param name="psfRoot">
/// <para>Type: <c>IShellFolder*</c></para>
/// <para>A pointer to a Shell folder object. If is <c>NULL</c>, indicates that the IDList passed is relative to the desktop.</para>
/// </param>
/// <param name="pidl">
/// <para>Type: <c>PCUIDLIST_RELATIVE</c></para>
/// <para>A PIDL to bind to, relative to . If is <c>NULL</c>, this is an absolute IDList relative to the desktop folder.</para>
/// </param>
/// <param name="riid">
/// <para>Type: <c>REFIID</c></para>
/// <para>
/// Reference to the desired interface ID. This is typically IID_IShellFolder or IID_IShellFolder2, but can be anything supported by
/// the target folder.
/// </para>
/// </param>
/// <param name="ppv">
/// <para>Type: <c>void**</c></para>
/// <para>
/// When this function returns, contains the interface pointer requested in . This is typically IShellFolder or IShellFolder2, but
/// can be anything supported by the target folder.
/// </para>
/// </param>
/// <param name="ppidlLast">
/// <para>Type: <c>PCUITEMID_CHILD*</c></para>
/// <para>
/// A pointer to the last ID of the parameter, and is a child ID relative to the parent folder returned in . This value can be <c>NULL</c>.
/// </para>
/// </param>
/// <returns>
/// <para>Type: <c>HRESULT</c></para>
/// <para>If this function succeeds, it returns <c>S_OK</c>. Otherwise, it returns an <c>HRESULT</c> error code.</para>
/// </returns>
/// <remarks>
/// <para>
/// <c>Note</c> Calling the <c>SHBindToFolderIDListParent</c> function is equivalent to calling the SHBindToFolderIDListParentEx
/// function with <c>NULL</c> as the bind context.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-shbindtofolderidlistparent
// SHSTDAPI SHBindToFolderIDListParent( IShellFolder *psfRoot, PCUIDLIST_RELATIVE pidl, REFIID riid, void **ppv, PCUITEMID_CHILD *ppidlLast );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "72a79d1b-15ed-475e-9ebd-03345579a06a")]
public static extern HRESULT SHBindToFolderIDListParent(IShellFolder psfRoot, PIDL pidl, [In, MarshalAs(UnmanagedType.LPStruct)] Guid riid, [MarshalAs(UnmanagedType.IUnknown)] out object ppv, IntPtr ppidlLast);
/// <summary>
/// <para>Extends the SHBindToFolderIDListParent function by allowing the caller to specify a bind context.</para>
/// </summary>
/// <param name="psfRoot">
/// <para>Type: <c>IShellFolder*</c></para>
/// <para>A pointer to a Shell folder object. If is <c>NULL</c>, indicates that the IDList passed is relative to the desktop.</para>
/// </param>
/// <param name="pidl">
/// <para>Type: <c>PCUIDLIST_RELATIVE</c></para>
/// <para>A PIDL to bind to, relative to . If is <c>NULL</c>, this is an absolute IDList relative to the desktop folder.</para>
/// </param>
/// <param name="ppbc">
/// <para>Type: <c>IBindCtx*</c></para>
/// <para>
/// A pointer to IBindCtx interface on a bind context object to be used during this operation. If this parameter is not used, set it
/// to <c>NULL</c>, which is equivalent to calling the SHBindToFolderIDListParent function. Because support for is optional for
/// folder object implementations, some folders may not support the use of bind contexts.
/// </para>
/// </param>
/// <param name="riid">
/// <para>Type: <c>REFIID</c></para>
/// <para>
/// Reference to the desired interface ID. This is typically IID_IShellFolder or IID_IShellFolder2, but can be anything supported by
/// the target folder.
/// </para>
/// </param>
/// <param name="ppv">
/// <para>Type: <c>void**</c></para>
/// <para>
/// When this function returns, contains the interface pointer requested in . This is typically IShellFolder or IShellFolder2, but
/// can be anything supported by the target folder.
/// </para>
/// </param>
/// <param name="ppidlLast">
/// <para>Type: <c>PCUITEMID_CHILD*</c></para>
/// <para>
/// A pointer to the last ID of the parameter, and is a child ID relative to the parent folder returned in . This value can be <c>NULL</c>.
/// </para>
/// </param>
/// <returns>
/// <para>Type: <c>HRESULT</c></para>
/// <para>If this function succeeds, it returns <c>S_OK</c>. Otherwise, it returns an <c>HRESULT</c> error code.</para>
/// </returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-shbindtofolderidlistparentex
// SHSTDAPI SHBindToFolderIDListParentEx( IShellFolder *psfRoot, PCUIDLIST_RELATIVE pidl, IBindCtx *ppbc, REFIID riid, void **ppv, PCUITEMID_CHILD *ppidlLast );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "4f9b68cb-d0ae-45f7-90f5-2db1da3ab599")]
public static extern HRESULT SHBindToFolderIDListParentEx(IShellFolder psfRoot, PIDL pidl, IBindCtx ppbc, [In, MarshalAs(UnmanagedType.LPStruct)] Guid riid, [MarshalAs(UnmanagedType.IUnknown)] out object ppv, IntPtr ppidlLast);
/// <summary>
/// <para>Retrieves and binds to a specified object by using the Shell namespace IShellFolder::BindToObject method.</para>
/// </summary>
/// <param name="psf">
/// <para>Type: <c>IShellFolder*</c></para>
/// <para>
/// A pointer to IShellFolder. This parameter can be <c>NULL</c>. If is <c>NULL</c>, this indicates parameter is relative to the
/// desktop. In this case, must specify an absolute ITEMIDLIST.
/// </para>
/// </param>
/// <param name="pidl">
/// <para>Type: <c>PCUIDLIST_RELATIVE</c></para>
/// <para>
/// A pointer to a constant ITEMIDLIST to bind to that is relative to . If is <c>NULL</c>, this is an absolute <c>ITEMIDLIST</c>
/// relative to the desktop folder.
/// </para>
/// </param>
/// <param name="pbc">
/// <para>Type: <c>IBindCtx*</c></para>
/// <para>
/// A pointer to IBindCtx interface on a bind context object to be used during this operation. If this parameter is not used, set it
/// to <c>NULL</c>. Because support for is optional for folder object implementations, some folders may not support the use of bind contexts.
/// </para>
/// </param>
/// <param name="riid">
/// <para>Type: <c>REFIID</c></para>
/// <para>Identifier of the interface to return.</para>
/// </param>
/// <param name="ppv">
/// <para>Type: <c>void**</c></para>
/// <para>
/// When this method returns, contains the interface pointer as specified in to the bound object. If an error occurs, contains a
/// <c>NULL</c> pointer.
/// </para>
/// </param>
/// <returns>
/// <para>Type: <c>HRESULT</c></para>
/// <para>If this function succeeds, it returns <c>S_OK</c>. Otherwise, it returns an <c>HRESULT</c> error code.</para>
/// </returns>
/// <remarks>
/// <para><c>Note</c> This is a helper function that gets the desktop object by calling SHGetDesktopFolder.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-shbindtoobject
// SHSTDAPI SHBindToObject( IShellFolder *psf, PCUIDLIST_RELATIVE pidl, IBindCtx *pbc, REFIID riid, void **ppv );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "acc16097-8301-4118-8cb5-00aa2705306a")]
public static extern HRESULT SHBindToObject(IShellFolder psf, PIDL pidl, IBindCtx pbc, [In, MarshalAs(UnmanagedType.LPStruct)] Guid riid, [MarshalAs(UnmanagedType.IUnknown)] out object ppv);
/// <summary>Displays a dialog box that enables the user to select a Shell folder.</summary>
/// <param name="lpbi">A pointer to a BROWSEINFO structure that contains information used to display the dialog box.</param>
/// <returns>
/// Returns a PIDL that specifies the location of the selected folder relative to the root of the namespace. If the user chooses the Cancel button in the
/// dialog box, the return value is NULL.
/// </returns>
[DllImport(Lib.Shell32, CharSet = CharSet.Auto)]
[PInvokeData("Shlobj.h", MSDNShortId = "bb762115")]
public static extern PIDL SHBrowseForFolder(ref BROWSEINFO lpbi);
/// <summary>
/// <para>Locks the shared memory associated with a Shell change notification event.</para>
/// </summary>
/// <param name="hChange">
/// <para>Type: <c>HANDLE</c></para>
/// <para>A handle to a window received as a in the specified Shell change notification message.</para>
/// </param>
/// <param name="dwProcId">
/// <para>Type: <c>DWORD</c></para>
/// <para>The process ID ( in the message callback).</para>
/// </param>
/// <param name="pppidl">
/// <para>Type: <c>PIDLIST_ABSOLUTE**</c></para>
/// <para>
/// The address of a pointer to a PIDLIST_ABSOLUTE that, when this function returns successfully, receives the list of affected PIDLs.
/// </para>
/// </param>
/// <param name="plEvent">
/// <para>Type: <c>LONG*</c></para>
/// <para>
/// A pointer to a LONG value that, when this function returns successfully, receives the Shell change notification ID of the event
/// that took place.
/// </para>
/// </param>
/// <returns>
/// <para>Type: <c>HANDLE</c></para>
/// <para>Returns a handle (HLOCK) to the locked memory. Pass this value to SHChangeNotification_Unlock when finished.</para>
/// </returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-shchangenotification_lock
// HANDLE SHChangeNotification_Lock( HANDLE hChange, DWORD dwProcId, PIDLIST_ABSOLUTE **pppidl, LONG *plEvent );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "8e22d5d0-64be-403c-982d-c23705d85223")]
public static extern IntPtr SHChangeNotification_Lock(IntPtr hChange, uint dwProcId, IntPtr pppidl, ref int plEvent);
/// <summary>
/// <para>Unlocks shared memory for a change notification.</para>
/// </summary>
/// <param name="hLock">
/// <para>Type: <c>HANDLE</c></para>
/// <para>A handle to the memory lock. This is the handle returned by SHChangeNotification_Lock when it locked the memory.</para>
/// </param>
/// <returns>
/// <para>Type: <c>BOOL</c></para>
/// <para>Returns <c>TRUE</c> on success; otherwise, <c>FALSE</c>.</para>
/// </returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-shchangenotification_unlock
// BOOL SHChangeNotification_Unlock( HANDLE hLock );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "967ede1f-ee9c-46ee-a371-dcfc3a57d824")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SHChangeNotification_Unlock(IntPtr hLock);
/// <summary>
/// Notifies the system of an event that an application has performed. An application should use this function if it performs an
/// action that may affect the Shell.
/// </summary>
/// <param name="wEventId">
/// Describes the event that has occurred. Typically, only one event is specified at a time. If more than one event is specified, the
/// values contained in the dwItem1 and dwItem2 parameters must be the same, respectively, for all specified events.
/// </param>
/// <param name="uFlags">Flags that, when combined bitwise with SHCNF_TYPE, indicate the meaning of the dwItem1 and dwItem2 parameters.</param>
/// <param name="dwItem1">Optional. First event-dependent value.</param>
/// <param name="dwItem2">Optional. Second event-dependent value.</param>
[DllImport(Lib.Shell32, ExactSpelling = true)]
[PInvokeData("Shlobj.h")]
public static extern void SHChangeNotify(SHCNE wEventId, SHCNF uFlags, [Optional] IntPtr dwItem1, [Optional] IntPtr dwItem2);
/// <summary>
/// <para>Unregisters the client's window process from receiving SHChangeNotify messages.</para>
/// </summary>
/// <param name="ulID">
/// <para>Type: <c>ULONG</c></para>
/// <para>A value of type <c>ULONG</c> that specifies the registration ID returned by SHChangeNotifyRegister.</para>
/// </param>
/// <returns>
/// <para>Type: <c>BOOL</c></para>
/// <para>Returns <c>TRUE</c> if the specified client was found and removed; otherwise <c>FALSE</c>.</para>
/// </returns>
/// <remarks>
/// <para>
/// See the Change Notify Watcher Sample in the Windows Software Development Kit (SDK) for a full example that demonstrates the use
/// of this function.
/// </para>
/// <para>
/// The <c>NTSHChangeNotifyDeregister</c> function, which is no longer available for use as of Windows Vista, was equivalent to <c>SHChangeNotifyDeregister</c>.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-shchangenotifyderegister
// BOOL SHChangeNotifyDeregister( ULONG ulID );
[DllImport(Lib.Shell32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("shlobj_core.h", MSDNShortId = "fad021dc-8199-4384-b623-c98bc618799f")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SHChangeNotifyDeregister(uint ulID);
/// <summary>
/// <para>Enables asynchronous register and deregister of a thread.</para>
/// </summary>
/// <param name="status">
/// <para>Type: <c>SCNRT_STATUS</c></para>
/// <para>Indicates whether the function is being used to register or deregister the thread. One of the values of SCNRT_STATUS.</para>
/// </param>
/// <returns>
/// <para>This function does not return a value.</para>
/// </returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj/nf-shlobj-shchangenotifyregisterthread
// void SHChangeNotifyRegisterThread( SCNRT_STATUS status );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj.h", MSDNShortId = "170afefc-b4de-4661-9c12-1341656b0fdb")]
public static extern void SHChangeNotifyRegisterThread(SCNRT_STATUS status);
/// <summary>
/// <para>Creates a data object in a parent folder.</para>
/// </summary>
/// <param name="pidlFolder">
/// <para>Type: <c>PCIDLIST_ABSOLUTE</c></para>
/// <para>A pointer to an ITEMIDLIST (PIDL) of the parent folder that contains the data object.</para>
/// </param>
/// <param name="cidl">
/// <para>Type: <c>UINT</c></para>
/// <para>The number of file objects or subfolders specified in the parameter.</para>
/// </param>
/// <param name="apidl">
/// <para>Type: <c>PCUITEMID_CHILD_ARRAY</c></para>
/// <para>
/// An array of pointers to constant 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.
/// </para>
/// </param>
/// <param name="pdtInner">
/// <para>Type: <c>IDataObject*</c></para>
/// <para>
/// A pointer to interface IDataObject. This parameter can be <c>NULL</c>. Specify only if the data object created needs to support
/// additional FORMATETC clipboard formats beyond the default formats it is assigned at creation. Alternatively, provide support for
/// populating the created data object using non-default clipboard formats by calling method IDataObject::SetData and specifying the
/// format in the <c>FORMATETC</c> structure passed in parameter .
/// </para>
/// </param>
/// <param name="riid">
/// <para>Type: <c>REFIID</c></para>
/// <para>A reference to the IID of the interface to retrieve through . This must be IID_IDataObject.</para>
/// </param>
/// <param name="ppv">
/// <para>Type: <c>void**</c></para>
/// <para>When this method returns successfully, contains the IDataObject interface pointer requested in .</para>
/// </param>
/// <returns>
/// <para>Type: <c>HRESULT</c></para>
/// <para>If this function succeeds, it returns <c>S_OK</c>. Otherwise, it returns an <c>HRESULT</c> error code.</para>
/// </returns>
/// <remarks>
/// <para>
/// This function is typically called when implementing method IShellFolder::GetUIObjectOf. When an interface pointer of interface ID
/// IID_IDataObject is requested (using parameter ), the implementer can return the interface pointer on the object created with
/// <c>SHCreateDataObject</c> in response.
/// </para>
/// <para>
/// This function supports the CFSTR_SHELLIDLIST (also known as HIDA) clipboard format and also has generic support for arbitrary
/// clipboard formats through IDataObject::SetData. For more information on clipboard formats, see Shell Clipboard Formats.
/// </para>
/// <para>
/// The new data object is intended to be used in operations such as drag-and-drop, in which the data is stored in the clipboard with
/// a given format.
/// </para>
/// <para>
/// We recommend that you use the IID_PPV_ARGS macro, defined in Objbase.h, to package the and parameters. This macro provides the
/// correct IID based on the interface pointed to by the value in , which eliminates the possibility of a coding error in that could
/// lead to unexpected results.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-shcreatedataobject
// SHSTDAPI SHCreateDataObject( PCIDLIST_ABSOLUTE pidlFolder, UINT cidl, PCUITEMID_CHILD_ARRAY apidl, IDataObject *pdtInner, REFIID riid, void **ppv );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "d56cdafe-9463-43a5-8ef0-6cfaf0c524a8")]
public static extern HRESULT SHCreateDataObject(PIDL pidlFolder, uint cidl, [In, MarshalAs(UnmanagedType.LPArray)] PIDL[] apidl, IDataObject pdtInner, [In, MarshalAs(UnmanagedType.LPStruct)] Guid riid, out IDataObject ppv);
/// <summary>
/// <para>Creates an object that represents the Shell's default context menu implementation.</para>
/// </summary>
/// <param name="pdcm">
/// <para>Type: <c>const DEFCONTEXTMENU*</c></para>
/// <para>A pointer to a constant DEFCONTEXTMENU structure.</para>
/// </param>
/// <param name="riid">
/// <para>Type: <c>REFIID</c></para>
/// <para>
/// Reference to the interface ID of the interface on which to base the object. This is typically the IID of IContextMenu,
/// IContextMenu2, or IContextMenu3.
/// </para>
/// </param>
/// <param name="ppv">
/// <para>Type: <c>void**</c></para>
/// <para>When this method returns, contains the interface pointer requested in riid.</para>
/// </param>
/// <returns>
/// <para>Type: <c>HRESULT</c></para>
/// <para>If this function succeeds, it returns <c>S_OK</c>. Otherwise, it returns an <c>HRESULT</c> error code.</para>
/// </returns>
/// <remarks>
/// <para>
/// This function is typically used in the implementation of IShellFolder::GetUIObjectOf. <c>GetUIObjectOf</c> creates a context menu
/// that merges IContextMenu handlers specified by the DEFCONTEXTMENU structure, and can optionally provide default context menu verb
/// implementations such as open, explore, delete, and copy.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-shcreatedefaultcontextmenu
// SHSTDAPI SHCreateDefaultContextMenu( const DEFCONTEXTMENU *pdcm, REFIID riid, void **ppv );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "055ff0a0-9ba7-463d-9684-3fd072b190da")]
public static extern HRESULT SHCreateDefaultContextMenu(ref DEFCONTEXTMENU pdcm, [In, MarshalAs(UnmanagedType.LPStruct)] Guid riid, [MarshalAs(UnmanagedType.IUnknown)] out object ppv);
/// <summary>
/// <para>
/// [SHCreateDirectory is available for use in the operating systems specified in the Requirements section. It may be altered or
/// unavailable in subsequent versions.]
/// </para>
/// <para>Creates a new file system folder.</para>
/// </summary>
/// <param name="hwnd">
/// <para>Type: <c>HWND</c></para>
/// <para>A handle to a parent window. This parameter can be set to <c>NULL</c> if no user interface is displayed.</para>
/// </param>
/// <param name="pszPath">
/// <para>Type: <c>PCWSTR</c></para>
/// <para>
/// A pointer to a null-terminated Unicode string that contains the fully qualified path of the directory. This string should have no
/// more than MAX_PATH characters, including the terminating null character.
/// </para>
/// </param>
/// <returns>
/// <para>Type: <c>int</c></para>
/// <para>
/// Returns <c>ERROR_SUCCESS</c> if successful. If the operation fails, other error codes can be returned, including those listed
/// here. For values not specifically listed, see System Error Codes.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>ERROR_BAD_PATHNAME</term>
/// <term>The parameter was set to a relative path.</term>
/// </item>
/// <item>
/// <term>ERROR_FILENAME_EXCED_RANGE</term>
/// <term>The path pointed to by is too long.</term>
/// </item>
/// <item>
/// <term>ERROR_FILE_EXISTS</term>
/// <term>The directory exists.</term>
/// </item>
/// <item>
/// <term>ERROR_ALREADY_EXISTS</term>
/// <term>The directory exists.</term>
/// </item>
/// <item>
/// <term>ERROR_CANCELLED</term>
/// <term>The user canceled the operation.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>
/// This function creates a file system folder whose fully qualified path is given by . If one or more of the intermediate folders do
/// not exist, it creates them.
/// </para>
/// <para>To set security attributes on a new folder, use SHCreateDirectoryEx.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-shcreatedirectory
// int SHCreateDirectory( HWND hwnd, PCWSTR pszPath );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "4927429c-f457-4dda-aa0d-236eb236795c")]
public static extern Win32Error SHCreateDirectory([Optional] HandleRef hwnd, [MarshalAs(UnmanagedType.LPWStr)] string pszPath);
/// <summary>
/// <para>
/// [This function is available through Windows XP Service Pack 2 (SP2) and Windows Server 2003. It might be altered or unavailable
/// in subsequent versions of Windows.]
/// </para>
/// <para>Creates a new file system folder, with optional security attributes.</para>
/// </summary>
/// <param name="hwnd">
/// <para>Type: <c>HWND</c></para>
/// <para>A handle to a parent window. This parameter can be set to <c>NULL</c> if no user interface will be displayed.</para>
/// </param>
/// <param name="pszPath">
/// <para>Type: <c>LPCTSTR</c></para>
/// <para>
/// A pointer to a null-terminated string specifying the fully qualified path of the directory. This string is of maximum length of
/// 248 characters, including the terminating null character.
/// </para>
/// </param>
/// <param name="psa">
/// <para>Type: <c>const SECURITY_ATTRIBUTES*</c></para>
/// <para>
/// A pointer to a SECURITY_ATTRIBUTES structure with the directory's security attribute. Set this parameter to <c>NULL</c> if no
/// security attributes need to be set.
/// </para>
/// </param>
/// <returns>
/// <para>Type: <c>int</c></para>
/// <para>
/// Returns <c>ERROR_SUCCESS</c> if successful. If the operation fails, other error codes can be returned, including those listed
/// here. For values not specifically listed, see System Error Codes.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>ERROR_BAD_PATHNAME</term>
/// <term>The parameter was set to a relative path.</term>
/// </item>
/// <item>
/// <term>ERROR_FILENAME_EXCED_RANGE</term>
/// <term>The path pointed to by is too long.</term>
/// </item>
/// <item>
/// <term>ERROR_PATH_NOT_FOUND</term>
/// <term>The system cannot find the path pointed to by . The path may contain an invalid entry.</term>
/// </item>
/// <item>
/// <term>ERROR_FILE_EXISTS</term>
/// <term>The directory exists.</term>
/// </item>
/// <item>
/// <term>ERROR_ALREADY_EXISTS</term>
/// <term>The directory exists.</term>
/// </item>
/// <item>
/// <term>ERROR_CANCELLED</term>
/// <term>The user canceled the operation.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>
/// This function creates a file system folder whose fully qualified path is given by . If one or more of the intermediate folders do
/// not exist, they are created as well. <c>SHCreateDirectoryEx</c> also verifies that the files are visible. If they are not
/// visible, expect one of the following:
/// </para>
/// <list type="bullet">
/// <item>
/// If is set to a valid window handle, a message box is displayed warning the user that he or she might not be able to access the
/// files. If the user chooses not to proceed, the function returns <c>ERROR_CANCELLED</c>.
/// </item>
/// <item>If is set to <c>NULL</c>, no user interface is displayed and the function returns <c>ERROR_CANCELLED</c>.</item>
/// </list>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-shcreatedirectoryexa
// int SHCreateDirectoryEx( HWND hwnd, LPCTSTR pszPath, const SECURITY_ATTRIBUTES *psa );
[DllImport(Lib.Shell32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("shlobj_core.h", MSDNShortId = "7f44f907-cd12-4156-91c0-76e577ae25f6")]
public static extern Win32Error SHCreateDirectoryEx([Optional] HandleRef hwnd, string pszPath, [In] SECURITY_ATTRIBUTES psa);
/// <summary>
/// <para>[</para>
/// <para>SHCreateFileExtractIcon</para>
/// <para>
/// is available for use in the operating systems specified in the Requirements section. It may be altered or unavailable in
/// subsequent versions.]
/// </para>
/// <para>
/// Creates a default IExtractIcon handler for a file system object. Namespace extensions that display file system objects typically
/// use this function. The extension and file attributes derive all that is needed for a simple icon extractor.
/// </para>
/// </summary>
/// <param name="pszFile">
/// <para>Type: <c>LPCTSTR</c></para>
/// <para>
/// A pointer to a null-terminated string that specifies the file system object. The buffer must not exceed MAX_PATH characters in length.
/// </para>
/// </param>
/// <param name="dwFileAttributes">
/// <para>Type: <c>DWORD</c></para>
/// <para>
/// A combination of one or more file attribute flags (FILE_ATTRIBUTE_* values as defined in Winnt.h) that specify the type of object.
/// </para>
/// </param>
/// <param name="riid">
/// <para>Type: <c>REFIID</c></para>
/// <para>
/// Reference to the desired interface ID of the icon extractor interface to create. This must be either IID_IExtractIconA or IID_IExtractIconW.
/// </para>
/// </param>
/// <param name="ppv">
/// <para>Type: <c>void**</c></para>
/// <para>When this function returns, contains the interface pointer requested in . This is typically IExtractIcon.</para>
/// </param>
/// <returns>
/// <para>Type: <c>HRESULT</c></para>
/// <para>If this function succeeds, it returns <c>S_OK</c>. Otherwise, it returns an <c>HRESULT</c> error code.</para>
/// </returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/nf-shlobj_core-shcreatefileextracticonw
// SHSTDAPI SHCreateFileExtractIconW( LPCWSTR pszFile, DWORD dwFileAttributes, REFIID riid, void **ppv );
[DllImport(Lib.Shell32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("shlobj_core.h", MSDNShortId = "af3beb0a-892b-43e5-b5b8-8005f497b6e5")]
public static extern HRESULT SHCreateFileExtractIconW([MarshalAs(UnmanagedType.LPWStr)] string pszFile, FileFlagsAndAttributes dwFileAttributes, [In, MarshalAs(UnmanagedType.LPStruct)] Guid riid, [MarshalAs(UnmanagedType.IUnknown)] out object ppv);
/// <summary>Creates a new instance of the default Shell folder view object (DefView).</summary>
/// <param name="pcsfv">Pointer to a SFV_CREATE structure that describes the particulars used in creating this instance of the Shell folder view object.</param>
/// <param name="ppsv">When this function returns successfully, contains an interface pointer to the new IShellView object. On failure, this value is NULL.</param>
/// <returns>If this function succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code.</returns>
[DllImport(Lib.Shell32, CharSet = CharSet.Auto)]
[PInvokeData("Shlobj.h")]
public static extern HRESULT SHCreateShellFolderView(ref SFV_CREATE pcsfv, out IShellView ppsv);
/// <summary>Provides a default handler to extract an icon from a file.</summary>
/// <param name="pszIconFile">A pointer to a null-terminated buffer that contains the path and name of the file from which the icon is extracted.</param>
/// <param name="iIndex">
/// The location of the icon within the file named in pszIconFile. If this is a positive number, it refers to the zero-based position of the icon in the
/// file. For instance, 0 refers to the 1st icon in the resource file and 2 refers to the 3rd. If this is a negative number, it refers to the icon's
/// resource ID.
/// </param>
/// <param name="uFlags">A flag that controls the icon extraction.</param>
/// <param name="phiconLarge">
/// A pointer to an HICON that, when this function returns successfully, receives the handle of the large version of the icon specified in the LOWORD of
/// nIconSize. This value can be NULL.
/// </param>
/// <param name="phiconSmall">
/// A pointer to an HICON that, when this function returns successfully, receives the handle of the small version of the icon specified in the HIWORD of nIconSize.
/// </param>
/// <param name="nIconSize">
/// A value that contains the large icon size in its LOWORD and the small icon size in its HIWORD. Size is measured in pixels. Pass 0 to specify default
/// large and small sizes.
/// </param>
[DllImport(Lib.Shell32, CharSet = CharSet.Auto)]
[PInvokeData("Shlobj.h", MSDNShortId = "bb762149")]
public static extern HRESULT SHDefExtractIcon(string pszIconFile, int iIndex, uint uFlags, ref IntPtr phiconLarge,
ref IntPtr phiconSmall, uint nIconSize);
/// <summary>Provides a default handler to extract an icon from a file.</summary>
/// <param name="pszIconFile">A pointer to a null-terminated buffer that contains the path and name of the file from which the icon is extracted.</param>
/// <param name="iIndex">
/// The location of the icon within the file named in pszIconFile. If this is a positive number, it refers to the zero-based position of the icon in the
/// file. For instance, 0 refers to the 1st icon in the resource file and 2 refers to the 3rd. If this is a negative number, it refers to the icon's
/// resource ID.
/// </param>
/// <param name="uFlags">A flag that controls the icon extraction.</param>
/// <param name="phiconLarge">
/// A pointer to an HICON that, when this function returns successfully, receives the handle of the large version of the icon specified in the LOWORD of
/// nIconSize. This value can be NULL.
/// </param>
/// <param name="phiconSmall">
/// A pointer to an HICON that, when this function returns successfully, receives the handle of the small version of the icon specified in the HIWORD of nIconSize.
/// </param>
/// <param name="nIconSize">
/// A value that contains the large icon size in its LOWORD and the small icon size in its HIWORD. Size is measured in pixels. Pass 0 to specify default
/// large and small sizes.
/// </param>
[DllImport(Lib.Shell32, CharSet = CharSet.Auto)]
[PInvokeData("Shlobj.h", MSDNShortId = "bb762149")]
public static extern HRESULT SHDefExtractIcon(string pszIconFile, int iIndex, uint uFlags, IntPtr phiconLarge,
ref IntPtr phiconSmall, uint nIconSize);
/// <summary>Retrieves extended property data from a relative identifier list.</summary>
/// <param name="psf">
/// The address of the parent IShellFolder interface. This must be the immediate parent of the ITEMIDLIST structure referenced by the pidl parameter.
/// </param>
/// <param name="pidl">A pointer to an ITEMIDLIST structure that identifies the object relative to the folder specified in psf.</param>
/// <param name="nFormat">The format in which the data is being requested.</param>
/// <param name="pv">
/// A pointer to a buffer that, when this function returns successfully, receives the requested data. The format of this buffer is determined by nFormat.
/// <para>
/// If nFormat is SHGDFIL_NETRESOURCE, there are two possible cases. If the buffer is large enough, the net resource's string information (fields for the
/// network name, local name, provider, and comments) will be placed into the buffer. If the buffer is not large enough, only the net resource structure
/// will be placed into the buffer and the string information pointers will be NULL.
/// </para>
/// </param>
/// <param name="cb">Size of the buffer at pv, in bytes.</param>
/// <remarks>
/// This function extracts only information that is present in the pointer to an item identifier list (PIDL). Since the content of a PIDL depends on the
/// folder object that created the PIDL, there is no guarantee that all requested information will be available. In addition, the information that is
/// returned reflects the state of the object at the time the PIDL was created. The current state of the object could be different. For example, if you
/// set nFormat to SHGDFIL_FINDDATA, the function might assign meaningful values to only some of the members of the WIN32_FIND_DATA structure. The
/// remaining members will be set to zero. To retrieve complete current information on a file system file or folder, use standard file system functions
/// such as GetFileTime or FindFirstFile.
/// <para>
/// E_INVALIDARG is returned if the psf, pidl, pv, or cb parameter does not match the nFormat parameter, or if nFormat is not one of the specific
/// SHGDFIL_ values shown above.
/// </para>
/// </remarks>
[DllImport(Lib.Shell32, CharSet = CharSet.Auto)]
[SecurityCritical, SuppressUnmanagedCodeSecurity]
[PInvokeData("Shlobj.h", MSDNShortId = "bb762174")]
public static extern HRESULT SHGetDataFromIDList([In, MarshalAs(UnmanagedType.Interface)]
IShellFolder psf, [In] PIDL pidl, SHGetDataFormat nFormat, [In, Out] IntPtr pv, int cb);
/// <summary>Retrieves the IShellFolder interface for the desktop folder, which is the root of the Shell's namespace.</summary>
/// <param name="ppv">
/// When this method returns, receives an IShellFolder interface pointer for the desktop folder. The calling application is responsible for eventually
/// freeing the interface by calling its IUnknown::Release method.
/// </param>
/// <returns>If this function succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code.</returns>
[DllImport(Lib.Shell32, CharSet = CharSet.Unicode, ExactSpelling = true)]
[SecurityCritical, SuppressUnmanagedCodeSecurity]
[PInvokeData("Shlobj.h", MSDNShortId = "bb762175")]
public static extern HRESULT SHGetDesktopFolder([MarshalAs(UnmanagedType.Interface)] out IShellFolder ppv);
/// <summary>Deprecated. Retrieves the path of a folder as an ITEMIDLIST structure.</summary>
/// <param name="hwndOwner">Reserved.</param>
/// <param name="nFolder">
/// A CSIDL value that identifies the folder to be located. The folders associated with the CSIDLs might not exist on a particular system.
/// </param>
/// <param name="hToken">
/// An access token that can be used to represent a particular user. It is usually set to NULL, but it may be needed when there are multiple users for
/// those folders that are treated as belonging to a single user. The most commonly used folder of this type is My Documents. The calling application is
/// responsible for correct impersonation when hToken is non-NULL. It must have appropriate security privileges for the particular user, and the user's
/// registry hive must be currently mounted.
/// <para>
/// Assigning the hToken parameter a value of -1 indicates the Default User. This allows clients of SHGetFolderLocation to find folder locations (such as
/// the Desktop folder) for the Default User. The Default User user profile is duplicated when any new user account is created, and includes special
/// folders such as My Documents and Desktop. Any items added to the Default User folder also appear in any new user account.
/// </para>
/// </param>
/// <param name="dwReserved">Reserved.</param>
/// <param name="ppidl">
/// The address of a pointer to an item identifier list structure that specifies the folder's location relative to the root of the namespace (the
/// desktop). The ppidl parameter is set to NULL on failure. The calling application is responsible for freeing this resource by calling CoTaskMemFree.
/// </param>
[DllImport(Lib.Shell32, ExactSpelling = true)]
[PInvokeData("Shlobj.h", MSDNShortId = "bb762180")]
public static extern HRESULT SHGetFolderLocation(IntPtr hwndOwner, int nFolder, SafeTokenHandle hToken,
int dwReserved, out PIDL ppidl);
/// <summary>
/// Deprecated. Gets the path of a folder identified by a CSIDL value. <note>As of Windows Vista, this function is merely a wrapper for
/// SHGetKnownFolderPath. The CSIDL value is translated to its associated KNOWNFOLDERID and then SHGetKnownFolderPath is called. New applications should
/// use the known folder system rather than the older CSIDL system, which is supported only for backward compatibility.</note>
/// </summary>
/// <param name="hwndOwner">Reserved.</param>
/// <param name="nFolder">
/// A CSIDL value that identifies the folder whose path is to be retrieved. Only real folders are valid. If a virtual folder is specified, this function
/// fails. You can force creation of a folder by combining the folder's CSIDL with CSIDL_FLAG_CREATE.
/// </param>
/// <param name="hToken">
/// An access token that represents a particular user. If this parameter is NULL, which is the most common usage, the function requests the known folder
/// for the current user.
/// <para>
/// Request a specific user's folder by passing the hToken of that user. This is typically done in the context of a service that has sufficient
/// privileges to retrieve the token of a given user. That token must be opened with TOKEN_QUERY and TOKEN_IMPERSONATE rights. In some cases, you also
/// need to include TOKEN_DUPLICATE. In addition to passing the user's hToken, the registry hive of that specific user must be mounted. See Access
/// Control for further discussion of access control issues.
/// </para>
/// <para>
/// Assigning the hToken parameter a value of -1 indicates the Default User. This allows clients of SHGetKnownFolderPath to find folder locations (such
/// as the Desktop folder) for the Default User. The Default User user profile is duplicated when any new user account is created, and includes special
/// folders such as Documents and Desktop. Any items added to the Default User folder also appear in any new user account. Note that access to the
/// Default User folders requires administrator privileges.
/// </para>
/// </param>
/// <param name="dwFlags">
/// Flags that specify the path to be returned. This value is used in cases where the folder associated with a KNOWNFOLDERID (or CSIDL) can be moved,
/// renamed, redirected, or roamed across languages by a user or administrator.
/// <para>
/// The known folder system that underlies SHGetFolderPath allows users or administrators to redirect a known folder to a location that suits their
/// needs. This is achieved by calling IKnownFolderManager::Redirect, which sets the "current" value of the folder associated with the SHGFP_TYPE_CURRENT flag.
/// </para>
/// <para>
/// The default value of the folder, which is the location of the folder if a user or administrator had not redirected it elsewhere, is retrieved by
/// specifying the SHGFP_TYPE_DEFAULT flag. This value can be used to implement a "restore defaults" feature for a known folder.
/// </para>
/// <para>
/// For example, the default value (SHGFP_TYPE_DEFAULT) for FOLDERID_Music (CSIDL_MYMUSIC) is "C:\Users\user name\Music". If the folder was redirected,
/// the current value (SHGFP_TYPE_CURRENT) might be "D:\Music". If the folder has not been redirected, then SHGFP_TYPE_DEFAULT and SHGFP_TYPE_CURRENT
/// retrieve the same path.
/// </para>
/// </param>
/// <param name="pszPath">
/// A pointer to a null-terminated string of length MAX_PATH which will receive the path. If an error occurs or S_FALSE is returned, this string will be
/// empty. The returned path does not include a trailing backslash. For example, "C:\Users" is returned rather than "C:\Users\".
/// </param>
[DllImport(Lib.Shell32, CharSet = CharSet.Auto)]
[SecurityCritical, SuppressUnmanagedCodeSecurity]
[PInvokeData("Shlobj.h", MSDNShortId = "bb762181")]
public static extern HRESULT SHGetFolderPath(IntPtr hwndOwner, int nFolder, [In, Optional] SafeTokenHandle hToken,
SHGFP dwFlags, [Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszPath);
/// <summary>
/// Retrieves the full path of a known folder identified by the folder's KNOWNFOLDERID. This extends SHGetKnownFolderPath by allowing you to set the
/// initial size of the string buffer.
/// </summary>
/// <param name="rfid">A reference to the KNOWNFOLDERID that identifies the folder.</param>
/// <param name="dwFlags">Flags that specify special retrieval options. This value can be 0; otherwise, one or more of the KNOWN_FOLDER_FLAG values.</param>
/// <param name="hToken">
/// An access token that represents a particular user. If this parameter is NULL, which is the most common usage, the function requests the known folder
/// for the current user.
/// <para>
/// Request a specific user's folder by passing the hToken of that user. This is typically done in the context of a service that has sufficient
/// privileges to retrieve the token of a given user. That token must be opened with TOKEN_QUERY and TOKEN_IMPERSONATE rights. In some cases, you also
/// need to include TOKEN_DUPLICATE. In addition to passing the user's hToken, the registry hive of that specific user must be mounted. See Access
/// Control for further discussion of access control issues.
/// </para>
/// <para>
/// Assigning the hToken parameter a value of -1 indicates the Default User. This allows clients of SHGetKnownFolderPath to find folder locations (such
/// as the Desktop folder) for the Default User. The Default User user profile is duplicated when any new user account is created, and includes special
/// folders such as Documents and Desktop. Any items added to the Default User folder also appear in any new user account. Note that access to the
/// Default User folders requires administrator privileges.
/// </para>
/// </param>
/// <param name="pszPath">
/// A null-terminated, Unicode string. This buffer must be of size cchPath. When SHGetFolderPathEx returns successfully, this parameter contains the path
/// for the known folder.
/// </param>
/// <param name="cchPath">The size of the ppszPath buffer, in characters.</param>
[DllImport(Lib.Shell32, CharSet = CharSet.Unicode, ExactSpelling = true)]
[SecurityCritical, SuppressUnmanagedCodeSecurity]
[PInvokeData("Shlobj.h", MSDNShortId = "mt757093")]
public static extern HRESULT SHGetFolderPathEx([In, MarshalAs(UnmanagedType.LPStruct)]
Guid rfid, KNOWN_FOLDER_FLAG dwFlags, [In, Optional] SafeTokenHandle hToken,
[Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszPath, uint cchPath);
/// <summary>Retrieves the pointer to an item identifier list (PIDL) of an object.</summary>
/// <param name="iUnknown">A pointer to the IUnknown of the object from which to get the PIDL.</param>
/// <param name="ppidl">When this function returns, contains a pointer to the PIDL of the given object.</param>
[DllImport(Lib.Shell32, ExactSpelling = true)]
[PInvokeData("Shlobj.h", MSDNShortId = "bb762184")]
public static extern HRESULT SHGetIDListFromObject([MarshalAs(UnmanagedType.IUnknown)] object iUnknown,
out PIDL ppidl);
/// <summary>Retrieves an image list.</summary>
/// <param name="iImageList">The image type contained in the list.</param>
/// <param name="riid">Reference to the image list interface identifier, normally IID_IImageList.</param>
/// <param name="ppv">When this method returns, contains the interface pointer requested in riid. This is typically IImageList.</param>
[DllImport(Lib.Shell32, ExactSpelling = true)]
[PInvokeData("Shlobj.h", MSDNShortId = "bb762185")]
public static extern HRESULT SHGetImageList(SHIL iImageList, [MarshalAs(UnmanagedType.LPStruct)] Guid riid,
out IImageList ppv);
/// <summary>Retrieves the path of a known folder as an ITEMIDLIST structure.</summary>
/// <param name="rfid">
/// A reference to the KNOWNFOLDERID that identifies the folder. The folders associated with the known folder IDs might not exist on a particular system.
/// </param>
/// <param name="dwFlags">
/// Flags that specify special retrieval options. This value can be 0; otherwise, it is one or more of the KNOWN_FOLDER_FLAG values.
/// </param>
/// <param name="hToken">
/// An access token used to represent a particular user. This parameter is usually set to NULL, in which case the function tries to access the current
/// user's instance of the folder. However, you may need to assign a value to hToken for those folders that can have multiple users but are treated as
/// belonging to a single user. The most commonly used folder of this type is Documents.
/// <para>
/// The calling application is responsible for correct impersonation when hToken is non-null. It must have appropriate security privileges for the
/// particular user, including TOKEN_QUERY and TOKEN_IMPERSONATE, and the user's registry hive must be currently mounted. See Access Control for further
/// discussion of access control issues.
/// </para>
/// <para>
/// Assigning the hToken parameter a value of -1 indicates the Default User. This allows clients of SHGetKnownFolderIDList to find folder locations (such
/// as the Desktop folder) for the Default User. The Default User user profile is duplicated when any new user account is created, and includes special
/// folders such as Documents and Desktop. Any items added to the Default User folder also appear in any new user account. Note that access to the
/// Default User folders requires administrator privileges.
/// </para>
/// </param>
/// <param name="ppidl">
/// When this method returns, contains a pointer to the PIDL of the folder. This parameter is passed uninitialized. The caller is responsible for freeing
/// the returned PIDL when it is no longer needed by calling ILFree.
/// </param>
[DllImport(Lib.Shell32, ExactSpelling = true)]
[PInvokeData("Shlobj.h", MSDNShortId = "bb762187")]
public static extern HRESULT SHGetKnownFolderIDList([In, MarshalAs(UnmanagedType.LPStruct)]
Guid rfid, KNOWN_FOLDER_FLAG dwFlags, [In, Optional] SafeTokenHandle hToken, out PIDL ppidl);
/// <summary>Retrieves an IShellItem object that represents a known folder.</summary>
/// <param name="rfid">A reference to the KNOWNFOLDERID, a GUID that identifies the folder that contains the item.</param>
/// <param name="dwFlags">
/// Flags that specify special options used in the retrieval of the known folder IShellItem. This value can be KF_FLAG_DEFAULT; otherwise, one or more of
/// the KNOWN_FOLDER_FLAG values.
/// </param>
/// <param name="hToken">
/// An access token used to represent a particular user. This parameter is usually set to NULL, in which case the function tries to access the current
/// user's instance of the folder. However, you may need to assign a value to hToken for those folders that can have multiple users but are treated as
/// belonging to a single user. The most commonly used folder of this type is Documents.
/// <para>
/// The calling application is responsible for correct impersonation when hToken is non-null. It must have appropriate security privileges for the
/// particular user, including TOKEN_QUERY and TOKEN_IMPERSONATE, and the user's registry hive must be currently mounted. See Access Control for further
/// discussion of access control issues.
/// </para>
/// <para>
/// Assigning the hToken parameter a value of -1 indicates the Default User. This allows clients of SHGetKnownFolderIDList to find folder locations (such
/// as the Desktop folder) for the Default User. The Default User user profile is duplicated when any new user account is created, and includes special
/// folders such as Documents and Desktop. Any items added to the Default User folder also appear in any new user account. Note that access to the
/// Default User folders requires administrator privileges.
/// </para>
/// </param>
/// <param name="riid">A reference to the IID of the interface that represents the item, usually IID_IShellItem or IID_IShellItem2.</param>
/// <param name="ppv">When this method returns, contains the interface pointer requested in riid.</param>
[DllImport(Lib.Shell32, ExactSpelling = true)]
[PInvokeData("Shlobj.h", MSDNShortId = "dd378429")]
public static extern HRESULT SHGetKnownFolderItem([In, MarshalAs(UnmanagedType.LPStruct)]
Guid rfid, KNOWN_FOLDER_FLAG dwFlags, [In, Optional] SafeTokenHandle hToken,
[In, MarshalAs(UnmanagedType.LPStruct)]
Guid riid, [MarshalAs(UnmanagedType.Interface)] out object ppv);
/// <summary>Retrieves the full path of a known folder identified by the folder's KNOWNFOLDERID.</summary>
/// <param name="rfid">A reference to the KNOWNFOLDERID that identifies the folder.</param>
/// <param name="dwFlags">Flags that specify special retrieval options. This value can be 0; otherwise, one or more of the KNOWN_FOLDER_FLAG values.</param>
/// <param name="hToken">
/// An access token that represents a particular user. If this parameter is NULL, which is the most common usage, the function requests the known folder
/// for the current user.
/// <para>
/// Request a specific user's folder by passing the hToken of that user. This is typically done in the context of a service that has sufficient
/// privileges to retrieve the token of a given user. That token must be opened with TOKEN_QUERY and TOKEN_IMPERSONATE rights. In some cases, you also
/// need to include TOKEN_DUPLICATE. In addition to passing the user's hToken, the registry hive of that specific user must be mounted. See Access
/// Control for further discussion of access control issues.
/// </para>
/// <para>
/// Assigning the hToken parameter a value of -1 indicates the Default User. This allows clients of SHGetKnownFolderPath to find folder locations (such
/// as the Desktop folder) for the Default User. The Default User user profile is duplicated when any new user account is created, and includes special
/// folders such as Documents and Desktop. Any items added to the Default User folder also appear in any new user account. Note that access to the
/// Default User folders requires administrator privileges.
/// </para>
/// </param>
/// <param name="pszPath">
/// When this method returns, contains the address of a pointer to a null-terminated Unicode string that specifies the path of the known folder. The
/// calling process is responsible for freeing this resource once it is no longer needed by calling CoTaskMemFree. The returned path does not include a
/// trailing backslash. For example, "C:\Users" is returned rather than "C:\Users\".
/// </param>
/// <returns>Returns S_OK if successful, or an error value otherwise.</returns>
/// <remarks>This function replaces SHGetFolderPath. That older function is now simply a wrapper for SHGetKnownFolderPath.</remarks>
[DllImport(Lib.Shell32, ExactSpelling = true)]
[PInvokeData("Shlobj.h", MSDNShortId = "bb762188")]
public static extern HRESULT SHGetKnownFolderPath([MarshalAs(UnmanagedType.LPStruct)] Guid rfid,
KNOWN_FOLDER_FLAG dwFlags, [In, Optional] SafeTokenHandle hToken, out SafeCoTaskMemHandle pszPath);
/// <summary>Retrieves the full path of a known folder identified by the folder's KNOWNFOLDERID.</summary>
/// <param name="id">A reference to the KNOWNFOLDERID that identifies the folder.</param>
/// <param name="dwFlags">Flags that specify special retrieval options. This value can be 0; otherwise, one or more of the KNOWN_FOLDER_FLAG values.</param>
/// <param name="hToken">
/// An access token that represents a particular user. If this parameter is NULL, which is the most common usage, the function requests the known folder
/// for the current user.
/// <para>
/// Request a specific user's folder by passing the hToken of that user. This is typically done in the context of a service that has sufficient
/// privileges to retrieve the token of a given user. That token must be opened with TOKEN_QUERY and TOKEN_IMPERSONATE rights. In some cases, you also
/// need to include TOKEN_DUPLICATE. In addition to passing the user's hToken, the registry hive of that specific user must be mounted. See Access
/// Control for further discussion of access control issues.
/// </para>
/// <para>
/// Assigning the hToken parameter a value of -1 indicates the Default User. This allows clients of SHGetKnownFolderPath to find folder locations (such
/// as the Desktop folder) for the Default User. The Default User user profile is duplicated when any new user account is created, and includes special
/// folders such as Documents and Desktop. Any items added to the Default User folder also appear in any new user account. Note that access to the
/// Default User folders requires administrator privileges.
/// </para>
/// </param>
/// <returns>String that specifies the path of the known folder.</returns>
/// <remarks>This function replaces SHGetFolderPath. That older function is now simply a wrapper for SHGetKnownFolderPath.</remarks>
[PInvokeData("Shlobj.h", MSDNShortId = "bb762188")]
public static string SHGetKnownFolderPath(KNOWNFOLDERID id, KNOWN_FOLDER_FLAG dwFlags, SafeTokenHandle hToken = null)
{
SHGetKnownFolderPath(id.Guid(), dwFlags, hToken ?? SafeTokenHandle.Null, out SafeCoTaskMemHandle path);
return path.ToString(-1);
}
/// <summary>Retrieves the display name of an item identified by its IDList.</summary>
/// <param name="pidl">A PIDL that identifies the item.</param>
/// <param name="sigdnName">A value from the SIGDN enumeration that specifies the type of display name to retrieve.</param>
/// <param name="ppszName">A value that, when this function returns successfully, receives the address of a pointer to the retrieved display name.</param>
[DllImport(Lib.Shell32, ExactSpelling = true, CharSet = CharSet.Unicode)]
[PInvokeData("Shlobj.h", MSDNShortId = "bb762191")]
public static extern HRESULT SHGetNameFromIDList(PIDL pidl, SIGDN sigdnName, out SafeCoTaskMemHandle ppszName);
/// <summary>Converts an item identifier list to a file system path.</summary>
/// <param name="pidl">
/// The address of an item identifier list that specifies a file or directory location relative to the root of the namespace (the desktop).
/// </param>
/// <param name="pszPath">The address of a buffer to receive the file system path. This buffer must be at least MAX_PATH characters in size.</param>
/// <returns>Returns TRUE if successful; otherwise, FALSE.</returns>
[DllImport(Lib.Shell32, CharSet = CharSet.Auto)]
[return: MarshalAs(UnmanagedType.Bool)]
[PInvokeData("Shlobj.h", MSDNShortId = "bb762194")]
public static extern bool SHGetPathFromIDList(PIDL pidl, [MarshalAs(UnmanagedType.LPTStr)] StringBuilder pszPath);
/// <summary>Opens a Windows Explorer window with specified items in a particular folder selected.</summary>
/// <param name="pidlFolder">A pointer to a fully qualified item ID list that specifies the folder.</param>
/// <param name="cidl">
/// A count of items in the selection array, apidl. If cidl is zero, then pidlFolder must point to a fully specified ITEMIDLIST describing a single item
/// to select. This function opens the parent folder and selects that item.
/// </param>
/// <param name="apidl">A pointer to an array of PIDL structures, each of which is an item to select in the target folder referenced by pidlFolder.</param>
/// <param name="dwFlags">The optional flags. Under Windows XP this parameter is ignored. In Windows Vista, the following flags are defined.</param>
[DllImport(Lib.Shell32, ExactSpelling = true)]
[PInvokeData("Shlobj.h", MSDNShortId = "bb762232")]
public static extern HRESULT SHOpenFolderAndSelectItems(PIDL pidlFolder, uint cidl,
[In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] IntPtr[] apidl, OFASI dwFlags);
/// <summary>
/// Translates a Shell namespace object's display name into an item identifier list and returns the attributes of the object. This function is the
/// preferred method to convert a string to a pointer to an item identifier list (PIDL).
/// </summary>
/// <param name="pszName">A pointer to a zero-terminated wide string that contains the display name to parse.</param>
/// <param name="pbc">A bind context that controls the parsing operation. This parameter is normally set to NULL.</param>
/// <param name="ppidl">
/// The address of a pointer to a variable of type ITEMIDLIST that receives the item identifier list for the object. If an error occurs, then this
/// parameter is set to NULL.
/// </param>
/// <param name="sfgaoIn">
/// A ULONG value that specifies the attributes to query. To query for one or more attributes, initialize this parameter with the flags that represent
/// the attributes of interest. For a list of available SFGAO flags, see IShellFolder::GetAttributesOf.
/// </param>
/// <param name="psfgaoOut">
/// A pointer to a ULONG. On return, those attributes that are true for the object and were requested in sfgaoIn are set. An object's attribute flags can
/// be zero or a combination of SFGAO flags. For a list of available SFGAO flags, see IShellFolder::GetAttributesOf.
/// </param>
[DllImport(Lib.Shell32, CharSet = CharSet.Unicode, ExactSpelling = true)]
[PInvokeData("Shlobj.h", MSDNShortId = "bb762236")]
public static extern HRESULT SHParseDisplayName([MarshalAs(UnmanagedType.LPWStr)] string pszName,
[In, Optional] IntPtr pbc, out PIDL ppidl, SFGAO sfgaoIn, out SFGAO psfgaoOut);
/// <summary>
/// <para>
/// [CABINETSTATE is available for use in the operating systems specified in the Requirements section. It may be altered or
/// unavailable in subsequent versions.]
/// </para>
/// <para>
/// Holds the global configuration for Windows Explorer and Windows Internet Explorer. This structure is used in the ReadCabinetState
/// and WriteCabinetState functions.
/// </para>
/// </summary>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/ns-shlobj_core-cabinetstate
// typedef struct CABINETSTATE { WORD cLength; WORD nVersion; BOOL fFullPathTitle : 1; BOOL fSaveLocalView : 1; BOOL fNotShell : 1; BOOL fSimpleDefault : 1; BOOL fDontShowDescBar : 1; BOOL fNewWindowMode : 1; BOOL fShowCompColor : 1; BOOL fDontPrettyNames : 1; BOOL fAdminsCreateCommonGroups : 1; UINT fUnusedFlags : 7; UINT fMenuEnumFilter; } *LPCABINETSTATE;
[PInvokeData("shlobj_core.h", MSDNShortId = "4b82b6a8-c4c0-4af2-9612-0551376c1c62")]
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public struct CABINETSTATE
{
/// <summary><para>Type: <c>WORD</c></para><para>The size of the structure, in bytes.</para></summary>
public ushort cLength;
/// <summary><para>Type: <c>WORD</c></para></summary>
public ushort nVersion;
private ushort fFlags;
/// <summary><para>Type: <c>UINT</c></para><para>One or both of the following flags.</para><para>SHCONTF_FOLDERS</para><para>Display folders.</para><para>SHCONTF_NONFOLDERS</para><para>Display non-folder items.</para></summary>
public SHCONTF fMenuEnumFilter;
/// <summary><para>Type: <c>BOOL</c></para><para>TRUE</para><para>Display the full path in the title bar.</para><para>FALSE</para><para>Display only the file name in the title bar.</para></summary>
public bool fFullPathTitle { get => (fFlags & 1 << 0) != 0; set { if (value) fFlags |= 1 << 0; else { int i = fFlags; i &= ~(1 << 0); fFlags = (ushort)i; } } }
/// <summary><para>Type: <c>BOOL</c></para><para>TRUE</para><para>Remember each folder&#39;s view settings.</para><para>FALSE</para><para>Use global settings for all folders.</para></summary>
public bool fSaveLocalView { get => (fFlags & 1 << 1) != 0; set { if (value) fFlags |= 1 << 1; else { int i = fFlags; i &= ~(1 << 1); fFlags = (ushort)i; } } }
/// <summary><para>Type: <c>BOOL</c></para><para>Not used.</para></summary>
public bool fNotShell { get => (fFlags & 1 << 2) != 0; set { if (value) fFlags |= 1 << 2; else { int i = fFlags; i &= ~(1 << 2); fFlags = (ushort)i; } } }
/// <summary><para>Type: <c>BOOL</c></para><para>Not used.</para></summary>
public bool fSimpleDefault { get => (fFlags & 1 << 3) != 0; set { if (value) fFlags |= 1 << 3; else { int i = fFlags; i &= ~(1 << 3); fFlags = (ushort)i; } } }
/// <summary><para>Type: <c>BOOL</c></para><para>Not used.</para></summary>
public bool fDontShowDescBar { get => (fFlags & 1 << 4) != 0; set { if (value) fFlags |= 1 << 4; else { int i = fFlags; i &= ~(1 << 4); fFlags = (ushort)i; } } }
/// <summary><para>Type: <c>BOOL</c></para><para>TRUE</para><para>Display in a new window.</para><para>FALSE</para><para>Display in the current window.</para></summary>
public bool fNewWindowMode { get => (fFlags & 1 << 5) != 0; set { if (value) fFlags |= 1 << 5; else { int i = fFlags; i &= ~(1 << 5); fFlags = (ushort)i; } } }
/// <summary><para>Type: <c>BOOL</c></para><para>TRUE</para><para>Show encrypted or compressed NTFS files in color.</para><para>FALSE</para><para>Do not show encrypted or compressed NTFS files in color.</para></summary>
public bool fShowCompColor { get => (fFlags & 1 << 6) != 0; set { if (value) fFlags |= 1 << 6; else { int i = fFlags; i &= ~(1 << 6); fFlags = (ushort)i; } } }
/// <summary><para>Type: <c>BOOL</c></para><para>Not used.</para></summary>
public bool fDontPrettyNames { get => (fFlags & 1 << 7) != 0; set { if (value) fFlags |= 1 << 7; else { int i = fFlags; i &= ~(1 << 7); fFlags = (ushort)i; } } }
/// <summary><para>Type: <c>BOOL</c></para><para>Used when an administrator installs an application that places an icon in the <c>Start</c> menu.</para><para>TRUE</para><para>Add the icon to the <c>Start</c> menu for all users (CSIDL_COMMON_STARTMENU). This is the default value.</para><para>FALSE</para><para>Add the icon to only the current user (CSIDL_STARTMENU).</para></summary>
public bool fAdminsCreateCommonGroups { get => (fFlags & 1 << 8) != 0; set { if (value) fFlags |= 1 << 8; else { int i = fFlags; i &= ~(1 << 8); fFlags = (ushort)i; } } }
}
/// <summary>
/// Defines the coordinates of a character cell in a console screen buffer. The origin of the coordinate system (0,0) is at the top, left cell of the buffer.
/// </summary>
[PInvokeData("wincon.h")]
[StructLayout(LayoutKind.Sequential, Pack = 2)]
public struct COORD
{
/// <summary>The horizontal coordinate or column value. The units depend on the function call.</summary>
public short X;
/// <summary>The vertical coordinate or row value. The units depend on the function call.</summary>
public short Y;
}
/// <summary>Serves as the header for some of the extra data structures used by IShellLinkDataList.</summary>
[StructLayout(LayoutKind.Sequential, Pack = 4)]
[PInvokeData("Shlobj.h", MSDNShortId = "bb773249")]
public struct DATABLOCKHEADER
{
/// <summary>The size of the extra data block.</summary>
public uint cbSize;
/// <summary>A signature that identifies the type of data block that follows the header.</summary>
public ShellDataBlockSignature dwSignature;
}
/// <summary>Contains context menu information used by SHCreateDefaultContextMenu.</summary>
[StructLayout(LayoutKind.Sequential)]
[PInvokeData("shlobj_core.h")]
public struct DEFCONTEXTMENU
{
/// <summary>A handle to the context menu. Set this member to the handle returned from CreateMenu.</summary>
public IntPtr hwnd;
/// <summary>
/// A pointer to the IContextMenuCB interface supported by the callback object. This value is optional and can be NULL.
/// </summary>
public IContextMenuCB pcmcb;
/// <summary>
/// The PIDL of the folder that contains the selected file object(s) or the folder of the context menu if no file objects are
/// selected. This value is optional and can be NULL, in which case the PIDL is computed from the psf member.
/// </summary>
public IntPtr pidlFolder;
/// <summary>
/// A pointer to the IShellFolder interface of the folder object that contains the selected file objects, or the folder that
/// contains the context menu if no file objects are selected.
/// </summary>
public IShellFolder psf;
/// <summary>The count of items in member apidl.</summary>
public uint cidl;
/// <summary>
/// A pointer to a constant array of ITEMIDLIST structures. Each entry in the array describes a child item to which the context
/// menu applies, for instance, a selected file the user wants to Open.
/// </summary>
public IntPtr apidl;
/// <summary>
/// A pointer to the IQueryAssociations interface on the object from which to load extensions. This parameter is optional and
/// thus can be NULL. If this value is NULL and members aKeys and cKeys are also NULL (see Remarks), punkAssociationInfo is
/// computed from the apidl member and cidl via a request for IQueryAssociations through IShellFolder::GetUIObjectOf. If
/// IShellFolder::GetUIObjectOf returns E_NOTIMPL, a default implementation is provided based on the SFGAO_FOLDER and
/// SFGAO_FILESYSTEM attributes returned from IShellFolder::GetAttributesOf.
/// </summary>
public IQueryAssociations punkAssociationInfo;
/// <summary> The count of items in member aKeys. This value can be zero. If the value is zero, the extensions are loaded based
/// on the object that supports interface IQueryAssociations as specified by member punkAssociationInfo. If the value is
/// non-NULL, the extensions are loaded based only on member aKeys and not member punkAssociationInfo.
// Note The maximum number of keys is 16. Callers must enforce this limit as the API does not. Failing to do so can result in
// memory corruption.
/// </summary>
public uint cKeys;
/// <summary>
/// A pointer to an HKEY that specifies the registry key from which to load extensions. This parameter is optional and can be
/// NULL. If the value is NULL, the extensions are loaded based on the object that supports interface IQueryAssociations as
/// specified in punkAssociationInfo.
/// </summary>
public IntPtr aKeys;
}
/// <summary>Holds an extra data block used by IShellLinkDataList. It holds the link's Windows Installer ID.</summary>
[StructLayout(LayoutKind.Sequential, Pack = 4)]
[PInvokeData("Shlobj.h", MSDNShortId = "bb773274")]
public struct EXP_DARWIN_LINK
{
/// <summary>
/// DATABLOCK_HEADER structure stating the size and signature of the EXP_DARWIN_LINK structure. The following is the only recognized signature value: EXP_DARWIN_ID_SIG
/// </summary>
public DATABLOCKHEADER dbh;
/// <summary>The link's ID in the form of an ANSI string.</summary>
[MarshalAs(UnmanagedType.LPStr, SizeConst = MAX_PATH)]
public string szDarwinID;
/// <summary>The link's ID in the form of an Unicode string.</summary>
[MarshalAs(UnmanagedType.LPWStr, SizeConst = MAX_PATH)]
public string szwDarwinID;
}
/// <summary>Holds an extra data block used by IShellLinkDataList. It holds special folder information.</summary>
[StructLayout(LayoutKind.Sequential, Pack = 4)]
[PInvokeData("Shlobj.h", MSDNShortId = "bb773279")]
public struct EXP_SPECIAL_FOLDER
{
/// <summary>The size of the EXP_SPECIAL_FOLDER structure.</summary>
public uint cbSize;
/// <summary>The structure's signature. It should be set to EXP_SPECIAL_FOLDER_SIG.</summary>
public ShellDataBlockSignature dwSignature;
/// <summary>The ID of the special folder that the link points into.</summary>
public uint idSpecialFolder;
/// <summary>The offset into the saved PIDL.</summary>
public uint cbOffset;
}
/// <summary>Holds an extra data block used by IShellLinkDataList. It holds expandable environment strings for the icon or target.</summary>
[StructLayout(LayoutKind.Sequential, Pack = 4)]
[PInvokeData("Shlobj.h", MSDNShortId = "bb773282")]
public struct EXP_SZ_LINK
{
/// <summary>The size of the EXP_SZ_LINK structure.</summary>
public uint cbSize;
/// <summary>
/// The structure's signature. It can have one of the following values: EXP_SZ_LINK_SIG = Contains the link's target path; EXP_SZ_ICON_SIG = Contains
/// the links icon path.
/// </summary>
public ShellDataBlockSignature dwSignature;
/// <summary>The null-terminated ANSI string with the path of the target or icon.</summary>
[MarshalAs(UnmanagedType.LPStr, SizeConst = MAX_PATH)]
public string szTarget;
/// <summary>The null-terminated Unicode string with the path of the target or icon.</summary>
[MarshalAs(UnmanagedType.LPWStr, SizeConst = MAX_PATH)]
public string swzTarget;
}
/// <summary>Holds an extra data block used by IShellLinkDataList. It holds console properties.</summary>
[StructLayout(LayoutKind.Sequential, Pack = 2)]
[PInvokeData("Shlobj.h", MSDNShortId = "bb773359")]
public struct NT_CONSOLE_PROPS
{
/// <summary>
/// The DATABLOCK_HEADER structure with the NT_CONSOLE_PROPS structure's size and signature. The signature for an NT_CONSOLE_PROPS structure is NT_CONSOLE_PROPS_SIG.
/// </summary>
public DATABLOCKHEADER dbh;
/// <summary>Fill attribute for the console.</summary>
public ushort wFillAttribute;
/// <summary>Fill attribute for console pop-ups.</summary>
public ushort wPopupFillAttribute;
/// <summary>A COORD structure with the console's screen buffer size.</summary>
public COORD dwScreenBufferSize;
/// <summary>A COORD structure with the console's window size.</summary>
public COORD dwWindowSize;
/// <summary>A COORD structure with the console's window origin.</summary>
public COORD dwWindowOrigin;
/// <summary>The font.</summary>
public uint nFont;
/// <summary>The input buffer size.</summary>
public uint nInputBufferSize;
/// <summary>A COORD structure with the font size.</summary>
public COORD dwFontSize;
/// <summary>The font family/</summary>
public uint uFontFamily;
/// <summary>The font weight.</summary>
public uint uFontWeight;
/// <summary>A character array that contains the font's face name.</summary>
[MarshalAs(UnmanagedType.LPWStr, SizeConst = LF_FACESIZE)]
public string FaceName;
/// <summary>The cursor size.</summary>
public uint uCursorSize;
/// <summary>A boolean value that is set to TRUE if the console is in full-screen mode, or FALSE otherwise.</summary>
[MarshalAs(UnmanagedType.Bool)] public bool bFullScreen;
/// <summary>A boolean value that is set to TRUE if the console is in quick-edit mode, or FALSE otherwise.</summary>
[MarshalAs(UnmanagedType.Bool)] public bool bQuickEdit;
/// <summary>A boolean value that is set to TRUE if the console is in insert mode, or FALSE otherwise.</summary>
[MarshalAs(UnmanagedType.Bool)] public bool bInsertMode;
/// <summary>A boolean value that is set to TRUE if the console is in auto-position mode, or FALSE otherwise.</summary>
[MarshalAs(UnmanagedType.Bool)] public bool bAutoPosition;
/// <summary>The size of the history buffer.</summary>
public uint uHistoryBufferSize;
/// <summary>The number of history buffers.</summary>
public uint uNumberOfHistoryBuffers;
/// <summary>A boolean value that is set to TRUE if old duplicate history lists should be discarded, or FALSE otherwise.</summary>
[MarshalAs(UnmanagedType.Bool)] public bool bHistoryNoDup;
/// <summary>An array of COLORREF values with the console's color settings.</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
public uint[] ColorTable;
}
/// <summary>Holds an extra data block used by IShellLinkDataList. It holds the console's code page.</summary>
[StructLayout(LayoutKind.Sequential, Pack = 2)]
[PInvokeData("Shlobj.h", MSDNShortId = "bb773362")]
public struct NT_FE_CONSOLE_PROPS
{
/// <summary>
/// The DATABLOCK_HEADER structure with the NT_FE_CONSOLE_PROPS structure's size and signature. The signature for an NT_FE_CONSOLE_PROPS structure is NT_FE_CONSOLE_PROPS_SIG.
/// </summary>
public DATABLOCKHEADER dbh;
/// <summary>The console's code page.</summary>
public uint uCodePage;
}
/// <summary><para>This structure contains information from a .pif file. It is used by PifMgr_GetProperties.</para></summary>
// https://docs.microsoft.com/en-us/windows/desktop/api/shlobj_core/ns-shlobj_core-propprg
// typedef struct PROPPRG { WORD flPrg; WORD flPrgInit; CHAR achTitle[PIFNAMESIZE]; CHAR achCmdLine[PIFSTARTLOCSIZE + PIFPARAMSSIZE + 1]; CHAR achWorkDir[PIFDEFPATHSIZE]; WORD wHotKey; CHAR achIconFile[PIFDEFFILESIZE]; WORD wIconIndex; DWORD dwEnhModeFlags; DWORD dwRealModeFlags; CHAR achOtherFile[PIFDEFFILESIZE]; CHAR achPIFFile[PIFMAXFILEPATH]; };
[PInvokeData("shlobj_core.h", MSDNShortId = "603f990b-efb8-4d72-bc96-27bda4ffcbd8")]
[StructLayout(LayoutKind.Sequential)]
public struct PROPPRG
{
private const int PIFNAMESIZE = 30;
private const int PIFSTARTLOCSIZE = 63;
private const int PIFDEFPATHSIZE = 64;
private const int PIFPARAMSSIZE = 64;
private const int PIFSHPROGSIZE = 64;
private const int PIFSHDATASIZE = 64;
private const int PIFDEFFILESIZE = 80;
private const int PIFMAXFILEPATH = 260;
/// <summary><para>Type: <c>WORD</c></para><para>Flags that describe how the program will run.</para><para>PRG_DEFAULT</para><para>Use the default options.</para><para>PRG_CLOSEONEXIT</para><para>Close the application on exit.</para></summary>
public ushort flPrg;
/// <summary><para>Type: <c>WORD</c></para><para>Flags that specify the initial conditions for the application.</para><para>PRGINIT_DEFAULT</para><para>Use the default options.</para><para>PRGINIT_MINIMIZED</para><para>The application should be minimized.</para><para>PRGINIT_MAXIMIZED</para><para>The application should be maximized.</para><para>PRGINIT_REALMODE</para><para>The application should run in real mode.</para><para>PRGINIT_REALMODESILENT</para><para>The application should run in real mode without being prompted.</para><para>PRGINIT_AMBIGUOUSPIF</para><para>The data is ambiguous.</para><para>PRGINIT_NOPIF</para><para>No .pif file was found.</para><para>PRGINIT_DEFAULTPIF</para><para>A default .pif was found.</para><para>PRGINIT_INFSETTINGS</para><para>A .inf file was found.</para><para>PRGINIT_INHIBITPIF</para><para>The .inf file indicates that a .pif file should not be created.</para></summary>
public ushort flPrgInit;
/// <summary><para>Type: <c>__wchar_t</c></para><para>A null-terminated string that contains the title.</para></summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = PIFNAMESIZE)]
public byte[] achTitle;
/// <summary><para>Type: <c>__wchar_t</c></para><para>A null-terminated string that contains the command line, including arguments.</para></summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = PIFSTARTLOCSIZE + PIFPARAMSSIZE + 1)]
public byte[] achCmdLine;
/// <summary><para>Type: <c>__wchar_t</c></para><para>A null-terminated string that contains the working directory.</para></summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = PIFDEFPATHSIZE)]
public byte[] achWorkDir;
/// <summary><para>Type: <c>WORD</c></para><para>The key code of the .pif file&#39;s hotkey.</para></summary>
public ushort wHotKey;
/// <summary><para>Type: <c>__wchar_t</c></para><para>A null-terminated string that contains the name of the file that contains the icon.</para></summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = PIFDEFFILESIZE)]
public byte[] achIconFile;
/// <summary><para>Type: <c>WORD</c></para><para>The index of the icon in the file specified by <c>achIconFile</c>.</para></summary>
public ushort wIconIndex;
/// <summary><para>Type: <c>DWORD</c></para><para>Reserved.</para></summary>
public uint dwEnhModeFlags;
/// <summary><para>Type: <c>DWORD</c></para><para>Flags that specify the real mode options.</para><para>RMOPT_MOUSE</para><para>Requires a real-mode mouse.</para><para>RMOPT_EMS</para><para>Requires expanded memory.</para><para>RMOPT_CDROM</para><para>Requires CD-ROM support.</para><para>RMOPT_NETWORK</para><para>Requires network support.</para><para>RMOPT_DISKLOCK</para><para>Requires disk locking.</para><para>RMOPT_PRIVATECFG</para><para>Use a private config.sys or autoexec.bat file.</para><para>RMOPT_VESA</para><para>Requires a VESA driver.</para></summary>
public uint dwRealModeFlags;
/// <summary><para>Type: <c>__wchar_t</c></para><para>A null-terminated string that contains the name of the &quot;other&quot; file in the directory.</para></summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = PIFDEFFILESIZE)]
public byte[] achOtherFile;
/// <summary><para>Type: <c>__wchar_t</c></para><para>A null-terminated string that contains the name of the .pif file in the directory.</para></summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = PIFMAXFILEPATH)]
public byte[] achPIFFile;
}
/// <summary>This structure is used with the SHCreateShellFolderView function.</summary>
[StructLayout(LayoutKind.Sequential)]
[PInvokeData("Shlobj.h")]
public struct SFV_CREATE
{
/// <summary>The size of the SFV_CREATE structure, in bytes.</summary>
public uint cbSize;
/// <summary>The IShellFolder interface of the folder for which to create the view.</summary>
public IShellFolder pshf;
/// <summary>
/// A pointer to the parent IShellView interface. This parameter may be NULL. This parameter is used only when the view created by
/// SHCreateShellFolderView is hosted in a common dialog box.
/// </summary>
public IShellView psvOuter;
/// <summary>
/// A pointer to the IShellFolderViewCB interface that handles the view's callbacks when various events occur. This parameter may be NULL.
/// </summary>
public IShellFolderViewCB psfvcb;
}
/// <summary>Receives item data in response to a call to SHGetDataFromIDList.</summary>
[StructLayout(LayoutKind.Sequential)]
[PInvokeData("Shlobj.h", MSDNShortId = "bb759775")]
public struct SHDESCRIPTIONID
{
/// <summary>Receives a value that determines what type the item is.</summary>
public SHDID dwDescriptionId;
/// <summary>Receives the CLSID of the object to which the item belongs.</summary>
public Guid clsid;
}
/*[StructLayout(LayoutKind.Sequential)]
[PInvokeData("Shlobj.h", MSDNShortId = "bb773399")]
public struct SFV_CREATE
{
public uint cbSize;
[MarshalAs(UnmanagedType.Interface)] public IShellFolder pshf;
[MarshalAs(UnmanagedType.Interface)] public IShellView psvOuter;
[MarshalAs(UnmanagedType.Interface)] public IShellFolderViewCB psfbcb;
}*/
}
}
Reference in New Issue View Git Blame Copy Permalink