Changeset 2057 for trunk/eraser

Timestamp:

5/4/2010 8:02:41 AM (3 years ago)

Author:

lowjoel

Message:

Implemented drag & drop from shell virtual folders (mainly the Recycle Bin)

Location:

trunk/eraser

Files:

• Eraser.Util/NativeMethods/Shell.cs (modified) (1 diff)
• Eraser.Util/Shell.cs (modified) (2 diffs)
• Eraser/SchedulerPanel.cs (modified) (4 diffs)
• Eraser/Strings.en.resx (modified) (1 diff)
• Eraser/Strings.it.resx (modified) (1 diff)
• Eraser/Strings.nl.resx (modified) (1 diff)
• Eraser/Strings.pl.resx (modified) (1 diff)
• Eraser/Strings.resx (modified) (1 diff)

trunk/eraser/Eraser.Util/NativeMethods/Shell.cs

@@ -351 +351 @@
             public string szTypeName;
         }
+
+        /// <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.
+        /// 
+        /// 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.
+        /// 
+        /// 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.</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("Shell32.dll", CharSet = CharSet.Unicode, PreserveSig = true)]
+        public static extern void SHGetKnownFolderIDList(ref Guid rfid, int dwFlags,
+            IntPtr hToken, out IntPtr ppidl);
+
+        /// <summary>
+        /// Frees an ITEMIDLIST structure allocated by the Shell.
+        /// </summary>
+        /// <param name="pidl">A pointer to the ITEMIDLIST structure to be freed.
+        /// This parameter can be NULL.</param>
+        [DllImport("Shell32.dll")]
+        public static extern void ILFree(IntPtr pidl);
+
+        /// <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>
+        /// <remarks>If the location specified by the pidl parameter is not part of the
+        /// file system, this function will fail.
+        /// 
+        /// If the pidl parameter specifies a shortcut, the pszPath will contain the
+        /// path to the shortcut, not to the shortcut's target.</remarks>
+        [DllImport("Shell32.dll", CharSet = CharSet.Unicode)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        public static extern bool SHGetPathFromIDList(IntPtr pidl,
+            StringBuilder pszPath);
     }
 }

trunk/eraser/Eraser.Util/Shell.cs

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Text;
 
@@ -87 +88 @@
             return result;
         }
