JavaScript/jQuery TreeMap Options

In hierarchical data sources, objects normally have at least one nested array of objects. To specify the field providing this array, assign its name to the childrenField option. Such hierarchical objects will be visualized by groups of tiles.

See Also

• dataSource - specifies the origin of data for the widget.
• valueField - specifies the data source field that provides values for tiles.
• labelField - specifies the data source field that provides texts for tile and group labels.

There are several approaches to colorizing tiles.

• Colorizing each tile uniquely into the color specified directly in the data object.
• Colorizing tiles using the colorizer.
• Specifying a single color for all tiles using the tile.color option.

You can use the first approach only if objects of your data source contain a field providing colors. If so, assign the name of this field to the colorField option. The colors must have one of the following formats:

• Hexadecimal colors
• RGB colors
• RGBA colors
• Predefined/cross-browser color names
• Predefined SVG colors

This approach has the highest priority among the others. To get familiar with the other two approaches, see the colorizer and tile.color option descriptions.

There are several approaches to colorizing tiles.

• Colorizing each tile uniquely into the color specified directly in the data object.
• Colorizing tiles using the colorizer.
• Specifying a single color for all tiles using the tile.color option.

If for some reason you cannot use the first approach, colorize tiles using the colorizer object. It offers three colorization algorithms: "discrete", "gradient" and "range". For more information on how to use each algorithm, refer to the type option description.

To find out how else you can colorize tiles, see the colorField and tile.color option descriptions.

View Demo Watch Video

If you use DevExtreme ASP.NET MVC Controls, refer to the Data Binding article.

The TreeMap works with collections of objects.

Objects that have a plain structure are visualized by tiles. For example, the following array of objects produces four tiles:

let data = [
    { name: "Apples", value: 10 },
    { name: "Oranges", value: 13 },
    { name: "Cucumbers", value: 4 },
    { name: "Tomatoes", value: 8 }
];

Objects that have a hierarchical structure are visualized by groups of tiles. For example, the following array arranges the tiles from the previous code in two groups: "Fruits" and "Vegetables".

let data = [{
    name: "Fruits",
    items: [
        { name: "Apples", value: 10 },
        { name: "Oranges", value: 13 }
    ]
}, {
    name: "Vegetables",
    items: [
        { name: "Cucumbers", value: 4 },
        { name: "Tomatoes", value: 8 }
    ]
}];

View Demo

For both structures, set the valueField and labelField; for the hierarchical structure, also set the childrenField.

A plain data array can imply a hierarchical structure. An example of such array is given below. In this case, set the idField and parentField in addition to the valueField and labelField.

let data = [
    { id: 1, name: "Fruits"},
    { parent: 1, name: "Apples", value: 10 },
    { parent: 1, name: "Oranges", value: 13 },

    { id: 2, name: "Vegetables" },
    { parent: 2, name: "Cucumbers", value: 4 },
    { parent: 2, name: "Tomatoes", value: 8 }
];

let treeMapOptions = {
    // ...
    idField: "id",
    parentField: "parent"
};

View Demo

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

• Data Array
  Assign the array to the dataSource option.

• Read-Only Data in JSON Format
  Set the dataSource option 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 widgets 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";
      $("#treeMapContainer").dxTreeMap({
          // ...
          dataSource: DevExpress.data.AspNet.createStore({
              key: "ID",
              loadUrl: serviceUrl + "/GetAction"
          })
      })
  });

  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"
          })
      }
  }

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

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

  Vue

  App.vue

  <template> 
      <dx-tree-map ...
          :data-source="store" />
  </template>
  
  <script>
  import CustomStore from 'devextreme/data/custom_store';
  import { createStore } from 'devextreme-aspnet-data-nojquery';
  import { DxTreeMap } from 'devextreme-vue/tree-map';
  
  export default {
      components: {
          DxTreeMap
      },
      data() {
          const serviceUrl = "https://url/to/my/service";
          const store = createStore({
              key: "ID",
              loadUrl: serviceUrl + "/GetAction"
          });
          return {
              store
          }
      }
  }
  </script>

  React

  App.js

  import React from 'react';
  
  import CustomStore from 'devextreme/data/custom_store';
  import { createStore } from 'devextreme-aspnet-data-nojquery';
  import TreeMap from 'devextreme-react/tree-map';
  
  const serviceUrl = "https://url/to/my/service";
  const store = createStore({
      key: "ID",
      loadUrl: serviceUrl + "/GetAction"
  });
  
  class App extends React.Component {
      render() {
          return (
              <TreeMap ...
                  dataSource={store} />
          );
      }
  }
  export default App;

