Components.ModelsTableServerPaginated Class
Table-component with pagination, sorting and filtering.
It should be used when pagination, filtering and sorting are done on the server-side. Otherwise models-table should be used.
This component extends the base models-table component. For the end user, it can be used (nearly) the same:
<ModelsTableServerPaginated @data={{data}} @columns={{columns}} />
Usage with block context:
<ModelsTableServerPaginated @data={{data}} @columns={{columns}} as |MT|>
<MT.GlobalFilter />
<MT.DataGroupBySelect />
<MT.ColumnsDropdown />
<MT.Table />
<MT.Footer />
</ModelsTable>
ModelsTableServerPaginated yields same components, actions and properties as a ModelsTable does. Check its docs for more info.
Check own docs for each component to get detailed info.
ModelsTableServerPaginated has a lot of options you may configure, but there are two required properties called data and columns. First one contains data-query:
model() {
return this.store.query('my-model', {});
}
It will then take this query and extend it with pagination, sorting and filtering information. All other query parameters added in will remain untouched. Everything else works exactly the same - global filters, column filters etc. still use the same properties to control them. A few things to notice:
- When using
filterWithSelectfor a column, you must usepredefinedFilterOptions, because the automatic loading of possible filter values cannot work here. - There is a new optional field
filteredByfor columns, which works much likesortedBy: if set, this field will be used as query parameter, otherwise it will use thepropertyName. - Sorting will not use multipleColumnSorting, it will only sort by one column.
- If you set
sortedBy: falseon a column, sorting will be disabled for this column.
There are a couple of things which can be configured to adapt to your API:
// The property on meta to load the pages count from.
metaPagesCountProperty: 'pagesCount',
// The property on meta to load the total item count from.
metaItemsCountProperty: 'itemsCount',
// The time to wait until new data is actually loaded.
// This can be tweaked to avoid making too many server requests.
debounceDataLoadTime: 500,
// The query parameters to use for server side filtering / querying.
filterQueryParameters: {
globalFilter: 'search',
sort: 'sort',
sortDirection: 'sortDirection',
page: 'page',
pageSize: 'pageSize'
},
This default configuration would try to get the total page count from model.get('meta.pagesCount') and the total item count from model.get('meta.itemsCount'), and would then go on to build the following query:
columns: [
{
propertyName: 'name',
filteredBy: 'model_name'
}
]
// after searching globally for "searchtexthere"
// and in the name column for "filterforname",
// and going to page 2,
// the following query would be built:
?page=2&pageSize=50&search=searchtexthere&sort=name&sortDirection=ASC&model_name=filterforname
Item Index
Methods
- _checkColumnTitles
- _clearFilters
- _createColumn
- _createColumnInstance
- _loadData
- _multiColumnsSorting
- _postProcessColumn
- _sendColumnsVisibilityChangedAction
- _setupColumns
- _setupColumnsComponent
- _setupColumnsOnce
- _setupPageSizeOptions
- _setupSelectedRows
- _singleColumnSorting
- collapseRowOnNavigate
- doQuery
- filteredContentObserver
- filteredContentObserverOnce
- focus
- forceToFirstPage
- getCustomFilterTitle
- multipleColumnsSortingWrapper
- rebuildTable
- refilter
- setQueryFilter
- setup
- singleColumnSortingWrapper
- updateColumns
- updateHeaderCellsColspan
- updateHeaderCellsColspanOnce
- updateState
- userInteractionObserver
- userInteractionObserverOnce
- visibleContentObserver
- visibleContentObserverOnce
Properties
- allColumnsAreHidden
- anyFilterUsed
- arrangedContent
- arrangedContentLength
- checkTextTranslations
- collapsedGroupValues
- collapseNumPaginationForPagesCount
- columnComponents
- columnDropdownOptions
- columnFieldsToCheckUpdate
- columns
- columnsAreUpdateable
- columnSets
- currentGroupingPropertyName
- currentPageNumber
- currentPageNumberOptions
- data
- dataGroupOptions
- dataGroupProperties
- debounceDataLoadTime
- displayGroupedValueAs
- doFilteringByHiddenColumns
- expandedItems
- expandedRowComponent
- filteredContent
- filteringIgnoreCase
- filterQueryParameters
- filterString
- firstIndex
- focusGlobalFilter
- forceToFirstPageProps
- globalFilterUsed
- groupedArrangedContent
- groupedHeaders
- groupedVisibleContent
- groupedVisibleContentValuesOrder
- groupHeaderCellComponent
- groupingRowComponent
- groupSummaryRowComponent
- isError
- isLastPage
- isLoading
- isolated
- lastIndex
- metaItemsCountProperty
- metaPagesCountProperty
- multipleColumnsSorting
- multipleExpand
- multipleSelect
- noHeaderFilteringAndSorting
- observedProperties
- pagesCount
- pageSize
- pageSizeOptions
- pageSizeValues
- processedColumns
- publicAPI
- registerAPI
- selectedItems
- selectRowOnClick
- showColumnsDropdown
- showComponentFooter
- showCurrentPageNumberSelect
- showGlobalFilter
- showPageSize
- sortByGroupedFieldDirection
- sortFunctions
- sortMap
- sortProperties
- ThemeInstance
- useDataGrouping
- useFilteringByColumns
- useNumericPagination
- visibleContent
- visibleProcessedColumns
Events
- clearFilters
- clickOnRow
- collapseAllRows
- collapseRow
- columnsVisibilityChangedAction
- displayDataChangedAction
- doubleClickOnRow
- expandAllRows
- expandRow
- gotoCustomPage
- hideAllColumns
- hoverOnRow
- outRow
- restoreDefaultVisibility
- rowDoubleClickAction
- rowHoverAction
- rowOutAction
- showAllColumns
- sort
- toggleAllSelection
- toggleColumnSet
- toggleGroupedRows
- toggleGroupedRowsExpands
- toggleGroupedRowsSelection
- toggleHidden
Methods
_checkColumnTitles
()
protected
_clearFilters
()
protected
Clear all filters.
_createColumn
(
Utils.ModelsTableColumn
-
options
Create a column.
This can be overwritten if you need to use your own column object.
Override must something like:
Parameters:
-
optionsUtils.ModelsTableColumn
Returns:
Example:
_createColumn(options) {
const column = this._createColumnInstance(options);
setProperties(column, options);
return this._postProcessColumn(column);
}
_createColumnInstance
(
protected
-
options
Generate hash for column-
extend
Parameters:
-
optionsUtils.ModelsTableColumn
_loadData
()
private
This function actually loads the data from the server. It takes the store, modelName and query from the passed in data-object and adds page, sorting & filtering to it.
Returns:
Promise
_multiColumnsSorting
()
protected
Set
sortProperties when multi-columns sorting is used
_postProcessColumn
(
protected
-
column
Set values for some column-properties after its creation
Parameters:
-
columnUtils.ModelsTableColumn
Returns:
Utils.ModelsTableColumn
_sendColumnsVisibilityChangedAction
()
protected
Send
columnsVisibilityChangedAction-action when user changes which columns are visible.
Action is sent if columnsVisibilityChangedAction is a closure action
_setupColumns
()
private
Create new properties for
columns
_setupColumnsComponent
()
protected
Create new properties for
columns for components
_setupColumnsOnce
()
protected
Wrapper for [_setupColumns](Components.ModelsTable.html#method__setupColumns) to call it only once when observer is fired
_setupPageSizeOptions
()
protected
Provide backward compatibility with
pageSizeValues equal to an array with numbers and not objects
pageSizeValues is live as is, pageSizeOptions is used in the templates
_setupSelectedRows
()
protected
Preselect table rows if
selectedItems is provided
multipleSelected may be set true if selectedItems has more than 1 item
_singleColumnSorting
()
protected
Set
sortProperties when single-column sorting is used
doQuery
(
-
store -
modelName -
query
Do query-request to load new data
You may override this method to add some extra behavior or even additional requests
Returns:
Promise
filteredContentObserver
()
protected
filteredContentObserverOnce
()
protected
focus
()
protected
Focus on 'Global filter' on component render
forceToFirstPage
()
protected
Handler for global filter and filter by each column
getCustomFilterTitle
(
-
column
Customize filter title
Parameters:
-
columnObject
Returns:
string title
multipleColumnsSortingWrapper
(
-
query -
sortProperties
Wrapper for sorting query when multi columns sorting is used
Returns:
object query parameters
rebuildTable
()
protected
Rebuild the whole table.
This can be called to force a complete re-render of the table.
refilter
()
protected
setQueryFilter
(
-
query -
column -
filterTitle -
filter
Actually set the filter on a query. This can be overwritten for special case handling. Note that this will mutate the given query object!
setup
()
protected
Component init
Set visibility and filtering attributes for each column
singleColumnSortingWrapper
(
-
query -
sortBy -
sortDirection
Wrapper for sorting query when single column sorting is used
Returns:
object query parameters
updateColumns
()
protected
Recalculate processedColumns when the columns attr changes
updateHeaderCellsColspan
()
protected
Update colspans for table header cells
updateHeaderCellsColspanOnce
()
protected
userInteractionObserver
()
protected
Send
displayDataChangedAction-action when user does sort of filter.
Action is sent if displayDataChangedAction is a closure-action
userInteractionObserverOnce
()
protected
visibleContentObserver
()
protected
Show first page if for some reasons there is no content for current page, but table data exists
visibleContentObserverOnce
()
protected
Properties
allColumnsAreHidden
Boolean
protected
True if all processedColumns are hidden by
isHidden
Default: false
anyFilterUsed
Boolean
protected
true if global filter or filter by any column is used
Default: false
arrangedContent
Object[]
protected
For server side filtering, arrangedContent is same as the filtered content
arrangedContentLength
Number
protected
The total content length is get from the meta information. Set metaItemsCountProperty to change from which meta property this is loaded.
checkTextTranslations
Boolean
Value for development purposes. Used to check translation issues like:
* Auto generated titles for columns
Default: false
collapsedGroupValues
Array[]
List of grouped property values where the groups are collapsed
Default: []
collapseNumPaginationForPagesCount
Number
Used in numeric pagination. If pages count is less than
collapseNumPaginationForPagesCount, all pages will be shown.
E.g. for collapseNumPaginationForPagesCount = 4 and pagesCount = 4 pagination will be 1 2 3 4, however for
collapseNumPaginationForPagesCount = 1 and pagesCount = 4 pagination will be 1 2 ... 4
Default: 1
columnComponents
Object
Hash of components to be used for columns.
See [ModelsTableColumn](Utils.ModelsTableColumn.html), property component
Default: {}
columnDropdownOptions
Internal.ColumnDropdownOptions
protected
These are options for the columns dropdown.
By default, the 'Show All', 'Hide All' and 'Restore Defaults' buttons are displayed.
columnFieldsToCheckUpdate
String[]
columns fields which are observed to update shown table-columns
It is used only if columnsAreUpdateable is true
Default: ['propertyName', 'component']
columns
Utils.ModelsTableColumn[]
Table columns. Check [ModelsTableColumn](Utils.ModelsTableColumn.html) for available properties
It's a second of the two attributes you must set to the component
Default: []
columnsAreUpdateable
Boolean
Determines if
processedColumns will be updated if columns are changed (propertyName and template are observed)
**IMPORTANT** All filter, sort and visibility options will be dropped to the default values while updating
Default: false
columnSets
Internal.ColumnSet[]
Sets of columns that can be toggled together.
Each object should have:
*
label (string) - The label for the set. This will be displayed in the columns dropdown.
* showColumns (array|Function) - This should either be an array of propertyNames to show, or a function. If it is a function, the function will be called with the processedColumns as attribute.
* hideOtherColumns (boolean) - If this is true (default), all columns not specified in showColumns will be hidden. If this is set to false, other columns will be left at whatever visibility they were before.
* toggleSet (boolean) - If this is true (default is false), the set columns will be shown if one of them is currently hidden,
else they will all be hidden. Settings this will result in a default of hideOtherColumns=false
Default: []
currentGroupingPropertyName
String
Property name used now for grouping rows
**IMPORTANT** It should be set initially if [useDataGrouping](Components.ModelsTable.html#property_useDataGrouping) is set to
true
Default: null
currentPageNumberOptions
SelectOption
protected
List of options for pageNumber-selectBox
Default: []
data
Object[]
All table records
It's a first of the two attributes you must set to the component
Default: []
dataGroupProperties
String[] | Object[]
List of property names can be used for grouping
It may be a list of strings of list of objects. In first case label and value in the select-box will be the same.
In the second case you must set
label and value properties for each list item
**IMPORTANT** It must contain [currentGroupingPropertyName](Components.ModelsTable.html#property_currentGroupingPropertyName)-value
Default: []
debounceDataLoadTime
Number
The time to wait until new data is actually loaded. This can be tweaked to avoid making too many server requests.
Default: 500
displayGroupedValueAs
String
Determines how grouped value will be displayed - as a row or column
Allowed values are
row and column
Default: 'row'
doFilteringByHiddenColumns
Boolean
Determines if filtering should be done by hidden columns
**Notice:** after changing this value filtering results will be updated only after filter options are changed
Default: true
expandedItems
Object[]
Expanded row items.
It's set to the initial value when current page or page size is changed
Default: []
expandedRowComponent
Object
Component used in the 'expanded' row
It will receive several options:
*
record - current row value
* processedColumns - current column (one of the [processedColumns](Components.ModelsTable.html#property_processedColumns))
* index - current row index
* selectedItems - bound from [selectedItems](Components.ModelsTable.html#property_selectedItems)
* visibleProcessedColumns - bound from [visibleProcessedColumns](Components.ModelsTable.html#property_visibleProcessedColumns)
* clickOnRow - closure action [clickOnRow](Components.ModelsTable.html#event_clickOnRow)
* themeInstance - bound from [themeInstance](Components.ModelsTable.html#property_themeInstance)
Default: null
Example:
<ModelsTable
@data={{model}}
@columns={{columns}}
@expandedRowComponent={{component "expanded-row"}}
/>
filteredContent
Object[]
protected
This is set during didReceiveAttr and whenever the page/filters change.
Default: null
filteringIgnoreCase
Boolean
Determines if filtering (global and by column) should ignore case
Default: false
focusGlobalFilter
Boolean
Determines if focus should be on the 'Global filter'-field on component render
Default: false
forceToFirstPageProps
String[]
protected
Default: ['processedColumns.@each.filterString', 'filterString', 'pageSize']
groupedArrangedContent
Object[]
protected
[filteredContent](Components.ModelsTable.html#property_filteredContent) grouped by [currentGroupingPropertyName](Components.ModelsTable.html#property_currentGroupingPropertyName) sorted by needed properties
Default: []
groupedHeaders
Internal.GroupedHeader[]
List of the additional headers. Used to group columns.
Each object may have such fields:
*
title (string) - Header for grouped column
* colspan (number) - HTML colspan attr
* rowspan (number) - HTML rowspan attr
Default: []
groupedVisibleContent
Object[]
protected
Content of the current table page when rows grouping is used
[groupedVisibleContent](Components.ModelsTable.html#property_groupedVisibleContent) sliced for currently shown page
Default: []
groupedVisibleContentValuesOrder
Object[]
protected
List of grouped property values in order to show groups in the table
Default: []
groupHeaderCellComponent
Object
Component for header cell for column with grouping value
This component won't be used if [useDataGrouping](Components.ModelsTable.html#property_useDataGrouping) is not
true and [displayGroupedValueAs](Components.ModelsTable.html#property_displayGroupedValueAs) is not columns
Default: null
Example:
<ModelsTable
@data={{model}}
@columns={{columns}}
@groupHeaderCellComponent={{component "group-header-cell"}}
/>
Component will receive such options:
currentGroupingPropertyName- property name used to group rows in the current moment
groupingRowComponent
Object
Component used in the row with a grouped value
This component won't be used if [useDataGrouping](Components.ModelsTable.html#property_useDataGrouping) is not
true
Component will receive several options:
* groupedValue - grouped property value
* currentGroupingPropertyName - bound from [currentGroupingPropertyName](Components.ModelsTable.html#property_currentGroupingPropertyName)
* displayGroupedValueAs - bound from [displayGroupedValueAs](Components.ModelsTable.html#property_displayGroupedValueAs)
* toggleGroupedRows - closure action [toggleGroupedRows](Components.ModelsTable.html#event_toggleGroupedRows)
* toggleGroupedRowsExpands - closure action [toggleGroupedRowsExpands](Components.ModelsTable.html#event_toggleGroupedRowsExpands)
* toggleGroupedRowsSelection - closure action [toggleGroupedRowsSelection](Components.ModelsTable.html#event_toggleGroupedRowsSelection)
* visibleProcessedColumns - bound from [visibleProcessedColumns](Components.ModelsTable.html#event_visibleProcessedColumns)
* themeInstance - bound from [themeInstance](Components.ModelsTable.html#property_themeInstance)
* groupedItems - list of all rows group items
* visibleGroupedItems - list of rows group items shown on the current table page
* selectedGroupedItems - list of selected rows group items
* expandedGroupedItems - list of expanded rows group items
Default: null
Example:
<ModelsTable
@data={{model}}
@columns={{columns}}
@groupingRowComponent={{component "grouping-row"}}
/>
groupSummaryRowComponent
Object
This component won't be used if [useDataGrouping](Compnents.ModelsTable.html#property_useDataGrouping) is not
true
Component will receive several options:
* visibleProcessedColumns - bound from [visibleProcessedColumns](Components.ModelsTable.html#property_visibleProcessedColumns)
* themeInstance - bound from [themeInstance](Components.ModelsTable.html#property_themeInstance)
* groupedItems - list of all rows group items
* visibleGroupedItems - list of rows group items shown on the current table page
* selectedGroupedItems - list of selected rows group items
* expandedGroupedItems - list of expanded rows group items
Default: null
Example:
<ModelsTable
@data={{model}}
@columns={{columns}}
@groupSummaryRowComponent={{component "group-summary-row"}}
/>
isError
Boolean
protected
True if last data query promise has been rejected. Can be used in the template to e.g. indicate stale data or to e.g. show error state.
Default: false
isLoading
Boolean
protected
True if data is currently being loaded from the server. Can be used in the template to e.g. display a loading spinner.
Default: false
isolated
Boolean
Flag to determine if component should bubble inner
click action handler
It's useful when models-table is used inside the row-expand
Default: false
metaItemsCountProperty
String
The property on meta to load the total item count from.
Default: 'itemsCount'
metaPagesCountProperty
String
The property on meta to load the pages count from.
Default: 'pagesCount'
multipleExpand
Boolean
true - allow to expand more than 1 row,
false - only 1 row may be expanded in the same time
Default: false
multipleSelect
Boolean
Allow or disallow to select multiple rows.
If
false - only one row may be selected in the same time
Default: false
noHeaderFilteringAndSorting
Boolean
protected
true if all processedColumns don't use filtering and sorting
Default: false
observedProperties
String[]
protected
Default: ['currentPageNumber', 'sortProperties.[]', 'pageSize', 'filterString', 'processedColumns.@each.filterString']
pagesCount
Number
protected
The pages count is get from the meta information. Set metaPagesCountProperty to change from which meta property this is loaded.
pageSizeOptions
SelectOption
protected
List of options for pageSize-selectBox
It's mapped from [pageSizeValues](Components.ModelsTable.html#property_pageSizeValues)
This value should not be set manually!
Default: []
pageSizeValues
Number[]
List of possible [pageSize](Components.ModelsTable.html#property_pageSize) values. Used to change size of
visibleContent
Default: [10, 25, 50]
processedColumns
Utils.ModelsTableColumn[]
protected
List of columns shown in the table. It's created from the [columns](Components.ModelsTable.html#property_columns) provided to the component
Default: []
publicAPI
Unknown
Public API that allows for programmatic interaction with the component
*
refilter() - Invalidates the filteredContent property, causing the table to be re-filtered.
* recordsCount - Size of the current arranged content
Default: null
selectedItems
Object[]
List of currently selected row items
Row may be selected by clicking on it, if [selectRowOnClick](Components.ModelsTable.html#event_selectRowOnClick) is set to
true
Default: []
selectRowOnClick
Boolean
Allow or disallow to select rows on click.
If
false - no row can be selected
Default: true
showCurrentPageNumberSelect
Boolean
Determines if dropdown for current page number should be shown near the pagination block
Default: true
sortByGroupedFieldDirection
String
protected
Sort direction for grouped property values
Default: 'asc'
sortMap
Internal.SortMap
Order of sorting for each columns. Unsorted column firstly become sorted ASC, then DESC, then sorting is dropped again
sortProperties
Unknown
protected
List of properties to sort table rows
Each value is like 'propertyName:sortDirection'
ThemeInstance
Themes.Bootstrap3Theme
themeInstance is an instance of [DefaultTheme](Themes.Default.html) or it's children.
By default models-table uses [BootstrapTheme](Themes.Bootstrap3.html) instance.
You may create your own theme-class and set themeInstance to it's instance. Check Theme properties you may define in your own theme.
useDataGrouping
Boolean
Determines if rows should be grouped for some property
Grouped value may be shown in the separated row on the top of the group or in the first column (in the cell with rowspan) in the each group (see [displayGroupedValueAs](Components.ModelsTable.html#property_displayGroupedValueAs))
Generally you should not show column with property which is used for grouping (but it's up to you)
Default: false
useFilteringByColumns
Boolean
Determines if filtering by columns should be available to the user
Default: true
visibleContent
Object[]
protected
For server side filtering, visibleContent is same as the filtered content
Events
clearFilters
protected
Clear all column filters and global filter
May trigger sending [displayDataChangedAction](Components.ModelsTable.html#event_displayDataChangedAction)
clickOnRow
protected
Handler for row-click
Toggle
selected-state for row. Select only one or multiple rows depends on [multipleSelect](Components.ModelsTable.html#property_multipleSelect) value. May trigger sending [displayDataChangedAction](Components.ModelsTable.html#event_displayDataChangedAction)
collapseAllRows
protected
Collapse all rows in the current page
May trigger sending [displayDataChangedAction](Components.ModelsTable.html#event_displayDataChangedAction)
collapseRow
protected
Collapse selected row
May trigger sending [displayDataChangedAction](Components.ModelsTable.html#event_displayDataChangedAction)
columnsVisibilityChangedAction
Closure action sent on change of visible columns
The action will receive an array of objects as parameter, where every object looks like this:
{ propertyName: 'firstName', isHidden: true, mayBeHidden: false }
Example:
<ModelsTable
@data={{model}}
@columns={{columns}}
@columnsVisibilityChangedAction={{action "someAction"}}
/>
displayDataChangedAction
Closure action sent on user interaction
Action will send one parameter - object with fields:
*
sort - list with sort value propertyName:sortDirection
* currentPageNumber - currently shown page number
* pageSize - current page size
* filterString - global filter value
* filteredContent - filtered data
* selectedItems - list with selected row items
* expandedItems - list with expanded row items
* columnFilters - hash with fields equal to filtered propertyName and values equal to filter values
Example:
<ModelsTable
@data={{model}}
@columns={{columns}}
@displayDataChangedAction={{action "someAction"}}
/>
doubleClickOnRow
protected
Handler for double-click on row
May trigger sending [rowDoubleClickAction](Components.ModelsTable.html#event_rowDoubleClickAction)
expandAllRows
protected
Expand all rows in the current page
It works only if [multipleExpand](Components.ModelsTable.html#property_multipleExpand) is set to
true. May trigger sending [displayDataChangedAction](Components.ModelsTable.html#event_displayDataChangedAction)
expandRow
protected
Expand selected row
It will cause expandedRowComponent to be used for it. It will collapse already expanded row if [multipleExpand](Components.ModelsTable.html#property_multipleExpand) is set to
false. Expanding is assigned to the record itself and not their index. So, if page #1 has first row expanded and user is moved to any another page, first row on new page won't be expanded. But when user will be back to the first page, first row will be expanded. May trigger sending [displayDataChangedAction](Components.ModelsTable.html#event_displayDataChangedAction)
gotoCustomPage
protected
Pagination click-handler
It moves user to the selected page. Check [models-table/pagination-numeric](Components.ModelsTablePaginationNumeric.html) and [models-table/pagination-simple](Components.ModelsTablePaginationSimple.html) for usage examples. May trigger sending [displayDataChangedAction](Components.ModelsTable.html#event_displayDataChangedAction)
Event Payload:
-
pageNumberNumber
hideAllColumns
protected
Hide all columns that may be hidden (see [mayBeHidden](Utils.ModelsTableColumn.html#property_mayBeHidden))
May trigger sending [columnsVisibilityChangedAction](Components.ModelsTable.html#event_columnsVisibilityChangedAction)
hoverOnRow
protected
Handler for row-hover
May trigger sending [rowHoverAction](Components.ModelsTable.html#event_rowHoverAction)
outRow
protected
Handler for row-hover
May trigger sending [rowOutAction](Components.ModelsTable.html#event_rowOutAction)
restoreDefaultVisibility
protected
Restore columns visibility values according to their default visibility settings (see [defaultVisible](Utils.ModelsTableColumn.html#property_defaultVisible))
May trigger sending [columnsVisibilityChangedAction](Components.MdoelsTableColumn.html#event_columnsVisibilityChangedAction)
rowDoubleClickAction
Closure action sent on row double-click
Example:
<ModelsTable
@data={{model}}
@columns={{columns}}
@rowDoubleClickAction={{action "someAction"}}
/>
rowHoverAction
Closure action sent on row hover
Example:
<ModelsTable
@data={{model}}
@columns={{columns}}
@rowHoverAction={{action "someAction"}}
/>
rowOutAction
Closure action sent on row out
Example:
<ModelsTable
@data={{model}}
@columns={{columns}}
@rowOutAction={{action "someAction"}}
/>
showAllColumns
protected
Show all columns
Set each column
isHidden value to false. May trigger sending [columnsVisibilityChangedAction](Components.ModelsTable.html#event_columnsVisibilityChangedAction)
toggleAllSelection
protected
Select/deselect all rows
May trigger sending [displayDataChangedAction](Components.ModelsTable.html#event_displayDataChangedAction)
toggleColumnSet
protected
Toggle visibility for every column in the selected columns set
It ignore columns that can't be hidden (see [mayBeHidden](Utils.ModelsTableColumn.html#property_mayBeHidden)). May trigger sending [columnsVisibilityChangedAction](Components.ModelsTable.html#event_columnsVisibilityChangedAction)
Event Payload:
-
columnSetToToggleInternal.ColumnSet
toggleGroupedRows
protected
Collapse or expand rows group
toggleGroupedRowsExpands
protected
Expand or collapse all rows in the rows group
**IMPORTANT**
multipleExpand should be set to true otherwise this action won't do anything
toggleGroupedRowsSelection
protected
Select/deselect rows from the rows group
**IMPORTANT**
multipleSelect should be set to true otherwise this action won't do anything
May trigger sending [displayDataChangedAction](Components.ModelsTable.html#event_displayDataChangedAction)
toggleHidden
protected
Toggle visibility for provided column
It doesn't do nothing if column can't be hidden (see [mayBeHidden](Utils.ModelsTableColumn.html#property_mayBeHidden)). May trigger sending [columnsVisibilityChangedAction](Components.ModelsTable.html#event_columnsVisibilityChangedAction)
Event Payload:
-
columnUtils.ModelsTableColumn