TreeTable

TreeTable is used to display hierarchical data in tabular format.

Import #


import { TreeTableModule } from 'primeng/treetable';

Basic #

TreeTable requires a collection of TreeNode instances as a value components as children for the representation.


<p-treeTable [value]="files" [scrollable]="true" [tableStyle]="{'min-width':'50rem'}">
    <ng-template pTemplate="header">
        <tr>
            <th>Name</th>
            <th>Size</th>
            <th>Type</th>
        </tr>
    </ng-template>
    <ng-template pTemplate="body" let-rowNode let-rowData="rowData">
        <tr [ttRow]="rowNode">
            <td>
                <p-treeTableToggler [rowNode]="rowNode" />
                {{ rowData.name }}
            </td>
            <td>{{ rowData.size }}</td>
            <td>{{ rowData.type }}</td>
        </tr>
    </ng-template>
</p-treeTable>

Dynamic Columns #

Columns can be created programmatically.


<p-treeTable [value]="files" [columns]="cols" [scrollable]="true" [tableStyle]="{'min-width':'50rem'}">
    <ng-template pTemplate="header" let-columns>
        <tr>
            <th *ngFor="let col of columns">
                {{ col.header }}
            </th>
        </tr>
    </ng-template>
    <ng-template pTemplate="body" let-rowNode let-rowData="rowData" let-columns="columns">
        <tr [ttRow]="rowNode">
            <td *ngFor="let col of columns; let i = index">
                <p-treeTableToggler [rowNode]="rowNode" *ngIf="i === 0" />
                {{ rowData[col.field] }}
            </td>
        </tr>
    </ng-template>
</p-treeTable>

Controlled #

Expansion state is controlled with expandedKeys property.


<p-button (onClick)="toggleApplications()" label="Toggle Applications" />
<p-treeTable [value]="files" [scrollable]="true" [tableStyle]="{ 'min-width': '50rem' }" styleClass="mt-4">
    <ng-template pTemplate="header">
        <tr>
            <th>Name</th>
            <th>Size</th>
            <th>Type</th>
        </tr>
    </ng-template>
    <ng-template pTemplate="body" let-rowNode let-rowData="rowData">
        <tr [ttRow]="rowNode">
            <td>
                <p-treeTableToggler [rowNode]="rowNode" />
                {{ rowData.name }}
            </td>
            <td>{{ rowData.size }}</td>
            <td>{{ rowData.type }}</td>
        </tr>
    </ng-template>
</p-treeTable>

Template #

Custom content at caption, header, body and summary sections are supported via templating.


<p-treeTable [value]="files" [columns]="cols" [scrollable]="true" [tableStyle]="{ 'min-width': '50rem' }">
        <ng-template pTemplate="caption"><div class="text-xl font-bold">File Viewer</div> </ng-template>
        <ng-template pTemplate="header" let-columns>
            <tr>
                <th *ngFor="let col of columns">
                    {{ col.header }}
                </th>
            </tr>
        </ng-template>
        <ng-template pTemplate="body" let-rowNode let-rowData="rowData" let-columns="columns">
            <tr [ttRow]="rowNode">
                <td *ngFor="let col of columns; let i = index; let last = last">
                    <p-treeTableToggler [rowNode]="rowNode" *ngIf="i === 0" />
                    {{ rowData[col.field] }}
                    <ng-container *ngIf="last">
                        <p-button icon="pi pi-search" rounded="true" [style]="{ 'margin-right': '.5em' }" />
                        <p-button icon="pi pi-pencil" rounded="true" severity="success" />
                    </ng-container>
                </td>
            </tr>
        </ng-template>
        <ng-template pTemplate="summary">
            <div style="text-align:left">
                <p-button icon="pi pi-refresh" label="Reload" severity="warning" />
            </div>
        </ng-template>
</p-treeTable>

Size #

In addition to a regular treetable, alternatives with alternative sizes are available. Add p-treetable-sm class to reduce the size of treetable or p-treetable-lg to enlarge it.


<div class="flex justify-content-center mb-3">
    <p-selectButton 
        [options]="sizes" 
        [(ngModel)]="selectedSize" 
        [multiple]="false" 
        optionLabel="name" 
        optionValue="class" />
</div>
<p-treeTable 
    [value]="files" 
    [scrollable]="true" 
    [tableStyle]="{'min-width':'50rem'}" 
    [styleClass]="selectedSize">
        <ng-template pTemplate="header">
            <tr>
                <th>Name</th>
                <th>Size</th>
                <th>Type</th>
            </tr>
        </ng-template>
        <ng-template pTemplate="body" let-rowNode let-rowData="rowData">
            <tr [ttRow]="rowNode">
                <td>
                    <p-treeTableToggler [rowNode]="rowNode" />
                    {{ rowData.name }}
                </td>
                <td>{{ rowData.size }}</td>
                <td>{{ rowData.type }}</td>
            </tr>
        </ng-template>
</p-treeTable>

Grid Lines #

Adding p-treetable-gridlines class displays grid lines.


<p-treeTable 
    [value]="files" 
    [scrollable]="true" 
    [tableStyle]="{'min-width':'50rem'}" 
    styleClass="p-treetable-gridlines">
        <ng-template pTemplate="header">
            <tr>
                <th>Name</th>
                <th>Size</th>
                <th>Type</th>
            </tr>
        </ng-template>
        <ng-template pTemplate="body" let-rowNode let-rowData="rowData">
            <tr [ttRow]="rowNode">
                <td>
                    <p-treeTableToggler [rowNode]="rowNode" />
                    {{ rowData.name }}
                </td>
                <td>{{ rowData.size }}</td>
                <td>{{ rowData.type }}</td>
            </tr>
        </ng-template>
</p-treeTable>

Paginator #

Basic #

Pagination is enabled by adding paginator property and defining rows per page.


<p-treeTable 
    [value]="files" 
    [columns]="cols" 
    [paginator]="true" 
    [rows]="5" 
    [rowsPerPageOptions]="[5, 10, 25]" 
    [scrollable]="true" 
    [tableStyle]="{'min-width':'50rem'}">
        <ng-template pTemplate="header" let-columns>
            <tr>
                <th *ngFor="let col of columns">
                    {{ col.header }}
                </th>
            </tr>
        </ng-template>
        <ng-template pTemplate="body" let-rowNode let-rowData="rowData" let-columns="columns">
            <tr [ttRow]="rowNode">
                <td *ngFor="let col of columns; let i = index">
                    <p-treeTableToggler [rowNode]="rowNode" *ngIf="i === 0" />
                    {{ rowData[col.field] }}
                </td>
            </tr>
        </ng-template>
