JavaScript/jQuery TreeView Options

See Also

• Configure a UI Component: Angular | Vue | React | jQuery | AngularJS | Knockout

The value of this property will be passed to the accesskey attribute of the HTML element that underlies the UI component.

The UI component switches to the active state when users press down the primary mouse button. When this property is set to true, the CSS rules for the active state apply. You can change these rules to customize the component.

Use this property when you display the component on a platform whose guidelines include the active state change for UI components. See the following GitHub repository for an example of this type of platform: MUI.

createChildren is called at the beginning of the UI component's lifetime and each time a user expands a node whose child nodes have not been loaded yet. It allows you to load the entire tree in portions: load root nodes first (when the function's parentNode parameter is null) and the child nodes of each expanded node later.

This function has the following restrictions:

• Neither the dataSource, nor the items property should be specified.

• The dataStructure property should be set to "plain".

• Since the search will be performed on loaded nodes only and thus produce incorrect results, it is not recommended that you enable this functionality.

The following code shows how to use this function with a remote service:

$(function() {
    $("#treeViewContainer").dxTreeView({
        dataStructure: "plain",
        rootValue: 0, 
        createChildren: function (parentNode) {
            var d = $.Deferred();
            $.get("http://url/to/the/service", {
                    // Here, 0 is the "rootValue" property's value.
                    parentId: parentNode ? JSON.stringify(parentNode.key) : "0" 
                })
                .done(function (result) {
                    d.resolve(result);
                });
            return d.promise();
        }
    });
});

<dx-tree-view
    [rootValue]="0"
    dataStructure="plain"
    [createChildren]="createChildren">
</dx-tree-view>

import { ..., Inject } from "@angular/core";
import { HttpClient, HttpClientModule, HttpParams } from "@angular/common/http";
import "rxjs/add/operator/toPromise";
import { DxTreeViewModule } from "devextreme-angular";
// ...
export class AppComponent {
    constructor(@Inject(HttpClient) httpClient: HttpClient) { }
    createChildren = (parentNode) => {
        let params: HttpParams = new HttpParams()
            // Here, 0 is the "rootValue" property's value.
            .set("parentId", parentNode ? JSON.stringify(parentNode.key) : "0"); 
        return httpClient.get("http://url/to/the/service", {
                params: params
            })
            .toPromise();
    }
}
@NgModule({
    imports: [
        // ...
        DxTreeViewModule,
        HttpClientModule 
    ],
    // ...
})

<template>
    <DxTreeView
        :create-children="createChildren"
        :root-value="''"
        data-structure="plain"
    />
</template>
<script>

import DxTreeView from 'devextreme-vue/tree-view';
import 'whatwg-fetch';

export default {
    components: {
        DxTreeView
    },
    methods: {
        createChildren: function(parent) {
        let parentId = parent ? parent.itemData.id : '';

        return fetch(`http://url/to/the/service?parentId=${parentId}`)
            .then(response => response.json())
            .catch(() => { throw 'Data Loading Error'; });
        }
    }
};
</script>

import React from 'react';
import TreeView from 'devextreme-react/tree-view';
import 'whatwg-fetch';

const App = () => {
    return (
        <TreeView
            dataStructure="plain"
            rootValue="''"
            createChildren={createChildren}
        />
    );
}

const createChildren = (parent) => {
    let parentId = parent ? parent.itemData.id : '';

    return fetch(`http://url/to/the/service?parentId=${parentId}`)
        .then(response => response.json())
        .catch(() => { throw 'Data Loading Error'; });
}

export default App;

View Demo

See Also

• Enhance Performance on Large Datasets
• Demo: Simple Array - Plain Structure

The TreeView works with object collections that can have a plain or hierarchical structure. Depending on the structure, the objects should provide different data fields. Specify the dataStructure property to notify the TreeView of the used structure and refer to the property's description for information on the required fields.

Depending on your data source, bind the TreeView to data as follows.

• Data Array
  Assign the array to the dataSource option.

