private static void AddSubFoldersToCurrentFolder(TreeViewCancelEventArgs e, string[] newSubs)
        {
            if (newSubs.Length > 0)
            {
                for (int k = 0; k < newSubs.Length; k++)
                {
                    //Only get the non-hidden folders and non-system folders
                    //TODO: Find out why C:\PerfLogs denies access in Win7 or at least some flag
                    //that it uses so I don't have to have the string hard-coded into the program
                    bool isHidden = ((File.GetAttributes(newSubs[k]) & FileAttributes.Hidden) ==
                        FileAttributes.Hidden);
                    bool isSystem = ((File.GetAttributes(newSubs[k]) & FileAttributes.System) ==
                        FileAttributes.System);
                    if (!isHidden && !newSubs[k].Contains("PerfLogs") && !isSystem)
                    {

                        TreeNode subNode = new TreeNode();
                        subNode.Name = newSubs[k];
                        string[] tokenPath = newSubs[k].Split(Path.DirectorySeparatorChar);
                        subNode.Text = tokenPath[tokenPath.Length - 1];
                        subNode.Tag = newSubs[k];
                        subNode.ImageIndex = (int)folderTypes.FolderClosed;
                        subNode.SelectedImageIndex = (int)folderTypes.FolderOpen;

                        AddPlaceholderForSubFolders(newSubs[k], subNode);

                        e.Node.Nodes.Add(subNode);
                    }

                }
            }
        }

        private void TilesetTree_BeforeExpand(object sender, TreeViewCancelEventArgs e)
        {
            ObjectDirectory od = null;
            TreeNode node = null;

            foreach (TreeNode cNode in e.Node.Nodes)
            {
                if (cNode.Tag is ObjectDirectory && cNode.Nodes.Count == 0)
                {
                    od = cNode.Tag as ObjectDirectory;

                    foreach (ObjectDirectory c in od.ObjectDirectories)
                    {
                        node = new TreeNode(c.Name);
                        node.Tag = c;
                        cNode.Nodes.Add(node);
                    }

                    foreach (MapObject c in od.MapObjects)
                    {
                        node = new TreeNode(c.Name);
                        node.Tag = c;
                        cNode.Nodes.Add(node);
                    }
                }
            }
        }

        private static void TvWndList_BeforeExpand(object sender, TreeViewCancelEventArgs e)
        {
            TreeNode node = e.Node;
            if (node.Nodes[0].Name != "none")
            {
                return;
            }
            node.Nodes.Clear();

            string name = node.Name;
            if (!Regex.IsMatch(name, "^\\d+$"))
            {
                return;
            }

            var intPtr = (IntPtr)int.Parse(name);
            if (intPtr == IntPtr.Zero)
            {
                return;
            }

            IntPtr subPtr = IntPtr.Zero;
            var classList = new Dictionary<string, int>();
            while (true)
            {
                subPtr = User32API.FindWindowEx(intPtr, subPtr, null, null);
                if (subPtr == IntPtr.Zero)
                {
                    break;
                }
                var temp = new TreeNode { Name = subPtr.ToString(), Text = DisplayNote(subPtr, classList) };
                temp.Nodes.Add(new TreeNode { Name = "none" });
                node.Nodes.Add(temp);
            }
        }

 // cancel selection just in case we get selected somehow
 protected override void OnBeforeSelect(TreeViewCancelEventArgs e)
 {
     base.OnBeforeSelect(e);
       if (e.Node.ForeColor == SystemColors.GrayText) {
     e.Cancel = true;
       }
 }

 protected internal override void OnPopulate( TreeViewCancelEventArgs e )
 {
     if ( method.MethodSpecs.Count > 0 )
     {
         this.Nodes.Add( new MethodSpecCollectionTreeNode( method.MethodSpecs ) );
     }
 }

		protected override void OnBeforeExpand(TreeViewCancelEventArgs e) {
			var node = e.Node as TreeNodeX;
			if (node != null) {
				node.OnExpand();
			}
			base.OnBeforeExpand(e);
		}

        protected override void OnBeforeSelect(TreeViewCancelEventArgs e)
        {
            base.OnBeforeSelect(e);

            bool controlKeyDown = (Control.ModifierKeys == Keys.Control);
            bool shiftKeyDown = (Control.ModifierKeys == Keys.Shift);

            if (controlKeyDown
                && _selectedNodes.Contains(e.Node))
            {
                // Unselect it (let framework know we don't want selection this time)
                e.Cancel = true;

                // Update nodes
                e.Node.BackColor = this.BackColor;
                e.Node.ForeColor = this.ForeColor;
                _selectedNodes.Remove(e.Node);

                if (this.SelectionChanged != null)
                {
                    this.SelectionChanged(this, EventArgs.Empty);
                }
            }
            else
            {
                _lastNode = e.Node;
                if (!shiftKeyDown)
                {
                    _firstNode = e.Node;
                }
            }
        }

 private void NodeTree_BeforeExpand(object sender, TreeViewCancelEventArgs e)
 {
     ExplorerNode node = e.Node.Tag as ExplorerNode;
     if (node == null)
         return;
     node.BeforeExpand(sender, e);
 }

        private void f_filesView_BeforeSelect(object sender, TreeViewCancelEventArgs e)
        {
            TreeNode selectedNode = f_filesView.SelectedNode;

            if (selectedNode == null)
                return;
        }

 protected internal override void OnPopulate( TreeViewCancelEventArgs e )
 {
     foreach ( TypeRefDeclaration externalType in this.decl.TypeRefs )
     {
         this.Nodes.Add( new ExternalTypeTreeNode( externalType ) );
     }
 }

 protected override void OnBeforeSelect(TreeViewCancelEventArgs e)
 {
     if (Updating)
         e.Cancel = true;
     else
         base.OnBeforeSelect(e);
 }

 protected internal override void OnPopulate( TreeViewCancelEventArgs e )
 {
     foreach ( InterfaceImplementationDeclaration interfaceImplementation in type.InterfaceImplementations )
     {
         this.Nodes.Add( new InterfaceImplementationTreeNode( interfaceImplementation.ImplementedInterface ) );
     }
 }

 protected internal override void OnPopulate( TreeViewCancelEventArgs e )
 {
     foreach ( MethodSpecDeclaration methodSpec in methodSpecs )
     {
         this.Nodes.Add( new MethodSpecTreeNode( methodSpec ) );
     }
 }

 protected internal override void OnPopulate( TreeViewCancelEventArgs e )
 {
     foreach ( GenericParameterDeclaration genericParameter in genericParameters )
     {
         this.Nodes.Add( new GenericParameterTreeNode( genericParameter ) );
     }
 }

        private void treeView1_BeforeExpand(object sender, TreeViewCancelEventArgs e)
        {
            if (e.Node.Nodes.Count > 0)
            {
                if (e.Node.Nodes[0].Text == "..." && e.Node.Nodes[0].Tag == null)
                {

                    e.Node.Nodes.Clear();
                    string[] dirs = Directory.GetDirectories(e.Node.Tag.ToString());
                    foreach(string dir in dirs)
                    {
                        if (dir != e.Node.Tag+"System Volume Information")
                        {
                            DirectoryInfo di = new DirectoryInfo(dir);
                            TreeNode node = new TreeNode(di.Name, 0, 1);

                            node.Tag = dir;
                            if (di.GetDirectories().Count() > 0)
                                node.Nodes.Add(null, "...");
                             e.Node.Nodes.Add(node);
                        }
                        else
                        {
                            MessageBox.Show(dir);
                        }

                    }

                }

            }
        }