</p-treeTable>

Locale #

Paginator localization information such as page numbers and rows per page options are defined with the paginatorLocale property which defaults to the user locale.


<p-treeTable 
    paginatorLocale="fa-IR" 
    [value]="files" 
    [columns]="cols" 
    [paginator]="true" 
    [rows]="10" 
    [scrollable]="true" 
    [tableStyle]="{'min-width':'50rem'}">
        <ng-template pTemplate="header" let-columns>
            <tr>
                <th *ngFor="let col of columns">
                    {{ col.header }}
                </th>
            </tr>
        </ng-template>
        <ng-template pTemplate="body" let-rowNode let-rowData="rowData" let-columns="columns">
            <tr [ttRow]="rowNode">
                <td *ngFor="let col of columns; let i = index">
                    <p-treeTableToggler [rowNode]="rowNode" *ngIf="i === 0" />
                    {{ rowData[col.field] }}
                </td>
            </tr>
        </ng-template>
</p-treeTable>

Template #

Paginator UI is customized using the paginatorleft and paginatorright property. Each element can also be customized further with your own UI to replace the default one, refer to the Paginator component for more information about the advanced customization options.


<p-treeTable 
    [value]="files" 
    [columns]="cols" 
    [paginator]="true" 
    [rows]="10" 
    [scrollable]="true" 
    [tableStyle]="{'min-width':'50rem'}">
        <ng-template pTemplate="header" let-columns>
            <tr>
                <th *ngFor="let col of columns">
                    {{ col.header }}
                </th>
            </tr>
        </ng-template>
        <ng-template pTemplate="body" let-rowNode let-rowData="rowData" let-columns="columns">
            <tr [ttRow]="rowNode">
                <td *ngFor="let col of columns; let i = index">
                    <p-treeTableToggler [rowNode]="rowNode" *ngIf="i === 0" />
                    {{ rowData[col.field] }}
                </td>
            </tr>
        </ng-template>
        <ng-template pTemplate="paginatorleft">
            <p-button icon="pi pi-refresh" styleClass="p-button-text" />
        </ng-template>
        <ng-template pTemplate="paginatorright">
            <p-button icon="pi pi-download" styleClass="p-button-text" />
        </ng-template>
</p-treeTable>

Sort #

Single Column #

Sorting on a column is enabled by adding the ttSortableColumn property.


<p-treeTable 
    [value]="files" 
    [columns]="cols" 
    [scrollable]="true" 
    [tableStyle]="{'min-width':'50rem'}">
        <ng-template pTemplate="header" let-columns>
            <tr>
                <th *ngFor="let col of columns" [ttSortableColumn]="col.field">
                    {{ col.header }}
                    <p-treeTableSortIcon [field]="col.field" />
                </th>
            </tr>
        </ng-template>
        <ng-template pTemplate="body" let-rowNode let-rowData="rowData" let-columns="columns">
            <tr [ttRow]="rowNode">
                <td *ngFor="let col of columns; let i = index">
                    <p-treeTableToggler [rowNode]="rowNode" *ngIf="i === 0" />
                    {{ rowData[col.field] }}
                </td>
            </tr>
        </ng-template>
</p-treeTable>

Multiple Columns #

Multiple columns can be sorted by defining sortMode as multiple. This mode requires metaKey (e.g. ⌘) to be pressed when clicking a header.


<p-treeTable 
    [value]="files" 
    [columns]="cols" 
    sortMode="multiple" 
    [scrollable]="true" 
    [tableStyle]="{'min-width':'50rem'}">
        <ng-template pTemplate="header" let-columns>
            <tr>
                <th *ngFor="let col of columns" [ttSortableColumn]="col.field">
                    {{ col.header }}
                    <p-treeTableSortIcon [field]="col.field" />
                </th>
            </tr>
        </ng-template>
        <ng-template pTemplate="body" let-rowNode let-rowData="rowData" let-columns="columns">
            <tr [ttRow]="rowNode">
                <td *ngFor="let col of columns; let i = index">
                    <p-treeTableToggler [rowNode]="rowNode" *ngIf="i === 0" />
                    {{ rowData[col.field] }}
                </td>
            </tr>
        </ng-template>
</p-treeTable>

Filter #

The filterMode specifies the filtering strategy, in lenient mode when the query matches a node, children of the node are not searched further as all descendants of the node are included. On the other hand, in strict mode when the query matches a node, filtering continues on all descendants. A general filled called filterGlobal is also provided to search all columns that support filtering.

Lenient

Strict


<p-selectButton 
    [options]="filterModes" 
    [(ngModel)]="filterMode" 
    optionLabel="label" 
    optionValue="value" />

<p-treeTable 
    #tt 
    [value]="files" 
    [columns]="cols" 
    [filterMode]="filterMode" 
    [scrollable]="true" 
    [tableStyle]="{'min-width':'50rem'}">
        <ng-template pTemplate="caption">
            <div class="flex justify-content-end align-items-center">
                <div class="p-input-icon-left">
                    <i class="pi pi-search"></i>
                    <input 
                        type="text" 
                        pInputText 
                        placeholder="Global Search" 
                        (input)="tt.filterGlobal($event.target.value, 'contains')" />
                </div>
            </div>
        </ng-template>
        <ng-template pTemplate="header" let-columns>
            <tr>
                <th *ngFor="let col of cols">
                    {{ col.header }}
                </th>
            </tr>
            <tr>
                <th *ngFor="let col of cols">
                    <input 
                        pInputText 
                        type="text" 
                        (input)="tt.filter($event.target.value, col.field, col.filterMatchMode)" />
                </th>
            </tr>
        </ng-template>
        <ng-template pTemplate="body" let-rowNode let-rowData="rowData">
            <tr [ttRow]="rowNode">
                <td *ngFor="let col of cols; let i = index">
                    <p-treeTableToggler [rowNode]="rowNode" *ngIf="i === 0" />
                    {{ rowData[col.field] }}
                </td>
            </tr>
        </ng-template>
        <ng-template pTemplate="emptymessage">
            <tr>
                <td [attr.colspan]="cols.length">No data found.</td>
            </tr>
        </ng-template>
</p-treeTable>

Selection #

Single #

Single node selection is configured by setting selectionMode as single along with selection properties to manage the selection value binding.

By default, metaKey press (e.g. ⌘) is necessary to unselect a node however this can be configured with disabling the metaKeySelection property. In touch enabled devices this option has no effect and behavior is same as setting it to false

Metakey


