ag-grid

ag-grid

Version 18.1.2
Published 6 years ago
12.6 MB
No dependencies
MIT license

Install

npm i ag-grid

yarn add ag-grid

pnpm add ag-grid

Overview

Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components

Index

Functions

function Autowired

Autowired: (name?: string) => Function;

function Bean

Bean: (beanName: string) => Function;

function defaultGroupComparator

defaultGroupComparator: (
    valueA: any,
    valueB: any,
    nodeA: RowNode,
    nodeB: RowNode,
    accentedCompare?: boolean
) => number;

function initialiseAgGridWithAngular1

initialiseAgGridWithAngular1: (angular: any) => void;

function initialiseAgGridWithWebComponents

initialiseAgGridWithWebComponents: () => void;

function Listener

Listener: (eventName?: string) => Function;

function Optional

Optional: (name?: string) => Function;

function PostConstruct

PostConstruct: (
    target: Object,
    methodName: string,
    descriptor: TypedPropertyDescriptor<any>
) => void;

function PreConstruct

PreConstruct: (
    target: Object,
    methodName: string,
    descriptor: TypedPropertyDescriptor<any>
) => void;

function PreDestroy

PreDestroy: (
    target: Object,
    methodName: string,
    descriptor: TypedPropertyDescriptor<any>
) => void;

function Qualifier

Qualifier: (name: string) => Function;

function QuerySelector

QuerySelector: (selector?: string) => Function;

function RefSelector

RefSelector: (ref?: string) => Function;

function simpleHttpRequest

simpleHttpRequest: (params: SimpleHttpRequestParams) => Promise<any>;

Classes

class AgCheckbox

class AgCheckbox extends Component {}

constructor

constructor();

property EVENT_CHANGED

static EVENT_CHANGED: string;

method getNextValue

getNextValue: () => boolean;

method isReadOnly

isReadOnly: () => boolean;

method isSelected

isSelected: () => boolean;

method setPassive

setPassive: (passive: boolean) => void;

method setReadOnly

setReadOnly: (readOnly: boolean) => void;

method setSelected

setSelected: (selected: boolean) => void;

method toggle

toggle: () => void;

class AlignedGridsService

class AlignedGridsService {}

method getColumnIds

getColumnIds: (event: ColumnEvent) => string[];

method getMasterColumns

getMasterColumns: (event: ColumnEvent) => Column[];

method init

init: () => void;

method onColumnEvent

onColumnEvent: (event: AgEvent) => void;

method registerGridComp

registerGridComp: (gridPanel: GridPanel) => void;

class AnimateShowChangeCellRenderer

class AnimateShowChangeCellRenderer extends Component implements ICellRenderer {}

constructor

constructor();

method init

init: (params: any) => void;

method refresh

refresh: (params: any) => boolean;

class AnimateSlideCellRenderer

class AnimateSlideCellRenderer extends Component implements ICellRenderer {}

constructor

constructor();

method addSlideAnimation

addSlideAnimation: () => void;

method init

init: (params: any) => void;

method refresh

refresh: (params: any) => boolean;

class AutoWidthCalculator

class AutoWidthCalculator {}

method getPreferredWidthForColumn

getPreferredWidthForColumn: (column: Column) => number;

method registerGridComp

registerGridComp: (gridPanel: GridPanel) => void;

method registerHeaderRootComp

registerHeaderRootComp: (headerRootComp: HeaderRootComp) => void;

class BalancedColumnTreeBuilder

class BalancedColumnTreeBuilder {}

method createBalancedColumnGroups

createBalancedColumnGroups: (
    abstractColDefs: (ColDef | ColGroupDef)[],
    primaryColumns: boolean
) => any;

method createForAutoGroups

createForAutoGroups: (
    autoGroupCols: Column[],
    gridBalancedTree: OriginalColumnGroupChild[]
) => OriginalColumnGroupChild[];

method mergeColDefs

mergeColDefs: (colDef: ColDef) => ColDef;

class BaseComponentWrapper

abstract class BaseComponentWrapper<F extends WrapableInterface>
    implements FrameworkComponentWrapper {}

method createWrapper

abstract createWrapper: (
    OriginalConstructor: { new (): any },
    componentName?: string
) => F;

method wrap

wrap: <A extends IComponent<any>>(
    OriginalConstructor: { new (): any },
    mandatoryMethodList: string[],
    optionalMethodList?: string[],
    componentName?: string
) => A;

class BaseCreator