• Any other data source
  Implement a CustomStore.

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

These features allow a user to export your widget into a document or print it. When exporting is enabled, the "Exporting/Printing" button appears in the widget. A click on it invokes a drop-down menu that lists exporting and printing commands. The following formats are supported for exporting into: PNG, PDF, JPEG, SVG and GIF.

See Also

• exportTo(fileName, format)
• print()
• DevExpress.viz.exportFromMarkup(markup, options)

Watch Video

A group is an element that collects several tiles in it. In terms of data, it is a node that has children in the current context. Groups appear only if the data source implies a hierarchical structure.

The following list provides an overview of group features that you can configure using the group object.

• Labels
  Each group is identified by a label. Its appearance can be changed using the fields of the label object. If the group's width is too small, the label will be hidden.
• Headers' Height
  Group headers contain labels. To specify the height of the group headers, use the headerHeight option.
• Color
  There are several approaches to colorizing the group headers. Refer to the color option description to find information about all of them.
• Hover and Selection Styles
  A group can be in the hover or selected state. In these states, its style changes to the one specified by the hoverStyle or selectionStyle object respectively. A group can also enter the hover or selected state when a nested tile enters it. To enable this feature, assign true to the interactWithGroup option of the root configuration object.
• Border's Appearance
  Specify the fields of the border object to configure group borders.

An object assigned to the group field configures all groups in the widget. To customize a specific group, pass a similar object to the customize(options) method of the node represented by the group.

See Also

• group.hoverStyle
• tile.hoverStyle
• group.hoverEnabled
• onHoverChanged

In certain cases, you may have a plain data source that implies a hierarchical structure. For example, the following code declares a data source that, despite being plain, can be rearranged into a hierarchy of two groups with two items in each.

var treeMapOptions = {
    // ...
    dataSource: [
        // Group 1
        { id: 1, name: 'Fruits'},
        { parent: 1, name: 'Apples', value: 10 },
        { parent: 1, name: 'Oranges', value: 13 },

        // Group 2
        { id: 2, name: 'Vegetables' },
        { parent: 2, name: 'Cucumbers', value: 4 },
        { parent: 2, name: 'Tomatoes', value: 8 }
    ]
};

Note that in this data source, objects that have children have the "id" field whose value is unique. Their children have the "parent" field pointing at the parent's ID. The "id" and "parent" fields can have other names, but in any case, they must be assigned to the idField and parentField options.

var treeMapOptions = {
    // ...
    idField: 'id',
    parentField: 'parent'
};

View Demo

By default, the click, hoverChanged and selectionChanged events are fired for the tile that has been clicked, paused on or selected. If you need these events to be passed on to the parent group of the tile, set the interactWithGroup option to true. This setting impacts appearance as well. For example, when the user pauses on a tile, the whole group to which the tile belongs will apply the hover style.

Each tile or group of tiles is accompanied by a text label. Usually, a label displays the name of the tile or the group. However, you can put any desired text into it. For this purpose, call the label(label) method of the node whose label must be changed. You can call this method, for example, when all nodes are initialized or when they are being rendered.

If you need to change the appearance of all labels, use the tile.label and group.label objects. To change the appearance of a particular label, use the customize(options) function of the node to which the label belongs.