<p-treeTable 
    [value]="files" 
    [columns]="cols" 
    selectionMode="single" 
    [(selection)]="selectedNode" 
    dataKey="name" 
    [scrollable]="true" 
    [tableStyle]="{'min-width':'50rem'}">
        <ng-template pTemplate="header" let-columns>
            <tr>
                <th *ngFor="let col of columns">
                    {{ col.header }}
                </th>
            </tr>
        </ng-template>
        <ng-template pTemplate="body" let-rowNode let-rowData="rowData" let-columns="columns">
            <tr [ttRow]="rowNode" [ttSelectableRow]="rowNode">
                <td *ngFor="let col of columns; let i = index">
                    <p-treeTableToggler [rowNode]="rowNode" *ngIf="i === 0" />
                    {{ rowData[col.field] }}
                </td>
            </tr>
        </ng-template>
</p-treeTable>

Multiple #

More than one node is selectable by setting selectionMode to multiple. By default in multiple selection mode, metaKey press (e.g. ⌘) is necessary to add to existing selections however this can be configured with disabling the metaKeySelection property. Note that in touch enabled devices, TreeTable always ignores metaKey.

Metakey


<p-inputSwitch [(ngModel)]="metaKeySelection" />
<p-treeTable 
    [value]="files" 
    [columns]="cols" 
    selectionMode="multiple" 
    [(selection)]="selectedNodes" 
    dataKey="name" 
    [metaKeySelection]="metaKeySelection" 
    [scrollable]="true" 
    [tableStyle]="{'min-width':'50rem'}">
        <ng-template pTemplate="header" let-columns>
            <tr>
                <th *ngFor="let col of columns">
                    {{ col.header }}
                </th>
            </tr>
        </ng-template>
        <ng-template pTemplate="body" let-rowNode let-rowData="rowData" let-columns="columns">
            <tr [ttRow]="rowNode" [ttSelectableRow]="rowNode">
                <td *ngFor="let col of columns; let i = index">
                    <p-treeTableToggler [rowNode]="rowNode" *ngIf="i === 0" />
                    {{ rowData[col.field] }}
                </td>
            </tr>
        </ng-template>
</p-treeTable>

Checkbox #

Selection of multiple nodes via checkboxes is enabled by configuring selectionMode as checkbox.

In checkbox selection mode, value binding should be a key-value pair where key (or the dataKey) is the node key and value is an object that has checked and partialChecked properties to represent the checked state of a node.


{
    '0-0': {
        partialChecked: false,
        checked: true
    }
}


<p-treeTable 
    [value]="files" 
    [columns]="cols" 
    selectionMode="checkbox" 
    [(selectionKeys)]="selectionKeys" 
    dataKey="key" 
    [scrollable]="true" 
    [tableStyle]="{ 'min-width': '50rem' }">
        <ng-template pTemplate="header" let-columns>
            <tr>
                <th *ngFor="let col of columns">
                    {{ col.header }}
                </th>
            </tr>
        </ng-template>
        <ng-template pTemplate="body" let-rowNode let-rowData="rowData" let-columns="columns">
            <tr [ttRow]="rowNode" [ttSelectableRow]="rowNode">
                <td *ngFor="let col of columns; let i = index">
                    <p-treeTableToggler [rowNode]="rowNode" *ngIf="i === 0" />
                    <p-treeTableCheckbox [value]="rowNode" *ngIf="i === 0" />
                    {{ rowData[col.field] }}
                </td>
            </tr>
        </ng-template>
</p-treeTable>

Events #

TreeTable provides onNodeSelect and onNodeUnselect events to listen selection events.


<p-treeTable 
    [value]="files" 
    [columns]="cols" 
    selectionMode="single" 
    [(selection)]="selectedNode" 
    dataKey="name" 
    (onNodeSelect)="nodeSelect($event)" 
    (onNodeUnselect)="nodeUnselect($event)" 
    [scrollable]="true" 
    [tableStyle]="{'min-width':'50rem'}">
        <ng-template pTemplate="header" let-columns>
            <tr>
                <th *ngFor="let col of columns">
                    {{ col.header }}
                </th>
            </tr>
        </ng-template>
        <ng-template pTemplate="body" let-rowNode let-rowData="rowData" let-columns="columns">
            <tr [ttRow]="rowNode" [ttSelectableRow]="rowNode">
                <td *ngFor="let col of columns; let i = index">
                    <p-treeTableToggler [rowNode]="rowNode" *ngIf="i === 0" />
                    {{ rowData[col.field] }}
                </td>
            </tr>
        </ng-template>
</p-treeTable>

Column Group #


<p-treeTable [value]="sales" [scrollable]="true" [tableStyle]="{'min-width':'50rem'}">
    <ng-template pTemplate="header">
        <tr>
            <th rowspan="3">Brand</th>
            <th colspan="4">Sale Rate</th>
        </tr>
        <tr>
            <th colspan="2">Sales</th>
            <th colspan="2">Profits</th>
        </tr>
        <tr>
            <th>Last Year</th>
            <th>This Year</th>
            <th>Last Year</th>
            <th>This Year</th>
        </tr>
    </ng-template>
    <ng-template pTemplate="body" let-rowNode let-rowData="rowData">
        <tr>
            <td>
                <p-treeTableToggler [rowNode]="rowNode" />
                {{ rowData.brand }}
            </td>
            <td>{{ rowData.lastYearSale }}</td>
            <td>{{ rowData.thisYearSale }}</td>
            <td>{{ rowData.lastYearProfit }}</td>
            <td>{{ rowData.thisYearProfit }}</td>
        </tr>
    </ng-template>
    <ng-template pTemplate="footer">
        <tr>
            <td colspan="3">Totals</td>
            <td>$3,283,772</td>
            <td>$2,126,925</td>
        </tr>
    </ng-template>
</p-treeTable>

Lazy Load #

Lazy mode is handy to deal with large datasets, instead of loading the entire data, small chunks of data is loaded by invoking corresponding callbacks everytime paging, sorting and filtering occurs. Sample below imitates lazy loading data from a remote datasource using an in-memory list and timeouts to mimic network connection.

Enabling the lazy property and assigning the logical number of rows to totalRecords by doing a projection query are the key elements of the implementation so that paginator displays the UI assuming there are actually records of totalRecords size although in reality they are not present on page, only the records that are displayed on the current page exist.

In addition, only the root elements should be loaded, children can be loaded on demand using onNodeExpand callback.

Name	Size	Type

Item 0	335kb	Type 0
Item 1	690kb	Type 1
Item 2	833kb	Type 2
Item 3	749kb	Type 3
Item 4	120kb	Type 4
Item 5	500kb	Type 5
Item 6	867kb	Type 6
Item 7	754kb	Type 7
Item 8	806kb	Type 8
Item 9	410kb	Type 9