// Triggers
//
// (overriden method, and base class called to ensure events are triggered)


		protected override void OnBeforeSelect(TreeViewCancelEventArgs e)
		{
			base.OnBeforeSelect(e);
				
			bool bControl = (ModifierKeys==Keys.Control);
			bool bShift = (ModifierKeys==Keys.Shift);

			// selecting twice the node while pressing CTRL ?
			if (bControl && m_coll.Contains( e.Node ) )
			{
				// unselect it (let framework know we don't want selection this time)
				e.Cancel = true;
	
				// update nodes
				removePaintFromNodes();
				m_coll.Remove( e.Node );

        foreach (TreeNode node in e.Node.Nodes)
          if (m_coll.Contains(node))
            m_coll.Remove(node);

				paintSelectedNodes();
				return;
			}

			m_lastNode = e.Node;
			if (!bShift) m_firstNode = e.Node; // store begin of shift sequence
		}

		/// <summary>
		/// Raises the <see cref="TreeView.BeforeExpand"/> event.
		/// </summary>
		/// <remarks>
		/// This ensures that the children of a node that is about to be exanded are loaded.
		/// </remarks>
		/// <param name="e">A <see cref="TreeViewCancelEventArgs"/> describing the event arguments.</param>
		protected override void OnBeforeExpand(TreeViewCancelEventArgs e)
		{
			foreach (XmlTreeNode xtnChild in e.Node.Nodes)
				if (!xtnChild.IsLoaded)
					xtnChild.LoadChildren();
			base.OnBeforeExpand(e);
		}

 protected internal override void OnPopulate( TreeViewCancelEventArgs e )
 {
     foreach ( MethodSemanticDeclaration method in @event.Members )
     {
         this.Nodes.Add( new MethodTreeNode( method.Method ) );
     }
 }

        protected internal override void OnPopulate( TreeViewCancelEventArgs e )
        {
            if ( this.block.HasChildrenBlocks )
            {
                IEnumerator<InstructionBlock> children = this.block.GetChildrenEnumerator();
                while ( children.MoveNext() )
                {
                    this.Nodes.Add(
                        new InstructionBlockTreeNode( children.Current,
                                                      children.Current.HasExceptionHandlers
                                                          ? "protected block"
                                                          : "block" ) );
                }
            }

            if ( this.block.HasExceptionHandlers )
            {
                ExceptionHandler handler = this.block.FirstExceptionHandler;
                while ( handler != null )
                {
                    this.Nodes.Add( new ExceptionHandlerTreeNode( handler ) );
                    handler = handler.NextSiblingExceptionHandler;
                }
            }


            if ( this.block.HasLocalVariableSymbols )
            {
                this.Nodes.Add( new LocaVariableSymbolCollectionTreeNode( this.block ) );
            }
        }

 private void BeforeSelect(object source, TreeViewCancelEventArgs e)
 {
     TreeNode node = e.Node;
     string[] strArray = node.FullPath.Split(new char[] { '\\' });
     node.SelectedImageIndex = strArray.Length - 1;
     this.exit = false;
 }