abstract class BaseCreator<
    T,
    S extends GridSerializingSession<T>,
    P extends ExportParams<T>
> {}

method createSerializingSession

abstract createSerializingSession: (params?: P) => S;

method export

export: (userParams?: P) => string;

method getData

getData: (params: P) => string;

method getDefaultFileExtension

abstract getDefaultFileExtension: () => string;

method getDefaultFileName

abstract getDefaultFileName: () => string;

method getMimeType

abstract getMimeType: () => string;

method isExportSuppressed

abstract isExportSuppressed: () => boolean;

method setBeans

protected setBeans: (beans: BaseCreatorBeans) => void;

class BaseFilter

abstract class BaseFilter<T, P extends IFilterParams, M>
    extends Component
    implements IFilterComp {}

T(ype) The type of this filter. ie in DateFilter T=Date P(arams) The params that this filter can take M(model getModel/setModel) The object that this filter serializes to F Floating filter params
Contains common logic to ALL filters.. Translation, apply and clear button get/setModel context wiring....

property applyActive

applyActive: boolean;

property clearActive

clearActive: boolean;

property conditionValue

conditionValue: string;

property CONTAINS

static CONTAINS: string;

property context

context: Context;

property defaultFilter

defaultFilter: string;

property ENDS_WITH

static ENDS_WITH: string;

property EQUALS

static EQUALS: string;

property filter

filter: string;

property filterCondition

filterCondition: string;

property filterParams

filterParams: IFilterParams;

property GREATER_THAN

static GREATER_THAN: string;

property GREATER_THAN_OR_EQUAL

static GREATER_THAN_OR_EQUAL: string;

property gridOptionsWrapper

gridOptionsWrapper: GridOptionsWrapper;

property IN_RANGE

static IN_RANGE: string;

property LESS_THAN

static LESS_THAN: string;

property LESS_THAN_OR_EQUAL

static LESS_THAN_OR_EQUAL: string;

property NOT_CONTAINS

static NOT_CONTAINS: string;

property NOT_EQUAL

static NOT_EQUAL: string;

property STARTS_WITH

static STARTS_WITH: string;

method acceptsBooleanLogic

acceptsBooleanLogic: () => boolean;

method bodyTemplate

abstract bodyTemplate: (type: FilterConditionType) => string;

method customInit

abstract customInit: () => void;

method doesFilterPass

abstract doesFilterPass: (params: IDoesFilterPassParams) => boolean;

method floatingFilter

floatingFilter: (from: string) => void;

method generateFilterHeader

generateFilterHeader: (type: FilterConditionType) => string;

method getDebounceMs

getDebounceMs: (filterParams: ITextFilterParams | INumberFilterParams) => number;

method getModel

getModel: () => M | CombinedFilter<M>;

method getNullableModel

getNullableModel: () => M | CombinedFilter<M>;

method init

init: (params: P) => void;

method initialiseFilterBodyUi

abstract initialiseFilterBodyUi: (type: FilterConditionType) => void;

method isFilterActive

abstract isFilterActive: () => boolean;

method isFilterConditionActive

abstract isFilterConditionActive: (type: FilterConditionType) => boolean;

method modelFromFloatingFilter

abstract modelFromFloatingFilter: (from: string) => M;

method onClearButton

onClearButton: () => void;

method onFilterChanged

onFilterChanged: (applyNow?: boolean) => void;

method onFloatingFilterChanged

onFloatingFilterChanged: (change: FloatingFilterChange) => boolean;

method onNewRowsLoaded

onNewRowsLoaded: () => void;

method parse

abstract parse: (toParse: M, type: FilterConditionType) => void;

method refreshFilterBodyUi

abstract refreshFilterBodyUi: (type: FilterConditionType) => void;

method resetState

abstract resetState: () => void;

method serialize

abstract serialize: (type: FilterConditionType) => M;

method setModel

setModel: (model: M | CombinedFilter<M>) => void;

method translate

translate: (toTranslate: string) => string;

method wrapCondition

wrapCondition: (mainCondition: string) => string;

class BaseFrameworkFactory

class BaseFrameworkFactory implements IFrameworkFactory {}

The base frameworks, eg React & Angular 2, override this bean with implementations specific to their requirement.

method colDefCellEditor

colDefCellEditor: (colDef: ColDef) => { new (): ICellEditorComp } | string;

method colDefCellRenderer