<p-treeTable 
    [value]="files" 
    [columns]="cols" 
    [paginator]="true" 
    [rows]="10" 
    [lazy]="true" 
    (onLazyLoad)="loadNodes($event)" 
    [totalRecords]="1000" 
    [loading]="loading" 
    (onNodeExpand)="onNodeExpand($event)" 
    [scrollable]="true" 
    [tableStyle]="{'min-width':'50rem'}">
        <ng-template pTemplate="header" let-columns>
            <tr>
                <th *ngFor="let col of columns">
                    {{ col.header }}
                </th>
            </tr>
        </ng-template>
        <ng-template pTemplate="body" let-rowNode let-rowData="rowData" let-columns="columns">
            <tr [ttRow]="rowNode">
                <td *ngFor="let col of columns; let i = index">
                    <p-treeTableToggler [rowNode]="rowNode" *ngIf="i === 0" />
                    {{ rowData[col.field] }}
                </td>
            </tr>
        </ng-template>
</p-treeTable>

Edit #

Incell editing is enabled by defining input elements with treeTableCellEditor.


<p-treeTable 
    [value]="files" 
    [columns]="cols" 
    [scrollable]="true" 
    [tableStyle]="{'min-width':'50rem'}">
        <ng-template pTemplate="header" let-columns>
            <tr>
                <th *ngFor="let col of columns">
                    {{ col.header }}
                </th>
            </tr>
        </ng-template>
        <ng-template pTemplate="body" let-rowNode let-rowData="rowData" let-columns="columns">
            <tr [ttRow]="rowNode">
                <td *ngFor="let col of columns; let i = index" ttEditableColumn [ttEditableColumnDisabled]="i == 0" [ngClass]="{ 'p-toggler-column': i === 0 }">
                    <p-treeTableToggler [rowNode]="rowNode" *ngIf="i === 0" />
                    <p-treeTableCellEditor>
                        <ng-template pTemplate="input">
                            <input pInputText type="text" [(ngModel)]="rowData[col.field]" />
                        </ng-template>
                        <ng-template pTemplate="output">
                            {{ rowData[col.field] }}
                        </ng-template>
                    </p-treeTableCellEditor>
                </td>
            </tr>
        </ng-template>
</p-treeTable>

Scroll #

Vertical #

Adding scrollable property along with a scrollHeight for the data viewport enables vertical scrolling with fixed headers.


<p-treeTable 
    [value]="files" 
    [columns]="cols" 
    [scrollable]="true" 
    scrollHeight="200px" 
    [scrollable]="true" 
    [tableStyle]="{'min-width':'50rem'}">
        <ng-template pTemplate="header" let-columns>
            <tr>
                <th *ngFor="let col of columns">
                    {{ col.header }}
                </th>
            </tr>
        </ng-template>
        <ng-template pTemplate="body" let-rowNode let-rowData="rowData" let-columns="columns">
            <tr [ttRow]="rowNode">
                <td *ngFor="let col of columns; let i = index">
                    <p-treeTableToggler [rowNode]="rowNode" *ngIf="i === 0" />
                    {{ rowData[col.field] }}
                </td>
            </tr>
        </ng-template>
</p-treeTable>

Flexible #

Flex scroll feature makes the scrollable viewport section dynamic instead of a fixed value so that it can grow or shrink relative to the parent size of the table. Click the button below to display a maximizable Dialog where data viewport adjusts itself according to the size changes.


<p-button label="Show" icon="pi pi-external-link" (onClick)="dialogVisible = true" />
<p-dialog 
    [(visible)]="dialogVisible" 
    header="Flex Scroll" 
    [style]="{ width: '75vw' }" 
    maximizable 
    modal 
    [contentStyle]="{ height: '300px' }">
        <ng-template pTemplate="content">
            <p-treeTable 
                [value]="files" 
                [scrollable]="true" 
                scrollHeight="flex" 
                [tableStyle]="{ 'min-width': '50rem' }">
                    <ng-template pTemplate="header">
                        <tr>
                            <th>Name</th>
                            <th>Size</th>
                            <th>Type</th>
                        </tr>
                    </ng-template>
                    <ng-template pTemplate="body" let-rowNode let-rowData="rowData">
                        <tr [ttRow]="rowNode">
                            <td>
                                <p-treeTableToggler [rowNode]="rowNode" />
                                {{ rowData.name }}
                            </td>
                            <td>
                                {{ rowData.size }}
                            </td>
                            <td>
                                {{ rowData.type }}
                            </td>
                        </tr>
                    </ng-template>
            </p-treeTable>
        </ng-template>
        <ng-template pTemplate="footer">
            <p-button label="Ok" icon="pi pi-check" (onClick)="dialogVisible = false" />
        </ng-template>
</p-dialog>

Horizontal #

Horizontal scrolling is enabled when the total width of columns exceeds table width.


<p-treeTable [value]="files" [columns]="cols" [scrollable]="true" scrollHeight="200px" [scrollable]="true" [tableStyle]="{'min-width':'50rem'}">
    <ng-template pTemplate="colgroup" let-columns>
        <colgroup>
            <col *ngFor="let col of columns" style="width:500px" />
        </colgroup>
    </ng-template>
    <ng-template pTemplate="header" let-columns>
        <tr>
            <th *ngFor="let col of columns">
                {{ col.header }}
            </th>
        </tr>
    </ng-template>
    <ng-template pTemplate="body" let-rowNode let-rowData="rowData" let-columns="columns">
        <tr [ttRow]="rowNode">
            <td *ngFor="let col of columns; let i = index">
                <p-treeTableToggler [rowNode]="rowNode" *ngIf="i === 0"></p-treeTableToggler>
                {{ rowData[col.field] }}
            </td>
        </tr>
    </ng-template>
</p-treeTable>

Frozen Columns #

A column can be fixed during horizontal scrolling by enabling the frozenColumns property.