See Also

• dataSource - specifies the origin of data for the widget.
• valueField - specifies the data source field that provides values for tiles.
• childrenField - specifies the data source field that provides nested items for a group.

Layout algorithms determine the position and size of tiles and groups. Therefore, the chosen algorithm plays the definitive role in the resulting look of the widget. TreeMap provides the following algorithms out of the box.

• Squarified
  This algorithm lays the items out so that the aspect ratio will be closer to 1. In other words, this algorithm tries to make items as square as possible.

  For more information about this algorithm, refer to the Squarified Treemaps paper.

• Strip
  This algorithm is a modification of the "Squarified" algorithm. At the beginning, the algorithm has an available area divided into several strips and a set of items to distribute between the strips. Throughout the layout process, a current strip is maintained. For each item to be arranged, the algorithm checks whether or not adding the item to the current strip improves the average aspect ratios of the rectangles in the current strip. If so, the item is added to the current strip. Otherwise, it is added to the next strip.

  The direction of the strips depends on the size of the available area. If the width is greater than the height, the strips are lined up horizontally. If vice versa, vertically.

  For more information on this algorithm, see the Ordered and Quantum Treemaps: Making Effective Use of 2D Space to Display Hierarchies paper.

• Slice and Dice
  This algorithm uses parallel lines to divide an available area into rectangles representing items. In case of a hierarchical structure, each rectangle representing an item is divided once more into smaller rectangles representing its children, and so on.

  To learn more about this algorithm, refer to the Tree Visualization with Tree-Maps: a 2D Space-Filling Approach paper.

If none of the predefined algorithms satisfy your needs, implement your own algorithm. For this purpose, assign a function to the layoutAlgorithm option. Basically, this function should calculate the coordinates of two diagonally-opposite points defining a rectangle and assign them to the needed item. To access a set of items to distribute, use the items field of the function's parameter. All available fields of the parameter are listed in the header of this description.

var treeMapOptions = {
    // ...
    layoutAlgorithm: function (e) {
        // ...
        e.items.forEach(function(item) {
            // ...
            // Calculating the rectangle for the current item here
            // ...
            item.rect = rectPoints;
        });
    }
};

In addition, you can change the layout direction. For this purpose, use the layoutDirection option.

Use the TreeMapLayoutAlgorithm enum to specify this option when the widget is used as an ASP.NET MVC Control. This enum accepts the following values: Squarified, Strip, and SliceAndDice.

View Demo

The value of this option determines the start and end point of the layout. See the image below to spot the difference between the available layout directions.

Use the TreeMapLayoutDirection enum to specify this option when the widget is used as an ASP.NET MVC Control. This enum accepts the following values: LeftTopRightBottom, LeftBottomRightTop, RightTopLeftBottom, and RightBottomLeftTop.

When the widget visualizes local data, loading is instant. But when the widget is bound to a remote data source, loading may takes a considerable amount of time. To keep the viewer's attention, the widget can display a loading indicator.

To activate the loading indicator, assign true to the loadingIndicator.show option. Once data is loaded, the loading indicator will be hidden automatically.

See Also

• showLoadingIndicator()
• hideLoadingIndicator()

If you have a structure with deep nesting level, displaying all levels at once produces visual clutter. To reduce it, specify the number of levels that can be visualized at a time using the maxDepth property.

When you set this option, data that occupies the lowest levels may become unavailable to the user. For such cases, implement the drill down feature.

This function is often used to implement item selection as shown in the following code:

$(function () {
    $("#treeMapContainer").dxTreeMap({
        // ...
        onClick: function (e) {
            e.node.select(!e.node.isSelected());
        }
    });
});

<dx-tree-map ...
    (onClick)="selectItem($event)">
</dx-tree-map>