colDefCellRenderer: (
    colDef: ColDef
) => { new (): ICellRendererComp } | ICellRendererFunc | string;

method colDefFilter

colDefFilter: (colDef: ColDef) => { new (): IFilterComp } | string;

method colDefFloatingCellRenderer

colDefFloatingCellRenderer: (
    colDef: ColDef
) => { new (): ICellRendererComp } | ICellRendererFunc | string;

method dateComponent

dateComponent: (gridOptions: GridOptions) => { new (): IDateComp };

method gridOptionsFullWidthCellRenderer

gridOptionsFullWidthCellRenderer: (
    gridOptions: GridOptions
) => { new (): ICellRendererComp } | ICellRendererFunc | string;

method gridOptionsGroupRowInnerRenderer

gridOptionsGroupRowInnerRenderer: (
    gridOptions: GridOptions
) => { new (): ICellRendererComp } | ICellRendererFunc | string;

method gridOptionsGroupRowRenderer

gridOptionsGroupRowRenderer: (
    gridOptions: GridOptions
) => { new (): ICellRendererComp } | ICellRendererFunc | string;

method setTimeout

setTimeout: (action: any, timeout?: any) => void;

class BaseGridSerializingSession

abstract class BaseGridSerializingSession<T> implements GridSerializingSession<T> {}

constructor

constructor(
    columnController: ColumnController,
    valueService: ValueService,
    gridOptionsWrapper: GridOptionsWrapper,
    processCellCallback?: (params: ProcessCellForExportParams) => string,
    processHeaderCallback?: (params: ProcessHeaderForExportParams) => string,
    cellAndHeaderEscaper?: (rawValue: string) => string
);

property cellAndHeaderEscaper

cellAndHeaderEscaper: (rawValue: string) => string;

property columnController

columnController: ColumnController;

property gridOptionsWrapper

gridOptionsWrapper: GridOptionsWrapper;

property processCellCallback

processCellCallback: (params: ProcessCellForExportParams) => string;

property processHeaderCallback

processHeaderCallback: (params: ProcessHeaderForExportParams) => string;

property valueService

valueService: ValueService;

method addCustomFooter

abstract addCustomFooter: (customFooter: T) => void;

method addCustomHeader

abstract addCustomHeader: (customHeader: T) => void;

method extractHeaderValue

extractHeaderValue: (column: Column) => string;

method extractRowCellValue

extractRowCellValue: (
    column: Column,
    index: number,
    type: string,
    node?: RowNode
) => any;

method onNewBodyRow

abstract onNewBodyRow: () => RowAccumulator;

method onNewHeaderGroupingRow

abstract onNewHeaderGroupingRow: () => RowSpanningAccumulator;

method onNewHeaderRow

abstract onNewHeaderRow: () => RowAccumulator;

method parse

abstract parse: () => string;

method prepare

abstract prepare: (columnsToExport: Column[]) => void;

class BeanStub

class BeanStub implements IEventEmitter {}

property EVENT_DESTROYED

static EVENT_DESTROYED: string;

method addDestroyableEventListener

addDestroyableEventListener: (
    eElement: Window | HTMLElement | IEventEmitter | GridOptionsWrapper,
    event: string,
    listener: (event?: any) => void
) => void;

method addDestroyFunc

addDestroyFunc: (func: () => void) => void;

method addEventListener

addEventListener: (eventType: string, listener: Function) => void;

method destroy

destroy: () => void;

method dispatchEvent

dispatchEvent: <T extends AgEvent>(event: T) => void;

method dispatchEventAsync

dispatchEventAsync: (event: AgEvent) => void;

method isAlive

isAlive: () => boolean;

method removeEventListener

removeEventListener: (eventType: string, listener: Function) => void;

class BodyDropPivotTarget

class BodyDropPivotTarget implements DropListener {}

constructor

constructor(pinned: string);

method getIconName

getIconName: () => string;

method onDragEnter

onDragEnter: (draggingEvent: DraggingEvent) => void;

Callback for when drag enters

method onDragging

onDragging: (draggingEvent: DraggingEvent) => void;

Callback for when dragging

method onDragLeave

onDragLeave: (draggingEvent: DraggingEvent) => void;

Callback for when drag leaves

method onDragStop

onDragStop: (draggingEvent: DraggingEvent) => void;

Callback for when drag stops

class BodyDropTarget

class BodyDropTarget implements DropTarget {}

constructor

constructor(pinned: string, eContainer: HTMLElement);

method getContainer