<p-treeTable 
    [value]="files" 
    [columns]="scrollableCols" 
    [frozenColumns]="frozenCols" 
    [scrollable]="true" 
    scrollHeight="250px" 
    frozenWidth="200px" 
    [scrollable]="true" 
    [tableStyle]="{'min-width':'50rem'}">
        <ng-template pTemplate="colgroup" let-columns>
            <colgroup>
                <col *ngFor="let col of columns" style="width:250px" />
            </colgroup>
        </ng-template>
        <ng-template pTemplate="header" let-columns>
            <tr>
                <th *ngFor="let col of columns">
                    {{ col.header }}
                </th>
            </tr>
        </ng-template>
        <ng-template pTemplate="body" let-rowData="rowData" let-columns="columns">
            <tr [ttRow]="rowNode" style="height: 57px">
                <td *ngFor="let col of columns; let i = index">
                    {{ rowData[col.field] }}
                </td>
            </tr>
        </ng-template>
        <ng-template pTemplate="frozenbody" let-rowNode let-rowData="rowData">
            <tr [ttRow]="rowNode" style="height: 57px">
                <td>
                    <p-treeTableToggler [rowNode]="rowNode" />
                    {{ rowData.name }}
                </td>
            </tr>
        </ng-template>
</p-treeTable>

Column Resize #

Fit Mode #

Columns can be resized with drag and drop when resizableColumns is enabled. Default resize mode is fit that does not change the overall table width.


<p-treeTable 
    [value]="files" 
    [columns]="cols" 
    [resizableColumns]="true" 
    [tableStyle]="{'min-width': '50rem'}">
        <ng-template pTemplate="header" let-columns>
            <tr>
                <th *ngFor="let col of columns" ttResizableColumn>
                    {{ col.header }}
                </th>
            </tr>
        </ng-template>
        <ng-template pTemplate="body" let-rowNode let-rowData="rowData" let-columns="columns">
            <tr [ttRow]="rowNode">
                <td *ngFor="let col of columns; let i = index">
                    <p-treeTableToggler [rowNode]="rowNode" *ngIf="i === 0" />
                    {{ rowData[col.field] }}
                </td>
            </tr>
        </ng-template>
</p-treeTable>

Expand Mode #

Setting columnResizeMode as expand changes the table width as well.


<p-treeTable 
    [value]="files" 
    [columns]="cols" 
    [resizableColumns]="true" 
    columnResizeMode="expand">
        <ng-template pTemplate="header" let-columns>
            <tr>
                <th *ngFor="let col of columns" ttResizableColumn>
                    {{ col.header }}
                </th>
            </tr>
        </ng-template>
        <ng-template pTemplate="body" let-rowNode let-rowData="rowData" let-columns="columns">
            <tr [ttRow]="rowNode">
                <td *ngFor="let col of columns; let i = index">
                    <p-treeTableToggler [rowNode]="rowNode" *ngIf="i === 0" />
                    {{ rowData[col.field] }}
                </td>
            </tr>
        </ng-template>
</p-treeTable>

Scrollable #

To utilize the column resize modes with a scrollable TreeTable, a colgroup template must be defined. The default value of scrollHeight is "flex," it can also be set as a string value.


<p-treeTable 
    [value]="files" 
    [columns]="cols" 
    [resizableColumns]="true" 
    [scrollable]="true" 
    scrollHeight="200px">
        <ng-template pTemplate="colgroup" let-columns>
            <colgroup>
                <col *ngFor="let col of columns">
            </colgroup>
        </ng-template>
        <ng-template pTemplate="header" let-columns>
            <tr>
                <th *ngFor="let col of columns" ttResizableColumn>
                    {{ col.header }}
                </th>
            </tr>
        </ng-template>
        <ng-template pTemplate="body" let-rowNode let-rowData="rowData" let-columns="columns">
            <tr [ttRow]="rowNode">
                <td *ngFor="let col of columns; let i = index">
                    <p-treeTableToggler [rowNode]="rowNode" *ngIf="i === 0" />
                    {{ rowData[col.field] }}
                </td>
            </tr>
        </ng-template>
</p-treeTable>

Reorder #

Order of the columns can be changed using drag and drop when reorderableColumns is present.


<p-treeTable [value]="files" [columns]="cols" [reorderableColumns]="true" [scrollable]="true" [tableStyle]="{'min-width':'50rem'}">
    <ng-template pTemplate="header" let-columns>
        <tr>
            <th *ngFor="let col of columns" ttReorderableColumn>
                {{ col.header }}
            </th>
        </tr>
    </ng-template>
    <ng-template pTemplate="body" let-rowNode let-rowData="rowData" let-columns="columns">
        <tr [ttRow]="rowNode">
            <td *ngFor="let col of columns; let i = index">
                <p-treeTableToggler [rowNode]="rowNode" *ngIf="i === 0"></p-treeTableToggler>
                {{ rowData[col.field] }}
            </td>
        </tr>
    </ng-template>
</p-treeTable>

Column Toggle #

Column visibility based on a condition can be implemented with dynamic columns, in this sample a MultiSelect is used to manage the visible columns.


<p-treeTable 
    [value]="files" 
    [columns]="selectedColumns" 
    [scrollable]="true" 
    [tableStyle]="{'min-width':'50rem'}">
        <ng-template pTemplate="caption">
            <div style="text-align:left">
                <p-multiSelect 
                    [options]="cols" 
                    [(ngModel)]="selectedColumns"
                    optionLabel="header" 
                    selectedItemsLabel="{0} columns selected" 
                    [style]="{ width: '20em' }" 
                    defaultLabel="Choose Columns" display="chip" />
            </div>
        </ng-template>
        <ng-template pTemplate="header" let-columns>
            <tr>
                <th *ngFor="let col of columns">
                    {{ col.header }}
                </th>
            </tr>
        </ng-template>
        <ng-template pTemplate="body" let-rowNode let-rowData="rowData" let-columns="columns">
            <tr [ttRow]="rowNode">
                <td *ngFor="let col of columns; let i = index">
                    <p-treeTableToggler [rowNode]="rowNode" *ngIf="i === 0" />
                    {{ rowData[col.field] }}
                </td>
            </tr>
        </ng-template>
</p-treeTable>

Conditional Style #

Particular rows and cells can be styled based on conditions. The ngClass receives a row data as a parameter to return a style class for a row whereas cells are customized using the body template.


<p-treeTable 
    [value]="files" 
    [columns]="cols" 
    [scrollable]="true" 
    [tableStyle]="{'min-width':'50rem'}">
        <ng-template pTemplate="header" let-columns>
            <tr>
                <th *ngFor="let col of columns">
                    {{ col.header }}
                </th>
            </tr>
        </ng-template>
        <ng-template pTemplate="body" let-rowNode let-rowData="rowData" let-columns="columns">
            <tr [ttRow]="rowNode" [ngClass]="{ 'p-highlight': rowData.size.endsWith('kb') }">
                <td 
                    *ngFor="let col of columns; let i = index" 
                    [ngClass]="{ 'font-bold': col.field === 'size' && rowData.size.endsWith('kb') }">
                        <p-treeTableToggler [rowNode]="rowNode" *ngIf="i === 0" />
                        {{ rowData[col.field] }}
                </td>
            </tr>
        </ng-template>
