The TreeView control has a property, Nodes, which gets a TreeNodeCollection object. The TreeNodeCollection is a collection of TreeNode objects, each of which represents a node in the tree. Start by emptying that collection:

tvw.Nodes.Clear(  );

You are ready to fill the TreeView’s Nodes collection by recursing through the directories of all the drives. First, you get all the logical drives on the system. To do so you call a static method of the Environment object, GetLogicalDrives( ). The Environment class provides information about and access to the current platform environment. You can use the Environment object to get the machine name, OS version, system directory, and so forth, from the computer on which you are running your program.

string[] strDrives = Environment.GetLogicalDrives(  );

GetLogicalDrives( ) returns an array of strings, each of which represents the root directory of one of the logical drives. You will iterate over that collection, adding nodes to the TreeView control as you go.

foreach (string rootDirectoryName in strDrives)
{

You should process each drive within the foreach loop. The very first thing you need to determine is whether the drive is ready. My hack for that is to get the list of top-level directories from the drive by calling GetDirectories( ) on a DirectoryInfo object I created for the root directory:

DirectoryInfo dir = new DirectoryInfo(rootDirectoryName);
dir.GetDirectories(  );

The DirectoryInfo class exposes instance methods for creating, moving, and enumerating through directories, their files, and their subdirectories. The DirectoryInfo class is covered in detail in Chapter 21.

The GetDirectories( ) method returns a list of directories, but you’ll throw this list away. You are calling it here only to generate an exception if the drive is not ready.

You’ll wrap the call in a try block and take no action in the catch block. The effect is that if an exception is thrown, the drive is skipped.

Once you know that the drive is ready, you create a TreeNode to hold the root directory of the drive and add that node to the TreeView control:

TreeNode ndRoot = new TreeNode(rootDirectoryName);
tvw.Nodes.Add(ndRoot);

You now want to recurse through the directories, so you call into a new routine, GetSubDirectoryNodes( ), passing in the root node, the name of the root directory, and the flag indicating whether you want files:

if (isSource)
{
   GetSubDirectoryNodes(ndRoot, ndRoot.Text, true);
}
else
{
   GetSubDirectoryNodes(ndRoot, ndRoot.Text, false);
}

You’re probably wondering why you need to pass in ndRoot.Text if you’re already passing in ndRoot. Patience; you’ll see why this is needed when you recurse back into GetSubDirectoryNodes.

GetSubDirectoryNodes( ) begins by once again calling GetDirectories( ), this time stashing away the resulting array of DirectoryInfo objects:

private void GetSubDirectoryNodes(
   TreeNode parentNode, string fullName, bool getFileNames)
{
   DirectoryInfo dir = new DirectoryInfo(fullName);
   DirectoryInfo[] dirSubs = dir.GetDirectories(  );

Notice that the node passed in is named parentNode. The current level of nodes will be considered children to the node passed in. This is how you map the directory structure to the hierarchy of the tree view.

Iterate over each subdirectory, skipping any that are marked Hidden:

foreach (Directory dirSub in dirSubs)
{
    if ( (dirSub.Attributes & 
         FileSystemAttributes.Hidden) != 0 )
    {
        continue;
    }

FileSystemAttributes is an enum; other possible values include Archive, Compressed, Directory, Encrypted, Hidden, Normal, ReadOnly, etc.

You create a TreeNode with the directory name and add it to the Nodes collection of the node passed in to the method (parentNode):

TreeNode subNode = new TreeNode(dirSub.Name);
parentNode.Nodes.Add(subNode);

You now recurse back into the GetSubDirectoryNodes( ) method, passing in the node you just created as the new parent, the full path as the full name of the parent, and the flag:

GetSubDirectoryNodes(subNode,dirSub.FullName,getFileNames);

Once you’ve recursed through the subdirectories, it is time to get the files for the directory, if the getFileNames flag is true. To do so, you call the GetFiles( ) method on the DirectoryInfo object. What is returned is an array of FileInfo objects:

if (getFileNames)
{
   //  Get any files for this node.
   FileInfo[] files = dir.GetFiles(  );

The FileInfo class (covered in Chapter 21) provides instance methods for manipulating files.

You can now iterate over this collection, accessing the Name property of the FileInfo object and passing that name to the constructor of a TreeNode, which you then add to the parent node’s Nodes collection (thus creating a child node). There is no recursion this time because files do not have subdirectories:

foreach (FileInfo file in files)
{
   TreeNode fileNode = new TreeNode(file.Name);
   parentNode.Nodes.Add(fileNode);
}

That’s all it takes to fill the two tree views.

There are two TreeView objects, each with its own event handler. Consider the source TreeView object first. The user checks the files and directories he wants to copy from. Each time the user clicks a file or directory, a number of events are raised. The event you must handle is AfterCheck.

To do so, you implement a custom event-handler method you will create and name tvwSource_AfterCheck( ). Visual Studio.NET will wire this to the event handler, or if you are not using the integrated development environment, you must do so yourself.

tvwSource.AfterCheck += 
new System.Windows.Forms.TreeViewEventHandler 
   (this.tvwSource_AfterCheck);

The implementation of AfterCheck( ) delegates the work to a recursable method named SetCheck( ), you’ll also write.

protected void tvwSource_AfterCheck (
object sender, System.Windows.Forms.TreeViewEventArgs e)
{
    SetCheck(e.node,e.node.Checked);
}

The event handler passes in the sender object and an object of type TreeViewEventArgs. It turns out that you can get the node from this TreeViewEventArgs object (e). You call SetCheck( ), passing in the node and the state of whether the node has been checked.

Each node has a Nodes property, which gets a TreeNodeCollection containing all the subnodes. SetCheck( ) recurses through the current node’s Nodes collection, setting each subnode’s check mark to match that of the node that was checked. In other words, when you check a directory, all its files and subdirectories are checked, recursively, all the way down.

For each TreeNode in the Nodes collection, you check to see if it is a leaf. A node is a leaf if its own Nodes collection has a count of zero. If so, you set its check property to whatever was passed in as a parameter. If it is not a leaf, you recurse.

private void SetCheck(TreeNode node, bool check)
{
    node.Checked = check;

    foreach (TreeNode n in node.Nodes)
    {
        if (node.Nodes.Count == 0)
        {
            node.Checked = check;
        }
        else
        {
            SetCheck(n,check);
        }
    }   
}

This propagates the check mark (or clears the check mark) down through the entire structure. In this way, the user can indicate that he wants to select all the files in all the subdirectories by clicking a single directory.

The event handler for the target TreeView is somewhat trickier. The event itself is AfterSelect. (Remember that the target TreeView does not have checkboxes.) This time, you want to take the one directory chosen and put its full path into the text box at the upper-left corner of the form.

To do so, you must work your way up through the nodes, finding the name of each parent directory and building the full path:

protected void tvwTargetDir_AfterSelect (
    object sender, System.Windows.Forms.TreeViewEventArgs e)
{

    string theFullPath = GetParentString(e.node);

We’ll look at GetParentString( ) in just a moment. Once you have the full path, you must lop off the backslash (if any) on the end and then you can fill the text box:

if (theFullPath.EndsWith("\")) 
{
    theFullPath = 
        theFullPath.Substring(0,theFullPath.Length-1);
}
txtTargetDir.Text = theFullPath; 

The GetParentString( ) method takes a node and returns a string with the full path. To do so, it recurses upward through the path, adding the backslash after any node that is not a leaf:

private string GetParentString(TreeNode node)
{
    if(node.Parent == null)
    {
        return node.Text;
    }
    else
    {
        return GetParentString(node.Parent) + node.Text +  
            (node.Nodes.Count == 0  ? "" : "\");
    }
}

The recursion stops when there is no parent; that is, when you hit the root directory.

Given the SetCheck( ) method developed earlier, handling the Clear button’s click event is trivial:

protected void btnClear_Click (object sender, System.EventArgs e)
{
     foreach (TreeNode node in tvwSource.Nodes)
     {
         SetCheck(node, false);
     }
}

You just call the SetCheck( ) method on the root nodes and tell them to recursively uncheck all their contained nodes.

You start by instantiating a new ArrayList object to hold the strings representing the names of all the files selected:

private ArrayList GetFileList(  )
{
    ArrayList fileNames = new ArrayList(  );

To get the selected filenames, you can walk through the source TreeView control:

foreach (TreeNode theNode in tvwSource.Nodes)
{
    GetCheckedFiles(theNode, fileNames);
}

To see how this works, you want to step into the GetCheckedFiles( ) method. This method is pretty simple: it examines the node it was handed. If that node has no children (node.Nodes.Count == 0), it is a leaf. If that leaf is checked, you want to get the full path (by calling GetParentString( ) on the node) and add it to the ArrayList passed in as a parameter:

private void GetCheckedFiles(TreeNode node, ArrayList fileNames)
{
    if (node.Nodes.Count == 0)
    {
        if (node.Checked)
        {
             string fullPath = GetParentString(node);
             fileNames.Add(fullPath);
        }
    }

If the node is not a leaf, you want to recurse down the tree, finding the child nodes:

else  
    {
        foreach (TreeNode n in node.Nodes)
        {
            GetCheckedFiles(n,fileNames);
        }
    }
}

This will return the ArrayList filled with all the filenames. Back in GetFileList( ), you’ll use this ArrayList of filenames to create a second ArrayList, this time to hold the actual FileInfo objects:

ArrayList fileList = new ArrayList(  );

Notice that once again you do not tell the ArrayList constructor what kind of object it will hold. This is one of the advantages of a rooted type-system; the collection only needs to know that it has some kind of Object; because all types are derived from Object, the list can hold FileInfo objects as easily as it can hold string objects.

You can now iterate through the filenames in ArrayList, picking out each name and instantiating a FileInfo object with it. You can detect if it is a file or a directory by calling the Exists property, which will return false if the File object you created is actually a directory. If it is a File, you can add it to the new ArrayList:

foreach (string fileName in fileNames)
{
    FileInfo file = new File(fileName);

    if (file.Exists)
    {
        fileList.Add(file);
    }
}

You want to work your way through the list of selected files in large to small order so that you can pack the target disk as tightly as possible. You must therefore sort the ArrayList. You can call its Sort( ) method, but how will it know how to sort File objects? Remember, the ArrayList has no special knowledge about its contents.

To solve this, you must pass in an IComparer interface. We’ll create a class called FileComparer that will implement this interface and that will know how to sort FileInfo objects:

public class FileComparer : IComparer
{

This class has only one method, Compare( ), which takes two objects as arguments:

public int Compare (object f1, object f2)
{

The normal approach is to return 1 if the first object (f1) is larger than the second (f2), to return -1 if the opposite is true, and to return 0 if they are equal. In this case, however, you want the list sorted from big to small, so you should reverse the return values.

To test the length of the FileInfo object, you must cast the Object parameters to FileInfo objects (which is safe, as you know this method will never receive anything else):

FileInfo file1 = (FileInfo) f1;
        FileInfo file2 = (FileInfo) f2;
        if (file1.Length > file2.Length)
        {
            return -1;  
        }
        if (file1.Length < file2.Length)
        {
           return 1;
        }
        return 0;
    }
}

Returning to GetFileList( ), you were about to instantiate the IComparer reference and pass it to the Sort( ) method of fileList:

IComparer comparer = (IComparer) new FileComparer(  );
fileList.Sort(comparer);

That done, you can return fileList to the calling method:

return fileList;

The calling method was btnCopy_Click. Remember you went off to GetFileList( ) in the first line of the event handler!

protected void btnCopy_Click (object sender, System.EventArgs e)
{
    ArrayList fileList = GetFileList(  );

At this point you’ve returned with a sorted list of File objects, each representing a file selected in the source TreeView.

You can now iterate through the list, copying the files and updating the UI:

foreach (FileInfo file in fileList)
{ 
   try
   {
        lblStatus.Text = "Copying " + 
          txtTargetDir.Text + "\" + 
            file.Name + "...";
        Application.DoEvents(  );

        file.CopyTo(txtTargetDir.Text + "\" + 
            file.Name,chkOverwrite.Checked);
    }
   
   catch (Exception ex)
   {
        MessageBox.Show(ex.Message);
   }
}
lblStatus.Text = "Done.";
Application.DoEvents(  );

As you go, you write the progress to the lblStatus label and call Application.DoEvents( ) to give the UI an opportunity to redraw. You then call CopyTo( ) on the file, passing in the target directory, obtained from the text field, and a Boolean flag indicating whether the file should be overwritten if it already exists.

You’ll notice that the flag you pass in is the value of the chkOverWrite checkbox. The Checked property evaluates true if the checkbox is checked and false if not.

The copy is wrapped in a try block because you can anticipate any number of things going wrong when copying files. For now, you handle all exceptions by popping up a dialog box with the error, but you might want to take corrective action in a commercial application.

That’s it; you’ve implemented file copying!