• Read-Only Data in JSON Format
  Set the dataSource property to the URL of a JSON file or service that returns JSON data.

• OData
  Implement an ODataStore.

• Web API, PHP, MongoDB
  Use one of the following extensions to enable the server to process data according to the protocol DevExtreme UI components use:

  • DevExtreme.AspNet.Data
  • DevExtreme-PHP-Data
  • devextreme-query-mongodb

  Then, use the createStore method to configure access to the server on the client as shown below. This method is part of DevExtreme.AspNet.Data.

  jQuery

  JavaScript

  $(function() {
      let serviceUrl = "https://url/to/my/service";
      $("#treeViewContainer").dxTreeView({
          // ...
          dataSource: DevExpress.data.AspNet.createStore({
              key: "ID",
              loadUrl: serviceUrl + "/GetAction",
              insertUrl: serviceUrl + "/InsertAction",
              updateUrl: serviceUrl + "/UpdateAction",
              deleteUrl: serviceUrl + "/DeleteAction"
          })
      })
  });

  Angular

  app.component.ts

  app.component.html

  app.module.ts

  import { Component } from '@angular/core';
  import CustomStore from 'devextreme/data/custom_store';
  import { createStore } from 'devextreme-aspnet-data-nojquery';
  
  @Component({
      selector: 'app-root',
      templateUrl: './app.component.html',
      styleUrls: ['./app.component.css']
  })
  export class AppComponent {
      store: CustomStore;
      constructor() {
          let serviceUrl = "https://url/to/my/service";
          this.store = createStore({
              key: "ID",
              loadUrl: serviceUrl + "/GetAction",
              insertUrl: serviceUrl + "/InsertAction",
              updateUrl: serviceUrl + "/UpdateAction",
              deleteUrl: serviceUrl + "/DeleteAction"
          })
      }
  }

  <dx-tree-view ...
      [dataSource]="store">
  </dx-tree-view>

  import { BrowserModule } from '@angular/platform-browser';
  import { NgModule } from '@angular/core';
  import { AppComponent } from './app.component';
  
  import { DxTreeViewModule } from 'devextreme-angular';
  
  @NgModule({
      declarations: [
          AppComponent
      ],
      imports: [
          BrowserModule,
          DxTreeViewModule
      ],
      providers: [],
      bootstrap: [AppComponent]
  })
  export class AppModule { }

  Vue

  App.vue

  <template> 
      <DxTreeView ...
          :data-source="store" />
  </template>
  
  <script>
  import 'devextreme/dist/css/dx.light.css';
  
  import CustomStore from 'devextreme/data/custom_store';
  import { createStore } from 'devextreme-aspnet-data-nojquery';
  import { DxTreeView } from 'devextreme-vue/tree-view';
  
  export default {
      components: {
          DxTreeView
      },
      data() {
          const serviceUrl = "https://url/to/my/service";
          const store = createStore({
              key: "ID",
              loadUrl: serviceUrl + "/GetAction",
              insertUrl: serviceUrl + "/InsertAction",
              updateUrl: serviceUrl + "/UpdateAction",
              deleteUrl: serviceUrl + "/DeleteAction"
          });
          return {
              store
          }
      }
  }
  </script>

  React

  App.js

  import React from 'react';
  import 'devextreme/dist/css/dx.light.css';
  
  import CustomStore from 'devextreme/data/custom_store';
  import { createStore } from 'devextreme-aspnet-data-nojquery';
  import TreeView from 'devextreme-react/tree-view';
  
  const serviceUrl = "https://url/to/my/service";
  const store = createStore({
      key: "ID",
      loadUrl: serviceUrl + "/GetAction",
      insertUrl: serviceUrl + "/InsertAction",
      updateUrl: serviceUrl + "/UpdateAction",
      deleteUrl: serviceUrl + "/DeleteAction"
  });
  
  class App extends React.Component {
      render() {
          return (
              <TreeView ...
                  dataSource={store} />
          );
      }
  }
  export default App;