</p-treeTable>

Context Menu #

TreeTable has exclusive integration with ContextMenu using the contextMenu event to open a menu on right click alont with contextMenuSelection properties to control the selection via the menu.


<p-toast [style]="{ marginTop: '80px' }" />

<p-treeTable 
    [value]="files" 
    [columns]="cols" 
    dataKey="name" 
    [(contextMenuSelection)]="selectedNode" 
    [contextMenu]="cm" 
    [scrollable]="true" 
    [tableStyle]="{'min-width':'50rem'}">
        <ng-template pTemplate="header" let-columns>
            <tr>
                <th *ngFor="let col of columns">
                    {{ col.header }}
                </th>
            </tr>
        </ng-template>
        <ng-template pTemplate="body" let-rowNode let-rowData="rowData" let-columns="columns">
            <tr [ttRow]="rowNode" [ttContextMenuRow]="rowNode">
                <td *ngFor="let col of columns; let i = index">
                    <p-treeTableToggler [rowNode]="rowNode" *ngIf="i === 0" />
                    {{ rowData[col.field] }}
                </td>
            </tr>
        </ng-template>
</p-treeTable>

<p-contextMenu #cm [model]="items" />

Style #

Following is the list of structural style classes, for theming classes visit theming page.

Name	Element
p-treetable	Container element.
p-treetable-caption	Caption element.
p-treetable-summary	Section section.
p-sortable-column	Sortable column header.
p-treetable-scrollable-header	Container of header in a scrollable table.
p-treetable-scrollable-body	Container of body in a scrollable table.
p-treetable-scrollable-footer	Container of footer in a scrollable table.
p-treetable-loading	Loader mask.
p-treetable-loading-content	Loader content.
p-treetable-wrapper	Loader content.
p-treetable-scrollable-wrapper	Loader content.
p-treetable-resizer-helper	Vertical resize indicator bar.
p-treetable-reorder-indicator-top	Top indicator of column reordering.
p-treetable-reorder-indicator-top	Bottom indicator of column reordering.

Accessibility #

Screen Reader

Default role of the table is table. Header, body and footer elements use rowgroup, rows use row role, header cells have columnheader and body cells use cell roles. Sortable headers utilizer aria-sort attribute either set to "ascending" or "descending".

Row elements manage aria-expanded for state and aria-level attribute to define the hierachy by ttRow directive. Table rows and table cells should be specified by users using the aria-posinset, aria-setsize, aria-label, and aria-describedby attributes, as they are determined through templating.

When selection is enabled, ttSelectableRow directive sets aria-selected to true on a row. In checkbox mode, the built-in checkbox component use checkbox role with aria-checked state attribute.

Editable cells use custom templating so you need to manage aria roles and attributes manually if required.

Paginator is a standalone component used inside the TreeTable, refer to the paginator for more information about the accessibility features.

Sortable Headers Keyboard Support

Key	Function
tab	Moves through the headers.
enter	Sorts the column.
space	Sorts the column.

Keyboard Support

Key	Function
tab	Moves focus to the first selected node when focus enters the component, if there is none then first element receives the focus. If focus is already inside the component, moves focus to the next focusable element in the page tab sequence.
shift + tab	Moves focus to the last selected node when focus enters the component, if there is none then first element receives the focus. If focus is already inside the component, moves focus to the previous focusable element in the page tab sequence.
enter	Selects the focused treenode.
space	Selects the focused treenode.
down arrow	Moves focus to the next treenode.
up arrow	Moves focus to the previous treenode.
right arrow	If node is closed, opens the node otherwise moves focus to the first child node.
left arrow	If node is open, closes the node otherwise moves focus to the parent node.

TreeTable API

API defines helper props, events and others for the PrimeNG TreeTable module.

TreeTable #

TreeTable is used to display hierarchical data in tabular format.

Properties #

Defines the input properties of the component.