import { DxTreeMapModule } from "devextreme-angular";
// ...
export class AppComponent {
    selectItem (e) {
        e.node.select(!e.node.isSelected());
    }
}
@NgModule({
    imports: [
        // ...
        DxTreeMapModule
    ],
    // ...
})

To identify whether the clicked node is a single tile or a group of tiles, use the node's isLeaf() method.

Although not provided out-of-the-box, the drill down capability is easy to implement using the API methods. Learn how to do this from the drillDown() method description.

View Demo Watch Video

See Also

• onExporting
• onFileSaving

See Also

• onExported
• onFileSaving

See Also

• onExporting
• onExported

To identify whether the pointer has entered or left the node, call the node's isHovered() method. To identify whether the node is a single tile or a group of tiles, use the node's isLeaf() method.

The widget notifies you of errors and warnings by passing messages to the browser console. Each message contains the incident's ID, a brief description, and a link to the Errors and Warnings section where further information about this incident can be found.

The onIncidentOccurred function allows you to handle errors and warnings the way you require. The object passed to it contains the target field. This field provides information about the occurred incident and contains the following properties:

• id
  The incident's ID. The full list of IDs can be found in the Errors and Warnings section.
• type
  The incident's type: "error" or "warning".
• args
  The argument of the incident's message. Depends on the incident. For example, it may be the name of the data source field that was specified incorrectly, or the name of the option that was not set properly.
• text
  The text passed to the browser's console. Includes the args content, if there is any.
• widget
  The name of the widget that produced the error or warning.
• version
  The used DevExtreme version.

See Also

• Get a Widget Instance in Angular | AngularJS | Knockout | Vue | React

Use this function to change the node structure. The root node is available via the root field of the function's parameter. Using the root node's getAllNodes(), getAllChildren() and getChild(index) methods, you can access any other node.

To identify whether the selection has been applied or canceled, call the node's isSelected() method. To identify whether the clicked node is a single tile or a group of tiles, use the node's isLeaf() method.

In certain cases, you may have a plain data source that implies a hierarchical structure. For example, the following code declares a data source that, despite being plain, can be rearranged into a hierarchy of two groups with two items in each.

var treeMapOptions = {
    // ...
    dataSource: [
        // Group 1
        { id: 1, name: 'Fruits'},
        { parent: 1, name: 'Apples', value: 10 },
        { parent: 1, name: 'Oranges', value: 13 },

        // Group 2
        { id: 2, name: 'Vegetables' },
        { parent: 2, name: 'Cucumbers', value: 4 },
        { parent: 2, name: 'Tomatoes', value: 8 }
    ]
};

Note that in this data source, objects that have children have the "id" field whose value is unique. Their children have the "parent" field pointing at the parent's ID. The "id" and "parent" fields can have other names, but in any case they must be assigned to the idField and parentField options.

var treeMapOptions = {
    // ...
    idField: 'id',
    parentField: 'parent'
};

View Demo

If you place the widget on a page that uses a tag modifying the path (<base>, <iframe>, etc.), some of the widget elements may get mixed up or disappear. To solve this problem, set the pathModified option to true.

See Also

• DevExpress.viz.refreshPaths()

When this option is set to true, the widget will be redrawn automatically in case the size of its parent window changes.

Use the TreeMapResolveLabelOverflow enum to specify this option when the widget is used as an ASP.NET MVC Control. This enum accepts the following values: Hide and Ellipsis.

View Demo

When this option is set to true, the widget 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
});

In a single mode, only one node can be in the selected state at one moment. When the user selects another node, the formerly selected node becomes unselected. In a multiple mode, any number of nodes can be in the selected state.

To implement selection, assign the following or similar callback function to the onClick option.

var treeMapOptions = {
    // ...
    onClick: function (e) {
        e.node.select(!e.node.isSelected());
    }    
};

When entering the selected state, a tile or a group of tiles changes its appearance. You can configure it using the group | selectionStyle and tile.selectionStyle objects.

