File

projects/k-components/src/lib/components/datagrid/datagrid.component.ts

Implements

OnInit AfterViewInit

Metadata

changeDetection ChangeDetectionStrategy.OnPush
selector wm-data-grid
styleUrls ./datagrid.component.css
templateUrl ./datagrid.component.html

Index

Properties
Methods
Inputs
Accessors

Constructor

constructor(injector: Injector, changeDetector: ChangeDetectorRef)
Parameters :
Name Type Optional
injector Injector No
changeDetector ChangeDetectorRef No

Inputs

cellClick
Type : EventEmitter<CellClickEvent>
Default value : new EventEmitter()
data
Type : any
KeyDownHandler
Type : EventEmitter<any>
Default value : new EventEmitter()
model
Type : DataGridModel
pageSize
Type : any
pageSizes
Type : {}
Default value : [10, 20, 50, 100, 200]

Allows to configure the number of items that will be displayed per page.

selectionChange
Type : EventEmitter<any>
Default value : new EventEmitter()

Methods

cellClickHandler
cellClickHandler($event)
Parameters :
Name Optional
$event No
Returns : void
Public getCalculatedStyle
getCalculatedStyle()
Returns : void
getColumns
getColumns()
Returns : any
keyDownHandler
keyDownHandler($event)
Parameters :
Name Optional
$event No
Returns : void
ngAfterViewInit
ngAfterViewInit()
Returns : void
ngOnInit
ngOnInit()
Returns : void
Public refresh
refresh()
Returns : void
selectionChangeHandler
selectionChangeHandler($event)
Parameters :
Name Optional
$event No
Returns : void
setSelectedItem
setSelectedItem()
Returns : void

Properties

cellClick
Type : EventEmitter<CellClickEvent>
Default value : new EventEmitter()
Decorators :
@Input()
internalData
Type : Array<any>
isInitialized
Default value : false
kendoGridComponent
Type : GridComponent
Decorators :
@ViewChild(GridComponent, {static: false})
KeyDownHandler
Type : EventEmitter<any>
Default value : new EventEmitter()
Decorators :
@Input()
Public model
Type : DataGridModel
Decorators :
@Input()
pageSize
Decorators :
@Input()
pageSizes
Type : []
Default value : [10, 20, 50, 100, 200]
Decorators :
@Input()

Allows to configure the number of items that will be displayed per page.

selectionChange
Type : EventEmitter<any>
Default value : new EventEmitter()
Decorators :
@Input()
viewChildren
Type : QueryList<DataGridColumnComponent>
Decorators :
@ContentChildren(DataGridColumnComponent)

Accessors

data
getdata()
setdata(value: any)
Parameters :
Name Type Optional
value any No
Returns : void
import {
  Component,
  Input,
  Injector,
  OnInit,
  EventEmitter,
  ViewChild,
  AfterViewInit,
  QueryList,
  ContentChildren,
  ChangeDetectorRef,
} from '@angular/core';
import { CellClickEvent, GridComponent } from '@progress/kendo-angular-grid';
import { ComponentId } from '@mobilize/wms-framework';
import { AngularComponentId } from '@mobilize/wms-framework';
import { DataGridModel } from '@mobilize/wms-framework';
import { DataGridColumnComponent } from '../datagridcolumn/datagridcolumn.component';

@Component({
  selector: 'wm-data-grid',
  templateUrl: './datagrid.component.html',
  styleUrls: ['./datagrid.component.css'],
  changeDetection: ChangeDetectionStrategy.OnPush,
})
@ComponentId([AngularComponentId.dataGrid])
export class DataGridComponent implements OnInit, AfterViewInit {
  internalData: Array<any>;

  @Input()
  public model: DataGridModel;
  /**
   * Allows to configure the number of items that will be displayed per page.
   */
  @Input()
  pageSizes = [10, 20, 50, 100, 200];

  @Input()
  pageSize;

  @Input()
  cellClick: EventEmitter<CellClickEvent> = new EventEmitter();
  @Input()
  selectionChange: EventEmitter<any> = new EventEmitter();
  @Input()
  KeyDownHandler: EventEmitter<any> = new EventEmitter();