• Any other data source
  Implement a CustomStore.

Regardless of the data source on the input, the TreeView always wraps it in the DataSource object. This object allows you to sort, filter, group, and perform other data shaping operations. To get its instance, call the getDataSource() method.

See Also

• Enhance Performance on Large Datasets

The UI component expects that data has a hierarchical structure where each data item contains a text, a unique id, and an items array if the data item nests other data items:

var hierarchicalData = [{
    id: '1',
    text: 'Fruits',
    items: [
        { id: '1_1', text: 'Apples' },
        { id: '1_2', text: 'Oranges' }
    ]
}, {
    id: '2',
    text: 'Vegetables',
    items: [
        { id: '2_1', text: 'Cucumbers' },
        { id: '2_2', text: 'Tomatoes' }
    ]
}];

View Demo

If data has a plain structure, set the dataStructure property to "plain". In this case, each data item should have a text, a unique id, and a parentId. For root items, parentId should be equal to 0 or undefined:

var plainData = [
    { id: '1', text: 'Fruits' },     // A root item
    { id: '1_1', text: 'Apples', parentId: '1' },
    { id: '1_2', text: 'Oranges', parentId: '1' },
    { id: '2', text: 'Vegetables' }, // Also a root item
    { id: '2_1', text: 'Cucumbers', parentId: '2' },
    { id: '2_2', text: 'Tomatoes', parentId: '2' }
];

id, text, items, and parentId are conventional field names. To use other names, change the keyExpr, displayExpr, itemsExpr, and parentIdExpr properties, respectively. You can also specify the rootValue property to change the parentId value that root items should have.

View Demo

See Also

• TreeView - Use Hierarchical Data
• TreeView - Use Plain Data

Set this property to the name of a data field that provides displayed values...

displayExpr: "name"

... or to a function that returns the displayed value:

displayExpr: function(item) {
    // "item" can be null
    return item && 'ID: ' + item.id + ', Name: ' + item.name;
}

View Demo

See Also

• Use Hierarchical Data
• Use Plain Data

See Also

• expandEvent
• Expand and Collapse Nodes

This property accepts a value of one of the following types:

• Number
  The height in pixels.

• String
  A CSS-accepted measurement of height. For example, "55px", "80%", "inherit".

• Function
  A function returning either of the above. For example:

  JavaScript

  height: function() {
      return window.innerHeight / 1.5;
  }

The TreeView works with object collections that can have a plain or hierarchical structure. Depending on the structure, the objects should provide different data fields. Specify the dataStructure property to notify the TreeView of the used structure and refer to the property's description for information on the required fields.

If you need to update the UI component items, reassign the entire items array as shown in the following example:

treeViewInstance.option('items', newItems);

As an alternative to items, you can use the dataSource property. It accepts the DataSource object, whose underlying stores provide an API that allows you to update individual items without reassigning the entire item collection.

See Also

• Customize Node Appearance
• Custom Templates

See Also

• Specify data using dataSource property
• Specify data using items property

The TreeView component evaluates the noDataText property's value. This evaluation, however, makes the TreeView potentially vulnerable to XSS attacks. To guard against these attacks, encode the HTML markup before you assign it to the noDataText property. Refer to the following help topic for more information: Potentially Vulnerable API - noDataText.

See Also

• Get a UI component Instance in Angular | AngularJS | Knockout | Vue | React

See Also

-Expand and Collapse Nodes - Events

View Demo

See Also

• Expand and Collapse Nodes - Events

This function is executed when:

• Users select an item by click or using its checkbox.

• The selectItem() or unselectItem() method is called.

Alternatively, you can use the onSelectionChanged function, which is executed in all the cases above, and when all items are selected simultaneously.

The following example shows how to subscribe to component property changes:

$(function() {
    $("#treeViewContainer").dxTreeView({
        // ...
        onOptionChanged: function(e) {
            if(e.name === "changedProperty") {
                // handle the property change here
            }
        }
    });
});

