Classe: TDataGrid  - X-Ref

TDataGrid class

TDataGrid represents a data bound and updatable grid control.

To populate data into the datagrid, sets its {@link setDataSource DataSource}
to a tabular data source and call {@link dataBind()}.
Each row of data will be represented by an item in the {@link getItems Items}
collection of the datagrid.

An item can be at one of three states: browsing, selected and edit.
The state determines how the item will be displayed. For example, if an item
is in edit state, it may be displayed as a table row with input text boxes
if the columns are of type {@link TBoundColumn}; and if in browsing state,
they are displayed as static text.

To change the state of an item, set {@link setEditItemIndex EditItemIndex}
or {@link setSelectedItemIndex SelectedItemIndex} property.

Each datagrid item has a {@link TDataGridItem::getItemType type}
which tells the position and state of the item in the datalist. An item in the header
of the repeater is of type Header. A body item may be of either
Item, AlternatingItem, SelectedItem or EditItem, depending whether the item
index is odd or even, whether it is being selected or edited.

A datagrid is specified with a list of columns. Each column specifies how the corresponding
table column will be displayed. For example, the header/footer text of that column,
the cells in that column, and so on. The following column types are currently
provided by the framework,
- {@link TBoundColumn}, associated with a specific field in datasource and displays the corresponding data.
- {@link TEditCommandColumn}, displaying edit/update/cancel command buttons
- {@link TButtonColumn}, displaying generic command buttons that may be bound to specific field in datasource.
- {@link THyperLinkColumn}, displaying a hyperlink that may be bound to specific field in datasource.
- {@link TCheckBoxColumn}, displaying a checkbox that may be bound to specific field in datasource.
- {@link TTemplateColumn}, displaying content based on templates.

There are three ways to specify columns for a datagrid.
<ul>
<li>Automatically generated based on data source.
By setting {@link setAutoGenerateColumns AutoGenerateColumns} to true,
a list of columns will be automatically generated based on the schema of the data source.
Each column corresponds to a column of the data.</li>
<li>Specified in template. For example,
<code>
<com:TDataGrid ...>
<com:TBoundColumn .../>
<com:TEditCommandColumn .../>
</com:TDataGrid>
</code>
</li>
<li>Manually created in code. Columns can be manipulated via
the {@link setColumns Columns} property of the datagrid. For example,
<code>
$column=new TBoundColumn;
$datagrid->Columns[]=$column;
</code>
</li>
</ul>
Note, automatically generated columns cannot be accessed via
the {@link getColumns Columns} property.

TDataGrid supports sorting. If the {@link setAllowSorting AllowSorting}
is set to true, a column with nonempty {@link setSortExpression SortExpression}
will have its header text displayed as a clickable link button.
Clicking on the link button will raise {@link onSortCommand OnSortCommand}
event. You can respond to this event, sort the data source according
to the event parameter, and then invoke {@link databind()} on the datagrid
to show to end users the sorted data.

TDataGrid supports paging. If the {@link setAllowPaging AllowPaging}
is set to true, a pager will be displayed on top and/or bottom of the table.
How the pager will be displayed is determined by the {@link getPagerStyle PagerStyle}
property. Clicking on a pager button will raise an {@link onPageIndexChanged OnPageIndexChanged}
event. You can respond to this event, specify the page to be displayed by
setting {@link setCurrentPageIndex CurrentPageIndex}</b> property,
and then invoke {@link databind()} on the datagrid to show to end users
a new page of data.

TDataGrid supports two kinds of paging. The first one is based on the number of data items in
datasource. The number of pages {@link getPageCount PageCount} is calculated based
the item number and the {@link setPageSize PageSize} property.
The datagrid will manage which section of the data source to be displayed
based on the {@link setCurrentPageIndex CurrentPageIndex} property.
The second approach calculates the page number based on the
{@link setVirtualItemCount VirtualItemCount} property and
the {@link setPageSize PageSize} property. The datagrid will always
display from the beginning of the datasource up to the number of
{@link setPageSize PageSize} data items. This approach is especially
useful when the datasource may contain too many data items to be managed by
the datagrid efficiently.

When the datagrid contains a button control that raises an {@link onCommand OnCommand}
event, the event will be bubbled up to the datagrid control.
If the event's command name is recognizable by the datagrid control,
a corresponding item event will be raised. The following item events will be
raised upon a specific command:
- OnEditCommand, if CommandName=edit
- OnCancelCommand, if CommandName=cancel
- OnSelectCommand, if CommandName=select
- OnDeleteCommand, if CommandName=delete
- OnUpdateCommand, if CommandName=update
- onPageIndexChanged, if CommandName=page
- OnSortCommand, if CommandName=sort
Note, an {@link onItemCommand OnItemCommand} event is raised in addition to
the above specific command events.