getContainer: () => HTMLElement;

method getIconName

getIconName: () => string;

method getSecondaryContainers

getSecondaryContainers: () => HTMLElement[];

method isInterestedIn

isInterestedIn: (type: DragSourceType) => boolean;

method onDragEnter

onDragEnter: (draggingEvent: DraggingEvent) => void;

method onDragging

onDragging: (params: DraggingEvent) => void;

method onDragLeave

onDragLeave: (params: DraggingEvent) => void;

method onDragStop

onDragStop: (params: DraggingEvent) => void;

method registerGridComp

registerGridComp: (gridPanel: GridPanel) => void;

class CellComp

class CellComp extends Component {}

constructor

constructor(
    scope: any,
    beans: Beans,
    column: Column,
    rowNode: RowNode,
    rowComp: RowComp,
    autoHeightCell: boolean
);

property DOM_DATA_KEY_CELL_COMP

static DOM_DATA_KEY_CELL_COMP: string;

method afterAttached

afterAttached: () => void;

method attemptCellRendererRefresh

attemptCellRendererRefresh: () => boolean;

method destroy

destroy: () => void;

method detach

detach: () => void;

method dispatchCellContextMenuEvent

dispatchCellContextMenuEvent: (event: Event) => void;

method doesUserWantToCancelKeyboardEvent

doesUserWantToCancelKeyboardEvent: (event: KeyboardEvent) => boolean;

method flashCell

flashCell: () => void;

method focusCell

focusCell: (forceBrowserFocus?: boolean) => void;

method getCellEditor

getCellEditor: () => ICellEditorComp;

method getCellRenderer

getCellRenderer: () => ICellRendererComp;

method getColumn

getColumn: () => Column;

method getCreateTemplate

getCreateTemplate: () => string;

method getGridCell

getGridCell: () => GridCell;

method getInitialValueToRender

getInitialValueToRender: () => string;

method getParentRow

getParentRow: () => HTMLElement;

method getRenderedRow

getRenderedRow: () => RowComp;

method isCellEditable

isCellEditable: () => boolean;

method isEditing

isEditing: () => boolean;

method isSuppressNavigable

isSuppressNavigable: () => boolean;

method onKeyDown

onKeyDown: (event: KeyboardEvent) => void;

method onKeyPress

onKeyPress: (event: KeyboardEvent) => void;

method onMouseEvent

onMouseEvent: (eventName: string, mouseEvent: MouseEvent) => void;

method refreshCell

refreshCell: (params?: {
    suppressFlash?: boolean;
    newData?: boolean;
    forceRefresh?: boolean;
}) => void;

method setFocusInOnEditor

setFocusInOnEditor: () => void;

method setFocusOutOnEditor

setFocusOutOnEditor: () => void;

method setParentRow

setParentRow: (eParentRow: HTMLElement) => void;

method setUsingWrapper

setUsingWrapper: () => void;

method startEditingIfEnabled

startEditingIfEnabled: (
    keyPress?: number,
    charPress?: string,
    cellStartedEdit?: boolean
) => void;

method startRowOrCellEdit

startRowOrCellEdit: (keyPress?: number, charPress?: string) => void;

method stopEditing

stopEditing: (cancel?: boolean) => void;

method stopRowOrCellEdit

stopRowOrCellEdit: (cancel?: boolean) => void;

class CellEditorFactory

class CellEditorFactory {}

method addCellEditor

addCellEditor: (key: string, cellEditor: { new (): ICellEditorComp }) => void;

method createCellEditor

createCellEditor: (
    column: ColDef,
    params: ICellEditorParams
) => Promise<ICellEditorComp>;

class CellNavigationService

class CellNavigationService {}

method getNextCellToFocus

getNextCellToFocus: (key: any, lastCellToFocus: GridCell) => GridCell;

method getNextTabbedCell

getNextTabbedCell: (gridCell: GridCell, backwards: boolean) => GridCell;

method getNextTabbedCellBackwards

getNextTabbedCellBackwards: (gridCell: GridCell) => GridCell;

method getNextTabbedCellForwards

getNextTabbedCellForwards: (gridCell: GridCell) => GridCell;

method getRowBelow

getRowBelow: (lastRow: GridRow) => GridRow;

class CellRendererFactory

class CellRendererFactory {}

property ANIMATE_SHOW_CHANGE

static ANIMATE_SHOW_CHANGE: string;

property ANIMATE_SLIDE

static ANIMATE_SLIDE: string;