To control the selection feature in code, use the isSelected, select(state) and clearSelection() methods. In addition, you can perform certain actions when a node enters/leaves the selected state. For this purpose, implement the onSelectionChanged event handler.

Use the SelectionMode enum to specify this option when the widget is used as an ASP.NET MVC Control. This enum accepts the following values: None, Single and Multiple.

The widget occupies its container's entire area by default. Use the size object to specify the widget's size if it should be different from that of its container. Assign 0 to size object's height and width options to hide the widget.

$(function() {
    $("#treeMapContainer").dxTreeMap({
        // ...
        size: {
            height: 300,
            width: 600
        }
    });
});

<dx-tree-map ... >
    <dxo-size
        [height]="300"
        [width]="600">
    </dxo-size>
</dx-tree-map>

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

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

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

import { DxTreeMapModule } from 'devextreme-angular';

@NgModule({
    declarations: [
        AppComponent
    ],
    imports: [
        BrowserModule,
        DxTreeMapModule
    ],
    providers: [ ],
    bootstrap: [AppComponent]
})
export class AppModule { }

<template>
    <dx-tree-map ... >
        <dx-size
            :height="300"
            :width="600"
        />
    </dx-tree-map>
</template>

<script>
import 'devextreme/dist/css/dx.common.css';
import 'devextreme/dist/css/dx.light.css';

import DxTreeMap, {
    DxSize
} from 'devextreme-vue/tree-map';

export default {
    components: {
        DxTreeMap,
        DxSize
    },
    // ...
}
</script>

import React from 'react';

import 'devextreme/dist/css/dx.common.css';
import 'devextreme/dist/css/dx.light.css';

import TreeMap, {
    Size
} from 'devextreme-react/tree-map';

class App extends React.Component {
    render() {
        return (
            <TreeMap ... >
                <Size
                    height={300}
                    width={600}
                />
            </TreeMap>
        );
    }
}
export default App;

A theme is a widget configuration that gives the widget a distinctive appearance. Use can use one of the predefined themes or create a custom one. Changing the option values in the widget's configuration object overrides the theme's corresponding values.

Use the VizTheme enum to specify this option when the widget is used as an ASP.NET MVC Control. This enum accepts the following values: GenericLight, GenericDark, GenericContrast, GenericCarmine, GenericDarkMoon, GenericSoftBlue, GenericDarkViolet, GenericGreenMist, IOS7Default, MaterialBlueLight, MaterialLimeLight, MaterialOrangeLight, MaterialPurpleLight, MaterialTealLight.

A tile is a rectangle representing a node that has no children in the current context. Several tiles can be collected into a group if the data source implies a hierarchical structure.

The following list provides an overview of tiles' features that you can configure using the tile object.

• Labels
  Each tile is identified by a label. Its appearance can be changed using the fields of the label object. If the tile's area is too small, the label will be hidden.
• Color
  There are several approaches to colorizing the tiles. Refer to the color option description to find information about all of them.
• Hover and Selection Styles
  A tile can be in the hover or selected state. In these states, its style changes to the one specified by the hoverStyle or selectionStyle object respectively. Along with the tile, its parent group can enter the hover or selected state. To enable this feature, assign true to the interactWithGroup option of the root configuration object.
• Border's Appearance
  Specify the fields of the border object to configure the tile borders.

An object assigned to the tile field configures all tiles in the widget. To customize a specific tile, pass a similar object to the customize(options) method of the node represented by the tile.

The widget's title is a short text that usually indicates what is visualized. If you need to specify the title's text only, assign it directly to the title option. Otherwise, set this option to an object with the text and other fields specified.

The title can be accompanied by a subtitle elaborating on the visualized subject using the title.subtitle object.

See Also

• dataSource - specifies the origin of data for the widget.
• childrenField - specifies the data source field that provides nested items for a group.
• labelField - specifies the data source field that provides texts for tile and group labels.