FolderTreeView Control

private void TreeViewBeforeExpand(object sender, System.Windows.Forms.TreeViewCancelEventArgs e)
{
	this.BeginUpdate();
	ShellOperations.ExpandBranch(e.Node, this.ImageList, showFoldersOnly);
	this.EndUpdate();

	// This kludge handles cases where the tree view doesn't fire this event before
	// a request to drill to a path occurs.  This happens any time the tree view is
	// placed in a non-visible area, such as a tab page that isn't immediately visible
	// when the application starts up.
	if (beforeExpandFired==false)
	{
		beforeExpandFired=true;
		if (drillToFolder != null)
		{
			DrillToFolder(drillToFolder);
		}
	}
}

public bool DrillToFolder(string folderPath)
{
	// if the initial TreeViewCancelEvent hasn't fired yet, hold off on the
	// drill to folder until it has.
	if (!beforeExpandFired)
	{
		drillToFolder=folderPath;
		return false;
	}
        ...
}

public static Shell32.FolderItem GetFolderItemFromFolder(Shell32.Folder folder)
{
 if(folder != null)
 {
  try
  {
   IntPtr fldPtr = Marshal.GetComInterfaceForObject(folder, typeof(Shell32.Folder2));
   try
   {
    Shell32.Folder2 fldr2 = (Shell32.Folder2)Marshal.GetObjectForIUnknown(fldPtr);
    try
    {
     return fldr2.Self;
    }
    finally
    {
     /* GetObjectForIUnknown called AddRef on fldr2. 
      * So we'll release it.*/
     Marshal.ReleaseComObject(fldr2);
    }
   }
   finally
   {
    /* GetComInterfaceForObject called AddRef for fldPtr. 
     * So we'll release it as well.*/
    Marshal.Release(fldPtr);
   }
  }
  catch{}
 }
 return null;
}

private TreeNode DrillTreeByFolderList(TreeNodeCollection tnLst, ArrayList folderList)
{
 Shell32.Folder seekFolder = folderList[folderList.Count - 1] as Shell32.Folder;
 folderList.RemoveAt(folderList.Count - 1);

 string s1 = seekFolder.Title;
Shell32.FolderItem seekFldItem = ShellOperations.GetFolderItemFromFolder(seekFolder);
 if(seekFldItem != null)
  s1 = seekFldItem.Name;

 foreach(TreeNode tn in tnLst)
 {
  Shell32.FolderItem curFolder = (Shell32.FolderItem)tn.Tag;
  string s2 = curFolder.Name;
  if((String.Compare(s1, s2, true) == 0))
  {
   tn.Expand();
   if(folderList.Count > 0)
    return DrillTreeByFolderList(tn.Nodes, folderList);
   else
    return tn;
  }
 }
 return null;
}

public static Shell32.FolderItem GetFolderItemFromFolder(Shell32.Folder folder)
{
 if(folder != null)
 {
  try
  {
   /*
    * GetComInterfaceForObject is a wraper for a set of Ole calls, including
    *  (IDispatch.)GetTypeInfo , (ITypeInfo.)GetContainingTypeLib, GetTypeAttr,
    *  GetRefTypeOfImplType, GetRefTypeInfo and so on...
    * Notice that the IntPtr is a CLR complient type, so no need to use "unsafe" code
    * and "fixed" directive.
    * */
   IntPtr fldPtr = <a target=_blank title='New Window' href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemruntimeinteropservicesmarshalclassgetcominterfaceforobjecttopic.asp">Marshal.GetComInterfaceForObject</a>(folder, typeof(Shell32.Folder2));
   /*
    * GetObjectForIUnknown is the way to convert the code-safe pointer into
    * a .NET interop class (in this case, an interface).
    * */
   Shell32.Folder2 fldr2 = (Shell32.Folder2)<a target=_blank title='New Window' href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemruntimeinteropservicesmarshalclassgetobjectforiunknowntopic.asp">Marshal.GetObjectForIUnknown</a>(fldPtr);
   /*
    * And, Walla!
    * */
   return <a target=_blank title='New Window' href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/shellcc/platform/shell/reference/objects/folder2/self.asp">fldr2.Self</a>;
  }
  catch{}
  return null;
 }
 return null;
}

public bool DrillToFolderByShell(string folderPath)
{
   Shell32.Shell shell32 = new Shell32.ShellClass();
   /* Here we'll get the leaf folder. 
    * This will work for Net path and Mapped paths 
    * as well as for standard locals. */
   Shell32.Folder shell32Folder = shell32.NameSpace(folderPath);
   if(shell32Folder != null)
   {
    /* If we found it, we'll add this folder, and all its' Parent-Folders
     * to a list. The last item in this list will be the root folder. */
    ArrayList fullLst = new ArrayList();
    fullLst.Add(shell32Folder);
    Shell32.Folder par = shell32Folder.ParentFolder;
    while(par != null)
    {
     fullLst.Add(par);
     par = par.ParentFolder;
    }
    /* Now, that we have our road map, we can drill down. 
     * We'll start from the root list. */
    SelectedNode =  DrillTreeByFolderList(Nodes, fullLst);
    return SelectedNode != null;
   }
   else
    throw new DirectoryNotFoundException("\"" + folderPath + "\" Not found");
}

private TreeNode DrillTreeByFolderList(TreeNodeCollection tnLst, ArrayList folderList)
 {
   /* This is the recursive drilling.
    * For each call, we'll take the last folder 
    * (closest to the root) , and remove it from the list. */
   Shell32.Folder seekFolder = folderList[titleList.Count - 1] as Shell32.Folder;
   folderList.RemoveAt(titleList.Count - 1);

   string s1 = seekFolder.Title;
   /* Using the Folder.Title is a guessing game. 
    * If we can get the actual FolderItem.Name, we'll be 100% right. */
   Shell32.FolderItem seekFldItem = ShellOperations.GetFolderItemFromFolder(seekFolder);
   if(seekFldItem != null)
    s1 = seekFldItem.Name;

   foreach(TreeNode tn in tnLst)
   {
    Shell32.FolderItem curFolder = (Shell32.FolderItem)tn.Tag;
    string s2 = curFolder.Name;
    /* Case-Insensitive comparison tells us if we have the right
     * folder, and if we can drill on or stop.*/
    if((String.Compare(s1, s2, true) == 0))
    {
     tn.Expand();
     if(titleList.Count > 0)
      return DrillTreeByTitleList(tn.Nodes, titleList);
     else
      return tn;
    }
   }

   /* Originally, I had a fail safe code here, that uses 
    * the dfolder.ParentFolder.Items() search, but I think
    * this is only necessary for Shell32 earlier then version 5. */

   return null;
 }