+
+        /// <summary>
+        /// A List of known folder IDs in the shell namespace.
+        /// </summary>
+        public static class KnownFolderIDs
+        {
+            /// <summary>
+            /// The Known Folder ID of the Recycle Bin
+            /// </summary>
+            public static readonly Guid RecycleBin = 
+                new Guid(0xB7534046, 0x3ECB, 0x4C18, 0xBE, 0x4E, 0x64, 0xCD, 0x4C, 0xB7, 0xD6, 0xAC);
+
+            /// <summary>
+            /// Gets the PIDL for the given Known folder ID.
+            /// </summary>
+            /// <param name="folderId">The known folder ID to query.</param>
+            /// <returns>The PIDL for the given folder.</returns>
+            public static ShellItemIDList GetShellItemIdList(Guid folderId)
+            {
+                Guid guid = folderId;
+                IntPtr pidl = IntPtr.Zero;
+                NativeMethods.SHGetKnownFolderIDList(ref guid, 0, IntPtr.Zero, out pidl);
+
+                try
+                {
+                    return new ShellItemIDList(pidl);
+                }
+                finally
+                {
+                    NativeMethods.ILFree(pidl);
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// Retrieves the path of a known folder as an ITEMIDLIST structure.
+    /// </summary>
+    public class ShellCIDA
+    {
+        /// <summary>
+        /// Parses the given buffer for CIDA elements
+        /// </summary>
+        /// <param name="buffer"></param>
+        public ShellCIDA(byte[] buffer)
+        {
+            int offset = 0;
+            cidl = BitConverter.ToUInt32(buffer, offset);
+            aoffset = new ShellItemIDList[cidl + 1];
+
+            for (int i = 0; i < aoffset.Length; ++i)
+            {
+                int pidlOffset = BitConverter.ToInt32(buffer, offset += sizeof(int));
+
+                //Read the size of the IDL
+                aoffset[i] = new ShellItemIDList(buffer.Skip(pidlOffset).ToArray());
+            }
+        }
+
+        /// <summary>
+        /// The number of PIDLs that are being transferred, not including the parent folder.
+        /// </summary>
+        public uint cidl
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// The first element of aoffset contains the fully-qualified PIDL of a parent folder.
+        /// If this PIDL is empty, the parent folder is the desktop. Each of the remaining
+        /// elements of the array contains an offset to one of the PIDLs to be transferred.
+        /// All of these PIDLs are relative to the PIDL of the parent folder.
+        /// </summary>
+        public ShellItemIDList[] aoffset
+        {
+            get;
+            private set;
+        }
+    }
+
+    /// <summary>
+    /// Contains a list of item identifiers.
+    /// </summary>
+    public class ShellItemIDList
+    {
+        public ShellItemIDList(byte[] buffer)
+        {
+            mkid = new ShellItemID(buffer);
+        }
+
+        public ShellItemIDList(IntPtr buffer)
+        {
+            mkid = new ShellItemID(buffer);
+        }
+
+        public ShellItemID mkid
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// The physical path to the object referenced by this IDL.
+        /// </summary>
+        /// <remarks>If this IDL references a virtual object, this will return
+        /// null.</remarks>
+        public string Path
+        {
+            get
+            {
+                IntPtr mkid = this.mkid.ToSHITEMID();
+                try
+                {
+                    StringBuilder result = new StringBuilder(NativeMethods.MaxPath);
+                    if (NativeMethods.SHGetPathFromIDList(mkid, result))
+                        return result.ToString();
+                }
+                finally
+                {
+                    Marshal.FreeHGlobal(mkid);
+                }
+
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// The GUID of the virtual folder referenced by this IDL.
+        /// </summary>
+        /// <remarks>If this IDL references a physical object, this will return
+        /// <see cref="Guid.Empty"/></remarks>
+        public Guid Guid
+        {
+            get
+            {
+                Guid[] guids = new Guid[] {
+                    Shell.KnownFolderIDs.RecycleBin
+                };
+
+                foreach (Guid guid in guids)
+                {
+                    if (Shell.KnownFolderIDs.GetShellItemIdList(guid) == this)
+                        return guid;
+                }
+
+                return Guid.Empty;
+            }
+        }
+
+        public static bool operator==(ShellItemIDList lhs, ShellItemIDList rhs)
+        {
+            return lhs.mkid == rhs.mkid;
+        }
+
+        public static bool operator!=(ShellItemIDList lhs, ShellItemIDList rhs)
+        {
+            return lhs.mkid != rhs.mkid;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj is ShellItemIDList)
+                return this == (ShellItemIDList)obj;
+            return this.Equals(obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+    }
+
+    /// <summary>
+    /// Defines an item identifier. (native type: SHITEMID)
+    /// </summary>
+    public class ShellItemID
+    {
+        public ShellItemID(byte[] buffer)
+        {
+            short cb = BitConverter.ToInt16(buffer, 0);
+            abID = new byte[cb];
+            if (cb > 0)
+                Buffer.BlockCopy(buffer, sizeof(short), abID, 0, cb - sizeof(short));
+        }
+
+        public ShellItemID(IntPtr buffer)
+        {
+            short cb = Marshal.ReadInt16(buffer);
+            abID = new byte[cb];
+            if (cb > 0)
+                Marshal.Copy(new IntPtr(buffer.ToInt64() + sizeof(short)), abID, 0, cb - sizeof(short));
+        }
+
+        byte[] abID;
+
+        /// <summary>
+        /// Converts this ShellItemID to the native SHITEMID.
+        /// </summary>
+        /// <returns>A Pointer to an unmanaged block of memory which should be
+        /// freed by Marshal.FreeHGlobal upon completion.</returns>
+        internal IntPtr ToSHITEMID()
+        {
+            //Allocate the buffer
+            IntPtr result = Marshal.AllocHGlobal(abID.Length + (abID.Length == 0 ? 0 : sizeof(short)));
+
+            //Write the size of the identifier
+            Marshal.WriteInt16(result, (short)abID.Length);
+
+            //Then copy the block of memory
+            Marshal.Copy(abID, 0, new IntPtr(result.ToInt64() + 2), abID.Length);
+            return result;
+        }
+
+        public static bool operator==(ShellItemID lhs, ShellItemID rhs)
+        {
+            return lhs.abID.SequenceEqual(rhs.abID);
+        }
+
+        public static bool operator!=(ShellItemID lhs, ShellItemID rhs)
+        {
+            return !lhs.abID.SequenceEqual(rhs.abID);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj is ShellItemID)
+                return this == (ShellItemID)obj;
+            return this.Equals(obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
     }
 }

trunk/eraser/Eraser/SchedulerPanel.cs

@@ -361 +361 @@
             string descriptionMessage = string.Empty;
             string descriptionInsert = string.Empty;
-            const string descrptionPlaceholder = "%1";
-            if (!e.Data.GetDataPresent(DataFormats.FileDrop))
-                e.Effect = DragDropEffects.None;
-            else
-            {
-                string[] files = (string[])e.Data.GetData(DataFormats.FileDrop, false);
-                bool isTaskList = true;
-                foreach (string file in files)
-                {
-                    if (descriptionInsert.Length < 259 &&
-                        (descriptionInsert.Length < 3 || descriptionInsert.Substring(descriptionInsert.Length - 3) != "..."))
+            string descriptionItemFormat = S._("{0}, ");
+            const string descriptionPlaceholder = "%1";
+            
+            bool recycleBinIncluded = false;
+            List<string> files = e.Data.GetDataPresent(DataFormats.FileDrop) ?
+                new List<string>((string[])e.Data.GetData(DataFormats.FileDrop, false)) :
+                new List<string>();
+            if (e.Data.GetDataPresent("Shell IDList Array"))
+            {
+                MemoryStream stream = (MemoryStream)e.Data.GetData("Shell IDList Array");
+                byte[] buffer = new byte[stream.Length];
+                stream.Read(buffer, 0, buffer.Length);
+                ShellCIDA cida = new ShellCIDA(buffer);
+
+                if (cida.cidl > 0)
+                {
+                    for (int i = 1; i <= cida.cidl; ++i)
                     {
-                        string append = string.Format(CultureInfo.InvariantCulture, "{0}, ",
-                            Path.GetFileNameWithoutExtension(file));
-                        if (descriptionInsert.Length + append.Length > 259)
+                        if (cida.aoffset[i].Guid != Guid.Empty)
                         {
-                            descriptionInsert += ".....";
+                            if (cida.aoffset[i].Guid == Shell.KnownFolderIDs.RecycleBin)
+                            {
+                                descriptionInsert += string.Format(CultureInfo.InvariantCulture,
+                                    descriptionItemFormat, S._("Recycle Bin"));
+                                recycleBinIncluded = true;
+                            }
                         }
                         else
                         {
-                            descriptionInsert += append;
+                            files.Add(cida.aoffset[i].Path);
                         }
                     }
-
-                    if (Path.GetExtension(file) != ".ersx")
-                        isTaskList = false;
-                }
-                descriptionInsert = descriptionInsert.Remove(descriptionInsert.Length - 2);
-
-                if (isTaskList)
-                {
-                    e.Effect = DragDropEffects.Copy;
-                    descriptionMessage = S._("Import tasks from {0}", descrptionPlaceholder);
-                }
-                else
-                {
-                    e.Effect = DragDropEffects.Move;
-                    descriptionMessage = S._("Erase {0}", descrptionPlaceholder);
-                }
+                }
+            }
+
+            bool isTaskList = !recycleBinIncluded;
+            foreach (string file in files)
+            {
+                if (descriptionInsert.Length < 259 &&
+                    (descriptionInsert.Length < 3 || descriptionInsert.Substring(descriptionInsert.Length - 3) != "..."))
+                {
+                    string append = string.Format(CultureInfo.InvariantCulture,
+                        descriptionItemFormat, Path.GetFileNameWithoutExtension(file));
+                    if (descriptionInsert.Length + append.Length > 259)
+                    {
+                        descriptionInsert += ".....";
+                    }
+                    else
+                    {
+                        descriptionInsert += append;
+                    }
+                }
+
+                if (Path.GetExtension(file) != ".ersx")
+                    isTaskList = false;
+            }
+            descriptionInsert = descriptionInsert.Remove(descriptionInsert.Length - 2);
+
+            if (!recycleBinIncluded && files.Count == 0)
+                e.Effect = DragDropEffects.None;
+            else if (isTaskList)
+            {
+                e.Effect = DragDropEffects.Copy;
+                descriptionMessage = S._("Import tasks from {0}", descriptionPlaceholder);
+            }
+            else
+            {
+                e.Effect = DragDropEffects.Move;
+                descriptionMessage = S._("Erase {0}", descriptionPlaceholder);
             }
 
@@ -422 +452 @@
         private void scheduler_DragDrop(object sender, DragEventArgs e)
         {
-            if (!e.Data.GetDataPresent(DataFormats.FileDrop))
-            {
-                e.Effect = DragDropEffects.None;
-                return;
-            }
-
             DropTargetHelper.Drop(e.Data, new Point(e.X, e.Y), e.Effect);
+            if (e.Effect == DragDropEffects.None)
+                return;
+
+            bool recycleBinIncluded = false;
+            List<string> files = e.Data.GetDataPresent(DataFormats.FileDrop) ?
+                new List<string>((string[])e.Data.GetData(DataFormats.FileDrop, false)) :
+                new List<string>();
+            if (e.Data.GetDataPresent("Shell IDList Array"))
+            {
+                MemoryStream stream = (MemoryStream)e.Data.GetData("Shell IDList Array");
+                byte[] buffer = new byte[stream.Length];
+                stream.Read(buffer, 0, buffer.Length);
+                ShellCIDA cida = new ShellCIDA(buffer);
+
+                if (cida.cidl > 0)
+                {
+                    for (int i = 1; i <= cida.cidl; ++i)
+                    {
+                        if (cida.aoffset[i].Guid != Guid.Empty)
+                        {
+                            if (cida.aoffset[i].Guid == Shell.KnownFolderIDs.RecycleBin)
+                                recycleBinIncluded = true;
+                        }
+                        else
+                        {
+                            files.Add(cida.aoffset[i].Path);
+                        }
+                    }
+                }
+            }
 
             //Schedule the task dialog to be shown (to get to the event loop so that
             //ComCtl32.dll v6 is used.)
-            BeginInvoke((Action<DragDropEffects, string[]>)scheduler_DragDropConfirm,
-                e.Effect, e.Data.GetData(DataFormats.FileDrop, false));
+            BeginInvoke((Action<DragDropEffects, List<string>, bool>)scheduler_DragDropConfirm,
+                e.Effect, files, recycleBinIncluded);
         }
 
@@ -441 +495 @@
         /// <param name="effect">The Drag/drop effect of the operation.</param>
         /// <param name="files">The files which were dropped into the program.</param>
-        private void scheduler_DragDropConfirm(DragDropEffects effect, string[] files)
+        /// <param name="recycleBinIncluded">True if the recycle bin was among the
+        /// items dropped.</param>
+        private void scheduler_DragDropConfirm(DragDropEffects effect, List<string> files,
+            bool recycleBinIncluded)
         {
             //Determine whether we are importing a task list or dragging files for
@@ -470 +527 @@
                 //Create a task with the default settings
                 Task task = new Task();
-                foreach (string file in files)
-                {   
-                    FileSystemObjectErasureTarget target;
-                    if ((File.GetAttributes(file) & FileAttributes.Directory) != 0)
-                        target = new FolderErasureTarget();
-                    else
-                        target = new FileErasureTarget();
-                    target.Path = file;
-
-                    task.Targets.Add(target);
-                }
+                if (files != null)
+                    foreach (string file in files)
+                    {   
+                        FileSystemObjectErasureTarget target;
+                        if ((File.GetAttributes(file) & FileAttributes.Directory) != 0)
+                            target = new FolderErasureTarget();
+                        else
+                            target = new FileErasureTarget();
+                        target.Path = file;
+
+                        task.Targets.Add(target);
+                    }
+
+                //Add the recycle bin if it was specified
+                if (recycleBinIncluded)
+                    task.Targets.Add(new RecycleBinErasureTarget());
 
                 //Add the task, asking the user for his intent.

trunk/eraser/Eraser/Strings.en.resx

@@ -223 +223 @@
     <value>Task executed</value>
   </data>
+  <data name="{0}, " xml:space="preserve">
+    <value>{0}, </value>
+  </data>
+  <data name="Recycle Bin" xml:space="preserve">
+    <value>Recycle Bin</value>
+  </data>
   <data name="Import tasks from {0}" xml:space="preserve">
     <value>Import tasks from {0}</value>

trunk/eraser/Eraser/Strings.it.resx

@@ -223 +223 @@
     <value>Operazione eseguita</value>
   </data>
+  <data name="{0}, " xml:space="preserve">
+    <value>(Untranslated)</value>
+  </data>
+  <data name="Recycle Bin" xml:space="preserve">
+    <value>(Untranslated)</value>
+  </data>
   <data name="Import tasks from {0}" xml:space="preserve">
     <value>Importazione operazioni da {0}</value>

trunk/eraser/Eraser/Strings.nl.resx

@@ -223 +223 @@
     <value>(Untranslated)</value>
   </data>
+  <data name="{0}, " xml:space="preserve">
+    <value>(Untranslated)</value>
+  </data>
+  <data name="Recycle Bin" xml:space="preserve">
+    <value>(Untranslated)</value>
+  </data>
   <data name="Import tasks from {0}" xml:space="preserve">
     <value>(Untranslated)</value>

trunk/eraser/Eraser/Strings.pl.resx

@@ -223 +223 @@
     <value>Zadanie wykonano</value>
   </data>
+  <data name="{0}, " xml:space="preserve">
+    <value>(Untranslated)</value>
+  </data>
+  <data name="Recycle Bin" xml:space="preserve">
+    <value>(Untranslated)</value>
+  </data>
   <data name="Import tasks from {0}" xml:space="preserve">
     <value>Importuj zadania z {0}</value>

trunk/eraser/Eraser/Strings.resx

@@ -223 +223 @@
     <value>Task executed</value>
   </data>
+  <data name="{0}, " xml:space="preserve">
+    <value>{0}, </value>
+  </data>
+  <data name="Recycle Bin" xml:space="preserve">
+    <value>Recycle Bin</value>
+  </data>
   <data name="Import tasks from {0}" xml:space="preserve">
     <value>Import tasks from {0}</value>