  @ContentChildren(DataGridColumnComponent)
  viewChildren: QueryList<DataGridColumnComponent>;

  @ViewChild(GridComponent, { static: false })
  kendoGridComponent: GridComponent;

  isInitialized = false;

  public refresh(): void {}

  constructor(
    private injector: Injector,
    private changeDetector: ChangeDetectorRef
  ) {}
  ngAfterViewInit(): void {
    if (!this.isInitialized) {
      this.viewChildren.forEach((item) => {
        this.model.addColumn(item.model);
      });
      this.isInitialized = true;
    }
    this.changeDetector.detectChanges();
  }

  ngOnInit(): void {
    this.model = this.model || new DataGridModel();
    this.pageSize = this.pageSize ? this.pageSize : 10;
  }

  public getCalculatedStyle(): void {}

  cellClickHandler($event): void {
    if ($event) {
      this.model.SelectedItem = $event.dataItem;
      this.model.SelectedIndex = $event.rowIndex;
      this.model.SelectedColumnIndex = $event.columnInde;
      this.cellClick.emit($event);
    }
  }

  selectionChangeHandler($event): void {
    if ($event) {
      this.model.SelectedItems = $event.selectedRows;
      this.selectionChange.emit($event);
    }
  }

  keyDownHandler($event): void {
    if ($event) {
      this.model?.KeyDownHandler($event);
      this.KeyDownHandler.emit($event);
    }
  }

  getColumns(): any {
    return this.model.getColumns();
  }

  setSelectedItem(): void {
    if (this.kendoGridComponent && this.kendoGridComponent.navigable) {
      this.kendoGridComponent.focusCell(
        this.model.SelectedIndex,
        this.model.SelectedColumnIndex
      );
    }
  }

  @Input()
  get data(): any {
    return this.internalData;
  }

  set data(value: any) {
    /* tslint:disable-next-line:no-string-literal */
    if (value && typeof value['internalArray'] !== 'undefined') {
      /* tslint:disable-next-line:no-string-literal */
      this.internalData = value['internalArray'];
    } else {
      this.internalData = value;
    }
  }
}
<ng-container *ngIf="model">
  <ng-container *ngIf="model.Columns; else elseBlock">
    <kendo-grid
      [data]="internalData || model.ItemsSource?.internalArray"
      [selectable]="model.selectableSettings"
      [reorderable]="true"
      [pageSize]="pageSize"
      [resizable]="true"
      [scrollable]="true"
      (cellClick)="cellClickHandler($event)"
      (selectionChange)="selectionChangeHandler($event)"
      (keydown)="keyDownHandler($event)"
    >
      <ng-container *ngFor="let col of model.Columns">
        <kendo-grid-column field="{{ col.Field }}" title="{{ col.Header }}">
          <ng-container *ngIf="col.templateRef">
            <ng-template
              kendoGridCellTemplate
              let-rowIndex="rowIndex"
              let-column
              let-columnIndex="columnIndex"
              let-dataItem="dataItem"
            >
              <ng-container *ngTemplateOutlet="col.templateRef"></ng-container>
            </ng-template>
          </ng-container>
        </kendo-grid-column>
      </ng-container>
    </kendo-grid>
  </ng-container>
  <ng-template #elseBlock>
    <kendo-grid
      [data]="internalData || model.ItemsSource?.internalArray"
      [selectable]="model.selectableSettings"
      [reorderable]="true"
      [pageSize]="pageSize"
      [resizable]="true"
      [scrollable]="true"
      (cellClick)="cellClickHandler($event)"
      (selectionChange)="selectionChangeHandler($event)"
      (keydown)="keyDownHandler($event)"
    >
    </kendo-grid>
  </ng-template>
</ng-container>

./datagrid.component.css

wm-data-grid .k-grid-aria-root {
  height: calc(100% - 25px);
}
Legend
Html element
Component
Html element with directive

result-matching ""

    No results matching ""