TreeListNodeBase.IsExpanded Property

Gets or sets whether or not the node is expanded.

Namespace: DevExpress.Data.TreeList

Assembly: DevExpress.Data.v24.2.dll

Declaration

C#

public virtual bool IsExpanded { get; set; }

VB.NET

Public Overridable Property IsExpanded As Boolean

Property Value

Type	Description
Boolean	true to expand the node; otherwise, false.

Remarks

To learn more, see Expanding and Collapsing Nodes .

Example

In this demo, the TreeListView displays the file/folder tree. Child nodes that correspond to sub folders or files contained within a folder are dynamically created when a parent node is being expanded.

Note

A complete sample project is available at https://github.com/DevExpress-Examples/wpf-treelist-load-nodes-dynamically

MainWindow.xaml

<Window x:Class="DynamicNodeLoading.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525" xmlns:dxg="http://schemas.devexpress.com/winfx/2008/xaml/grid">
    <Grid>
        <dxg:GridControl Name="grid">
            <dxg:GridControl.Columns>
                <dxg:GridColumn FieldName="Name" />
                <dxg:GridColumn FieldName="ItemType" />
                <dxg:GridColumn FieldName="Size" />
                <dxg:GridColumn FieldName="FullName" />
            </dxg:GridControl.Columns>
            <dxg:GridControl.View>
                <dxg:TreeListView Name="treeListView1" AutoWidth="True"
                                  NodeExpanding="treeListView1_NodeExpanding"/>
            </dxg:GridControl.View>
        </dxg:GridControl>
    </Grid>
</Window>

MainWindow.xaml.cs

using System;
using System.Windows;
using DevExpress.Xpf.Grid;
using System.IO;
using DevExpress.Utils;

namespace DynamicNodeLoading {
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window {
        public MainWindow() {
            InitializeComponent();
            Helper = new FileSystemHelper();
            InitDrives();
        }

        private void treeListView1_NodeExpanding(object sender, DevExpress.Xpf.Grid.TreeList.TreeListNodeAllowEventArgs e) {
            TreeListNode node = e.Node;
            if (node.Tag == null || (bool)node.Tag == false) {
                InitFolder(node);
                node.Tag = true;
            }
        }

        FileSystemDataProvider Helper { get; set; }

        public void InitDrives() {
            grid.BeginDataUpdate();
            try {
                string[] root = Helper.GetLogicalDrives();

                foreach (string s in root) {
                    TreeListNode node = new TreeListNode() { Content = new FileSystemItem(s, "Drive", "<Drive>", s) };
                    treeListView1.Nodes.Add(node);
                    node.IsExpandButtonVisible = DefaultBoolean.True;
                }
            }
            catch { }
            grid.EndDataUpdate();
        }
        private void InitFolder(TreeListNode treeListNode) {
            grid.BeginDataUpdate();
            InitFolders(treeListNode);
            InitFiles(treeListNode);
            grid.EndDataUpdate();
        }

        private void InitFiles(TreeListNode treeListNode) {
            FileSystemItem item = treeListNode.Content as FileSystemItem;
            if (item == null) return;
            TreeListNode node;
            try {
                string[] root = Helper.GetFiles(item.FullName);
                foreach (string s in root) {
                    node = new TreeListNode() { Content = new FileSystemItem(Helper.GetFileName(s), "File", Helper.GetFileSize(s).ToString(), s) };
                    node.IsExpandButtonVisible = DefaultBoolean.False;
                    treeListNode.Nodes.Add(node);
                }
            }
            catch { }
        }

        private void InitFolders(TreeListNode treeListNode) {
            FileSystemItem item = treeListNode.Content as FileSystemItem;
            if (item == null) return;

            try {
                string[] root = Helper.GetDirectories(item.FullName);
                foreach (string s in root) {
                    try {
                        TreeListNode node = new TreeListNode() { Content = new FileSystemItem(Helper.GetDirectoryName(s), "Folder", "<Folder>", s) };
                        treeListNode.Nodes.Add(node);

                        node.IsExpandButtonVisible = HasFiles(s) ? DefaultBoolean.True : DefaultBoolean.False;
                    }
                    catch { }
                }
            }
            catch { }
        }

        private bool HasFiles(string path) {
            string[] root = Helper.GetFiles(path);
            if (root.Length > 0) return true;
            root = Helper.GetDirectories(path);
            if (root.Length > 0) return true;
            return false;
        }
        public abstract class FileSystemDataProvider {
            public abstract string[] GetLogicalDrives();
            public abstract string[] GetDirectories(string path);
            public abstract string[] GetFiles(string path);
            public abstract string GetDirectoryName(string path);
            public abstract string GetFileName(string path);
            public abstract long GetFileSize(string path);
        }
        public class FileSystemHelper : FileSystemDataProvider {

            public override string[] GetLogicalDrives() {
                return Directory.GetLogicalDrives();
            }

            public override string[] GetDirectories(string path) {
                return Directory.GetDirectories(path);
            }

            public override string[] GetFiles(string path) {
                return Directory.GetFiles(path);
            }

            public override string GetDirectoryName(string path) {
                return new DirectoryInfo(path).Name;
            }

            public override string GetFileName(string path) {
                return new FileInfo(path).Name;
            }

            public override long GetFileSize(string path) {
                return new FileInfo(path).Length;
            }
        }
    }

    public class FileSystemItem {
        public FileSystemItem(string name, string type, string size, string fullName) {
            Name = name;
            ItemType = type;
            Size = size;
            FullName = fullName;
        }
        public string Name { get; set; }
        public string ItemType { get; set; }
        public string Size { get; set; }
        public string FullName { get; set; }
    }
}

MainWindow.xaml.vb

