Class GanttEvents<TValue>
Configures gantt events.
Inheritance
Namespace: Syncfusion.Blazor.Gantt
Assembly: Syncfusion.Blazor.dll
Syntax
public class GanttEvents<TValue> : ComponentBase
Type Parameters
Name | Description |
---|---|
TValue | Specifies the type of GanttEvents. |
Constructors
GanttEvents()
Declaration
public GanttEvents()
Properties
BeforeCopy
Declaration
public EventCallback<BeforeCopyEventArgs> BeforeCopy { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<BeforeCopyEventArgs> | An event callback function. |
Remarks
This event triggers before BeforeCopy event, so you can cancel copy operation by using this event. Also, this event handler receives a BeforeCopyEventArgs object which provides the details of before copy action.
Examples
<SfGantt>
<GanttEvents BeforeCopy=”BeforeCopyHandler”></GanttEvents>
</SfGantt>
@Code {
private void BeforeCopyHandler (Syncfusion.Blazor.Gantt.BeforeCopyEventArgs args){
…
}
}
BeforeTooltipRender
An event that is raised every time before the tooltip appears in Gantt Chart.
Declaration
public EventCallback<BeforeTooltipRenderEventArgs<TValue>> BeforeTooltipRender { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<BeforeTooltipRenderEventArgs<TValue>> | An event callback function. |
Remarks
An event is raised before a tooltip is displayed.And that event handler receives a BeforeTooltipRenderEventArgs<TValue> object which provides the details of the target element. Rendering tooltip can be cancelled using Cancel argument property.
Examples
<SfGantt TValue="TaskData">
<GanttEvents BeforeTooltipRender="BeforeTooltipRenderHandler"></GanttEvents>
</SfGantt>
@code{
private void BeforeTooltipRenderHandler(BeforeTooltipRenderEventArgs<TaskData> args)
{
}
}
CellDeselected
An event that is raised when the selected cell is deselected.
Declaration
public EventCallback<CellDeselectEventArgs<TValue>> CellDeselected { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<CellDeselectEventArgs<TValue>> | An event callback function. |
Remarks
This event handler receives a CellDeselectEventArgs<T> object that provides the details of the deselected cell.
Examples
<SfGantt>
<GanttEvents CellDeselected="CellDeselectedHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void CellDeselectedHandler(Syncfusion.Blazor.Grids.CellDeselectEventArgs<TaskData> args)
{
}
}
CellDeselecting
An event that is raised before a cell is deselected
Declaration
public EventCallback<CellDeselectEventArgs<TValue>> CellDeselecting { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<CellDeselectEventArgs<TValue>> | An event callback function. |
Remarks
This event handler receives a CellDeselectEventArgs<T> object which provides the details of the cell to be deselected.
Examples
<SfGantt TValue="TaskData">
<GanttEvents CellDeselecting="CellDeselectingHandler"></GanttEvents>
</SfGantt>
@code{
private void CellDeselectingHandler(Syncfusion.Blazor.Grids.CellDeselectEventArgs<TaskData> args)
{
}
}
CellSaved
An event that is triggered when a cell is saved.
Declaration
public EventCallback<CellSavedArgs<TValue>> CellSaved { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<CellSavedArgs<TValue>> | An event callback function. |
Remarks
This event handler receives a CellSavedArgs<T> object, which provides the details about the cell to be saved.
Examples
<SfGantt>
<GanttEvents CellSaved="CellSavedHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void CellSavedHandler (Syncfusion.Blazor.Grids.CellSavedArgs<TaskData> args)
{
}
}
CellSelected
An event is triggered when a cell is selected.
Declaration
public EventCallback<CellSelectEventArgs<TValue>> CellSelected { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<CellSelectEventArgs<TValue>> | An event callback function. |
Remarks
This event handler receives a CellSelectEventArgs<T> object which provides the details of the selected cell.
Examples
<SfGantt>
<GanttEvents CellSelected="CellSelectedHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void CellSelectedHandler(Syncfusion.Blazor.Grids.CellSelectEventArgs<TaskData> args)
{
}
}
CellSelecting
An event that is raised prior to a cell being selected.
Declaration
public EventCallback<CellSelectingEventArgs<TValue>> CellSelecting { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<CellSelectingEventArgs<TValue>> | An event callback function. |
Remarks
This event handler receives a CellSelectingEventArgs<T> object which provides information about cell to be selected. The Cell selection action can be cancelled using Cancel argument proprety.
Examples
<SfGantt>
<GanttEvents CellSelecting="CellSelectingHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void CellSelectingHandler(Syncfusion.Blazor.Grids.CellSelectingEventArgs<TaskData> args)
{
}
}
Collapsed
An event that is raised after the row is collapsed to hide its child rows.
Declaration
public EventCallback<RowCollapsedEventArgs<TValue>> Collapsed { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<RowCollapsedEventArgs<TValue>> | An event callback function. |
Remarks
This event handler receives a RowCollapsedEventArgs<T> object which provides the details of parent and child rows.
Examples
<SfGantt>
<GanttEvents Collapsed ="CollapseHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void CollapseHandler(Syncfusion.Blazor.TreeGrid.RowCollapsedEventArgs<TaskData> args)
{
}
}
Collapsing
An event that is raised a row begings collapsing to hide its child rows.
Declaration
public EventCallback<RowCollapsingEventArgs<TValue>> Collapsing { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<RowCollapsingEventArgs<TValue>> | An event callback function. |
Remarks
This event handler receives a RowCollapsingEventArgs<T> object which provides the details of parent and child rows. Row collapse action can be cancelled using Cancel argument property.
Examples
<SfGantt>
<GanttEvents Collapsing="CollapseHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void CollapseHandler(Syncfusion.Blazor.TreeGrid.RowCollapsingEventArgs<TaskData> args)
{
}
}
ColumnMenuClicked
An event that is raised when a column menu is clicked.
Declaration
public EventCallback<ColumnMenuClickEventArgs> ColumnMenuClicked { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<ColumnMenuClickEventArgs> | An event callback function. |
Remarks
This event handler receives a ColumnMenuClickEventArgs object which provides the details for the column menu item.
Examples
<SfGantt>
<GanttEvents ColumnMenuClicked="ColumnMenuClickedHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void ColumnMenuClickedHandler(Syncfusion.Blazor.Grids.ColumnMenuClickEventArgs args)
{
}
}
ColumnReordered
Gets or sets the event callback that is raised when columns are reordered in the Gantt Chart.
Declaration
public EventCallback<ColumnReorderedEventArgs> ColumnReordered { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<ColumnReorderedEventArgs> | An event callback function. |
Remarks
The event handler receives aColumnReorderedEventArgs object, which provides details about the columns reordered in the Gantt Chart.
Examples
This example shows how to handle the ColumnReordered event:
<SfGantt >
<GanttEvents TValue="Orders" ColumnReordered ="ColumnReorderedHandler"></GanttEvents>
........
</SfGantt>
@code{
public async Task ColumnReorderedHandler(ColumnReorderedEventArgs args)
{
var toColumn = args.ToColumn; // To get the to columns list
}
ColumnReordering
Gets or sets the event callback that is raised when columns reordering action is performed in the Gantt Chart.
Declaration
public EventCallback<ColumnReorderingEventArgs> ColumnReordering { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<ColumnReorderingEventArgs> | An event callback function. |
Remarks
The event handler receives a ColumnReorderingEventArgs object, which provides details about the columns reordering action in the Gantt Chart.
Examples
This example shows how to handle the ColumnReordering event:
<SfGantt>
<GanttEvents TValue="Orders" ColumnReordering ="ColumnReorderingHandler"></GanttEvents>
........
</SfGantt>
@code{
public async Task ColumnReorderingHandler(ColumnReorderingEventArgs args)
{
var fromColumn = args.FromColumn; // To get the from columns list
}
ColumnResized
An event that is raised when a grid column resize action ends.
Declaration
public EventCallback<ResizeArgs> ColumnResized { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<ResizeArgs> | An event callback function. |
Remarks
This event handler receives a ResizeArgs object which provides the details of the resized column.
Examples
<SfGantt>
<GanttEvents ColumnResized ="ColumnResizedHandler" TValue="TaskData" ></GanttEvents>
</ SfGantt >
@code{
private void ColumnResizedHandler(Syncfusion.Blazor.Grids.ResizeArgs args)
{
}
}
ColumnResizeStart
An event is raised when a grid column resizing.
Declaration
public EventCallback<ResizeArgs> ColumnResizeStart { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<ResizeArgs> | An event callback function. |
Remarks
This event handler receives a ResizeArgs object which provides the details of the resizing column.
Examples
<SfGantt>
<GanttEvents ColumnResizeStart ="ColumnResizeStartHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void ColumnResizeStartHandler(Syncfusion.Blazor.Grids.ResizeArgs args)
{
}
}
ContextMenuItemClicked
An event that is raised when a context menu items is clicked.
Declaration
public EventCallback<ContextMenuClickEventArgs<TValue>> ContextMenuItemClicked { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<ContextMenuClickEventArgs<TValue>> | An event callback function. |
Remarks
This event handler receives a ContextMenuClickEventArgs<T>object that contains information regarding the conetxt menu item. Custom actions for custom context menu items can be performed here.
Examples
<SfGantt>
<GanttEvents ContextMenuItemClicked="ContextMenuItemClickedHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void ContextMenuItemClickedHandler(Syncfusion.Blazor.Grids.ContextMenuClickEventArgs<TaskData> args)
{
}
}
ContextMenuOpen
An event that is raised before the context menu appears.
Declaration
public EventCallback<ContextMenuOpenEventArgs<TValue>> ContextMenuOpen { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<ContextMenuOpenEventArgs<TValue>> | An event callback function. |
Remarks
This event handler receives a ContextMenuOpenEventArgs<T> object which provides the details about the context menu.
Examples
<SfGantt>
<GanttEvents ContextMenuOpen="ContextMenuOpenHandler" TValue="TaskData"></GanttEvents>
</ SfGantt >
@code{
private void ContextMenuOpenHandler(Syncfusion.Blazor.Grids.ContextMenuOpenEventArgs<TaskData> args)
{
}
}
Created
An event that is raised when the Gantt component is generated.
Declaration
public EventCallback<object> Created { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<System.Object> | An event callback function. |
Remarks
An event that is raised when a Gantt componenet is created . And that event handler receives a System.Object object which provides the details of created component.
Examples
<SfGantt>
<GanttEvents Created="CreateHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void CreateHandler(System.Object args)
{
}
}
DataBound
An event that is raised when data source is populated on the Gantt Chart.
Declaration
public EventCallback DataBound { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback | An event callback function. |
Remarks
This event is raised after the data has been successfully bound to the control.Object which provides the Bounded data
Examples
<SfGantt @ref=”Gantt” DataSource=”GanttData”>
<GanttEditSettings AllowEditing = "true" ></GanttEditSettings>
<GanttEvents DataBound="DataBoundHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
SfGantt<TaskData> Gantt;
private void DataBoundHandler(){
…
}
}
Destroyed
An event that is raised when the component is destroyed.
Declaration
public EventCallback<object> Destroyed { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<System.Object> | An event callback function. |
Remarks
This event handler receives a System.Object object which provides the details when the component is detroyed.
Examples
<SfGantt>
<GanttEvents Destroyed = "DestroyHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void DestroyHandler(System.Object args)
{
}
}
EndEdit
An event that is raised when a task is updated with new data.
Declaration
public EventCallback<TaskbarEditedEventArgs<TValue>> EndEdit { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<TaskbarEditedEventArgs<TValue>> | An event callback function. |
Remarks
This event handler receives a TaskbarEditedEventArgs<T> object which provides the details aboud the updated task data.
Examples
<SfGantt>
<GanttEvents EndEdit="EndEditHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void EndEditHandler(TaskbarEditedEventArgs<TaskData> args)
{
}
}
Expanded
An event that is raised after a parent row is expanded to show is child rows.
Declaration
public EventCallback<RowExpandedEventArgs<TValue>> Expanded { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<RowExpandedEventArgs<TValue>> | An event callback function. |
Remarks
This event handler receives a RowExpandedEventArgs<T> object which provides the details of parent and child rows.
Examples
<SfGantt>
<GanttEvents Expanded="ExpandHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void ExpandHandler(Syncfusion.Blazor.TreeGrid.RowExpandedEventArgs<TaskData> args)
{
}
}
Expanding
An event that is raised when begin expanding a parent row to show its child rows.
Declaration
public EventCallback<RowExpandingEventArgs<TValue>> Expanding { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<RowExpandingEventArgs<TValue>> | An event callback function. |
Remarks
This event handler receives a RowExpandingEventArgs<T> object which provides the details of parent and child rows. Row expand action can be cancelled using Cancel argument property.
Examples
<SfGantt>
<GanttEvents Expanding="ExpandingHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void ExpandingHandler(Syncfusion.Blazor.TreeGrid.RowExpandingEventArgs<TaskData> args)
{
}
}
FilterDialogOpened
Gets or sets the event callback that is raised after the filter dialog is opened in the Gantt Chart.
Declaration
public EventCallback<FilterDialogOpenedEventArgs> FilterDialogOpened { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<FilterDialogOpenedEventArgs> | An event callback function. |
Remarks
The event handler receives aFilterDialogOpenedEventArgs object, which provides details about the filter dialog opened in the Gantt Chart.
Examples
This example shows how to handle the FilterDialogOpened event:
<SfGantt >
<GanttEvents TValue="Orders" FilterDialogOpened ="FilterDialogOpenedHandler"></GanttEvents>
........
</SfGantt>
@code{
public async Task FilterDialogOpenedHandler(FilterDialogOpenedEventArgs args)
{
}
FilterDialogOpening
Gets or sets the event callback that is raised before the filter dialog is opened in the Gantt Chart.
Declaration
public EventCallback<FilterDialogOpeningEventArgs> FilterDialogOpening { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<FilterDialogOpeningEventArgs> | An event callback function. |
Remarks
The event handler receives aFilterDialogOpeningEventArgs object, which provides details about the filter dialog opening in the Gantt Chart.
Examples
This example shows how to handle the FilterDialogOpening event:
<SfGantt>
<GanttEvents TValue="Orders" FilterDialogOpening ="FilterDialogOpeningHandler"></ GanttEvents>
........
</SfGantt>
@code{
public async Task FilterDialogOpeningHandler(FilterDialogOpeningEventArgs args)
{
args.Cancel = true; // To cancel the filter dialog opening action.
}
Filtered
Gets or sets the event callback that is raised after the filtered or clear filtered action is performed in the Gantt Chart.
Declaration
public EventCallback<FilteredEventArgs> Filtered { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<FilteredEventArgs> | An event callback function. |
Remarks
The event handler receives a FilteredEventArgs object,
which contains details about filtering or clearing the filtering action in the Gantt Chart.
This event is invoked once with Action
argument set to Reset
when calling the
ClearFilteringAsync() API without passing the column's field as a parameter. It notifies
the clear filtering action, and the event arguments will not be updated in this case. You can
prevent the clear filtering action using this event.
Examples
This example shows how to handle the Filtered event:
<SfGantt >
<GanttEvents TValue="Orders" Filtered ="FilteredHandler"></GanttEvents>
........
</SfGantt>
@code{
public async Task FilteredHandler(FilteredEventArgs args)
{
}
Filtering
Gets or sets the event callback that is raised before the filtering or clear filtering action is performed in the Gantt Chart.
Declaration
public EventCallback<FilteringEventArgs> Filtering { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<FilteringEventArgs> | An event callback function. |
Remarks
The event handler receives a FilteringEventArgs object,
which contains details about filtering or clearing the filtering action in the Gantt Chart.
This event is invoked once with Action
argument set to Reset
when calling the
ClearFilteringAsync() API without passing the column's field as a parameter. It notifies
the clear filtering action, and the event arguments will not be updated in this case. You can
prevent the clear filtering action using this event.
Conversely, this event is invoked for each field with Action
set to Remove
when
calling the ClearFilteringAsync
API with the column's field name as a parameter. In this
scenario, you can access detailed information in the corresponding event arguments.
Examples
This example shows how to handle the Filtering event:
<SfGantt>
<GanttEvents TValue="Orders" Filtering ="FilteringHandler"></ GanttEvents>
........
</ SfGantt>
@code{
public async Task FilteringHandler(FilteringEventArgs args)
{
}
GanttDialogOpened
Gets or sets the event callback that is raised after the dialog opened.
Declaration
public EventCallback<GanttDialogOpenedEventArgs<TValue>> GanttDialogOpened { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<GanttDialogOpenedEventArgs<TValue>> | An event callback function. |
Remarks
The event handler receives a GanttDialogOpenedEventArgs<TValue> object, which provides details about the edit or add action in the gantt chart.
Examples
<SfGantt>
<GanttEvents GanttDialogOpened=”DialogOpenedHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void DialogOpenedHandler(Syncfusion.Blazor.Gantt.GanttDialogOpenedEventArgs<TValue> args)
{
// Handle actions that should occur after the dialog has been opened.
}
}
GanttDialogOpening
Gets or sets the event callback that is raised before the dialog opens.
Declaration
public EventCallback<GanttDialogOpenEventArgs<TValue>> GanttDialogOpening { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<GanttDialogOpenEventArgs<TValue>> | An event callback function. |
Remarks
The event handler receives a GanttDialogOpenEventArgs<TValue> object, which provides details about the edit or add action in the gantt chart.
Examples
<SfGantt>
<GanttEvents GanttDialogOpening="GanttDialogOpeningHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void GanttDialogOpeningHandler(Syncfusion.Blazor.Gantt.GanttDialogOpenEventArgs<TValue> args)
{
args.Cancel = true; // To cancel the dialog open.
}
}
IndentationChanged
An event that is raised after indent or outdent action is performed in the Gantt Chart.
Declaration
public EventCallback<IndentationChangedEventArgs<TValue>> IndentationChanged { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<IndentationChangedEventArgs<TValue>> | An event callback function. |
Remarks
The event handler receives a IndentationChangedEventArgs<T> object, which provides details about the indent or outdent action performed in the Gantt Chart.
Examples
This example demonstrates how to handle the IndentationChanged event:
<SfGantt>
<GanttEvents TValue="TaskData" IndentationChanged=" IndentationChangedHandler "></GanttEvents>
........
</SfGantt>
@code{
public async Task IndentationChangedHandler(IndentationChangedEventArgs<TaskData> args)
{
}
}
IndentationChanging
An event that is raised before an indent or outdent action is performed in the Gantt Chart.
Declaration
public EventCallback<IndentationChangingEventArgs<TValue>> IndentationChanging { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<IndentationChangingEventArgs<TValue>> | An event callback function. |
Remarks
The event handler receives a IndentationChangingEventArgs<T> object, which provides details about the indent or outdent action performing in the Gantt Chart.
Based on the IsIndent
property of this event argument, the type of indentation (indent or outdent) can be determined.
Examples
This example demonstrates how to handle the IndentationChanging event:
<SfGantt @ref="Gantt" DataSource="GanttData">
<GanttEvents TValue="TaskData" IndentationChanging=" IndentationChangingHandler "></GanttEvents>
........
</SfGantt>
@code {
public async Task IndentationChangingHandler (IndentationChangingEventArgs<TaskData> args)
{
}
}
OnActionBegin
An event that is raised when Gantt actions such as sorting, filtering, searching etc., begins.
Declaration
public EventCallback<GanttActionEventArgs<TValue>> OnActionBegin { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<GanttActionEventArgs<TValue>> | An event callback function. |
Remarks
And that event handler receives a GanttActionEventArgs<TValue> object which provides the details about the current action to be performed in Gantt. Current action can be cancelled using Cancel argument property.
Examples
<SfGantt>
<GanttEvents OnActionBegin="OnActionBeginHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void OnActionBeginHandler(GanttActionEventArgs<TaskData> args)
{
}
}
OnActionComplete
An event that is raised when Gantt actions such as sorting, filtering, searching, etc. are completed.
Declaration
public EventCallback<GanttActionEventArgs<TValue>> OnActionComplete { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<GanttActionEventArgs<TValue>> | An event callback function. |
Remarks
An event is raised whenever the actions is triggered. And that event handler receives a GanttActionEventArgs<TValue> object which provides the details about the current action performed in Gantt.
Examples
<SfGantt>
<GanttEvents OnActionComplete="OnActionCompleteHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void OnActionCompleteHandler(GanttActionEventArgs<TaskData> args)
{
}
}
OnActionFailure
An event that is raised when any Gantt action failed to achieve the desired results.
Declaration
public EventCallback<FailureEventArgs> OnActionFailure { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<FailureEventArgs> | An event callback function. |
Remarks
This event handler receives a FailureEventArgs object which provides the details of action failure in Gantt Chart. Stack trace of exceptions, if any, can also be obtained here.
Examples
<SfGantt >
<GanttEvents OnActionFailure="OnActionFailureHandler" TValue="TaskData"></GanttEvents>
</SfGantt
@code{
private void OnActionFailureHandler(Syncfusion.Blazor.Grids.FailureEventArgs args)
{
}
}
OnCellEdit
An event that is raised when editing a cell.
Declaration
public EventCallback<CellEditArgs<TValue>> OnCellEdit { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<CellEditArgs<TValue>> | An event callback function. |
Remarks
The event handler will be called when the value of a cell is edited.And the event handler receives a CellEditArgs<T> object which provides the details of the cell to be edited. Cell edit action can be cancelled using Cancel argument property.
Examples
<SfGantt>
<GanttEvents OnCellEdit="OnCellEditHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void OnCellEditHandler(Syncfusion.Blazor.Grids.CellEditArgs<TValue> args)
{
}
}
OnCellSave
An event that occurs prior to the updating of a cell with new data.
Declaration
public EventCallback<CellSaveArgs<TValue>> OnCellSave { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<CellSaveArgs<TValue>> | An event callback function. |
Remarks
This event handler receives a CellSaveArgs<T> object which provides the details about the cell to be saved. To retrieve details about the modified record collection, you can refer to the GanttRowUpdatedEventArgs<T> event handler. Each record is represented as a dictionary of field names and corresponding values.
Examples
<SfGantt>
<GanttEvents OnCellSave="OnCellSaveHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void OnCellSaveHandler(Syncfusion.Blazor.Grids.CellSaveArgs<TaskData> args)
{
}
}
OnLoad
An event that is raised before the rendering of Gantt Component.
Declaration
public EventCallback<object> OnLoad { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<System.Object> | An event callback function. |
Remarks
This event handler receives a System.Object object which provides the details of the gantt before initial rendering.
Examples
<SfGantt>
<GanttEvents OnLoad="OnLoadHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void OnLoadHandler(System.Object args)
{
}
}
OnRowDragStart
Gets or sets the event callback that is raised when we start dragging the rows to perform a reorder.
Declaration
public EventCallback<RowDragEventArgs<TValue>> OnRowDragStart { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<RowDragEventArgs<TValue>> | An event callback function. |
Remarks
This event handler receives a RowDragEventArgs<T> object that shows information about the rows it is being dragged from.
Examples
<SfGantt>
<GanttEvents OnRowDragStart="OnRowDragStartHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void OnRowDragStartHandler(Syncfusion.Blazor.Grids.RowDragEventArgs<TaskData> args)
{
}
}
OnToolbarClick
An event that is raised when a toolbar item is clicked.
Declaration
public EventCallback<ClickEventArgs> OnToolbarClick { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<ClickEventArgs> | An event callback function. |
Remarks
This event handler receives a ClickEventArgs object which provides the details about the toolbar item. Custom actions for custom toolbar items can be performed using this event.
Examples
<SfGantt>
<GanttEvents OnToolbarClick="OnToolbarClickHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void OnToolbarClickHandler(Syncfusion.Blazor.Navigations.ClickEventArgs args)
{
}
}
Parent
Declaration
protected SfGantt<TValue> Parent { get; set; }
Property Value
Type |
---|
SfGantt<TValue> |
PdfColumnHeaderQueryCellInfo
Gets or sets an event callback that is raised whenever a Gantt's column header cell is being drawn into the Pdf document.
Declaration
public EventCallback<PdfHeaderQueryCellInfoEventArgs> PdfColumnHeaderQueryCellInfo { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<PdfHeaderQueryCellInfoEventArgs> | An event callback function. |
Remarks
The event handler receives a PdfHeaderQueryCellInfoEventArgs object, which provides details about the column header template information in the Gantt chart.
Examples
This example shows how to handle the PdfColumnHeaderQueryCellInfo event:
<SfGantt>
.........
<GanttEvents TValue="TaskData" PdfColumnHeaderQueryCellInfo="PdfColumnHeaderQueryCellInfoHandler"></GanttEvents>
</SfGantt>
@code {
private async Task PdfColumnHeaderQueryCellInfoHandler(PdfColumnHeaderQueryCellInfoEventArgs args)
{
// Handle the query for column header information
}
}
PdfExported
Gets or sets an event callback that is raised after the Gantt chart is exported to a PDF document. This event is triggered when the PDF exporting is completed in the Gantt chart.
Declaration
public EventCallback<PdfExportedEventArgs> PdfExported { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<PdfExportedEventArgs> | An event callback function. |
Remarks
The event handler receives a PdfExportedEventArgs, which provides details about the exported PDF document in the Gantt chart.
Examples
This example shows how to handle the PdfExported event:
<SfGantt>
.........
<GanttEvents PdfExported =" PdfExportedHandler"></GanttEvents>
</SfGantt>
@code {
private async Task PdfExportedHandler(PdfExportedEventArgs args)
{
// Handle actions that should occur after PDF export
}
}
PdfExporting
Gets or sets an event callback that is raised when beginning to export the gantt chart to a Pdf document.
Declaration
public EventCallback<PdfExportEventArgs> PdfExporting { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<PdfExportEventArgs> | An event callback function. |
Remarks
The event handler receives a PdfExportEventArgs, which provides details about the timeline range, and export information in the Gantt chart.
Examples
This example shows how to handle the PdfExporting event:
<SfGantt>
.........
<GanttEvents PdfExporting=" PdfExportingHandler "></GanttEvents>
</SfGantt>
@code {
private async Task PdfExportingHandler(PdfExportEventArgs args)
{
// Handle actions that should occur before PDF export
}
}
PdfQueryCellInfo
Gets or sets an event callback that is raised whenever a Gantt's grid row cell is being drawn into the PDF document.
Declaration
public EventCallback<PdfQueryCellInfoEventArgs<TValue>> PdfQueryCellInfo { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<PdfQueryCellInfoEventArgs<TValue>> | An event callback function. |
Remarks
The event handler receives a PdfQueryCellInfoEventArgs<TValue> object, which provides details about the cell template information in the Gantt chart.
Examples
This example shows how to handle the PdfQueryCellInfo event:
<SfGantt>
.........
<GanttEvents TValue="TaskData" PdfQueryCellInfo="PdfQueryCellInfoHandler"></GanttEvents>
</SfGantt>
@code {
private async Task PdfQueryCellInfoHandler(PdfQueryCellInfoEventArgs<TaskData> args)
{
// Handle the query for cell information
}
}
PdfQueryTaskbarInfo
Gets or sets an event callback that is raised when a taskbar is being drawn into the PDF document. This event is triggered when the user exports Gantt Chart to PDF.
Declaration
public EventCallback<PdfQueryTaskbarInfoEventArgs<TValue>> PdfQueryTaskbarInfo { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<PdfQueryTaskbarInfoEventArgs<TValue>> | An event callback function. |
Remarks
The event handler receives a PdfQueryTaskbarInfoEventArgs<TValue>, which provides details about the task information of a row in the Gantt chart.
Examples
This example shows how to handle the PdfQueryTaskbarInfo event:
<SfGantt>
.........
<GanttEvents TValue="TaskData" PdfQueryTaskbarInfo="PdfQueryTaskbarInfoHandler"></GanttEvents>
</SfGantt>
@code {
private async Task PdfQueryTaskbarInfoHandler(PdfQueryTaskbarInfoEventArgs<TaskData> args)
{
// Handle the query for taskbar template information
}
}
PdfQueryTimelineCellInfo
Gets or sets an event callback that is raised whenever a Gantt's timeline cell is being drawn into the Pdf document.
Declaration
public EventCallback<PdfQueryTimelineCellInfoEventArgs> PdfQueryTimelineCellInfo { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<PdfQueryTimelineCellInfoEventArgs> | An event callback function. |
Remarks
The event handler receives a PdfQueryTimelineCellInfoEventArgs object, which provides details about the timeline cell information in the Gantt chart.
Examples
This example shows how to handle the PdfQueryTimelineCellInfoEventArgs event:
<SfGantt>
.........
<GanttEvents TValue="TaskData" PdfQueryTimelineCellInfoEventArgs="PdfQueryTimelineCellInfoEventArgsHandler"></GanttEvents>
</SfGantt>
@code {
private async Task PdfQueryTimelineCellInfoEventArgsHandler(PdfQueryTimelineCellInfoEventArgs args)
{
// Handle the query for timeline cell information
}
}
QueryCellInfo
An event that is raised whenever a grid cell is rendered or refreshed in Gantt.
Declaration
public EventCallback<QueryCellInfoEventArgs<TValue>> QueryCellInfo { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<QueryCellInfoEventArgs<TValue>> | An event callback function. |
Remarks
This event handler receives a QueryCellInfoEventArgs<T> object which provides the details of the grid cell. Customizations for grid cell element can be performed here.
Examples
<SfGantt>
<GanttEvents QueryCellInfo="QueryCellInfoHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void QueryCellInfoHandler(Syncfusion.Blazor.Grids.QueryCellInfoEventArgs<TaskData> args)
{
}
}
QueryChartRowInfo
An event that is raised whenever a chart row is rendered or refreshed in Gantt.
Declaration
public EventCallback<QueryChartRowInfoEventArgs<TValue>> QueryChartRowInfo { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<QueryChartRowInfoEventArgs<TValue>> | An event callback function. |
Remarks
This event handler receives a QueryChartRowInfoEventArgs<TValue> object which provides the details about the chart row. Customizations for chart row element can be performed here.
Examples
<SfGantt>
<GanttEvents QueryChartRowInfo="QueryChartRowInfoHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void QueryChartRowInfoHandler(QueryChartRowInfoEventArgs<TValue> args)
{
}
}
RowCreated
Gets or sets the event callback that is raised after the add action is performed in the Gantt Chart.
Declaration
public EventCallback<GanttRowCreatedEventArgs<TValue>> RowCreated { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<GanttRowCreatedEventArgs<TValue>> | An event callback function. |
Remarks
The event handler receives a GanttRowCreatedEventArgs<T> object, which provide details about the add action in the Gantt Chart.
Examples
This example shows how to handle the RowCreated event:
<SfGantt >
<GanttEvents TValue="Orders" RowCreated ="RowCreatedHandler"></GanttEvents>
........
</SfGantt>
@code{
public async Task RowCreatedHandler (GanttRowCreatedEventArgs<Order> args)
{
var addedRecord = args.Data; // Gets the added record.
}
RowCreating
Gets or sets the event callback that is raised before the add action is performed in the Gantt Chart.
Declaration
public EventCallback<GanttRowCreatingEventArgs<TValue>> RowCreating { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<GanttRowCreatingEventArgs<TValue>> | An event callback function. |
Remarks
The event handler receives a GanttRowCreatingEventArgs<T> object, which provides details about the add action in the Gantt Chart.
Examples
This example shows how to handle the RowCreating event:
<SfGantt>
<GanttEvents TValue="Orders" RowCreating ="RowAddingHandler"></ GanttEvents>
........
</ SfGantt>
@code{
public async Task RowAddingHandler (GanttRowCreatingEventArgs<Order> args)
{
args.Cancel = true; // To cancel the add action.
}
RowDataBound
An event that is raised whenever a grid row is rendered or refreshed in Gantt.
Declaration
public EventCallback<RowDataBoundEventArgs<TValue>> RowDataBound { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<RowDataBoundEventArgs<TValue>> | An event callback function. |
Remarks
This event handler receives a RowDataBoundEventArgs<T> object which provides the details of the grid row. Customizations for grid row element can be performed here.
Examples
<SfGantt>
<GanttEvents RowDataBound="RowDataBoundHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void RowDataBoundHandler(Syncfusion.Blazor.Grids.RowDataBoundEventArgs<TaskData> args)
{
}
}
RowDeleted
Gets or sets the event callback that is raised after the delete action is performed in the Gantt Chart.
Declaration
public EventCallback<GanttRowDeletedEventArgs<TValue>> RowDeleted { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<GanttRowDeletedEventArgs<TValue>> | An event callback function. |
Remarks
The event handler receives a GanttRowDeletedEventArgs<T> object, which provides details about the delete action in the Gantt Chart.
Examples
This example shows how to handle the RowDeleted event:
<SfGantt >
<GanttEvents TValue="Orders" RowDeleted ="RowDeletedHandler"></GanttEvents>
........
</SfGantt>
@code{
public async Task RowDeletedHandler(GanttRowDeletedEventArgs<Order> args)
{
var rowIndex = args.Index; // Gets the row index of the deleted record.
}
RowDeleting
Gets or sets the event callback that is raised before the delete action is performed in the Gantt Chart.
Declaration
public EventCallback<GanttRowDeletingEventArgs<TValue>> RowDeleting { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<GanttRowDeletingEventArgs<TValue>> | An event callback function. |
Remarks
The event handler receives a GanttRowDeletingEventArgs<T> object,which provides details about the delete action in the Gantt Chart.
Examples
This example shows how to handle the RowDeleting event:
<SfGantt>
<GanttEvents TValue="Orders" RowDeleting ="RowDeletingHandler"></ GanttEvents >
........
</SfGantt>
@code{
public async Task RowDeletingHandler(GanttRowDeletingEventArgs<Order> args)
{
if(args.Data.OrderID == 10248) // To cancel the delete action for a specific record.
{
args.Cancel = true;
}
}
RowDeselected
An event that is raised when a selected row is deselected.
Declaration
public EventCallback<RowDeselectEventArgs<TValue>> RowDeselected { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<RowDeselectEventArgs<TValue>> | An event callback function. |
Remarks
This event handler receives a RowDeselectEventArgs<T> object which provides the details of the deselected row.
Examples
<SfGantt>
<GanttEvents RowDeselected="RowDeselectedHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void RowDeselectedHandler(Syncfusion.Blazor.Grids.RowDeselectEventArgs<TaskData> args)
{
}
}
RowDeselecting
An event that is raised before a row is deselected.
Declaration
public EventCallback<RowDeselectEventArgs<TValue>> RowDeselecting { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<RowDeselectEventArgs<TValue>> | An event callback function. |
Remarks
The RowDeselecting event occurs before a row is deselected. This event handler receives a RowDeselectEventArgs<T> object which provides the details of the row to be deselected.
Examples
<SfGantt>
<GanttEvents RowDeselecting="RowDeselectingHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void RowDeselectingHandler(Syncfusion.Blazor.Grids.RowDeselectEventArgs<TaskData> args)
{
}
}
RowDragStarting
Gets or sets the event callback that is raised when we start dragging the rows to perform a reorder.
Declaration
public EventCallback<RowDragStartingEventArgs<TValue>> RowDragStarting { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<RowDragStartingEventArgs<TValue>> | An event callback function. |
Remarks
This event handler receives a RowDragStartingEventArgs<T> object that shows information about the rows it is being dragged from.
Examples
<SfGantt>
<GanttEvents RowDragStarting="RowDragStartingHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void RowDragStartingHandler(Syncfusion.Blazor.Grids.RowDragStartingEventArgs<TaskData> args)
{
}
}
RowDropped
An event that is raised when the dragged row elements are dropped on a target row.
Declaration
public EventCallback<RowDroppedEventArgs<TValue>> RowDropped { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<RowDroppedEventArgs<TValue>> | An event callback function. |
Remarks
This event handler receives a RowDroppedEventArgs<T> object which provides the details of dragged and dropped target rows.
Examples
<SfGantt>
<GanttEvents RowDropped="RowDroppedHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void RowDroppedHandler(Syncfusion.Blazor.Grids.RowDroppedEventArgs<TaskData> args)
{
}
}
RowDropping
Gets or sets the event callback that is raised when the row of elements are dropping on target element. You can cancel the dropping action using this event.
Declaration
public EventCallback<RowDroppingEventArgs<TValue>> RowDropping { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<RowDroppingEventArgs<TValue>> | An event callback function. |
Remarks
This event handler receives a RowDroppingEventArgs<T> object which provides the details of the rows which are dropping and the target where the rows are dropping.
If the dropping action is prevented using the Cancel
argument, then the RowDropped event doesn't trigger.
Examples
<SfGantt>
<GanttEvents RowDropping="OnRowDroppingHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void RowDroppingHandler(RowDroppingEventArgs<BusinessObject> args)
{
//you can cancel the dropping action here
args.Cancel = true;
}
RowSelected
An event that is raised when a row is selected.
Declaration
public EventCallback<RowSelectEventArgs<TValue>> RowSelected { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<RowSelectEventArgs<TValue>> | An event callback function. |
Remarks
This event handler receives a RowSelectEventArgs<T> object which provides the details of the selected row.
Examples
<SfGantt>
<GanttEvents RowSelected="RowSelectedHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void RowSelectedHandler(Syncfusion.Blazor.Grids.RowSelectEventArgs<TaskData> args)
{
}
}
RowSelecting
An event that is raised before row selection occurs.
Declaration
public EventCallback<RowSelectingEventArgs<TValue>> RowSelecting { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<RowSelectingEventArgs<TValue>> | An event callback function. |
Remarks
An event is raised whenever the user is about to select a row. And that event handler receives a RowSelectingEventArgs<T> object which provides the details of the row to be selected. Row selection action can be cancelled using Cancel argument property.
Examples
<SfGantt>
<GanttEvents RowSelecting="RowSelectingHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void RowSelectingHandler(Syncfusion.Blazor.Grids.RowSelectingEventArgs<TaskData> args)
{
}
}
RowUpdated
Gets or sets the event callback that is raised after the save action is performed in the Gantt Chart.
Declaration
public EventCallback<GanttRowUpdatedEventArgs<TValue>> RowUpdated { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<GanttRowUpdatedEventArgs<TValue>> | An event callback function. |
Remarks
The event handler receives aGanttRowUpdatedEventArgs<T> object, which provides details about the save action in the Gantt Chart.
Examples
This example shows how to handle the RowUpdated event:
<SfGantt >
<GanttEvents TValue="Orders" RowUpdated ="RowUpdatedHandler"></GanttEvents>
........
</SfGantt>
@code{
public async Task RowUpdatedHandler (GanttRowUpdatedEventArgs<Order> args)
{
var rowIndex = args.Index; // Gets the row index of the saved record.
}
RowUpdating
Gets or sets the event callback that is raised before the save action is performed in the Gantt Chart.
Declaration
public EventCallback<GanttRowUpdatingEventArgs<TValue>> RowUpdating { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<GanttRowUpdatingEventArgs<TValue>> | An event callback function. |
Remarks
The event handler receives a GanttRowUpdatingEventArgs<T> object, which provides details about the save action in the Gantt Chart.
Examples
This example shows how to handle the RowUpdating event:
<SfGantt>
<GanttEvents TValue="Orders" RowUpdating ="RowUpdatingHandler"></ GanttEvents >
........
</SfGantt>
@code{
public async Task RowUpdatingHandler (GanttRowUpdatingEventArgs<Order> args)
{
args.Cancel = true; // To cancel the save action.
}
Searched
Gets or sets the event callback that is raised after the search action is performed in the Gantt Chart.
Declaration
public EventCallback<SearchedEventArgs> Searched { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<SearchedEventArgs> | An event callback function. |
Remarks
The event handler receives aSearchedEventArgs object, which provides details about the search action in the Gantt Chart.
Examples
This example shows how to handle the Searched event:
<SfGantt >
<GanttEvents TValue="Orders" Searched="SearchedHandler"></GanttEvents>
........
</SfGantt>
@code{
public async Task SearchedHandler (SearchedEventArgs args)
{
var searchResult = args.SearchString; // Gets the search result.
}
Searching
Gets or sets the event callback that is raised before the search action is performed in the Gantt Chart.
Declaration
public EventCallback<SearchingEventArgs> Searching { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<SearchingEventArgs> | An event callback function. |
Remarks
This event handler receives a SearchingEventArgs object, which provides details about the search action in the Gantt Chart.
Examples
This example shows how to handle the Searching event:
<SfGantt>
<GanttEvents TValue="Orders" Searching ="SearchingHandler"></GanttEvents>
........
</ SfGantt>
@code {
public async Task SearchingHandler (SearchingEventArgs args)
{
args.Cancel = true; // To cancel the search begin action.
}
Sorted
Gets or sets the event callback that is raised after sorting action is performed in the Gantt Chart.
Declaration
public EventCallback<SortedEventArgs> Sorted { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<SortedEventArgs> | An event callback function. |
Remarks
The event handler receives a SortedEventArgs object, which provides details about the sorting action in the Gantt Chart.
Examples
This example shows how to handle the Sorted event:
<SfGantt>
<GanttEvents TValue="Orders" Sorted="SortedHandler"></GanttEvents>
........
</SfGantt>
@code{
public async Task SortedHandler(SortedEventArgs args)
{
var direction = args.Direction; // Gets the current sorting direction.
}
Sorting
Gets or sets the event callback that is invoked before a sorting action is performed or a column is removed from sorting in the Gantt Chart or when the sort column direction changes from Ascending to Descending or vice versa for the same column.
Declaration
public EventCallback<SortingEventArgs> Sorting { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<SortingEventArgs> | An event callback function. |
Remarks
The event handler receives a SortingEventArgs object, which provides details about the sorting action or a column is removed from sorting in the Gantt Chart or when the sort column direction changes from Ascending
to Descending
or vice versa for the same column.
Examples
This example shows how to handle the Sorting event:
<SfGantt>
<GanttEvents TValue="Orders" Sorting="SortingHandler"></ GanttEvents>
........
</SfGantt>
@code{
public async Task SortingHandler(SortingEventArgs args)
{
args.Cancel = true; // To cancel the sorting action.
}
SplitterCreated
An event that is raised when a splitter is created in Gantt.
Declaration
public EventCallback<object> SplitterCreated { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<System.Object> | An event callback function. |
Remarks
This event handler receives a System.Object object which provides the details of splitter.
Examples
@using Syncfusion.Blazor.Gantt
<SfGantt>
<GanttEvents TValue="TaskData" SplitterCreated="SplitterCreatedHandler"></GanttEvents>
</SfGantt>
@code{
public void SplitterCreatedHandler(System.Object args)
{
Console.WriteLine("Callback for splitter created event");
}
}
SplitterResized
An event that is raised when the splitter is resized.
Declaration
public EventCallback<ResizingEventArgs> SplitterResized { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<ResizingEventArgs> | An event callback function. |
Remarks
This event handler receives a ResizingEventArgs object which provides the details of splitter resize action.
Examples
<SfGantt>
<GanttEvents SplitterResized="SplitterResizeHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void SplitterResizeHandler(Syncfusion.Blazor.Layouts.ResizingEventArgs args)
{
}
}
SplitterResizeStart
An event that is raised when the Splitter is started to be resized.
Declaration
public EventCallback<ResizeEventArgs> SplitterResizeStart { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<ResizeEventArgs> | An event callback function. |
Remarks
This event handler receives a ResizeEventArgs object which provides the details of resize action.
Examples
<SfGantt>
<GanttEvents SplitterResizeStart="SplitterResizeStartHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void SplitterResizeStartHandler(Syncfusion.Blazor.Layouts.ResizeEventArgs args)
{
}
}
SplitterResizing
An event that is raised when the splitter is resizing.
Declaration
public EventCallback<ResizingEventArgs> SplitterResizing { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<ResizingEventArgs> | An event callback function. |
Remarks
This event handler receives a ResizingEventArgs object which provides the details of splitter resize action.
Examples
<SfGantt>
<GanttEvents SplitterResizing="SplitterResizingHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void SplitterResizingHandler(Syncfusion.Blazor.Layouts.ResizingEventArgs args)
{
}
}
TaskbarEdited
An event that is raised when taskbar was dragged and dropped in a new position.
Declaration
public EventCallback<TaskbarEditedEventArgs<TValue>> TaskbarEdited { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<TaskbarEditedEventArgs<TValue>> | An event callback function. |
Remarks
This event handler receives a TaskbarEditedEventArgs<T> object which provides the details about the taskbar current position. To cancel the taskbar save action, you can use cancel argument property in event. To retrieve details about the modified record collection, you can refer to the GanttRowUpdatedEventArgs<T> event handler. Each record is represented as a dictionary of field names and corresponding values.
Examples
<SfGantt>
<GanttEvents TaskbarEdited="TaskbarEditHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void TaskbarEditHandler(TaskbarEditedEventArgs<TaskData> args)
{
}
}
TaskbarEditing
An event that is raised when the user starts editing the taskbar.
Declaration
public EventCallback<TaskbarEditingEventArgs<TValue>> TaskbarEditing { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<TaskbarEditingEventArgs<TValue>> | An event callback function. |
Remarks
An event is raised when the taskbar is being edited.And that event handler recevies a TaskbarEditingEventArgs<TValue> object which provides the taskbar editing information and an option to cancel the taskbar edit action.
Examples
<SfGantt DataSource = "@TaskCollection" Height="450px" Width="700px">
<GanttTaskFields Id = "TaskId" Name="TaskName" StartDate="StartDate" EndDate="EndDate" Duration="Duration" Progress="Progress" ParentID="ParentId" Dependency="Predecessor">
</GanttTaskFields>
<GanttEditSettings AllowTaskbarEditing = "true" ></ GanttEditSettings >
< GanttEvents TaskbarEditing="TaskbarEditingHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void TaskbarEditingHandler(TaskbarEditingEventArgs<TValue> args)
{
TaskData record = args.Data;
string actionName = args.Action;
args.Cancel = true;
}
}
TaskConnectorChanged
Gets or sets the event callback that is raised when a dependency connector line is drawn between two taskbar and connection is complete.
Declaration
public EventCallback<TaskConnectorChangedEventArgs<TValue>> TaskConnectorChanged { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<TaskConnectorChangedEventArgs<TValue>> | An event callback function. |
Remarks
The event handler receives a TaskConnectorChangedEventArgs<TValue> object, which provides details about the dependency connection for the tasks.
Examples
<SfGantt>
<GanttEvents TaskConnectorChanged =" ConnectorLineDrawCompletedHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void ConnectorLineDrawCompleted Handler(Syncfusion.Blazor.Gantt. TaskConnectorChangedEventArgs<TValue> args)
{
// Handle actions that should occur after a connector line has been successfully completed.
}
}
TaskConnectorChanging
Gets or sets an event callback that is raised when beginning to connect a taskbar to another.
Declaration
public EventCallback<TaskConnectorChangeEventArgs<TValue>> TaskConnectorChanging { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<TaskConnectorChangeEventArgs<TValue>> | An event callback function. |
Remarks
The event handler receives a TaskConnectorChangeEventArgs<TValue> object, which provides details about the taskbar and connector details.
Examples
<SfGantt>
<GanttEvents TaskConnectorChanging="ConnectorLineDrawHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void ConnectorLineDrawHandler (Syncfusion.Blazor.Gantt.TaskConnectorChangeEventArgs <TValue> args)
{
args.Cancel = true; // Cancel the connector line process.
}
}
Zoomed
Gets or sets an event callback that is raised after zoom action is performed.
Declaration
public EventCallback<ZoomedEventArgs> Zoomed { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<ZoomedEventArgs> | An event callback function. |
Remarks
The event handler receives a ZoomedEventArgs object, which provides details about the zoom action in the gantt chart.
Examples
<SfGantt>
<GanttEvents Zoomed="ZoomCompleteHandler"></GanttEvents>
</SfGantt>
@code{
private void ZoomCompleteHandler(Syncfusion.Blazor.Gantt.ZoomedEventArgs args)
{
// Handle actions that should occur after a zoom action has been completed.
}
}
Zooming
Gets or sets an event callback that is raised before zoom action is performed.
Declaration
public EventCallback<ZoomEventArgs> Zooming { get; set; }
Property Value
Type | Description |
---|---|
Microsoft.AspNetCore.Components.EventCallback<ZoomEventArgs> | An event callback function. |
Remarks
The event handler receives a ZoomEventArgs object, which provides details about the zoom action in the gantt chart.///
Examples
<SfGantt>
<GanttEvents Zooming="ZoomBeginHandler" TValue="TaskData"></GanttEvents>
</SfGantt>
@code{
private void ZoomBeginHandler(Syncfusion.Blazor.Gantt.ZoomEventArgs args)
{
args.Cancel = true; // To cancel the zoom action and not allow it to proceed.
}
}
Methods
OnInitializedAsync()
Declaration
protected override Task OnInitializedAsync()
Returns
Type |
---|
System.Threading.Tasks.Task |