Defaults to DataTableCfg. Type of the configuration object for this widget.
Creates a new instance of this widget. Please note that you should NOT override this constructor. Instead, override the init method, which is called at the end of the constructor once the instance is created.
The widget configuration to be used for this widget
instance. This widget configuration is usually created on the server by the javax.faces.render.Renderer for
this component.
Map between the sort order names and the multiplier for the comparator.
Whether all available items were already loaded.
Localized message for sorting a column in ascending order.
The DOM element for the body part of the table.
Cache for the contents of a row. Key is the row index, value the HTML content of the row.
Number of rows to cache.
The configuration of this widget instance. Please note that
no property is guaranteed to be present, you should always check for undefined before accessing a property.
This is partly because the value of a property is not transmitted from the server to the client when it equals
the default.
DOM element of the container with the check all checkbox in the header.
Clone of the table header.
Whether column widths are fixed or may be resized.
DOM element of the table cell for which the context menu was opened.
Widget with the context menu for the DataTable.
Current cell to be edited.
0-based index of row where the the cursor is located.
Localized message for sorting a column in descending order.
Array of registered listeners invoked when this widget is destroyed. You should normally not use modify this directly, use addDestroyListener instead.
DOM element of the icon that indicates a column is draggable.
DOM element of the icon that indicates a column is draggable.
DOM element of the hidden input that holds the row keys of the rows that are expanded. Used to preserve the expansion state during AJAX updates.
List of row indices to expand.
ID as returned by setTimeout used during filtering.
DOM element of the currently focused row.
Whether the focused row includes the checkbox for selecting the row.
The DOM elements for the footer columns.
The DOM elements for the footer table.
The DOM element for the header THEAD.
The DOM elements for the resizer button of each group.
Whether the table has any column groups.
The DOM elements for the header table.
DOM elements for the TH headers of this DataTable.
The client-side ID of this widget, with all parent naming containers, such as
myForm:myWidget. This is also the ID of the container HTML element for this widget. In case the widget needs
multiple container elements (such as Paginator), this may also be an array if IDs.
Whether to ignore row hover event.
Whether the writing direction is set to right-to-left.
Whether a row toggler was clicked.
The jQuery instance of the container element of this widget. In case id is an array, it will contain multiple elements. Please note that some widgets have got not DOM elements at all, in this case this will be an empty jQuery instance.
A CSS selector for the container element (or elements, in case id is an array) of
this widget, This is usually an ID selector (that is properly escaped). You can select the container element or
elements like this: $(widget.jqId).
Whether live scrolling is currently active.
List of row keys of the expansion rows that had their content already loaded via AJAX.
Whether data is currently being loaded due to the live scrolling feature.
Whether a mousedown event occurred on a row.
INPUT element storing the current column / row order.
The original row index of the row that was clicked.
Localized message for removing the sort order and showing rows in their original order.
When pagination is enabled: The paginator widget instance used for paging.
The current relative vertical scroll position.
The current relative horizontal scroll position.
true if reflow is enabled, false otherwise.
Array of registered listeners invoked when this widget is refreshed. You should normally not use modify this directly, use addRefreshListener instead.
The height of the table viewport, relative to the total height, used for scrolling.
A list with the current widths for each resizable column.
INPUT element storing the current widths for each resizable column.
The set-timeout timer ID of the timer used for resizing.
The DOM element for the resize helper.
Constant height in pixels for each row, when virtual scrolling is enabled.
The CSS selector for the table rows.
The CSS selector for the table rows that can be clicked.
The DOM element for the scrollable body of the table.
The DOM element for the scrollable body of the table.
The DOM element for the scrollable footer box of the table.
The DOM element for the scrollable header of the table.
The DOM element for the scrollable header box of the table.
The current scroll position.
INPUT element storing the current scroll position.
The DOM element for the scrollable TBODY.
The set-timeout timer ID of the timer used for scrolling.
CSS attribute for the scrollbar width, eg. 20px.
List of row keys for the currently selected rows.
ID of the INPUT element storing the currently selected rows.
Whether live scrolling is currently enabled.
Information about how each column is sorted. Key is the column key.
DOM elements for the columns that are sortable.
The DOM element for the sticky container of the table.
DOM element of the TBODY element of this DataTable, if it exists.
DOM element of the TFOOT element of this DataTable, if it exists.
DOM element of the THEAD element of this DataTable, if it exists.
The DOM element for the cloned table head.
Whether virtual scrolling is currently active.
The name of the widget variables of this widget. The widget variable can be used to
access a widget instance by calling PF('myWidgetVar').
This render method is called by this deferred widget once the widget container has become visible. You may now proceed with widget initialization.
Must be overridden, or an error will be thrown.
Adds a deferred rendering task for the given widget to the queue.
The ID of a deferred widget.
The container element that should be visible.
Callback that is invoked when the widget may possibly have become visible.
Should return true when the widget was rendered, or false when the widget still needs to be rendered
later.
Lets you register a listener that is called before the component is destroyed.
When an AJAX call is made and this component is updated, the DOM element is replaced with the newly rendered content. When the element is removed from the DOM by the update, the DOM element is detached from the DOM and all destroy listeners are called. This makes it possible to add listeners from outside the widget code.
If you call this method twice with the same listener, it will be registered twice and later also called twice.
Note that for this to work, you must not override the destroy method; or if you do, call super.
Also, after this widget was detached is done, all destroy listeners will be unregistered.
A destroy listener to be registered.
Adds and sets up an invisible row for internal purposes.
When an AJAX call is made and this component is updated, the DOM element is replaced with the newly rendered content. However, no new instance of the widget is created. Instead, after the DOM element was replaced, all refresh listeners are called. This makes it possible to add listeners from outside the widget code.
If you call this method twice with the same listener, it will be registered twice and later also called twice.
Note that for this to work, you must not override the refresh method; or if you do, call super.
Also, after the refresh is done, all refresh listeners will be deregistered. If you added the listeners from
within this widget, consider adding the refresh listeners not only in the init method, but also again in
the refresh method after calling super.
A refresh listener to be registered.
Adds the resizers for change the width of a column of this DataTable.
Fetches the last row from the backend and inserts a row instead of updating the table itself.
Adds given row to the list of selected rows.
Key of the row to add.
Adds the given sorting to the list of sort rows. Each sorting describes a column by which to sort. This data table may be sorted by multiple columns.
Sorting to add.
Adjusts the height of the body of this DataTable for the current scrolling settings.
Adjusts the width of the header, body, and footer of this DataTable to fit the current settings.
Adds some margin to the scroll body to make it align properly.
Applies the width information to the given element.
The element to which the width should be applied.
The width information (retrieved using the method getColumnWidthInfo).
Stores the row which is currently focused.
Row to set as the focused row.
Sets up the change event listeners on the column filter elements.
DOM element of a column filter
Sets up the event listeners for radio buttons contained in this DataTable.
Callback that is invoked when the context menu is initialized. Lets the context menu provider register the appropriate event listeners for when the context menu should be shown and hidden.
The widget instance of the context menu.
The widget instance of the target widget that wants to add a context menu.
ID selector or DOM element of the target, i.e. the element the context menu belongs to.
The current configuration of the context menu.
Binds editor events non-obtrusively.
Sets up the enter key event listeners for the text filters on a column.
INPUT element of the text filter.
Applies events related to row expansion in a non-obtrusive way
Sets up all event listeners for the given filter element of a column filter.
DOM element of a column filter.
Binds the change event listener and renders the paginator
Sets up the event listeners for radio buttons contained in this DataTable.
Sets up the event listeners for clicking on a row.
Sets up all event listeners for event triggered on a row of this DataTable.
Sets up the event listeners for hovering over a DataTable row.
Selector for the row elements. Any hover event that does not reach an element that matches this selector will be ignored.
Applies events related to selection in a non-obtrusive way
Sets up all delegated event listeners on the table body.
Applies events related to sorting in a non-obtrusive way
Sets up the event listeners for the text filters on a column.
INPUT element of the text filter.
Sets up the event handlers for row group events.
Computes the `colspan value for the table rows.
The computed colspan value.
Each widget may have one or several behaviors attached to it. This method calls all attached behaviors for the given event name. In case no such behavior exists, this method does nothing and returns immediately.
A behavior is a way for associating client-side scripts with UI components that opens all sorts of possibilities, including client-side validation, DOM and style manipulation, keyboard handling, and more. When the behavior is triggered, the configured JavaScript gets executed.
Behaviors are often, but not necessarily, AJAX behavior. When triggered, it initiates a request the server
and processes the response once it is received. This enables several features such as updating or replacing
elements dynamically. You can add an AJAX behavior via
<p:ajax event="name" actionListener="#{...}" onstart="..." />.
The name of an event to call.
Additional configuration that is passed to the AJAX request for the server-side callback.
When the given row is currently being edited, cancel the editing operation and discard the entered data. Use
findRow to get a row by its index.
A row (TR) in edit mode.
Initializes the given cell so that its content can be edited (when row editing is enabled)
A cell of this DataTable to set up.
Checks the select all checkbox in the header of this DataTable.
Clears all cached rows so that they are loaded from the server the next time they are requested.
Clears all table filters and shows all rows that may have been hidden by filters.
Clears the saved scrolling position.
Clears the saved list of selected rows.
Creates and stores a cloned copy of the table head(er) of this DataTable, and sets up some event handlers.
Clones a table header and removes duplicate IDs.
The head (THEAD) of the table to clone.
The table to which the head belongs.
The cloned table head.
Collapses all rows that are currently expanded.
Collapses the given row, if it is expandable. Use findRow to get a row by its index. Does not update the row
expansion toggler button.
Row to collapse.
Cleans up deferred render tasks. When you extend this class and override this method, make sure to call
super.
Disables the select all checkbox in the header of this DataTable.
Display the given HTML string in the specified row. Called mainly after an AJAX request.
Row to display.
HTML string of the content to add to the row
When the user wants to discard the edits to a cell, performs the required AJAX request for that.
The cell in edit mode with changes to discard.
When the users clicks on an editable cell, runs the AJAX request to show the inline editor for the given cell.
The cell to switch to edit mode.
Sends an AJAX request to handle row save or cancel
The current row editor.
Whether to save or cancel the row edit.
Enables the select all checkbox in the header of this DataTable.
Loads next page asynchronously to keep it at viewstate and Updates viewstate
The new values for the current page and the rows per page count.
Filters this DataTable. Uses the current values of the filter inputs. This will result in an AJAX request being sent.
Finds the saved width of the given column. The width of resizable columns may be saved to restore it after an AJAX update.
ID of a column
The saved width of the given column in pixels. undefined when the given column
does not exist.
Finds the group resizer element for the given drag event data.
Data for the drag event.
The resizer DOM element.
Converts a row specifier to the row element. The row specifier is either a row index or the row element itself.
In case this DataTable has got expandable rows, please not that a new table row is created for each expanded row. This may result in the given index not pointing to the intended row.
The row to convert.
The row, or an empty JQuery instance of no row was found.
Invokes the behaviors and event listeners when a column is resized.
Header of the column which was resized.
Calls the behaviors and event listeners when a row is collapsed.
A row of this DataTable.
Sends a row select event on server side to invoke a row select listener if defined.
The key of the row that was selected.
Name of the event to fire.
Optional callback function invoked when the menu was opened.
Sends a row unselect event on server side to invoke a row unselect listener if defined
The key of the row that was deselected.
Name of the event to fire.
Adjusts the width of the given columns to fit the current settings.
Each widget may have one or several behaviors attached to it. This method returns the callback function for the given event.
Note: Do not call the method directly, the recommended way to invoke a behavior is via callBehavior.
A behavior is a way for associating client-side scripts with UI components that opens all sorts of possibilities, including client-side validation, DOM and style manipulation, keyboard handling, and more. When the behavior is triggered, the configured JavaScript gets executed.
Behaviors are often, but not necessarily, AJAX behavior. When triggered, it initiates a request the server
and processes the response once it is received. This enables several features such as updating or replacing
elements dynamically. You can add an AJAX behavior via
<p:ajax event="name" actionListener="#{...}" onstart="..." />.
The name of an event for which to retrieve the behavior.
The behavior with the given name, or null if no such behavior
exists.
Finds the meta data for a given cell.
A cell for which to get the meta data.
The meta data of the given cell or NULL if not found
Retrieves width information of the given column.
The column of which the width should be retrieved.
Tells whether the width should be retrieved from the resizable state, if it exists.
The width information of the given column.
Finds the list of row that are currently expanded.
All rows (TR) that are currently expanded.
Finds the body of this DataTable with the property that the user can focus it.
The body of this DataTable.
Each widget has got a container element, this method returns that container. This container element is usually also the element whose ID is the client-side ID of the JSF component.
The jQuery instance representing the main HTML container element of this widget.
Returns the paginator instance if any exists.
The paginator instance for this widget, or undefined if
paging is not enabled.
Gets the closest parent form for this widget.
A JQuery instance that either contains the form when found, or an empty JQuery instance when the form could not be found.
Gets the closest parent form ID for this widget lazily so it can be used in AJAX requests.
Either the form ID or undefined if no form can be found.
Finds all editors of a row. Usually each editable column has got an editor.
A row for which to find its row editors.
A list of row editors for each editable column of the given row
Finds the index and the row key for the given row.
The element (TR) of a row of this DataTable.
The meta for the row with the index and the row key.
Finds the width of the current scrollbar used for this DataTable.
The width in pixels of the scrollbar of this DataTable.
Finds the number of rows that are selected.
The number of rows that are currently selected.
Creates the sort order message shown to indicate what the current sort order is.
Optional label text from an aria attribute.
Sort order message.
The sort order message to use.
Retrieves the table body of this DataTable.
DOM element of the table body.
Retrieves the table footer of this DataTable.
DOM element of the table footer.
Retrieves the table header of this DataTable.
DOM element of the table header.
Called by groupRows, this method performs the grouping of a single set of rows that belong to one row group.
Index of the column to group.
Rows to group into one row group.
When row grouping is enabled, groups all rows accordingly.
Each widget may have one or several behaviors attached to it. This method checks whether this widget has got at least one behavior associated with given event name.
A behavior is a way for associating client-side scripts with UI components that opens all sorts of possibilities, including client-side validation, DOM and style manipulation, keyboard handling, and more. When the behavior is triggered, the configured JavaScript gets executed.
Behaviors are often, but not necessarily, AJAX behavior. When triggered, it initiates a request the server
and processes the response once it is received. This enables several features such as updating or replacing
elements dynamically. You can add an AJAX behavior via
<p:ajax event="name" actionListener="#{...}" onstart="..." />.
The name of an event to check.
true if this widget has the given behavior, false otherwise.
Checks whether this DataTable has got any column groups.
true if this DataTable has got any column groups, or false otherwise.
Checks whether the body of this DataTable overflow vertically.
true if any content overflow vertically, false otherwise.
Highlights the currently focused row (if any) by adding the appropriate CSS class.
Highlights row to mark it as selected.
Row to highlight.
A widget class should not declare an explicit constructor, the default constructor provided by this base widget should be used. Instead, override this initialize method which is called after the widget instance was constructed. You can use this method to perform any initialization that is required. For widgets that need to create custom HTML on the client-side this is also the place where you should call your render method.
Please make sure to call the super method first before adding your own custom logic to the init method:
PrimeFaces.widget.MyWidget = PrimeFaces.widget.BaseWidget.extend({
init: function(cfg) {
this._super(cfg);
// custom initialization
}
});
The widget configuration to be used for this widget instance.
This widget configuration is usually created on the server by the javax.faces.render.Renderer for this
component.
Reflow mode is a responsive mode to display columns as stacked depending on screen size.
Initializes the expansion state
Displays row editors in invalid format.
0-based index of the row to invalidate.
Checks whether the rows of this DataTable are selected via checkboxes.
true if selection mode is set to checkbox, or false otherwise.
Checks if this widget is detached, ie whether the HTML element of this widget is currently contained within the DOM (the HTML body element). A widget may become detached during an AJAX update, and it may remain detached in case the update removed this component from the component tree.
true if this widget is currently detached, or false otherwise.
Checks whether this DataTable has got any rows. When there are no rows, usually the message no items found is
shown.
true if this DataTable has got no rows, false otherwise.
Checks whether multiples rows may be selected at a time.
true if selection mode is set to multiple, or false otherwise.
Checks whether the rows of this DataTable are selected via radio buttons.
true if selection mode is set to radio, or false otherwise.
Checks whether the given row is currently selected.
The key of a row from this DataTable.
true if the given row is currently selected, or false otherwise.
Checks whether the user may select the rows of this DataTable.
true is rows may be selected, or false otherwise.
Checks whether only one row may be selected at a time.
true if selection mode is set to single, or false otherwise.
Serializes the option from the sort meta items.
Property of the sort meta to use.
All values from the current sort meta list for the given option.
Performs the required initialization for making a row editable. Only called on-demand when the row actually needs to be edited.
A row of this DataTable.
Loads the data for the given page and displays it. When some rows exist in the cache, do not reload them from the server.
The new values for the current page and the rows per page count.
Loads the detailed content for the given expandable row.
A row with content to load.
Use only when live scrolling is enabled: Loads the next set of rows on-the-fly.
When live scrolling is enabled: Loads the next set of rows via AJAX.
0-based index of the page to load.
Callback that is invoked after the rows have been loaded and inserted into the DOM.
Makes the rows of this DataTable draggable via JQueryUI.
Callback for a click event on a row.
Click event that occurred.
Row that was clicked
true to prevent behaviors from being invoked, false otherwise.
Callback for a double click event on a row.
Event that occurred.
Row that was clicked.
Callback for a right click event on a row. May bring up the context menu
Event that occurred.
Row that was clicked.
The current selection mode.
Optional callback function invoked when the menu was opened.
true to hide the native browser context menu, false to display it
Switches to the given page by loading the content via AJAX. Compare with loadDataWithCache, which first checks
whether the data is already cached and loads it from the server only when not found in the cache.
The new values for the current page and the rows per page count.
Called after the widget has become visible and after it was rendered. May be overridden, the default implementation is a no-op.
Called after an AJAX update. Binds the appropriate event listeners again.
Removes the current clone of the table header from the DOM, and creates a new clone.
Used in ajax updates, reloads the widget configuration.
When an AJAX call is made and this component is updated, the DOM element is replaced with the newly rendered content. However, no new instance of the widget is created. Instead, after the DOM element was replaced, this method is called with the new widget configuration from the server. This makes it possible to persist client-side state during an update, such as the currently selected tab.
Please note that instead of overriding this method, you should consider adding a refresh listener instead via addRefreshListener. This has the advantage of letting you add multiple listeners, and makes it possible to add additional listeners from code outside this widget.
By default, this method calls all refresh listeners, then reinitializes the widget by calling the init
method.
The new widget configuration from the server.
The value as returned by the init method, which is often undefined.
Removes the widget's script block from the DOM. Currently, the ID of this script block consists of the
client-side ID of this widget with the prefix _s, but this is subject to change.
The client-side ID of the widget.
Remove given row from the list of selected rows.
Key of the row to remove.
This render method to check whether the widget container is visible. Do not override this method, or the deferred widget functionality may not work properly anymore.
true if the widget container is visible, false or
undefined otherwise.
Resets the scroll state of the body to a non-scrolled state.
Resizes this DataTable, row, or columns in response to a drag event of a resizer element.
Event triggered for the drag.
Data for the drag event.
Reads the saved scroll state and applies it. This helps to preserve the current scrolling position during AJAX updates.
After the user is done editing a cell, saves the content of the given cell and switches back to view mode.
A cell (TD) in edit mode.
Saves the current column order, used to preserve the state between AJAX updates etc.
When the given row is currently being edited, saves the contents of the edited row and switch back to view mode.
Use findRow to get a row by its index.
A row (TR) in edit mode to save.
Saves the current scrolling position. This helps to preserve the current scrolling position during AJAX updates.
Selects all rows of this DataTable so that no rows are selected. This includes all rows on all pages, irrespective of whether they are on the currently shown page.
Select all rows on the currently shown page. Compare with selectAllRows.
Selects the given checkbox from a row.
A checkbox to select.
Selects the given radio button from a row.
A radio button to select.
Selects the given row, according to the current selection mode.
A row of this DataTable to select.
true to prevent behaviors and event listeners from being invoked, or false
otherwise.
Selects the corresponding row of a checkbox based column selection
A checkox INPUT element
true to prevent behaviors from being invoked, false otherwise.
Selects the corresponding row of a radio based column selection
A radio INPUT element
Select the rows between the cursor and the given row.
A row of this DataTable.
Applies the appropriated width to all given column elements.
A list of column elements.
Applies the given width to this DataTable.
Element of the DataTable.
New width in pixels to set.
Applies the given scroll width to this DataTable.
Scroll width in pixels to set.
Sets up all event listeners required for making column draggable and reorderable.
Binds filter events to standard filters
Sets up the event listeners to enable columns to be resized.
Sets up the DataTable and adds all event listeners required for hovering over rows.
Prepares this DataTable for the current scrolling settings and sets up all related event handlers.
Sets up the DataTable and adds all event listener required for selecting rows.
Applies the styling and event listeners required for the sticky headers feature.
When live scrolling (loading more items on-demand) is enabled, checks whether more items are allowed to be loaded
right now. Returns false when live scroling is disabled or items are currently being loaded already.
true if more items may be loaded, false otherwise.
Called in response to a click. Checks whether this DataTable should now be sorted. Returns false when there
are no items to be sorted, or when no sorting button was clicked.
(Click) event that occurred.
Column Column of this DataTable on which the event occurred.
true to perform a sorting operation, false otherwise.
When cell editing is enabled, shows the cell editor for the given cell that lets the user edit the cell content.
A cell (TD) of this DataTable to edit.
Shows the cell editors for the given cell.
A cell of this DataTable.
Shows the row editor(s) for the given row (and hides the normal output display).
Row for which to show the row editor.
Performs a sorting operation on the rows of this DataTable via AJAX
Header of the column by which to sort.
-1 to sort column values in ascending order, +1 to sort column values in descending
order, or 0 to remove the sorting order and display rows in their original order.
true if sorting by multiple columns is enabled, or false otherwise.
Switch all editable columns of the given row to their editing mode, if editing is enabled on this DataTable.
Use findRow to get a row by its index.
A row (TR) to switch to edit mode.
Sets the style class on each, depending whether it is an even-numbered or odd-numbered row.
Moves to the next or previous editable cell when the tab key was pressed.
The currently focused cell
true if tabbing forward, false otherwise.
Toggles the selected all checkbox in the header of this DataTable. When no rows are selected, this will select
all rows. When some rows are selected, this will unselect all rows.
Expands a row to display its detailed content
The row toggler of a row to expand.
Expands or collapses the given row, depending on whether it is currently collapsed or expanded, respectively.
A row (TR) to expand or collapse.
Removes event listeners needed if refreshing to prevent multiple sort and pagination events.
Cancels all current drag and drop events.
Unchecks the select all checkbox in the header of this data table.
Unhighlights the currently focused row (if any) by adding the appropriate CSS class.
Removes the highlight of a row so it is no longer marked as selected.
Row to unhighlight.
Unselects all rows of this DataTable so that no rows are selected. This includes all rows on all pages, irrespective of whether they are on the currently shown page.
Unselect all rows on the currently shown page. Compare with unselectAllRows.
Unselects the given checkbox from a row.
A checkbox to unselect.
Unselects the given radio button from a row.
A radio button to unselect.
Unselects the given row.
A row of this DataTable to unselect.
true to prevent behaviors and event listeners from being invoked, or false
otherwise.
Unselects the corresponding row of a checkbox based column selection
A checkox INPUT element
true to prevent behaviors from being invoked, false otherwise.
Updates the colspan attribute of the given row.
A row to update.
The new colspan value. If not given, computes the value automatically.
Updates some style classes for all columns.
Updates the currently selected cell based on where the context menu right click occurred.
Event that occurred.
The current widget
Sets the given HTML string as the content of the body of this DataTable. Afterwards, sets up all required event listeners etc.
HTML string to set on the body.
Whether the contents of the table body should be removed beforehand.
Updates the colspan attribute for the message shown when no rows are available.
Updates the colspan attributes of all expanded rows.
Updates the check all checkbox in the header of this DataTable.
Updates and syncs the current pagination state with the server.
The new values for the current page and the rows per page count.
Reflow mode is a responsive mode to display columns as stacked depending on screen size. Updates the reflow for the given header.
Header of a column to update.
Sort order of the column.
Computes and saves the resizable state of this DataTable, ie. which columns have got which width. May be used later to restore the current column width after an AJAX update.
Element of a column header of this DataTable.
Element of the column header next to the given column header.
The element for this DataTable.
New width to be applied.
Width of the column next to the given column header.
Updates a row with the given content
Row to update.
HTML string to set on the row.
Updates the rowspan attribute of the given row.
A column to update.
In multi-sort mode this will add number indicators to let the user know the current sort order. If only one column is sorted then no indicator is displayed and will only be displayed once more than one column is sorted.
Switches the given cell to its view mode (not editable).
A cell of this DataTable.
Write row expansion state.
Writes selected row ids to state holder
Generated using TypeDoc
PrimeFaces DataTable Widget
DataTable displays data in tabular format.