Imports Microsoft.VisualBasic
Imports System
Imports System.Windows
Imports DevExpress.Xpf.Grid
Imports System.IO
Imports DevExpress.Utils

Namespace DynamicNodeLoading
    ''' <summary>
    ''' Interaction logic for MainWindow.xaml
    ''' </summary>
    Partial Public Class MainWindow
        Inherits Window
        Public Sub New()
            InitializeComponent()
            Helper = New FileSystemHelper()
            InitDrives()
        End Sub

        Private Sub treeListView1_NodeExpanding(ByVal sender As Object, ByVal e As DevExpress.Xpf.Grid.TreeList.TreeListNodeAllowEventArgs)
            Dim node As TreeListNode = e.Node
            If node.Tag Is Nothing OrElse CBool(node.Tag) = False Then
                InitFolder(node)
                node.Tag = True
            End If
        End Sub

        Private privateHelper As FileSystemDataProvider
        Private Property Helper() As FileSystemDataProvider
            Get
                Return privateHelper
            End Get
            Set(ByVal value As FileSystemDataProvider)
                privateHelper = value
            End Set
        End Property

        Public Sub InitDrives()
            grid.BeginDataUpdate()
            Try
                Dim root() As String = Helper.GetLogicalDrives()

                For Each s As String In root
                    Dim node As New TreeListNode() With {.Content = New FileSystemItem(s, "Drive", "<Drive>", s)}
                    treeListView1.Nodes.Add(node)
                    node.IsExpandButtonVisible = DefaultBoolean.True
                Next s
            Catch
            End Try
            grid.EndDataUpdate()
        End Sub
        Private Sub InitFolder(ByVal treeListNode As TreeListNode)
            grid.BeginDataUpdate()
            InitFolders(treeListNode)
            InitFiles(treeListNode)
            grid.EndDataUpdate()
        End Sub

        Private Sub InitFiles(ByVal treeListNode As TreeListNode)
            Dim item As FileSystemItem = TryCast(treeListNode.Content, FileSystemItem)
            If item Is Nothing Then
                Return
            End If
            Dim node As TreeListNode
            Try
                Dim root() As String = Helper.GetFiles(item.FullName)
                For Each s As String In root
                    node = New TreeListNode() With {.Content = New FileSystemItem(Helper.GetFileName(s), "File", Helper.GetFileSize(s).ToString(), s)}
                    node.IsExpandButtonVisible = DefaultBoolean.False
                    treeListNode.Nodes.Add(node)
                Next s
            Catch
            End Try
        End Sub

        Private Sub InitFolders(ByVal treeListNode As TreeListNode)
            Dim item As FileSystemItem = TryCast(treeListNode.Content, FileSystemItem)
            If item Is Nothing Then
                Return
            End If

            Try
                Dim root() As String = Helper.GetDirectories(item.FullName)
                For Each s As String In root
                    Try
                        Dim node As New TreeListNode() With {.Content = New FileSystemItem(Helper.GetDirectoryName(s), "Folder", "<Folder>", s)}
                        treeListNode.Nodes.Add(node)

                        node.IsExpandButtonVisible = If(HasFiles(s), DefaultBoolean.True, DefaultBoolean.False)
                    Catch
                    End Try
                Next s
            Catch
            End Try
        End Sub

        Private Function HasFiles(ByVal path As String) As Boolean
            Dim root() As String = Helper.GetFiles(path)
            If root.Length > 0 Then
                Return True
            End If
            root = Helper.GetDirectories(path)
            If root.Length > 0 Then
                Return True
            End If
            Return False
        End Function
        Public MustInherit Class FileSystemDataProvider
            Public MustOverride Function GetLogicalDrives() As String()
            Public MustOverride Function GetDirectories(ByVal path As String) As String()
            Public MustOverride Function GetFiles(ByVal path As String) As String()
            Public MustOverride Function GetDirectoryName(ByVal path As String) As String
            Public MustOverride Function GetFileName(ByVal path As String) As String
            Public MustOverride Function GetFileSize(ByVal path As String) As Long
        End Class
        Public Class FileSystemHelper
            Inherits FileSystemDataProvider

            Public Overrides Function GetLogicalDrives() As String()
                Return Directory.GetLogicalDrives()
            End Function

            Public Overrides Function GetDirectories(ByVal path As String) As String()
                Return Directory.GetDirectories(path)
            End Function

            Public Overrides Function GetFiles(ByVal path As String) As String()
                Return Directory.GetFiles(path)
            End Function

            Public Overrides Function GetDirectoryName(ByVal path As String) As String
                Return New DirectoryInfo(path).Name
            End Function

            Public Overrides Function GetFileName(ByVal path As String) As String
                Return New FileInfo(path).Name
            End Function

            Public Overrides Function GetFileSize(ByVal path As String) As Long
                Return New FileInfo(path).Length
            End Function
        End Class
    End Class

    Public Class FileSystemItem
        Public Sub New(ByVal name As String, ByVal type As String, ByVal size As String, ByVal fullName As String)
            Name = name
            ItemType = type
            Size = size
            FullName = fullName
        End Sub
        Private privateName As String
        Public Property Name() As String
            Get
                Return privateName
            End Get
            Set(ByVal value As String)
                privateName = value
            End Set
        End Property
        Private privateItemType As String
        Public Property ItemType() As String
            Get
                Return privateItemType
            End Get
            Set(ByVal value As String)
                privateItemType = value
            End Set
        End Property
        Private privateSize As String
        Public Property Size() As String
            Get
                Return privateSize
            End Get
            Set(ByVal value As String)
                privateSize = value
            End Set
        End Property
        Private privateFullName As String
        Public Property FullName() As String
            Get
                Return privateFullName
            End Get
            Set(ByVal value As String)
                privateFullName = value
            End Set
        End Property
    End Class
End Namespace