/// <summary> /// Get Shell file or folder info with extra flags. /// </summary> private static ShellObject GetInfo(Shell32.FileInfoItemType identifier, string name, Shell32.FileInfoFlag extraFlags) { // Create a filesystemobject to hold the result ShellObject result = new ShellObject(); // Create a structure to hold the information Shell32.SHFILEINFO info = new Shell32.SHFILEINFO(); int infoSize = Marshal.SizeOf(typeof(Shell32.SHFILEINFO)); // Build the flags Shell32.FileInfoFlag flags = Shell32.FileInfoFlag.Icon | Shell32.FileInfoFlag.UseFileAttributes; flags |= extraFlags; // Retrieve the small icon Shell32.SHGetFileInfo(name, identifier, ref info, infoSize, flags | Shell32.FileInfoFlag.IconSizeSmall); result.SmallIcon = Icon.FromHandle(info.hIcon).ToBitmap(); User32.DestroyIcon(info.hIcon); // Retrieve the large icon and type info Shell32.SHGetFileInfo(name, identifier, ref info, infoSize, flags | Shell32.FileInfoFlag.IconSizeLarge | Shell32.FileInfoFlag.TypeName); result.LargeIcon = Icon.FromHandle(info.hIcon).ToBitmap(); result.TypeName = info.szTypeName; User32.DestroyIcon(info.hIcon); return result; }
private static Boolean checkStatus(int ItemCount, Shell32.Folder DestFlder) { DateTime timeoutDeadline = DateTime.Now.AddMinutes(1); for (; ; ) { //Are we past the deadline? if (DateTime.Now > timeoutDeadline) { break; } //Check the number of items in the new zip to see if it matches //the number of items in the original source location //Only check the item count every .25 seconds System.Threading.Thread.Sleep(250); int ZipFileItemCount = RecurseCount(DestFlder.Items()); if (ItemCount == ZipFileItemCount) { break; } } return true; }
public void Perform(Shell32InstanceWrapper shell, string destDir, Shell32.FolderItem src, TimeSpan timeout, CopyReaderDelegate reader) { var destFile = Path.GetFullPath(Path.Combine(destDir, Path.GetFileName(src.Path))); var destFolder = shell.NameSpace(destDir); StartCopy(src, destFolder); FinishCopy(destFile, timeout, reader); }
private static string GetArtist(Shell32.Folder shellFolder, Shell32.FolderItem shellFile) { if (!string.IsNullOrEmpty(shellFolder.GetDetailsOf(shellFile, AUTHOR))) return shellFolder.GetDetailsOf(shellFile, AUTHOR); if (!string.IsNullOrEmpty(shellFolder.GetDetailsOf(shellFile, ALBUM_ARTIST))) return shellFolder.GetDetailsOf(shellFile, ALBUM_ARTIST); return "Unknown Artist"; }
public LinkType(Shell32.ShellLinkObject _Link,FileInfo _FileInfo) { Link = _Link; FileInfo = _FileInfo; Arguments = Link.Arguments; WorkingDirectory = Link.WorkingDirectory; Description = Link.Description; Target = Link.Target.Path; LinkFullName = FileInfo.FullName; //Path = Link.Path; }
/// <summary> /// Initialises the ShellItem, from its PIDL and parent. /// </summary> /// <param name="pidl">The pidl.</param> /// <param name="parentFolder">The parent folder.</param> private void Initialise(IntPtr pidl, ShellItem parentFolder) { // Set the parent item and relative pidl. ParentItem = parentFolder; RelativePIDL = pidl; // Create the fully qualified PIDL. PIDL = Shell32.ILCombine(parentFolder.PIDL, pidl); // Use the desktop folder to get attributes. var flags = SFGAO.SFGAO_FOLDER | SFGAO.SFGAO_HASSUBFOLDER | SFGAO.SFGAO_BROWSABLE | SFGAO.SFGAO_FILESYSTEM; //todo was this parentFolder.ShellFolderInterface.GetAttributesOf(1, ref pidl, ref flags); var apidl = Marshal.AllocCoTaskMem(IntPtr.Size * 1); Marshal.Copy(new IntPtr[] { pidl }, 0, apidl, 1); parentFolder.ShellFolderInterface.GetAttributesOf(1, apidl, ref flags); IsFolder = (flags & SFGAO.SFGAO_FOLDER) != 0; HasSubFolders = (flags & SFGAO.SFGAO_HASSUBFOLDER) != 0; // Get the file info. var fileInfo = new SHFILEINFO(); Shell32.SHGetFileInfo(PIDL, 0, out fileInfo, (uint)Marshal.SizeOf(fileInfo), SHGFI.SHGFI_SMALLICON | SHGFI.SHGFI_SYSICONINDEX | SHGFI.SHGFI_PIDL | SHGFI.SHGFI_DISPLAYNAME | SHGFI.SHGFI_ATTRIBUTES); // Set extended attributes. DisplayName = fileInfo.szDisplayName; Attributes = (SFGAO)fileInfo.dwAttributes; TypeName = fileInfo.szTypeName; IconIndex = fileInfo.iIcon; // Are we a folder? if (IsFolder) { // Bind the shell folder interface. IShellFolder shellFolderInterface; IntPtr ppv = IntPtr.Zero; var result = parentFolder.ShellFolderInterface.BindToObject(pidl, IntPtr.Zero, ref Shell32.IID_IShellFolder, out ppv);//out shellFolderInterface); shellFolderInterface = ((IShellFolder)Marshal.GetObjectForIUnknown(ppv)); ShellFolderInterface = shellFolderInterface; // Validate the result. if (result != 0) { // Throw the failure as an exception. Marshal.ThrowExceptionForHR((int)result); } } }
private string kind(string extension) { Shell32.SHFILEINFO shinfo = new Shell32.SHFILEINFO(); IntPtr hSuccess = Shell32.SHGetFileInfo(extension, 0, ref shinfo, (uint)Marshal.SizeOf(shinfo), Shell32.SHGFI_TYPENAME | Shell32.SHGFI_USEFILEATTRIBUTES); if (hSuccess != IntPtr.Zero) { return(Convert.ToString(shinfo.szTypeName.Trim())); } return(null); }
public static Icon GetResourceIcon(string resourceReference) { var parts = GetResourceRefParts(resourceReference); IntPtr hIcon = IntPtr.Zero, hSmIcon = IntPtr.Zero; Shell32.SHDefExtractIcon(parts.Item1, parts.Item2, 0, ref hIcon, ref hSmIcon, 0); DestroyIcon(hSmIcon); var ico = (Icon)Icon.FromHandle(hIcon).Clone(); DestroyIcon(hIcon); return(ico); }
public void SHGetKnownFolderPathTest() { string path; //ダウンロードフォルダ //Guid id = new Guid("374DE290-123F-4565-9164-39C4925E467B"); //ライブラリ Guid id = new Guid("031E4825-7B94-4DC3-B131-E946B44C8DD5"); int result = Shell32.SHGetKnownFolderPath(id, 0, IntPtr.Zero, out path); Debug.Print(path); }
protected CsShellDirectory PopulateDictionaries() { Debug.Print("Populating Dictionaries"); ActiveShellDirectory = new CsShellDirectory().Create(); try { Debug.Print("> Enumerating Files"); foreach (string ss in Directory.GetFiles(currentPath)) { FileInfo f = new FileInfo(ss); using (CsShellFile sh = new CsShellFile(ss, SHGFI.SMALLICON | SHGFI.ICON | SHGFI.TYPENAME)) { if (!ActiveShellDirectory.Files.Paths.ContainsKey(f.FullName)) { ActiveShellDirectory.Files.Paths.Add(f.FullName, sh.GetListItem()); } if (!ActiveShellDirectory.Files.IcoPtr.ContainsKey(ss)) { ActiveShellDirectory.Files.IcoPtr.Add(f.FullName, sh.IIcon); } } } Debug.Print("> File Count: {0}", ActiveShellDirectory.Files.Paths.Count); Debug.Print("> Enumerating Directories"); foreach (string ss in Directory.GetDirectories(currentPath)) { DirectoryInfo d = new DirectoryInfo(ss); CsShellFile_ListItem sx = new CsShellFile_ListItem(); sx.Path = ss; sx.Name = Path.GetFileName(ss); SHFileInfo sh = Shell32.StrIco(ss, SHGFI.SMALLICON | SHGFI.ICON | SHGFI.TYPENAME); sx.TypeName = sh.szTypeName; if (!ActiveShellDirectory.Directories.Paths.ContainsKey(d.Name)) { ActiveShellDirectory.Directories.Paths.Add(d.Name, sx); } if (!ActiveShellDirectory.Directories.IcoPtr.ContainsKey(ss)) { ActiveShellDirectory.Directories.IcoPtr.Add(ss, sh.hIcon); } User32.DestroyIcon(sh.hIcon); } Debug.Print("> Directory Count: {0}", ActiveShellDirectory.Directories.Paths.Count); } catch (IOException e) { MessageBox.Show(e.Message, e.Source); } catch (Exception e) { Debug.Print("{0}", e); } return(ActiveShellDirectory); }
public void Initialize(IntPtr lvHandle, string path, int index) { var shellItem = Shell32.SHCreateItemFromParsingName(path, IntPtr.Zero, typeof(IShellItem).GUID); this.ParentPIDL = IntPtr.Zero; this.EnumPIDL = Shell32.SHGetIDListFromObject(shellItem); Marshal.ReleaseComObject(shellItem); //this.ParentHandle = lvHandle; this.OverlayIconIndex = -1; this.ShieldedIconIndex = -1; }
private static IShellItem CreateItemFromIDList(IntPtr pidl) { //TODO: Consider moving the Try Finally to here if (RunningVista) { return(Shell32.SHCreateItemFromIDList(pidl, typeof(IShellItem).GUID)); } else { return(new Interop.VistaBridge.ShellItemImpl(pidl, false)); } }
public static IdList GetDesktop() { IntPtr pidl; Shell32.SHGetKnownFolderIDList(FOLDERID_Desktop, // KnownFolders.FOLDERID_Desktop, KNOWN_FOLDER_FLAG.KF_NO_FLAGS, IntPtr.Zero, out pidl); var idlist = IdList.Create(Decode(pidl)); Shell32.ILFree(pidl); return(idlist); }
private void cmnuProperties_Click(object sender, EventArgs e) { try { ApplicationJob job = olvJobs.SelectedObject as ApplicationJob; Shell32.ShowFileProperties(job.CurrentLocation); } catch (Exception) { // ignore if fails for whatever reason } }
public static IShellFolder GetFolderImpl(this IntPtr pidl, ref PidlFolderData data, SBSP wFlags) { IShellFolder result = null; int hr = 0; IntPtr pidlTmp = IntPtr.Zero; var folderTmp = data.folderTmp; var currentAbsolutePidl = data.currentAbsolutePidl; var folderTmpPtr = data.folderTmpPtr; var currentFolder = data.currentFolder; IShellFolder desktopFolder = PidlFolderData.DesktopFolder; var desktopFolderPidl = PidlFolderData.DesktopFolderPidl; // Check to see if we have a desktop pidl, relative pidl or absolite pidl. if (Shell32.ILIsEqual(pidl, desktopFolderPidl)) { // The provided PIDL is the desktop folder. pidlTmp = Shell32.ILClone(desktopFolderPidl); folderTmp = desktopFolder; } else if ((wFlags & SBSP.SBSP_RELATIVE) != 0) { // SBSP_RELATIVE - pidl is relative from the current folder if ((hr = currentFolder.BindToObject(pidl, IntPtr.Zero, ref Shell32.IID_IShellFolder, out folderTmpPtr)) != WinError.S_OK) { return(result); // hr; } pidlTmp = Shell32.ILCombine(currentAbsolutePidl, pidl); folderTmp = (IShellFolder)Marshal.GetObjectForIUnknown(folderTmpPtr); } else { // SBSP_ABSOLUTE - pidl is an absolute pidl (relative from desktop) PidlClone pidlClone = PidlClone.Of(pidl); folderTmp = GetPidlCloneFolder(pidlClone); pidlTmp = pidlClone.Handle; } if (folderTmp == null) { Shell32.ILFree(pidlTmp); return(result); // WinError.E_FAIL; } result = folderTmp; return(result); }
// 48X48 private static IntPtr GetXLIcon(int iImage) { IImageList spiml = null; Guid guil = new Guid(IID_IImageList);//or IID_IImageList Shell32.SHGetImageList(Shell32.SHIL_EXTRALARGE, ref guil, ref spiml); IntPtr hIcon = IntPtr.Zero; spiml.GetIcon(iImage, Shell32.ILD_TRANSPARENT | Shell32.ILD_IMAGE, ref hIcon); // return(hIcon); }
public void Navigate(ShellItem destination) { this.cache.Clear(); this.refreshedImages.Clear(); GC.Collect(); this.Cancel = true; Shell32.SetProcessWorkingSetSize(Process.GetCurrentProcess().Handle, -1, -1); this.Items = destination.OrderByDescending(o => o.IsFolder).ToArray(); User32.SendMessage(this.LVHandle, MSG.LVM_SETITEMCOUNT, this.Items.Length, 0); this.m_CurrentFolder = destination; this.OnNavigated(new NavigatedEventArgs(destination)); }
public void CanGetDesktopFolderLocationAndPath() { // Asserts we can get the desktop folder pidl, get a path for it and free the pidl. IntPtr pidl; Shell32.SHGetFolderLocation(IntPtr.Zero, CSIDL.CSIDL_DESKTOP, IntPtr.Zero, 0, out pidl); var sb = new StringBuilder(260); Assert.IsTrue(Shell32.SHGetPathFromIDList(pidl, sb)); Assert.IsNotNullOrEmpty(sb.ToString()); Assert.DoesNotThrow(() => Shell32.ILFree(pidl)); }
static IntPtr GetJumboIcon(int iImage) { IImageList spiml = null; Guid guil = new Guid(IID_IImageList2); Shell32.SHGetImageList(Shell32.SHIL_JUMBO, ref guil, ref spiml); IntPtr hIcon = IntPtr.Zero; spiml.GetIcon(iImage, Shell32.ILD_TRANSPARENT | Shell32.ILD_IMAGE, ref hIcon); return(hIcon); }
public HResult GetParent(out IShellItem ppsi) { var pidl = Shell32.ILClone(Pidl); if (Shell32.ILRemoveLastID(pidl)) { ppsi = new ShellItemImpl(pidl, true); return(HResult.S_OK); } ppsi = null; return(HResult.MK_E_NOOBJECT); }
//private void OnFileSystemWatcherChanged(object sender, FileSystemEventArgs e) //{ // Dispatcher.Current.Invoke(() => // { // try // { // Image image = CreateImageFromFile(e.FullPath); // LoadCircuitBoard(image); // } // catch (Exception exception) // { // Debug.WriteLine(exception); // } // }); //} protected override void OnCreate(ref CreateWindowPacket packet) { base.OnCreate(ref packet); Shell32.DragAcceptFiles(Handle, true); textBrush = new SolidColorBrush(Dx.D2D.Context, textColor); textFormat = new TextFormat(Dx.TextFactory, "Consolas", 16); LoadDefaultCircuitBoard(); performanceMonitor.Start(); }
public static bool ShowFileProperties(string filename) { var info = new ShellExecuteInfo(); info.cbSize = Marshal.SizeOf(info); info.lpVerb = "properties"; info.lpFile = filename; //info.lpParameters = "Security"; info.nShow = (int)ShowWindowCommands.Show; info.fMask = (uint)ShellExecuteMasks.InvokeIdList; return(Shell32.ShellExecuteEx(ref info)); }
private static async Task parseRecycleBinAction(AppServiceRequestReceivedEventArgs args, string action) { switch (action) { case "Empty": // Shell function to empty recyclebin Shell32.SHEmptyRecycleBin(IntPtr.Zero, null, Shell32.SHERB.SHERB_NOCONFIRMATION | Shell32.SHERB.SHERB_NOPROGRESSUI); break; case "Query": var responseQuery = new ValueSet(); Shell32.SHQUERYRBINFO queryBinInfo = new Shell32.SHQUERYRBINFO(); queryBinInfo.cbSize = (uint)Marshal.SizeOf(queryBinInfo); var res = Shell32.SHQueryRecycleBin("", ref queryBinInfo); if (res == HRESULT.S_OK) { var numItems = queryBinInfo.i64NumItems; var binSize = queryBinInfo.i64Size; responseQuery.Add("NumItems", numItems); responseQuery.Add("BinSize", binSize); await args.Request.SendResponseAsync(responseQuery); } break; case "Enumerate": // Enumerate recyclebin contents and send response to UWP var responseEnum = new ValueSet(); var folderContentsList = new List <ShellFileItem>(); foreach (var folderItem in recycler) { try { var shellFileItem = GetRecycleBinItem(folderItem); folderContentsList.Add(shellFileItem); } catch (FileNotFoundException) { // Happens if files are being deleted } finally { folderItem.Dispose(); } } responseEnum.Add("Enumerate", JsonConvert.SerializeObject(folderContentsList)); await args.Request.SendResponseAsync(responseEnum); break; default: break; } }
public void CanFullRoundTripPidl() { IntPtr pidl; Shell32.SHGetKnownFolderIDList(KnownFolders.FOLDERID_Downloads, KNOWN_FOLDER_FLAG.KF_NO_FLAGS, IntPtr.Zero, out pidl); var idList = PidlManager.PidlToIdlist(pidl); var pidl2 = PidlManager.IdListToPidl(idList); var idList2 = PidlManager.PidlToIdlist(pidl2); Assert.IsTrue(idList.Matches(idList2)); }
/// <summary> /// Function to purge old workspace directories if they were left over (e.g. debug break, crash, etc...) /// </summary> /// <param name="prevDirectory">The previously used directory path for the project.</param> /// <param name="recycle"><b>true</b> to recycle the directory, or <b>false</b> to permenantly delete it.</param> /// <exception cref="ArgumentNullException">Thrown when the <paramref name="prevDirectory"/> parameter is <b>null</b>.</exception> private void PurgeStaleDirectories(DirectoryInfo prevDirectory, bool recycle) { int count = 0; if (!prevDirectory.Exists) { return; } var deleteDir = new DirectoryInfo(prevDirectory.FullName); // To avoid issues with delete being an asynchronous operation, we will first rename the directory, and then delete it. // This way we can recreate the directory structure without interference (one would hope at least). if (!recycle) { deleteDir.MoveTo(Path.Combine(deleteDir.Parent.FullName, Guid.NewGuid().ToString("N"))); } // Attempt to delete multiple times if the directory is locked (explorer is a jerk sometimes). while (count < 4) { try { if (!deleteDir.Exists) { return; } if (recycle) { Program.Log.Print($"Moving '{deleteDir.FullName}' to the recycle bin...", LoggingLevel.Intermediate); Shell32.SendToRecycleBin(deleteDir.FullName, Shell32.FileOperationFlags.FOF_SILENT | Shell32.FileOperationFlags.FOF_NOCONFIRMATION | Shell32.FileOperationFlags.FOF_WANTNUKEWARNING); } else { Program.Log.Print($"Deleting '{deleteDir.FullName}'...", LoggingLevel.Intermediate); deleteDir.Delete(true); } break; } catch (Exception ex) { Program.Log.LogException(ex); ++count; // Give the system some time. Sometimes explorer will release its lock. Thread.Sleep(250); } } prevDirectory.Refresh(); }
public static List <AssociationPackage> GetAllAssociation(string Path) { List <AssociationPackage> Association = new List <AssociationPackage>(100); try { string Extension = System.IO.Path.GetExtension(Path).ToLower(); if (Shell32.SHAssocEnumHandlers(Extension, Shell32.ASSOC_FILTER.ASSOC_FILTER_NONE, out Shell32.IEnumAssocHandlers AssocHandlers) == HRESULT.S_OK) { Shell32.IAssocHandler[] Handlers = new Shell32.IAssocHandler[100]; if (AssocHandlers.Next(100, Handlers, out uint FetchedNum) == HRESULT.S_OK) { Array.Resize(ref Handlers, Convert.ToInt32(FetchedNum)); foreach (Shell32.IAssocHandler Handler in Handlers) { try { if (Handler.GetName(out string FullPath) == HRESULT.S_OK && Handler.GetUIName(out string DisplayName) == HRESULT.S_OK) { //For UWP application, DisplayName == FullPath if (DisplayName != FullPath) { Association.Add(new AssociationPackage(Extension, FullPath, Handler.IsRecommended() == HRESULT.S_OK)); } } } catch { continue; } finally { Marshal.ReleaseComObject(Handler); } } } } return(Association); } catch { return(Association); } finally { Association.TrimExcess(); } }
private DialogBoxResult ShowVistaDialog(IWin32Window owner) { // ReSharper disable once SuspiciousTypeConversion.Global var frm = (IFileDialog) new FileOpenDialogRCW(); frm.GetOptions(out var options); options |= FileOpenDialogOptions.PickFolders | FileOpenDialogOptions.ForceFileSystem | FileOpenDialogOptions.NoValidate | FileOpenDialogOptions.NoTestFileCreate | FileOpenDialogOptions.DontAddToRecent; frm.SetOptions(options); if (InitialFolder != null) { var riid = typeof(IShellItem).GUID; if (Shell32.SHCreateItemFromParsingName(InitialFolder, IntPtr.Zero, ref riid, out var directoryShellItem) == ErrorCode.S_OK) { frm.SetFolder(directoryShellItem); } } if (DefaultFolder != null) { var riid = typeof(IShellItem).GUID; if (Shell32.SHCreateItemFromParsingName(DefaultFolder, IntPtr.Zero, ref riid, out var directoryShellItem) == ErrorCode.S_OK) { frm.SetDefaultFolder(directoryShellItem); } } var result = owner == null ? frm.Show() : frm.Show(owner.Handle); if (result == ErrorCode.S_OK && frm.GetResult(out var shellItem) == ErrorCode.S_OK && shellItem.GetDisplayName(SIGDN.FileSysPath, out var pszString) == ErrorCode.S_OK && pszString != IntPtr.Zero) { try { SelectedFolder = Marshal.PtrToStringAuto(pszString); return(DialogBoxResult.OK); } finally { Marshal.FreeCoTaskMem(pszString); } } return(DialogBoxResult.Cancel); }
private void FillLocalView(Shell32.Folder folder) { this.Cursor = Cursors.WaitCursor; m_currentFolder = folder; // Notify that update begins LocalView.BeginUpdate(); // Erase last view items LocalView.Items.Clear(); // Erase previous lists image ImgListViewSmall.Images.Clear(); ImgListViewLarge.Images.Clear(); int idImage = 0; ListViewItem lvItem = new ListViewItem(".."); lvItem.Tag = folder; LocalView.Items.Add(lvItem); Shell32.FolderItems items = folder.Items(); // Folder enumeration foreach (Shell32.FolderItem item in items) { if (item.IsFolder) { AddViewItem(item, ref idImage); } } // Other files foreach (Shell32.FolderItem item in items) { if (!item.IsFolder) { AddViewItem(item, ref idImage); } } // End update view LocalView.EndUpdate(); //ftpc.LocalFolder = folder.Title; this.Cursor = Cursors.Default; }
public static ImageSource GetImage(string path, int size) { IntPtr intPtr = FileOperation.GetIcon(path, size, size); ImageSource imageSource = Imaging.CreateBitmapSourceFromHBitmap(intPtr, IntPtr.Zero, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions()); if (imageSource != null) { imageSource.Freeze(); } Shell32.DestroyIcon(intPtr); return(imageSource); }
public static bool IsConsoleSubsystem(string executablePath) { if (Environment.OSVersion.Platform != PlatformID.Win32NT) { // Under UNIX all applications are effectively console. return(true); } var info = new Shell32.SHFILEINFO(); var executableType = (uint)Shell32.SHGetFileInfo(executablePath, 0u, ref info, (uint)Marshal.SizeOf(info), Shell32.SHGFI_EXETYPE); return(executableType == Shell32.MZ || executableType == Shell32.PE); }
private static IShellItem CreateItemWithParent(ShellItem parent, IntPtr pidl) { if (RunningVista) { return(Shell32.SHCreateItemWithParent(IntPtr.Zero, parent.GetIShellFolder(), pidl, typeof(IShellItem).GUID)); } var impl = (ShellItemImpl)parent.ComInterface; return(new ShellItemImpl( Shell32.ILCombine(impl.Pidl, pidl), true)); }
/// <summary> /// Provides a default IExtractIcon implementation. /// </summary> /// <param name="folderIcon">if set to <c>true</c> use a folder icon, otherwise use an item icon.</param> /// <param name="interfacePointer">The interface pointer.</param> private void ProvideDefaultIExtractIcon(bool folderIcon, out IntPtr interfacePointer) { // Create a default extract icon init interface. IDefaultExtractIconInit pdxi; Shell32.SHCreateDefaultExtractIcon(typeof(IDefaultExtractIconInit).GUID, out pdxi); // Set the normal icon. pdxi.SetNormalIcon("shell32.dll", folderIcon ? 4 : 1); // Get the IExtractIconW interface. interfacePointer = Marshal.GetComInterfaceForObject(pdxi, typeof(IExtractIconW)); }
void OnDelete() { if (File.Exists(FileName)) { if (Shell32.FileOperation(FileName, FileOperationType.Delete, 0) != 0) { return; } } // Remove from List RemoveRequested?.Invoke(); }
static KnownFolder CreateFolder(CSIDL csidl, string name) { StringBuilder path = new StringBuilder(512); if (Shell32.SHGetFolderPath(IntPtr.Zero, csidl, IntPtr.Zero, 0, path) == HResult.S_OK) { return(new KnownFolder(csidl, name, path.ToString())); } else { return(new KnownFolder(csidl, name, string.Empty)); } }
ShellItemImpl GetParent() { IntPtr pidl = Shell32.ILClone(m_Pidl); if (Shell32.ILRemoveLastID(pidl)) { return(new ShellItemImpl(pidl, true)); } else { return(this); } }
static IShellItem CreateItemFromIDList(IntPtr pidl) { if (RunningVista) { return(Shell32.SHCreateItemFromIDList(pidl, typeof(IShellItem).GUID)); } else { return(new Interop.VistaBridge.ShellItemImpl( pidl, false)); } }
public static void MinimizeAll() { Shell32 shell = null; IShellDispatch shellDispatch = null; try { shell = new Shell32(); shellDispatch = (IShellDispatch)shell; shellDispatch.MinimizeAll(); } finally { Release(shellDispatch); Release(shell); } }
// Gets each video in the child folders private static void DirSearch(Shell32.Folder sDir) { // Goes through each folder foreach (Shell32.FolderItem2 item in sDir.Items()) { // Finds each file in folder string type = (string)item.ExtendedProperty("Type"); if (type.ToLower().Contains("folder")) { DirSearch(shell.NameSpace(sDir.GetDetailsOf(item, 180))); } else { if (type.ToLower().Contains("mp3")) { Songs w = new Songs((string)item.ExtendedProperty("Name"), sDir.GetDetailsOf(item, 21)); windowsSongs.Add(w); //Debug.WriteLine("Title: {0}\n Name: {1}\n Ext: {2}\n\n", sDir.GetDetailsOf(item, 21), (string)item.ExtendedProperty("Name"), (string)item.ExtendedProperty("Type")); } } } }
private static string GetTitle(Shell32.Folder shellFolder, Shell32.FolderItem shellFile) { if (!string.IsNullOrEmpty(shellFolder.GetDetailsOf(shellFile, TITLE))) return shellFolder.GetDetailsOf(shellFile, TITLE); // return the filename if there's no title return shellFolder.GetDetailsOf(shellFile, FILENAME); }
private void AddViewItem(Shell32.FolderItem item, ref int idImage) { string[] sValues = new string[10]; sValues[0] = item.Name; if (item.Size == 0) sValues[1] = ""; else sValues[1] = Convert.ToString(item.Size / 1024) + " KB"; sValues[2] = item.Type; sValues[3] = item.ModifyDate.ToString(); /* sValues[4] = item.Path; sValues[5] = item.IsBrowsable.ToString(); sValues[6] = item.IsFileSystem.ToString(); sValues[7] = item.IsFolder.ToString(); sValues[8] = item.IsLink.ToString(); */ ImgListViewSmall.Images.Add (ExtractIcon.GetIcon(item.Path, true)); ListViewItem lvItem = new ListViewItem(sValues, idImage++); lvItem.Tag = item; LocalView.Items.Add (lvItem); }
private static TreeNode AddTreeNode(Shell32.FolderItem item, ref int imageCount, ImageList imageList, bool getIcons) { TreeNode tn = new TreeNode(); tn.Text = item.Name; tn.Tag = item; if(getIcons) { try { imageCount++; tn.ImageIndex = imageCount; imageCount++; tn.SelectedImageIndex = imageCount; imageList.Images.Add(ExtractIcons.GetIcon(item.Path, false, imageList)); // normal icon imageList.Images.Add(ExtractIcons.GetIcon(item.Path, true, imageList)); // selected icon } catch // use default { tn.ImageIndex = 1; tn.SelectedImageIndex = 2; } } else // use default { tn.ImageIndex = 1; tn.SelectedImageIndex = 2; } return tn; }
public void StartCopy(Shell32.FolderItem src, Shell32.Folder destFolder) { destFolder.CopyHere(src, 0 /*4 do not show file copy dialog */); }
public static int AddRootNode(TreeView tree, int imageCount, ImageList imageList, bool getIcons, Shell32.Shell shell32, Shell32.Folder shell32Folder, string rootNodeS) { Shell32.FolderItems items = shell32Folder.Items(); tree.Nodes.Clear(); TreeNode desktop = new TreeNode(rootNodeS, 0, 0); // Added in version 1.11 // add a FolderItem object to the root (Desktop) node tag that corresponds to the DesktopDirectory namespace // This ensures that the GetSelectedNodePath will return the actual Desktop folder path when queried. // There's possibly a better way to create a Shell32.FolderItem instance for this purpose, // but I surely don't know it Shell32.Folder dfolder = shell32Folder; //shell32.NameSpace(ShellFolder.DesktopDirectory); foreach (Shell32.FolderItem fi in dfolder.ParentFolder.Items()) { if (fi.Name == dfolder.Title) { desktop.Tag = fi; break; } } // Add the Desktop root node to the tree tree.Nodes.Add(desktop); vlozitSLozkuNa = 0; // iterate through the Desktop namespace and populate the first level nodes foreach (Shell32.FolderItem item in items) { TreeNode tn = AddTreeNode(item, ref imageCount, imageList, getIcons); if (item.IsFolder) // this ensures that desktop shortcuts etc are not displayed { desktop.Nodes.Insert(vlozitSLozkuNa, tn); vlozitSLozkuNa++; CheckForSubDirs(tn, imageList); CheckForSubItems(tn, imageCount); } else { desktop.Nodes.Add( tn); } //} } return imageCount; }
/// <summary> /// Get Shell file or folder info. /// </summary> private static ShellObject GetInfo(Shell32.FileInfoItemType identifier, string name) { return GetInfo(identifier, name, 0); }
private void ProcessFile(Shell32.FolderItem file, Shell32.Folder objFolder) { Debug.WriteLine(" [Processing File " + file.Path + "]"); DataRow data = files.NewRow(); foreach (int id in ColumnListPerID) { if (id != 26) data[objFolder.GetDetailsOf(null, id).Replace("'", "_").Replace("’", "_")] = objFolder.GetDetailsOf(file, id); } if (string.IsNullOrEmpty(objFolder.GetDetailsOf(file, 26))) data[objFolder.GetDetailsOf(null, 26).Replace("'", "_").Replace("’", "_")] = DBNull.Value; else data[objFolder.GetDetailsOf(null, 26).Replace("'", "_").Replace("’", "_")] = int.Parse(objFolder.GetDetailsOf(file, 26)); if ((string) data[objFolder.GetDetailsOf(null, 21).Replace("'", "_").Replace("’", "_")] == "") data[objFolder.GetDetailsOf(null, 21).Replace("'", "_").Replace("’", "_")] = System.IO.Path.GetFileName(file.Path); data["URI"] = new Uri(file.Path); data["ID"] = files.Rows.Count + 1; files.Rows.Add(data); }
private TreeViewItem CreateTreeItem(Shell32.FolderItem folderItem) { if (folderItem == null) { throw new ArgumentNullException("folderItem"); } TreeViewItem tvi = new TreeViewItem(); //tvi.Header = folderItem.Name; tvi.Tag = folderItem; StackPanel panel = new StackPanel(); panel.Orientation = Orientation.Horizontal; panel.Margin = new Thickness(1); tvi.Header = panel; Image image = new Image(); image.Source = ExtractIcons.GetIcon(folderItem.Path, false, (folderItem.Type == "3½-Inch Floppy Disk" || folderItem.Type == "Floppy Disk Drive")); image.Margin = new Thickness(0, 0, 4, 0); TextBlock text = new TextBlock(); text.VerticalAlignment = VerticalAlignment.Center; text.Text = folderItem.Name; panel.Children.Add(image); panel.Children.Add(text); return tvi; }
public static extern IntPtr SHBrowseForFolder ( ref Shell32.BROWSEINFO bi );
/// <summary> /// Returns an icon for a given file - indicated by the name parameter. /// </summary> /// <param name="name">Extension or pathname for file.</param> /// <param name="size">Large or small</param> /// <param name="linkOverlay">Whether to include the link icon</param> /// <param name="shfi">Return File Information</param> /// <returns>System.Drawing.Icon</returns> public static Icon GetFileIcon(string name, IconSize size, bool linkOverlay, ref Shell32.SHFILEINFO shfi) { name = Environment.ExpandEnvironmentVariables(name); shfi = new Shell32.SHFILEINFO(); Shell32.SHGetFileInfoConstants flags = Shell32.SHGetFileInfoConstants.SHGFI_TYPENAME | Shell32.SHGetFileInfoConstants.SHGFI_DISPLAYNAME | Shell32.SHGetFileInfoConstants.SHGFI_ICON | Shell32.SHGetFileInfoConstants.SHGFI_SHELLICONSIZE | Shell32.SHGetFileInfoConstants.SHGFI_SYSICONINDEX | Shell32.SHGetFileInfoConstants.SHGFI_USEFILEATTRIBUTES; if (linkOverlay) flags |= Shell32.SHGetFileInfoConstants.SHGFI_LINKOVERLAY; /* Check the size specified for return. */ if (IconSize.Small == size) flags |= Shell32.SHGetFileInfoConstants.SHGFI_SMALLICON; else flags |= Shell32.SHGetFileInfoConstants.SHGFI_LARGEICON; IntPtr hIml = Shell32.SHGetFileInfo(name, Shell32.FILE_ATTRIBUTE.NORMAL, ref shfi, (uint)Marshal.SizeOf(shfi), flags); if (shfi.hIcon == IntPtr.Zero) return null; if (!IconHelper.Utils.IsXpOrAbove()) return GetManagedIcon(shfi.hIcon); // Get the System IImageList object from the Shell: Guid iidImageList = new Guid("46EB5926-582E-4017-9FDF-E8998DAA0950"); Shell32.IImageList iImageList = null; int ret = Shell32.SHGetImageList( (int)size, ref iidImageList, ref iImageList ); // the image list handle is the IUnknown pointer, but // using Marshal.GetIUnknownForObject doesn't return // the right value. It really doesn't hurt to make // a second call to get the handle: Shell32.SHGetImageListHandle((int)size, ref iidImageList, ref hIml); IntPtr hIcon = IntPtr.Zero; if (iImageList == null) { hIcon = Comctl32.ImageList_GetIcon( hIml, shfi.iIcon, (int)Comctl32.ImageListDrawItemConstants.ILD_TRANSPARENT); } else { iImageList.GetIcon( shfi.iIcon, (int)Comctl32.ImageListDrawItemConstants.ILD_TRANSPARENT, ref hIcon); } return hIcon == IntPtr.Zero ? GetManagedIcon(shfi.hIcon) : GetManagedIcon(hIcon); }
public static void CopyItemHereAndRead(Shell32InstanceWrapper shell, string destDir, Shell32.FolderItem src, TimeSpan timeout, CopyReaderDelegate reader) { var performer = new CopyPerformer(); performer.Perform(shell, destDir, src, timeout, reader); }
public string GetItem(Shell32.FolderItem2 Item2) { return "Not implemented"; }
/// <summary> /// Extract the icon from file, and return icon information /// </summary> /// <param name="path">File path, /// such as ex: "C:\\Program Files\\NetMeeting\\conf.exe,1".</param> /// <param name="size">The desired icon size</param> /// <param name="linkOverlay">Whether to include the link icon</param> /// <param name="shfi">The icon size</param> /// <returns>This method always returns an icon with the especified size and thier information.</returns> public static Icon ExtractIconFromFileEx(string path, IconSize size, bool linkOverlay, ref Shell32.SHFILEINFO shfi) { EmbeddedIconInfo embeddedIcon = GetEmbeddedIconInfo(Environment.ExpandEnvironmentVariables(path)); //Gets the handle of the icon. return GetFileIcon(embeddedIcon.FileName, size, linkOverlay, ref shfi); }
public string GetTitle(Shell32.FolderItem2 item2) { string title = _objFolder.GetDetailsOf(item2, 0); return title; }
/// <summary> /// Used to access system folder icons. /// </summary> /// <param name="size">Specify large or small icons.</param> /// <param name="folderType">Specify open or closed FolderType.</param> /// <param name="shfi">Return Folder Information</param> /// <returns>System.Drawing.Icon</returns> public static Icon GetFolderIcon(IconSize size, FolderType folderType, ref Shell32.SHFILEINFO shfi) { // Need to add size check, although errors generated at present! Shell32.SHGetFileInfoConstants flags = Shell32.SHGetFileInfoConstants.SHGFI_TYPENAME | Shell32.SHGetFileInfoConstants.SHGFI_DISPLAYNAME | Shell32.SHGetFileInfoConstants.SHGFI_ICON | Shell32.SHGetFileInfoConstants.SHGFI_USEFILEATTRIBUTES; if (FolderType.Open == folderType) flags |= Shell32.SHGetFileInfoConstants.SHGFI_OPENICON; if (IconSize.Small == size) flags |= Shell32.SHGetFileInfoConstants.SHGFI_SMALLICON; else flags |= Shell32.SHGetFileInfoConstants.SHGFI_LARGEICON; IntPtr hIml; // Get the folder icon shfi = new Shell32.SHFILEINFO(); if (IconHelper.Utils.IsSevenOrAbove()) // Windows 7 FIX { hIml = Shell32.SHGetFileInfo(Environment.GetFolderPath(Environment.SpecialFolder.System), Shell32.FILE_ATTRIBUTE.DIRECTORY, ref shfi, (uint)Marshal.SizeOf(shfi), flags); } else { hIml = Shell32.SHGetFileInfo(null, Shell32.FILE_ATTRIBUTE.DIRECTORY, ref shfi, (uint)Marshal.SizeOf(shfi), flags); } if (shfi.hIcon == IntPtr.Zero) return null; if (!IconHelper.Utils.IsXpOrAbove()) return GetManagedIcon(shfi.hIcon); // Get the System IImageList object from the Shell: Guid iidImageList = new Guid("46EB5926-582E-4017-9FDF-E8998DAA0950"); Shell32.IImageList iImageList = null; int ret = Shell32.SHGetImageList( (int)size, ref iidImageList, ref iImageList ); // the image list handle is the IUnknown pointer, but // using Marshal.GetIUnknownForObject doesn't return // the right value. It really doesn't hurt to make // a second call to get the handle: Shell32.SHGetImageListHandle((int)size, ref iidImageList, ref hIml); IntPtr hIcon = IntPtr.Zero; if (iImageList == null) { hIcon = Comctl32.ImageList_GetIcon( hIml, shfi.iIcon, (int)Comctl32.ImageListDrawItemConstants.ILD_TRANSPARENT); } else { iImageList.GetIcon( shfi.iIcon, (int)Comctl32.ImageListDrawItemConstants.ILD_TRANSPARENT, ref hIcon); } return hIcon == IntPtr.Zero ? GetManagedIcon(shfi.hIcon) : GetManagedIcon(hIcon); }
private static int RecurseCount(Shell32.FolderItems Source) { int ItemCount = 0; foreach (Shell32.FolderItem item in Source) { if (item.IsFolder == true) { //Add one for this folder ItemCount++; //Then continue walking down the folder tree ItemCount += RecurseCount(((Shell32.Folder)item.GetFolder).Items()); } else { //Add one for this file ItemCount++; } } return ItemCount; }