<dx-tree-view ...
    (onOptionChanged)="handlePropertyChange($event)"> 
</dx-tree-view>

import { Component } from '@angular/core'; 

@Component({ 
    selector: 'app-root', 
    templateUrl: './app.component.html', 
    styleUrls: ['./app.component.css'] 
}) 

export class AppComponent { 
    // ...
    handlePropertyChange(e) {
        if(e.name === "changedProperty") { 
            // handle the property change here
        }
    }
}

import { BrowserModule } from '@angular/platform-browser'; 
import { NgModule } from '@angular/core'; 
import { AppComponent } from './app.component'; 
import { DxTreeViewModule } from 'devextreme-angular'; 

@NgModule({ 
    declarations: [ 
        AppComponent 
    ], 
    imports: [ 
        BrowserModule, 
        DxTreeViewModule 
    ], 
    providers: [ ], 
    bootstrap: [AppComponent] 
}) 

export class AppModule { }  

<template> 
    <DxTreeView ...
        @option-changed="handlePropertyChange"
    />            
</template> 

<script>  
import 'devextreme/dist/css/dx.light.css'; 
import DxTreeView from 'devextreme-vue/tree-view'; 

export default { 
    components: { 
        DxTreeView
    }, 
    // ...
    methods: { 
        handlePropertyChange: function(e) {
            if(e.name === "changedProperty") {
                // handle the property change here
            }
        }
    } 
} 
</script> 

import React from 'react';  
import 'devextreme/dist/css/dx.light.css'; 

import TreeView from 'devextreme-react/tree-view'; 

const handlePropertyChange = (e) => {
    if(e.name === "changedProperty") {
        // handle the property change here
    }
}

export default function App() { 
    return ( 
        <TreeView ...
            onOptionChanged={handlePropertyChange}
        />        
    ); 
} 

See Also

• onSelectionChanged

This function is executed when:

• Users select an item by click or using a checkbox.

• One of the following methods is called: selectAll(), unselectAll(), selectItem(), unselectItem().

View Demo

This property is used if the dataStructure property is set to "plain".

View Demo

When this property is set to true, the UI component text flows from right to left, and the layout of elements is reversed. To switch the entire application/site to the right-to-left representation, assign true to the rtlEnabled field of the object passed to the DevExpress.config(config) method.

DevExpress.config({
    rtlEnabled: true
});

DataGrid Demo Navigation UI Demo Editors Demo

See the TextBox Configuration for properties you can specify in this object.

View Demo

See Also

• Search Nodes

If you need to search several fields, assign an array of field names to this property.

searchExpr: ["firstName", "lastName"]

See Also

• Search Nodes

View Demo

See Also

• showCheckBoxesMode

To enable selection, set selectByClick to true or showCheckBoxesMode to "normal" or "selectAll".

View Demo

View Demo

The property accepts the following values:

• "none"
  The UI component does not display checkboxes.

• "normal"
  The UI component displays one checkbox per item.

• "selectAll"
  The UI component displays one checkbox per item and one "Select All" checkbox at the top of the UI component. The selectionMode should be "multiple".

View Demo

See Also

• selectByClick

The value of this property will be passed to the tabindex attribute of the HTML element that underlies the UI component.

If this property is true, the UI component initially loads only the root nodes. Child nodes are loaded when their parent is being expanded.

The virtual mode has the following restrictions:

• The dataSource property should be set to a DataSource instance able to filter items by parent ID.

• The dataStructure property should be set to "plain".

• Since the search will be performed on loaded nodes only and thus produce incorrect results, it is not recommended that you enable this functionality.

View Demo

See Also

• Enhance Performance on Large Datasets
• createChildren

This property accepts a value of one of the following types:

• Number
  The width in pixels.

• String
  A CSS-accepted measurement of width. For example, "55px", "80%", "auto", "inherit".

• Function
  A function returning either of the above. For example:

  JavaScript

  width: function() {
      return window.innerWidth / 1.5;
  }