/// <summary> /// Load the library using a number of options /// </summary> /// <param name="libraryName">The name of the library</param> /// <param name="isReadOnly">If <B>true</B>, loads the library in read-only mode.</param> /// <returns>A ShellLibrary Object</returns> public static ShellLibrary Load(string libraryName, bool isReadOnly) { CoreHelpers.ThrowIfNotWin7(); IKnownFolder kf = KnownFolders.Libraries; string librariesFolderPath = (kf != null) ? kf.Path : string.Empty; Guid guid = new Guid(ShellIIDGuid.IShellItem); string shellItemPath = System.IO.Path.Combine(librariesFolderPath, libraryName + FileExtension); int hr = ShellNativeMethods.SHCreateItemFromParsingName(shellItemPath, IntPtr.Zero, ref guid, out IShellItem nativeShellItem); if (!CoreErrorHelper.Succeeded(hr)) { throw new ShellException(hr); } INativeShellLibrary nativeShellLibrary = (INativeShellLibrary) new ShellLibraryCoClass(); AccessModes flags = isReadOnly ? AccessModes.Read : AccessModes.ReadWrite; nativeShellLibrary.LoadLibraryFromItem(nativeShellItem, flags); ShellLibrary library = new ShellLibrary(nativeShellLibrary); try { library.nativeShellItem = (IShellItem2)nativeShellItem; library.Name = libraryName; return(library); } catch { library.Dispose(); throw; } }
private void UpdateProperties(IKnownFolder folder) { // TODO - Make XAML only // There is currently no way to get all the KnownFolder properties in a collection // that can be use for binding to a listbox. Create our own properties collection with name/value pairs Collection<KnownFolderProperty> properties = new Collection<KnownFolderProperty>(); properties.Add(new KnownFolderProperty { Property = "Canonical Name", Value = folder.CanonicalName }); properties.Add(new KnownFolderProperty { Property = "Category", Value = folder.Category }); properties.Add(new KnownFolderProperty { Property = "Definition Options", Value = folder.DefinitionOptions }); properties.Add(new KnownFolderProperty { Property = "Description", Value = folder.Description }); properties.Add(new KnownFolderProperty { Property = "File Attributes", Value = folder.FileAttributes }); properties.Add(new KnownFolderProperty { Property = "Folder Id", Value = folder.FolderId }); properties.Add(new KnownFolderProperty { Property = "Folder Type", Value = folder.FolderType }); properties.Add(new KnownFolderProperty { Property = "Folder Type Id", Value = folder.FolderTypeId }); properties.Add(new KnownFolderProperty { Property = "Localized Name", Value = folder.LocalizedName }); properties.Add(new KnownFolderProperty { Property = "Localized Name Resource Id", Value = folder.LocalizedNameResourceId }); properties.Add(new KnownFolderProperty { Property = "Parent Id", Value = folder.ParentId }); properties.Add(new KnownFolderProperty { Property = "ParsingName", Value = folder.ParsingName }); properties.Add(new KnownFolderProperty { Property = "Path", Value = folder.Path }); properties.Add(new KnownFolderProperty { Property = "Relative Path", Value = folder.RelativePath }); properties.Add(new KnownFolderProperty { Property = "Redirection", Value = folder.Redirection }); properties.Add(new KnownFolderProperty { Property = "Security", Value = folder.Security }); properties.Add(new KnownFolderProperty { Property = "Tooltip", Value = folder.Tooltip }); properties.Add(new KnownFolderProperty { Property = "Tooltip Resource Id", Value = folder.TooltipResourceId }); // Bind the collection to the properties listbox. PropertiesListBox.ItemsSource = properties; }
/// <summary> /// パス情報を初期化します。 /// </summary> /// <param name="knownFolderInterface"></param> private void InitializePath(IKnownFolder knownFolderInterface) { Contract.Requires(knownFolderInterface != null); this.Path = String.Empty; if (this.Category == KnownFolderCategories.Virtual) { this.PathExists = false; } else { try { this.Path = knownFolderInterface.GetPath(0); this.PathExists = true; } catch (FileNotFoundException) { this.PathExists = false; } catch (DirectoryNotFoundException) { this.PathExists = false; } } }
/// <summary> /// <see cref="KNOWNFOLDER_DEFINITION" />を取得し、 /// 各プロパティを初期化します。 /// </summary> /// <param name="knownFolderInterface"></param> private void Initialize(IKnownFolder knownFolderInterface) { Contract.Requires(knownFolderInterface != null); KNOWNFOLDER_DEFINITION knownFolderDefinition; knownFolderInterface.GetFolderDefinition(out knownFolderDefinition); try { this.ParsingName = PtrToString(knownFolderDefinition.pszParsingName); this.CanonicalName = PtrToString(knownFolderDefinition.pszName); this.Category = (KnownFolderCategories)knownFolderDefinition.category; this.Description = PtrToString(knownFolderDefinition.pszDescription); this.ParentId = knownFolderDefinition.fidParent; this.RelativePath = PtrToString(knownFolderDefinition.pszRelativePath); InitializeResourceProperties(knownFolderDefinition); this.FolderDefinitionFlags = (FolderDefinitionFlags)knownFolderDefinition.kfdFlags; this.FileAttributes = (FileAttributes)knownFolderDefinition.dwAttributes; this.FolderTypeId = knownFolderDefinition.ftidType; this.FolderType = String.Empty; this.FolderId = knownFolderInterface.GetId(); InitializePath(knownFolderInterface); this.Redirection = (RedirectionCapability)knownFolderInterface.GetRedirectionCapabilities(); this.Security = PtrToString(knownFolderDefinition.pszSecurity); } finally { ShellNativeMethods.FreeKnownFolderDefinitionFields(ref knownFolderDefinition); } }
/// <summary> /// Creates a shell library in the Libraries Known Folder, /// using the given IKnownFolder /// </summary> /// <param name="sourceKnownFolder">KnownFolder from which to create the new Shell Library</param> /// <param name="isReadOnly">If <B>true</B> , opens the library in read-only mode.</param> private ShellLibrary(IKnownFolder sourceKnownFolder, bool isReadOnly) : this() { Debug.Assert(sourceKnownFolder != null); // Keep a reference locally knownFolder = sourceKnownFolder; nativeShellLibrary = (INativeShellLibrary) new ShellLibraryCoClass(); AccessModes flags = isReadOnly ? AccessModes.Read : AccessModes.ReadWrite; // Get the IShellItem2 base.nativeShellItem = ((ShellObject)sourceKnownFolder).NativeShellItem2; Guid guid = sourceKnownFolder.FolderId; // Load the library from the IShellItem2 try { nativeShellLibrary.LoadLibraryFromKnownFolder(ref guid, flags); } catch (InvalidCastException) { throw new ArgumentException(LocalizedMessages.ShellLibraryInvalidLibrary, "sourceKnownFolder"); } catch (NotImplementedException) { throw new ArgumentException(LocalizedMessages.ShellLibraryInvalidLibrary, "sourceKnownFolder"); } }
public void VerifyDefaultFoldersInAllCollection() { ICollection<IKnownFolder> folders = KnownFolders.All; PropertyInfo[] properties = typeof(KnownFolders).GetProperties(BindingFlags.Static | BindingFlags.Public); foreach (PropertyInfo info in properties) { if (info.PropertyType == typeof(IKnownFolder)) { IKnownFolder kf = null; try { //if an exception is thrown, the known folder does not exist on the computer. kf = (IKnownFolder)info.GetValue(null, null); } catch { continue; } Assert.Contains(folders, x => kf.FolderId == x.FolderId); } } }
public void KnownFolder_GetRedirectionCaps() { IKnownFolderManager manager = ShellDesktopMethods.GetKnownFolderManager(); IKnownFolder folder = manager.GetFolder(KNOWNFOLDERID.Libraries); folder.GetRedirectionCapabilities().Should().Be(KF_REDIRECTION_CAPABILITIES.REDIRECTABLE); }
/// <summary> /// Creates a shell library in the Libraries Known Folder, /// using the given IKnownFolder /// </summary> /// <param name="sourceKnownFolder">KnownFolder from which to create the new Shell Library</param> /// <param name="isReadOnly">If <B>true</B> , opens the library in read-only mode.</param> private ShellLibrary(IKnownFolder sourceKnownFolder, bool isReadOnly) { CoreHelpers.ThrowIfNotWin7(); Debug.Assert(sourceKnownFolder != null); // Keep a reference locally knownFolder = sourceKnownFolder; nativeShellLibrary = (INativeShellLibrary) new ShellLibraryCoClass(); ShellNativeMethods.STGM flags = isReadOnly ? ShellNativeMethods.STGM.Read : ShellNativeMethods.STGM.ReadWrite; // Get the IShellItem2 base.nativeShellItem = ((ShellObject)sourceKnownFolder).NativeShellItem2; Guid guid = sourceKnownFolder.FolderId; // Load the library from the IShellItem2 try { nativeShellLibrary.LoadLibraryFromKnownFolder(ref guid, flags); } catch (InvalidCastException) { throw new ArgumentException("The given known folder is not a valid library.", "sourceKnownFolder"); } catch (NotImplementedException) { throw new ArgumentException("The given known folder is not a valid library.", "sourceKnownFolder"); } }
/// <summary> /// Returns a known folder given a globally unique identifier. /// </summary> /// <param name="knownFolderId">A GUID for the requested known folder.</param> /// <returns>A known folder representing the specified name.</returns> /// <exception cref="System.ArgumentException">Thrown if the given Known Folder ID is invalid.</exception> public static IKnownFolder FromKnownFolderId(Guid knownFolderId) { IKnownFolderNative knownFolderNative; IKnownFolderManager knownFolderManager = (IKnownFolderManager) new KnownFolderManagerClass(); HRESULT hr = knownFolderManager.GetFolder(knownFolderId, out knownFolderNative); if (hr == HRESULT.S_OK) { IKnownFolder kf = GetKnownFolder(knownFolderNative); if (kf != null) { return(kf); } else { throw new ArgumentException("Given Known Folder ID is invalid.", "knownFolderId"); } } else { throw Marshal.GetExceptionForHR((int)hr); } }
public void KnownFolder_GetCategory() { IKnownFolderManager manager = ShellDesktopMethods.GetKnownFolderManager(); IKnownFolder folder = manager.GetFolder(KNOWNFOLDERID.Windows); folder.GetCategory().Should().Be(KF_CATEGORY.FIXED); }
public void KnownFolderManager_GetKnownFolder() { IKnownFolderManager manager = ShellMethods.GetKnownFolderManager(); IKnownFolder folder = manager.GetFolder(KNOWNFOLDERID.Windows); folder.Should().NotBeNull(); }
public void KnownFolder_GetRedirectionCaps() { IKnownFolderManager manager = ShellMethods.GetKnownFolderManager(); IKnownFolder folder = manager.GetFolder(KnownFolderIds.Libraries); folder.GetRedirectionCapabilities().Should().Be(KnownFolderRedirectionCapabilities.Redirectable); }
public void KnownFolder_GetId() { IKnownFolderManager manager = ShellDesktopMethods.GetKnownFolderManager(); IKnownFolder folder = manager.GetFolder(KNOWNFOLDERID.Windows); folder.GetId().Should().Be(KNOWNFOLDERID.Windows); }
private void navigateButton_Click(object sender, EventArgs e) { if (this.pathEdit.Text.Value.StartsWith("::{")) { try { IKnownFolder kf = KnownFolderHelper.FromParsingName(this.pathEdit.Text.Value); this.explorerBrowser.Navigate((ShellObject)kf); } catch { logError("Navigation not possible. Failed to retrieve known folder."); } return; } if (!this.pathEdit.Items.Contains(this.pathEdit.Text.Value)) { NavigateToFolderOrArchive(this.pathEdit.Text.Value); } else { NavigateToSpecialFolder(this.pathEdit.Text.Value); } }
/// <summary> /// Load the library using a number of options /// </summary> /// <param name="sourceKnownFolder">A known folder.</param> /// <param name="isReadOnly">If <B>true</B>, opens the library in read-only mode.</param> /// <returns>A ShellLibrary Object</returns> public static ShellLibrary Load( IKnownFolder sourceKnownFolder, bool isReadOnly) { CoreHelpers.ThrowIfNotWin7(); return(new ShellLibrary(sourceKnownFolder, isReadOnly)); }
public void KnownFolder_GetCategory() { IKnownFolderManager manager = ShellMethods.GetKnownFolderManager(); IKnownFolder folder = manager.GetFolder(KnownFolderIds.Windows); folder.GetCategory().Should().Be(KnownFolderCategory.Fixed); }
public void ShellItem_GetDisplayName() { IKnownFolderManager manager = ShellMethods.GetKnownFolderManager(); IKnownFolder folder = manager.GetFolder(KnownFolderIds.Windows); IShellItem item = folder.GetShellItem(0, new Guid(InterfaceIds.IID_IShellItem)); item.GetDisplayName(ShellItemDisplayNames.NormalDisplay).Should().Be("Windows"); }
public void ShellItem_GetDisplayName() { IKnownFolderManager manager = ShellDesktopMethods.GetKnownFolderManager(); IKnownFolder folder = manager.GetFolder(KNOWNFOLDERID.Windows); IShellItem item = folder.GetShellItem(0, new Guid(InterfaceIds.IID_IShellItem)); item.GetDisplayName(SIGDN.NORMALDISPLAY).Should().Be("Windows"); }
public void Dispose() { if (_knownFolder != null) { Marshal.ReleaseComObject(_knownFolder); _knownFolder = null; } }
public void KnownFolder_GetFolderType() { // Most known folders don't have a FolderType associated and will throw a COMException with E_FAIL. IKnownFolderManager manager = ShellDesktopMethods.GetKnownFolderManager(); IKnownFolder folder = manager.GetFolder(KNOWNFOLDERID.Contacts); folder.GetFolderType().Should().Be(FOLDERTYPEID.Contacts); }
internal KnownFolderDefinition(IKnownFolder nativeKnownFolder) { if (nativeKnownFolder == null) { throw new ArgumentNullException("nativeKnownFolder"); } this.nativeDefinition = KNOWNFOLDER_DEFINITION.FromKnownFolder(nativeKnownFolder); }
/// <summary> /// Returns a known folder given its shell namespace parsing name, such as /// <c>::{645FF040-5081-101B-9F08-00AA002F954E}</c> for the Recycle Bin. /// </summary> /// <param name="parsingName">The parsing name (or path) for the requested known folder.</param> /// <returns>A known folder representing the specified name.</returns> /// <exception cref="System.ArgumentException">Thrown if the given parsing name is invalid.</exception> public static IKnownFolder FromParsingName(string parsingName) { if (parsingName == null) { throw new ArgumentNullException(nameof(parsingName)); } IntPtr pidl = IntPtr.Zero; IntPtr pidl2 = IntPtr.Zero; try { pidl = ShellHelper.PidlFromParsingName(parsingName); if (pidl == IntPtr.Zero) { throw new ArgumentException(LocalizedMessages.KnownFolderParsingName, nameof(parsingName)); } // It's probably a special folder, try to get it IKnownFolderNative knownFolderNative = KnownFolderHelper.FromPIDL(pidl); if (knownFolderNative != null) { IKnownFolder kf = KnownFolderHelper.GetKnownFolder(knownFolderNative); if (kf == null) { throw new ArgumentException(LocalizedMessages.KnownFolderParsingName, nameof(parsingName)); } return(kf); } // No physical storage was found for this known folder // We'll try again with a different name // try one more time with a trailing \0 pidl2 = ShellHelper.PidlFromParsingName(parsingName.PadRight(1, '\0')); if (pidl2 == IntPtr.Zero) { throw new ArgumentException(LocalizedMessages.KnownFolderParsingName, nameof(parsingName)); } IKnownFolder kf2 = KnownFolderHelper.GetKnownFolder(KnownFolderHelper.FromPIDL(pidl)); if (kf2 == null) { throw new ArgumentException(LocalizedMessages.KnownFolderParsingName, nameof(parsingName)); } return(kf2); } finally { ShellNativeMethods.ILFree(pidl); ShellNativeMethods.ILFree(pidl2); } }
internal KnownFolder(IKnownFolder nativeKnownFolder) { if (nativeKnownFolder == null) { throw new ArgumentNullException("nativeKnownFolder"); } this.nativeKnownFolder = nativeKnownFolder; }
/// <summary> /// Initialize a new instance of the <see cref="ShellKnownFolder" /> class /// to the specified <see cref="ShellItem" />, <see cref="IKnownFolder" /> and <see cref="FolderProperties" />. /// </summary> /// <param name="shellItem"><see cref="ShellItem" />.</param> /// <param name="knownFolderInterface"><see cref="IKnownFolder" />.</param> /// <exception cref="ArgumentNullException"> /// <para> /// <paramref name="=shellItem" /> is a <c>null</c> reference. /// </para> /// or /// <para> /// <paramref name="knownFolderInterface" /> is a <c>null</c> reference. /// </para> /// </exception> internal ShellKnownFolder(ShellItem shellItem, IKnownFolder knownFolderInterface) : base(shellItem) { Contract.Requires <ArgumentNullException>(shellItem != null); Contract.Requires <ArgumentNullException>(knownFolderInterface != null); this.KnownFolderInterface = knownFolderInterface; this.KnownFolderProperties = new FolderProperties(knownFolderInterface); }
/* * /// <summary> * /// Returns a URI representation of the <see cref="ShellItem"/>. * /// </summary> * public Uri ToUri() { * return this.ParsingName.StartsWith("::") ? new Uri("shell:///" + this.ParsingName) : new Uri(this.FileSystemPath); * StringBuilder path = new StringBuilder("shell:///"); * * if (this.ParsingName.StartsWith("::")) { * path.Append(this.ParsingName); * return new Uri(path.ToString()); * } * return new Uri(this.FileSystemPath); * } */ private void Initialize(Uri uri) { if (uri.Scheme == "file") { ComInterface = CreateItemFromParsingName(uri.LocalPath); } else if (uri.Scheme == "shell") { //InitializeFromShellUri(uri); //TO_DO: add shell folders handling here //KnownFolderManager manager = new KnownFolderManager(); string path = uri.GetComponents(UriComponents.Path, UriFormat.Unescaped); string knownFolder; string restOfPath; int separatorIndex = path.IndexOf('/'); if (separatorIndex != -1) { knownFolder = path.Substring(0, separatorIndex); restOfPath = path.Substring(separatorIndex + 1); } else { knownFolder = path; restOfPath = string.Empty; } try { IKnownFolder knownFolderI = KnownFolderHelper.FromParsingName(knownFolder); if (knownFolderI != null) { ComInterface = (knownFolderI as ShellItem).ComInterface; } else if (knownFolder.StartsWith(KnownFolders.Libraries.ParsingName)) { var lib = ShellLibrary.Load(Path.GetFileNameWithoutExtension(knownFolder), true); if (lib != null) { ComInterface = lib.ComInterface; } } } catch { } if (restOfPath != string.Empty) { ComInterface = this[restOfPath.Replace('/', '\\')].ComInterface; } } else { throw new InvalidOperationException("Invalid URI scheme"); } }
/// <summary> /// Shows the library management dialog which enables users to mange the library folders and default save location. /// </summary> /// <param name="sourceKnownFolder">A known folder.</param> /// <param name="windowHandle">The parent window,or IntPtr.Zero for no parent</param> /// <param name="title">A title for the library management dialog, or null to use the library name as the title</param> /// <param name="instruction">An optional help string to display for the library management dialog</param> /// <param name="allowAllLocations">If true, do not show warning dialogs about locations that cannot be indexed</param> /// <remarks>If the library is already open in read-write mode, the dialog will not save the changes.</remarks> public static void ShowManageLibraryUI(IKnownFolder sourceKnownFolder, IntPtr windowHandle, string title, string instruction, bool allowAllLocations) { // this method is not safe for MTA consumption and will blow // Access Violations if called from an MTA thread so we wrap this // call up into a Worker thread that performs all operations in a // single threaded apartment using (ShellLibrary shellLibrary = ShellLibrary.Load(sourceKnownFolder, true)) { ShowManageLibraryUI(shellLibrary, windowHandle, title, instruction, allowAllLocations); } }
/// <summary> /// Load the library using a number of options /// </summary> /// <param name="libraryName">The name of the library</param> /// <param name="isReadOnly">If <B>true</B>, loads the library in read-only mode.</param> /// <returns>A ShellLibrary Object</returns> public static ShellLibrary Load(string libraryName, bool isReadOnly) { IKnownFolder kf = KnownFolders.Libraries; string librariesFolderPath = kf != null ? kf.Path : string.Empty; var guid = new Guid(InterfaceGuids.IShellItem); string shellItemPath = System.IO.Path.Combine(librariesFolderPath, libraryName + FileExtension); IShellItem nativeShellItem = Shell32.SHCreateItemFromParsingName(shellItemPath, IntPtr.Zero, guid); return(Load_Helper(nativeShellItem, libraryName, isReadOnly)); }
void NavigateExplorerBrowser(object sender, SelectionChangedEventArgs args) { IKnownFolder folder = (IKnownFolder)((ListBox)sender).SelectedItem; if (folder == null) { folder = (IKnownFolder)ShellFileSystemFolder.FromParsingName(KnownFolders.Desktop.ParsingName); } UpdateProperties(folder); }
public void KnownFolder_GetIShellItem() { IKnownFolderManager manager = ShellDesktopMethods.GetKnownFolderManager(); IKnownFolder folder = manager.GetFolder(KNOWNFOLDERID.Windows); IShellItem item = folder.GetShellItem(0, new Guid(InterfaceIds.IID_IShellItem)); item.Should().NotBeNull(); IShellItem2 item2 = (IShellItem2)folder.GetShellItem(0, new Guid(InterfaceIds.IID_IShellItem2)); item2.Should().NotBeNull(); }
public void KnownFolder_GetIdList() { IKnownFolderManager manager = ShellMethods.GetKnownFolderManager(); IKnownFolder folder = manager.GetFolder(KnownFolderIds.Windows); using (var id = folder.GetIDList(0)) { id.IsInvalid.Should().BeFalse(); ShellMethods.GetNameFromId(id, ShellItemDisplayNames.ParentRelative).Should().Be("Windows"); } }
public void KnownFolder_GetIdList() { IKnownFolderManager manager = ShellDesktopMethods.GetKnownFolderManager(); IKnownFolder folder = manager.GetFolder(KNOWNFOLDERID.Windows); using (var id = folder.GetIDList(0)) { id.IsInvalid.Should().BeFalse(); ShellDesktopMethods.GetNameFromId(id, SIGDN.PARENTRELATIVE).Should().Be("Windows"); } }
public static KNOWNFOLDER_DEFINITION FromKnownFolder(IKnownFolder knownFolder) { if (knownFolder == null) { throw new ArgumentNullException("knownFolder"); } KNOWNFOLDER_DEFINITION def; using (var handles = new KnownFolderDefinitionHandles()) { KNOWNFOLDER_DEFINITION_RAW rawDef; RuntimeHelpers.PrepareConstrainedRegions(); try { } finally { knownFolder.GetFolderDefinition(out rawDef); try { handles.SecureHandles(ref rawDef); } finally { // in case SecureHandles throws rawDef.FreeKnownFolderDefinitionFields(); } } def = new KNOWNFOLDER_DEFINITION(ref rawDef, handles); } return def; }
public void FromCanonicalNameTest(IKnownFolder folder) { IKnownFolder test = KnownFolderHelper.FromCanonicalName(folder.CanonicalName); Assert.True(folder.FolderId == test.FolderId); }
public void FromParsingNameTest(IKnownFolder folder) { IKnownFolder test = KnownFolderHelper.FromParsingName(folder.ParsingName); Assert.True(folder.FolderId == test.FolderId); }
/// <summary> /// Creates a new instance of KnownFolder. /// </summary> internal KnownFolder(IKnownFolder knownFolder) { Debug.Assert(knownFolder != null); _knownFolder = knownFolder; GetFolderProperties(); }
internal KnownFolder(IKnownFolder knownFolder) { _knownFolder = knownFolder; }