TDataGrid also raises an {@link onItemCreated OnItemCreated} event for
every newly created datagrid item. You can respond to this event to customize
the content or style of the newly created item.

Note, the data bound to the datagrid are reset to null after databinding.
There are several ways to access the data associated with a datagrid row:
- Access the data in {@link onItemDataBound OnItemDataBound} event
- Use {@link getDataKeys DataKeys} to obtain the data key associated with
the specified datagrid row and use the key to fetch the corresponding data
from some persistent storage such as DB.
- Save the data in viewstate and get it back during postbacks.

Classe: TDataGridItemEventParameter  - X-Ref

TDataGridItemEventParameter class

TDataGridItemEventParameter encapsulates the parameter data for
{@link TDataGrid::onItemCreated OnItemCreated} event of {@link TDataGrid} controls.
The {@link getItem Item} property indicates the datagrid item related with the event.

Classe: TDataGridPagerEventParameter  - X-Ref

TDataGridPagerEventParameter class

TDataGridPagerEventParameter encapsulates the parameter data for
{@link TDataGrid::onPagerCreated OnPagerCreated} event of {@link TDataGrid} controls.
The {@link getPager Pager} property indicates the datagrid pager related with the event.

Classe: TDataGridCommandEventParameter  - X-Ref

TDataGridCommandEventParameter class

TDataGridCommandEventParameter encapsulates the parameter data for
{@link TDataGrid::onItemCommand ItemCommand} event of {@link TDataGrid} controls.

The {@link getItem Item} property indicates the datagrid item related with the event.
The {@link getCommandSource CommandSource} refers to the control that originally
raises the Command event.

Classe: TDataGridSortCommandEventParameter  - X-Ref

TDataGridSortCommandEventParameter class

TDataGridSortCommandEventParameter encapsulates the parameter data for
{@link TDataGrid::onSortCommand SortCommand} event of {@link TDataGrid} controls.

The {@link getCommandSource CommandSource} property refers to the control
that originally raises the OnCommand event, while {@link getSortExpression SortExpression}
gives the sort expression carried with the sort command.

Classe: TDataGridPageChangedEventParameter  - X-Ref

TDataGridPageChangedEventParameter class

TDataGridPageChangedEventParameter encapsulates the parameter data for
{@link TDataGrid::onPageIndexChanged PageIndexChanged} event of {@link TDataGrid} controls.

The {@link getCommandSource CommandSource} property refers to the control
that originally raises the OnCommand event, while {@link getNewPageIndex NewPageIndex}
returns the new page index carried with the page command.

Classe: TDataGridItem  - X-Ref

TDataGridItem class

A TDataGridItem control represents an item in the {@link TDataGrid} control,
such as heading section, footer section, or a data item.
The index and data value of the item can be accessed via {@link getItemIndex ItemIndex}>
and {@link getDataItem DataItem} properties, respectively. The type of the item
is given by {@link getItemType ItemType} property. Property {@link getDataSourceIndex DataSourceIndex}
gives the index of the item from the bound data source.

Classe: TDataGridPager  - X-Ref

TDataGridPager class.

TDataGridPager represents a datagrid pager.

Classe: TDataGridItemCollection  - X-Ref

TDataGridItemCollection class.

TDataGridItemCollection represents a collection of data grid items.

Classe: TDataGridColumnCollection  - X-Ref

TDataGridColumnCollection class.

TDataGridColumnCollection represents a collection of data grid columns.

Classe: TDataGridPagerStyle  - X-Ref

TDataGridPagerStyle class.

TDataGridPagerStyle specifies the styles available for a datagrid pager.

Classe: TDataGridPagerMode  - X-Ref

TDataGridPagerMode class.
TDataGridPagerMode defines the enumerable type for the possible modes that a datagrid pager can take.

The following enumerable values are defined:
- NextPrev: pager buttons are displayed as next and previous pages
- Numeric: pager buttons are displayed as numeric page numbers

Classe: TDataGridPagerButtonType  - X-Ref

TDataGridPagerButtonType class.
TDataGridPagerButtonType defines the enumerable type for the possible types of datagrid pager buttons.

The following enumerable values are defined:
- LinkButton: link buttons
- PushButton: form submit buttons

Classe: TDataGridPagerPosition  - X-Ref

TDataGridPagerPosition class.
TDataGridPagerPosition defines the enumerable type for the possible positions that a datagrid pager can be located at.

The following enumerable values are defined:
- Bottom: pager appears only at the bottom of the data grid.
- Top: pager appears only at the top of the data grid.
- TopAndBottom: pager appears on both top and bottom of the data grid.