name	type	default	description
columns	any[]	null	An array of objects to represent dynamic columns.
style	Object	null	Inline style of the component.
styleClass	string	null	Style class of the component.
tableStyle	Object	null	Inline style of the table.
tableStyleClass	string	null	Style class of the table.
autoLayout	boolean	false	Whether the cell widths scale according to their content or not.
lazy	boolean	false	Defines if data is loaded and interacted with in lazy manner.
lazyLoadOnInit	boolean	true	Whether to call lazy loading on initialization.
paginator	boolean	false	When specified as true, enables the pagination.
rows	number	null	Number of rows to display per page.
first	number	0	Index of the first row to be displayed.
pageLinks	number	5	Number of page links to display in paginator.
rowsPerPageOptions	any[]	null	Array of integer/object values to display inside rows per page dropdown of paginator
alwaysShowPaginator	boolean	true	Whether to show it even there is only one page.
paginatorPosition	"both" \| "top" \| "bottom"	bottom	Position of the paginator.
paginatorStyleClass	string	null	Custom style class for paginator
paginatorDropdownAppendTo	any	null	Target element to attach the paginator dropdown overlay, valid values are "body" or a local ng-template variable of another element (note: use binding with brackets for template variables, e.g. [appendTo]="mydiv" for a div element having #mydiv as variable name).
currentPageReportTemplate	string	{currentPage} of {totalPages}	Template of the current page report element. Available placeholders are {currentPage},{totalPages},{rows},{first},{last} and {totalRecords}
showCurrentPageReport	boolean	false	Whether to display current page report.
showJumpToPageDropdown	boolean	false	Whether to display a dropdown to navigate to any page.
showFirstLastIcon	boolean	true	When enabled, icons are displayed on paginator to go first and last page.
showPageLinks	boolean	true	Whether to show page links.
defaultSortOrder	number	1	Sort order to use when an unsorted column gets sorted by user interaction.
sortMode	"multiple" \| "single"	single	Defines whether sorting works on single column or on multiple columns.
resetPageOnSort	boolean	true	When true, resets paginator to first page after sorting.
customSort	boolean	false	Whether to use the default sorting or a custom one using sortFunction.
selectionMode	string	null	Specifies the selection mode, valid values are "single" and "multiple".
contextMenuSelection	any	null	Selected row with a context menu.
contextMenuSelectionMode	string	separate	Mode of the contet menu selection.
dataKey	string	null	A property to uniquely identify a record in data.
metaKeySelection	boolean	false	Defines whether metaKey is should be considered for the selection. On touch enabled devices, metaKeySelection is turned off automatically.
compareSelectionBy	string	deepEquals	Algorithm to define if a row is selected, valid values are "equals" that compares by reference and "deepEquals" that compares all fields.
rowHover	boolean	false	Adds hover effect to rows without the need for selectionMode.
loading	boolean	false	Displays a loader to indicate data load is in progress.
loadingIcon	string	null	The icon to show while indicating data load is in progress.
showLoader	boolean	true	Whether to show the loading mask when loading property is true.
scrollable	boolean	false	When specifies, enables horizontal and/or vertical scrolling.
scrollHeight	string	null	Height of the scroll viewport in fixed pixels or the "flex" keyword for a dynamic size.
virtualScroll	boolean	false	Whether the data should be loaded on demand during scroll.
virtualScrollItemSize	number	null	Height of a row to use in calculations of virtual scrolling.
virtualScrollOptions	ScrollerOptions	null	Whether to use the scroller feature. The properties of scroller component can be used like an object in it.
virtualScrollDelay	number	150	The delay (in milliseconds) before triggering the virtual scroll. This determines the time gap between the user's scroll action and the actual rendering of the next set of items in the virtual scroll.
frozenWidth	string	null	Width of the frozen columns container.
frozenColumns	Object	null	An array of objects to represent dynamic columns that are frozen.
resizableColumns	boolean	false	When enabled, columns can be resized using drag and drop.
columnResizeMode	string	fit	Defines whether the overall table width should change on column resize, valid values are "fit" and "expand".
reorderableColumns	boolean	false	When enabled, columns can be reordered using drag and drop.
contextMenu	any	null	Local ng-template varilable of a ContextMenu.
rowTrackBy	Function	...	Function to optimize the dom operations by delegating to ngForTrackBy, default algorithm checks for object identity.
filters	Object	{}	An array of FilterMetadata objects to provide external filters.
globalFilterFields	string[]	null	An array of fields as string to use in global filtering.
filterDelay	number	300	Delay in milliseconds before filtering the data.
filterMode	string	lenient	Mode for filtering valid values are "lenient" and "strict". Default is lenient.
filterLocale	string	null	Locale to use in filtering. The default locale is the host environment's current locale.
paginatorLocale	string	null	Locale to be used in paginator formatting.
totalRecords	number	null	Number of total records, defaults to length of value when not defined.
sortField	string	null	Name of the field to sort data by default.
sortOrder	number	null	Order to sort when default sorting is enabled.
multiSortMeta	SortMeta[]	null	An array of SortMeta objects to sort the data by default in multiple sort mode.
selection	any	null	Selected row in single mode or an array of values in multiple mode.
value	TreeNode<any>[]	null	An array of objects to display.
virtualRowHeight	number	null	Indicates the height of rows to be scrolled.
selectionKeys	any	null	A map of keys to control the selection state.

Emitters #

Defines emit that determine the behavior of the component based on a given condition or report the actions that the component takes.

name	parameters	description
selectionChange	value : TreeTableNode	Callback to invoke on selected node change.
contextMenuSelectionChange	value : TreeTableNode	Callback to invoke on context menu selection change.
onFilter	event : TreeTableFilterEvent	Callback to invoke when data is filtered.
onNodeExpand	event : TreeTableNodeExpandEvent	Callback to invoke when a node is expanded.
onNodeCollapse	event : TreeTableNodeCollapseEvent	Callback to invoke when a node is collapsed.
onPage	value : TreeTablePaginatorState	Callback to invoke when pagination occurs.
onSort	value : any	Callback to invoke when a column gets sorted.
onLazyLoad	event : TreeTableLazyLoadEvent	Callback to invoke when paging, sorting or filtering happens in lazy mode.
sortFunction	event : TreeTableSortEvent	An event emitter to invoke on custom sorting, refer to sorting section for details.
onColResize	event : TreeTableColResizeEvent	Callback to invoke when a column is resized.
onColReorder	event : TreeTableColumnReorderEvent	Callback to invoke when a column is reordered.
onNodeSelect	value : TreeTableNode	Callback to invoke when a node is selected.
onNodeUnselect	event : TreeTableNodeUnSelectEvent	Callback to invoke when a node is unselected.
onContextMenuSelect	event : TreeTableContextMenuSelectEvent	Callback to invoke when a node is selected with right click.
onHeaderCheckboxToggle	event : TreeTableHeaderCheckboxToggleEvent	Callback to invoke when state of header checkbox changes.
onEditInit	event : TreeTableEditEvent	Callback to invoke when a cell switches to edit mode.
onEditComplete	event : TreeTableEditEvent	Callback to invoke when cell edit is completed.
onEditCancel	event : TreeTableEditEvent	Callback to invoke when cell edit is cancelled with escape key.
selectionKeysChange	value : any	Callback to invoke when selectionKeys are changed.

Methods #

Defines methods that can be accessed by the component's reference.

name	parameters	description
resetScrollTop		Resets scroll to top.
scrollToVirtualIndex	index : number	Scrolls to given index when using virtual scroll.
scrollTo	options : ScrollToOptions	Scrolls to given index.
reset		Clears the sort and paginator state.

Templates #

Defines the templates used by the component.

name	parameters	description
caption		Custom caption template.
header	context : { $implicit: any, // Columns instance. }	Custom header template.
body	context : { $implicit: TreeNode, // undefined node: TreeNode, // Serialized node. rowData: any, // Row data. columns: any, // Columns instance. }	Custom body template.
footer	context : { $implicit: any, // Columns instance. }	Custom footer template.
summary		Custom summary template.
colgroup	context : { $implicit: any, // Columns instance. }	Custom colgroup template.
emptymessage	context : { $implicit: any, // Columns instance. frozen: boolean, // Boolean value indicates whether column is frozen. }	Custom emptymessage template.
paginatorleft		Custom paginator left section template.
paginatorright		Custom paginator right section template.
paginatordropdownitem		Custom paginator dropdown template.
frozenheader	context : { $implicit: any, // Columns instance. }	Custom frozenheader template.
frozenbody		Custom frozenbody template.
frozenfooter	context : { $implicit: any, // Columns instance. }	Custom frozenfooter template.
frozencolgroup	context : { $implicit: any, // Columns instance. }	Custom frozen column group template.
loadingicon		Custom loading icon template.
reorderindicatorupicon		Custom reorder indicator up icon template.
reorderindicatordownicon		Custom reorder indicator down icon template.
sorticon	context : { $implicit: number, // Sort order. }	Custom sort icon template.
checkboxicon	context : { $implicit: boolean, // Checkbox state. partialSelected: boolean, // Partial selection state of row node. }	Custom checkbox icon template.
headercheckboxicon	context : { $implicit: boolean, // Checkbox state. }	Custom header checkbox icon template.
togglericon	context : { $implicit: boolean, // Expand state of row node. }	Custom toggler icon template.
paginatorfirstpagelinkicon		Custom paginator first page link icon template.
paginatorlastpagelinkicon		Custom paginatorlastpagelinkicon template.
paginatorpreviouspagelinkicon		Custom paginatorpreviouspagelinkicon template.
paginatornextpagelinkicon		Custom paginatornextpagelinkicon template.

Events #

Defines the custom events used by the component's emitters.

TreeTableLazyLoadEvent #

Custom lazy load event.

name	type	description
rows	number
sortField	string \| string[]
sortOrder	number
filters	Object
globalFilter	string \| string[]
multiSortMeta	SortMeta[]
forceUpdate	Function
first	any	First element in viewport.
last	any	Last element in viewport.

TreeTableColumnReorderEvent #

Custom column reorder event.

name	type	description
dragIndex	number	Index of the dragged item.
dropIndex	number	Index of the drop position.
columns	any[]	Columns after reorder.

TreeTableFilterEvent #

Custom filter event.

name	type	description
filters	Object	Filter meta.
filteredValue	TreeNode<any>[]	Value after filter.

TreeTableNodeExpandEvent #

Custom node expand event.

name	type	description
originalEvent	Event	Browser event.
node	TreeTableNode<T>	Node instance.

TreeTableNodeCollapseEvent #

Custom node collapse event.

name	type	description
originalEvent	Event	Browser event.
node	TreeTableNode<T>	Node instance.

TreeTableSortEvent #

Custom sort event.

name	type	description
originalEvent	Event	Browser event.
data	TreeNode<any>[]	Value to be sorted.
mode	"multiple" \| "single"	Sort mode.
field	string	Sort field.
order	number	Sort order.
multiSortMeta	SortMeta[]	Multiple sort meta.
multisortmeta	any	Multiple sort meta.
sortMeta	SortMeta	Sort meta.

TreeTableColResizeEvent #

Custom column resize event.

name	type	description
element	HTMLElement	Instance of resized column.
delta	number	Position.

TreeTableNodeSelectEvent #

Custom node select event.

name	type	description
checked	boolean
label	string	Label of the node.
data	any	Data represented by the node.
icon	string	Icon of the node to display next to content.
expandedIcon	string	Icon to use in expanded state.
collapsedIcon	string	Icon to use in collapsed state.
children	TreeNode<any>[]	An array of treenodes as children.
leaf	boolean	Specifies if the node has children. Used in lazy loading.
expanded	boolean	Expanded state of the node.
parent	TreeNode<any>	Parent of the node.
partialSelected	boolean	Defines if value is partially selected.
style	any	Inline style of the node.
styleClass	string	Style class of the node.
draggable	boolean	Defines if the node is draggable.
droppable	boolean	Defines if the node is droppable.
selectable	boolean	Whether the node is selectable when selection mode is enabled.
key	string	Mandatory unique key of the node.
loading	boolean	Defines if the node is loading.
originalEvent	Event	Browser event.
rowNode	any	Row of the node.
node	TreeNode<any>	Node instance.
type	string	Selection type.
index	number	Node index.
level	number	Node level.
visible	boolean	Boolean value indicates if node is in viewport.

TreeTableNodeUnSelectEvent #

Custom node unselect event.

name	type	description
originalEvent	Event	Browser event.
node	TreeTableNode<any>	Node instance.
type	string	Selection type.

TreeTableContextMenuSelectEvent #

Custom context menu select event.

name	type	description
originalEvent	Event	Browser event.
node	TreeTableNode<any>	Node instance.

TreeTableHeaderCheckboxToggleEvent #

Custom checkbox toggle event.

name	type	description
originalEvent	Event	Browser event.
checked	boolean	Checked state.

TreeTableEditEvent #

Custom edit event.

name	type	description
field	string	Field to be edited.
data	string	New value.

Interfaces #

Defines the custom interfaces used by the module.

TreeTablePaginatorState #

Paginator state.

name	type	description
page	number	Current page.
first	number	Index of the first element.
rows	number	Row count.
pageCount	number	Page count.

TreeTableFilterOptions #

Filtering options.

name	type	description
filterField	string	Field to be filtered.
filterValue	any	Value to use when filtering.
filterConstraint	Function	Filter constraints.
isStrictMode	boolean	Boolean value that defines if strict mode enabled.

TreeTableNode #

Tree table node element.

name	type	description
checked	boolean
label	string	Label of the node.
data	any	Data represented by the node.
icon	string	Icon of the node to display next to content.
expandedIcon	string	Icon to use in expanded state.
collapsedIcon	string	Icon to use in collapsed state.
children	TreeNode<any>[]	An array of treenodes as children.
leaf	boolean	Specifies if the node has children. Used in lazy loading.
expanded	boolean	Expanded state of the node.
parent	TreeNode<any>	Parent of the node.
partialSelected	boolean	Defines if value is partially selected.
style	any	Inline style of the node.
styleClass	string	Style class of the node.
draggable	boolean	Defines if the node is draggable.
droppable	boolean	Defines if the node is droppable.
selectable	boolean	Whether the node is selectable when selection mode is enabled.
key	string	Mandatory unique key of the node.
loading	boolean	Defines if the node is loading.
originalEvent	Event	Browser event.
rowNode	any	Row of the node.
node	TreeNode<T>	Node instance.
type	string	Selection type.
index	number	Node index.
level	number	Node level.
visible	boolean	Boolean value indicates if node is in viewport.

TreeNode #

Represents a node in a tree data structure.

name	type	description
checked	boolean
label	string	Label of the node.
data	T	Data represented by the node.
icon	string	Icon of the node to display next to content.
expandedIcon	string	Icon to use in expanded state.
collapsedIcon	string	Icon to use in collapsed state.
children	TreeNode<T>[]	An array of treenodes as children.
leaf	boolean	Specifies if the node has children. Used in lazy loading.
expanded	boolean	Expanded state of the node.
type	string	Type of the node to match a template.
parent	TreeNode<T>	Parent of the node.
partialSelected	boolean	Defines if value is partially selected.
style	any	Inline style of the node.
styleClass	string	Style class of the node.
draggable	boolean	Defines if the node is draggable.
droppable	boolean	Defines if the node is droppable.
selectable	boolean	Whether the node is selectable when selection mode is enabled.
key	string	Mandatory unique key of the node.
loading	boolean	Defines if the node is loading.