diff --git a/ng-grid/ng-grid-tests.ts b/ng-grid/ng-grid-tests.ts index 53763b1a51..a11067e849 100644 --- a/ng-grid/ng-grid-tests.ts +++ b/ng-grid/ng-grid-tests.ts @@ -1,4 +1,5 @@ -/// +/// +/// var options1: ngGrid.IGridOptions = { data: [{ 'Name': 'Bob' }, { 'Name': 'Jane' }] @@ -25,3 +26,288 @@ var options4: ngGrid.IGridOptions = { currentPage: 1 } }; + +var columnDef: ngGrid.IColumnDef = { + width:{}, + minWidth:{}, + visible:false, + field:'', + displayName:'', + sortable:false, + resizable:false, + groupable:false, + pinnable:false, + editableCellTemplate:'', + enableCellEdit:false, + cellEditableCondition:'', + sortFn:(a:any, b:any):number=> { return 0 }, + cellTemplate:'', + cellClass:'', + headerClass:'', + headerCellTemplate:'', + cellFilter:'', + aggLabelFilter:'', + pinned:false +} + +var searchProvider: ngGrid.ISearchProvider = {}; +searchProvider.fieldMap = {}; +searchProvider.extFilter = false; +searchProvider.evalFilter(); + +var nr:number; + +var selectionProvider: ngGrid.ISelectionProvider = {}; +selectionProvider.multi = false; +selectionProvider.selectedItems = []; +selectionProvider.selectedIndex = 1; +selectionProvider.lastClickedRow = {}; +selectionProvider.ignoreSelectedItemChanges = false; +selectionProvider.pKeyParser = {}; +selectionProvider.ChangeSelection({}, {}); +nr = selectionProvider.getSelection({}); +nr = selectionProvider.getSelectionIndex({}); +selectionProvider.setSelection({}, false); +selectionProvider.toggleSelectAll(true, false, false); + +var eventProvider: ngGrid.IEventProvider = {}; +eventProvider.colToMove = {}; +eventProvider.groupToMove = {}; +eventProvider.assignEvents(); +eventProvider.assignGridEventHandlers(); +eventProvider.dragStart({}); +eventProvider.dragOver({}); +eventProvider.setDraggables(); +eventProvider.onGroupMouseDown({}); +eventProvider.onGroupDrop({}); +eventProvider.onHeaderMouseDown({}); +eventProvider.onHeaderDrop({}); + +var aggregate: ngGrid.IAggregate = {}; +aggregate.rowIndex = 0; +aggregate.offsetTop = 0; +aggregate.entity = {}; +aggregate.label = ''; +aggregate.field = ''; +aggregate.depth = 0; +aggregate.parent = {}; +aggregate.children = []; +aggregate.aggChildren = []; +aggregate.aggIndex = 0; +aggregate.collapsed = false; +aggregate.groupInitState = false; +aggregate.rowFactory = {}; +aggregate.rowHeight = 0; +aggregate.isAggRow = false; +aggregate.offsetLeft = 0; +aggregate.aggLabelFilter = {}; + +var rowConfig: ngGrid.IRowConfig = {}; +rowConfig.enableCellSelection = false; +rowConfig.enableRowSelection = false; +rowConfig.jqueryUITheme = false; +rowConfig.rowClasses = ['']; +rowConfig.rowHeight = 0; +rowConfig.selectWithCheckboxOnly = false; +rowConfig.selectedItems = []; +rowConfig.afterSelectionChangeCallback(); +rowConfig.beforeSelectionChangeCallback(); + +var renderedRange: ngGrid.IRenderedRange = {}; +renderedRange.bottomRow = 0; +renderedRange.topRow = 0; + +var rowFactory: ngGrid.IRowFactory = {}; +rowFactory.aggCache= null; +rowFactory.dataChanged= false; +rowFactory.groupedData= null; +rowFactory.numberOfAggregates = 0; +rowFactory.parentCache= []; +rowFactory.parsedData= []; +rowFactory.renderedRange = {}; +rowFactory.rowConfig = {}; +rowFactory.rowHeight = 0; +rowFactory.selectionProvider = {}; +rowFactory.UpdateViewableRange({}); +aggregate = rowFactory.buildAggregateRow({}, 0); +var row:ngGrid.IRow = rowFactory.buildEntityRow({}, 0); +rowFactory.filteredRowsChanged(); +rowFactory.fixRowCache(); +rowFactory.getGrouping({}); +rowFactory.parseGroupData({}); +rowFactory.renderedChange(); +rowFactory.renderedChangeNoGroups(); + +var dimension: ngGrid.IDimension = {}; +dimension.outerHeight = 0; +dimension.outerWidth = 0; +dimension.autoFitHeight = false; + +var elmDimension: ngGrid.IElementDimension = {}; +elmDimension.rootMaxH = 0; +elmDimension.rootMaxW = 0; +elmDimension.rowIndexCellW = 0; +elmDimension.rowSelectedCellW = 0; +elmDimension.scrollH = 0; +elmDimension.scrollW = 0; + +var row: ngGrid.IRow = {}; +row.entity= {}; +row.config = {}; +row.selectionProvider = {}; +row.rowIndex = 0; +row.utils= {}; +row.selected = false; +row.cursor = ''; +row.offsetTop = 0; +row.rowDisplayIndex = 0; +row.afterSelectionChange(); +row.beforeSelectionChange(); +row.setSelection(false); +row.continueSelection({}); +row.ensureEntity({}); +var b:boolean = row.toggleSelected({}); +row.alternatingRowClass(); +var a:any = row.getProperty(''); +var r:ngGrid.IRow = row.copy(); +row.setVars({}); + +var column: ngGrid.IColumn = {}; +column.colDef = {}; +column.width = 0; +column.groupIndex = 0; +column.isGroupedBy = false; +column.minWidth = 0; +column.maxWidth = 0; +column.enableCellEdit = false; +column.cellEditableCondition = {}; +column.headerRowHeight = 0; +column.displayName = ''; +column.index = 0; +column.isAggCol = false; +column.cellClass = ''; +column.sortPriority = 0; +column.cellFilter = {}; +column.field = ''; +column.aggLabelFilter = {}; +column.visible = false; +column.sortable = false; +column.resizable = false; +column.pinnable = false; +column.pinned = false; +column.originalIndex = 0; +column.groupable = false; +column.sortDirection = ''; +column.sortingAlgorithm = ()=>{}; +column.headerClass = ''; +column.cursor = ''; +column.headerCellTemplate = ''; +column.cellTemplate = ''; +var s:string = column.groupedByClass(); +column.toggleVisible(); +b = column.showSortButtonUp(); +b = column.showSortButtonDown(); +b = column.noSortVisible(); +b = column.sort({}); +a = column.gripClick(); +a = column.gripOnMouseDown({}); +column.onMouseMove({}); +column.gripOnMouseUp({}); +var c:ngGrid.IColumn = column.copy(); +column.setVars(c); + +var gridScope: ngGrid.IGridScope = {}; +gridScope.elementsNeedMeasuring = false; +gridScope.columns = []; +gridScope.renderedRows = []; +gridScope.renderedColumns = []; +gridScope.headerRow = {}; +gridScope.rowHeight = 0; +gridScope.jqueryUITheme = {}; +gridScope.showSelectionCheckbox = false; +gridScope.enableCellSelection = false; +gridScope.enableCellEditOnFocus = false; +gridScope.footer = {}; +gridScope.selectedItems = []; +gridScope.multiSelect = false; +gridScope.showFooter = false; +gridScope.footerRowHeight = 0; +gridScope.showColumnMenu = false; +gridScope.forceSyncScrolling = false; +gridScope.showMenu = false; +gridScope.configGroups = []; +gridScope.gridId = ''; +gridScope.enablePaging = false; +gridScope.pagingOptions = {}; +gridScope.i18n = {}; +gridScope.selectionProvider = {}; +gridScope.adjustScrollLeft(0); +gridScope.adjustScrollTop(0, true); +gridScope.toggleShowMenu(); +gridScope.toggleSelectAll(); +nr = gridScope.totalFilteredItemsLength(); +a = gridScope.showGroupPanel(); +nr = gridScope.topPanelHeight(); +nr = gridScope.viewportDimHeight(); +gridScope.groupBy({}); +gridScope.removeGroup(0); +gridScope.togglePin({}); +nr = gridScope.totalRowWidth(); +a = gridScope.headerScrollerDim(); + +var gridInstance: ngGrid.IGridInstance = {}; +gridInstance.$canvas = {}; +gridInstance.$viewport = {}; +gridInstance.$groupPanel = {}; +gridInstance.$footerPanel = {}; +gridInstance.$headerScroller = {}; +gridInstance.$headerContainer = {}; +gridInstance.$headers = {}; +gridInstance.$topPanel = {}; +gridInstance.$root = {}; +gridInstance.config = {}; +gridInstance.data = {}; +gridInstance.elementDims = {}; +gridInstance.eventProvider = {}; +gridInstance.filteredRows = [{}]; +gridInstance.footerController = {}; +gridInstance.gridId = ''; +gridInstance.lastSortedColumns = [{}]; +gridInstance.lateBindColumns = false; +gridInstance.maxCanvasHt = 0; +gridInstance.prevScrollIndex = 0; +gridInstance.prevScrollTop = 0; +gridInstance.rootDim = {}; +gridInstance.rowCache = [{}]; +gridInstance.rowFactory = {}; +gridInstance.rowMap = [{}]; +gridInstance.searchProvider = {}; +gridInstance.styleProvider = {}; +gridInstance.buildColumnDefsFromData(); +gridInstance.buildColumns(); +gridInstance.calcMaxCanvasHeight(); +gridInstance.clearSortingData(); +gridInstance.configureColumnWidths(); +gridInstance.fixColumnIndexes(); +gridInstance.fixGroupIndexes(); +var p:ng.IPromise = gridInstance.getTemplate(''); +p = gridInstance.init(); +p = gridInstance.initTemplates(); +gridInstance.minRowsToRender(); +gridInstance.refreshDomSizes(); +gridInstance.resizeOnData({}); +gridInstance.setRenderedRows([{}]); +gridInstance.sortActual(); +gridInstance.sortColumnsInit(); +gridInstance.sortData({}, {}); + +var styleProvider:ngGrid.IStyleProvider = new ngStyleProvider({}, {}); +var searchProvider:ngGrid.ISearchProvider = new ngSearchProvider({}, {}, {}); +var selectionProvider:ngGrid.ISelectionProvider = new ngSelectionProvider({}, {}, {}); +var ngEventProvider:ngGrid.IEventProvider = new ngEventProvider({}, {}, <{}, {}); +var ngAggregate:ngGrid.IAggregate = new ngAggregate({}, {}, 10, true); +var ngRenderedRange:ngGrid.IRenderedRange = new ngRenderedRange(1, 2); +var ngDimension:ngGrid.IDimension = new ngDimension({}); +var ngRow:ngGrid.IRow = new ngRow({}, {}, {}, 0, {}); +var ngColumn:ngGrid.IColumn = new ngColumn({}, {}, {}, {}, {}, {}); +var ngFooter:ngGrid.IFooter = new ngFooter({}, {}); diff --git a/ng-grid/ng-grid.d.ts b/ng-grid/ng-grid.d.ts index 70f4f569f8..7aa8f87161 100644 --- a/ng-grid/ng-grid.d.ts +++ b/ng-grid/ng-grid.d.ts @@ -1,23 +1,358 @@ // Type definitions for ng-grid // Project: http://angular-ui.github.io/ng-grid/ -// Definitions by: Ken Smith +// Definitions by: Ken Smith and Roland Zwaga and Kent Cooper // DefinitelyTyped: https://github.com/borisyankov/DefinitelyTyped // These are very definitely preliminary. Please feel free to improve. +// Changelog: +// 25/4/2014: Added interfaces for all classes and services + +/// + declare class ngGridReorderable { constructor(); } +declare var ngStyleProvider:ngGrid.IStyleProviderStatic; +declare var ngSearchProvider:ngGrid.ISearchProviderStatic; +declare var ngSelectionProvider:ngGrid.ISelectionProviderStatic; +declare var ngEventProvider:ngGrid.IEventProviderStatic; +declare var ngAggregate:ngGrid.IAggregateStatic; +declare var ngRenderedRange:ngGrid.IRenderedRangeStatic; +declare var ngDimension:ngGrid.IDimensionStatic; +declare var ngRow:ngGrid.IRowStatic; +declare var ngColumn:ngGrid.IColumnStatic; +declare var ngFooter:ngGrid.IFooterStatic; + declare module ngGrid { + export interface IDomAccessProvider { + previousColumn:IColumn; + grid:IGridInstance; + changeUserSelect(elm:ng.IAugmentedJQuery, value:string):void; + focusCellElement($scope:IGridScope, index:number):void; + selectionHandlers($scope:IGridScope, elm:ng.IAugmentedJQuery):void; + } + + export interface IStyleProviderStatic { + new($scope:IGridScope, grid:IGridInstance):IStyleProvider; + } + + export interface IStyleProvider { + } + + export interface ISearchProviderStatic { + new($scope:IGridScope, grid:IGridInstance, $filter:ng.IFilterService):ISearchProvider; + } + + export interface ISearchProvider { + fieldMap:any; + extFilter:boolean; + evalFilter():void; + } + + export interface ISelectionProviderStatic { + new(grid:IGridInstance, $scope:IGridScope, $parse:ng.IParseService):ISelectionProvider; + } + + export interface ISelectionProvider { + multi:boolean; + selectedItems:any[]; + selectedIndex:number; + lastClickedRow:any; + ignoreSelectedItemChanges:boolean; + pKeyParser:ng.ICompiledExpression; + ChangeSelection(rowItem:any, event:any):void; + getSelection(entity:any):number; + getSelectionIndex(entity:any):number; + setSelection(rowItem:IRow, isSelected:boolean):void; + toggleSelectAll(checkAll:boolean, bypass:boolean, selectFiltered:boolean):void; + } + + export interface IEventProviderStatic { + new(grid:IGridInstance, $scope:IGridScope, domUtilityService:service.IDomUtilityService, $timeout:ng.ITimeoutService):IEventProvider; + } + + export interface IEventProvider { + colToMove:IColumn; + groupToMove:any; + assignEvents():void; + assignGridEventHandlers():void; + dragStart(event:any):void; + dragOver(event:any):void; + setDraggables():void; + onGroupMouseDown(event:any):void; + onGroupDrop(event:any):void; + onHeaderMouseDown(event:any):void; + onHeaderDrop(event:any):void; + } + + export interface IAggregateStatic { + new(aggEntity:any, rowFactory:IRowFactory, rowHeight:number, groupInitState:boolean):IAggregate; + } + + export interface IAggregate { + rowIndex:number; + offsetTop:number; + entity:any; + label:string; + field:string; + depth:number; + parent:any; + children:any[]; + aggChildren:any[]; + aggIndex:number; + collapsed:boolean; + groupInitState:boolean; + rowFactory:IRowFactory; + rowHeight:number; + isAggRow:boolean; + offsetLeft:number; + aggLabelFilter:any; + } + + export interface IRowConfig { + enableCellSelection:boolean; + enableRowSelection:boolean; + jqueryUITheme:boolean; + rowClasses:string[]; + rowHeight:number; + selectWithCheckboxOnly:boolean; + selectedItems:any[]; + + afterSelectionChangeCallback():void; + beforeSelectionChangeCallback():void; + } + + export interface IRenderedRangeStatic { + new(top:number, bottom:number):IRenderedRange; + } + + export interface IRenderedRange { + bottomRow:number; + topRow:number; + } + + export interface IRowFactory { + aggCache:any; + dataChanged:boolean; + groupedData:any; + numberOfAggregates:number; + parentCache:any[]; + parsedData:any[]; + renderedRange:IRenderedRange; + rowConfig:IRowConfig; + rowHeight:number; + selectionProvider:ISelectionProvider; + + UpdateViewableRange(newRange:IRenderedRange):void; + buildAggregateRow(aggEntity:any, rowIndex:number):IAggregate; + buildEntityRow(entity:any, rowIndex:number):IRow; + filteredRowsChanged():void; + fixRowCache():void; + getGrouping(groups:any):void; + parseGroupData(groupData:any):void; + renderedChange():void; + renderedChangeNoGroups():void; + } + + export interface IDimensionStatic { + new(options:any):IDimension; + } + + export interface IDimension { + outerHeight?:number; + outerWidth?:number; + autoFitHeight?:boolean; + } + + export interface IElementDimension { + rootMaxH?:number; + rootMaxW?:number; + rowIndexCellW?:number; + rowSelectedCellW?:number; + scrollH?:number; + scrollW?:number; + } + + export interface IRowStatic { + new(entity:any, config:IRowConfig, selectionProvider:ISelectionProvider, rowIndex:number, $utils:any):IRow; + } + + export interface IRow { + entity:any; + config:IRowConfig; + selectionProvider:ISelectionProvider; + rowIndex:number; + utils:any; + selected:boolean; + cursor:string; + offsetTop:number; + rowDisplayIndex:number; + afterSelectionChange():void; + beforeSelectionChange():void; + setSelection(isSelected:boolean):void; + continueSelection(event:any):void; + ensureEntity(expected:any):void; + toggleSelected(event:any):boolean; + alternatingRowClass():void; + getProperty(path:string):any; + copy():IRow; + setVars(fromRow:IRow):void; + } + + export interface IColumnStatic { + new(config:IGridOptions, $scope:IGridScope, grid:IGridInstance, domUtilityService:service.IDomUtilityService, $templateCache:ng.ITemplateCacheService, $utils:any):IColumn; + } + + export interface IColumn { + colDef:IColumnDef; + width:number; + groupIndex:number; + isGroupedBy:boolean; + minWidth:number; + maxWidth:number; + enableCellEdit:boolean; + cellEditableCondition:any; + headerRowHeight:number; + displayName:string; + index:number; + isAggCol:boolean; + cellClass:string; + sortPriority:number; + cellFilter:any; + field:string; + aggLabelFilter:any; + visible:boolean; + sortable:boolean; + resizable:boolean; + pinnable:boolean; + pinned:boolean; + originalIndex:number; + groupable:boolean; + sortDirection:string; + sortingAlgorithm:Function; + headerClass:string; + cursor:string; + headerCellTemplate:string; + cellTemplate:string; + groupedByClass():string; + toggleVisible():void; + showSortButtonUp():boolean; + showSortButtonDown():boolean; + noSortVisible():boolean; + sort(event:any):boolean; + gripClick():any; + gripOnMouseDown(event:any):any; + onMouseMove(event:any):void; + gripOnMouseUp(event:any):void; + copy():IColumn; + setVars(fromCol:IColumn):void; + } + + export interface IGridScope extends ng.IScope { + elementsNeedMeasuring:boolean; + columns:any[]; + renderedRows:any[]; + renderedColumns:any[]; + headerRow:any; + rowHeight:number; + jqueryUITheme:any; + showSelectionCheckbox:boolean; + enableCellSelection:boolean; + enableCellEditOnFocus:boolean; + footer:IFooter; + selectedItems:any[]; + multiSelect:boolean; + showFooter:boolean; + footerRowHeight:number; + showColumnMenu:boolean; + forceSyncScrolling:boolean; + showMenu:boolean; + configGroups:any[]; + gridId:string; + enablePaging:boolean; + pagingOptions:IPagingOptions; + i18n:any; + selectionProvider:ISelectionProvider; + adjustScrollLeft(scrollLeft:number):void; + adjustScrollTop(scrollTop:number, force:boolean):void; + toggleShowMenu():void; + toggleSelectAll():void; + totalFilteredItemsLength():number; + showGroupPanel():any; + topPanelHeight():number; + viewportDimHeight():number; + groupBy(col:IColumn):void; + removeGroup(index:number):void; + togglePin(col:IColumn):void; + totalRowWidth():number; + headerScrollerDim():any; + } + + export interface IGridInstance { + $canvas:ng.IAugmentedJQuery; + $viewport:ng.IAugmentedJQuery; + $groupPanel:ng.IAugmentedJQuery; + $footerPanel:ng.IAugmentedJQuery; + $headerScroller:ng.IAugmentedJQuery; + $headerContainer:ng.IAugmentedJQuery; + $headers:ng.IAugmentedJQuery; + $topPanel:ng.IAugmentedJQuery; + $root:ng.IAugmentedJQuery; + config:IGridOptions; + data:any; + elementDims:IElementDimension; + eventProvider:IEventProvider; + filteredRows:IRow[]; + footerController:any; + gridId:string; + lastSortedColumns:IColumn[]; + lateBindColumns:boolean; + maxCanvasHt:number; + prevScrollIndex:number; + prevScrollTop:number; + rootDim:IDimension; + rowCache:IRow[]; + rowFactory:IRowFactory; + rowMap:IRow[]; + searchProvider:ISearchProvider; + styleProvider:IStyleProvider; + + buildColumnDefsFromData():void; + buildColumns():void; + calcMaxCanvasHeight():void; + clearSortingData():void; + configureColumnWidths():void; + fixColumnIndexes():void; + fixGroupIndexes():void; + getTemplate(key:string):ng.IPromise; + init():ng.IPromise; + initTemplates():ng.IPromise; + minRowsToRender():void; + refreshDomSizes():void; + resizeOnData(col:IColumn):void; + setRenderedRows(newRows:IRow[]):void; + sortActual():void; + sortColumnsInit():void; + sortData(col:IColumn, event:any):void; + } + + export interface IFooterStatic { + new($scope:IGridScope, grid:IGridInstance):IFooter; + } + + export interface IFooter { + } + export interface IGridOptions { /** Define an aggregate template to customize the rows when grouped. See github wiki for more details. */ aggregateTemplate?: string; /** Callback for when you want to validate something after selection. */ - afterSelectionChange?: (rowItem?: any, event?: any) => void ; + afterSelectionChange?: (rowItem?: IRow, event?: any) => void ; /** Callback if you want to inspect something before selection, return false if you want to cancel the selection. return true otherwise. @@ -25,7 +360,7 @@ declare module ngGrid { use rowItem.changeSelection(event) method after returning false initially. Note: when shift+ Selecting multiple items in the grid this will only get called once and the rowItem will be an array of items that are queued to be selected. */ - beforeSelectionChange?: (rowItem?: any, event?: any) => boolean ; + beforeSelectionChange?: (rowItem?: IRow, event?: any) => boolean ; /** checkbox templates. */ checkboxCellTemplate?: string; @@ -176,11 +511,68 @@ declare module ngGrid { } export interface IColumnDef { + /** + * This can be an absolute numberor it can also be defined in percentages (20%, 30%), + * in weighted *s, or "auto" (which sizes the column based on data length) + * (much like WPF/Silverlight)/ note: "auto" only works in single page apps currently because the re-size + * happens on "document.ready + */ + width?: any; + + /** The minum width the column is allowed to be. See width for the different options */ + minWidth?: any; + + /** Set the default visiblity of the column */ + visible?: boolean; + + /** Can also be a property path on your data model. "foo.bar.myField", "Name.First", etc..*/ field?: string; - width?: any; //**this can be a string containing a relatively, absolute size units or a number: '30%','54px',45 /* + + /** What to display in the column header */ displayName?: string; - cellTemplate?: string; + + /** Restrict or allow the column to be sorted */ + sortable?: boolean; + + /** Restrict or allow the column to be resized */ + resizable?: boolean; + + /** Allows the column to be grouped with drag and drop, but has no effect on gridOptions.groups */ + groupable?: boolean; + + /** Allows the column to be pinned when enablePinning is set to true */ + pinnable?: boolean; + + /** The template to use while editing */ + editableCellTemplate?: string; + + /** Allows the cell to use an edit template when focused (grid option enableCellSelection must be enabled)*/ enableCellEdit?: boolean; + + /** Controls when to use the edit template on per-row basis using an angular expression (enableCellEdit must also be true for editing)*/ + cellEditableCondition?: string; + + /** The funtion to use when filtering values in this column */ + sortFn?: (a: any, b: any) => number; + + /** Html template used to render the cell */ + cellTemplate?: string; + + /** User defined CSS class name */ + cellClass?: string; + + /** User defined CSS class name for the header cell */ + headerClass?: string; + + /** Html template used to render the header cell */ + headerCellTemplate?: string; + + /** string name for filter to use on the cell ('currency', 'date', etc..) */ + cellFilter?: string; + + /** String name for filter to use on the aggregate label ('currency', 'date', etc..) defaults to cellFilter if not set. */ + aggLabelFilter?: string; + pinned?: boolean; } @@ -199,4 +591,60 @@ declare module ngGrid { /** currentPage: the uhm... current page. */ currentPage?: number; } + + export interface IPlugin { + init(childScope:IGridScope, gridInstance:IGridInstance, services:any):void; + } + + export module service { + + export interface IDomUtilityService { + eventStorage:any; + numberOfGrids:number; + immediate:number; + AssignGridContainers($scope:IGridScope, rootel:ng.IAugmentedJQuery, grid:IGridInstance):void; + getRealWidth(obj:IDimension):number; + UpdateGridLayout($scope:IGridScope, grid:IGridInstance):void; + setStyleText(grid:IGridInstance, css:string):void; + BuildStyles($scope:IGridScope, grid:IGridInstance, digest:boolean):void; + setColLeft(col:IColumn, colLeft:number, grid:IGridInstance):void; + RebuildGrid($scope:IGridScope, grid:IGridInstance):void; + digest($scope:IGridScope):void; + ScrollH:number; + ScrollW:number; + LetterW:number; + } + + export interface ISortInfo { + fields:string[]; + } + + export interface ISortService { + colSortFnCache:any; + isCustomSort:boolean; + isSorting:boolean; + guessSortFn(item:any):(a:any, b:any)=>number; + basicSort(a:any, b:any):number; + sortNumber(a:number, b:number):number; + sortNumberStr(a:string, b:string):number; + sortAlpha(a:string, b:string):number; + sortDate(a:Date, b:Date):number; + sortBool(a:boolean, b:boolean):number; + sortData(sortInfo:ISortInfo, data:any):void; + Sort(sortInfo:ISortInfo, data:any):void; + getSortFn(col:IColumn, data:any):(a:any, b:any)=>number; + } + + export interface IUtilityService { + visualLength(node:any):number; + forIn(obj:any, action:(value:any, property:string)=>{}):void; + evalProperty(entity:any, path:string):any; + endsWith(str:string, suffix:string):boolean; + isNullOrUndefined(obj:any):boolean; + getElementsByClassName(cl:string):any[]; + newId():string; + seti18n($scope:IGridScope, language:string):void; + getInstanceType(o:any):string; + } + } }