property GROUP

static GROUP: string;

method addCellRenderer

addCellRenderer: (
    key: string,
    cellRenderer: { new (): ICellRenderer } | ICellRendererFunc
) => void;

method getCellRenderer

getCellRenderer: (key: string) => { new (): ICellRenderer } | ICellRendererFunc;

class CellRendererService

class CellRendererService {}

Class to use a cellRenderer.

method bindToHtml

bindToHtml: (
    cellRendererPromise: Promise<ICellRendererComp>,
    eTarget: HTMLElement
) => Promise<ICellRendererComp>;

method useCellRenderer

useCellRenderer: (
    target: ColDef,
    eTarget: HTMLElement,
    params: any
) => Promise<ICellRendererComp>;

method useFilterCellRenderer

useFilterCellRenderer: (
    target: ColDef,
    eTarget: HTMLElement,
    params: any
) => Promise<ICellRendererComp>;

method useFullWidthGroupRowInnerCellRenderer

useFullWidthGroupRowInnerCellRenderer: (
    eTarget: HTMLElement,
    params: any
) => Promise<ICellRendererComp>;

method useInnerCellRenderer

useInnerCellRenderer: (
    target: GroupCellRendererParams,
    originalColumn: ColDef,
    eTarget: HTMLElement,
    params: any
) => Promise<ICellRendererComp>;

method useRichSelectCellRenderer

useRichSelectCellRenderer: (
    target: ColDef,
    eTarget: HTMLElement,
    params: any
) => Promise<ICellRendererComp>;

class ChangedPath

class ChangedPath {}

constructor

constructor(keepingColumns: boolean);

method addParentNode

addParentNode: (rowNode: RowNode, columns?: Column[]) => void;

method getNotValueColumnsForNode

getNotValueColumnsForNode: (
    rowNode: RowNode,
    valueColumns: Column[]
) => Column[];

method getValueColumnsForNode

getValueColumnsForNode: (rowNode: RowNode, valueColumns: Column[]) => Column[];

method isActive

isActive: () => boolean;

method isInPath

isInPath: (rowNode: RowNode) => boolean;

method setInactive

setInactive: () => void;

class CheckboxSelectionComponent

class CheckboxSelectionComponent extends Component {}

constructor

constructor();

method init

init: (params: any) => void;

class ClientSideNodeManager

class ClientSideNodeManager {}

constructor

constructor(
    rootNode: RowNode,
    gridOptionsWrapper: GridOptionsWrapper,
    context: Context,
    eventService: EventService,
    columnController: ColumnController,
    gridApi: GridApi,
    columnApi: ColumnApi,
    selectionController: SelectionController
);

method addItems

addItems: (items: any) => RowNode[];

method getCopyOfNodesMap

getCopyOfNodesMap: () => { [id: string]: RowNode };

method getRowNode

getRowNode: (id: string) => RowNode;

method insertItemsAtIndex

insertItemsAtIndex: (index: number, rowData: any[]) => RowNode[];

method isLegacyTreeData

isLegacyTreeData: () => boolean;

method postConstruct

postConstruct: () => void;

method setRowData

setRowData: (rowData: any[]) => RowNode[];

method updateRowData

updateRowData: (
    rowDataTran: RowDataTransaction,
    rowNodeOrder: { [id: string]: number }
) => RowNodeTransaction;

class ClientSideRowModel

class ClientSideRowModel {}

method batchUpdateRowData

batchUpdateRowData: (
    rowDataTransaction: RowDataTransaction,
    callback?: (res: RowNodeTransaction) => void
) => void;

method doAggregate

doAggregate: (changedPath?: ChangedPath) => void;

method ensureRowAtPixel

ensureRowAtPixel: (rowNode: RowNode, pixel: number) => boolean;

method expandOrCollapseAll

expandOrCollapseAll: (expand: boolean) => void;

method forEachLeafNode

forEachLeafNode: (callback: Function) => void;

method forEachNode

forEachNode: (callback: Function) => void;

method forEachNodeAfterFilter

forEachNodeAfterFilter: (callback: Function) => void;

method forEachNodeAfterFilterAndSort

forEachNodeAfterFilterAndSort: (callback: Function) => void;

method forEachPivotNode

forEachPivotNode: (callback: Function) => void;

method getCopyOfNodesMap

getCopyOfNodesMap: () => { [id: string]: RowNode };

method getCurrentPageHeight

getCurrentPageHeight: () => number;

