internal ShellStreamReader(ShellItem shellItem, IStorage parentStorage, FileAccess access)
{
this.shellItem = shellItem;
OpenStream(parentStorage, ref access);
this.canRead = (access == FileAccess.Read || access == FileAccess.ReadWrite);
this.canWrite = (access == FileAccess.Write || access == FileAccess.ReadWrite);
currentPos = 0;
}
private void InitVars()
{
IntPtr tempPidl;
ShellAPI.SHFILEINFO info;
//My Computer
info = new ShellAPI.SHFILEINFO();
tempPidl = IntPtr.Zero;
ShellAPI.SHGetSpecialFolderLocation(IntPtr.Zero, ShellAPI.CSIDL.DRIVES, out tempPidl);
ShellAPI.SHGetFileInfo(tempPidl, 0, ref info, ShellAPI.cbFileInfo,
ShellAPI.SHGFI.PIDL | ShellAPI.SHGFI.DISPLAYNAME | ShellAPI.SHGFI.TYPENAME);
sysfolderName = info.szTypeName;
mycompName = info.szDisplayName;
Marshal.FreeCoTaskMem(tempPidl);
//
//Dekstop
tempPidl = IntPtr.Zero;
ShellAPI.SHGetSpecialFolderLocation(IntPtr.Zero, ShellAPI.CSIDL.DESKTOP, out tempPidl);
IntPtr desktopFolderPtr;
ShellAPI.SHGetDesktopFolder(out desktopFolderPtr);
desktopItem = new ShellItem(this, tempPidl, desktopFolderPtr);
//
//My Documents
uint pchEaten = 0;
ShellAPI.SFGAO pdwAttributes = 0;
desktopItem.ShellFolder.ParseDisplayName(
IntPtr.Zero,
IntPtr.Zero,
SpecialFolderPath.MyDocuments,
ref pchEaten,
out tempPidl,
ref pdwAttributes);
info = new ShellAPI.SHFILEINFO();
ShellAPI.SHGetFileInfo(tempPidl, 0, ref info, ShellAPI.cbFileInfo,
ShellAPI.SHGFI.PIDL | ShellAPI.SHGFI.DISPLAYNAME);
mydocsName = info.szDisplayName;
Marshal.FreeCoTaskMem(tempPidl);
StringBuilder path = new StringBuilder(ShellAPI.MAX_PATH);
ShellAPI.SHGetFolderPath(
IntPtr.Zero, ShellAPI.CSIDL.PERSONAL,
IntPtr.Zero, ShellAPI.SHGFP.TYPE_CURRENT, path);
mydocsPath = path.ToString();
//
}
internal ShellItem(ShellBrowser browser, ShellItem parentItem, IntPtr pidl)
{
this.browser = browser;
this.parentItem = parentItem;
pidlRel = new PIDL(pidl, false);
SetText(this);
SetPath(this);
SetAttributesFile(this);
SetInfo(this);
sortFlag = MakeSortFlag(this);
}
public ShellItem(ShellBrowser browser, ShellItem parentItem, IntPtr pidl)
{
this.Browser = browser;
this.ParentItem = parentItem;
PIDLRel = new PIDL(pidl, false);
SetText(this);
SetPath(this);
SetAttributesFile(this);
SetInfo(this);
SortFlag = MakeSortFlag(this);
}
public bool GetListItem(ShellItem shellItem, out ListViewItem listItem)
{
listItem = null;
foreach (ListViewItem item in Items)
{
if (shellItem.Equals(item.Tag))
{
listItem = item;
return true;
}
}
return false;
}
public static bool GetIStorage(ShellItem item, out IntPtr storagePtr, out IStorage storage)
{
if (item.ParentItem.ShellFolder.BindToStorage(
item.PIDLRel.Ptr,
IntPtr.Zero,
ref ShellAPI.IID_IStorage,
out storagePtr) == ShellAPI.S_OK)
{
storage = (IStorage)Marshal.GetTypedObjectForIUnknown(storagePtr, typeof(IStorage));
return true;
}
else
{
storage = null;
storagePtr = IntPtr.Zero;
return false;
}
}
internal ShellItem(ShellBrowser browser, ShellItem parentItem, IntPtr pidl, IntPtr shellFolderPtr)
{
this.browser = browser;
this.parentItem = parentItem;
this.shellFolderPtr = shellFolderPtr;
this.shellFolder = (IShellFolder)Marshal.GetTypedObjectForIUnknown(shellFolderPtr, typeof(IShellFolder));
subFiles = new ShellItemCollection(this);
subFolders = new ShellItemCollection(this);
pidlRel = new PIDL(pidl, false);
SetText(this);
SetPath(this);
SetAttributesFolder(this);
SetInfo(this);
sortFlag = MakeSortFlag(this);
}
/// <summary>
/// This method will use the GetUIObjectOf method of IShellFolder to obtain the IDataObject of a
/// ShellItem.
/// </summary>
/// <param name="item">The item for which to obtain the IDataObject</param>
/// <param name="dataObjectPtr">A pointer to the returned IDataObject</param>
/// <returns>the IDataObject the ShellItem</returns>
public static IntPtr GetIDataObject(ShellItem[] items)
{
ShellItem parent = items[0].ParentItem != null ? items[0].ParentItem : items[0];
IntPtr[] pidls = new IntPtr[items.Length];
for (int i = 0; i < items.Length; i++)
pidls[i] = items[i].PIDLRel.Ptr;
IntPtr dataObjectPtr;
if (parent.ShellFolder.GetUIObjectOf(
IntPtr.Zero,
(uint)pidls.Length,
pidls,
ref ShellAPI.IID_IDataObject,
IntPtr.Zero,
out dataObjectPtr) == ShellAPI.S_OK)
{
return dataObjectPtr;
}
else
{
return IntPtr.Zero;
}
}
public bool GetTreeNode(ShellItem shellItem, out TreeNode treeNode)
{
ArrayList pathList = new ArrayList();
while (shellItem.ParentItem != null)
{
pathList.Add(shellItem);
shellItem = shellItem.ParentItem;
}
pathList.Add(shellItem);
pathList.Reverse();
treeNode = Nodes[0];
for (int i = 1; i < pathList.Count; i++)
{
bool found = false;
foreach (TreeNode node in treeNode.Nodes)
{
if (node.Tag != null && node.Tag.Equals(pathList[i]))
{
treeNode = node;
found = true;
break;
}
}
if (!found)
{
treeNode = null;
return false;
}
}
return true;
}
public int DragOver(ShellAPI.MK grfKeyState, ShellAPI.POINT pt, ref DragDropEffects pdwEffect)
{
bool reset = false;
#region Get DropItem
Point point = br.FolderView.PointToClient(new Point(pt.x, pt.y));
TreeViewHitTestInfo hitTest = br.FolderView.HitTest(point);
if(!TreeNode.Equals(dropNode, hitTest.Node))
{
if(dropTarget != null)
dropTarget.DragLeave();
ReleaseCom();
dropNode = hitTest.Node;
br.FolderView.SelectedNode = dropNode;
if(dropNode == null)
{
pdwEffect = DragDropEffects.None;
if(dropHelper != null)
dropHelper.DragOver(ref pt, pdwEffect);
return ShellAPI.S_OK;
}
else
{
ShellItem item = (ShellItem)dropNode.Tag;
parentDropItem = item;
ShellHelper.GetIDropTarget(item, out dropTargetPtr, out dropTarget);
reset = true;
}
}
else if(dropNode == null)
{
if(dropTarget != null)
dropTarget.DragLeave();
ReleaseCom();
dropNode = null;
br.SelectedNode = null;
pdwEffect = DragDropEffects.None;
if(dropHelper != null)
dropHelper.DragOver(ref pt, pdwEffect);
return ShellAPI.S_OK;
}
#endregion
if(dropTarget != null)
{
if(reset)
dropTarget.DragEnter(dropDataObject, grfKeyState, pt, ref pdwEffect);
else
dropTarget.DragOver(grfKeyState, pt, ref pdwEffect);
}
else
pdwEffect = DragDropEffects.None;
if(dropHelper != null)
dropHelper.DragOver(ref pt, pdwEffect);
return ShellAPI.S_OK;
}
internal static void SetIconIndex(ShellItem item, int index, bool SelectedIcon)
{
bool HasOverlay = false; //true if it's an overlay
int rVal = 0; //The returned Index
ShellAPI.SHGFI dwflag = ShellAPI.SHGFI.SYSICONINDEX | ShellAPI.SHGFI.PIDL | ShellAPI.SHGFI.ICON;
ShellAPI.FILE_ATTRIBUTE dwAttr = 0;
//build Key into HashTable for this Item
int Key = index * 256;
if (item.IsLink)
{
Key = Key | 1;
dwflag = dwflag | ShellAPI.SHGFI.LINKOVERLAY;
HasOverlay = true;
}
if (item.IsShared)
{
Key = Key | 2;
dwflag = dwflag | ShellAPI.SHGFI.ADDOVERLAYS;
HasOverlay = true;
}
if (SelectedIcon)
{
Key = Key | 4;
dwflag = dwflag | ShellAPI.SHGFI.OPENICON;
HasOverlay = true; //not really an overlay, but handled the same
}
if (imageTable.ContainsKey(Key))
{
rVal = (int)imageTable[Key];
}
else if (!HasOverlay && !item.IsHidden) //for non-overlay icons, we already have
{
rVal = (int)System.Math.Floor((double)Key / 256); // the right index -- put in table
imageTable[Key] = rVal;
}
else //don't have iconindex for an overlay, get it.
{
if (item.IsFileSystem & !item.IsDisk & !item.IsFolder)
{
dwflag = dwflag | ShellAPI.SHGFI.USEFILEATTRIBUTES;
dwAttr = dwAttr | ShellAPI.FILE_ATTRIBUTE.NORMAL;
}
PIDL pidlFull = item.PIDLFull;
ShellAPI.SHFILEINFO shfiSmall = new ShellAPI.SHFILEINFO();
ShellAPI.SHGetFileInfo(pidlFull.Ptr, dwAttr, ref shfiSmall, ShellAPI.cbFileInfo, dwflag | ShellAPI.SHGFI.SMALLICON);
ShellAPI.SHFILEINFO shfiLarge = new ShellAPI.SHFILEINFO();
ShellAPI.SHGetFileInfo(pidlFull.Ptr, dwAttr, ref shfiLarge, ShellAPI.cbFileInfo, dwflag | ShellAPI.SHGFI.LARGEICON);
Marshal.FreeCoTaskMem(pidlFull.Ptr);
lock (imageTable)
{
rVal = ShellAPI.ImageList_ReplaceIcon(smallImageListHandle, -1, shfiSmall.hIcon);
ShellAPI.ImageList_ReplaceIcon(largeImageListHandle, -1, shfiLarge.hIcon);
}
ShellAPI.DestroyIcon(shfiSmall.hIcon);
ShellAPI.DestroyIcon(shfiLarge.hIcon);
imageTable[Key] = rVal;
}
if (SelectedIcon)
item.SelectedImageIndex = rVal;
else
item.ImageIndex = rVal;
}
public ShellItemUpdateEventArgs(
ShellItem oldItem,
ShellItem newItem,
ShellItemUpdateType type)
{
this.oldItem = oldItem;
this.newItem = newItem;
this.type = type;
}
public static DragDropEffects CanDropClipboard(ShellItem item)
{
IntPtr dataObject;
ShellAPI.OleGetClipboard(out dataObject);
IntPtr targetPtr;
ShellDll.IDropTarget target;
DragDropEffects retVal = DragDropEffects.None;
if (GetIDropTarget(item, out targetPtr, out target))
{
#region Check Copy
DragDropEffects effects = DragDropEffects.Copy;
if (target.DragEnter(
dataObject,
ShellAPI.MK.CONTROL,
new ShellAPI.POINT(0, 0),
ref effects) == ShellAPI.S_OK)
{
if (effects == DragDropEffects.Copy)
retVal |= DragDropEffects.Copy;
target.DragLeave();
}
#endregion
#region Check Move
effects = DragDropEffects.Move;
if (target.DragEnter(
dataObject,
ShellAPI.MK.SHIFT,
new ShellAPI.POINT(0, 0),
ref effects) == ShellAPI.S_OK)
{
if (effects == DragDropEffects.Move)
retVal |= DragDropEffects.Move;
target.DragLeave();
}
#endregion
#region Check Lick
effects = DragDropEffects.Link;
if (target.DragEnter(
dataObject,
ShellAPI.MK.ALT,
new ShellAPI.POINT(0, 0),
ref effects) == ShellAPI.S_OK)
{
if (effects == DragDropEffects.Link)
retVal |= DragDropEffects.Link;
target.DragLeave();
}
#endregion
Marshal.ReleaseComObject(target);
Marshal.Release(targetPtr);
}
return retVal;
}
/// <summary>
/// Invokes a specific command for a set of pidls
/// </summary>
/// <param name="parent">the parent ShellItem which contains the pidls</param>
/// <param name="pidls">the pidls from the items for which to invoke</param>
/// <param name="cmd">the execute string from the command to invoke</param>
/// <param name="ptInvoke">the point (in screen coördinates) from which to invoke</param>
public static void InvokeCommand(ShellItem parent, IntPtr[] pidls, string cmd, Point ptInvoke)
{
IntPtr icontextMenuPtr;
IContextMenu iContextMenu;
if (GetIContextMenu(parent.ShellFolder, pidls, out icontextMenuPtr, out iContextMenu))
{
try
{
InvokeCommand(
iContextMenu,
cmd,
ShellItem.GetRealPath(parent),
ptInvoke);
}
catch (Exception) { }
finally
{
if (iContextMenu != null)
Marshal.ReleaseComObject(iContextMenu);
if (icontextMenuPtr != IntPtr.Zero)
Marshal.Release(icontextMenuPtr);
}
}
}
/// <summary>
/// Reset all fields to the default values and release the IDropTarget
/// </summary>
private void ResetDrop()
{
if (dropListItem != null)
{
dropListItem.Selected = wasSelected;
dropListItem = null;
parentDropItem = null;
}
br.SelectionChange = true;
}
public int DragOver(ShellAPI.MK grfKeyState, ShellAPI.POINT pt, ref DragDropEffects pdwEffect)
{
bool reset = false;
#region Get DropItem
Point point = br.FileView.PointToClient(new Point(pt.x, pt.y));
ListViewHitTestInfo hitTest = br.FileView.HitTest(point);
if (hitTest.Item != null &&
(br.FileView.View != View.Details || hitTest.SubItem == null || hitTest.Item.Name == hitTest.SubItem.Name) &&
(hitTest.Location == ListViewHitTestLocations.Image ||
hitTest.Location == ListViewHitTestLocations.Label ||
hitTest.Location == ListViewHitTestLocations.StateImage))
{
if (!hitTest.Item.Equals(dropListItem))
{
if (dropTarget != null)
dropTarget.DragLeave();
ReleaseCom();
if (dropListItem != null)
dropListItem.Selected = wasSelected;
dropListItem = hitTest.Item;
wasSelected = dropListItem.Selected;
dropListItem.Selected = true;
ShellItem item = (ShellItem)dropListItem.Tag;
parentDropItem = item;
ShellHelper.GetIDropTarget(item, out dropTargetPtr, out dropTarget);
reset = true;
}
}
else
{
if (dropListItem != null)
{
if (dropTarget != null)
dropTarget.DragLeave();
ReleaseCom();
dropListItem.Selected = wasSelected;
dropListItem = null;
parentDropItem = br.SelectedItem;
ShellHelper.GetIDropTarget(br.SelectedItem, out dropTargetPtr, out dropTarget);
reset = true;
}
}
#endregion
if (dropTarget != null)
{
if (reset)
dropTarget.DragEnter(dropDataObject, grfKeyState, pt, ref pdwEffect);
else
dropTarget.DragOver(grfKeyState, pt, ref pdwEffect);
}
else
pdwEffect = DragDropEffects.None;
if (dropHelper != null)
dropHelper.DragOver(ref pt, pdwEffect);
return ShellAPI.S_OK;
}
public static bool GetNewContextMenu(ShellItem item, out IntPtr iContextMenuPtr, out IContextMenu iContextMenu)
{
if (ShellAPI.CoCreateInstance(
ref ShellAPI.CLSID_NewMenu,
IntPtr.Zero,
ShellAPI.CLSCTX.INPROC_SERVER,
ref ShellAPI.IID_IContextMenu,
out iContextMenuPtr) == ShellAPI.S_OK)
{
iContextMenu = Marshal.GetTypedObjectForIUnknown(iContextMenuPtr, typeof(IContextMenu)) as IContextMenu;
IntPtr iShellExtInitPtr;
if (Marshal.QueryInterface(
iContextMenuPtr,
ref ShellAPI.IID_IShellExtInit,
out iShellExtInitPtr) == ShellAPI.S_OK)
{
IShellExtInit iShellExtInit = Marshal.GetTypedObjectForIUnknown(
iShellExtInitPtr, typeof(IShellExtInit)) as IShellExtInit;
PIDL pidlFull = item.PIDLFull;
iShellExtInit.Initialize(pidlFull.Ptr, IntPtr.Zero, 0);
Marshal.ReleaseComObject(iShellExtInit);
Marshal.Release(iShellExtInitPtr);
pidlFull.Free();
return true;
}
else
{
if (iContextMenu != null)
{
Marshal.ReleaseComObject(iContextMenu);
iContextMenu = null;
}
if (iContextMenuPtr != IntPtr.Zero)
{
Marshal.Release(iContextMenuPtr);
iContextMenuPtr = IntPtr.Zero;
}
return false;
}
}
else
{
iContextMenuPtr = IntPtr.Zero;
iContextMenu = null;
return false;
}
}
private ListViewItem GetListViewItem(string[] subItems, ShellItem shellItem)
{
ListViewItem listItem = new ListViewItem(shellItem.Text, shellItem.ImageIndex);
listItem.Name = listItem.Text;
listItem.Tag = shellItem;
provider.ProviderItem = shellItem;
if (shellItem.CanRead)
{
if (shellItem.IsFolder)
{
#region Folder Info
for (int i = 1; i < fileView.Columns.Count; i++)
{
IColumnPlugin plugin = fileView.Columns[i].Tag as IColumnPlugin;
try
{
subItems[i - 1] = plugin.GetFolderInfo(
provider,
fileView.Columns[i].Text,
shellItem);
}
catch (Exception)
{
subItems[i - 1] = string.Empty;
}
}
provider.ReleaseStorage();
#endregion
}
else
{
#region File Info
for (int i = 1; i < fileView.Columns.Count; i++)
{
IColumnPlugin plugin = fileView.Columns[i].Tag as IColumnPlugin;
try
{
subItems[i - 1] = plugin.GetFileInfo(
provider,
fileView.Columns[i].Text,
shellItem);
}
catch (Exception)
{
subItems[i - 1] = string.Empty;
}
}
provider.ReleaseStream();
#endregion
}
}
else
{
for (int i = 1; i < fileView.Columns.Count; i++)
{
subItems[i - 1] = string.Empty;
}
}
provider.ProviderItem = null;
listItem.SubItems.AddRange(subItems);
return listItem;
}
/// <summary>
/// This method will use the GetUIObjectOf method of IShellFolder to obtain the IDropTarget of a
/// ShellItem.
/// </summary>
/// <param name="item">The item for which to obtain the IDropTarget</param>
/// <param name="dropTargetPtr">A pointer to the returned IDropTarget</param>
/// <returns>the IDropTarget from the ShellItem</returns>
public static bool GetIDropTarget(ShellItem item, out IntPtr dropTargetPtr, out ShellDll.IDropTarget dropTarget)
{
ShellItem parent = item.ParentItem != null ? item.ParentItem : item;
if (parent.ShellFolder.GetUIObjectOf(
IntPtr.Zero,
1,
new IntPtr[] { item.PIDLRel.Ptr },
ref ShellAPI.IID_IDropTarget,
IntPtr.Zero,
out dropTargetPtr) == ShellAPI.S_OK)
{
dropTarget =
(ShellDll.IDropTarget)Marshal.GetTypedObjectForIUnknown(dropTargetPtr, typeof(ShellDll.IDropTarget));
return true;
}
else
{
dropTarget = null;
dropTargetPtr = IntPtr.Zero;
return false;
}
}
/// <summary>
/// Initialises the base ShellItems, including the Desktop and all it's children and the children of My Computer.
/// These items are also added to the TreeView and the navigation bar.
/// </summary>
private void InitBaseItems()
{
if (ShellBrowser == null)
ShellBrowser = new ShellBrowser();
desktopNode = new TreeNode(
ShellBrowser.DesktopItem.Text,
ShellBrowser.DesktopItem.ImageIndex,
ShellBrowser.DesktopItem.SelectedImageIndex);
desktopNode.Tag = ShellBrowser.DesktopItem;
desktopNode.Name = desktopNode.Text;
folderView.Nodes.Add(desktopNode);
navAddressBox.Items.Clear();
navAddressBox.Items.Add(new BrowserComboItem(ShellBrowser.DesktopItem, 0));
navAddressBox.CurrentItem = (BrowserComboItem)navAddressBox.Items[0];
selectedNode = desktopNode;
selectedItem = ShellBrowser.DesktopItem;
ShellBrowser.DesktopItem.Expand(false, true, IntPtr.Zero);
foreach (ShellItem desktopChild in ShellBrowser.DesktopItem.SubFolders)
{
TreeNode desktopChildNode = new TreeNode(
desktopChild.Text,
desktopChild.ImageIndex,
desktopChild.SelectedImageIndex);
desktopChildNode.Tag = desktopChild;
desktopChildNode.Name = desktopChildNode.Text;
navAddressBox.Items.Add(new BrowserComboItem(desktopChild, 1));
if (desktopChildNode.Text == ShellBrowser.MyComputerName)
{
myCompNode = desktopChildNode;
desktopChild.Expand(false, true, IntPtr.Zero);
foreach (ShellItem myCompChild in desktopChild.SubFolders)
{
TreeNode myCompChildNode = new TreeNode(
myCompChild.Text,
myCompChild.ImageIndex,
myCompChild.SelectedImageIndex);
myCompChildNode.Tag = myCompChild;
myCompChildNode.Name = myCompChildNode.Text;
if (myCompChild.HasSubfolder)
myCompChildNode.Nodes.Add(string.Empty);
navAddressBox.Items.Add(new BrowserComboItem(myCompChild, 2));
desktopChildNode.Nodes.Add(myCompChildNode);
}
}
else if (desktopChild.HasSubfolder)
desktopChildNode.Nodes.Add(string.Empty);
desktopNode.Nodes.Add(desktopChildNode);
}
}
public static bool GetIQueryInfo(ShellItem item, out IntPtr iQueryInfoPtr, out IQueryInfo iQueryInfo)
{
ShellItem parent = item.ParentItem != null ? item.ParentItem : item;
if (parent.ShellFolder.GetUIObjectOf(
IntPtr.Zero,
1,
new IntPtr[] { item.PIDLRel.Ptr },
ref ShellAPI.IID_IQueryInfo,
IntPtr.Zero,
out iQueryInfoPtr) == ShellAPI.S_OK)
{
iQueryInfo =
(IQueryInfo)Marshal.GetTypedObjectForIUnknown(iQueryInfoPtr, typeof(IQueryInfo));
return true;
}
else
{
iQueryInfo = null;
iQueryInfoPtr = IntPtr.Zero;
return false;
}
}
/// <summary>
/// When a new directory is selected, this method is called to clear the ListView and fill it with
/// the contents of the new directory
/// </summary>
/// <param name="oldItem">The ShellItem of the previous selected directory</param>
/// <param name="newItem">The ShellItem of the new selected directory</param>
private bool SetNewPath(ShellItem oldItem, ShellItem newItem)
{
Cursor.Current = Cursors.WaitCursor;
if (oldItem != newItem && newItem.Expand(true, false, Handle))
{
ShellBrowser.UpdateCondition.ContinueUpdate = false;
fileView.BeginUpdate();
fileView.Items.Clear();
fileView.ClearSelections();
if (oldItem != null)
{
bool used = false;
foreach (Browser br in ShellBrowser.Browsers)
{
if (!this.Equals(br) && oldItem.Equals(br.SelectedItem))
{
used = true;
break;
}
}
if (!used)
oldItem.Clear(true, false);
}
selectedItem = newItem;
ListViewItem[] newListItemsArray = new ListViewItem[newItem.Count];
string[] subItems = new string[fileView.Columns.Count - 1];
for (int i = 0; i < newListItemsArray.Length; i++)
{
newListItemsArray[i] = GetListViewItem(subItems, newItem[i]);
}
fileView.SetSorting(true);
fileView.Items.AddRange(newListItemsArray);
fileView.SetSorting(false);
fileView.EndUpdate();
Cursor.Current = Cursors.Default;
return true;
}
else
{
Cursor.Current = Cursors.Default;
return (oldItem == newItem);
}
}
internal ShellItem[] GetPath(ShellItem item)
{
ArrayList pathList = new ArrayList();
ShellItem currentItem = item;
while (currentItem.ParentItem != null)
{
pathList.Add(currentItem);
currentItem = currentItem.ParentItem;
}
pathList.Add(currentItem);
pathList.Reverse();
return (ShellItem[])pathList.ToArray(typeof(ShellItem));
}
public SelectedFolderChangedEventArgs(TreeNode node)
{
this.node = node;
item = (ShellItem)node.Tag;
}
public DragEnterEventArgs(ShellItem parent, Control dragStartControl)
{
this.parent = parent;
this.dragStartControl = dragStartControl;
}
/// <summary>
/// Selects a path from an existing ShellItem, this ShellItem must be present in the browsers
/// ShellBrowser, otherwise it can't be selected.
/// </summary>
/// <param name="specialFolder">The ShellItem to select</param>
/// <returns>The TreeNode of the directory which was selected, this will be null if the directory
/// doesn't exist</returns>
public TreeNode SelectPath(ShellItem item, bool expandNode)
{
if (item == null)
return null;
ShellItem[] path = ShellBrowser.GetPath(item);
if (path != null)
{
TreeNode currentNode = desktopNode;
for (int i = 1; i < path.Length; i++)
{
ExtendTreeNode(currentNode, false);
foreach (TreeNode subNode in currentNode.Nodes)
{
if (path[i].Equals(subNode.Tag))
{
currentNode = subNode;
break;
}
}
}
if (expandNode)
currentNode.Expand();
folderView.SelectedNode = currentNode;
return currentNode;
}
else
return null;
}
public int DragEnter(IntPtr pDataObj, ShellAPI.MK grfKeyState, ShellAPI.POINT pt, ref DragDropEffects pdwEffect)
{
mouseButtons = grfKeyState;
br.FolderView.Focus();
br.SelectionChange = false;
lastSelectedNode = br.FolderView.SelectedNode;
ReleaseCom();
dropDataObject = pDataObj;
#region Get DropItem
Point point = br.FolderView.PointToClient(new Point(pt.x, pt.y));
TreeViewHitTestInfo hitTest = br.FolderView.HitTest(point);
dropNode = hitTest.Node;
br.FolderView.SelectedNode = dropNode;
if(dropNode != null)
{
ShellItem item = (ShellItem)dropNode.Tag;
parentDropItem = item;
if(ShellHelper.GetIDropTarget(item, out dropTargetPtr, out dropTarget))
{
dropTarget.DragEnter(pDataObj, grfKeyState, pt, ref pdwEffect);
}
}
#endregion
if(dropHelper != null)
dropHelper.DragEnter(br.Handle, pDataObj, ref pt, pdwEffect);
return ShellAPI.S_OK;
}
private void AddNavBackForwardItem(ToolStripSplitButton button, ShellItem selectedItem)
{
Bitmap image = ShellImageList.GetIcon(selectedItem.ImageIndex, true).ToBitmap();
ToolStripMenuItem backItem = new ToolStripMenuItem(selectedItem.Text, image);
backItem.Name = backItem.Text;
backItem.Tag = selectedItem;
backItem.ImageScaling = ToolStripItemImageScaling.None;
if (button.DropDownItems.Count == maxBackForward)
button.DropDownItems.RemoveAt(maxBackForward - 1);
button.DropDownItems.Insert(0, backItem);
button.Enabled = true;
}
/// <summary>
/// Reset all fields to the default values and release the IDropTarget
/// </summary>
private void ResetDrop()
{
if(dropNode != null)
{
dropNode = null;
parentDropItem = null;
}
if(lastSelectedNode != null)
br.FolderView.SelectedNode = lastSelectedNode;
br.SelectionChange = true;
}
/// <summary>
/// This method initialises the dragging of a ListViewItem
/// </summary>
void ItemDrag(object sender, ItemDragEventArgs e)
{
ReleaseCom();
startButton = e.Button;
ShellItem[] items = new ShellItem[br.FileView.SelectedItems.Count];
for (int i = 0; i < br.FileView.SelectedItems.Count; i++)
{
items[i] = (ShellItem)br.FileView.SelectedItems[i].Tag;
}
dataObjectPtr = ShellHelper.GetIDataObject(items);
if (dataObjectPtr != IntPtr.Zero)
{
DragDropEffects effects;
OnDragStart(new DragEnterEventArgs((items[0].ParentItem != null ? items[0].ParentItem : items[0]), br.FileView));
ShellAPI.DoDragDrop(dataObjectPtr, this, DragDropEffects.Copy | DragDropEffects.Link | DragDropEffects.Move, out effects);
OnDragEnd(new EventArgs());
}
}
