projects/wms-framework/src/lib/models/controls/XamGridModel.ts
A class to represent grid cells
Properties |
Methods |
|
Accessors |
constructor(row?: RowBase, column?: XamGridColumnModel)
|
|||||||||
Creates an instance of XamGridCell.
Parameters :
|
_style |
Type : RuntimeStyleInfo
|
Default value : null
|
EditorStyleResolved |
Type : RuntimeStyleInfo
|
Default value : null
|
Determines if the editor style was resolved |
IsActive |
Default value : false
|
IsSelected |
Default value : false
|
key |
Type : string
|
Key for the cell |
Column |
Type : XamGridColumnModel
|
Default value : null
|
Inherited from
CellBase
|
Defined in
CellBase:70
|
Column of this cell |
Control |
Type : any
|
Default value : null
|
Inherited from
CellBase
|
Defined in
CellBase:35
|
Cell control |
Row |
Type : RowBase
|
Default value : null
|
Inherited from
CellBase
|
Defined in
CellBase:43
|
Cell row |
Private visibleIndex |
visibleIndex()
|
Returns the index of the cell in the grid when is visible in the viewport otherwise returns -1
Returns :
number
{number} |
Refresh |
Refresh()
|
Inherited from
CellBase
|
Defined in
CellBase:78
|
Refresh current cell
Returns :
void
|
gridComponent |
getgridComponent()
|
IsActive | ||||||
getIsActive()
|
||||||
Determines if this cell is active
Returns :
boolean
|
||||||
setIsActive(value: boolean)
|
||||||
Parameters :
Returns :
void
|
IsSelected | ||||||
getIsSelected()
|
||||||
Determines if this cell is selected |
||||||
setIsSelected(value: boolean)
|
||||||
Parameters :
Returns :
void
|
Style | ||||||
getStyle()
|
||||||
Cell style |
||||||
setStyle(val: RuntimeStyleInfo)
|
||||||
Parameters :
Returns :
void
|
Value |
getValue()
|
Cell value
Returns :
any
|
import {
DependencyObject,
INotifyPropertyChanged,
IValueConverter,
} from '../../basecomponentmodel';
import { Control } from '../../basecomponentmodel/Control';
import { Dependency } from '../../basecomponentmodel/Dependency';
import { DependencyProperty } from '../../basecomponentmodel/DependencyProperty';
import { DependencyPropertyChangedEventArgs } from '../../basecomponentmodel/DependencyPropertyChangedEventArgs';
import { RuntimeStyleInfo } from '../../basecomponentmodel/RuntimeStyleInfo';
import {
IPagedCollectionView,
iuAny,
iuFirstOrDefault,
ObservableCollection,
SimpleList,
} from '../../baseframework/collections';
import { ReflectionHelper } from '../../baseframework/ReflectionSupport';
import { Debugger } from '../../diagnostics/Debugger';
import { AngularComponentId } from '../../helpers/AngularComponentId';
import { transformStyles } from '../../utils/StyleFunctions';
import { SubscriptionEvent } from '../../utils/SubscriptionEvent';
import { XamSelectionMode } from '../enums/SelectionMode';
import { SortDirection } from '../enums/SortDirection';
import { RoutedEventArgs } from '../events/RoutedEventArgs';
import { ActiveCellChangingEventArgs } from './ActiveCellChangingEventArgs';
import { CancellableEventArgs } from './CancellableEventArgs';
import { CellAlignment } from './CellAlignment';
import { CellBase } from './CellBase';
import { ChildBandCell } from './ChildBandCell';
import { ColumnLayout } from './ColumnLayout';
import { ContentControlModel } from './ContentControlModel';
import { ColumnWidth } from './DataGridLengthModel';
import { FilterRow } from './FilterRow';
import { InvokeAction } from './InvokeAction';
import { RowBase } from './RowBase';
import { RowCollection } from './RowCollection';
import { RowsManager } from './RowsManager';
import { ThicknessModel } from './ThicknessModel';
import {
XamGridColumnModel,
XamGridGroupColumnModel,
} from './XamGridColumnModel';
import { XamGridRow } from './XamGridRow';
import { XamGridRowsManager } from './XamGridRowsManager';
/**
* Enumeration for specifying the kinds of overs
*
* @export
* @enum {number}
* @wEnum Infragistics.Controls.Grids.RowHoverType
*/
export enum RowHoverType {
Cell,
Row,
None,
}
/**
* Valid column types for XamGrid.
*
* @export
*/
export type XamGridColumnType = 'int' | 'decimal' | 'int?' | 'Nullable<int>';
/**
* Class that represents the Model of the XamGrid
*
* @export
* @class XamGridModel
* @extends {Control}
* @wType Infragistics.Controls.Grids.XamGrid
*/
export class XamGridModel extends Control {
/**
* Custom Mobilize property to access the XamGridComponent.
*
* @type {*}
* @memberof XamGridModel
*/
gridComponentInstance: any = null;
/**
* Flag to prevent clearing Active Cell when CollectionChnged is triggered.
*
* @memberof XamGridModel
* @wIgnore
*/
PreventClearActiveCell = false;
/**
* SelectedRowProperty dependency property.
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
* @wIgnore
*/
static SelectedRowProperty = new DependencyProperty(
'SelectedRow',
null,
null
);
/**
* ActiveItemProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static ActiveItemProperty: DependencyProperty = new DependencyProperty(
'ActiveItem',
null,
null
);
/**
* AutoGenerateColumnsProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static AutoGenerateColumnsProperty: DependencyProperty =
new DependencyProperty('AutoGenerateColumns', true, null);
/**
* CellControlGenerationModeProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static CellControlGenerationModeProperty: DependencyProperty =
new DependencyProperty('CellControlGenerationMode', null, null);
/**
* CellStyleProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static CellStyleProperty: DependencyProperty = new DependencyProperty(
'CellStyle',
null,
null
);
/**
* ChildBandHeaderHeightProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static ChildBandHeaderHeightProperty: DependencyProperty =
new DependencyProperty('ChildBandHeaderHeight', null, null);
/**
* ChildBandHeaderStyleProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static ChildBandHeaderStyleProperty: DependencyProperty =
new DependencyProperty('ChildBandHeaderStyle', null, null);
/**
* ColumnLayoutHeaderVisibilityProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static ColumnLayoutHeaderVisibilityProperty: DependencyProperty =
new DependencyProperty('ColumnLayoutHeaderVisibility', null, null);
/**
* ColumnsFooterTemplateProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static ColumnsFooterTemplateProperty: DependencyProperty =
new DependencyProperty('ColumnsFooterTemplate', null, null);
/**
* ColumnWidthProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static ColumnWidthProperty: DependencyProperty =
new DependencyProperty('ColumnWidth', ColumnWidth.InitialAuto, null);
/**
* DeleteKeyActionProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static DeleteKeyActionProperty: DependencyProperty =
new DependencyProperty('DeleteKeyAction', null, null);
/**
* FixedRowSeparatorStyleProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static FixedRowSeparatorStyleProperty: DependencyProperty =
new DependencyProperty('FixedRowSeparatorStyle', null, null);
/**
* FooterRowHeightProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static FooterRowHeightProperty: DependencyProperty =
new DependencyProperty('FooterRowHeight', null, null);
/**
* FooterStyleProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static FooterStyleProperty: DependencyProperty =
new DependencyProperty('FooterStyle', null, null);
/**
* FooterVisibilityProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static FooterVisibilityProperty: DependencyProperty =
new DependencyProperty('FooterVisibility', false, null);
/**
* HeaderRowHeightProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static HeaderRowHeightProperty: DependencyProperty =
new DependencyProperty('HeaderRowHeight', null, null);
/**
* HeaderStyleProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static HeaderStyleProperty: DependencyProperty =
new DependencyProperty(
'HeaderStyle',
null,
XamGridModel.TransformStyleCallback
);
/**
* HeaderTemplateProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static HeaderTemplateProperty: DependencyProperty =
new DependencyProperty('HeaderTemplate', null, null);
/**
* HeaderTextHorizontalAlignmentProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static HeaderTextHorizontalAlignmentProperty: DependencyProperty =
new DependencyProperty('HeaderTextHorizontalAlignment', null, null);
/**
* HeaderTextVerticalAlignmentProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static HeaderTextVerticalAlignmentProperty: DependencyProperty =
new DependencyProperty('HeaderTextVerticalAlignment', null, null);
/**
* HeaderVisibilityProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static HeaderVisibilityProperty: DependencyProperty =
new DependencyProperty('HeaderVisibility', null, null);
/**
* IndentationProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static IndentationProperty: DependencyProperty =
new DependencyProperty('Indentation', null, null);
/**
* IsAlternateRowsEnabledProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static IsAlternateRowsEnabledProperty: DependencyProperty =
new DependencyProperty('IsAlternateRowsEnabled', false, null);
/**
* IsTouchSupportEnabledProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static IsTouchSupportEnabledProperty: DependencyProperty =
new DependencyProperty('IsTouchSupportEnabled', null, null);
/**
* ItemsSourceProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static ItemsSourceProperty: DependencyProperty =
new DependencyProperty(
'ItemsSource',
null,
XamGridModel.itemsSourceCallback
);
/**
* KeyboardNavigationProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static KeyboardNavigationProperty: DependencyProperty =
new DependencyProperty('KeyboardNavigation', null, null);
/**
* MaxDepthProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static MaxDepthProperty: DependencyProperty = new DependencyProperty(
'MaxDepth',
null,
null
);
/**
* MinimumRowHeightProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static MinimumRowHeightProperty: DependencyProperty =
new DependencyProperty('MinimumRowHeight', null, null);
/**
* RowHeightProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static RowHeightProperty: DependencyProperty = new DependencyProperty(
'RowHeight',
null,
null
);
/**
* RowHoverProperty dependency property
*
* @static
* @type {DependencyProperty}
* @memberof XamGridModel
*/
public static RowHoverProperty: DependencyProperty = new DependencyProperty(
'RowHover',
RowHoverType.Cell,
null
);
private readonly _rowsManager: XamGridRowsManager;
/**
* Keeps the current edit cell
*
* @type {XamGridCell}
* @memberof XamGridModel
*/
public CurrentEditCell: XamGridCell;
/**
* Keeps the current edit row
*
* @type {XamGridRow}
* @memberof XamGridModel
*/
public CurrentEditRow: XamGridRow;
/**
* Sets the grid height to limit how many rows are rendered
* accepts null value, which will render all rows in the DOM with no scrollbar
*
* @type {string|null}
* @memberof XamGridModel
*/
virtualHeight: string | null = '100%';
/**
* Keeps the current active cell
*
* @private
* @type {CellBase}
* @memberof XamGridModel
*/
private _activeCell: CellBase;
/**
* Mobilize callback to set the ActiveCell when the igx-grid is rendered
*
* @type {*}
* @memberof XamGridModel
*/
contextActiveCell: () => void;
/**
* Internal property to keep the current Selection setting for the xamGrid
*
* @private
* @type {SelectionSettings}
* @memberof XamGridModel
*/
private _selectionSettings: SelectionSettings;
/**
* returns the rowsManager instance, which is responsible for managing the rows of the grid
* this is a custom property created by Mobilize team to access the rowsManager
* @readonly
* @protected
* @type {XamGridRowsManager}
* @memberof XamGridModel
*/
public get RowsManager(): XamGridRowsManager {
return this._rowsManager;
}
/**
* Triggers a special model change event when ItemsSource changes.
*
* @private
* @static
* @param {DependencyObject} sender
* @param {DependencyPropertyChangedEventArgs} args
* @memberof XamGridModel
*/
private static itemsSourceCallback(
sender: DependencyObject,
args: DependencyPropertyChangedEventArgs
) {
if (sender instanceof XamGridModel) {
sender.ItemsSourceAsPagedCollection = null;
if (
args.NewValue &&
ReflectionHelper.isInterfaceIsSupported(
args.NewValue,
'System.ComponentModel.IPagedCollectionView'
)
) {
sender.ItemsSourceAsPagedCollection = args.NewValue;
}
sender.ApplyItemSource(args.NewValue as Iterable<any>);
sender.change.fire(['ItemsSourceChanged', args]);
}
}
/**
* Applies the Item source
*
* @param {Iterable<any>} itemSource
* @memberof XamGridModel
* @wIgnore
*/
ApplyItemSource(itemSource: Iterable<any>) {
if (this._rowsManager.ItemsSource !== itemSource) {
this._rowsManager.ItemsSource = itemSource;
this.SortingSettings.SortedColumns?.clear();
}
}
/**
* Creates an instance of XamGridModel.
* @memberof XamGridModel
*/
constructor() {
super();
this._rowsManager = new XamGridRowsManager(this);
}
/**
* Notify this model of a data update.
*
* @memberof XamGridModel
* @wIgnore
*/
public NotifyDataUpdate(): void {
this.adjustColumnTypesBasedOnNewData();
this.change.fire(['DataUpdate']);
}
/**
* Adjust column DataType properties based on new data
*
* @private
* @static
* @param {DependencyPropertyChangedEventArgs} args
* @param {XamGridModel} sender
* @memberof XamGridModel
*/
public adjustColumnTypesBasedOnNewData(): void {
if (
!this.dataColumnInfoAdjusted &&
this.ItemsSource &&
this.Columns.count > 0 &&
this.ItemsSource[Symbol.iterator]
) {
const firstRow = iuFirstOrDefault(this.ItemsSource);
if (
firstRow &&
typeof firstRow === 'object' &&
firstRow.constructor !== Object
) {
const typeInfo = ReflectionHelper.getTypeInfo(firstRow);
for (const textColumn of this.Columns) {
if (textColumn.Key in firstRow) {
const propInfo = typeInfo.getProperty(textColumn.Key);
if (propInfo.propertyType?.JSType === Date) {
textColumn.DataType = 'date';
}
}
}
this.dataColumnInfoAdjusted = true;
}
}
}
public AngularComponentId = AngularComponentId.xamGrid;
/**
* Rendered subscription event
* @memberof XamGridModel
* @wIgnore
*/
Rendered = new SubscriptionEvent<(s: XamGridModel, e: any) => void>();
/**
* Loaded subscription event
* @memberof XamGridModel
* @wIgnore
*/
Loaded = new SubscriptionEvent<(s: XamGridModel, e: any) => void>();
/**
* Unloaded subscription event
* @memberof XamGridModel
* @wIgnore
*/
Unloaded = new SubscriptionEvent<(s: XamGridModel, e: any) => void>();
/**
* CellSelectionChanged subscription event
* @memberof XamGridModel
* @wIgnore
*/
CellSelectionChanged = new SubscriptionEvent<
(s: XamGridModel, e: any) => void
>();
/**
* RowSelectionChanged subscription event
* @memberof XamGridModel
* @wIgnore
*/
RowSelectionChanged = new SubscriptionEvent<
(s: XamGridModel, e: any) => void
>();
/**
* RowsCollectionChanged subscription event
* @memberof XamGridModel
* @wIgnore
*/
RowsCollectionChanged = new SubscriptionEvent<
(s: XamGridModel, e: any) => void
>();
/**
* ColumnSelectionChanged subscription event
* @memberof XamGridModel
* @wIgnore
*/
ColumnSelectionChanged = new SubscriptionEvent<
(s: XamGridModel, e: any) => void
>();
ColumnSorted = new SubscriptionEvent<(s: XamGridModel, e: any) => void>();
ColumnSorting = new SubscriptionEvent<(s: XamGridModel, e: any) => void>();
/**
* ColumnFiltered subscription event
* @memberof XamGridModel
* @wIgnore
*/
ColumnFiltered = new SubscriptionEvent<(s: XamGridModel, e: any) => void>();
ColumnResized = new SubscriptionEvent<(s: XamGridModel, e: any) => void>();
ColumnResizing = new SubscriptionEvent<(s: XamGridModel, e: any) => void>();
ColumnFixedStateChanged = new SubscriptionEvent<
(s: XamGridModel, e: any) => void
>();
CellClicked = new SubscriptionEvent<
(s: XamGridModel, e: CellClickedEventArgs) => void
>();
CellControlAttached = new SubscriptionEvent<
(s: XamGridModel, e: CellControlAttachedEventArgs) => void
>();
/**
* AfterCellControlAttached subscription event
* @memberof XamGridModel
* @wIgnore
*/
AfterCellControlAttached = new SubscriptionEvent<
(s: XamGridModel, e: CellControlAttachedEventArgs) => void
>();
CellDoubleClicked = new SubscriptionEvent<
(s: XamGridModel, e: any) => void
>();
/**
* KeyDown subscription event
* @memberof XamGridModel
* @wIgnore
*/
KeyDown = new SubscriptionEvent<(s: XamGridModel, e: any) => void>();
ActiveCellChanged = new SubscriptionEvent<
(s: XamGridModel, e: any) => void
>();
ActiveCellChanging = new SubscriptionEvent<
(s: XamGridModel, e: any) => void
>();
CellEnteredEditMode = new SubscriptionEvent<
(s: XamGridModel, e: EditingCellEventArgs) => void
>();
SelectedRowsCollectionChanged: SubscriptionEvent<any> =
new SubscriptionEvent<any>();
CellExitingEditMode = new SubscriptionEvent<
(s: XamGridModel, e: ExitEditingCellEventArgs) => void
>();
CellExitedEditMode = new SubscriptionEvent<
(s: XamGridModel, e: CellExitedEditingEventArgs) => void
>();
CellEnteringEditMode = new SubscriptionEvent<
(s: XamGridModel, e: BeginEditingCellEventArgs) => void
>();
/**
* CellEditing subscription event
* @memberof XamGridModel
* @wIgnore
*/
CellEditing = new SubscriptionEvent<
(s: XamGridModel, e: EditingCellEventArgs) => void
>();
/**
* CellEdited subscription event
* @memberof XamGridModel
* @wIgnore
*/
CellEdited = new SubscriptionEvent<
(s: XamGridModel, e: ExitEditingCellEventArgs) => void
>();
InitializeRow = new SubscriptionEvent<
(s: XamGridModel, e: InitializeRowEventArgs) => void
>();
PageIndexChanged = new SubscriptionEvent<
(s: XamGridModel, e: PageChangedEventArgs) => void
>();
PageIndexChanging = new SubscriptionEvent<
(s: XamGridModel, e: CancellablePageChangingEventArgs) => void
>();
RowAdded = new SubscriptionEvent<(s: XamGridModel, e: any) => void>();
RowDeleted = new SubscriptionEvent<(s: XamGridModel, e: any) => void>();
RowExitedEditMode = new SubscriptionEvent<
(s: XamGridModel, e: EditingRowEventArgs) => void
>();
RowEnteredEditMode = new SubscriptionEvent<
(s: XamGridModel, e: EditingRowEventArgs) => void
>();
/**
* ScrolledCellIntoView subscription event
* @memberof XamGridModel
* @wIgnore
*/
ScrolledCellIntoView: SubscriptionEvent<(cell: XamGridCell) => void> =
new SubscriptionEvent<(cell: XamGridCell) => void>();
isEditableOnAdd: boolean;
/**
* Flag to determine if the types of the column were adjusted based on new objects added to the items source
*
* @private
* @memberof XamGridRow
*/
private dataColumnInfoAdjusted = false;
/**
* Flag to manage when the editor template is loaded
*
* @type {boolean}
* @memberof XamGridComponent
*/
editorTemplateLoading = false;
/**
* Gets or sets the auto generate columns
*
* @memberof XamGridModel
*/
@Dependency(XamGridModel.AutoGenerateColumnsProperty)
AutoGenerateColumns: boolean;
/**
* Gets or sets the column width
*
* @memberof XamGridModel
*/
@Dependency(XamGridModel.ColumnWidthProperty)
ColumnWidth: ColumnWidth;
/**
* Gets or sets the IsAlternateRowsEnabled property
*
* @memberof XamGridModel
*/
@Dependency(XamGridModel.IsAlternateRowsEnabledProperty)
IsAlternateRowsEnabled: boolean;
FilteringSettings = new FilteringSettings();
/**
* Gets or sets the footer visibility
*
* @memberof XamGridModel
*/
@Dependency(XamGridModel.FooterVisibilityProperty)
FooterVisibility: boolean;
EditingSettings = new EditingSettings();
/**
* Gets or sets the header style
*
* @type {RuntimeStyleInfo}
* @memberof XamGridModel
*/
@Dependency(XamGridModel.HeaderStyleProperty)
HeaderStyle: RuntimeStyleInfo;
RowSelectorSettings = new RowSelectorSettings();
/**
* Gets or sets the row hover
*
* @memberof XamGridModel
*/
@Dependency(XamGridModel.RowHoverProperty)
RowHover: RowHoverType;
PagerSettings = new PagerSettings();
SortingSettings = new SortingSettings();
FixedColumnSettings = new FixedColumnSettings();
ColumnResizingSettings = new ColumnResizingSettings();
ColumnMovingSettings = new ColumnMovingSettings();
/**
* Gets or sets the selected column index
*
* @memberof XamGridModel
* @wIgnore
*/
SelectedColumnIndex: any;
BorderThickness: ThicknessModel = new ThicknessModel();
BorderBrush: any;
HeaderVisibility: any = 'visible';
/**
* headerStyleProperty css properties object used to apply
*
* @type {*}
* @memberof XamGridModel
* @wIgnore
*/
HeaderStylePropertyToApply: any = {};
/**
* Callback function to transform style object.
*
* @static
* @param {XamGridModel} sender
* @param {DependencyPropertyChangedEventArgs} args
* @memberof XamGridModel
* @wIgnore
*/
public static TransformStyleCallback(
sender: XamGridModel,
args: DependencyPropertyChangedEventArgs
) {
const xamGridModel: any = sender;
const newStyle = args.NewValue;
/* istanbul ignore else */
if (newStyle instanceof RuntimeStyleInfo) {
transformStyles(
xamGridModel.HeaderStylePropertyToApply,
newStyle.Setters
);
}
}
/**
* Gets the ActiveCell
*
* @type {CellBase}
* @memberof XamGridModel
*/
public get ActiveCell(): CellBase {
return this._activeCell;
}
/**
* Sets the ActiveCell
*
* @memberof XamGridModel
*/
public set ActiveCell(value: CellBase) {
this.SetActiveCell(
value,
CellAlignment.NotSet,
InvokeAction.Code,
true,
true,
true
);
/* istanbul ignore else */
if (this._activeCell == null) {
this.contextActiveCell = null;
return;
}
const isOnCellActiveEditingEnabled =
this.EditingSettings?.IsOnCellActiveEditingEnabled;
const isReadOnly = this._activeCell.Column.IsReadOnly;
this.contextActiveCell = () => {
this.gridComponentInstance.processActiveCell(
isOnCellActiveEditingEnabled,
isReadOnly
);
this.contextActiveCell = null;
};
setTimeout(() => {
/* istanbul ignore else */
if (
this.gridComponentInstance &&
!this.gridComponentInstance.callProcessActiveCellFlag
) {
this.gridComponentInstance.processActiveCell(
isOnCellActiveEditingEnabled,
isReadOnly
);
}
}, 200);
}
/**
* Set the active Cell for the xamGrid,
* trigger events for OnActiveCellChanging and OnActiveCellChanged
*
* @param {CellBase} cell
* @param {CellAlignment} alignment
* @param {InvokeAction} action
* @param {boolean} allowSelection
* @param {boolean} setFocus
* @param {boolean} scrollIntoView
* @return {*}
* @memberof XamGridModel
*/
SetActiveCell(
cell: CellBase,
alignment: CellAlignment,
action: InvokeAction,
allowSelection: boolean,
setFocus: boolean,
scrollIntoView: boolean
) {
if (cell != null) {
if (!cell.Column.Visibility) {
throw new Error('InvalidActiveCellException');
}
} else if (this.ActiveCell == null) {
return;
}
if (cell != null && this.ActiveCell == cell) {
if (cell.Control == null) {
return;
}
if (cell.Control.Content instanceof Control) {
cell.Control.Content.focus?.();
return;
}
}
if (scrollIntoView && cell != null && this.ActiveCell != cell && cell.Row) {
this.ScrollCellIntoView(cell);
}
this.isInEditMode(cell);
return this.ActiveLifeCycle(cell);
}
isInEditMode(cell: CellBase) {
// the next to if statements are to prevent the active cell when the grid is in editmode!
if (this.CurrentEditRow != null) {
if (cell != null && cell.Row != this.CurrentEditRow) {
this.ScrollCellIntoView(this.CurrentEditCell);
return;
}
} else if (this.CurrentEditCell != null) {
const currentEditCell = this.CurrentEditCell;
// if true, we need to scroll the cell into view
if (
currentEditCell.Row instanceof FilterRow &&
cell != null &&
!(cell.Row instanceof FilterRow) &&
currentEditCell.Row.RowsManager instanceof RowsManager
) {
const dataManager = currentEditCell.Row.RowsManager.DataManager;
if (dataManager != null) {
if (dataManager.FilterItems.Count == 0) {
return;
}
}
}
}
}
/**
* Run the active life cycle of the activeNode process
*
* @private
* @param {CellBase} cell
* @return {*}
* @memberof XamGridModel
*/
private ActiveLifeCycle(cell: CellBase) {
const cell2 = cell;
if (cell2 == null && !(cell instanceof ChildBandCell)) {
cell = null;
}
const activeCellChangingEventArgs = new ActiveCellChangingEventArgs();
activeCellChangingEventArgs.NewActiveCell = cell;
activeCellChangingEventArgs.PreviousActiveCell = this.ActiveCell;
const activeCellChangingEventArgs2 = activeCellChangingEventArgs;
this.OnActiveCellChanging(activeCellChangingEventArgs);
if (!activeCellChangingEventArgs2.Cancel) {
this._activeCell = cell;
this.OnActiveCellChanged();
}
return cell;
}
OnActiveCellChanged() {
this.ActiveCellChanged?.fire([this, {}]);
}
OnActiveCellChanging(e: ActiveCellChangingEventArgs) {
this.ActiveCellChanging?.fire([this, e]);
}
/**
* Flag to determine if the row should enter edit mode on add
*
* @memberof XamGridModel
* @wIgnore
*/
get IsEditableOnAdd(): boolean {
return this.isEditableOnAdd;
}
/**
* Sets the IsEditableOnAdd flag
* @memberof XamGridModel
* @wIgnore
*/
set IsEditableOnAdd(value: boolean) {
this.isEditableOnAdd = value;
}
/**
* Selected row property
* @memberof XamGridModel
* @wIgnore
*/
@Dependency(XamGridModel.SelectedRowProperty)
public SelectedRow: any;
/**
* Gets or sets the items source
*
* @type {*}
* @memberof XamGridModel
*/
public get ItemsSource(): Iterable<any> {
return this._rowsManager.ItemsSource;
}
public set ItemsSource(value: Iterable<any>) {
this.setValue(XamGridModel.ItemsSourceProperty, value);
}
/**
* SelectedIndex
*
* @type {*}
* @memberof XamGridModel
* @wIgnore
*/
SelectedIndex: any;
/**
* SelectedItems
*
* @type {ObservableCollection<any>}
* @memberof XamGridModel
* @wIgnore
*/
SelectedItems: ObservableCollection<any> = new ObservableCollection<any>();
/**
* SelectionSettings
*
* @memberof XamGridModel
*/
get SelectionSettings(): SelectionSettings {
if (this._selectionSettings == null) {
this._selectionSettings = new SelectionSettings(
this._rowsManager.ColumnLayout
);
}
this._selectionSettings.Grid = this;
return this._selectionSettings;
}
set SelectionSettings(value: SelectionSettings) {
if (value !== this._selectionSettings) {
this._selectionSettings = value;
}
}
/**
* Columns
*
* @memberof XamGridModel
*/
get Columns(): ColumnBaseCollection {
return this._rowsManager.ColumnLayout.Columns;
}
/**
* Rows
*
* @memberof XamGridModel
*/
get Rows(): RowCollection {
return this._rowsManager.Rows.ActualCollection as any;
}
/**
* addColumn
*
* @param {XamGridColumnModel} column
* @memberof XamGridModel
*/
public addColumn(column: XamGridColumnModel): void {
this.setColumnInfo(column);
this.Columns.add(column);
}
addVisualColumn(column: XamGridColumnModel): void {
this.setColumnInfo(column);
this.Columns.add(column);
}
/**
* Sets the ColumnLayout for the row
*
* @private
* @param {XamGridColumnModel} column
* @memberof XamGridModel
*/
private setColumnInfo(column: XamGridColumnModel) {
column.ColumnLayout = this._rowsManager.ColumnLayout;
column.Parent = this;
}
/**
* getColumns
*
* @return {*} {ColumnBaseCollection}
* @memberof XamGridModel
*/
public getColumns(): ColumnBaseCollection {
return this.Columns;
}
/**
* ScrollCellIntoView
*
* @param {*} cell
* @memberof XamGridModel
*/
public ScrollCellIntoView(cell: CellBase): void {
if (cell instanceof XamGridCell && cell.Row.Index !== -1) {
this.ScrolledCellIntoView.fire([cell]);
}
}
/**
* fire CellSelectionChangeHandler
*
* @param {*} event
* @memberof XamGridModel
* @wIgnore
*/
public CellSelectionChangeHandler(event: any): void {
this.CellSelectionChanged.fire([this, event]);
}
/**
* ScrollIntoView
*
* @param {...any[]} args
* @memberof XamGridModel
* @wIgnore
*/
public ScrollIntoView(...args: any[]): void {
Debugger.Throw('Not implemented');
}
/**
* Fire RowSelectionChangeHandler
*
* @param {*} event
* @memberof XamGridModel
* @wIgnore
*/
public RowSelectionChangeHandler(event: any): void {
this.RowSelectionChanged.fire([this, event]);
}
/**
* Fire ColumnSelectionChangeHandler
*
* @param {*} event
* @memberof XamGridModel
* @wIgnore
*/
public ColumnSelectionChangeHandler(event: any): void {
this.ColumnSelectionChanged.fire([this, event]);
}
/**
* KeyDownHandler
*
* @param {*} event
* @memberof XamGridModel
* @wIgnore
*/
public KeyDownHandler(event: any): void {
this.KeyDown.fire([this, event]);
}
/**
* Fire CellDoubleClickHandler
*
* @param {*} event
* @memberof XamGridModel
* @wIgnore
*/
public CellDoubleClickHandler(event: any): void {
this.CellDoubleClicked.fire([this, event]);
}
/**
* Property containing a reference as a IPagedCollection or null
*
* @return {*} {IPagedCollectionView}
* @memberof XamGridModel
* @wIgnore
*/
public ItemsSourceAsPagedCollection: IPagedCollectionView = null;
/**
* Dispose
*
* @param {boolean} [disposing]
* @memberof XamGridModel
*/
public Dispose(disposing?: boolean) {
Debugger.Throw('Not implemented');
}
/**
* ExitEditMode
*
* @param {boolean} cancel
* @memberof XamGridModel
*/
public ExitEditMode(cancel: boolean) {
this.change.fire(['triggerExitEditMode', !cancel]);
}
/**
* ExitEditModeInternal
*
* @param {boolean} cancel
* @memberof XamGridModel
* @wNoMap
*/
public ExitEditModeInternal(cancel: boolean) {
Debugger.Throw('Not implemented');
}
/**
* OnPropertyChanged
*
* @param {string} name
* @memberof XamGridModel
* @wNoMap
*/
public OnPropertyChanged(name: string) {
Debugger.Throw('Not implemented');
}
/**
* On Got Focus handler for XamGrid
*
* @param {*} sender
* @param {*} [args]
* @memberof XamGridModel
*/
public OnGotFocus(args: RoutedEventArgs): void {
super.OnGotFocus(args);
if (this.CurrentEditCell == null && this.ActiveCell == null) {
if (this.Rows.count > 0 && this.Rows.getItem(0).Cells.count > 0) {
const setFocus = true;
for (let cell of this.Rows.getItem(0).Cells) {
if (cell instanceof CellBase && cell.Column.Visibility) {
this.SetActiveCell(
cell,
CellAlignment.NotSet,
InvokeAction.Code,
true,
setFocus,
false
);
break;
}
}
}
}
}
/**
* Sets the data type associated with a column name. Valid examples
* of column types are:
* - 'int'
* - 'decimal'
* - 'int?'
* - 'Nullable\<int\>'
* - etc.
*
* @param {string} columnName
* @param {XamGridColumnType} type
* @memberof XamGridModel
* @wIgnore
*/
public SetColumnType(columnName: string, type: XamGridColumnType): void {
this.columnTypes.set(columnName, type);
}
/**
* Returns `true` if the given column name has an associated data type,
* `false` otherwise.
*
* @param {string} columnName
* @return {*} {boolean}
* @memberof XamGridModel
* @wIgnore
*/
public HasColumnType(columnName: string): boolean {
return this.columnTypes.has(columnName);
}
/**
* Returns the column data type associated with the given column name.
*
* @param {string} columnName
* @return {*} {string}
* @memberof XamGridModel
* @wIgnore
*/
public GetColumnType(columnName: string): XamGridColumnType {
return this.columnTypes.get(columnName);
}
/**
* Clears selected rows.
*
* @memberof XamGridModel
* @wIgnore
*/
public ClearSelectedRows(): void {
this.SelectionSettings.SelectedRows.clear();
for (const row of this.Rows) {
row.IsSelected = false;
}
}
/**
* A callback function to handle row selection
*
* @param {XamGridRow} row
* @memberof XamGridModel
*/
public SelectRow(row: XamGridRow): void {
const selectedRows = this.SelectionSettings?.SelectedRows;
let oldRows = selectedRows
? new SelectedRowsCollection(selectedRows.toArray())
: new SelectedRowsCollection();
let isChanged = false;
if (
selectedRows &&
this.SelectionSettings?.RowSelection === XamSelectionMode.Single
) {
if (
selectedRows.count > 1 ||
!iuAny(
selectedRows,
(anotherRow) => anotherRow == row || anotherRow.Data === row.Data
)
) {
selectedRows.clear();
selectedRows.add(row);
isChanged = true;
}
} else if (
selectedRows &&
!iuAny(
selectedRows,
(anotherRow) => anotherRow == row || anotherRow.Data === row.Data
)
) {
selectedRows.add(row);
isChanged = true;
}
if (isChanged && this.SelectedRow != row) {
// Fire SelectedRowsCollectionChanged event
let newRows = new SelectedRowsCollection(selectedRows.toArray());
const params = new SelectionCollectionChangedEventArgs();
params.NewSelectedItems = new SelectedRowsCollection(newRows);
params.PreviouslySelectedItems = new SelectedRowsCollection(oldRows);
this.SelectedRowsCollectionChanged.fire([this, params]);
this.RowSelectionChangeHandler(params);
}
}
/**
* A callback function to handle the unselection of rows
*
* @param {XamGridRow} row
* @memberof XamGridModel
*/
public UnselectRow(row: XamGridRow): void {
const selectedRows = this.SelectionSettings?.SelectedRows;
if (selectedRows == null) {
return;
}
const unSelectedRow = iuFirstOrDefault(
selectedRows,
(each: XamGridRow) => each.Data === row.Data
);
let oldRows = new SelectedRowsCollection(selectedRows.toArray());
if (unSelectedRow != null) {
selectedRows.remove(unSelectedRow);
let newRows = new SelectedRowsCollection(selectedRows.toArray());
// Fire SelectedRowsCollectionChanged event
const params = new SelectionCollectionChangedEventArgs();
params.NewSelectedItems = new SelectedRowsCollection(newRows);
params.PreviouslySelectedItems = new SelectedRowsCollection(oldRows);
this.SelectedRowsCollectionChanged.fire([this, params]);
}
}
/**
* Stores information about column types.
*
* @private
* @type {Map<string, XamGridColumnType>}
* @memberof XamGridModel
*/
private readonly columnTypes: Map<string, XamGridColumnType> = new Map<
string,
XamGridColumnType
>();
}
// Replaced with class RowCollection
export class XamGridRowCollection<T> extends ObservableCollection<any> {
private xamGrid: XamGridModel;
constructor(parentGrid: XamGridModel) {
super();
this.xamGrid = parentGrid;
}
getItem(index: number): any {
const row = super.getItem(index);
return row;
}
/**
* Inserts a new element at the specified position.
*
* @param {number} index
* @param {XamGridRow} value
* @memberof XamGridRowCollection
*/
insert(index: number, value: XamGridRow): void {
super.insert(index, value);
if (index < 0 || value == null) {
return;
}
const source = this.xamGrid.ItemsSource;
if (source) {
this.xamGrid.change.fire(['ItemsSource']);
}
}
/**
* Removes the first element from the collection which matches the given value.
*
* @param {XamGridRow} value
* @return {boolean}
* @memberof ObservableCollection
*/
remove(value: XamGridRow): boolean {
const result = super.remove(value);
const source = this.xamGrid.ItemsSource;
if (value != null && source) {
const index = -1;
if (index >= 0) {
this.xamGrid.change.fire(['ItemsSource']);
}
}
return result;
}
}
/**
* Readonly collection of columns
*
* @export
* @class ReadOnlyKeyedColumnBaseCollection
* @extends {ObservableCollection<T>}
* @template T
* @wType Infragistics.Controls.Grids.ReadOnlyKeyedColumnBaseCollection`1
*/
export class ReadOnlyKeyedColumnBaseCollection<
T extends XamGridColumnModel
> extends ObservableCollection<T> {
getColumnByKey(key: string) {
return findColumn(key, this);
}
}
/**
* Base class for column collections
*
* @export
* @class ColumnBaseCollection
* @extends {ObservableCollection<XamGridColumnModel>}
* @wType Infragistics.Controls.Grids.ColumnBaseCollection
*/
export class ColumnBaseCollection extends ObservableCollection<XamGridColumnModel> {
/**
* XamGrid ColumnLayout internal reference.
*
* @type {ColumnLayout}
* @memberof ColumnBaseCollection
*/
private _columnLayout: ColumnLayout;
/**
* List of non layout columns.
*
* @type {SimpleList<XamGridColumnModel>}
* @memberof ColumnBaseCollection
*/
private _nonLayoutColumns: SimpleList<XamGridColumnModel>;
/**
* XamGrid DataColumns internal reference.
*
* @type {ReadOnlyKeyedColumnBaseCollection<XamGridColumnModel>}
* @memberof ColumnBaseCollection
*/
private _dataColumns: ReadOnlyKeyedColumnBaseCollection<XamGridColumnModel>;
/**
* XamGrid cached data columns.
*
* @type {ColumnLayout}
* @memberof ColumnBaseCollection
*/
private _rebuildAllDataColumnsCache: boolean;
/**
* Gets XamGrid ColumnLayout reference.
*
* @readonly
* @type {ColumnLayout}
* @memberof ColumnBaseCollection
*/
get ColumnLayout(): ColumnLayout {
return this._columnLayout;
}
/**
* Gets list of non layout columns.
*
* @readonly
* @type {ColumnLayout}
* @memberof ColumnBaseCollection
* @wIgnore
*/
get NonLayoutColumns(): SimpleList<XamGridColumnModel> {
return this._nonLayoutColumns;
}
/**
* Gets an array of data columns.
*
* @readonly
* @type {ReadOnlyKeyedColumnBaseCollection<XamGridColumnModel>}
* @memberof ColumnBaseCollection
*/
get DataColumns(): ReadOnlyKeyedColumnBaseCollection<XamGridColumnModel> {
return new ReadOnlyKeyedColumnBaseCollection(this.toArray());
}
/**
* Creates an instance of ColumnBaseCollection class
*
* @param {ColumnLayout} ColumnLayout
* @memberof ColumnBaseCollection
*/
constructor(columnLayout: ColumnLayout) {
super();
this._columnLayout = columnLayout;
this._nonLayoutColumns = new SimpleList<XamGridColumnModel>();
this._dataColumns = new ReadOnlyKeyedColumnBaseCollection(
this._nonLayoutColumns
);
}
/**
* Get a columns by its key.
*
* @param {string} key
* @returns {XamGridColumnModel}
* @memberof ColumnBaseCollection
*/
getColumnByKey(key: string): XamGridColumnModel {
return findColumn(key, this);
}
/**
* Get a columns by its key recursively.
*
* @param {string} key
* @memberof ColumnBaseCollection
*/
getColumnByKeyDeep(key: string): {
column: XamGridColumnModel;
isRoot: boolean;
} {
const groupColumns = [];
for (const column of this) {
if (column.Key === key) {
return { column, isRoot: true };
}
if (column instanceof XamGridGroupColumnModel) {
groupColumns.push(column);
}
}
for (const columnGroup of groupColumns) {
let { column } = columnGroup.Columns.getColumnByKeyDeep(key);
if (column) {
return { column, isRoot: false };
}
}
return { column: null, isRoot: false };
}
/**
* Add a new item to the collection.
*
* @param {XamGridColumnModel} item
* @type {void}
* @memberof ColumnBaseCollection
*/
AddItem(item: XamGridColumnModel): void {
this.add(item);
this.ColumnLayout.OnColumnAdded(item);
}
/**
* Gets an item from the collection.
*
* @param {number} index
* @type {XamGridColumnModel}
* @memberof ColumnBaseCollection
*/
getItem(index: number): XamGridColumnModel {
if (index >= 0 || index < this.count) {
return super.getItem(index);
}
}
/**
* Adds columns to the NonLayoutColumns collection.
*
* @param {boolean} fullInvalidate
* @type {XamGridColumnModel}
* @memberof ColumnBaseCollection
*/
InvalidateColumnsCollections(fullInvalidate: boolean) {
this._nonLayoutColumns.clear();
if (this.ColumnLayout?.Grid) {
this.internalArray.forEach((ColumnBase) => {
if (ColumnBase instanceof XamGridColumnModel) {
this._nonLayoutColumns.add(ColumnBase);
}
});
this._rebuildAllDataColumnsCache = true;
}
}
/**
* add a new column to the collection.
*
* @param {XamGridColumnModel} value
* @memberof ColumnBaseCollection
*/
add(value: XamGridColumnModel): void {
value.ColumnLayout = this.ColumnLayout;
if (this.ColumnLayout?.Grid?.gridComponentInstance) {
this.ColumnLayout.Grid.gridComponentInstance.forcedColumnsWidthCalc =
true;
this.ColumnLayout.Grid.gridComponentInstance.detectChangesAction?.();
}
super.add(value);
}
}
/**
* Event arguments for the `page changed` event
*
* @export
* @class PageChangedEventArgs
* @wType Infragistics.Controls.Grids.PageChangedEventArgs
*/
export class PageChangedEventArgs {
/**
* The index of the previous page
*
* @memberof PageChangedEventArgs
*/
OldPageIndex = -1;
}
/**
* Event argument for the "cancellable pagin changing" event
*
* @export
* @class CancellablePageChangingEventArgs
* @wType Infragistics.Controls.Grids.CancellablePageChangingEventArgs
*/
export class CancellablePageChangingEventArgs extends CancellableEventArgs {
NextPageIndex = 0;
}
/**
* Event argument for the "cell clicked" event
*
* @export
* @class CellClickedEventArgs
* @wType Infragistics.Controls.Grids.CellClickedEventArgs
*/
export class CellClickedEventArgs {
constructor(protected model: XamGridCell) {}
/**
* Cell being clicked
*
* @readonly
* @type {*}
* @memberof CellClickedEventArgs
*/
get Cell(): any {
return this.model;
}
}
/**
* Event arguments for the "Begin Editing Cell" event
*
* @export
* @class BeginEditingCellEventArgs
* @extends {CancellableEventArgs}
* @wType Infragistics.Controls.Grids.BeginEditingCellEventArgs
*/
export class BeginEditingCellEventArgs extends CancellableEventArgs {
constructor(protected model: XamGridCell) {
super();
}
/**
* Cell being edited
*
* @readonly
* @type {*}
* @memberof BeginEditingCellEventArgs
*/
get Cell(): any {
return this.model;
}
}
/**
* Events object for the "Editing Cell" event arguments
*
* @export
* @class EditingCellEventArgs
* @wType Infragistics.Controls.Grids.EditingCellEventArgs
*/
export class EditingCellEventArgs extends CancellableEventArgs {
constructor(protected model: XamGridCell) {
super();
}
// Editor event args.
#editor: any = null;
/**
* Cell being edited
*
* @readonly
* @type {*}
* @memberof EditingCellEventArgs
*/
get Cell(): XamGridCell {
return this.model;
}
/**
* Editor object
*
* @readonly
* @type {*}
* @memberof EditingCellEventArgs
*/
get Editor(): any {
return this.#editor;
}
/**
* Set Editor property.
*
* @memberof EditingCellEventArgs
*/
set Editor(value: any) {
this.#editor = value;
}
}
/**
* Base class for event arguments related to row events
*
* @export
* @class RowEventArgs
* @wType Infragistics.Controls.Grids.RowEventArgs
*/
export class RowEventArgs {
/**
* Gets the row property value
* @wNoMap
*/
get Row(): any {
Debugger.Throw('Not implemented');
return undefined;
}
}
/**
* Class used for EditRow Events
*
* @export
* @class EditingRowEventArgs
* @extends {RowEventArgs}
* @wType Infragistics.Controls.Grids.EditingRowEventArgs
*/
export class EditingRowEventArgs extends RowEventArgs {
constructor(row: any) {
super();
this.#row = row;
}
#row: XamGridRow;
/**
* Gets the Row affected by the event
*
* @type {*}
* @memberof EditingRowEventArgs
*/
get Row(): any {
return this.#row;
}
set Row(value: any) {
this.#row = value;
}
}
/**
* Event arguments for row initialization
*
* @export
* @class InitializeRowEventArgs
* @extends {RowEventArgs}
* @wType Infragistics.Controls.Grids.InitializeRowEventArgs
*/
export class InitializeRowEventArgs extends RowEventArgs {
constructor(row: any) {
super();
this.#row = row;
}
#row: XamGridRow;
/**
* Gets the Row affected by the event
*
* @type {*}
* @memberof InitializeRowEventArgs
*/
get Row(): any {
return this.#row;
}
/**
* Sets the Row affected by the event
*
* @type {*}
* @memberof InitializeRowEventArgs
*/
set Row(value: any) {
this.#row = value;
}
}
/**
* Event argument for the "Cell Exited Editing" event
*
* @export
* @class CellExitedEditingEventArgs
* @wType Infragistics.Controls.Grids.CellExitedEditingEventArgs
*/
export class CellExitedEditingEventArgs {
constructor(protected model: XamGridCell) {}
/**
* Cell being edited
*
* @readonly
* @type {*}
* @memberof CellExitedEditingEventArgs
*/
get Cell(): XamGridCell {
return this.model;
}
}
/**
* Event arguments for the "Cell Control Attached" event
*
* @export
* @class CellControlAttachedEventArgs
* @wType Infragistics.Controls.Grids.CellControlAttachedEventArgs
*/
export class CellControlAttachedEventArgs {
constructor() {}
/**
* The cell being added to the grid view
*
* @readonly
* @memberof CellControlAttachedEventArgs
*/
Cell: XamGridCell;
}
/**
* Enumeration for cell selection arguments
*
* @export
* @enum {number}
* @wEnum Infragistics.Controls.Grids.CellSelectionAction
*/
export enum CellSelectionAction {
/**
* Row being selected
*/
SelectRow,
/**
* Cell being selected
*/
SelectCell,
}
/**
* An object that contains settings for selection on the XamGrid
*
* @export
* @class SelectionSettings
* @wType Infragistics.Controls.Grids.SelectionSettings
*/
export class SelectionSettings {
/**
* Grid property
* @wIgnore
*/
Grid: XamGridModel;
RowSelection = XamSelectionMode.Single;
CellSelection = XamSelectionMode.Multiple;
ColumnSelection = XamSelectionMode.None;
/**
* Custom property to handle internal checkbox selection , should be hide as default
* @wIgnore
*/
HideRowCheckboxes = true;
CellClickAction = CellSelectionAction.SelectCell;
SelectedCells = new ObservableCollection();
SelectedColumns: ColumnBaseCollection;
private _selectedRows: SelectedRowsCollection;
/**
* Gets or sets the selected rows collection
*
* @type {SelectedRowsCollection}
* @memberof SelectionSettings
*/
get SelectedRows(): SelectedRowsCollection {
if (this._selectedRows == null) {
this._selectedRows = new SelectedRowsCollection();
this._selectedRows.Grid = this.Grid;
}
return this._selectedRows;
}
set SelectedRows(value) {
this._selectedRows = value;
}
constructor(columnLayout: ColumnLayout) {
this.SelectedColumns = new ColumnBaseCollection(columnLayout);
}
}
/**
* Enumeration for specifying the paging location
*
* @export
* @enum {number}
* @wEnum Infragistics.Controls.Grids.PagingLocation
*/
export enum PagingLocation {
Both,
Bottom,
Hidden,
None,
Top,
}
/**
* An object that contains settings for using PagerSettings on the XamGrid
*
* @export
* @class PagerSettings
* @wType Infragistics.Controls.Grids.PagerSettings
*/
export class PagerSettings extends Control {
/**
* AllowPagingProperty dependency property
*
* @static
* @memberof PagerSettings
*/
static AllowPagingProperty = new DependencyProperty(
'AllowPaging',
PagingLocation.None,
null
);
/**
* CurrentPageIndexProperty dependency property
*
* @static
* @memberof PagerSettings
* @wIgnore
*/
static CurrentPageIndexProperty = new DependencyProperty(
'CurrentPageIndex',
0,
null
);
/**
* PageSizeProperty dependency property
*
* @static
* @memberof PagerSettings
*/
static PageSizeProperty = new DependencyProperty('PageSize', 10, null);
protected _currentPageIndex = 0;
protected _pageSize = 10;
/**
* Gets/sets if paging will be allowed by default.
*
* @type {PagingLocation}
* @memberof PagerSettings
*/
@Dependency(PagerSettings.AllowPagingProperty)
public AllowPaging: PagingLocation;
/**
* Gets/sets what page of data will be displayed.
*
* @type {number}
* @memberof PagerSettings
*/
@Dependency(PagerSettings.CurrentPageIndexProperty)
public CurrentPageIndex: number;
/**
* Gets/sets the maximum number of rows that will be available per page.
*
* @type {number}
* @memberof PagerSettings
*/
@Dependency(PagerSettings.PageSizeProperty)
public PageSize: number;
}
/**
* An object that contains settings for using ColumnResizingSettings on the XamGrid
*
* @export
* @class ColumnResizingSettings
* @wType Infragistics.Controls.Grids.ColumnResizingSettings
*/
export class ColumnResizingSettings {
AllowColumnResizing = true;
}
/**
* An object that contains settings for using ColumnMovingSettings on the XamGrid
*
* @export
* @class ColumnMovingSettings
* @wType Infragistics.Controls.Grids.ColumnMovingSettings
*/
export class ColumnMovingSettings {
AllowColumnMoving = false;
}
/**
* An object that contains settings for using RowSelectorSettings on the XamGrid
*
* @export
* @class RowSelectorSettings
* @wType Infragistics.Controls.Grids.RowSelectorSettings
*/
export class RowSelectorSettings {
EnableRowNumbering = true;
}
/**
* Enumeration for specifying the kind of filtering being used in the grid
*
* @export
* @enum {number}
* @wEnum Infragistics.Controls.Grids.FilteringScope
*/
export enum FilteringScope {
ChildBand,
ColumnLayout,
}
/**
* Class to represent the Sorting Settings
*
* @export
* @class SortingSettings
* @wType Infragistics.Controls.Grids.SortingSettings
*/
export class SortingSettings {
AllowSorting = true;
AllowMultipleColumnSorting = true;
FirstSortDirection = SortDirection.Ascending;
SortedColumns = new ObservableCollection<XamGridColumnModel>();
}
/**
* Interface for record filters
*
* @export
* @interface IRecordFilter
* @wInterface Infragistics.IRecordFilter
*/
export interface IRecordFilter {
Conditions: any; // ConditionCollection;
FieldName: string;
}
/**
* Enumeration for editing type
*
* @export
* @enum {number}
* @wEnum Infragistics.Controls.Grids.EditingType
*/
export enum XamGridEditingType {
None,
Cell,
Row,
Hover,
}
/**
* Enumeration for mouse editing action
*
* @export
* @enum {number}
* @wEnum Infragistics.Controls.Grids.MouseEditingAction
*/
export enum MouseEditingAction {
DoubleClick,
None,
SingleClick,
}
/**
* A class to represent the FilteringSettings
* @export
* @class RowFiltersCollection
* @wType Infragistics.Controls.Grids.FilteringSettings
*/
export class FilteringSettings extends Control {
/**
* AllowFilteringProperty dependency property
*
* @static
* @memberof FilteringSettings
*/
static AllowFilteringProperty = new DependencyProperty(
'AllowFiltering',
0,
null
);
protected _allowFiltering = FilterUIType.None;
@Dependency(FilteringSettings.AllowFilteringProperty)
public AllowFiltering: FilterUIType;
FilteringScope = FilteringScope.ChildBand;
RowFiltersCollection = new RowFiltersCollection();
internalXamGrid: XamGridModel;
}
/**
* A class to represent the RowFiltersCollection
* @export
* @class RowFiltersCollection
* @wType Infragistics.Controls.Grids.RowFiltersCollection
*/
export class RowFiltersCollection extends ObservableCollection<IRecordFilter> {
/**
* Gets rows filter item by key
*
* @param {string} key
* @returns
* @memberof FilteringSettings
*/
getItemByKey(key: string): IRecordFilter {
return this.GetRowFilterByColumnKey(key);
}
/**
* Gets row filter by column key
*
* @param {string} columnKey
* @returns {IRecordFilter}
* @memberof FilteringSettings
*/
GetRowFilterByColumnKey(columnKey: string): IRecordFilter {
for (const recordFilter of this.internalArray) {
if (recordFilter.FieldName === columnKey) {
return recordFilter;
}
}
return null;
}
}
/**
* A class to represent the grid FixedColumnSettings
* @export
* @class EditingSettings
* @wType Infragistics.Controls.Grids.FixedColumnSettings
*/
export class FixedColumnSettings {
AllowFixedColumns = false;
FixedColumnsLeft = new ObservableCollection<XamGridColumnModel>();
FixedColumnsRight = new ObservableCollection<XamGridColumnModel>();
}
/**
* A class to represent the grid Editing Settings
* @export
* @class EditingSettings
* @wType Infragistics.Controls.Grids.EditingSettings
*/
export class EditingSettings {
AllowEditing: XamGridEditingType;
IsOnCellActiveEditingEnabled = false;
IsMouseActionEditingEnabled = MouseEditingAction.DoubleClick;
IsEnterKeyEditingEnabled = false;
IsF2EditingEnabled = false;
}
/**
* Event arguments for the "Editing Cell" event
*
* @export
* @class ExitEditingCellEventArgs
* @extends {CancellableEventArgs}
* @wType Infragistics.Controls.Grids.ExitEditingCellEventArgs
*/
export class ExitEditingCellEventArgs extends CancellableEventArgs {
/**
* Creates an instance of ExitEditingCellEventArgs.
* @param {XamGridCell} model
* @memberof ExitEditingCellEventArgs
*/
constructor(protected model: XamGridCell) {
super();
}
/**
* Private reference to the editor instance
*
* @type {*}
* @memberof ExitEditingCellEventArgs
*/
#editor: any = null;
/**
* Cell being edited
*
* @readonly
* @type {*}
* @memberof ExitEditingCellEventArgs
*/
get Cell(): XamGridCell {
return this.model;
}
/**
* Editor object
*
* @readonly
* @type {*}
* @memberof ExitEditingCellEventArgs
*/
get Editor(): any {
return this.#editor;
}
/**
* Set Editor property.
*
* @memberof ExitEditingCellEventArgs
*/
set Editor(value: any) {
this.#editor = value;
}
}
/**
* Enumeration for specifying the kind of filtering UI
*
* @export
* @enum {number}
* @wEnum Infragistics.Controls.Grids.FilterUIType
*/
export enum FilterUIType {
None,
FilterRowTop,
FilterRowBottom,
FilterMenu,
}
/**
* A class to represent grid cells
*
* @export
* @class XamGridCell
* @wType Infragistics.Controls.Grids.Cell
*/
export class XamGridCell extends CellBase {
#IsActive = false;
#IsSelected = false;
/**
* @wIgnore
*/
_style: RuntimeStyleInfo = null;
/**
* Key for the cell
*
* @type {string}
* @memberof XamGridCell
*/
key: string;
get gridComponent(): any {
return this.Row.ColumnLayout.Grid?.gridComponentInstance?.grid;
}
/**
* Returns the index of the cell in the grid when is visible in the viewport otherwise returns -1
*
* @private
* @return {*} {number}
* @memberof XamGridCell
*/
private visibleIndex(): number {
return (
this.gridComponent.getColumnByName(this.Column?.Key)?.visibleIndex ?? -1
);
}
/**
* Determines if the editor style was resolved
*
* @memberof XamGridCell
*/
EditorStyleResolved: RuntimeStyleInfo = null;
/**
* Determines if this cell is active
*
* @memberof XamGridCell
*/
get IsActive(): boolean {
return this.Row.ColumnLayout.Grid.ActiveCell == this;
}
/* istanbul ignore next */
set IsActive(value: boolean) {
if (value) {
this.Row.ColumnLayout.Grid.ActiveCell = this;
} else {
this.Row.ColumnLayout.Grid.ActiveCell = null;
this.Row.ColumnLayout.Grid.gridComponentInstance?.cleanActiveFromIgxGrid?.();
}
}
/**
* Determines if this cell is selected
*
* @memberof XamGridCell
*/
get IsSelected() {
return this.#IsSelected;
}
/* istanbul ignore next */
set IsSelected(value: boolean) {
if (value === this.#IsSelected) {
return;
}
this.#IsSelected = value;
const node = {
row: this.Row?.Index,
column: this.gridComponent?.getColumnByName(this.Column?.Key)
?.visibleIndex,
};
value
? this.gridComponent?.selectionService.add(node)
: this.gridComponent?.grid?.selectionService.remove(node);
}
/**
* Cell style
*
* @type {RuntimeStyleInfo}
* @memberof XamGridCell
*/
get Style() {
return this._style;
}
set Style(val: RuntimeStyleInfo) {
if (this._style !== val) {
this._style = val;
if (
this.Column.ColumnLayout.Grid.gridComponentInstance?.cellStyleEnabled
) {
this.Column.ColumnLayout.Grid.gridComponentInstance.cellChanged();
}
}
}
/**
* Cell value
*
* @type {unknown}
* @memberof XamGridCell
*/
get Value(): any {
if (this.Row.Data == null) {
return null;
}
if (this.Column.Key == null) {
return null;
}
return this.Row.Data[this.Column.Key];
}
/**
* Creates an instance of XamGridCell.
* @param {RowBase} [row]
* @param {XamGridColumnModel} [column]
* @memberof XamGridCell
*/
constructor(row?: RowBase, column?: XamGridColumnModel) {
super();
this.Row = row;
this.Column = column;
}
}
/**
* An object used to represent the associated control to a cell
*
* @export
* @class XamGridCellControl
* @extends {ContentControlModel}
*/
export class XamGridCellControl extends ContentControlModel {
/**
* Helper property to resolve UnboundDataContext and keep unique reference for comparison
*
* @type {UnboundColumnDataContext}
* @memberof XamGridCellControl
*/
UnboundDataContextResolver: UnboundColumnDataContext;
/**
* Lazy load content setter
*
* @type {*}
* @memberof XamGridCellControl
*/
set LazyLoadContent(value: any) {
this.lazyLoadContent = value;
this.isLazyLoad = value ? true : false;
}
/**
* On demand data context resolve function to recalculate DataContext each request
*
* @type {*}
* @memberof XamGridCellControl
*/
onDemandLoadDataContext: any;
/**
* The columns associated to the control
*
* @type {*}
* @memberof XamGridCellControl
*/
Column: any = null;
/**
* The cell associated to the control
*
* @type {*}
* @memberof XamGridCellControl
*/
Cell: any = null;
/**
* Represents the content of the Content with lazy loading
*
* @type {*}
* @memberof XamGridCellControl
*/
set Content(value: any) {
this.setValue(XamGridCellControl.ContentProperty, value);
}
get Content(): any {
if (this.isLazyLoad) {
this.setValue(XamGridCellControl.ContentProperty, this.lazyLoadContent());
}
return this.getValue(XamGridCellControl.ContentProperty);
}
/**
* Sets the datacontext
*
* @memberof XamGridCellControl
*/
set DataContext(value: any) {
this.setValue(XamGridCellControl.DataContextProperty, value);
}
/**
* Gets the data context updated using firts the onDemandLoadDataContext
*
* @type {*}
* @memberof XamGridCellControl
*/
get DataContext(): any {
this.refreshDataContext();
return this.getValue(XamGridCellControl.DataContextProperty);
}
/**
* Lazy load content function
*
* @type {*}
* @private
* @memberof XamGridCellControl
*/
private lazyLoadContent: any;
/**
* Flag to set the content when lazy loading
*
* @type {boolean}
* @private
* @memberof XamGridCellControl
*/
private isLazyLoad = false;
/**
* Refresh data context is used to be triggered internally and from child to force the XamGridCell to update
* the DataContext
*
* @memberof XamGridCellControl
*/
refreshDataContext(): void {
if (this.onDemandLoadDataContext) {
this.setValue(
XamGridCellControl.DataContextProperty,
this.onDemandLoadDataContext()
);
}
}
/**
* Overrides the ContentChangeHandler for lazy loading initialization
*
* @param {DependencyPropertyChangedEventArgs} args
* @memberof XamGridCellControl
*/
public ContentChangeHandler(args: DependencyPropertyChangedEventArgs) {
super.ContentChangeHandler(args);
}
}
/**
* An object used by the UnboundColumn to hold the DataContext for an unbound cell.
*
* @export
* @class UnboundColumnDataContext
* @wType Infragistics.Controls.Grids.UnboundColumnDataContext
*/
export class UnboundColumnDataContext implements INotifyPropertyChanged {
/**
* Event to indicate that a property have changed.
*
* @memberof UnboundColumnDataContext
*/
public PropertyChanged: SubscriptionEvent<
(e: any, args: { PropertyName: string }) => void
> = new SubscriptionEvent();
private columnKey: string;
private rowData: any;
private value: any;
private valueConverter: IValueConverter;
/**
* The column key of the associate Column
*
* @memberof UnboundColumnDataContext
*/
public get ColumnKey() {
return this.columnKey;
}
public set ColumnKey(value: string) {
this.columnKey = value;
this.onPropertyChanged({ PropertyName: 'ColumnKey' });
}
/**
* The data object associated with the row of data
*
* @memberof UnboundColumnDataContext
*/
public get RowData() {
return this.rowData;
}
public set RowData(value: any) {
this.rowData = value;
this.onPropertyChanged({ PropertyName: 'RowData' });
}
/**
* The value generated by the ValueConverter.
*
* @memberof UnboundColumnDataContext
*/
public get Value() {
return this.valueConverter
? this.valueConverter.Convert(this.value, null, null, null)
: this.value;
}
public set Value(value: any) {
this.value = value;
this.onPropertyChanged({ PropertyName: 'Value' });
}
/**
* Creates an instance of UnboundColumnDataContext.
*
* @param {string} columnKey
* @param {*} rowData
* @param {*} value
* @param {IValueConverter} [converter]
* @memberof UnboundColumnDataContext
*/
constructor(
columnKey: string,
rowData: any,
value: any,
converter?: IValueConverter
) {
this.columnKey = columnKey;
this.rowData = rowData;
this.value = value;
this.valueConverter = converter;
}
/**
* Raises the PropertyChanged event
*
* @protected
* @param {{ PropertyName: string }} info
* @memberof UnboundColumnDataContext
* @wMethod OnPropertyChanged
*/
/* istanbul ignore next */
protected onPropertyChanged(info: { PropertyName: string }): void {
this.PropertyChanged.fire([this, info]);
}
}
/**
* Collection for selected rows
*
* @export
* @class SelectedRowsCollection
* @extends {ObservableCollection<XamGridRow>}
* @wType Infragistics.Controls.Grids.SelectedRowsCollection
*/
export class SelectedRowsCollection extends ObservableCollection<XamGridRow> {
/**
* Property to keep the xamGrid reference
*
* @type {XamGridModel}
* @memberof SelectedRowsCollection
* @wIgnore
*/
Grid: XamGridModel;
/**
* Creates an instance of SelectedRowsCollection.
* @param {Iterable<XamGridRow>} [initial]
* @memberof SelectedRowsCollection
*/
constructor(initial?: Iterable<XamGridRow>) {
super(initial);
}
/**
* Remove the row from the collection and
* set in false the selection property of the row
*
* @param {XamGridRow} value
* @return {*} {boolean}
* @memberof SelectedRowsCollection
*/
remove(value: XamGridRow): boolean {
value.SetSelected(false);
const newEventArgs =
new SelectionCollectionChangedEventArgs<SelectedRowsCollection>();
newEventArgs.NewSelectedItems = new SelectedRowsCollection();
newEventArgs.PreviouslySelectedItems = new SelectedRowsCollection(
this.toArray()
);
const result = super.remove(value);
this.gridTriggerChange(newEventArgs);
return result;
}
/**
* Remove the row from the collection by Index and
* set in false the selection property of the row
* @param {number} index
* @memberof SelectedRowsCollection
*/
removeAt(index: number): void {
this.getItem(index).SetSelected(false);
const newEventArgs =
new SelectionCollectionChangedEventArgs<SelectedRowsCollection>();
newEventArgs.NewSelectedItems = new SelectedRowsCollection();
newEventArgs.PreviouslySelectedItems = new SelectedRowsCollection(
this.toArray()
);
super.removeAt(index);
this.gridTriggerChange(newEventArgs);
}
/**
* If the grid is not null, fire the change event on the grid for the SelectedItem.
* The change event is a built-in event that is fired whenever the grid's data changes.
* @memberof SelectedRowsCollection
*/
private gridTriggerChange(
eventArgs?: SelectionCollectionChangedEventArgs<SelectedRowsCollection>
): void {
if (eventArgs) {
this.Grid?.SelectedRowsCollectionChanged.fire([this.Grid, eventArgs]);
}
this.Grid?.change.fire(['SelectedRowsChanged']);
}
/**
* Remove all the rows from the collection and
* set in false the selection property of each row
* @memberof SelectedRowsCollection
*/
clear(): void {
this.forEach((item) => item.SetSelected(false));
let newEventArgs = null;
if (this.count > 0) {
newEventArgs =
new SelectionCollectionChangedEventArgs<SelectedRowsCollection>();
newEventArgs.NewSelectedItems = new SelectedRowsCollection();
newEventArgs.PreviouslySelectedItems = new SelectedRowsCollection(
this.toArray()
);
}
super.clear();
this.gridTriggerChange(newEventArgs);
}
/**
* Add the row to the collection and
* set in true the selection property of the row
* @param {XamGridRow} value
* @memberof SelectedRowsCollection
*/
add(value: XamGridRow): void {
value.SetSelected(true);
const newEventArgs =
new SelectionCollectionChangedEventArgs<SelectedRowsCollection>();
newEventArgs.NewSelectedItems = new SelectedRowsCollection([value]);
newEventArgs.PreviouslySelectedItems = new SelectedRowsCollection(
this.toArray()
);
super.add(value);
this.gridTriggerChange(newEventArgs);
}
/**
* Add the rows to the collection by index and
* set in true the selection property of each row
* @param {Iterable<XamGridRow>} values
* @memberof SelectedRowsCollection
*/
addRange(values: Iterable<XamGridRow>): void {
const newEventArgs =
new SelectionCollectionChangedEventArgs<SelectedRowsCollection>();
newEventArgs.NewSelectedItems = new SelectedRowsCollection([...values]);
newEventArgs.PreviouslySelectedItems = new SelectedRowsCollection(
this.toArray()
);
super.addRange(values);
this.forEach((item) => item.SetSelected(true));
this.gridTriggerChange(newEventArgs);
}
}
/**
* Event arguments for changed in the selection collection
*
* @export
* @class SelectionCollectionChangedEventArgs
* @template T
* @wType Infragistics.Controls.Grids.SelectionCollectionChangedEventArgs`1
*/
export class SelectionCollectionChangedEventArgs<T> {
NewSelectedItems: T;
PreviouslySelectedItems: T;
}
/**
* Event arguments for column resizing (cancellable)
*
* @export
* @class CancellableColumnResizingEventArgs
* @extends {CancellableEventArgs}
* @wType Infragistics.Controls.Grids.CancellableColumnResizingEventArgs
*/
export class CancellableColumnResizingEventArgs extends CancellableEventArgs {}
/**
* Find the column by key
*
* @param {string} key The key of the column to find
* @param {*} data The data to search in
* @return {*} {XamGridColumnModel} The column found
*/
function findColumn(key: string, data): XamGridColumnModel {
for (const column of data) {
if (column.Key === key) {
return column;
}
}
return null;
}