method getNodesInRangeForSelection

getNodesInRangeForSelection: (
    firstInRange: RowNode,
    lastInRange: RowNode
) => RowNode[];

method getPageFirstRow

getPageFirstRow: () => number;

method getPageLastRow

getPageLastRow: () => number;

method getRootNode

getRootNode: () => RowNode;

method getRow

getRow: (index: number) => RowNode;

method getRowBounds

getRowBounds: (index: number) => RowBounds;

method getRowCount

getRowCount: () => number;

method getRowIndexAtPixel

getRowIndexAtPixel: (pixelToMatch: number) => number;

method getRowNode

getRowNode: (id: string) => RowNode;

method getTopLevelNodes

getTopLevelNodes: () => RowNode[];

method getType

getType: () => string;

method getVirtualRowCount

getVirtualRowCount: () => number;

method init

init: () => void;

method isEmpty

isEmpty: () => boolean;

method isLastRowFound

isLastRowFound: () => boolean;

method isRowPresent

isRowPresent: (rowNode: RowNode) => boolean;

method isRowsToRender

isRowsToRender: () => boolean;

method onRowHeightChanged

onRowHeightChanged: () => void;

method refreshModel

refreshModel: (params: RefreshModelParams) => void;

method resetRowHeights

resetRowHeights: () => void;

method setDatasource

setDatasource: (datasource: any) => void;

method setRowData

setRowData: (rowData: any[]) => void;

method updateRowData

updateRowData: (
    rowDataTran: RowDataTransaction,
    rowNodeOrder?: { [id: string]: number }
) => RowNodeTransaction;

class ColDefUtil

class ColDefUtil {}

property ALL_PROPERTIES

static ALL_PROPERTIES: string[];

property ARRAY_PROPERTIES

static ARRAY_PROPERTIES: string[];

property BOOLEAN_PROPERTIES

static BOOLEAN_PROPERTIES: string[];

property FRAMEWORK_PROPERTIES

static FRAMEWORK_PROPERTIES: string[];

property FUNCTION_PROPERTIES

static FUNCTION_PROPERTIES: string[];

property NUMBER_PROPERTIES

static NUMBER_PROPERTIES: string[];

property OBJECT_PROPERTIES

static OBJECT_PROPERTIES: string[];

property STRING_PROPERTIES

static STRING_PROPERTIES: string[];

class Column

class Column implements ColumnGroupChild, OriginalColumnGroupChild, IEventEmitter {}

constructor

constructor(colDef: ColDef, colId: string, primary: boolean);

property EVENT_FILTER_ACTIVE_CHANGED

static EVENT_FILTER_ACTIVE_CHANGED: string;

property EVENT_FILTER_CHANGED

static EVENT_FILTER_CHANGED: string;

property EVENT_FIRST_RIGHT_PINNED_CHANGED

static EVENT_FIRST_RIGHT_PINNED_CHANGED: string;

ag-grid

Install

Overview

Index

Functions

Classes

Interfaces

Enums

Type Aliases

Functions

function Autowired

function Bean

function defaultGroupComparator

function initialiseAgGridWithAngular1

function initialiseAgGridWithWebComponents

function Listener

function Optional

function PostConstruct

function PreConstruct

function PreDestroy

function Qualifier

function QuerySelector

function RefSelector

function simpleHttpRequest

Classes

class AgCheckbox

constructor

property EVENT_CHANGED

method getNextValue

method isReadOnly

method isSelected

method setPassive

method setReadOnly

method setSelected

method toggle

class AlignedGridsService

method getColumnIds

method getMasterColumns

method init

method onColumnEvent

method registerGridComp

class AnimateShowChangeCellRenderer

constructor

method init

method refresh

class AnimateSlideCellRenderer

constructor

method addSlideAnimation

method init

method refresh

class AutoWidthCalculator

method getPreferredWidthForColumn

method registerGridComp

method registerHeaderRootComp

class BalancedColumnTreeBuilder

method createBalancedColumnGroups

method createForAutoGroups

method mergeColDefs

class BaseComponentWrapper

method createWrapper

method wrap

class BaseCreator

method createSerializingSession

method export

method getData

method getDefaultFileExtension

method getDefaultFileName

method getMimeType

method isExportSuppressed

method setBeans

class BaseFilter

property applyActive

property clearActive

property conditionValue

property CONTAINS

property context

property defaultFilter

property ENDS_WITH

property EQUALS

property filter