';
// wrapping in outer div, and wrapper, is needed to center the loading icon
// The idea for centering came from here: http://www.vanseodesign.com/css/vertical-centering/
var mainOverlayTemplate = '
' +
'
[OVERLAY_TEMPLATE]
' +
'
';
var defaultLoadingOverlayTemplate = '[LOADING...]';
var defaultNoRowsOverlayTemplate = '[NO_ROWS_TO_SHOW]';
var GridPanel = (function () {
function GridPanel() {
this.scrollLagCounter = 0;
this.lastLeftPosition = -1;
this.lastTopPosition = -1;
this.animationThreadCount = 0;
}
GridPanel.prototype.agWire = function (loggerFactory) {
// makes code below more readable if we pull 'forPrint' out
this.forPrint = this.gridOptionsWrapper.isForPrint();
this.scrollWidth = utils_1.Utils.getScrollbarWidth();
this.logger = loggerFactory.create('GridPanel');
this.findElements();
};
GridPanel.prototype.onRowDataChanged = function () {
if (this.rowModel.isEmpty() && !this.gridOptionsWrapper.isSuppressNoRowsOverlay()) {
this.showNoRowsOverlay();
}
else {
this.hideOverlay();
}
};
GridPanel.prototype.getLayout = function () {
return this.layout;
};
GridPanel.prototype.init = function () {
this.addEventListeners();
this.addDragListeners();
this.layout = new borderLayout_1.BorderLayout({
overlays: {
loading: utils_1.Utils.loadTemplate(this.createLoadingOverlayTemplate()),
noRows: utils_1.Utils.loadTemplate(this.createNoRowsOverlayTemplate())
},
center: this.eRoot,
dontFill: this.forPrint,
name: 'eGridPanel'
});
this.layout.addSizeChangeListener(this.sizeHeaderAndBody.bind(this));
this.addScrollListener();
if (this.gridOptionsWrapper.isSuppressHorizontalScroll()) {
this.eBodyViewport.style.overflowX = 'hidden';
}
if (this.gridOptionsWrapper.isRowModelDefault() && !this.gridOptionsWrapper.getRowData()) {
this.showLoadingOverlay();
}
this.setWidthsOfContainers();
this.showPinnedColContainersIfNeeded();
this.sizeHeaderAndBody();
this.disableBrowserDragging();
this.addShortcutKeyListeners();
this.addCellListeners();
};
// if we do not do this, then the user can select a pic in the grid (eg an image in a custom cell renderer)
// and then that will start the browser native drag n' drop, which messes up with our own drag and drop.
GridPanel.prototype.disableBrowserDragging = function () {
this.eRoot.addEventListener('dragstart', function (event) {
if (event.target instanceof HTMLImageElement) {
event.preventDefault();
return false;
}
});
};
GridPanel.prototype.addEventListeners = function () {
this.eventService.addEventListener(events_1.Events.EVENT_COLUMN_EVERYTHING_CHANGED, this.onColumnsChanged.bind(this));
this.eventService.addEventListener(events_1.Events.EVENT_COLUMN_GROUP_OPENED, this.onColumnsChanged.bind(this));
this.eventService.addEventListener(events_1.Events.EVENT_COLUMN_MOVED, this.onColumnsChanged.bind(this));
this.eventService.addEventListener(events_1.Events.EVENT_COLUMN_ROW_GROUP_CHANGE, this.onColumnsChanged.bind(this));
this.eventService.addEventListener(events_1.Events.EVENT_COLUMN_RESIZED, this.onColumnsChanged.bind(this));
//this.eventService.addEventListener(Events.EVENT_COLUMN_VALUE_CHANGE, this.onColumnsChanged.bind(this));
this.eventService.addEventListener(events_1.Events.EVENT_COLUMN_VISIBLE, this.onColumnsChanged.bind(this));
this.eventService.addEventListener(events_1.Events.EVENT_COLUMN_PINNED, this.onColumnsChanged.bind(this));
this.eventService.addEventListener(events_1.Events.EVENT_FLOATING_ROW_DATA_CHANGED, this.sizeHeaderAndBody.bind(this));
this.eventService.addEventListener(events_1.Events.EVENT_HEADER_HEIGHT_CHANGED, this.sizeHeaderAndBody.bind(this));
this.eventService.addEventListener(events_1.Events.EVENT_ROW_DATA_CHANGED, this.onRowDataChanged.bind(this));
};
GridPanel.prototype.addDragListeners = function () {
var _this = this;
if (this.forPrint // no range select when doing 'for print'
|| !this.gridOptionsWrapper.isEnableRangeSelection() // no range selection if no property
|| utils_1.Utils.missing(this.rangeController)) {
return;
}
var containers = [this.ePinnedLeftColsContainer, this.ePinnedRightColsContainer, this.eBodyContainer,
this.eFloatingTop, this.eFloatingBottom];
containers.forEach(function (container) {
_this.dragService.addDragSource({
dragStartPixels: 0,
eElement: container,
onDragStart: _this.rangeController.onDragStart.bind(_this.rangeController),
onDragStop: _this.rangeController.onDragStop.bind(_this.rangeController),
onDragging: _this.rangeController.onDragging.bind(_this.rangeController)
});
});
};
GridPanel.prototype.addCellListeners = function () {
var _this = this;
var eventNames = ['click', 'mousedown', 'dblclick', 'contextmenu'];
var that = this;
eventNames.forEach(function (eventName) {
_this.eAllCellContainers.forEach(function (container) {
return container.addEventListener(eventName, function (mouseEvent) {
var eventSource = this;
that.processMouseEvent(eventName, mouseEvent, eventSource);
});
});
});
};
GridPanel.prototype.processMouseEvent = function (eventName, mouseEvent, eventSource) {
var cell = this.mouseEventService.getCellForMouseEvent(mouseEvent);
if (utils_1.Utils.exists(cell)) {
//console.log(`row = ${cell.rowIndex}, floating = ${floating}`);
this.rowRenderer.onMouseEvent(eventName, mouseEvent, eventSource, cell);
}
};
GridPanel.prototype.addShortcutKeyListeners = function () {
var _this = this;
this.eAllCellContainers.forEach(function (container) {
container.addEventListener('keydown', function (event) {
if (event.ctrlKey || event.metaKey) {
switch (event.which) {
case constants_1.Constants.KEY_A: return _this.onCtrlAndA(event);
case constants_1.Constants.KEY_C: return _this.onCtrlAndC(event);
case constants_1.Constants.KEY_V: return _this.onCtrlAndV(event);
}
}
});
});
};
GridPanel.prototype.onCtrlAndA = function (event) {
if (this.rangeController && this.rowModel.isRowsToRender()) {
var rowEnd;
var floatingStart;
var floatingEnd;
if (this.floatingRowModel.isEmpty(constants_1.Constants.FLOATING_TOP)) {
floatingStart = null;
}
else {
floatingStart = constants_1.Constants.FLOATING_TOP;
}
if (this.floatingRowModel.isEmpty(constants_1.Constants.FLOATING_BOTTOM)) {
floatingEnd = null;
rowEnd = this.rowModel.getRowCount() - 1;
}
else {
floatingEnd = constants_1.Constants.FLOATING_BOTTOM;
rowEnd = this.floatingRowModel.getFloatingBottomRowData().length = 1;
}
var allDisplayedColumns = this.columnController.getAllDisplayedColumns();
if (utils_1.Utils.missingOrEmpty(allDisplayedColumns)) {
return;
}
this.rangeController.setRange({
rowStart: 0,
floatingStart: floatingStart,
rowEnd: rowEnd,
floatingEnd: floatingEnd,
columnStart: allDisplayedColumns[0],
columnEnd: allDisplayedColumns[allDisplayedColumns.length - 1]
});
}
event.preventDefault();
return false;
};
GridPanel.prototype.onCtrlAndC = function (event) {
if (!this.clipboardService) {
return;
}
this.clipboardService.copyToClipboard();
event.preventDefault();
return false;
};
GridPanel.prototype.onCtrlAndV = function (event) {
if (!this.clipboardService) {
return;
}
this.clipboardService.pasteFromClipboard();
//event.preventDefault();
return false;
};
GridPanel.prototype.getPinnedLeftFloatingTop = function () {
return this.ePinnedLeftFloatingTop;
};
GridPanel.prototype.getPinnedRightFloatingTop = function () {
return this.ePinnedRightFloatingTop;
};
GridPanel.prototype.getFloatingTopContainer = function () {
return this.eFloatingTopContainer;
};
GridPanel.prototype.getPinnedLeftFloatingBottom = function () {
return this.ePinnedLeftFloatingBottom;
};
GridPanel.prototype.getPinnedRightFloatingBottom = function () {
return this.ePinnedRightFloatingBottom;
};
GridPanel.prototype.getFloatingBottomContainer = function () {
return this.eFloatingBottomContainer;
};
GridPanel.prototype.createOverlayTemplate = function (name, defaultTemplate, userProvidedTemplate) {
var template = mainOverlayTemplate
.replace('[OVERLAY_NAME]', name);
if (userProvidedTemplate) {
template = template.replace('[OVERLAY_TEMPLATE]', userProvidedTemplate);
}
else {
template = template.replace('[OVERLAY_TEMPLATE]', defaultTemplate);
}
return template;
};
GridPanel.prototype.createLoadingOverlayTemplate = function () {
var userProvidedTemplate = this.gridOptionsWrapper.getOverlayLoadingTemplate();
var templateNotLocalised = this.createOverlayTemplate('loading', defaultLoadingOverlayTemplate, userProvidedTemplate);
var localeTextFunc = this.gridOptionsWrapper.getLocaleTextFunc();
var templateLocalised = templateNotLocalised.replace('[LOADING...]', localeTextFunc('loadingOoo', 'Loading...'));
return templateLocalised;
};
GridPanel.prototype.createNoRowsOverlayTemplate = function () {
var userProvidedTemplate = this.gridOptionsWrapper.getOverlayNoRowsTemplate();
var templateNotLocalised = this.createOverlayTemplate('no-rows', defaultNoRowsOverlayTemplate, userProvidedTemplate);
var localeTextFunc = this.gridOptionsWrapper.getLocaleTextFunc();
var templateLocalised = templateNotLocalised.replace('[NO_ROWS_TO_SHOW]', localeTextFunc('noRowsToShow', 'No Rows To Show'));
return templateLocalised;
};
GridPanel.prototype.ensureIndexVisible = function (index) {
this.logger.log('ensureIndexVisible: ' + index);
var lastRow = this.rowModel.getRowCount();
if (typeof index !== 'number' || index < 0 || index >= lastRow) {
console.warn('invalid row index for ensureIndexVisible: ' + index);
return;
}
var nodeAtIndex = this.rowModel.getRow(index);
var rowTopPixel = nodeAtIndex.rowTop;
var rowBottomPixel = rowTopPixel + nodeAtIndex.rowHeight;
var viewportTopPixel = this.eBodyViewport.scrollTop;
var viewportHeight = this.eBodyViewport.offsetHeight;
var scrollShowing = this.isHorizontalScrollShowing();
if (scrollShowing) {
viewportHeight -= this.scrollWidth;
}
var viewportBottomPixel = viewportTopPixel + viewportHeight;
var viewportScrolledPastRow = viewportTopPixel > rowTopPixel;
var viewportScrolledBeforeRow = viewportBottomPixel < rowBottomPixel;
var eViewportToScroll = this.columnController.isPinningRight() ? this.ePinnedRightColsViewport : this.eBodyViewport;
if (viewportScrolledPastRow) {
// if row is before, scroll up with row at top
eViewportToScroll.scrollTop = rowTopPixel;
}
else if (viewportScrolledBeforeRow) {
// if row is below, scroll down with row at bottom
var newScrollPosition = rowBottomPixel - viewportHeight;
eViewportToScroll.scrollTop = newScrollPosition;
}
// otherwise, row is already in view, so do nothing
};
// + moveColumnController
GridPanel.prototype.getCenterWidth = function () {
return this.eBodyViewport.clientWidth;
};
GridPanel.prototype.isHorizontalScrollShowing = function () {
var result = this.eBodyViewport.clientWidth < this.eBodyViewport.scrollWidth;
return result;
};
GridPanel.prototype.isVerticalScrollShowing = function () {
if (this.columnController.isPinningRight()) {
// if pinning right, then the scroll bar can show, however for some reason
// it overlays the grid and doesn't take space.
return false;
}
else {
return this.eBodyViewport.clientHeight < this.eBodyViewport.scrollHeight;
}
};
// gets called every 500 ms. we use this to set padding on right pinned column
GridPanel.prototype.periodicallyCheck = function () {
if (this.columnController.isPinningRight()) {
var bodyHorizontalScrollShowing = this.eBodyViewport.clientWidth < this.eBodyViewport.scrollWidth;
if (bodyHorizontalScrollShowing) {
this.ePinnedRightColsContainer.style.marginBottom = this.scrollWidth + 'px';
}
else {
this.ePinnedRightColsContainer.style.marginBottom = '';
}
}
};
GridPanel.prototype.ensureColumnVisible = function (key) {
var column = this.columnController.getColumn(key);
if (column.isPinned()) {
console.warn('calling ensureIndexVisible on a ' + column.getPinned() + ' pinned column doesn\'t make sense for column ' + column.getColId());
return;
}
if (!this.columnController.isColumnDisplayed(column)) {
console.warn('column is not currently visible');
return;
}
var colLeftPixel = column.getLeft();
var colRightPixel = colLeftPixel + column.getActualWidth();
var viewportLeftPixel = this.eBodyViewport.scrollLeft;
var viewportWidth = this.eBodyViewport.offsetWidth;
var scrollShowing = this.eBodyViewport.clientHeight < this.eBodyViewport.scrollHeight;
if (scrollShowing) {
viewportWidth -= this.scrollWidth;
}
var viewportRightPixel = viewportLeftPixel + viewportWidth;
var viewportScrolledPastCol = viewportLeftPixel > colLeftPixel;
var viewportScrolledBeforeCol = viewportRightPixel < colRightPixel;
if (viewportScrolledPastCol) {
// if viewport's left side is after col's left side, scroll right to pull col into viewport at left
this.eBodyViewport.scrollLeft = colLeftPixel;
}
else if (viewportScrolledBeforeCol) {
// if viewport's right side is before col's right side, scroll left to pull col into viewport at right
var newScrollPosition = colRightPixel - viewportWidth;
this.eBodyViewport.scrollLeft = newScrollPosition;
}
// otherwise, col is already in view, so do nothing
};
GridPanel.prototype.showLoadingOverlay = function () {
if (!this.gridOptionsWrapper.isSuppressLoadingOverlay()) {
this.layout.showOverlay('loading');
}
};
GridPanel.prototype.showNoRowsOverlay = function () {
if (!this.gridOptionsWrapper.isSuppressNoRowsOverlay()) {
this.layout.showOverlay('noRows');
}
};
GridPanel.prototype.hideOverlay = function () {
this.layout.hideOverlay();
};
GridPanel.prototype.getWidthForSizeColsToFit = function () {
var availableWidth = this.eBody.clientWidth;
var scrollShowing = this.isVerticalScrollShowing();
if (scrollShowing) {
availableWidth -= this.scrollWidth;
}
return availableWidth;
};
// method will call itself if no available width. this covers if the grid
// isn't visible, but is just about to be visible.
GridPanel.prototype.sizeColumnsToFit = function (nextTimeout) {
var _this = this;
var availableWidth = this.getWidthForSizeColsToFit();
if (availableWidth > 0) {
this.columnController.sizeColumnsToFit(availableWidth);
}
else {
if (nextTimeout === undefined) {
setTimeout(function () {
_this.sizeColumnsToFit(100);
}, 0);
}
else if (nextTimeout === 100) {
setTimeout(function () {
_this.sizeColumnsToFit(-1);
}, 100);
}
else {
console.log('ag-Grid: tried to call sizeColumnsToFit() but the grid is coming back with ' +
'zero width, maybe the grid is not visible yet on the screen?');
}
}
};
GridPanel.prototype.getBodyContainer = function () {
return this.eBodyContainer;
};
GridPanel.prototype.getDropTargetBodyContainers = function () {
if (this.forPrint) {
return [this.eBodyContainer, this.eFloatingTopContainer, this.eFloatingBottomContainer];
}
else {
return [this.eBodyViewport, this.eFloatingTopViewport, this.eFloatingBottomViewport];
}
};
GridPanel.prototype.getBodyViewport = function () {
return this.eBodyViewport;
};
GridPanel.prototype.getPinnedLeftColsContainer = function () {
return this.ePinnedLeftColsContainer;
};
GridPanel.prototype.getDropTargetLeftContainers = function () {
if (this.forPrint) {
return [];
}
else {
return [this.ePinnedLeftColsViewport, this.ePinnedLeftFloatingBottom, this.ePinnedLeftFloatingTop];
}
};
GridPanel.prototype.getPinnedRightColsContainer = function () {
return this.ePinnedRightColsContainer;
};
GridPanel.prototype.getDropTargetPinnedRightContainers = function () {
if (this.forPrint) {
return [];
}
else {
return [this.ePinnedRightColsViewport, this.ePinnedRightFloatingBottom, this.ePinnedRightFloatingTop];
}
};
GridPanel.prototype.getHeaderContainer = function () {
return this.eHeaderContainer;
};
GridPanel.prototype.getHeaderOverlay = function () {
return this.eHeaderOverlay;
};
GridPanel.prototype.getRoot = function () {
return this.eRoot;
};
GridPanel.prototype.getPinnedLeftHeader = function () {
return this.ePinnedLeftHeader;
};
GridPanel.prototype.getPinnedRightHeader = function () {
return this.ePinnedRightHeader;
};
GridPanel.prototype.queryHtmlElement = function (selector) {
return this.eRoot.querySelector(selector);
};
GridPanel.prototype.findElements = function () {
if (this.forPrint) {
this.eRoot = utils_1.Utils.loadTemplate(gridForPrintHtml);
utils_1.Utils.addCssClass(this.eRoot, 'ag-root');
utils_1.Utils.addCssClass(this.eRoot, 'ag-font-style');
utils_1.Utils.addCssClass(this.eRoot, 'ag-no-scrolls');
}
else {
this.eRoot = utils_1.Utils.loadTemplate(gridHtml);
utils_1.Utils.addCssClass(this.eRoot, 'ag-root');
utils_1.Utils.addCssClass(this.eRoot, 'ag-font-style');
utils_1.Utils.addCssClass(this.eRoot, 'ag-scrolls');
}
if (this.forPrint) {
this.eHeaderContainer = this.queryHtmlElement('.ag-header-container');
this.eBodyContainer = this.queryHtmlElement('.ag-body-container');
this.eFloatingTopContainer = this.queryHtmlElement('.ag-floating-top-container');
this.eFloatingBottomContainer = this.queryHtmlElement('.ag-floating-bottom-container');
this.eAllCellContainers = [this.eBodyContainer, this.eFloatingTopContainer, this.eFloatingBottomContainer];
}
else {
this.eBody = this.queryHtmlElement('.ag-body');
this.eBodyContainer = this.queryHtmlElement('.ag-body-container');
this.eBodyViewport = this.queryHtmlElement('.ag-body-viewport');
this.eBodyViewportWrapper = this.queryHtmlElement('.ag-body-viewport-wrapper');
this.ePinnedLeftColsContainer = this.queryHtmlElement('.ag-pinned-left-cols-container');
this.ePinnedRightColsContainer = this.queryHtmlElement('.ag-pinned-right-cols-container');
this.ePinnedLeftColsViewport = this.queryHtmlElement('.ag-pinned-left-cols-viewport');
this.ePinnedRightColsViewport = this.queryHtmlElement('.ag-pinned-right-cols-viewport');
this.ePinnedLeftHeader = this.queryHtmlElement('.ag-pinned-left-header');
this.ePinnedRightHeader = this.queryHtmlElement('.ag-pinned-right-header');
this.eHeader = this.queryHtmlElement('.ag-header');
this.eHeaderContainer = this.queryHtmlElement('.ag-header-container');
this.eHeaderOverlay = this.queryHtmlElement('.ag-header-overlay');
this.eHeaderViewport = this.queryHtmlElement('.ag-header-viewport');
this.eFloatingTop = this.queryHtmlElement('.ag-floating-top');
this.ePinnedLeftFloatingTop = this.queryHtmlElement('.ag-pinned-left-floating-top');
this.ePinnedRightFloatingTop = this.queryHtmlElement('.ag-pinned-right-floating-top');
this.eFloatingTopContainer = this.queryHtmlElement('.ag-floating-top-container');
this.eFloatingTopViewport = this.queryHtmlElement('.ag-floating-top-viewport');
this.eFloatingBottom = this.queryHtmlElement('.ag-floating-bottom');
this.ePinnedLeftFloatingBottom = this.queryHtmlElement('.ag-pinned-left-floating-bottom');
this.ePinnedRightFloatingBottom = this.queryHtmlElement('.ag-pinned-right-floating-bottom');
this.eFloatingBottomContainer = this.queryHtmlElement('.ag-floating-bottom-container');
this.eFloatingBottomViewport = this.queryHtmlElement('.ag-floating-bottom-viewport');
this.eAllCellContainers = [this.ePinnedLeftColsContainer, this.ePinnedRightColsContainer, this.eBodyContainer,
this.eFloatingTop, this.eFloatingBottom];
// IE9, Chrome, Safari, Opera
this.ePinnedLeftColsViewport.addEventListener('mousewheel', this.pinnedLeftMouseWheelListener.bind(this));
this.eBodyViewport.addEventListener('mousewheel', this.centerMouseWheelListener.bind(this));
// Firefox
this.ePinnedLeftColsViewport.addEventListener('DOMMouseScroll', this.pinnedLeftMouseWheelListener.bind(this));
this.eBodyViewport.addEventListener('DOMMouseScroll', this.centerMouseWheelListener.bind(this));
}
};
GridPanel.prototype.getHeaderViewport = function () {
return this.eHeaderViewport;
};
GridPanel.prototype.centerMouseWheelListener = function (event) {
// we are only interested in mimicking the mouse wheel if we are pinning on the right,
// as if we are not pinning on the right, then we have scrollbars in the center body, and
// as such we just use the default browser wheel behaviour.
if (this.columnController.isPinningRight()) {
return this.generalMouseWheelListener(event, this.ePinnedRightColsViewport);
}
};
GridPanel.prototype.pinnedLeftMouseWheelListener = function (event) {
var targetPanel;
if (this.columnController.isPinningRight()) {
targetPanel = this.ePinnedRightColsViewport;
}
else {
targetPanel = this.eBodyViewport;
}
return this.generalMouseWheelListener(event, targetPanel);
};
GridPanel.prototype.generalMouseWheelListener = function (event, targetPanel) {
var wheelEvent = utils_1.Utils.normalizeWheel(event);
// we need to detect in which direction scroll is happening to allow trackpads scroll horizontally
// horizontal scroll
if (Math.abs(wheelEvent.pixelX) > Math.abs(wheelEvent.pixelY)) {
var newLeftPosition = this.eBodyViewport.scrollLeft + wheelEvent.pixelX;
this.eBodyViewport.scrollLeft = newLeftPosition;
}
else {
var newTopPosition = this.eBodyViewport.scrollTop + wheelEvent.pixelY;
targetPanel.scrollTop = newTopPosition;
}
// if we don't prevent default, then the whole browser will scroll also as well as the grid
event.preventDefault();
return false;
};
GridPanel.prototype.onColumnsChanged = function (event) {
if (event.isContainerWidthImpacted()) {
this.setWidthsOfContainers();
}
if (event.isPinnedPanelVisibilityImpacted()) {
this.showPinnedColContainersIfNeeded();
}
if (event.getType() === events_1.Events.EVENT_COLUMN_EVERYTHING_CHANGED) {
this.sizeHeaderAndBody();
}
};
GridPanel.prototype.setWidthsOfContainers = function () {
this.logger.log('setWidthsOfContainers()');
this.showPinnedColContainersIfNeeded();
var mainRowWidth = this.columnController.getBodyContainerWidth() + 'px';
this.eBodyContainer.style.width = mainRowWidth;
if (this.forPrint) {
// pinned col doesn't exist when doing forPrint
return;
}
this.eFloatingBottomContainer.style.width = mainRowWidth;
this.eFloatingTopContainer.style.width = mainRowWidth;
var pinnedLeftWidth = this.columnController.getPinnedLeftContainerWidth() + 'px';
this.ePinnedLeftColsContainer.style.width = pinnedLeftWidth;
this.ePinnedLeftFloatingBottom.style.width = pinnedLeftWidth;
this.ePinnedLeftFloatingTop.style.width = pinnedLeftWidth;
this.eBodyViewportWrapper.style.marginLeft = pinnedLeftWidth;
var pinnedRightWidth = this.columnController.getPinnedRightContainerWidth() + 'px';
this.ePinnedRightColsContainer.style.width = pinnedRightWidth;
this.ePinnedRightFloatingBottom.style.width = pinnedRightWidth;
this.ePinnedRightFloatingTop.style.width = pinnedRightWidth;
this.eBodyViewportWrapper.style.marginRight = pinnedRightWidth;
};
GridPanel.prototype.showPinnedColContainersIfNeeded = function () {
// no need to do this if not using scrolls
if (this.forPrint) {
return;
}
//some browsers had layout issues with the blank divs, so if blank,
//we don't display them
if (this.columnController.isPinningLeft()) {
this.ePinnedLeftHeader.style.display = 'inline-block';
this.ePinnedLeftColsViewport.style.display = 'inline';
}
else {
this.ePinnedLeftHeader.style.display = 'none';
this.ePinnedLeftColsViewport.style.display = 'none';
}
if (this.columnController.isPinningRight()) {
this.ePinnedRightHeader.style.display = 'inline-block';
this.ePinnedRightColsViewport.style.display = 'inline';
this.eBodyViewport.style.overflowY = 'hidden';
}
else {
this.ePinnedRightHeader.style.display = 'none';
this.ePinnedRightColsViewport.style.display = 'none';
this.eBodyViewport.style.overflowY = 'auto';
}
};
GridPanel.prototype.sizeHeaderAndBody = function () {
if (this.forPrint) {
// if doing 'for print', then the header and footers are laid
// out naturally by the browser. it whatever size that's needed to fit.
return;
}
var heightOfContainer = this.layout.getCentreHeight();
if (!heightOfContainer) {
return;
}
var headerHeight = this.gridOptionsWrapper.getHeaderHeight();
var numberOfRowsInHeader = this.columnController.getHeaderRowCount();
var totalHeaderHeight = headerHeight * numberOfRowsInHeader;
this.eHeader.style['height'] = totalHeaderHeight + 'px';
// padding top covers the header and the floating rows on top
var floatingTopHeight = this.floatingRowModel.getFloatingTopTotalHeight();
var paddingTop = totalHeaderHeight + floatingTopHeight;
// bottom is just the bottom floating rows
var floatingBottomHeight = this.floatingRowModel.getFloatingBottomTotalHeight();
var floatingBottomTop = heightOfContainer - floatingBottomHeight;
var heightOfCentreRows = heightOfContainer - totalHeaderHeight - floatingBottomHeight - floatingTopHeight;
this.eBody.style.paddingTop = paddingTop + 'px';
this.eBody.style.paddingBottom = floatingBottomHeight + 'px';
this.eFloatingTop.style.top = totalHeaderHeight + 'px';
this.eFloatingTop.style.height = floatingTopHeight + 'px';
this.eFloatingBottom.style.height = floatingBottomHeight + 'px';
this.eFloatingBottom.style.top = floatingBottomTop + 'px';
this.ePinnedLeftColsViewport.style.height = heightOfCentreRows + 'px';
this.ePinnedRightColsViewport.style.height = heightOfCentreRows + 'px';
};
GridPanel.prototype.setHorizontalScrollPosition = function (hScrollPosition) {
this.eBodyViewport.scrollLeft = hScrollPosition;
};
// tries to scroll by pixels, but returns what the result actually was
GridPanel.prototype.scrollHorizontally = function (pixels) {
var oldScrollPosition = this.eBodyViewport.scrollLeft;
this.setHorizontalScrollPosition(oldScrollPosition + pixels);
var newScrollPosition = this.eBodyViewport.scrollLeft;
return newScrollPosition - oldScrollPosition;
};
GridPanel.prototype.getHorizontalScrollPosition = function () {
if (this.forPrint) {
return 0;
}
else {
return this.eBodyViewport.scrollLeft;
}
};
GridPanel.prototype.turnOnAnimationForABit = function () {
var _this = this;
if (this.gridOptionsWrapper.isSuppressColumnMoveAnimation()) {
return;
}
this.animationThreadCount++;
var animationThreadCountCopy = this.animationThreadCount;
utils_1.Utils.addCssClass(this.eRoot, 'ag-column-moving');
setTimeout(function () {
if (_this.animationThreadCount === animationThreadCountCopy) {
utils_1.Utils.removeCssClass(_this.eRoot, 'ag-column-moving');
}
}, 300);
};
GridPanel.prototype.addScrollListener = function () {
var _this = this;
// if printing, then no scrolling, so no point in listening for scroll events
if (this.forPrint) {
return;
}
this.eBodyViewport.addEventListener('scroll', function () {
// we are always interested in horizontal scrolls of the body
var newLeftPosition = _this.eBodyViewport.scrollLeft;
if (newLeftPosition !== _this.lastLeftPosition) {
_this.lastLeftPosition = newLeftPosition;
_this.horizontallyScrollHeaderCenterAndFloatingCenter();
_this.masterSlaveService.fireHorizontalScrollEvent(newLeftPosition);
}
// if we are pinning to the right, then it's the right pinned container
// that has the scroll.
if (!_this.columnController.isPinningRight()) {
var newTopPosition = _this.eBodyViewport.scrollTop;
if (newTopPosition !== _this.lastTopPosition) {
_this.lastTopPosition = newTopPosition;
_this.verticallyScrollLeftPinned(newTopPosition);
_this.requestDrawVirtualRows();
}
}
});
this.ePinnedRightColsViewport.addEventListener('scroll', function () {
var newTopPosition = _this.ePinnedRightColsViewport.scrollTop;
if (newTopPosition !== _this.lastTopPosition) {
_this.lastTopPosition = newTopPosition;
_this.verticallyScrollLeftPinned(newTopPosition);
_this.verticallyScrollBody(newTopPosition);
_this.requestDrawVirtualRows();
}
});
// this means the pinned panel was moved, which can only
// happen when the user is navigating in the pinned container
// as the pinned col should never scroll. so we rollback
// the scroll on the pinned.
this.ePinnedLeftColsViewport.addEventListener('scroll', function () {
_this.ePinnedLeftColsViewport.scrollTop = 0;
});
};
GridPanel.prototype.requestDrawVirtualRows = function () {
var _this = this;
// if we are in IE or Safari, then we only redraw if there was no scroll event
// in the 50ms following this scroll event. without this, these browsers have
// a bad scrolling feel, where the redraws clog the scroll experience
// (makes the scroll clunky and sticky). this method is like throttling
// the scroll events.
var useScrollLag;
// let the user override scroll lag option
if (this.gridOptionsWrapper.isSuppressScrollLag()) {
useScrollLag = false;
}
else if (this.gridOptionsWrapper.getIsScrollLag()) {
useScrollLag = this.gridOptionsWrapper.getIsScrollLag()();
}
else {
useScrollLag = utils_1.Utils.isBrowserIE() || utils_1.Utils.isBrowserSafari();
}
if (useScrollLag) {
this.scrollLagCounter++;
var scrollLagCounterCopy = this.scrollLagCounter;
setTimeout(function () {
if (_this.scrollLagCounter === scrollLagCounterCopy) {
_this.rowRenderer.drawVirtualRows();
}
}, 50);
}
else {
this.rowRenderer.drawVirtualRows();
}
};
GridPanel.prototype.horizontallyScrollHeaderCenterAndFloatingCenter = function () {
var bodyLeftPosition = this.eBodyViewport.scrollLeft;
this.eHeaderContainer.style.left = -bodyLeftPosition + 'px';
this.eFloatingBottomContainer.style.left = -bodyLeftPosition + 'px';
this.eFloatingTopContainer.style.left = -bodyLeftPosition + 'px';
};
GridPanel.prototype.verticallyScrollLeftPinned = function (bodyTopPosition) {
this.ePinnedLeftColsContainer.style.top = -bodyTopPosition + 'px';
};
GridPanel.prototype.verticallyScrollBody = function (position) {
this.eBodyViewport.scrollTop = position;
};
GridPanel.prototype.getVerticalScrollPosition = function () {
if (this.forPrint) {
return 0;
}
else {
return this.eBodyViewport.scrollTop;
}
};
GridPanel.prototype.getBodyViewportClientRect = function () {
if (this.forPrint) {
return this.eBodyContainer.getBoundingClientRect();
}
else {
return this.eBodyViewport.getBoundingClientRect();
}
};
GridPanel.prototype.getFloatingTopClientRect = function () {
if (this.forPrint) {
return this.eFloatingTopContainer.getBoundingClientRect();
}
else {
return this.eFloatingTop.getBoundingClientRect();
}
};
GridPanel.prototype.getFloatingBottomClientRect = function () {
if (this.forPrint) {
return this.eFloatingBottomContainer.getBoundingClientRect();
}
else {
return this.eFloatingBottom.getBoundingClientRect();
}
};
GridPanel.prototype.getPinnedLeftColsViewportClientRect = function () {
return this.ePinnedLeftColsViewport.getBoundingClientRect();
};
GridPanel.prototype.getPinnedRightColsViewportClientRect = function () {
return this.ePinnedRightColsViewport.getBoundingClientRect();
};
GridPanel.prototype.addScrollEventListener = function (listener) {
this.eBodyViewport.addEventListener('scroll', listener);
};
GridPanel.prototype.removeScrollEventListener = function (listener) {
this.eBodyViewport.removeEventListener('scroll', listener);
};
__decorate([
context_3.Autowired('masterSlaveService'),
__metadata('design:type', masterSlaveService_1.MasterSlaveService)
], GridPanel.prototype, "masterSlaveService", void 0);
__decorate([
context_3.Autowired('gridOptionsWrapper'),
__metadata('design:type', gridOptionsWrapper_1.GridOptionsWrapper)
], GridPanel.prototype, "gridOptionsWrapper", void 0);
__decorate([
context_3.Autowired('columnController'),
__metadata('design:type', columnController_1.ColumnController)
], GridPanel.prototype, "columnController", void 0);
__decorate([
context_3.Autowired('rowRenderer'),
__metadata('design:type', rowRenderer_1.RowRenderer)
], GridPanel.prototype, "rowRenderer", void 0);
__decorate([
context_3.Autowired('floatingRowModel'),
__metadata('design:type', floatingRowModel_1.FloatingRowModel)
], GridPanel.prototype, "floatingRowModel", void 0);
__decorate([
context_3.Autowired('eventService'),
__metadata('design:type', eventService_1.EventService)
], GridPanel.prototype, "eventService", void 0);
__decorate([
context_3.Autowired('rowModel'),
__metadata('design:type', Object)
], GridPanel.prototype, "rowModel", void 0);
__decorate([
context_5.Optional('rangeController'),
__metadata('design:type', Object)
], GridPanel.prototype, "rangeController", void 0);
__decorate([
context_3.Autowired('dragService'),
__metadata('design:type', dragService_1.DragService)
], GridPanel.prototype, "dragService", void 0);
__decorate([
context_3.Autowired('selectionController'),
__metadata('design:type', selectionController_1.SelectionController)
], GridPanel.prototype, "selectionController", void 0);
__decorate([
context_5.Optional('clipboardService'),
__metadata('design:type', Object)
], GridPanel.prototype, "clipboardService", void 0);
__decorate([
context_3.Autowired('csvCreator'),
__metadata('design:type', csvCreator_1.CsvCreator)
], GridPanel.prototype, "csvCreator", void 0);
__decorate([
context_3.Autowired('mouseEventService'),
__metadata('design:type', mouseEventService_1.MouseEventService)
], GridPanel.prototype, "mouseEventService", void 0);
__decorate([
__param(0, context_2.Qualifier('loggerFactory')),
__metadata('design:type', Function),
__metadata('design:paramtypes', [logger_1.LoggerFactory]),
__metadata('design:returntype', void 0)
], GridPanel.prototype, "agWire", null);
__decorate([
context_4.PostConstruct,
__metadata('design:type', Function),
__metadata('design:paramtypes', []),
__metadata('design:returntype', void 0)
], GridPanel.prototype, "init", null);
GridPanel = __decorate([
context_1.Bean('gridPanel'),
__metadata('design:paramtypes', [])
], GridPanel);
return GridPanel;
})();
exports.GridPanel = GridPanel;
/***/ },
/* 25 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
var gridOptionsWrapper_1 = __webpack_require__(3);
var columnController_1 = __webpack_require__(13);
var gridPanel_1 = __webpack_require__(24);
var eventService_1 = __webpack_require__(4);
var logger_1 = __webpack_require__(5);
var events_1 = __webpack_require__(10);
var context_1 = __webpack_require__(6);
var context_2 = __webpack_require__(6);
var context_3 = __webpack_require__(6);
var context_4 = __webpack_require__(6);
var MasterSlaveService = (function () {
function MasterSlaveService() {
// flag to mark if we are consuming. to avoid cyclic events (ie slave firing back to master
// while processing a master event) we mark this if consuming an event, and if we are, then
// we don't fire back any events.
this.consuming = false;
}
MasterSlaveService.prototype.agWire = function (loggerFactory) {
this.logger = loggerFactory.create('MasterSlaveService');
};
MasterSlaveService.prototype.init = function () {
this.eventService.addEventListener(events_1.Events.EVENT_COLUMN_MOVED, this.fireColumnEvent.bind(this));
this.eventService.addEventListener(events_1.Events.EVENT_COLUMN_VISIBLE, this.fireColumnEvent.bind(this));
this.eventService.addEventListener(events_1.Events.EVENT_COLUMN_PINNED, this.fireColumnEvent.bind(this));
this.eventService.addEventListener(events_1.Events.EVENT_COLUMN_GROUP_OPENED, this.fireColumnEvent.bind(this));
this.eventService.addEventListener(events_1.Events.EVENT_COLUMN_RESIZED, this.fireColumnEvent.bind(this));
};
// common logic across all the fire methods
MasterSlaveService.prototype.fireEvent = function (callback) {
// if we are already consuming, then we are acting on an event from a master,
// so we don't cause a cyclic firing of events
if (this.consuming) {
return;
}
// iterate through the slave grids, and pass each slave service to the callback
var slaveGrids = this.gridOptionsWrapper.getSlaveGrids();
if (slaveGrids) {
slaveGrids.forEach(function (slaveGridOptions) {
if (slaveGridOptions.api) {
var slaveService = slaveGridOptions.api.__getMasterSlaveService();
callback(slaveService);
}
});
}
};
// common logic across all consume methods. very little common logic, however extracting
// guarantees consistency across the methods.
MasterSlaveService.prototype.onEvent = function (callback) {
this.consuming = true;
callback();
this.consuming = false;
};
MasterSlaveService.prototype.fireColumnEvent = function (event) {
this.fireEvent(function (slaveService) {
slaveService.onColumnEvent(event);
});
};
MasterSlaveService.prototype.fireHorizontalScrollEvent = function (horizontalScroll) {
this.fireEvent(function (slaveService) {
slaveService.onScrollEvent(horizontalScroll);
});
};
MasterSlaveService.prototype.onScrollEvent = function (horizontalScroll) {
var _this = this;
this.onEvent(function () {
_this.gridPanel.setHorizontalScrollPosition(horizontalScroll);
});
};
MasterSlaveService.prototype.getMasterColumns = function (event) {
var result = [];
if (event.getColumn()) {
result.push(event.getColumn());
}
if (event.getColumns()) {
event.getColumns().forEach(function (column) {
result.push(column);
});
}
return result;
};
MasterSlaveService.prototype.getColumnIds = function (event) {
var result = [];
if (event.getColumn()) {
result.push(event.getColumn().getColId());
}
if (event.getColumns()) {
event.getColumns().forEach(function (column) {
result.push(column.getColId());
});
}
return result;
};
MasterSlaveService.prototype.onColumnEvent = function (event) {
var _this = this;
this.onEvent(function () {
// the column in the event is from the master grid. need to
// look up the equivalent from this (slave) grid
var masterColumn = event.getColumn();
var slaveColumn;
if (masterColumn) {
slaveColumn = _this.columnController.getColumn(masterColumn.getColId());
}
// if event was with respect to a master column, that is not present in this
// grid, then we ignore the event
if (masterColumn && !slaveColumn) {
return;
}
// likewise for column group
var masterColumnGroup = event.getColumnGroup();
var slaveColumnGroup;
if (masterColumnGroup) {
var colId = masterColumnGroup.getGroupId();
var instanceId = masterColumnGroup.getInstanceId();
slaveColumnGroup = _this.columnController.getColumnGroup(colId, instanceId);
}
if (masterColumnGroup && !slaveColumnGroup) {
return;
}
// in time, all the methods below should use the column ids, it's a more generic way
// of handling columns, and also allows for single or multi column events
var columnIds = _this.getColumnIds(event);
var masterColumns = _this.getMasterColumns(event);
switch (event.getType()) {
case events_1.Events.EVENT_COLUMN_MOVED:
_this.logger.log('onColumnEvent-> processing ' + event + ' toIndex = ' + event.getToIndex());
_this.columnController.moveColumns(columnIds, event.getToIndex());
break;
case events_1.Events.EVENT_COLUMN_VISIBLE:
_this.logger.log('onColumnEvent-> processing ' + event + ' visible = ' + event.isVisible());
_this.columnController.setColumnsVisible(columnIds, event.isVisible());
break;
case events_1.Events.EVENT_COLUMN_PINNED:
_this.logger.log('onColumnEvent-> processing ' + event + ' pinned = ' + event.getPinned());
_this.columnController.setColumnsPinned(columnIds, event.getPinned());
break;
case events_1.Events.EVENT_COLUMN_GROUP_OPENED:
_this.logger.log('onColumnEvent-> processing ' + event + ' expanded = ' + masterColumnGroup.isExpanded());
_this.columnController.setColumnGroupOpened(slaveColumnGroup, masterColumnGroup.isExpanded());
break;
case events_1.Events.EVENT_COLUMN_RESIZED:
masterColumns.forEach(function (masterColumn) {
_this.logger.log('onColumnEvent-> processing ' + event + ' actualWidth = ' + masterColumn.getActualWidth());
_this.columnController.setColumnWidth(masterColumn.getColId(), masterColumn.getActualWidth(), event.isFinished());
});
break;
}
});
};
__decorate([
context_3.Autowired('gridOptionsWrapper'),
__metadata('design:type', gridOptionsWrapper_1.GridOptionsWrapper)
], MasterSlaveService.prototype, "gridOptionsWrapper", void 0);
__decorate([
context_3.Autowired('columnController'),
__metadata('design:type', columnController_1.ColumnController)
], MasterSlaveService.prototype, "columnController", void 0);
__decorate([
context_3.Autowired('gridPanel'),
__metadata('design:type', gridPanel_1.GridPanel)
], MasterSlaveService.prototype, "gridPanel", void 0);
__decorate([
context_3.Autowired('eventService'),
__metadata('design:type', eventService_1.EventService)
], MasterSlaveService.prototype, "eventService", void 0);
__decorate([
__param(0, context_2.Qualifier('loggerFactory')),
__metadata('design:type', Function),
__metadata('design:paramtypes', [logger_1.LoggerFactory]),
__metadata('design:returntype', void 0)
], MasterSlaveService.prototype, "agWire", null);
__decorate([
context_4.PostConstruct,
__metadata('design:type', Function),
__metadata('design:paramtypes', []),
__metadata('design:returntype', void 0)
], MasterSlaveService.prototype, "init", null);
MasterSlaveService = __decorate([
context_1.Bean('masterSlaveService'),
__metadata('design:paramtypes', [])
], MasterSlaveService);
return MasterSlaveService;
})();
exports.MasterSlaveService = MasterSlaveService;
/***/ },
/* 26 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var gridOptionsWrapper_1 = __webpack_require__(3);
var rowNode_1 = __webpack_require__(19);
var context_1 = __webpack_require__(6);
var eventService_1 = __webpack_require__(4);
var context_2 = __webpack_require__(6);
var events_1 = __webpack_require__(10);
var context_3 = __webpack_require__(6);
var constants_1 = __webpack_require__(8);
var utils_1 = __webpack_require__(7);
var FloatingRowModel = (function () {
function FloatingRowModel() {
}
FloatingRowModel.prototype.init = function () {
this.setFloatingTopRowData(this.gridOptionsWrapper.getFloatingTopRowData());
this.setFloatingBottomRowData(this.gridOptionsWrapper.getFloatingBottomRowData());
};
FloatingRowModel.prototype.isEmpty = function (floating) {
var rows = floating === constants_1.Constants.FLOATING_TOP ? this.floatingTopRows : this.floatingBottomRows;
return utils_1.Utils.missingOrEmpty(rows);
};
FloatingRowModel.prototype.isRowsToRender = function (floating) {
return !this.isEmpty(floating);
};
FloatingRowModel.prototype.getRowAtPixel = function (pixel, floating) {
var rows = floating === constants_1.Constants.FLOATING_TOP ? this.floatingTopRows : this.floatingBottomRows;
if (utils_1.Utils.missingOrEmpty(rows)) {
return 0; // this should never happen, just in case, 0 is graceful failure
}
for (var i = 0; i < rows.length; i++) {
var rowNode = rows[i];
var rowTopPixel = rowNode.rowTop + rowNode.rowHeight - 1;
// only need to range check against the top pixel, as we are going through the list
// in order, first row to hit the pixel wins
if (rowTopPixel >= pixel) {
return i;
}
}
return rows.length - 1;
};
FloatingRowModel.prototype.setFloatingTopRowData = function (rowData) {
this.floatingTopRows = this.createNodesFromData(rowData, true);
this.eventService.dispatchEvent(events_1.Events.EVENT_FLOATING_ROW_DATA_CHANGED);
};
FloatingRowModel.prototype.setFloatingBottomRowData = function (rowData) {
this.floatingBottomRows = this.createNodesFromData(rowData, false);
this.eventService.dispatchEvent(events_1.Events.EVENT_FLOATING_ROW_DATA_CHANGED);
};
FloatingRowModel.prototype.createNodesFromData = function (allData, isTop) {
var _this = this;
var rowNodes = [];
if (allData) {
var nextRowTop = 0;
allData.forEach(function (dataItem) {
var rowNode = new rowNode_1.RowNode(_this.eventService, _this.gridOptionsWrapper, null);
rowNode.data = dataItem;
rowNode.floating = isTop ? constants_1.Constants.FLOATING_TOP : constants_1.Constants.FLOATING_BOTTOM;
rowNode.rowTop = nextRowTop;
rowNode.rowHeight = _this.gridOptionsWrapper.getRowHeightForNode(rowNode);
nextRowTop += rowNode.rowHeight;
rowNodes.push(rowNode);
});
}
return rowNodes;
};
FloatingRowModel.prototype.getFloatingTopRowData = function () {
return this.floatingTopRows;
};
FloatingRowModel.prototype.getFloatingBottomRowData = function () {
return this.floatingBottomRows;
};
FloatingRowModel.prototype.getFloatingTopTotalHeight = function () {
return this.getTotalHeight(this.floatingTopRows);
};
FloatingRowModel.prototype.getFloatingBottomTotalHeight = function () {
return this.getTotalHeight(this.floatingBottomRows);
};
FloatingRowModel.prototype.getTotalHeight = function (rowNodes) {
if (!rowNodes || rowNodes.length === 0) {
return 0;
}
else {
var lastNode = rowNodes[rowNodes.length - 1];
return lastNode.rowTop + lastNode.rowHeight;
}
};
__decorate([
context_2.Autowired('gridOptionsWrapper'),
__metadata('design:type', gridOptionsWrapper_1.GridOptionsWrapper)
], FloatingRowModel.prototype, "gridOptionsWrapper", void 0);
__decorate([
context_2.Autowired('eventService'),
__metadata('design:type', eventService_1.EventService)
], FloatingRowModel.prototype, "eventService", void 0);
__decorate([
context_3.PostConstruct,
__metadata('design:type', Function),
__metadata('design:paramtypes', []),
__metadata('design:returntype', void 0)
], FloatingRowModel.prototype, "init", null);
FloatingRowModel = __decorate([
context_1.Bean('floatingRowModel'),
__metadata('design:paramtypes', [])
], FloatingRowModel);
return FloatingRowModel;
})();
exports.FloatingRowModel = FloatingRowModel;
/***/ },
/* 27 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var utils_1 = __webpack_require__(7);
var BorderLayout = (function () {
function BorderLayout(params) {
this.sizeChangeListeners = [];
this.isLayoutPanel = true;
this.fullHeight = !params.north && !params.south;
var template;
if (!params.dontFill) {
if (this.fullHeight) {
template =
'
';
var PaginationController = (function () {
function PaginationController() {
}
PaginationController.prototype.init = function () {
var _this = this;
this.setupComponents();
this.callVersion = 0;
var paginationEnabled = this.gridOptionsWrapper.isRowModelPagination();
this.eventService.addEventListener(events_1.Events.EVENT_FILTER_CHANGED, function () {
if (paginationEnabled && _this.gridOptionsWrapper.isEnableServerSideFilter()) {
_this.reset();
}
});
this.eventService.addEventListener(events_1.Events.EVENT_SORT_CHANGED, function () {
if (paginationEnabled && _this.gridOptionsWrapper.isEnableServerSideSorting()) {
_this.reset();
}
});
if (paginationEnabled && this.gridOptionsWrapper.getDatasource()) {
this.setDatasource(this.gridOptionsWrapper.getDatasource());
}
};
PaginationController.prototype.setDatasource = function (datasource) {
this.datasource = datasource;
if (!datasource) {
// only continue if we have a valid datasource to work with
return;
}
this.reset();
};
PaginationController.prototype.reset = function () {
// important to return here, as the user could be setting filter or sort before
// data-source is set
if (utils_1.Utils.missing(this.datasource)) {
return;
}
this.selectionController.reset();
// copy pageSize, to guard against it changing the the datasource between calls
if (this.datasource.pageSize && typeof this.datasource.pageSize !== 'number') {
console.warn('datasource.pageSize should be a number');
}
this.pageSize = this.datasource.pageSize;
// see if we know the total number of pages, or if it's 'to be decided'
if (typeof this.datasource.rowCount === 'number' && this.datasource.rowCount >= 0) {
this.rowCount = this.datasource.rowCount;
this.foundMaxRow = true;
this.calculateTotalPages();
}
else {
this.rowCount = 0;
this.foundMaxRow = false;
this.totalPages = null;
}
this.currentPage = 0;
// hide the summary panel until something is loaded
this.ePageRowSummaryPanel.style.visibility = 'hidden';
this.setTotalLabels();
this.loadPage();
};
// the native method number.toLocaleString(undefined, {minimumFractionDigits: 0}) puts in decimal places in IE
PaginationController.prototype.myToLocaleString = function (input) {
if (typeof input !== 'number') {
return '';
}
else {
// took this from: http://blog.tompawlak.org/number-currency-formatting-javascript
return input.toString().replace(/(\d)(?=(\d{3})+(?!\d))/g, "$1,");
}
};
PaginationController.prototype.setTotalLabels = function () {
if (this.foundMaxRow) {
this.lbTotal.innerHTML = this.myToLocaleString(this.totalPages);
this.lbRecordCount.innerHTML = this.myToLocaleString(this.rowCount);
}
else {
var moreText = this.gridOptionsWrapper.getLocaleTextFunc()('more', 'more');
this.lbTotal.innerHTML = moreText;
this.lbRecordCount.innerHTML = moreText;
}
};
PaginationController.prototype.calculateTotalPages = function () {
this.totalPages = Math.floor((this.rowCount - 1) / this.pageSize) + 1;
};
PaginationController.prototype.pageLoaded = function (rows, lastRowIndex) {
var firstId = this.currentPage * this.pageSize;
this.rowModel.setRowData(rows, true, firstId);
// see if we hit the last row
if (!this.foundMaxRow && typeof lastRowIndex === 'number' && lastRowIndex >= 0) {
this.foundMaxRow = true;
this.rowCount = lastRowIndex;
this.calculateTotalPages();
this.setTotalLabels();
// if overshot pages, go back
if (this.currentPage > this.totalPages) {
this.currentPage = this.totalPages - 1;
this.loadPage();
}
}
this.enableOrDisableButtons();
this.updateRowLabels();
};
PaginationController.prototype.updateRowLabels = function () {
var startRow;
var endRow;
if (this.isZeroPagesToDisplay()) {
startRow = 0;
endRow = 0;
}
else {
startRow = (this.pageSize * this.currentPage) + 1;
endRow = startRow + this.pageSize - 1;
if (this.foundMaxRow && endRow > this.rowCount) {
endRow = this.rowCount;
}
}
this.lbFirstRowOnPage.innerHTML = this.myToLocaleString(startRow);
this.lbLastRowOnPage.innerHTML = this.myToLocaleString(endRow);
// show the summary panel, when first shown, this is blank
this.ePageRowSummaryPanel.style.visibility = "";
};
PaginationController.prototype.loadPage = function () {
this.enableOrDisableButtons();
var startRow = this.currentPage * this.datasource.pageSize;
var endRow = (this.currentPage + 1) * this.datasource.pageSize;
this.lbCurrent.innerHTML = this.myToLocaleString(this.currentPage + 1);
this.callVersion++;
var callVersionCopy = this.callVersion;
var that = this;
this.gridPanel.showLoadingOverlay();
var sortModel;
if (this.gridOptionsWrapper.isEnableServerSideSorting()) {
sortModel = this.sortController.getSortModel();
}
var filterModel;
if (this.gridOptionsWrapper.isEnableServerSideFilter()) {
filterModel = this.filterManager.getFilterModel();
}
var params = {
startRow: startRow,
endRow: endRow,
successCallback: successCallback,
failCallback: failCallback,
sortModel: sortModel,
filterModel: filterModel
};
// check if old version of datasource used
var getRowsParams = utils_1.Utils.getFunctionParameters(this.datasource.getRows);
if (getRowsParams.length > 1) {
console.warn('ag-grid: It looks like your paging datasource is of the old type, taking more than one parameter.');
console.warn('ag-grid: From ag-grid 1.9.0, now the getRows takes one parameter. See the documentation for details.');
}
this.datasource.getRows(params);
function successCallback(rows, lastRowIndex) {
if (that.isCallDaemon(callVersionCopy)) {
return;
}
that.pageLoaded(rows, lastRowIndex);
}
function failCallback() {
if (that.isCallDaemon(callVersionCopy)) {
return;
}
// set in an empty set of rows, this will at
// least get rid of the loading panel, and
// stop blocking things
that.rowModel.setRowData([], true);
}
};
PaginationController.prototype.isCallDaemon = function (versionCopy) {
return versionCopy !== this.callVersion;
};
PaginationController.prototype.onBtNext = function () {
this.currentPage++;
this.loadPage();
};
PaginationController.prototype.onBtPrevious = function () {
this.currentPage--;
this.loadPage();
};
PaginationController.prototype.onBtFirst = function () {
this.currentPage = 0;
this.loadPage();
};
PaginationController.prototype.onBtLast = function () {
this.currentPage = this.totalPages - 1;
this.loadPage();
};
PaginationController.prototype.isZeroPagesToDisplay = function () {
return this.foundMaxRow && this.totalPages === 0;
};
PaginationController.prototype.enableOrDisableButtons = function () {
var disablePreviousAndFirst = this.currentPage === 0;
this.btPrevious.disabled = disablePreviousAndFirst;
this.btFirst.disabled = disablePreviousAndFirst;
var zeroPagesToDisplay = this.isZeroPagesToDisplay();
var onLastPage = this.foundMaxRow && this.currentPage === (this.totalPages - 1);
var disableNext = onLastPage || zeroPagesToDisplay;
this.btNext.disabled = disableNext;
var disableLast = !this.foundMaxRow || zeroPagesToDisplay || this.currentPage === (this.totalPages - 1);
this.btLast.disabled = disableLast;
};
PaginationController.prototype.createTemplate = function () {
var localeTextFunc = this.gridOptionsWrapper.getLocaleTextFunc();
return template
.replace('[PAGE]', localeTextFunc('page', 'Page'))
.replace('[TO]', localeTextFunc('to', 'to'))
.replace('[OF]', localeTextFunc('of', 'of'))
.replace('[OF]', localeTextFunc('of', 'of'))
.replace('[FIRST]', localeTextFunc('first', 'First'))
.replace('[PREVIOUS]', localeTextFunc('previous', 'Previous'))
.replace('[NEXT]', localeTextFunc('next', 'Next'))
.replace('[LAST]', localeTextFunc('last', 'Last'));
};
PaginationController.prototype.getGui = function () {
return this.eGui;
};
PaginationController.prototype.setupComponents = function () {
this.eGui = utils_1.Utils.loadTemplate(this.createTemplate());
this.btNext = this.eGui.querySelector('#btNext');
this.btPrevious = this.eGui.querySelector('#btPrevious');
this.btFirst = this.eGui.querySelector('#btFirst');
this.btLast = this.eGui.querySelector('#btLast');
this.lbCurrent = this.eGui.querySelector('#current');
this.lbTotal = this.eGui.querySelector('#total');
this.lbRecordCount = this.eGui.querySelector('#recordCount');
this.lbFirstRowOnPage = this.eGui.querySelector('#firstRowOnPage');
this.lbLastRowOnPage = this.eGui.querySelector('#lastRowOnPage');
this.ePageRowSummaryPanel = this.eGui.querySelector('#pageRowSummaryPanel');
var that = this;
this.btNext.addEventListener('click', function () {
that.onBtNext();
});
this.btPrevious.addEventListener('click', function () {
that.onBtPrevious();
});
this.btFirst.addEventListener('click', function () {
that.onBtFirst();
});
this.btLast.addEventListener('click', function () {
that.onBtLast();
});
};
__decorate([
context_2.Autowired('filterManager'),
__metadata('design:type', filterManager_1.FilterManager)
], PaginationController.prototype, "filterManager", void 0);
__decorate([
context_2.Autowired('gridPanel'),
__metadata('design:type', gridPanel_1.GridPanel)
], PaginationController.prototype, "gridPanel", void 0);
__decorate([
context_2.Autowired('gridOptionsWrapper'),
__metadata('design:type', gridOptionsWrapper_1.GridOptionsWrapper)
], PaginationController.prototype, "gridOptionsWrapper", void 0);
__decorate([
context_2.Autowired('selectionController'),
__metadata('design:type', selectionController_1.SelectionController)
], PaginationController.prototype, "selectionController", void 0);
__decorate([
context_2.Autowired('rowModel'),
__metadata('design:type', Object)
], PaginationController.prototype, "rowModel", void 0);
__decorate([
context_2.Autowired('sortController'),
__metadata('design:type', sortController_1.SortController)
], PaginationController.prototype, "sortController", void 0);
__decorate([
context_2.Autowired('eventService'),
__metadata('design:type', eventService_1.EventService)
], PaginationController.prototype, "eventService", void 0);
__decorate([
context_3.PostConstruct,
__metadata('design:type', Function),
__metadata('design:paramtypes', []),
__metadata('design:returntype', void 0)
], PaginationController.prototype, "init", null);
PaginationController = __decorate([
context_1.Bean('paginationController'),
__metadata('design:paramtypes', [])
], PaginationController);
return PaginationController;
})();
exports.PaginationController = PaginationController;
/***/ },
/* 39 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var column_1 = __webpack_require__(15);
var context_1 = __webpack_require__(6);
var gridOptionsWrapper_1 = __webpack_require__(3);
var columnController_1 = __webpack_require__(13);
var eventService_1 = __webpack_require__(4);
var events_1 = __webpack_require__(10);
var context_2 = __webpack_require__(6);
var utils_1 = __webpack_require__(7);
var SortController = (function () {
function SortController() {
}
SortController.prototype.progressSort = function (column, multiSort) {
// update sort on current col
column.setSort(this.getNextSortDirection(column));
// sortedAt used for knowing order of cols when multi-col sort
if (column.getSort()) {
column.setSortedAt(new Date().valueOf());
}
else {
column.setSortedAt(null);
}
var doingMultiSort = multiSort && !this.gridOptionsWrapper.isSuppressMultiSort();
// clear sort on all columns except this one, and update the icons
if (!doingMultiSort) {
this.clearSortBarThisColumn(column);
}
this.dispatchSortChangedEvents();
};
SortController.prototype.dispatchSortChangedEvents = function () {
this.eventService.dispatchEvent(events_1.Events.EVENT_BEFORE_SORT_CHANGED);
this.eventService.dispatchEvent(events_1.Events.EVENT_SORT_CHANGED);
this.eventService.dispatchEvent(events_1.Events.EVENT_AFTER_SORT_CHANGED);
};
SortController.prototype.clearSortBarThisColumn = function (columnToSkip) {
this.columnController.getAllColumnsIncludingAuto().forEach(function (columnToClear) {
// Do not clear if either holding shift, or if column in question was clicked
if (!(columnToClear === columnToSkip)) {
columnToClear.setSort(null);
}
});
};
SortController.prototype.getNextSortDirection = function (column) {
var sortingOrder;
if (column.getColDef().sortingOrder) {
sortingOrder = column.getColDef().sortingOrder;
}
else if (this.gridOptionsWrapper.getSortingOrder()) {
sortingOrder = this.gridOptionsWrapper.getSortingOrder();
}
else {
sortingOrder = SortController.DEFAULT_SORTING_ORDER;
}
if (!Array.isArray(sortingOrder) || sortingOrder.length <= 0) {
console.warn('ag-grid: sortingOrder must be an array with at least one element, currently it\'s ' + sortingOrder);
return;
}
var currentIndex = sortingOrder.indexOf(column.getSort());
var notInArray = currentIndex < 0;
var lastItemInArray = currentIndex == sortingOrder.length - 1;
var result;
if (notInArray || lastItemInArray) {
result = sortingOrder[0];
}
else {
result = sortingOrder[currentIndex + 1];
}
// verify the sort type exists, as the user could provide the sortOrder, need to make sure it's valid
if (SortController.DEFAULT_SORTING_ORDER.indexOf(result) < 0) {
console.warn('ag-grid: invalid sort type ' + result);
return null;
}
return result;
};
// used by the public api, for saving the sort model
SortController.prototype.getSortModel = function () {
var columnsWithSorting = this.getColumnsWithSortingOrdered();
return utils_1.Utils.map(columnsWithSorting, function (column) {
return {
colId: column.getColId(),
sort: column.getSort()
};
});
};
SortController.prototype.setSortModel = function (sortModel) {
if (!this.gridOptionsWrapper.isEnableSorting()) {
console.warn('ag-grid: You are setting the sort model on a grid that does not have sorting enabled');
return;
}
// first up, clear any previous sort
var sortModelProvided = sortModel && sortModel.length > 0;
var allColumnsIncludingAuto = this.columnController.getAllColumnsIncludingAuto();
allColumnsIncludingAuto.forEach(function (column) {
var sortForCol = null;
var sortedAt = -1;
if (sortModelProvided && !column.getColDef().suppressSorting) {
for (var j = 0; j < sortModel.length; j++) {
var sortModelEntry = sortModel[j];
if (typeof sortModelEntry.colId === 'string'
&& typeof column.getColId() === 'string'
&& sortModelEntry.colId === column.getColId()) {
sortForCol = sortModelEntry.sort;
sortedAt = j;
}
}
}
if (sortForCol) {
column.setSort(sortForCol);
column.setSortedAt(sortedAt);
}
else {
column.setSort(null);
column.setSortedAt(null);
}
});
this.dispatchSortChangedEvents();
};
SortController.prototype.getColumnsWithSortingOrdered = function () {
// pull out all the columns that have sorting set
var allColumnsIncludingAuto = this.columnController.getAllColumnsIncludingAuto();
var columnsWithSorting = utils_1.Utils.filter(allColumnsIncludingAuto, function (column) { return !!column.getSort(); });
// put the columns in order of which one got sorted first
columnsWithSorting.sort(function (a, b) { return a.sortedAt - b.sortedAt; });
return columnsWithSorting;
};
// used by row controller, when doing the sorting
SortController.prototype.getSortForRowController = function () {
var columnsWithSorting = this.getColumnsWithSortingOrdered();
return utils_1.Utils.map(columnsWithSorting, function (column) {
var ascending = column.getSort() === column_1.Column.SORT_ASC;
return {
inverter: ascending ? 1 : -1,
column: column
};
});
};
SortController.DEFAULT_SORTING_ORDER = [column_1.Column.SORT_ASC, column_1.Column.SORT_DESC, null];
__decorate([
context_1.Autowired('gridOptionsWrapper'),
__metadata('design:type', gridOptionsWrapper_1.GridOptionsWrapper)
], SortController.prototype, "gridOptionsWrapper", void 0);
__decorate([
context_1.Autowired('columnController'),
__metadata('design:type', columnController_1.ColumnController)
], SortController.prototype, "columnController", void 0);
__decorate([
context_1.Autowired('eventService'),
__metadata('design:type', eventService_1.EventService)
], SortController.prototype, "eventService", void 0);
SortController = __decorate([
context_2.Bean('sortController'),
__metadata('design:paramtypes', [])
], SortController);
return SortController;
})();
exports.SortController = SortController;
/***/ },
/* 40 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var utils_1 = __webpack_require__(7);
var gridOptionsWrapper_1 = __webpack_require__(3);
var popupService_1 = __webpack_require__(41);
var valueService_1 = __webpack_require__(34);
var columnController_1 = __webpack_require__(13);
var textFilter_1 = __webpack_require__(42);
var numberFilter_1 = __webpack_require__(43);
var context_1 = __webpack_require__(6);
var context_2 = __webpack_require__(6);
var eventService_1 = __webpack_require__(4);
var events_1 = __webpack_require__(10);
var context_3 = __webpack_require__(6);
var FilterManager = (function () {
function FilterManager() {
this.allFilters = {};
this.quickFilter = null;
this.availableFilters = {
'text': textFilter_1.TextFilter,
'number': numberFilter_1.NumberFilter
};
}
FilterManager.prototype.init = function () {
this.eventService.addEventListener(events_1.Events.EVENT_ROW_DATA_CHANGED, this.onNewRowsLoaded.bind(this));
this.eventService.addEventListener(events_1.Events.EVENT_NEW_COLUMNS_LOADED, this.onNewColumnsLoaded.bind(this));
};
FilterManager.prototype.registerFilter = function (key, Filter) {
this.availableFilters[key] = Filter;
};
FilterManager.prototype.setFilterModel = function (model) {
var _this = this;
if (model) {
// mark the filters as we set them, so any active filters left over we stop
var modelKeys = Object.keys(model);
utils_1.Utils.iterateObject(this.allFilters, function (colId, filterWrapper) {
utils_1.Utils.removeFromArray(modelKeys, colId);
var newModel = model[colId];
_this.setModelOnFilterWrapper(filterWrapper.filter, newModel);
});
// at this point, processedFields contains data for which we don't have a filter working yet
utils_1.Utils.iterateArray(modelKeys, function (colId) {
var column = _this.columnController.getColumn(colId);
if (!column) {
console.warn('Warning ag-grid setFilterModel - no column found for colId ' + colId);
return;
}
var filterWrapper = _this.getOrCreateFilterWrapper(column);
_this.setModelOnFilterWrapper(filterWrapper.filter, model[colId]);
});
}
else {
utils_1.Utils.iterateObject(this.allFilters, function (key, filterWrapper) {
_this.setModelOnFilterWrapper(filterWrapper.filter, null);
});
}
this.onFilterChanged();
};
FilterManager.prototype.setModelOnFilterWrapper = function (filter, newModel) {
// because user can provide filters, we provide useful error checking and messages
if (typeof filter.getApi !== 'function') {
console.warn('Warning ag-grid - filter missing getApi method, which is needed for getFilterModel');
return;
}
var filterApi = filter.getApi();
if (typeof filterApi.setModel !== 'function') {
console.warn('Warning ag-grid - filter API missing setModel method, which is needed for setFilterModel');
return;
}
filterApi.setModel(newModel);
};
FilterManager.prototype.getFilterModel = function () {
var result = {};
utils_1.Utils.iterateObject(this.allFilters, function (key, filterWrapper) {
// because user can provide filters, we provide useful error checking and messages
if (typeof filterWrapper.filter.getApi !== 'function') {
console.warn('Warning ag-grid - filter missing getApi method, which is needed for getFilterModel');
return;
}
var filterApi = filterWrapper.filter.getApi();
if (typeof filterApi.getModel !== 'function') {
console.warn('Warning ag-grid - filter API missing getModel method, which is needed for getFilterModel');
return;
}
var model = filterApi.getModel();
if (utils_1.Utils.exists(model)) {
result[key] = model;
}
});
return result;
};
// returns true if any advanced filter (ie not quick filter) active
FilterManager.prototype.isAdvancedFilterPresent = function () {
var atLeastOneActive = false;
utils_1.Utils.iterateObject(this.allFilters, function (key, filterWrapper) {
if (!filterWrapper.filter.isFilterActive) {
console.error('Filter is missing method isFilterActive');
}
if (filterWrapper.filter.isFilterActive()) {
atLeastOneActive = true;
filterWrapper.column.setFilterActive(true);
}
else {
filterWrapper.column.setFilterActive(false);
}
});
return atLeastOneActive;
};
// returns true if quickFilter or advancedFilter
FilterManager.prototype.isAnyFilterPresent = function () {
return this.isQuickFilterPresent() || this.advancedFilterPresent || this.externalFilterPresent;
};
FilterManager.prototype.doesFilterPass = function (node, filterToSkip) {
var data = node.data;
var colKeys = Object.keys(this.allFilters);
for (var i = 0, l = colKeys.length; i < l; i++) {
var colId = colKeys[i];
var filterWrapper = this.allFilters[colId];
// if no filter, always pass
if (filterWrapper === undefined) {
continue;
}
if (filterWrapper.filter === filterToSkip) {
continue;
}
// don't bother with filters that are not active
if (!filterWrapper.filter.isFilterActive()) {
continue;
}
if (!filterWrapper.filter.doesFilterPass) {
console.error('Filter is missing method doesFilterPass');
}
var params = {
node: node,
data: data
};
if (!filterWrapper.filter.doesFilterPass(params)) {
return false;
}
}
// all filters passed
return true;
};
// returns true if it has changed (not just same value again)
FilterManager.prototype.setQuickFilter = function (newFilter) {
if (newFilter === undefined || newFilter === "") {
newFilter = null;
}
if (this.quickFilter !== newFilter) {
if (this.gridOptionsWrapper.isRowModelVirtual()) {
console.warn('ag-grid: cannot do quick filtering when doing virtual paging');
return;
}
//want 'null' to mean to filter, so remove undefined and empty string
if (newFilter === undefined || newFilter === "") {
newFilter = null;
}
if (newFilter !== null) {
newFilter = newFilter.toUpperCase();
}
this.quickFilter = newFilter;
this.onFilterChanged();
}
};
FilterManager.prototype.onFilterChanged = function () {
this.eventService.dispatchEvent(events_1.Events.EVENT_BEFORE_FILTER_CHANGED);
this.advancedFilterPresent = this.isAdvancedFilterPresent();
this.externalFilterPresent = this.gridOptionsWrapper.isExternalFilterPresent();
utils_1.Utils.iterateObject(this.allFilters, function (key, filterWrapper) {
if (filterWrapper.filter.onAnyFilterChanged) {
filterWrapper.filter.onAnyFilterChanged();
}
});
this.eventService.dispatchEvent(events_1.Events.EVENT_FILTER_CHANGED);
this.eventService.dispatchEvent(events_1.Events.EVENT_AFTER_FILTER_CHANGED);
};
FilterManager.prototype.isQuickFilterPresent = function () {
return this.quickFilter !== null;
};
FilterManager.prototype.doesRowPassOtherFilters = function (filterToSkip, node) {
return this.doesRowPassFilter(node, filterToSkip);
};
FilterManager.prototype.doesRowPassFilter = function (node, filterToSkip) {
//first up, check quick filter
if (this.isQuickFilterPresent()) {
if (!node.quickFilterAggregateText) {
this.aggregateRowForQuickFilter(node);
}
if (node.quickFilterAggregateText.indexOf(this.quickFilter) < 0) {
//quick filter fails, so skip item
return false;
}
}
//secondly, give the client a chance to reject this row
if (this.externalFilterPresent) {
if (!this.gridOptionsWrapper.doesExternalFilterPass(node)) {
return false;
}
}
//lastly, check our internal advanced filter
if (this.advancedFilterPresent) {
if (!this.doesFilterPass(node, filterToSkip)) {
return false;
}
}
//got this far, all filters pass
return true;
};
FilterManager.prototype.aggregateRowForQuickFilter = function (node) {
var aggregatedText = '';
var that = this;
this.columnController.getAllColumns().forEach(function (column) {
var value = that.valueService.getValue(column, node);
if (value && value !== '') {
aggregatedText = aggregatedText + value.toString().toUpperCase() + "_";
}
});
node.quickFilterAggregateText = aggregatedText;
};
FilterManager.prototype.onNewRowsLoaded = function () {
var that = this;
Object.keys(this.allFilters).forEach(function (field) {
var filter = that.allFilters[field].filter;
if (filter.onNewRowsLoaded) {
filter.onNewRowsLoaded();
}
});
};
FilterManager.prototype.createValueGetter = function (column) {
var that = this;
return function valueGetter(node) {
return that.valueService.getValue(column, node);
};
};
FilterManager.prototype.getFilterApi = function (column) {
var filterWrapper = this.getOrCreateFilterWrapper(column);
if (filterWrapper) {
if (typeof filterWrapper.filter.getApi === 'function') {
return filterWrapper.filter.getApi();
}
}
};
FilterManager.prototype.getOrCreateFilterWrapper = function (column) {
var filterWrapper = this.allFilters[column.getColId()];
if (!filterWrapper) {
filterWrapper = this.createFilterWrapper(column);
this.allFilters[column.getColId()] = filterWrapper;
}
return filterWrapper;
};
FilterManager.prototype.createFilterWrapper = function (column) {
var _this = this;
var colDef = column.getColDef();
var filterWrapper = {
column: column,
filter: null,
scope: null,
gui: null
};
if (typeof colDef.filter === 'function') {
// if user provided a filter, just use it
// first up, create child scope if needed
if (this.gridOptionsWrapper.isAngularCompileFilters()) {
filterWrapper.scope = this.$scope.$new();
}
// now create filter (had to cast to any to get 'new' working)
this.assertMethodHasNoParameters(colDef.filter);
filterWrapper.filter = new colDef.filter();
}
else if (utils_1.Utils.missing(colDef.filter) || typeof colDef.filter === 'string') {
var Filter = this.getFilterFromCache(colDef.filter);
filterWrapper.filter = new Filter();
}
else {
console.error('ag-Grid: colDef.filter should be function or a string');
}
var filterChangedCallback = this.onFilterChanged.bind(this);
var filterModifiedCallback = function () { return _this.eventService.dispatchEvent(events_1.Events.EVENT_FILTER_MODIFIED); };
var doesRowPassOtherFilters = this.doesRowPassOtherFilters.bind(this, filterWrapper.filter);
var filterParams = colDef.filterParams;
var params = {
colDef: colDef,
rowModel: this.rowModel,
filterChangedCallback: filterChangedCallback,
filterModifiedCallback: filterModifiedCallback,
filterParams: filterParams,
localeTextFunc: this.gridOptionsWrapper.getLocaleTextFunc(),
valueGetter: this.createValueGetter(column),
doesRowPassOtherFilter: doesRowPassOtherFilters,
context: this.gridOptionsWrapper.getContext(),
$scope: filterWrapper.scope
};
if (!filterWrapper.filter.init) {
throw 'Filter is missing method init';
}
filterWrapper.filter.init(params);
if (!filterWrapper.filter.getGui) {
throw 'Filter is missing method getGui';
}
var eFilterGui = document.createElement('div');
eFilterGui.className = 'ag-filter';
var guiFromFilter = filterWrapper.filter.getGui();
if (utils_1.Utils.isNodeOrElement(guiFromFilter)) {
//a dom node or element was returned, so add child
eFilterGui.appendChild(guiFromFilter);
}
else {
//otherwise assume it was html, so just insert
var eTextSpan = document.createElement('span');
eTextSpan.innerHTML = guiFromFilter;
eFilterGui.appendChild(eTextSpan);
}
if (filterWrapper.scope) {
filterWrapper.gui = this.$compile(eFilterGui)(filterWrapper.scope)[0];
}
else {
filterWrapper.gui = eFilterGui;
}
return filterWrapper;
};
FilterManager.prototype.getFilterFromCache = function (filterType) {
var defaultFilterType = this.enterprise ? 'set' : 'text';
var defaultFilter = this.availableFilters[defaultFilterType];
if (utils_1.Utils.missing(filterType)) {
return defaultFilter;
}
if (!this.enterprise && filterType === 'set') {
console.warn('ag-Grid: Set filter is only available in Enterprise ag-Grid');
filterType = 'text';
}
if (this.availableFilters[filterType]) {
return this.availableFilters[filterType];
}
else {
console.error('ag-Grid: Could not find filter type ' + filterType);
return this.availableFilters[defaultFilter];
}
};
FilterManager.prototype.onNewColumnsLoaded = function () {
this.agDestroy();
};
FilterManager.prototype.agDestroy = function () {
utils_1.Utils.iterateObject(this.allFilters, function (key, filterWrapper) {
if (filterWrapper.filter.destroy) {
filterWrapper.filter.destroy();
filterWrapper.column.setFilterActive(false);
}
});
this.allFilters = {};
};
FilterManager.prototype.assertMethodHasNoParameters = function (theMethod) {
var getRowsParams = utils_1.Utils.getFunctionParameters(theMethod);
if (getRowsParams.length > 0) {
console.warn('ag-grid: It looks like your filter is of the old type and expecting parameters in the constructor.');
console.warn('ag-grid: From ag-grid 1.14, the constructor should take no parameters and init() used instead.');
}
};
__decorate([
context_2.Autowired('$compile'),
__metadata('design:type', Object)
], FilterManager.prototype, "$compile", void 0);
__decorate([
context_2.Autowired('$scope'),
__metadata('design:type', Object)
], FilterManager.prototype, "$scope", void 0);
__decorate([
context_2.Autowired('gridOptionsWrapper'),
__metadata('design:type', gridOptionsWrapper_1.GridOptionsWrapper)
], FilterManager.prototype, "gridOptionsWrapper", void 0);
__decorate([
context_2.Autowired('gridCore'),
__metadata('design:type', Object)
], FilterManager.prototype, "gridCore", void 0);
__decorate([
context_2.Autowired('popupService'),
__metadata('design:type', popupService_1.PopupService)
], FilterManager.prototype, "popupService", void 0);
__decorate([
context_2.Autowired('valueService'),
__metadata('design:type', valueService_1.ValueService)
], FilterManager.prototype, "valueService", void 0);
__decorate([
context_2.Autowired('columnController'),
__metadata('design:type', columnController_1.ColumnController)
], FilterManager.prototype, "columnController", void 0);
__decorate([
context_2.Autowired('rowModel'),
__metadata('design:type', Object)
], FilterManager.prototype, "rowModel", void 0);
__decorate([
context_2.Autowired('eventService'),
__metadata('design:type', eventService_1.EventService)
], FilterManager.prototype, "eventService", void 0);
__decorate([
context_2.Autowired('enterprise'),
__metadata('design:type', Boolean)
], FilterManager.prototype, "enterprise", void 0);
__decorate([
context_3.PostConstruct,
__metadata('design:type', Function),
__metadata('design:paramtypes', []),
__metadata('design:returntype', void 0)
], FilterManager.prototype, "init", null);
FilterManager = __decorate([
context_1.Bean('filterManager'),
__metadata('design:paramtypes', [])
], FilterManager);
return FilterManager;
})();
exports.FilterManager = FilterManager;
/***/ },
/* 41 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var utils_1 = __webpack_require__(7);
var constants_1 = __webpack_require__(8);
var context_1 = __webpack_require__(6);
var PopupService = (function () {
function PopupService() {
}
PopupService.prototype.setPopupParent = function (ePopupParent) {
this.ePopupParent = ePopupParent;
};
PopupService.prototype.positionPopupForMenu = function (params) {
var sourceRect = params.eventSource.getBoundingClientRect();
var parentRect = this.ePopupParent.getBoundingClientRect();
var x = sourceRect.right - parentRect.left - 2;
var y = sourceRect.top - parentRect.top;
var minWidth;
if (params.ePopup.clientWidth > 0) {
minWidth = params.ePopup.clientWidth;
}
else {
minWidth = 200;
}
var widthOfParent = parentRect.right - parentRect.left;
var maxX = widthOfParent - minWidth;
if (x > maxX) {
// try putting menu to the left
x = sourceRect.left - minWidth;
}
if (x < 0) {
x = 0;
}
params.ePopup.style.left = x + "px";
params.ePopup.style.top = y + "px";
};
PopupService.prototype.positionPopupUnderMouseEvent = function (params) {
var parentRect = this.ePopupParent.getBoundingClientRect();
this.positionPopup({
ePopup: params.ePopup,
x: params.mouseEvent.clientX - parentRect.left,
y: params.mouseEvent.clientY - parentRect.top,
keepWithinBounds: true
});
};
PopupService.prototype.positionPopupUnderComponent = function (params) {
var sourceRect = params.eventSource.getBoundingClientRect();
var parentRect = this.ePopupParent.getBoundingClientRect();
this.positionPopup({
ePopup: params.ePopup,
minWidth: params.minWidth,
nudgeX: params.nudgeX,
nudgeY: params.nudgeY,
x: sourceRect.left - parentRect.left,
y: sourceRect.top - parentRect.top + sourceRect.height,
keepWithinBounds: params.keepWithinBounds
});
};
PopupService.prototype.positionPopup = function (params) {
var parentRect = this.ePopupParent.getBoundingClientRect();
var x = params.x;
var y = params.y;
if (params.nudgeX) {
x += params.nudgeX;
}
if (params.nudgeY) {
y += params.nudgeY;
}
// if popup is overflowing to the right, move it left
if (params.keepWithinBounds) {
var minWidth;
if (params.minWidth > 0) {
minWidth = params.minWidth;
}
else if (params.ePopup.clientWidth > 0) {
minWidth = params.ePopup.clientWidth;
}
else {
minWidth = 200;
}
var widthOfParent = parentRect.right - parentRect.left;
var maxX = widthOfParent - minWidth;
if (x > maxX) {
x = maxX;
}
if (x < 0) {
x = 0;
}
}
params.ePopup.style.left = x + "px";
params.ePopup.style.top = y + "px";
};
//adds an element to a div, but also listens to background checking for clicks,
//so that when the background is clicked, the child is removed again, giving
//a model look to popups.
PopupService.prototype.addAsModalPopup = function (eChild, closeOnEsc, closedCallback) {
var eBody = document.body;
if (!eBody) {
console.warn('ag-grid: could not find the body of the document, document.body is empty');
return;
}
var popupAlreadyShown = utils_1.Utils.isVisible(eChild);
if (popupAlreadyShown) {
return;
}
this.ePopupParent.appendChild(eChild);
var that = this;
// if we add these listeners now, then the current mouse
// click will be included, which we don't want
setTimeout(function () {
if (closeOnEsc) {
eBody.addEventListener('keydown', hidePopupOnEsc);
}
eBody.addEventListener('click', hidePopup);
eBody.addEventListener('contextmenu', hidePopup);
//eBody.addEventListener('mousedown', hidePopup);
eChild.addEventListener('click', consumeClick);
//eChild.addEventListener('mousedown', consumeClick);
}, 0);
var eventFromChild = null;
function hidePopupOnEsc(event) {
var key = event.which || event.keyCode;
if (key === constants_1.Constants.KEY_ESCAPE) {
hidePopup(null);
}
}
function hidePopup(event) {
if (event && event === eventFromChild) {
return;
}
that.ePopupParent.removeChild(eChild);
eBody.removeEventListener('keydown', hidePopupOnEsc);
//eBody.removeEventListener('mousedown', hidePopupOnEsc);
eBody.removeEventListener('click', hidePopup);
eBody.removeEventListener('contextmenu', hidePopup);
eChild.removeEventListener('click', consumeClick);
//eChild.removeEventListener('mousedown', consumeClick);
if (closedCallback) {
closedCallback();
}
}
function consumeClick(event) {
eventFromChild = event;
}
return hidePopup;
};
PopupService = __decorate([
context_1.Bean('popupService'),
__metadata('design:paramtypes', [])
], PopupService);
return PopupService;
})();
exports.PopupService = PopupService;
/***/ },
/* 42 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var utils_1 = __webpack_require__(7);
var template = '
' +
'
' +
'' +
'
' +
'
' +
'' +
'
' +
'
' +
'' +
'
' +
'
';
var CONTAINS = 1;
var EQUALS = 2;
var STARTS_WITH = 3;
var ENDS_WITH = 4;
var TextFilter = (function () {
function TextFilter() {
}
TextFilter.prototype.init = function (params) {
this.filterParams = params.filterParams;
this.applyActive = this.filterParams && this.filterParams.apply === true;
this.filterChangedCallback = params.filterChangedCallback;
this.filterModifiedCallback = params.filterModifiedCallback;
this.localeTextFunc = params.localeTextFunc;
this.valueGetter = params.valueGetter;
this.createGui();
this.filterText = null;
this.filterType = CONTAINS;
this.createApi();
};
TextFilter.prototype.onNewRowsLoaded = function () {
var keepSelection = this.filterParams && this.filterParams.newRowsAction === 'keep';
if (!keepSelection) {
this.api.setType(CONTAINS);
this.api.setFilter(null);
}
};
TextFilter.prototype.afterGuiAttached = function () {
this.eFilterTextField.focus();
};
TextFilter.prototype.doesFilterPass = function (node) {
if (!this.filterText) {
return true;
}
var value = this.valueGetter(node);
if (!value) {
return false;
}
var valueLowerCase = value.toString().toLowerCase();
switch (this.filterType) {
case CONTAINS:
return valueLowerCase.indexOf(this.filterText) >= 0;
case EQUALS:
return valueLowerCase === this.filterText;
case STARTS_WITH:
return valueLowerCase.indexOf(this.filterText) === 0;
case ENDS_WITH:
var index = valueLowerCase.lastIndexOf(this.filterText);
return index >= 0 && index === (valueLowerCase.length - this.filterText.length);
default:
// should never happen
console.warn('invalid filter type ' + this.filterType);
return false;
}
};
TextFilter.prototype.getGui = function () {
return this.eGui;
};
TextFilter.prototype.isFilterActive = function () {
return this.filterText !== null;
};
TextFilter.prototype.createTemplate = function () {
return template
.replace('[FILTER...]', this.localeTextFunc('filterOoo', 'Filter...'))
.replace('[EQUALS]', this.localeTextFunc('equals', 'Equals'))
.replace('[CONTAINS]', this.localeTextFunc('contains', 'Contains'))
.replace('[STARTS WITH]', this.localeTextFunc('startsWith', 'Starts with'))
.replace('[ENDS WITH]', this.localeTextFunc('endsWith', 'Ends with'))
.replace('[APPLY FILTER]', this.localeTextFunc('applyFilter', 'Apply Filter'));
};
TextFilter.prototype.createGui = function () {
this.eGui = utils_1.Utils.loadTemplate(this.createTemplate());
this.eFilterTextField = this.eGui.querySelector("#filterText");
this.eTypeSelect = this.eGui.querySelector("#filterType");
utils_1.Utils.addChangeListener(this.eFilterTextField, this.onFilterChanged.bind(this));
this.eTypeSelect.addEventListener("change", this.onTypeChanged.bind(this));
this.setupApply();
};
TextFilter.prototype.setupApply = function () {
var _this = this;
if (this.applyActive) {
this.eApplyButton = this.eGui.querySelector('#applyButton');
this.eApplyButton.addEventListener('click', function () {
_this.filterChangedCallback();
});
}
else {
utils_1.Utils.removeElement(this.eGui, '#applyPanel');
}
};
TextFilter.prototype.onTypeChanged = function () {
this.filterType = parseInt(this.eTypeSelect.value);
this.filterChanged();
};
TextFilter.prototype.onFilterChanged = function () {
var filterText = utils_1.Utils.makeNull(this.eFilterTextField.value);
if (filterText && filterText.trim() === '') {
filterText = null;
}
var newFilterText;
if (filterText !== null && filterText !== undefined) {
newFilterText = filterText.toLowerCase();
}
else {
newFilterText = null;
}
if (this.filterText !== newFilterText) {
this.filterText = newFilterText;
this.filterChanged();
}
};
TextFilter.prototype.filterChanged = function () {
this.filterModifiedCallback();
if (!this.applyActive) {
this.filterChangedCallback();
}
};
TextFilter.prototype.createApi = function () {
var that = this;
this.api = {
EQUALS: EQUALS,
CONTAINS: CONTAINS,
STARTS_WITH: STARTS_WITH,
ENDS_WITH: ENDS_WITH,
setType: function (type) {
that.filterType = type;
that.eTypeSelect.value = type;
},
setFilter: function (filter) {
filter = utils_1.Utils.makeNull(filter);
if (filter) {
that.filterText = filter.toLowerCase();
that.eFilterTextField.value = filter;
}
else {
that.filterText = null;
that.eFilterTextField.value = null;
}
},
getType: function () {
return that.filterType;
},
getFilter: function () {
return that.filterText;
},
getModel: function () {
if (that.isFilterActive()) {
return {
type: that.filterType,
filter: that.filterText
};
}
else {
return null;
}
},
setModel: function (dataModel) {
if (dataModel) {
this.setType(dataModel.type);
this.setFilter(dataModel.filter);
}
else {
this.setFilter(null);
}
}
};
};
TextFilter.prototype.getApi = function () {
return this.api;
};
return TextFilter;
})();
exports.TextFilter = TextFilter;
/***/ },
/* 43 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var utils_1 = __webpack_require__(7);
var template = '
' +
'
' +
'' +
'
' +
'
' +
'' +
'
' +
'
' +
'' +
'
' +
'
';
var EQUALS = 1;
var LESS_THAN = 2;
var GREATER_THAN = 3;
var NumberFilter = (function () {
function NumberFilter() {
}
NumberFilter.prototype.init = function (params) {
this.filterParams = params.filterParams;
this.applyActive = this.filterParams && this.filterParams.apply === true;
this.filterChangedCallback = params.filterChangedCallback;
this.filterModifiedCallback = params.filterModifiedCallback;
this.localeTextFunc = params.localeTextFunc;
this.valueGetter = params.valueGetter;
this.createGui();
this.filterNumber = null;
this.filterType = EQUALS;
this.createApi();
};
NumberFilter.prototype.onNewRowsLoaded = function () {
var keepSelection = this.filterParams && this.filterParams.newRowsAction === 'keep';
if (!keepSelection) {
this.api.setType(EQUALS);
this.api.setFilter(null);
}
};
NumberFilter.prototype.afterGuiAttached = function () {
this.eFilterTextField.focus();
};
NumberFilter.prototype.doesFilterPass = function (node) {
if (this.filterNumber === null) {
return true;
}
var value = this.valueGetter(node);
if (!value && value !== 0) {
return false;
}
var valueAsNumber;
if (typeof value === 'number') {
valueAsNumber = value;
}
else {
valueAsNumber = parseFloat(value);
}
switch (this.filterType) {
case EQUALS:
return valueAsNumber === this.filterNumber;
case LESS_THAN:
return valueAsNumber < this.filterNumber;
case GREATER_THAN:
return valueAsNumber > this.filterNumber;
default:
// should never happen
console.warn('invalid filter type ' + this.filterType);
return false;
}
};
NumberFilter.prototype.getGui = function () {
return this.eGui;
};
NumberFilter.prototype.isFilterActive = function () {
return this.filterNumber !== null;
};
NumberFilter.prototype.createTemplate = function () {
return template
.replace('[FILTER...]', this.localeTextFunc('filterOoo', 'Filter...'))
.replace('[EQUALS]', this.localeTextFunc('equals', 'Equals'))
.replace('[LESS THAN]', this.localeTextFunc('lessThan', 'Less than'))
.replace('[GREATER THAN]', this.localeTextFunc('greaterThan', 'Greater than'))
.replace('[APPLY FILTER]', this.localeTextFunc('applyFilter', 'Apply Filter'));
};
NumberFilter.prototype.createGui = function () {
this.eGui = utils_1.Utils.loadTemplate(this.createTemplate());
this.eFilterTextField = this.eGui.querySelector("#filterText");
this.eTypeSelect = this.eGui.querySelector("#filterType");
utils_1.Utils.addChangeListener(this.eFilterTextField, this.onFilterChanged.bind(this));
this.eTypeSelect.addEventListener("change", this.onTypeChanged.bind(this));
this.setupApply();
};
NumberFilter.prototype.setupApply = function () {
var _this = this;
if (this.applyActive) {
this.eApplyButton = this.eGui.querySelector('#applyButton');
this.eApplyButton.addEventListener('click', function () {
_this.filterChangedCallback();
});
}
else {
utils_1.Utils.removeElement(this.eGui, '#applyPanel');
}
};
NumberFilter.prototype.onTypeChanged = function () {
this.filterType = parseInt(this.eTypeSelect.value);
this.filterChanged();
};
NumberFilter.prototype.filterChanged = function () {
this.filterModifiedCallback();
if (!this.applyActive) {
this.filterChangedCallback();
}
};
NumberFilter.prototype.onFilterChanged = function () {
var filterText = utils_1.Utils.makeNull(this.eFilterTextField.value);
if (filterText && filterText.trim() === '') {
filterText = null;
}
var newFilter;
if (filterText !== null && filterText !== undefined) {
newFilter = parseFloat(filterText);
}
else {
newFilter = null;
}
if (this.filterNumber !== newFilter) {
this.filterNumber = newFilter;
this.filterChanged();
}
};
NumberFilter.prototype.createApi = function () {
var that = this;
this.api = {
EQUALS: EQUALS,
LESS_THAN: LESS_THAN,
GREATER_THAN: GREATER_THAN,
setType: function (type) {
that.filterType = type;
that.eTypeSelect.value = type;
},
setFilter: function (filter) {
filter = utils_1.Utils.makeNull(filter);
if (filter !== null && !(typeof filter === 'number')) {
filter = parseFloat(filter);
}
that.filterNumber = filter;
that.eFilterTextField.value = filter;
},
getType: function () {
return that.filterType;
},
getFilter: function () {
return that.filterNumber;
},
getModel: function () {
if (that.isFilterActive()) {
return {
type: that.filterType,
filter: that.filterNumber
};
}
else {
return null;
}
},
setModel: function (dataModel) {
if (dataModel) {
this.setType(dataModel.type);
this.setFilter(dataModel.filter);
}
else {
this.setFilter(null);
}
}
};
};
NumberFilter.prototype.getApi = function () {
return this.api;
};
return NumberFilter;
})();
exports.NumberFilter = NumberFilter;
/***/ },
/* 44 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var context_1 = __webpack_require__(6);
var context_2 = __webpack_require__(6);
var eventService_1 = __webpack_require__(4);
var context_3 = __webpack_require__(6);
var events_1 = __webpack_require__(10);
var gridOptionsWrapper_1 = __webpack_require__(3);
var columnController_1 = __webpack_require__(13);
var utils_1 = __webpack_require__(7);
var gridCell_1 = __webpack_require__(31);
var FocusedCellController = (function () {
function FocusedCellController() {
}
FocusedCellController.prototype.init = function () {
this.eventService.addEventListener(events_1.Events.EVENT_COLUMN_EVERYTHING_CHANGED, this.clearFocusedCell.bind(this));
this.eventService.addEventListener(events_1.Events.EVENT_COLUMN_GROUP_OPENED, this.clearFocusedCell.bind(this));
this.eventService.addEventListener(events_1.Events.EVENT_COLUMN_MOVED, this.clearFocusedCell.bind(this));
this.eventService.addEventListener(events_1.Events.EVENT_COLUMN_PINNED, this.clearFocusedCell.bind(this));
this.eventService.addEventListener(events_1.Events.EVENT_COLUMN_ROW_GROUP_CHANGE, this.clearFocusedCell.bind(this));
this.eventService.addEventListener(events_1.Events.EVENT_COLUMN_VISIBLE, this.clearFocusedCell.bind(this));
//this.eventService.addEventListener(Events.EVENT_COLUMN_VISIBLE, this.clearFocusedCell.bind(this));
};
FocusedCellController.prototype.clearFocusedCell = function () {
this.focusedCell = null;
this.onCellFocused(false);
};
FocusedCellController.prototype.getFocusedCell = function () {
return this.focusedCell;
};
FocusedCellController.prototype.setFocusedCell = function (rowIndex, colKey, floating, forceBrowserFocus) {
if (forceBrowserFocus === void 0) { forceBrowserFocus = false; }
if (this.gridOptionsWrapper.isSuppressCellSelection()) {
return;
}
var column = utils_1.Utils.makeNull(this.columnController.getColumn(colKey));
this.focusedCell = new gridCell_1.GridCell(rowIndex, utils_1.Utils.makeNull(floating), column);
this.onCellFocused(forceBrowserFocus);
};
FocusedCellController.prototype.isCellFocused = function (rowIndex, column, floating) {
if (utils_1.Utils.missing(this.focusedCell)) {
return false;
}
return this.focusedCell.column === column && this.isRowFocused(rowIndex, floating);
};
FocusedCellController.prototype.isRowFocused = function (rowIndex, floating) {
if (utils_1.Utils.missing(this.focusedCell)) {
return false;
}
var floatingOrNull = utils_1.Utils.makeNull(floating);
return this.focusedCell.rowIndex === rowIndex && this.focusedCell.floating === floatingOrNull;
};
FocusedCellController.prototype.onCellFocused = function (forceBrowserFocus) {
var event = {
rowIndex: null,
column: null,
floating: null,
forceBrowserFocus: forceBrowserFocus
};
if (this.focusedCell) {
event.rowIndex = this.focusedCell.rowIndex;
event.column = this.focusedCell.column;
event.floating = this.focusedCell.floating;
}
this.eventService.dispatchEvent(events_1.Events.EVENT_CELL_FOCUSED, event);
};
__decorate([
context_2.Autowired('eventService'),
__metadata('design:type', eventService_1.EventService)
], FocusedCellController.prototype, "eventService", void 0);
__decorate([
context_2.Autowired('gridOptionsWrapper'),
__metadata('design:type', gridOptionsWrapper_1.GridOptionsWrapper)
], FocusedCellController.prototype, "gridOptionsWrapper", void 0);
__decorate([
context_2.Autowired('columnController'),
__metadata('design:type', columnController_1.ColumnController)
], FocusedCellController.prototype, "columnController", void 0);
__decorate([
context_3.PostConstruct,
__metadata('design:type', Function),
__metadata('design:paramtypes', []),
__metadata('design:returntype', void 0)
], FocusedCellController.prototype, "init", null);
FocusedCellController = __decorate([
context_1.Bean('focusedCellController'),
__metadata('design:paramtypes', [])
], FocusedCellController);
return FocusedCellController;
})();
exports.FocusedCellController = FocusedCellController;
/***/ },
/* 45 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var utils_1 = __webpack_require__(7);
var eventService_1 = __webpack_require__(4);
var Component = (function () {
function Component(template) {
this.destroyFunctions = [];
this.eGui = utils_1.Utils.loadTemplate(template);
}
Component.prototype.addEventListener = function (eventType, listener) {
if (!this.localEventService) {
this.localEventService = new eventService_1.EventService();
}
this.localEventService.addEventListener(eventType, listener);
};
Component.prototype.dispatchEvent = function (eventType, event) {
if (this.localEventService) {
this.localEventService.dispatchEvent(eventType, event);
}
};
Component.prototype.getGui = function () {
return this.eGui;
};
Component.prototype.queryForHtmlElement = function (cssSelector) {
return this.eGui.querySelector(cssSelector);
};
Component.prototype.queryForHtmlInputElement = function (cssSelector) {
return this.eGui.querySelector(cssSelector);
};
Component.prototype.appendChild = function (newChild) {
if (utils_1.Utils.isNodeOrElement(newChild)) {
this.eGui.appendChild(newChild);
}
else {
this.eGui.appendChild(newChild.getGui());
}
};
Component.prototype.setVisible = function (visible) {
utils_1.Utils.addOrRemoveCssClass(this.eGui, 'ag-hidden', !visible);
};
Component.prototype.destroy = function () {
this.destroyFunctions.forEach(function (func) { return func(); });
};
Component.prototype.addGuiEventListener = function (event, listener) {
var _this = this;
this.getGui().addEventListener(event, listener);
this.destroyFunctions.push(function () { return _this.getGui().removeEventListener(event, listener); });
};
Component.prototype.addDestroyableEventListener = function (eElement, event, listener) {
if (eElement instanceof eventService_1.EventService) {
eElement.addEventListener(event, listener);
}
else {
eElement.addEventListener(event, listener);
}
this.destroyFunctions.push(function () {
if (eElement instanceof eventService_1.EventService) {
eElement.removeEventListener(event, listener);
}
else {
eElement.removeEventListener(event, listener);
}
});
};
Component.prototype.addDestroyFunc = function (func) {
this.destroyFunctions.push(func);
};
return Component;
})();
exports.Component = Component;
/***/ },
/* 46 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var context_1 = __webpack_require__(6);
var constants_1 = __webpack_require__(8);
var context_2 = __webpack_require__(6);
var columnController_1 = __webpack_require__(13);
var floatingRowModel_1 = __webpack_require__(26);
var utils_1 = __webpack_require__(7);
var gridRow_1 = __webpack_require__(32);
var gridCell_1 = __webpack_require__(31);
var CellNavigationService = (function () {
function CellNavigationService() {
}
CellNavigationService.prototype.getNextCellToFocus = function (key, lastCellToFocus) {
switch (key) {
case constants_1.Constants.KEY_UP: return this.getCellAbove(lastCellToFocus);
case constants_1.Constants.KEY_DOWN: return this.getCellBelow(lastCellToFocus);
case constants_1.Constants.KEY_RIGHT: return this.getCellToRight(lastCellToFocus);
case constants_1.Constants.KEY_LEFT: return this.getCellToLeft(lastCellToFocus);
default: console.log('ag-Grid: unknown key for navigation ' + key);
}
};
CellNavigationService.prototype.getCellToLeft = function (lastCell) {
var colToLeft = this.columnController.getDisplayedColBefore(lastCell.column);
if (!colToLeft) {
return null;
}
else {
return new gridCell_1.GridCell(lastCell.rowIndex, lastCell.floating, colToLeft);
}
};
CellNavigationService.prototype.getCellToRight = function (lastCell) {
var colToRight = this.columnController.getDisplayedColAfter(lastCell.column);
// if already on right, do nothing
if (!colToRight) {
return null;
}
else {
return new gridCell_1.GridCell(lastCell.rowIndex, lastCell.floating, colToRight);
}
};
CellNavigationService.prototype.getRowBelow = function (lastRow) {
// if already on top row, do nothing
if (this.isLastRowInContainer(lastRow)) {
if (lastRow.isFloatingBottom()) {
return null;
}
else if (lastRow.isNotFloating()) {
if (this.floatingRowModel.isRowsToRender(constants_1.Constants.FLOATING_BOTTOM)) {
return new gridRow_1.GridRow(0, constants_1.Constants.FLOATING_BOTTOM);
}
else {
return null;
}
}
else {
if (this.rowModel.isRowsToRender()) {
return new gridRow_1.GridRow(0, null);
}
else if (this.floatingRowModel.isRowsToRender(constants_1.Constants.FLOATING_BOTTOM)) {
return new gridRow_1.GridRow(0, constants_1.Constants.FLOATING_BOTTOM);
}
else {
return null;
}
}
}
else {
return new gridRow_1.GridRow(lastRow.rowIndex + 1, lastRow.floating);
}
};
CellNavigationService.prototype.getCellBelow = function (lastCell) {
var rowBelow = this.getRowBelow(lastCell.getGridRow());
if (rowBelow) {
return new gridCell_1.GridCell(rowBelow.rowIndex, rowBelow.floating, lastCell.column);
}
else {
return null;
}
};
CellNavigationService.prototype.isLastRowInContainer = function (gridRow) {
if (gridRow.isFloatingTop()) {
var lastTopIndex = this.floatingRowModel.getFloatingTopRowData().length - 1;
return lastTopIndex === gridRow.rowIndex;
}
else if (gridRow.isFloatingBottom()) {
var lastBottomIndex = this.floatingRowModel.getFloatingBottomRowData().length - 1;
return lastBottomIndex === gridRow.rowIndex;
}
else {
var lastBodyIndex = this.rowModel.getRowCount() - 1;
return lastBodyIndex === gridRow.rowIndex;
}
};
CellNavigationService.prototype.getRowAbove = function (lastRow) {
// if already on top row, do nothing
if (lastRow.rowIndex === 0) {
if (lastRow.isFloatingTop()) {
return null;
}
else if (lastRow.isNotFloating()) {
if (this.floatingRowModel.isRowsToRender(constants_1.Constants.FLOATING_TOP)) {
return this.getLastFloatingTopRow();
}
else {
return null;
}
}
else {
// last floating bottom
if (this.rowModel.isRowsToRender()) {
return this.getLastBodyCell();
}
else if (this.floatingRowModel.isRowsToRender(constants_1.Constants.FLOATING_TOP)) {
return this.getLastFloatingTopRow();
}
else {
return null;
}
}
}
else {
return new gridRow_1.GridRow(lastRow.rowIndex - 1, lastRow.floating);
}
};
CellNavigationService.prototype.getCellAbove = function (lastCell) {
var rowAbove = this.getRowAbove(lastCell.getGridRow());
if (rowAbove) {
return new gridCell_1.GridCell(rowAbove.rowIndex, rowAbove.floating, lastCell.column);
}
else {
return null;
}
};
CellNavigationService.prototype.getLastBodyCell = function () {
var lastBodyRow = this.rowModel.getRowCount() - 1;
return new gridRow_1.GridRow(lastBodyRow, null);
};
CellNavigationService.prototype.getLastFloatingTopRow = function () {
var lastFloatingRow = this.floatingRowModel.getFloatingTopRowData().length - 1;
return new gridRow_1.GridRow(lastFloatingRow, constants_1.Constants.FLOATING_TOP);
};
CellNavigationService.prototype.getNextTabbedCellForwards = function (gridCell) {
var displayedColumns = this.columnController.getAllDisplayedColumns();
var newRowIndex = gridCell.rowIndex;
var newFloating = gridCell.floating;
// move along to the next cell
var newColumn = this.columnController.getDisplayedColAfter(gridCell.column);
// check if end of the row, and if so, go forward a row
if (!newColumn) {
newColumn = displayedColumns[0];
var rowBelow = this.getRowBelow(gridCell.getGridRow());
if (utils_1.Utils.missing(rowBelow)) {
return;
}
newRowIndex = rowBelow.rowIndex;
newFloating = rowBelow.floating;
}
return new gridCell_1.GridCell(newRowIndex, newFloating, newColumn);
};
CellNavigationService.prototype.getNextTabbedCellBackwards = function (gridCell) {
var displayedColumns = this.columnController.getAllDisplayedColumns();
var newRowIndex = gridCell.rowIndex;
var newFloating = gridCell.floating;
// move along to the next cell
var newColumn = this.columnController.getDisplayedColBefore(gridCell.column);
// check if end of the row, and if so, go forward a row
if (!newColumn) {
newColumn = displayedColumns[displayedColumns.length - 1];
var rowAbove = this.getRowAbove(gridCell.getGridRow());
if (utils_1.Utils.missing(rowAbove)) {
return;
}
newRowIndex = rowAbove.rowIndex;
newFloating = rowAbove.floating;
}
return new gridCell_1.GridCell(newRowIndex, newFloating, newColumn);
};
__decorate([
context_2.Autowired('columnController'),
__metadata('design:type', columnController_1.ColumnController)
], CellNavigationService.prototype, "columnController", void 0);
__decorate([
context_2.Autowired('rowModel'),
__metadata('design:type', Object)
], CellNavigationService.prototype, "rowModel", void 0);
__decorate([
context_2.Autowired('floatingRowModel'),
__metadata('design:type', floatingRowModel_1.FloatingRowModel)
], CellNavigationService.prototype, "floatingRowModel", void 0);
CellNavigationService = __decorate([
context_1.Bean('cellNavigationService'),
__metadata('design:paramtypes', [])
], CellNavigationService);
return CellNavigationService;
})();
exports.CellNavigationService = CellNavigationService;
/***/ },
/* 47 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
var gridOptionsWrapper_1 = __webpack_require__(3);
var logger_1 = __webpack_require__(5);
var columnUtils_1 = __webpack_require__(16);
var columnKeyCreator_1 = __webpack_require__(48);
var originalColumnGroup_1 = __webpack_require__(17);
var column_1 = __webpack_require__(15);
var context_1 = __webpack_require__(6);
var context_2 = __webpack_require__(6);
var context_3 = __webpack_require__(6);
var context_4 = __webpack_require__(6);
// takes in a list of columns, as specified by the column definitions, and returns column groups
var BalancedColumnTreeBuilder = (function () {
function BalancedColumnTreeBuilder() {
}
BalancedColumnTreeBuilder.prototype.agWire = function (loggerFactory) {
this.logger = loggerFactory.create('BalancedColumnTreeBuilder');
};
BalancedColumnTreeBuilder.prototype.createBalancedColumnGroups = function (abstractColDefs) {
// column key creator dishes out unique column id's in a deterministic way,
// so if we have two grids (that cold be master/slave) with same column definitions,
// then this ensures the two grids use identical id's.
var columnKeyCreator = new columnKeyCreator_1.ColumnKeyCreator();
// create am unbalanced tree that maps the provided definitions
var unbalancedTree = this.recursivelyCreateColumns(abstractColDefs, 0, columnKeyCreator);
var treeDept = this.findMaxDept(unbalancedTree, 0);
this.logger.log('Number of levels for grouped columns is ' + treeDept);
var balancedTree = this.balanceColumnTree(unbalancedTree, 0, treeDept, columnKeyCreator);
this.columnUtils.deptFirstOriginalTreeSearch(balancedTree, function (child) {
if (child instanceof originalColumnGroup_1.OriginalColumnGroup) {
child.calculateExpandable();
}
});
return {
balancedTree: balancedTree,
treeDept: treeDept
};
};
BalancedColumnTreeBuilder.prototype.balanceColumnTree = function (unbalancedTree, currentDept, columnDept, columnKeyCreator) {
var _this = this;
var result = [];
// go through each child, for groups, recurse a level deeper,
// for columns we need to pad
unbalancedTree.forEach(function (child) {
if (child instanceof originalColumnGroup_1.OriginalColumnGroup) {
var originalGroup = child;
var newChildren = _this.balanceColumnTree(originalGroup.getChildren(), currentDept + 1, columnDept, columnKeyCreator);
originalGroup.setChildren(newChildren);
result.push(originalGroup);
}
else {
var newChild = child;
for (var i = columnDept - 1; i >= currentDept; i--) {
var newColId = columnKeyCreator.getUniqueKey(null, null);
var paddedGroup = new originalColumnGroup_1.OriginalColumnGroup(null, newColId);
paddedGroup.setChildren([newChild]);
newChild = paddedGroup;
}
result.push(newChild);
}
});
return result;
};
BalancedColumnTreeBuilder.prototype.findMaxDept = function (treeChildren, dept) {
var maxDeptThisLevel = dept;
for (var i = 0; i < treeChildren.length; i++) {
var abstractColumn = treeChildren[i];
if (abstractColumn instanceof originalColumnGroup_1.OriginalColumnGroup) {
var originalGroup = abstractColumn;
var newDept = this.findMaxDept(originalGroup.getChildren(), dept + 1);
if (maxDeptThisLevel < newDept) {
maxDeptThisLevel = newDept;
}
}
}
return maxDeptThisLevel;
};
BalancedColumnTreeBuilder.prototype.recursivelyCreateColumns = function (abstractColDefs, level, columnKeyCreator) {
var _this = this;
var result = [];
if (!abstractColDefs) {
return result;
}
abstractColDefs.forEach(function (abstractColDef) {
_this.checkForDeprecatedItems(abstractColDef);
if (_this.isColumnGroup(abstractColDef)) {
var groupColDef = abstractColDef;
var groupId = columnKeyCreator.getUniqueKey(groupColDef.groupId, null);
var originalGroup = new originalColumnGroup_1.OriginalColumnGroup(groupColDef, groupId);
var children = _this.recursivelyCreateColumns(groupColDef.children, level + 1, columnKeyCreator);
originalGroup.setChildren(children);
result.push(originalGroup);
}
else {
var colDef = abstractColDef;
var colId = columnKeyCreator.getUniqueKey(colDef.colId, colDef.field);
var column = new column_1.Column(colDef, colId);
_this.context.wireBean(column);
result.push(column);
}
});
return result;
};
BalancedColumnTreeBuilder.prototype.checkForDeprecatedItems = function (colDef) {
if (colDef) {
var colDefNoType = colDef; // take out the type, so we can access attributes not defined in the type
if (colDefNoType.group !== undefined) {
console.warn('ag-grid: colDef.group is invalid, please check documentation on how to do grouping as it changed in version 3');
}
if (colDefNoType.headerGroup !== undefined) {
console.warn('ag-grid: colDef.headerGroup is invalid, please check documentation on how to do grouping as it changed in version 3');
}
if (colDefNoType.headerGroupShow !== undefined) {
console.warn('ag-grid: colDef.headerGroupShow is invalid, should be columnGroupShow, please check documentation on how to do grouping as it changed in version 3');
}
}
};
// if object has children, we assume it's a group
BalancedColumnTreeBuilder.prototype.isColumnGroup = function (abstractColDef) {
return abstractColDef.children !== undefined;
};
__decorate([
context_3.Autowired('gridOptionsWrapper'),
__metadata('design:type', gridOptionsWrapper_1.GridOptionsWrapper)
], BalancedColumnTreeBuilder.prototype, "gridOptionsWrapper", void 0);
__decorate([
context_3.Autowired('columnUtils'),
__metadata('design:type', columnUtils_1.ColumnUtils)
], BalancedColumnTreeBuilder.prototype, "columnUtils", void 0);
__decorate([
context_3.Autowired('context'),
__metadata('design:type', context_4.Context)
], BalancedColumnTreeBuilder.prototype, "context", void 0);
__decorate([
__param(0, context_2.Qualifier('loggerFactory')),
__metadata('design:type', Function),
__metadata('design:paramtypes', [logger_1.LoggerFactory]),
__metadata('design:returntype', void 0)
], BalancedColumnTreeBuilder.prototype, "agWire", null);
BalancedColumnTreeBuilder = __decorate([
context_1.Bean('balancedColumnTreeBuilder'),
__metadata('design:paramtypes', [])
], BalancedColumnTreeBuilder);
return BalancedColumnTreeBuilder;
})();
exports.BalancedColumnTreeBuilder = BalancedColumnTreeBuilder;
/***/ },
/* 48 */
/***/ function(module, exports) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
// class returns a unique id to use for the column. it checks the existing columns, and if the requested
// id is already taken, it will start appending numbers until it gets a unique id.
// eg, if the col field is 'name', it will try ids: {name, name_1, name_2...}
// if no field or id provided in the col, it will try the ids of natural numbers
var ColumnKeyCreator = (function () {
function ColumnKeyCreator() {
this.existingKeys = [];
}
ColumnKeyCreator.prototype.getUniqueKey = function (colId, colField) {
var count = 0;
while (true) {
var idToTry;
if (colId) {
idToTry = colId;
if (count !== 0) {
idToTry += '_' + count;
}
}
else if (colField) {
idToTry = colField;
if (count !== 0) {
idToTry += '_' + count;
}
}
else {
idToTry = '' + count;
}
if (this.existingKeys.indexOf(idToTry) < 0) {
this.existingKeys.push(idToTry);
return idToTry;
}
count++;
}
};
return ColumnKeyCreator;
})();
exports.ColumnKeyCreator = ColumnKeyCreator;
/***/ },
/* 49 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var columnUtils_1 = __webpack_require__(16);
var columnGroup_1 = __webpack_require__(14);
var originalColumnGroup_1 = __webpack_require__(17);
var context_1 = __webpack_require__(6);
var context_2 = __webpack_require__(6);
// takes in a list of columns, as specified by the column definitions, and returns column groups
var DisplayedGroupCreator = (function () {
function DisplayedGroupCreator() {
}
DisplayedGroupCreator.prototype.createDisplayedGroups = function (sortedVisibleColumns, balancedColumnTree, groupInstanceIdCreator) {
var _this = this;
var result = [];
var previousRealPath;
var previousOriginalPath;
// go through each column, then do a bottom up comparison to the previous column, and start
// to share groups if they converge at any point.
sortedVisibleColumns.forEach(function (currentColumn) {
var currentOriginalPath = _this.getOriginalPathForColumn(balancedColumnTree, currentColumn);
var currentRealPath = [];
var firstColumn = !previousOriginalPath;
for (var i = 0; i < currentOriginalPath.length; i++) {
if (firstColumn || currentOriginalPath[i] !== previousOriginalPath[i]) {
// new group needed
var originalGroup = currentOriginalPath[i];
var groupId = originalGroup.getGroupId();
var instanceId = groupInstanceIdCreator.getInstanceIdForKey(groupId);
var newGroup = new columnGroup_1.ColumnGroup(originalGroup, groupId, instanceId);
currentRealPath[i] = newGroup;
// if top level, add to result, otherwise add to parent
if (i == 0) {
result.push(newGroup);
}
else {
currentRealPath[i - 1].addChild(newGroup);
}
}
else {
// reuse old group
currentRealPath[i] = previousRealPath[i];
}
}
var noColumnGroups = currentRealPath.length === 0;
if (noColumnGroups) {
// if we are not grouping, then the result of the above is an empty
// path (no groups), and we just add the column to the root list.
result.push(currentColumn);
}
else {
var leafGroup = currentRealPath[currentRealPath.length - 1];
leafGroup.addChild(currentColumn);
}
previousRealPath = currentRealPath;
previousOriginalPath = currentOriginalPath;
});
return result;
};
DisplayedGroupCreator.prototype.createFakePath = function (balancedColumnTree) {
var result = [];
var currentChildren = balancedColumnTree;
// this while look does search on the balanced tree, so our result is the right length
var index = 0;
while (currentChildren && currentChildren[0] && currentChildren[0] instanceof originalColumnGroup_1.OriginalColumnGroup) {
// putting in a deterministic fake id, in case the API in the future needs to reference the col
result.push(new originalColumnGroup_1.OriginalColumnGroup(null, 'FAKE_PATH_' + index));
currentChildren = currentChildren[0].getChildren();
index++;
}
return result;
};
DisplayedGroupCreator.prototype.getOriginalPathForColumn = function (balancedColumnTree, column) {
var result = [];
var found = false;
recursePath(balancedColumnTree, 0);
// it's possible we didn't find a path. this happens if the column is generated
// by the grid, in that the definition didn't come from the client. in this case,
// we create a fake original path.
if (found) {
return result;
}
else {
return this.createFakePath(balancedColumnTree);
}
function recursePath(balancedColumnTree, dept) {
for (var i = 0; i < balancedColumnTree.length; i++) {
if (found) {
// quit the search, so 'result' is kept with the found result
return;
}
var node = balancedColumnTree[i];
if (node instanceof originalColumnGroup_1.OriginalColumnGroup) {
var nextNode = node;
recursePath(nextNode.getChildren(), dept + 1);
result[dept] = node;
}
else {
if (node === column) {
found = true;
}
}
}
}
};
__decorate([
context_2.Autowired('columnUtils'),
__metadata('design:type', columnUtils_1.ColumnUtils)
], DisplayedGroupCreator.prototype, "columnUtils", void 0);
DisplayedGroupCreator = __decorate([
context_1.Bean('displayedGroupCreator'),
__metadata('design:paramtypes', [])
], DisplayedGroupCreator);
return DisplayedGroupCreator;
})();
exports.DisplayedGroupCreator = DisplayedGroupCreator;
/***/ },
/* 50 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var rowRenderer_1 = __webpack_require__(23);
var gridPanel_1 = __webpack_require__(24);
var context_1 = __webpack_require__(6);
var context_2 = __webpack_require__(6);
var AutoWidthCalculator = (function () {
function AutoWidthCalculator() {
}
// this is the trick: we create a dummy container and clone all the cells
// into the dummy, then check the dummy's width. then destroy the dummy
// as we don't need it any more.
// drawback: only the cells visible on the screen are considered
AutoWidthCalculator.prototype.getPreferredWidthForColumn = function (column) {
var eDummyContainer = document.createElement('span');
// position fixed, so it isn't restricted to the boundaries of the parent
eDummyContainer.style.position = 'fixed';
// we put the dummy into the body container, so it will inherit all the
// css styles that the real cells are inheriting
var eBodyContainer = this.gridPanel.getBodyContainer();
eBodyContainer.appendChild(eDummyContainer);
// get all the cells that are currently displayed (this only brings back
// rendered cells, rows not rendered due to row visualisation will not be here)
var eOriginalCells = this.rowRenderer.getAllCellsForColumn(column);
eOriginalCells.forEach(function (eCell, index) {
// make a deep clone of the cell
var eCellClone = eCell.cloneNode(true);
// the original has a fixed width, we remove this to allow the natural width based on content
eCellClone.style.width = '';
// the original has position = absolute, we need to remove this so it's positioned normally
eCellClone.style.position = 'static';
eCellClone.style.left = '';
// we put the cell into a containing div, as otherwise the cells would just line up
// on the same line, standard flow layout, by putting them into divs, they are laid
// out one per line
var eCloneParent = document.createElement('div');
// table-row, so that each cell is on a row. i also tried display='block', but this
// didn't work in IE
eCloneParent.style.display = 'table-row';
// the twig on the branch, the branch on the tree, the tree in the hole,
// the hole in the bog, the bog in the clone, the clone in the parent,
// the parent in the dummy, and the dummy down in the vall-e-ooo, OOOOOOOOO! Oh row the rattling bog....
eCloneParent.appendChild(eCellClone);
eDummyContainer.appendChild(eCloneParent);
});
// at this point, all the clones are lined up vertically with natural widths. the dummy
// container will have a width wide enough just to fit the largest.
var dummyContainerWidth = eDummyContainer.offsetWidth;
// we are finished with the dummy container, so get rid of it
eBodyContainer.removeChild(eDummyContainer);
// we add 4 as I found without it, the gui still put '...' after some of the texts
return dummyContainerWidth + 4;
};
__decorate([
context_2.Autowired('rowRenderer'),
__metadata('design:type', rowRenderer_1.RowRenderer)
], AutoWidthCalculator.prototype, "rowRenderer", void 0);
__decorate([
context_2.Autowired('gridPanel'),
__metadata('design:type', gridPanel_1.GridPanel)
], AutoWidthCalculator.prototype, "gridPanel", void 0);
AutoWidthCalculator = __decorate([
context_1.Bean('autoWidthCalculator'),
__metadata('design:paramtypes', [])
], AutoWidthCalculator);
return AutoWidthCalculator;
})();
exports.AutoWidthCalculator = AutoWidthCalculator;
/***/ },
/* 51 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var events_1 = __webpack_require__(10);
var ColumnChangeEvent = (function () {
function ColumnChangeEvent(type) {
this.type = type;
}
ColumnChangeEvent.prototype.toString = function () {
var result = 'ColumnChangeEvent {type: ' + this.type;
if (this.column) {
result += ', column: ' + this.column.getColId();
}
if (this.columnGroup) {
result += true ? this.columnGroup.getColGroupDef().headerName : '(not defined]';
}
if (this.toIndex) {
result += ', toIndex: ' + this.toIndex;
}
if (this.visible) {
result += ', visible: ' + this.visible;
}
if (this.pinned) {
result += ', pinned: ' + this.pinned;
}
if (typeof this.finished == 'boolean') {
result += ', finished: ' + this.finished;
}
result += '}';
return result;
};
ColumnChangeEvent.prototype.withPinned = function (pinned) {
this.pinned = pinned;
return this;
};
ColumnChangeEvent.prototype.withVisible = function (visible) {
this.visible = visible;
return this;
};
ColumnChangeEvent.prototype.isVisible = function () {
return this.visible;
};
ColumnChangeEvent.prototype.getPinned = function () {
return this.pinned;
};
ColumnChangeEvent.prototype.withColumn = function (column) {
this.column = column;
return this;
};
ColumnChangeEvent.prototype.withColumns = function (columns) {
this.columns = columns;
return this;
};
ColumnChangeEvent.prototype.withFinished = function (finished) {
this.finished = finished;
return this;
};
ColumnChangeEvent.prototype.withColumnGroup = function (columnGroup) {
this.columnGroup = columnGroup;
return this;
};
ColumnChangeEvent.prototype.withToIndex = function (toIndex) {
this.toIndex = toIndex;
return this;
};
ColumnChangeEvent.prototype.getToIndex = function () {
return this.toIndex;
};
ColumnChangeEvent.prototype.getType = function () {
return this.type;
};
ColumnChangeEvent.prototype.getColumn = function () {
return this.column;
};
ColumnChangeEvent.prototype.getColumns = function () {
return this.columns;
};
ColumnChangeEvent.prototype.getColumnGroup = function () {
return this.columnGroup;
};
ColumnChangeEvent.prototype.isPinnedPanelVisibilityImpacted = function () {
return this.type === events_1.Events.EVENT_COLUMN_EVERYTHING_CHANGED ||
this.type === events_1.Events.EVENT_COLUMN_GROUP_OPENED ||
this.type === events_1.Events.EVENT_COLUMN_VISIBLE ||
this.type === events_1.Events.EVENT_COLUMN_PINNED;
};
ColumnChangeEvent.prototype.isContainerWidthImpacted = function () {
return this.type === events_1.Events.EVENT_COLUMN_EVERYTHING_CHANGED ||
this.type === events_1.Events.EVENT_COLUMN_GROUP_OPENED ||
this.type === events_1.Events.EVENT_COLUMN_VISIBLE ||
this.type === events_1.Events.EVENT_COLUMN_RESIZED ||
this.type === events_1.Events.EVENT_COLUMN_PINNED ||
this.type === events_1.Events.EVENT_COLUMN_ROW_GROUP_CHANGE;
};
ColumnChangeEvent.prototype.isIndividualColumnResized = function () {
return this.type === events_1.Events.EVENT_COLUMN_RESIZED && this.column !== undefined && this.column !== null;
};
ColumnChangeEvent.prototype.isFinished = function () {
return this.finished;
};
return ColumnChangeEvent;
})();
exports.ColumnChangeEvent = ColumnChangeEvent;
/***/ },
/* 52 */
/***/ function(module, exports) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
// class returns unique instance id's for columns.
// eg, the following calls (in this order) will result in:
//
// getInstanceIdForKey('country') => 0
// getInstanceIdForKey('country') => 1
// getInstanceIdForKey('country') => 2
// getInstanceIdForKey('country') => 3
// getInstanceIdForKey('age') => 0
// getInstanceIdForKey('age') => 1
// getInstanceIdForKey('country') => 4
var GroupInstanceIdCreator = (function () {
function GroupInstanceIdCreator() {
// this map contains keys to numbers, so we remember what the last call was
this.existingIds = {};
}
GroupInstanceIdCreator.prototype.getInstanceIdForKey = function (key) {
var lastResult = this.existingIds[key];
var result;
if (typeof lastResult !== 'number') {
// first time this key
result = 0;
}
else {
result = lastResult + 1;
}
this.existingIds[key] = result;
return result;
};
return GroupInstanceIdCreator;
})();
exports.GroupInstanceIdCreator = GroupInstanceIdCreator;
/***/ },
/* 53 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var utils_1 = __webpack_require__(7);
function defaultGroupComparator(valueA, valueB, nodeA, nodeB) {
var nodeAIsGroup = utils_1.Utils.exists(nodeA) && nodeA.group;
var nodeBIsGroup = utils_1.Utils.exists(nodeB) && nodeB.group;
var bothAreGroups = nodeAIsGroup && nodeBIsGroup;
var bothAreNormal = !nodeAIsGroup && !nodeBIsGroup;
if (bothAreGroups) {
return utils_1.Utils.defaultComparator(nodeA.key, nodeB.key);
}
else if (bothAreNormal) {
return utils_1.Utils.defaultComparator(valueA, valueB);
}
else if (nodeAIsGroup) {
return 1;
}
else {
return -1;
}
}
exports.defaultGroupComparator = defaultGroupComparator;
/***/ },
/* 54 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var gridOptionsWrapper_1 = __webpack_require__(3);
var columnController_1 = __webpack_require__(13);
var gridPanel_1 = __webpack_require__(24);
var column_1 = __webpack_require__(15);
var context_1 = __webpack_require__(6);
var context_2 = __webpack_require__(6);
var context_3 = __webpack_require__(6);
var headerContainer_1 = __webpack_require__(55);
var eventService_1 = __webpack_require__(4);
var events_1 = __webpack_require__(10);
var context_4 = __webpack_require__(6);
var HeaderRenderer = (function () {
function HeaderRenderer() {
}
HeaderRenderer.prototype.init = function () {
this.eHeaderViewport = this.gridPanel.getHeaderViewport();
this.eRoot = this.gridPanel.getRoot();
this.eHeaderOverlay = this.gridPanel.getHeaderOverlay();
this.pinnedLeftContainer = new headerContainer_1.HeaderContainer(this.gridPanel.getPinnedLeftHeader(), null, this.eRoot, column_1.Column.PINNED_LEFT);
this.pinnedRightContainer = new headerContainer_1.HeaderContainer(this.gridPanel.getPinnedRightHeader(), null, this.eRoot, column_1.Column.PINNED_RIGHT);
this.centerContainer = new headerContainer_1.HeaderContainer(this.gridPanel.getHeaderContainer(), this.gridPanel.getHeaderViewport(), this.eRoot, null);
this.context.wireBean(this.pinnedLeftContainer);
this.context.wireBean(this.pinnedRightContainer);
this.context.wireBean(this.centerContainer);
// unlike the table data, the header more often 'refreshes everything' as a way to redraw, rather than
// do delta changes based on the event. this is because groups have bigger impacts, eg a column move
// can end up in a group splitting into two, or joining into one. this complexity makes the job much
// harder to do delta updates. instead we just shotgun - which is fine, as the header is relatively
// small compared to the body, so the cpu cost is low in comparison. it does mean we don't get any
// animations.
this.eventService.addEventListener(events_1.Events.EVENT_COLUMN_EVERYTHING_CHANGED, this.refreshHeader.bind(this));
this.eventService.addEventListener(events_1.Events.EVENT_COLUMN_ROW_GROUP_CHANGE, this.refreshHeader.bind(this));
this.eventService.addEventListener(events_1.Events.EVENT_COLUMN_MOVED, this.refreshHeader.bind(this));
this.eventService.addEventListener(events_1.Events.EVENT_COLUMN_VISIBLE, this.refreshHeader.bind(this));
this.eventService.addEventListener(events_1.Events.EVENT_COLUMN_GROUP_OPENED, this.refreshHeader.bind(this));
this.eventService.addEventListener(events_1.Events.EVENT_COLUMN_PINNED, this.refreshHeader.bind(this));
this.eventService.addEventListener(events_1.Events.EVENT_HEADER_HEIGHT_CHANGED, this.refreshHeader.bind(this));
// for resized, the individual cells take care of this, so don't need to refresh everything
this.eventService.addEventListener(events_1.Events.EVENT_COLUMN_RESIZED, this.setPinnedColContainerWidth.bind(this));
if (this.columnController.isReady()) {
this.refreshHeader();
}
};
// this is called from the API and refreshes everything, should be broken out
// into refresh everything vs just something changed
HeaderRenderer.prototype.refreshHeader = function () {
this.pinnedLeftContainer.removeAllChildren();
this.pinnedRightContainer.removeAllChildren();
this.centerContainer.removeAllChildren();
this.pinnedLeftContainer.insertHeaderRowsIntoContainer();
this.pinnedRightContainer.insertHeaderRowsIntoContainer();
this.centerContainer.insertHeaderRowsIntoContainer();
// if forPrint, overlay is missing
var rowHeight = this.gridOptionsWrapper.getHeaderHeight();
// we can probably get rid of this when we no longer need the overlay
var dept = this.columnController.getColumnDept();
if (this.eHeaderOverlay) {
this.eHeaderOverlay.style.height = rowHeight + 'px';
this.eHeaderOverlay.style.top = ((dept - 1) * rowHeight) + 'px';
}
this.setPinnedColContainerWidth();
};
HeaderRenderer.prototype.setPinnedColContainerWidth = function () {
if (this.gridOptionsWrapper.isForPrint()) {
// pinned col doesn't exist when doing forPrint
return;
}
var pinnedLeftWidth = this.columnController.getPinnedLeftContainerWidth() + 'px';
this.eHeaderViewport.style.marginLeft = pinnedLeftWidth;
var pinnedRightWidth = this.columnController.getPinnedRightContainerWidth() + 'px';
this.eHeaderViewport.style.marginRight = pinnedRightWidth;
};
HeaderRenderer.prototype.onIndividualColumnResized = function (column) {
this.pinnedLeftContainer.onIndividualColumnResized(column);
this.pinnedRightContainer.onIndividualColumnResized(column);
this.centerContainer.onIndividualColumnResized(column);
};
__decorate([
context_2.Autowired('gridOptionsWrapper'),
__metadata('design:type', gridOptionsWrapper_1.GridOptionsWrapper)
], HeaderRenderer.prototype, "gridOptionsWrapper", void 0);
__decorate([
context_2.Autowired('columnController'),
__metadata('design:type', columnController_1.ColumnController)
], HeaderRenderer.prototype, "columnController", void 0);
__decorate([
context_2.Autowired('gridPanel'),
__metadata('design:type', gridPanel_1.GridPanel)
], HeaderRenderer.prototype, "gridPanel", void 0);
__decorate([
context_2.Autowired('context'),
__metadata('design:type', context_3.Context)
], HeaderRenderer.prototype, "context", void 0);
__decorate([
context_2.Autowired('eventService'),
__metadata('design:type', eventService_1.EventService)
], HeaderRenderer.prototype, "eventService", void 0);
__decorate([
context_4.PostConstruct,
__metadata('design:type', Function),
__metadata('design:paramtypes', []),
__metadata('design:returntype', void 0)
], HeaderRenderer.prototype, "init", null);
HeaderRenderer = __decorate([
context_1.Bean('headerRenderer'),
__metadata('design:paramtypes', [])
], HeaderRenderer);
return HeaderRenderer;
})();
exports.HeaderRenderer = HeaderRenderer;
/***/ },
/* 55 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var utils_1 = __webpack_require__(7);
var columnGroup_1 = __webpack_require__(14);
var gridOptionsWrapper_1 = __webpack_require__(3);
var context_1 = __webpack_require__(6);
var column_1 = __webpack_require__(15);
var context_2 = __webpack_require__(6);
var renderedHeaderGroupCell_1 = __webpack_require__(56);
var renderedHeaderCell_1 = __webpack_require__(59);
var dragAndDropService_1 = __webpack_require__(61);
var moveColumnController_1 = __webpack_require__(62);
var columnController_1 = __webpack_require__(13);
var gridPanel_1 = __webpack_require__(24);
var context_3 = __webpack_require__(6);
var HeaderContainer = (function () {
function HeaderContainer(eContainer, eViewport, eRoot, pinned) {
this.headerElements = [];
this.eContainer = eContainer;
this.eRoot = eRoot;
this.pinned = pinned;
this.eViewport = eViewport;
}
HeaderContainer.prototype.init = function () {
var moveColumnController = new moveColumnController_1.MoveColumnController(this.pinned);
this.context.wireBean(moveColumnController);
var secondaryContainers;
switch (this.pinned) {
case column_1.Column.PINNED_LEFT:
secondaryContainers = this.gridPanel.getDropTargetLeftContainers();
break;
case column_1.Column.PINNED_RIGHT:
secondaryContainers = this.gridPanel.getDropTargetPinnedRightContainers();
break;
default:
secondaryContainers = this.gridPanel.getDropTargetBodyContainers();
break;
}
var icon = this.pinned ? dragAndDropService_1.DragAndDropService.ICON_PINNED : dragAndDropService_1.DragAndDropService.ICON_MOVE;
this.dropTarget = {
eContainer: this.eViewport ? this.eViewport : this.eContainer,
iconName: icon,
eSecondaryContainers: secondaryContainers,
onDragging: moveColumnController.onDragging.bind(moveColumnController),
onDragEnter: moveColumnController.onDragEnter.bind(moveColumnController),
onDragLeave: moveColumnController.onDragLeave.bind(moveColumnController),
onDragStop: moveColumnController.onDragStop.bind(moveColumnController)
};
this.dragAndDropService.addDropTarget(this.dropTarget);
};
HeaderContainer.prototype.removeAllChildren = function () {
this.headerElements.forEach(function (headerElement) {
headerElement.destroy();
});
this.headerElements.length = 0;
utils_1.Utils.removeAllChildren(this.eContainer);
};
HeaderContainer.prototype.insertHeaderRowsIntoContainer = function () {
var _this = this;
var cellTree = this.columnController.getDisplayedColumnGroups(this.pinned);
// if we are displaying header groups, then we have many rows here.
// go through each row of the header, one by one.
var rowHeight = this.gridOptionsWrapper.getHeaderHeight();
for (var dept = 0;; dept++) {
var nodesAtDept = [];
this.addTreeNodesAtDept(cellTree, dept, nodesAtDept);
// we want to break the for loop when we get to an empty set of cells,
// that's how we know we have finished rendering the last row.
if (nodesAtDept.length === 0) {
break;
}
var eRow = document.createElement('div');
eRow.className = 'ag-header-row';
eRow.style.top = (dept * rowHeight) + 'px';
eRow.style.height = rowHeight + 'px';
nodesAtDept.forEach(function (child) {
// skip groups that have no displayed children. this can happen when the group is broken,
// and this section happens to have nothing to display for the open / closed state
if (child instanceof columnGroup_1.ColumnGroup && child.getDisplayedChildren().length == 0) {
return;
}
var renderedHeaderElement = _this.createHeaderElement(child);
_this.headerElements.push(renderedHeaderElement);
var eGui = renderedHeaderElement.getGui();
eRow.appendChild(eGui);
});
this.eContainer.appendChild(eRow);
}
};
HeaderContainer.prototype.addTreeNodesAtDept = function (cellTree, dept, result) {
var _this = this;
cellTree.forEach(function (abstractColumn) {
if (dept === 0) {
result.push(abstractColumn);
}
else if (abstractColumn instanceof columnGroup_1.ColumnGroup) {
var columnGroup = abstractColumn;
_this.addTreeNodesAtDept(columnGroup.getDisplayedChildren(), dept - 1, result);
}
else {
}
});
};
HeaderContainer.prototype.createHeaderElement = function (columnGroupChild) {
var result;
if (columnGroupChild instanceof columnGroup_1.ColumnGroup) {
result = new renderedHeaderGroupCell_1.RenderedHeaderGroupCell(columnGroupChild, this.eRoot, this.$scope);
}
else {
result = new renderedHeaderCell_1.RenderedHeaderCell(columnGroupChild, this.$scope, this.eRoot, this.dropTarget);
}
this.context.wireBean(result);
return result;
};
HeaderContainer.prototype.onIndividualColumnResized = function (column) {
this.headerElements.forEach(function (headerElement) {
headerElement.onIndividualColumnResized(column);
});
};
__decorate([
context_1.Autowired('gridOptionsWrapper'),
__metadata('design:type', gridOptionsWrapper_1.GridOptionsWrapper)
], HeaderContainer.prototype, "gridOptionsWrapper", void 0);
__decorate([
context_1.Autowired('context'),
__metadata('design:type', context_2.Context)
], HeaderContainer.prototype, "context", void 0);
__decorate([
context_1.Autowired('$scope'),
__metadata('design:type', Object)
], HeaderContainer.prototype, "$scope", void 0);
__decorate([
context_1.Autowired('dragAndDropService'),
__metadata('design:type', dragAndDropService_1.DragAndDropService)
], HeaderContainer.prototype, "dragAndDropService", void 0);
__decorate([
context_1.Autowired('columnController'),
__metadata('design:type', columnController_1.ColumnController)
], HeaderContainer.prototype, "columnController", void 0);
__decorate([
context_1.Autowired('gridPanel'),
__metadata('design:type', gridPanel_1.GridPanel)
], HeaderContainer.prototype, "gridPanel", void 0);
__decorate([
context_3.PostConstruct,
__metadata('design:type', Function),
__metadata('design:paramtypes', []),
__metadata('design:returntype', void 0)
], HeaderContainer.prototype, "init", null);
return HeaderContainer;
})();
exports.HeaderContainer = HeaderContainer;
/***/ },
/* 56 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var utils_1 = __webpack_require__(7);
var svgFactory_1 = __webpack_require__(36);
var columnController_1 = __webpack_require__(13);
var filterManager_1 = __webpack_require__(40);
var gridOptionsWrapper_1 = __webpack_require__(3);
var column_1 = __webpack_require__(15);
var horizontalDragService_1 = __webpack_require__(57);
var context_1 = __webpack_require__(6);
var cssClassApplier_1 = __webpack_require__(58);
var context_2 = __webpack_require__(6);
var svgFactory = svgFactory_1.SvgFactory.getInstance();
var RenderedHeaderGroupCell = (function () {
function RenderedHeaderGroupCell(columnGroup, eRoot, parentScope) {
this.destroyFunctions = [];
this.columnGroup = columnGroup;
this.parentScope = parentScope;
this.eRoot = eRoot;
this.parentScope = parentScope;
}
// required by interface, but we don't use
RenderedHeaderGroupCell.prototype.refreshFilterIcon = function () { };
// required by interface, but we don't use
RenderedHeaderGroupCell.prototype.refreshSortIcon = function () { };
RenderedHeaderGroupCell.prototype.getGui = function () {
return this.eHeaderGroupCell;
};
RenderedHeaderGroupCell.prototype.onIndividualColumnResized = function (column) {
if (this.columnGroup.isChildInThisGroupDeepSearch(column)) {
this.setWidthOfGroupHeaderCell();
}
};
RenderedHeaderGroupCell.prototype.init = function () {
var _this = this;
this.eHeaderGroupCell = document.createElement('div');
var classNames = ['ag-header-group-cell'];
// having different classes below allows the style to not have a bottom border
// on the group header, if no group is specified
if (this.columnGroup.getColGroupDef()) {
classNames.push('ag-header-group-cell-with-group');
}
else {
classNames.push('ag-header-group-cell-no-group');
}
this.eHeaderGroupCell.className = classNames.join(' ');
//this.eHeaderGroupCell.style.height = this.getGridOptionsWrapper().getHeaderHeight() + 'px';
cssClassApplier_1.CssClassApplier.addHeaderClassesFromCollDef(this.columnGroup.getColGroupDef(), this.eHeaderGroupCell, this.gridOptionsWrapper);
if (this.gridOptionsWrapper.isEnableColResize()) {
this.eHeaderCellResize = document.createElement("div");
this.eHeaderCellResize.className = "ag-header-cell-resize";
this.eHeaderGroupCell.appendChild(this.eHeaderCellResize);
this.dragService.addDragHandling({
eDraggableElement: this.eHeaderCellResize,
eBody: this.eRoot,
cursor: 'col-resize',
startAfterPixels: 0,
onDragStart: this.onDragStart.bind(this),
onDragging: this.onDragging.bind(this)
});
if (!this.gridOptionsWrapper.isSuppressAutoSize()) {
this.eHeaderCellResize.addEventListener('dblclick', function (event) {
// get list of all the column keys we are responsible for
var keys = [];
_this.columnGroup.getDisplayedLeafColumns().forEach(function (column) {
// not all cols in the group may be participating with auto-resize
if (!column.getColDef().suppressAutoSize) {
keys.push(column.getColId());
}
});
if (keys.length > 0) {
_this.columnController.autoSizeColumns(keys);
}
});
}
}
// no renderer, default text render
var groupName = this.columnGroup.getHeaderName();
if (groupName && groupName !== '') {
var eGroupCellLabel = document.createElement("div");
eGroupCellLabel.className = 'ag-header-group-cell-label';
this.eHeaderGroupCell.appendChild(eGroupCellLabel);
if (utils_1.Utils.isBrowserSafari()) {
eGroupCellLabel.style.display = 'table-cell';
}
var eInnerText = document.createElement("span");
eInnerText.className = 'ag-header-group-text';
eInnerText.innerHTML = groupName;
eGroupCellLabel.appendChild(eInnerText);
if (this.columnGroup.isExpandable()) {
this.addGroupExpandIcon(eGroupCellLabel);
}
}
this.setWidthOfGroupHeaderCell();
};
RenderedHeaderGroupCell.prototype.setWidthOfGroupHeaderCell = function () {
var _this = this;
var widthChangedListener = function () {
_this.eHeaderGroupCell.style.width = _this.columnGroup.getActualWidth() + 'px';
};
this.columnGroup.getLeafColumns().forEach(function (column) {
column.addEventListener(column_1.Column.EVENT_WIDTH_CHANGED, widthChangedListener);
_this.destroyFunctions.push(function () {
column.removeEventListener(column_1.Column.EVENT_WIDTH_CHANGED, widthChangedListener);
});
});
widthChangedListener();
};
RenderedHeaderGroupCell.prototype.destroy = function () {
this.destroyFunctions.forEach(function (func) {
func();
});
};
RenderedHeaderGroupCell.prototype.addGroupExpandIcon = function (eGroupCellLabel) {
var eGroupIcon;
if (this.columnGroup.isExpanded()) {
eGroupIcon = utils_1.Utils.createIcon('columnGroupOpened', this.gridOptionsWrapper, null, svgFactory.createArrowLeftSvg);
}
else {
eGroupIcon = utils_1.Utils.createIcon('columnGroupClosed', this.gridOptionsWrapper, null, svgFactory.createArrowRightSvg);
}
eGroupIcon.className = 'ag-header-expand-icon';
eGroupCellLabel.appendChild(eGroupIcon);
var that = this;
eGroupIcon.onclick = function () {
var newExpandedValue = !that.columnGroup.isExpanded();
that.columnController.setColumnGroupOpened(that.columnGroup, newExpandedValue);
};
};
RenderedHeaderGroupCell.prototype.onDragStart = function () {
var _this = this;
this.groupWidthStart = this.columnGroup.getActualWidth();
this.childrenWidthStarts = [];
this.columnGroup.getDisplayedLeafColumns().forEach(function (column) {
_this.childrenWidthStarts.push(column.getActualWidth());
});
};
RenderedHeaderGroupCell.prototype.onDragging = function (dragChange, finished) {
var _this = this;
var newWidth = this.groupWidthStart + dragChange;
var minWidth = this.columnGroup.getMinWidth();
if (newWidth < minWidth) {
newWidth = minWidth;
}
// distribute the new width to the child headers
var changeRatio = newWidth / this.groupWidthStart;
// keep track of pixels used, and last column gets the remaining,
// to cater for rounding errors, and min width adjustments
var pixelsToDistribute = newWidth;
var displayedColumns = this.columnGroup.getDisplayedLeafColumns();
displayedColumns.forEach(function (column, index) {
var notLastCol = index !== (displayedColumns.length - 1);
var newChildSize;
if (notLastCol) {
// if not the last col, calculate the column width as normal
var startChildSize = _this.childrenWidthStarts[index];
newChildSize = startChildSize * changeRatio;
if (newChildSize < column.getMinWidth()) {
newChildSize = column.getMinWidth();
}
pixelsToDistribute -= newChildSize;
}
else {
// if last col, give it the remaining pixels
newChildSize = pixelsToDistribute;
}
_this.columnController.setColumnWidth(column, newChildSize, finished);
});
};
__decorate([
context_1.Autowired('filterManager'),
__metadata('design:type', filterManager_1.FilterManager)
], RenderedHeaderGroupCell.prototype, "filterManager", void 0);
__decorate([
context_1.Autowired('gridOptionsWrapper'),
__metadata('design:type', gridOptionsWrapper_1.GridOptionsWrapper)
], RenderedHeaderGroupCell.prototype, "gridOptionsWrapper", void 0);
__decorate([
context_1.Autowired('$compile'),
__metadata('design:type', Object)
], RenderedHeaderGroupCell.prototype, "$compile", void 0);
__decorate([
context_1.Autowired('horizontalDragService'),
__metadata('design:type', horizontalDragService_1.HorizontalDragService)
], RenderedHeaderGroupCell.prototype, "dragService", void 0);
__decorate([
context_1.Autowired('columnController'),
__metadata('design:type', columnController_1.ColumnController)
], RenderedHeaderGroupCell.prototype, "columnController", void 0);
__decorate([
context_2.PostConstruct,
__metadata('design:type', Function),
__metadata('design:paramtypes', []),
__metadata('design:returntype', void 0)
], RenderedHeaderGroupCell.prototype, "init", null);
return RenderedHeaderGroupCell;
})();
exports.RenderedHeaderGroupCell = RenderedHeaderGroupCell;
/***/ },
/* 57 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var context_1 = __webpack_require__(6);
var HorizontalDragService = (function () {
function HorizontalDragService() {
}
HorizontalDragService.prototype.addDragHandling = function (params) {
params.eDraggableElement.addEventListener('mousedown', function (startEvent) {
new DragInstance(params, startEvent);
});
};
HorizontalDragService = __decorate([
context_1.Bean('horizontalDragService'),
__metadata('design:paramtypes', [])
], HorizontalDragService);
return HorizontalDragService;
})();
exports.HorizontalDragService = HorizontalDragService;
var DragInstance = (function () {
function DragInstance(params, startEvent) {
this.mouseMove = this.onMouseMove.bind(this);
this.mouseUp = this.onMouseUp.bind(this);
this.mouseLeave = this.onMouseLeave.bind(this);
this.lastDelta = 0;
this.params = params;
this.eDragParent = document.querySelector('body');
this.dragStartX = startEvent.clientX;
this.startEvent = startEvent;
this.eDragParent.addEventListener('mousemove', this.mouseMove);
this.eDragParent.addEventListener('mouseup', this.mouseUp);
this.eDragParent.addEventListener('mouseleave', this.mouseLeave);
this.draggingStarted = false;
var startAfterPixelsExist = typeof params.startAfterPixels === 'number' && params.startAfterPixels > 0;
if (!startAfterPixelsExist) {
this.startDragging();
}
}
DragInstance.prototype.startDragging = function () {
this.draggingStarted = true;
this.oldBodyCursor = this.params.eBody.style.cursor;
this.oldParentCursor = this.eDragParent.style.cursor;
this.oldMsUserSelect = this.eDragParent.style.msUserSelect;
this.oldWebkitUserSelect = this.eDragParent.style.webkitUserSelect;
// change the body cursor, so when drag moves out of the drag bar, the cursor is still 'resize' (or 'move'
this.params.eBody.style.cursor = this.params.cursor;
// same for outside the grid, we want to keep the resize (or move) cursor
this.eDragParent.style.cursor = this.params.cursor;
// we don't want text selection outside the grid (otherwise it looks weird as text highlights when we move)
this.eDragParent.style.msUserSelect = 'none';
this.eDragParent.style.webkitUserSelect = 'none';
this.params.onDragStart(this.startEvent);
};
DragInstance.prototype.onMouseMove = function (moveEvent) {
var newX = moveEvent.clientX;
this.lastDelta = newX - this.dragStartX;
if (!this.draggingStarted) {
var dragExceededStartAfterPixels = Math.abs(this.lastDelta) >= this.params.startAfterPixels;
if (dragExceededStartAfterPixels) {
this.startDragging();
}
}
if (this.draggingStarted) {
this.params.onDragging(this.lastDelta, false);
}
};
DragInstance.prototype.onMouseUp = function () {
this.stopDragging();
};
DragInstance.prototype.onMouseLeave = function () {
this.stopDragging();
};
DragInstance.prototype.stopDragging = function () {
// reset cursor back to original cursor, if they were changed in the first place
if (this.draggingStarted) {
this.params.eBody.style.cursor = this.oldBodyCursor;
this.eDragParent.style.cursor = this.oldParentCursor;
this.eDragParent.style.msUserSelect = this.oldMsUserSelect;
this.eDragParent.style.webkitUserSelect = this.oldWebkitUserSelect;
this.params.onDragging(this.lastDelta, true);
}
// always remove the listeners, as these are always added
this.eDragParent.removeEventListener('mousemove', this.mouseMove);
this.eDragParent.removeEventListener('mouseup', this.mouseUp);
this.eDragParent.removeEventListener('mouseleave', this.mouseLeave);
};
return DragInstance;
})();
/***/ },
/* 58 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var utils_1 = __webpack_require__(7);
var CssClassApplier = (function () {
function CssClassApplier() {
}
CssClassApplier.addHeaderClassesFromCollDef = function (abstractColDef, eHeaderCell, gridOptionsWrapper) {
if (abstractColDef && abstractColDef.headerClass) {
var classToUse;
if (typeof abstractColDef.headerClass === 'function') {
var params = {
// bad naming, as colDef here can be a group or a column,
// however most people won't appreciate the difference,
// so keeping it as colDef to avoid confusion.
colDef: abstractColDef,
context: gridOptionsWrapper.getContext(),
api: gridOptionsWrapper.getApi()
};
var headerClassFunc = abstractColDef.headerClass;
classToUse = headerClassFunc(params);
}
else {
classToUse = abstractColDef.headerClass;
}
if (typeof classToUse === 'string') {
utils_1.Utils.addCssClass(eHeaderCell, classToUse);
}
else if (Array.isArray(classToUse)) {
classToUse.forEach(function (cssClassItem) {
utils_1.Utils.addCssClass(eHeaderCell, cssClassItem);
});
}
}
};
return CssClassApplier;
})();
exports.CssClassApplier = CssClassApplier;
/***/ },
/* 59 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var utils_1 = __webpack_require__(7);
var column_1 = __webpack_require__(15);
var filterManager_1 = __webpack_require__(40);
var columnController_1 = __webpack_require__(13);
var headerTemplateLoader_1 = __webpack_require__(60);
var gridOptionsWrapper_1 = __webpack_require__(3);
var horizontalDragService_1 = __webpack_require__(57);
var gridCore_1 = __webpack_require__(37);
var context_1 = __webpack_require__(6);
var context_2 = __webpack_require__(6);
var cssClassApplier_1 = __webpack_require__(58);
var dragAndDropService_1 = __webpack_require__(61);
var sortController_1 = __webpack_require__(39);
var context_3 = __webpack_require__(6);
var RenderedHeaderCell = (function () {
function RenderedHeaderCell(column, parentScope, eRoot, dragSourceDropTarget) {
// for better structured code, anything we need to do when this column gets destroyed,
// we put a function in here. otherwise we would have a big destroy function with lots
// of 'if / else' mapping to things that got created.
this.destroyFunctions = [];
this.column = column;
this.parentScope = parentScope;
this.eRoot = eRoot;
this.dragSourceDropTarget = dragSourceDropTarget;
}
RenderedHeaderCell.prototype.init = function () {
this.eHeaderCell = this.headerTemplateLoader.createHeaderElement(this.column);
utils_1.Utils.addCssClass(this.eHeaderCell, 'ag-header-cell');
this.createScope(this.parentScope);
this.addAttributes();
cssClassApplier_1.CssClassApplier.addHeaderClassesFromCollDef(this.column.getColDef(), this.eHeaderCell, this.gridOptionsWrapper);
// label div
var eHeaderCellLabel = this.eHeaderCell.querySelector('#agHeaderCellLabel');
this.setupMovingCss();
this.setupTooltip();
this.setupResize();
this.setupMove(eHeaderCellLabel);
this.setupMenu();
this.setupSort(eHeaderCellLabel);
this.setupFilterIcon();
this.setupText();
this.setupWidth();
};
RenderedHeaderCell.prototype.setupTooltip = function () {
var colDef = this.column.getColDef();
// add tooltip if exists
if (colDef.headerTooltip) {
this.eHeaderCell.title = colDef.headerTooltip;
}
};
RenderedHeaderCell.prototype.setupText = function () {
var colDef = this.column.getColDef();
// render the cell, use a renderer if one is provided
var headerCellRenderer;
if (colDef.headerCellRenderer) {
headerCellRenderer = colDef.headerCellRenderer;
}
else if (this.gridOptionsWrapper.getHeaderCellRenderer()) {
headerCellRenderer = this.gridOptionsWrapper.getHeaderCellRenderer();
}
var headerNameValue = this.columnController.getDisplayNameForCol(this.column);
var eText = this.eHeaderCell.querySelector('#agText');
if (eText) {
if (headerCellRenderer) {
this.useRenderer(headerNameValue, headerCellRenderer, eText);
}
else {
// no renderer, default text render
eText.className = 'ag-header-cell-text';
eText.innerHTML = headerNameValue;
}
}
};
RenderedHeaderCell.prototype.setupFilterIcon = function () {
var _this = this;
var eFilterIcon = this.eHeaderCell.querySelector('#agFilter');
if (!eFilterIcon) {
return;
}
var filterChangedListener = function () {
var filterPresent = _this.column.isFilterActive();
utils_1.Utils.addOrRemoveCssClass(_this.eHeaderCell, 'ag-header-cell-filtered', filterPresent);
utils_1.Utils.addOrRemoveCssClass(eFilterIcon, 'ag-hidden', !filterPresent);
};
this.column.addEventListener(column_1.Column.EVENT_FILTER_ACTIVE_CHANGED, filterChangedListener);
this.destroyFunctions.push(function () {
_this.column.removeEventListener(column_1.Column.EVENT_FILTER_ACTIVE_CHANGED, filterChangedListener);
});
filterChangedListener();
};
RenderedHeaderCell.prototype.setupWidth = function () {
var _this = this;
var widthChangedListener = function () {
_this.eHeaderCell.style.width = _this.column.getActualWidth() + 'px';
};
this.column.addEventListener(column_1.Column.EVENT_WIDTH_CHANGED, widthChangedListener);
this.destroyFunctions.push(function () {
_this.column.removeEventListener(column_1.Column.EVENT_WIDTH_CHANGED, widthChangedListener);
});
widthChangedListener();
};
RenderedHeaderCell.prototype.getGui = function () {
return this.eHeaderCell;
};
RenderedHeaderCell.prototype.destroy = function () {
this.destroyFunctions.forEach(function (func) {
func();
});
};
RenderedHeaderCell.prototype.createScope = function (parentScope) {
var _this = this;
if (this.gridOptionsWrapper.isAngularCompileHeaders()) {
this.childScope = parentScope.$new();
this.childScope.colDef = this.column.getColDef();
this.childScope.colDefWrapper = this.column;
this.destroyFunctions.push(function () {
_this.childScope.$destroy();
});
}
};
RenderedHeaderCell.prototype.addAttributes = function () {
this.eHeaderCell.setAttribute("colId", this.column.getColId());
};
RenderedHeaderCell.prototype.setupMenu = function () {
var eMenu = this.eHeaderCell.querySelector('#agMenu');
// if no menu provided in template, do nothing
if (!eMenu) {
return;
}
var weWantMenu = this.menuFactory.isMenuEnabled(this.column) && !this.column.getColDef().suppressMenu;
if (!weWantMenu) {
utils_1.Utils.removeFromParent(eMenu);
return;
}
var that = this;
eMenu.addEventListener('click', function () {
that.showMenu(this);
});
if (!this.gridOptionsWrapper.isSuppressMenuHide()) {
eMenu.style.opacity = '0';
this.eHeaderCell.addEventListener('mouseover', function () {
eMenu.style.opacity = '1';
});
this.eHeaderCell.addEventListener('mouseout', function () {
eMenu.style.opacity = '0';
});
}
var style = eMenu.style;
style['transition'] = 'opacity 0.2s, border 0.2s';
style['-webkit-transition'] = 'opacity 0.2s, border 0.2s';
};
RenderedHeaderCell.prototype.showMenu = function (eventSource) {
this.menuFactory.showMenu(this.column, eventSource);
};
RenderedHeaderCell.prototype.setupMovingCss = function () {
var _this = this;
// this function adds or removes the moving css, based on if the col is moving
var addMovingCssFunc = function () {
if (_this.column.isMoving()) {
utils_1.Utils.addCssClass(_this.eHeaderCell, 'ag-header-cell-moving');
}
else {
utils_1.Utils.removeCssClass(_this.eHeaderCell, 'ag-header-cell-moving');
}
};
// call it now once, so the col is set up correctly
addMovingCssFunc();
// then call it every time we are informed of a moving state change in the col
this.column.addEventListener(column_1.Column.EVENT_MOVING_CHANGED, addMovingCssFunc);
// finally we remove the listener when this cell is no longer rendered
this.destroyFunctions.push(function () {
_this.column.removeEventListener(column_1.Column.EVENT_MOVING_CHANGED, addMovingCssFunc);
});
};
RenderedHeaderCell.prototype.setupMove = function (eHeaderCellLabel) {
if (this.gridOptionsWrapper.isSuppressMovableColumns() || this.column.getColDef().suppressMovable) {
return;
}
if (this.gridOptionsWrapper.isForPrint()) {
// don't allow moving of headers when forPrint, as the header overlay doesn't exist
return;
}
if (eHeaderCellLabel) {
var dragSource = {
eElement: eHeaderCellLabel,
dragItem: this.column,
dragSourceDropTarget: this.dragSourceDropTarget
};
this.dragAndDropService.addDragSource(dragSource);
}
};
RenderedHeaderCell.prototype.setupResize = function () {
var _this = this;
var colDef = this.column.getColDef();
var eResize = this.eHeaderCell.querySelector('#agResizeBar');
// if no eResize in template, do nothing
if (!eResize) {
return;
}
var weWantResize = this.gridOptionsWrapper.isEnableColResize() && !colDef.suppressResize;
if (!weWantResize) {
utils_1.Utils.removeFromParent(eResize);
return;
}
this.dragService.addDragHandling({
eDraggableElement: eResize,
eBody: this.eRoot,
cursor: 'col-resize',
startAfterPixels: 0,
onDragStart: this.onDragStart.bind(this),
onDragging: this.onDragging.bind(this)
});
var weWantAutoSize = !this.gridOptionsWrapper.isSuppressAutoSize() && !colDef.suppressAutoSize;
if (weWantAutoSize) {
eResize.addEventListener('dblclick', function () {
_this.columnController.autoSizeColumn(_this.column);
});
}
};
RenderedHeaderCell.prototype.useRenderer = function (headerNameValue, headerCellRenderer, eText) {
// renderer provided, use it
var cellRendererParams = {
colDef: this.column.getColDef(),
$scope: this.childScope,
context: this.gridOptionsWrapper.getContext(),
value: headerNameValue,
api: this.gridOptionsWrapper.getApi(),
eHeaderCell: this.eHeaderCell
};
var cellRendererResult = headerCellRenderer(cellRendererParams);
var childToAppend;
if (utils_1.Utils.isNodeOrElement(cellRendererResult)) {
// a dom node or element was returned, so add child
childToAppend = cellRendererResult;
}
else {
// otherwise assume it was html, so just insert
var eTextSpan = document.createElement("span");
eTextSpan.innerHTML = cellRendererResult;
childToAppend = eTextSpan;
}
// angular compile header if option is turned on
if (this.gridOptionsWrapper.isAngularCompileHeaders()) {
var childToAppendCompiled = this.$compile(childToAppend)(this.childScope)[0];
eText.appendChild(childToAppendCompiled);
}
else {
eText.appendChild(childToAppend);
}
};
RenderedHeaderCell.prototype.setupSort = function (eHeaderCellLabel) {
var _this = this;
var enableSorting = this.gridOptionsWrapper.isEnableSorting() && !this.column.getColDef().suppressSorting;
if (!enableSorting) {
utils_1.Utils.removeFromParent(this.eHeaderCell.querySelector('#agSortAsc'));
utils_1.Utils.removeFromParent(this.eHeaderCell.querySelector('#agSortDesc'));
utils_1.Utils.removeFromParent(this.eHeaderCell.querySelector('#agNoSort'));
return;
}
// add the event on the header, so when clicked, we do sorting
if (eHeaderCellLabel) {
eHeaderCellLabel.addEventListener("click", function (event) {
_this.sortController.progressSort(_this.column, event.shiftKey);
});
}
// add listener for sort changing, and update the icons accordingly
var eSortAsc = this.eHeaderCell.querySelector('#agSortAsc');
var eSortDesc = this.eHeaderCell.querySelector('#agSortDesc');
var eSortNone = this.eHeaderCell.querySelector('#agNoSort');
var sortChangedListener = function () {
utils_1.Utils.addOrRemoveCssClass(_this.eHeaderCell, 'ag-header-cell-sorted-asc', _this.column.isSortAscending());
utils_1.Utils.addOrRemoveCssClass(_this.eHeaderCell, 'ag-header-cell-sorted-desc', _this.column.isSortDescending());
utils_1.Utils.addOrRemoveCssClass(_this.eHeaderCell, 'ag-header-cell-sorted-none', _this.column.isSortNone());
if (eSortAsc) {
utils_1.Utils.addOrRemoveCssClass(eSortAsc, 'ag-hidden', !_this.column.isSortAscending());
}
if (eSortDesc) {
utils_1.Utils.addOrRemoveCssClass(eSortDesc, 'ag-hidden', !_this.column.isSortDescending());
}
if (eSortNone) {
var alwaysHideNoSort = !_this.column.getColDef().unSortIcon && !_this.gridOptionsWrapper.isUnSortIcon();
utils_1.Utils.addOrRemoveCssClass(eSortNone, 'ag-hidden', alwaysHideNoSort || !_this.column.isSortNone());
}
};
this.column.addEventListener(column_1.Column.EVENT_SORT_CHANGED, sortChangedListener);
this.destroyFunctions.push(function () {
_this.column.removeEventListener(column_1.Column.EVENT_SORT_CHANGED, sortChangedListener);
});
sortChangedListener();
};
RenderedHeaderCell.prototype.onDragStart = function () {
this.startWidth = this.column.getActualWidth();
};
RenderedHeaderCell.prototype.onDragging = function (dragChange, finished) {
var newWidth = this.startWidth + dragChange;
this.columnController.setColumnWidth(this.column, newWidth, finished);
};
RenderedHeaderCell.prototype.onIndividualColumnResized = function (column) {
if (this.column !== column) {
return;
}
var newWidthPx = column.getActualWidth() + "px";
this.eHeaderCell.style.width = newWidthPx;
};
__decorate([
context_1.Autowired('context'),
__metadata('design:type', context_2.Context)
], RenderedHeaderCell.prototype, "context", void 0);
__decorate([
context_1.Autowired('filterManager'),
__metadata('design:type', filterManager_1.FilterManager)
], RenderedHeaderCell.prototype, "filterManager", void 0);
__decorate([
context_1.Autowired('columnController'),
__metadata('design:type', columnController_1.ColumnController)
], RenderedHeaderCell.prototype, "columnController", void 0);
__decorate([
context_1.Autowired('$compile'),
__metadata('design:type', Object)
], RenderedHeaderCell.prototype, "$compile", void 0);
__decorate([
context_1.Autowired('gridCore'),
__metadata('design:type', gridCore_1.GridCore)
], RenderedHeaderCell.prototype, "gridCore", void 0);
__decorate([
context_1.Autowired('headerTemplateLoader'),
__metadata('design:type', headerTemplateLoader_1.HeaderTemplateLoader)
], RenderedHeaderCell.prototype, "headerTemplateLoader", void 0);
__decorate([
context_1.Autowired('horizontalDragService'),
__metadata('design:type', horizontalDragService_1.HorizontalDragService)
], RenderedHeaderCell.prototype, "dragService", void 0);
__decorate([
context_1.Autowired('menuFactory'),
__metadata('design:type', Object)
], RenderedHeaderCell.prototype, "menuFactory", void 0);
__decorate([
context_1.Autowired('gridOptionsWrapper'),
__metadata('design:type', gridOptionsWrapper_1.GridOptionsWrapper)
], RenderedHeaderCell.prototype, "gridOptionsWrapper", void 0);
__decorate([
context_1.Autowired('dragAndDropService'),
__metadata('design:type', dragAndDropService_1.DragAndDropService)
], RenderedHeaderCell.prototype, "dragAndDropService", void 0);
__decorate([
context_1.Autowired('sortController'),
__metadata('design:type', sortController_1.SortController)
], RenderedHeaderCell.prototype, "sortController", void 0);
__decorate([
context_3.PostConstruct,
__metadata('design:type', Function),
__metadata('design:paramtypes', []),
__metadata('design:returntype', void 0)
], RenderedHeaderCell.prototype, "init", null);
return RenderedHeaderCell;
})();
exports.RenderedHeaderCell = RenderedHeaderCell;
/***/ },
/* 60 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var utils_1 = __webpack_require__(7);
var svgFactory_1 = __webpack_require__(36);
var gridOptionsWrapper_1 = __webpack_require__(3);
var context_1 = __webpack_require__(6);
var context_2 = __webpack_require__(6);
var svgFactory = svgFactory_1.SvgFactory.getInstance();
var HeaderTemplateLoader = (function () {
function HeaderTemplateLoader() {
}
HeaderTemplateLoader.prototype.createHeaderElement = function (column) {
var params = {
column: column,
colDef: column.getColDef,
context: this.gridOptionsWrapper.getContext(),
api: this.gridOptionsWrapper.getApi()
};
// option 1 - see if user provided a template in colDef
var userProvidedTemplate = column.getColDef().headerCellTemplate;
if (typeof userProvidedTemplate === 'function') {
var colDefFunc = userProvidedTemplate;
userProvidedTemplate = colDefFunc(params);
}
// option 2 - check the gridOptions for cellTemplate
if (!userProvidedTemplate && this.gridOptionsWrapper.getHeaderCellTemplate()) {
userProvidedTemplate = this.gridOptionsWrapper.getHeaderCellTemplate();
}
// option 3 - check the gridOptions for templateFunction
if (!userProvidedTemplate && this.gridOptionsWrapper.getHeaderCellTemplateFunc()) {
var gridOptionsFunc = this.gridOptionsWrapper.getHeaderCellTemplateFunc();
userProvidedTemplate = gridOptionsFunc(params);
}
// finally, if still no template, use the default
if (!userProvidedTemplate) {
userProvidedTemplate = this.createDefaultHeaderElement(column);
}
// template can be a string or a dom element, if string we need to convert to a dom element
var result;
if (typeof userProvidedTemplate === 'string') {
result = utils_1.Utils.loadTemplate(userProvidedTemplate);
}
else if (utils_1.Utils.isNodeOrElement(userProvidedTemplate)) {
result = userProvidedTemplate;
}
else {
console.error('ag-Grid: header template must be a string or an HTML element');
}
return result;
};
HeaderTemplateLoader.prototype.createDefaultHeaderElement = function (column) {
var eTemplate = utils_1.Utils.loadTemplate(HeaderTemplateLoader.HEADER_CELL_TEMPLATE);
this.addInIcon(eTemplate, 'sortAscending', '#agSortAsc', column, svgFactory.createArrowUpSvg);
this.addInIcon(eTemplate, 'sortDescending', '#agSortDesc', column, svgFactory.createArrowDownSvg);
this.addInIcon(eTemplate, 'sortUnSort', '#agNoSort', column, svgFactory.createArrowUpDownSvg);
this.addInIcon(eTemplate, 'menu', '#agMenu', column, svgFactory.createMenuSvg);
this.addInIcon(eTemplate, 'filter', '#agFilter', column, svgFactory.createFilterSvg);
return eTemplate;
};
HeaderTemplateLoader.prototype.addInIcon = function (eTemplate, iconName, cssSelector, column, defaultIconFactory) {
var eIcon = utils_1.Utils.createIconNoSpan(iconName, this.gridOptionsWrapper, column, defaultIconFactory);
eTemplate.querySelector(cssSelector).appendChild(eIcon);
};
// used when cell is dragged
HeaderTemplateLoader.HEADER_CELL_DND_TEMPLATE = '
' +
' ' +
'
' +
' ' +
'
' +
'
';
HeaderTemplateLoader.HEADER_CELL_TEMPLATE = '
' +
' ' +
' ' +
'
' +
' ' +
' ' +
' ' +
' ' +
' ' +
'
' +
'
';
__decorate([
context_2.Autowired('gridOptionsWrapper'),
__metadata('design:type', gridOptionsWrapper_1.GridOptionsWrapper)
], HeaderTemplateLoader.prototype, "gridOptionsWrapper", void 0);
HeaderTemplateLoader = __decorate([
context_1.Bean('headerTemplateLoader'),
__metadata('design:paramtypes', [])
], HeaderTemplateLoader);
return HeaderTemplateLoader;
})();
exports.HeaderTemplateLoader = HeaderTemplateLoader;
/***/ },
/* 61 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
var context_1 = __webpack_require__(6);
var logger_1 = __webpack_require__(5);
var context_2 = __webpack_require__(6);
var headerTemplateLoader_1 = __webpack_require__(60);
var utils_1 = __webpack_require__(7);
var gridOptionsWrapper_1 = __webpack_require__(3);
var context_3 = __webpack_require__(6);
var svgFactory_1 = __webpack_require__(36);
var dragService_1 = __webpack_require__(28);
var svgFactory = svgFactory_1.SvgFactory.getInstance();
var DragAndDropService = (function () {
function DragAndDropService() {
this.dropTargets = [];
this.ePinnedIcon = svgFactory.createPinIcon();
this.ePlusIcon = svgFactory.createPlusIcon();
this.eHiddenIcon = svgFactory.createColumnHiddenIcon();
this.eMoveIcon = svgFactory.createMoveIcon();
this.eLeftIcon = svgFactory.createLeftIcon();
this.eRightIcon = svgFactory.createRightIcon();
this.eGroupIcon = svgFactory.createGroupIcon();
}
DragAndDropService.prototype.agWire = function (loggerFactory) {
this.logger = loggerFactory.create('OldToolPanelDragAndDropService');
this.eBody = document.querySelector('body');
if (!this.eBody) {
console.warn('ag-Grid: could not find document body, it is needed for dragging columns');
}
};
// we do not need to clean up drag sources, as we are just adding a listener to the element.
// when the element is disposed, the drag source is also disposed, even though this service
// remains. this is a bit different to normal 'addListener' methods
DragAndDropService.prototype.addDragSource = function (params) {
this.dragService.addDragSource({
eElement: params.eElement,
onDragStart: this.onDragStart.bind(this, params),
onDragStop: this.onDragStop.bind(this),
onDragging: this.onDragging.bind(this)
});
//params.eElement.addEventListener('mousedown', this.onMouseDown.bind(this, params));
};
DragAndDropService.prototype.nudge = function () {
if (this.dragging) {
this.onDragging(this.eventLastTime);
}
};
DragAndDropService.prototype.onDragStart = function (dragSource, mouseEvent) {
this.logger.log('startDrag');
this.dragging = true;
this.dragSource = dragSource;
this.eventLastTime = mouseEvent;
this.dragSource.dragItem.setMoving(true);
this.dragItem = this.dragSource.dragItem;
this.lastDropTarget = this.dragSource.dragSourceDropTarget;
this.createGhost();
};
DragAndDropService.prototype.onDragStop = function (mouseEvent) {
this.logger.log('onDragStop');
this.eventLastTime = null;
this.dragging = false;
this.dragItem.setMoving(false);
if (this.lastDropTarget && this.lastDropTarget.onDragStop) {
var draggingEvent = this.createDropTargetEvent(this.lastDropTarget, mouseEvent, null);
this.lastDropTarget.onDragStop(draggingEvent);
}
this.lastDropTarget = null;
this.dragItem = null;
this.removeGhost();
};
DragAndDropService.prototype.onDragging = function (mouseEvent) {
var direction = this.workOutDirection(mouseEvent);
this.eventLastTime = mouseEvent;
this.positionGhost(mouseEvent);
// check if mouseEvent intersects with any of the drop targets
var dropTarget = utils_1.Utils.find(this.dropTargets, function (dropTarget) {
var targetsToCheck = [dropTarget.eContainer];
if (dropTarget.eSecondaryContainers) {
targetsToCheck = targetsToCheck.concat(dropTarget.eSecondaryContainers);
}
var gotMatch = false;
targetsToCheck.forEach(function (eContainer) {
if (!eContainer) {
return;
} // secondary can be missing
var rect = eContainer.getBoundingClientRect();
// if element is not visible, then width and height are zero
if (rect.width === 0 || rect.height === 0) {
return;
}
var horizontalFit = mouseEvent.clientX >= rect.left && mouseEvent.clientX <= rect.right;
var verticalFit = mouseEvent.clientY >= rect.top && mouseEvent.clientY <= rect.bottom;
//console.log(`rect.width = ${rect.width} || rect.height = ${rect.height} ## verticalFit = ${verticalFit}, horizontalFit = ${horizontalFit}, `);
if (horizontalFit && verticalFit) {
gotMatch = true;
}
});
return gotMatch;
});
if (dropTarget !== this.lastDropTarget) {
if (this.lastDropTarget) {
this.logger.log('onDragLeave');
var dragLeaveEvent = this.createDropTargetEvent(this.lastDropTarget, mouseEvent, direction);
this.lastDropTarget.onDragLeave(dragLeaveEvent);
this.setGhostIcon(null);
}
if (dropTarget) {
this.logger.log('onDragEnter');
var dragEnterEvent = this.createDropTargetEvent(dropTarget, mouseEvent, direction);
dropTarget.onDragEnter(dragEnterEvent);
this.setGhostIcon(dropTarget.iconName);
}
this.lastDropTarget = dropTarget;
}
else if (dropTarget) {
var draggingEvent = this.createDropTargetEvent(dropTarget, mouseEvent, direction);
dropTarget.onDragging(draggingEvent);
}
};
DragAndDropService.prototype.addDropTarget = function (dropTarget) {
this.dropTargets.push(dropTarget);
};
DragAndDropService.prototype.workOutDirection = function (event) {
var direction;
if (this.eventLastTime.clientX > event.clientX) {
direction = DragAndDropService.DIRECTION_LEFT;
}
else if (this.eventLastTime.clientX < event.clientX) {
direction = DragAndDropService.DIRECTION_RIGHT;
}
else {
direction = null;
}
return direction;
};
DragAndDropService.prototype.createDropTargetEvent = function (dropTarget, event, direction) {
// localise x and y to the target component
var rect = dropTarget.eContainer.getBoundingClientRect();
var x = event.clientX - rect.left;
var y = event.clientY - rect.top;
var dropTargetEvent = {
event: event,
x: x,
y: y,
direction: direction,
dragItem: this.dragItem,
dragSource: this.dragSource
};
return dropTargetEvent;
};
DragAndDropService.prototype.positionGhost = function (event) {
var ghostRect = this.eGhost.getBoundingClientRect();
var ghostHeight = ghostRect.height;
// for some reason, without the '-2', it still overlapped by 1 or 2 pixels, which
// then brought in scrollbars to the browser. no idea why, but putting in -2 here
// works around it which is good enough for me.
var browserWidth = utils_1.Utils.getBodyWidth() - 2;
var browserHeight = utils_1.Utils.getBodyHeight() - 2;
// put ghost vertically in middle of cursor
var top = event.pageY - (ghostHeight / 2);
// horizontally, place cursor just right of icon
var left = event.pageX - 30;
// check ghost is not positioned outside of the browser
if (browserWidth > 0) {
if ((left + this.eGhost.clientWidth) > browserWidth) {
left = browserWidth - this.eGhost.clientWidth;
}
}
if (left < 0) {
left = 0;
}
if (browserHeight > 0) {
if ((top + this.eGhost.clientHeight) > browserHeight) {
top = browserHeight - this.eGhost.clientHeight;
}
}
if (top < 0) {
top = 0;
}
this.eGhost.style.left = left + 'px';
this.eGhost.style.top = top + 'px';
};
DragAndDropService.prototype.removeGhost = function () {
if (this.eGhost) {
this.eBody.removeChild(this.eGhost);
}
this.eGhost = null;
};
DragAndDropService.prototype.createGhost = function () {
var dragItem = this.dragSource.dragItem;
this.eGhost = utils_1.Utils.loadTemplate(headerTemplateLoader_1.HeaderTemplateLoader.HEADER_CELL_DND_TEMPLATE);
this.eGhostIcon = this.eGhost.querySelector('#eGhostIcon');
if (this.lastDropTarget) {
this.setGhostIcon(this.lastDropTarget.iconName);
}
var eText = this.eGhost.querySelector('#agText');
if (dragItem.getColDef().headerName) {
eText.innerHTML = dragItem.getColDef().headerName;
}
else {
eText.innerHTML = dragItem.getColId();
}
this.eGhost.style.width = dragItem.getActualWidth() + 'px';
this.eGhost.style.height = this.gridOptionsWrapper.getHeaderHeight() + 'px';
this.eGhost.style.top = '20px';
this.eGhost.style.left = '20px';
this.eBody.appendChild(this.eGhost);
};
DragAndDropService.prototype.setGhostIcon = function (iconName, shake) {
if (shake === void 0) { shake = false; }
utils_1.Utils.removeAllChildren(this.eGhostIcon);
var eIcon;
switch (iconName) {
case DragAndDropService.ICON_ADD:
eIcon = this.ePlusIcon;
break;
case DragAndDropService.ICON_PINNED:
eIcon = this.ePinnedIcon;
break;
case DragAndDropService.ICON_MOVE:
eIcon = this.eMoveIcon;
break;
case DragAndDropService.ICON_LEFT:
eIcon = this.eLeftIcon;
break;
case DragAndDropService.ICON_RIGHT:
eIcon = this.eRightIcon;
break;
case DragAndDropService.ICON_GROUP:
eIcon = this.eGroupIcon;
break;
default:
eIcon = this.eHiddenIcon;
break;
}
this.eGhostIcon.appendChild(eIcon);
utils_1.Utils.addOrRemoveCssClass(this.eGhostIcon, 'ag-shake-left-to-right', shake);
};
DragAndDropService.DIRECTION_LEFT = 'left';
DragAndDropService.DIRECTION_RIGHT = 'right';
DragAndDropService.ICON_PINNED = 'pinned';
DragAndDropService.ICON_ADD = 'add';
DragAndDropService.ICON_MOVE = 'move';
DragAndDropService.ICON_LEFT = 'left';
DragAndDropService.ICON_RIGHT = 'right';
DragAndDropService.ICON_GROUP = 'group';
__decorate([
context_3.Autowired('gridOptionsWrapper'),
__metadata('design:type', gridOptionsWrapper_1.GridOptionsWrapper)
], DragAndDropService.prototype, "gridOptionsWrapper", void 0);
__decorate([
context_3.Autowired('dragService'),
__metadata('design:type', dragService_1.DragService)
], DragAndDropService.prototype, "dragService", void 0);
__decorate([
__param(0, context_1.Qualifier('loggerFactory')),
__metadata('design:type', Function),
__metadata('design:paramtypes', [logger_1.LoggerFactory]),
__metadata('design:returntype', void 0)
], DragAndDropService.prototype, "agWire", null);
DragAndDropService = __decorate([
context_2.Bean('dragAndDropService'),
__metadata('design:paramtypes', [])
], DragAndDropService);
return DragAndDropService;
})();
exports.DragAndDropService = DragAndDropService;
/***/ },
/* 62 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var context_1 = __webpack_require__(6);
var logger_1 = __webpack_require__(5);
var columnController_1 = __webpack_require__(13);
var column_1 = __webpack_require__(15);
var utils_1 = __webpack_require__(7);
var dragAndDropService_1 = __webpack_require__(61);
var gridPanel_1 = __webpack_require__(24);
var context_2 = __webpack_require__(6);
var MoveColumnController = (function () {
function MoveColumnController(pinned) {
this.needToMoveLeft = false;
this.needToMoveRight = false;
this.pinned = pinned;
this.centerContainer = !utils_1.Utils.exists(pinned);
}
MoveColumnController.prototype.init = function () {
this.logger = this.loggerFactory.create('MoveColumnController');
};
MoveColumnController.prototype.onDragEnter = function (draggingEvent) {
// we do dummy drag, so make sure column appears in the right location when first placed
this.columnController.setColumnVisible(draggingEvent.dragItem, true);
this.columnController.setColumnPinned(draggingEvent.dragItem, this.pinned);
this.onDragging(draggingEvent);
};
MoveColumnController.prototype.onDragLeave = function (draggingEvent) {
this.columnController.setColumnVisible(draggingEvent.dragItem, false);
this.ensureIntervalCleared();
};
MoveColumnController.prototype.onDragStop = function () {
this.ensureIntervalCleared();
};
MoveColumnController.prototype.adjustXForScroll = function (draggingEvent) {
if (this.centerContainer) {
return draggingEvent.x + this.gridPanel.getHorizontalScrollPosition();
}
else {
return draggingEvent.x;
}
};
MoveColumnController.prototype.workOutNewIndex = function (displayedColumns, allColumns, draggingEvent, xAdjustedForScroll) {
if (draggingEvent.direction === dragAndDropService_1.DragAndDropService.DIRECTION_LEFT) {
return this.getNewIndexForColMovingLeft(displayedColumns, allColumns, draggingEvent.dragItem, xAdjustedForScroll);
}
else {
return this.getNewIndexForColMovingRight(displayedColumns, allColumns, draggingEvent.dragItem, xAdjustedForScroll);
}
};
MoveColumnController.prototype.checkCenterForScrolling = function (xAdjustedForScroll) {
if (this.centerContainer) {
// scroll if the mouse has gone outside the grid (or just outside the scrollable part if pinning)
// putting in 50 buffer, so even if user gets to edge of grid, a scroll will happen
var firstVisiblePixel = this.gridPanel.getHorizontalScrollPosition();
var lastVisiblePixel = firstVisiblePixel + this.gridPanel.getCenterWidth();
this.needToMoveLeft = xAdjustedForScroll < (firstVisiblePixel + 50);
this.needToMoveRight = xAdjustedForScroll > (lastVisiblePixel - 50);
if (this.needToMoveLeft || this.needToMoveRight) {
this.ensureIntervalStarted();
}
else {
this.ensureIntervalCleared();
}
}
};
MoveColumnController.prototype.onDragging = function (draggingEvent) {
this.lastDraggingEvent = draggingEvent;
// if moving up or down (ie not left or right) then do nothing
if (!draggingEvent.direction) {
return;
}
var xAdjustedForScroll = this.adjustXForScroll(draggingEvent);
this.checkCenterForScrolling(xAdjustedForScroll);
// find out what the correct position is for this column
this.checkColIndexAndMove(draggingEvent, xAdjustedForScroll);
};
MoveColumnController.prototype.checkColIndexAndMove = function (draggingEvent, xAdjustedForScroll) {
var displayedColumns = this.columnController.getDisplayedColumns(this.pinned);
var allColumns = this.columnController.getAllColumns();
var newIndex = this.workOutNewIndex(displayedColumns, allColumns, draggingEvent, xAdjustedForScroll);
var oldColumn = allColumns[newIndex];
// if col already at required location, do nothing
if (oldColumn === draggingEvent.dragItem) {
return;
}
// we move one column, UNLESS the column is the only visible column
// of a group, in which case we move the whole group.
var columnsToMove = this.getColumnsAndOrphans(draggingEvent.dragItem);
this.columnController.moveColumns(columnsToMove.reverse(), newIndex);
};
MoveColumnController.prototype.getNewIndexForColMovingLeft = function (displayedColumns, allColumns, dragItem, x) {
var usedX = 0;
var leftColumn = null;
for (var i = 0; i < displayedColumns.length; i++) {
var currentColumn = displayedColumns[i];
if (currentColumn === dragItem) {
continue;
}
usedX += currentColumn.getActualWidth();
if (usedX > x) {
break;
}
leftColumn = currentColumn;
}
var newIndex;
if (leftColumn) {
newIndex = allColumns.indexOf(leftColumn) + 1;
var oldIndex = allColumns.indexOf(dragItem);
if (oldIndex < newIndex) {
newIndex--;
}
}
else {
newIndex = 0;
}
return newIndex;
};
MoveColumnController.prototype.getNewIndexForColMovingRight = function (displayedColumns, allColumns, dragItem, x) {
var usedX = dragItem.getActualWidth();
var leftColumn = null;
for (var i = 0; i < displayedColumns.length; i++) {
if (usedX > x) {
break;
}
var currentColumn = displayedColumns[i];
if (currentColumn === dragItem) {
continue;
}
usedX += currentColumn.getActualWidth();
leftColumn = currentColumn;
}
var newIndex;
if (leftColumn) {
newIndex = allColumns.indexOf(leftColumn) + 1;
var oldIndex = allColumns.indexOf(dragItem);
if (oldIndex < newIndex) {
newIndex--;
}
}
else {
newIndex = 0;
}
return newIndex;
};
MoveColumnController.prototype.getColumnsAndOrphans = function (column) {
// if this column was to move, how many children would be left without a parent
var pathToChild = this.columnController.getPathForColumn(column);
for (var i = pathToChild.length - 1; i >= 0; i--) {
var columnGroup = pathToChild[i];
var onlyDisplayedChild = columnGroup.getDisplayedChildren().length === 1;
var moreThanOneChild = columnGroup.getChildren().length > 1;
if (onlyDisplayedChild && moreThanOneChild) {
// return total columns below here, not including the column under inspection
var leafColumns = columnGroup.getLeafColumns();
return leafColumns;
}
}
return [column];
};
MoveColumnController.prototype.ensureIntervalStarted = function () {
if (!this.movingIntervalId) {
this.intervalCount = 0;
this.failedMoveAttempts = 0;
this.movingIntervalId = setInterval(this.moveInterval.bind(this), 100);
if (this.needToMoveLeft) {
this.dragAndDropService.setGhostIcon(dragAndDropService_1.DragAndDropService.ICON_LEFT, true);
}
else {
this.dragAndDropService.setGhostIcon(dragAndDropService_1.DragAndDropService.ICON_RIGHT, true);
}
}
};
MoveColumnController.prototype.ensureIntervalCleared = function () {
if (this.moveInterval) {
clearInterval(this.movingIntervalId);
this.movingIntervalId = null;
this.dragAndDropService.setGhostIcon(dragAndDropService_1.DragAndDropService.ICON_MOVE);
}
};
MoveColumnController.prototype.moveInterval = function () {
var pixelsToMove;
this.intervalCount++;
pixelsToMove = 10 + (this.intervalCount * 5);
if (pixelsToMove > 100) {
pixelsToMove = 100;
}
var pixelsMoved;
if (this.needToMoveLeft) {
pixelsMoved = this.gridPanel.scrollHorizontally(-pixelsToMove);
}
else if (this.needToMoveRight) {
pixelsMoved = this.gridPanel.scrollHorizontally(pixelsToMove);
}
if (pixelsMoved !== 0) {
this.onDragging(this.lastDraggingEvent);
this.failedMoveAttempts = 0;
}
else {
this.failedMoveAttempts++;
if (this.failedMoveAttempts > 7) {
if (this.needToMoveLeft) {
this.columnController.setColumnPinned(this.lastDraggingEvent.dragItem, column_1.Column.PINNED_LEFT);
}
else {
this.columnController.setColumnPinned(this.lastDraggingEvent.dragItem, column_1.Column.PINNED_RIGHT);
}
this.dragAndDropService.nudge();
}
}
};
__decorate([
context_1.Autowired('loggerFactory'),
__metadata('design:type', logger_1.LoggerFactory)
], MoveColumnController.prototype, "loggerFactory", void 0);
__decorate([
context_1.Autowired('columnController'),
__metadata('design:type', columnController_1.ColumnController)
], MoveColumnController.prototype, "columnController", void 0);
__decorate([
context_1.Autowired('gridPanel'),
__metadata('design:type', gridPanel_1.GridPanel)
], MoveColumnController.prototype, "gridPanel", void 0);
__decorate([
context_1.Autowired('dragAndDropService'),
__metadata('design:type', dragAndDropService_1.DragAndDropService)
], MoveColumnController.prototype, "dragAndDropService", void 0);
__decorate([
context_2.PostConstruct,
__metadata('design:type', Function),
__metadata('design:paramtypes', []),
__metadata('design:returntype', void 0)
], MoveColumnController.prototype, "init", null);
return MoveColumnController;
})();
exports.MoveColumnController = MoveColumnController;
/***/ },
/* 63 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var utils_1 = __webpack_require__(7);
var constants_1 = __webpack_require__(8);
var gridOptionsWrapper_1 = __webpack_require__(3);
var columnController_1 = __webpack_require__(13);
var filterManager_1 = __webpack_require__(40);
var rowNode_1 = __webpack_require__(19);
var eventService_1 = __webpack_require__(4);
var events_1 = __webpack_require__(10);
var context_1 = __webpack_require__(6);
var selectionController_1 = __webpack_require__(29);
var context_2 = __webpack_require__(6);
var constants_2 = __webpack_require__(8);
var context_3 = __webpack_require__(6);
var context_4 = __webpack_require__(6);
var RecursionType;
(function (RecursionType) {
RecursionType[RecursionType["Normal"] = 0] = "Normal";
RecursionType[RecursionType["AfterFilter"] = 1] = "AfterFilter";
RecursionType[RecursionType["AfterFilterAndSort"] = 2] = "AfterFilterAndSort";
})(RecursionType || (RecursionType = {}));
;
var InMemoryRowController = (function () {
function InMemoryRowController() {
// the rows go through a pipeline of steps, each array below is the result
// after a certain step.
this.allRows = []; // the rows, in a list, as provided by the user, but wrapped in RowNode objects
}
InMemoryRowController.prototype.init = function () {
this.eventService.addModalPriorityEventListener(events_1.Events.EVENT_COLUMN_EVERYTHING_CHANGED, this.refreshModel.bind(this, constants_2.Constants.STEP_EVERYTHING));
this.eventService.addModalPriorityEventListener(events_1.Events.EVENT_COLUMN_ROW_GROUP_CHANGE, this.refreshModel.bind(this, constants_2.Constants.STEP_EVERYTHING));
this.eventService.addModalPriorityEventListener(events_1.Events.EVENT_COLUMN_VALUE_CHANGE, this.refreshModel.bind(this, constants_2.Constants.STEP_AGGREGATE));
this.eventService.addModalPriorityEventListener(events_1.Events.EVENT_FILTER_CHANGED, this.refreshModel.bind(this, constants_1.Constants.STEP_FILTER));
this.eventService.addModalPriorityEventListener(events_1.Events.EVENT_SORT_CHANGED, this.refreshModel.bind(this, constants_1.Constants.STEP_SORT));
if (this.gridOptionsWrapper.isRowModelDefault()) {
this.setRowData(this.gridOptionsWrapper.getRowData(), this.columnController.isReady());
}
};
InMemoryRowController.prototype.refreshModel = function (step, fromIndex, groupState) {
// this goes through the pipeline of stages. what's in my head is similar
// to the diagram on this page:
// http://commons.apache.org/sandbox/commons-pipeline/pipeline_basics.html
// however we want to keep the results of each stage, hence we manually call
// each step rather than have them chain each other.
var _this = this;
// fallthrough in below switch is on purpose,
// eg if STEP_FILTER, then all steps below this
// step get done
switch (step) {
case constants_1.Constants.STEP_EVERYTHING:
this.doRowGrouping(groupState);
case constants_1.Constants.STEP_FILTER:
this.doFilter();
case constants_1.Constants.STEP_AGGREGATE:
this.doAggregate();
case constants_1.Constants.STEP_SORT:
this.doSort();
case constants_1.Constants.STEP_MAP:
this.doRowsToDisplay();
}
this.eventService.dispatchEvent(events_1.Events.EVENT_MODEL_UPDATED, { fromIndex: fromIndex });
if (this.$scope) {
setTimeout(function () {
_this.$scope.$apply();
}, 0);
}
};
InMemoryRowController.prototype.isEmpty = function () {
return this.allRows === null || this.allRows.length === 0 || !this.columnController.isReady();
};
InMemoryRowController.prototype.isRowsToRender = function () {
return utils_1.Utils.exists(this.rowsToDisplay) && this.rowsToDisplay.length > 0;
};
InMemoryRowController.prototype.setDatasource = function (datasource) {
console.error('ag-Grid: should never call setDatasource on inMemoryRowController');
};
InMemoryRowController.prototype.getTopLevelNodes = function () {
return this.rowsAfterGroup;
};
InMemoryRowController.prototype.getRow = function (index) {
return this.rowsToDisplay[index];
};
InMemoryRowController.prototype.getVirtualRowCount = function () {
console.warn('ag-Grid: rowModel.getVirtualRowCount() is not longer a function, use rowModel.getRowCount() instead');
return this.getRowCount();
};
InMemoryRowController.prototype.getRowCount = function () {
if (this.rowsToDisplay) {
return this.rowsToDisplay.length;
}
else {
return 0;
}
};
InMemoryRowController.prototype.getRowAtPixel = function (pixelToMatch) {
if (this.isEmpty()) {
return -1;
}
// do binary search of tree
// http://oli.me.uk/2013/06/08/searching-javascript-arrays-with-a-binary-search/
var bottomPointer = 0;
var topPointer = this.rowsToDisplay.length - 1;
// quick check, if the pixel is out of bounds, then return last row
if (pixelToMatch <= 0) {
// if pixel is less than or equal zero, it's always the first row
return 0;
}
var lastNode = this.rowsToDisplay[this.rowsToDisplay.length - 1];
if (lastNode.rowTop <= pixelToMatch) {
return this.rowsToDisplay.length - 1;
}
while (true) {
var midPointer = Math.floor((bottomPointer + topPointer) / 2);
var currentRowNode = this.rowsToDisplay[midPointer];
if (this.isRowInPixel(currentRowNode, pixelToMatch)) {
return midPointer;
}
else if (currentRowNode.rowTop < pixelToMatch) {
bottomPointer = midPointer + 1;
}
else if (currentRowNode.rowTop > pixelToMatch) {
topPointer = midPointer - 1;
}
}
};
InMemoryRowController.prototype.isRowInPixel = function (rowNode, pixelToMatch) {
var topPixel = rowNode.rowTop;
var bottomPixel = rowNode.rowTop + rowNode.rowHeight;
var pixelInRow = topPixel <= pixelToMatch && bottomPixel > pixelToMatch;
return pixelInRow;
};
InMemoryRowController.prototype.getRowCombinedHeight = function () {
if (this.rowsToDisplay && this.rowsToDisplay.length > 0) {
var lastRow = this.rowsToDisplay[this.rowsToDisplay.length - 1];
var lastPixel = lastRow.rowTop + lastRow.rowHeight;
return lastPixel;
}
else {
return 0;
}
};
InMemoryRowController.prototype.forEachNode = function (callback) {
this.recursivelyWalkNodesAndCallback(this.rowsAfterGroup, callback, RecursionType.Normal, 0);
};
InMemoryRowController.prototype.forEachNodeAfterFilter = function (callback) {
this.recursivelyWalkNodesAndCallback(this.rowsAfterFilter, callback, RecursionType.AfterFilter, 0);
};
InMemoryRowController.prototype.forEachNodeAfterFilterAndSort = function (callback) {
this.recursivelyWalkNodesAndCallback(this.rowsAfterSort, callback, RecursionType.AfterFilterAndSort, 0);
};
// iterates through each item in memory, and calls the callback function
// nodes - the rowNodes to traverse
// callback - the user provided callback
// recursion type - need this to know what child nodes to recurse, eg if looking at all nodes, or filtered notes etc
// index - works similar to the index in forEach in javascripts array function
InMemoryRowController.prototype.recursivelyWalkNodesAndCallback = function (nodes, callback, recursionType, index) {
if (nodes) {
for (var i = 0; i < nodes.length; i++) {
var node = nodes[i];
callback(node, index++);
// go to the next level if it is a group
if (node.group) {
// depending on the recursion type, we pick a difference set of children
var nodeChildren;
switch (recursionType) {
case RecursionType.Normal:
nodeChildren = node.children;
break;
case RecursionType.AfterFilter:
nodeChildren = node.childrenAfterFilter;
break;
case RecursionType.AfterFilterAndSort:
nodeChildren = node.childrenAfterSort;
break;
}
if (nodeChildren) {
index = this.recursivelyWalkNodesAndCallback(nodeChildren, callback, recursionType, index);
}
}
}
}
return index;
};
// it's possible to recompute the aggregate without doing the other parts
// + gridApi.recomputeAggregates()
InMemoryRowController.prototype.doAggregate = function () {
if (this.aggregationStage) {
this.aggregationStage.execute(this.rowsAfterFilter);
}
};
// + gridApi.expandAll()
// + gridApi.collapseAll()
InMemoryRowController.prototype.expandOrCollapseAll = function (expand) {
recursiveExpandOrCollapse(this.rowsAfterGroup);
function recursiveExpandOrCollapse(rowNodes) {
if (!rowNodes) {
return;
}
rowNodes.forEach(function (rowNode) {
if (rowNode.group) {
rowNode.expanded = expand;
recursiveExpandOrCollapse(rowNode.children);
}
});
}
this.refreshModel(constants_2.Constants.STEP_MAP);
};
InMemoryRowController.prototype.doSort = function () {
this.rowsAfterSort = this.sortStage.execute(this.rowsAfterFilter);
};
InMemoryRowController.prototype.doRowGrouping = function (groupState) {
// grouping is enterprise only, so if service missing, skip the step
var rowsAlreadyGrouped = utils_1.Utils.exists(this.gridOptionsWrapper.getNodeChildDetailsFunc());
if (this.groupStage && !rowsAlreadyGrouped) {
// remove old groups from the selection model, as we are about to replace them
// with new groups
this.selectionController.removeGroupsFromSelection();
this.rowsAfterGroup = this.groupStage.execute(this.allRows);
this.restoreGroupState(groupState);
if (this.gridOptionsWrapper.isGroupSelectsChildren()) {
this.selectionController.updateGroupsFromChildrenSelections();
}
}
else {
this.rowsAfterGroup = this.allRows;
}
};
InMemoryRowController.prototype.restoreGroupState = function (groupState) {
if (!groupState) {
return;
}
utils_1.Utils.traverseNodesWithKey(this.rowsAfterGroup, function (node, key) {
node.expanded = groupState[key] === true;
});
};
InMemoryRowController.prototype.doFilter = function () {
this.rowsAfterFilter = this.filterStage.execute(this.rowsAfterGroup);
};
// rows: the rows to put into the model
// firstId: the first id to use, used for paging, where we are not on the first page
InMemoryRowController.prototype.setRowData = function (rowData, refresh, firstId) {
// remember group state, so we can expand groups that should be expanded
var groupState = this.getGroupState();
// place each row into a wrapper
this.allRows = this.createRowNodesFromData(rowData, firstId);
this.eventService.dispatchEvent(events_1.Events.EVENT_ROW_DATA_CHANGED);
if (refresh) {
this.refreshModel(constants_2.Constants.STEP_EVERYTHING, null, groupState);
}
};
InMemoryRowController.prototype.getGroupState = function () {
if (!this.rowsAfterGroup || !this.gridOptionsWrapper.isRememberGroupStateWhenNewData()) {
return null;
}
var result = {};
utils_1.Utils.traverseNodesWithKey(this.rowsAfterGroup, function (node, key) { return result[key] = node.expanded; });
return result;
};
InMemoryRowController.prototype.createRowNodesFromData = function (rowData, firstId) {
if (!rowData) {
return [];
}
var rowNodeId = utils_1.Utils.exists(firstId) ? firstId : 0;
// func below doesn't have 'this' pointer, so need to pull out these bits
var nodeChildDetailsFunc = this.gridOptionsWrapper.getNodeChildDetailsFunc();
var suppressParentsInRowNodes = this.gridOptionsWrapper.isSuppressParentsInRowNodes();
var eventService = this.eventService;
var gridOptionsWrapper = this.gridOptionsWrapper;
var selectionController = this.selectionController;
// kick off recursion
var result = recursiveFunction(rowData, null, 0);
return result;
function recursiveFunction(rowData, parent, level) {
var rowNodes = [];
rowData.forEach(function (dataItem) {
var node = new rowNode_1.RowNode(eventService, gridOptionsWrapper, selectionController);
var nodeChildDetails = nodeChildDetailsFunc ? nodeChildDetailsFunc(dataItem) : null;
if (nodeChildDetails && nodeChildDetails.group) {
node.group = true;
node.children = recursiveFunction(nodeChildDetails.children, node, level + 1);
node.expanded = nodeChildDetails.expanded === true;
node.field = nodeChildDetails.field;
node.key = nodeChildDetails.key;
}
if (parent && !suppressParentsInRowNodes) {
node.parent = parent;
}
node.level = level;
node.id = rowNodeId++;
node.data = dataItem;
rowNodes.push(node);
});
return rowNodes;
}
};
InMemoryRowController.prototype.doRowsToDisplay = function () {
this.rowsToDisplay = this.flattenStage.execute(this.rowsAfterSort);
};
__decorate([
context_2.Autowired('gridOptionsWrapper'),
__metadata('design:type', gridOptionsWrapper_1.GridOptionsWrapper)
], InMemoryRowController.prototype, "gridOptionsWrapper", void 0);
__decorate([
context_2.Autowired('columnController'),
__metadata('design:type', columnController_1.ColumnController)
], InMemoryRowController.prototype, "columnController", void 0);
__decorate([
context_2.Autowired('filterManager'),
__metadata('design:type', filterManager_1.FilterManager)
], InMemoryRowController.prototype, "filterManager", void 0);
__decorate([
context_2.Autowired('$scope'),
__metadata('design:type', Object)
], InMemoryRowController.prototype, "$scope", void 0);
__decorate([
context_2.Autowired('selectionController'),
__metadata('design:type', selectionController_1.SelectionController)
], InMemoryRowController.prototype, "selectionController", void 0);
__decorate([
context_2.Autowired('eventService'),
__metadata('design:type', eventService_1.EventService)
], InMemoryRowController.prototype, "eventService", void 0);
__decorate([
context_2.Autowired('filterStage'),
__metadata('design:type', Object)
], InMemoryRowController.prototype, "filterStage", void 0);
__decorate([
context_2.Autowired('sortStage'),
__metadata('design:type', Object)
], InMemoryRowController.prototype, "sortStage", void 0);
__decorate([
context_2.Autowired('flattenStage'),
__metadata('design:type', Object)
], InMemoryRowController.prototype, "flattenStage", void 0);
__decorate([
context_4.Optional('groupStage'),
__metadata('design:type', Object)
], InMemoryRowController.prototype, "groupStage", void 0);
__decorate([
context_4.Optional('aggregationStage'),
__metadata('design:type', Object)
], InMemoryRowController.prototype, "aggregationStage", void 0);
__decorate([
// the rows mapped to rows to display
context_3.PostConstruct,
__metadata('design:type', Function),
__metadata('design:paramtypes', []),
__metadata('design:returntype', void 0)
], InMemoryRowController.prototype, "init", null);
InMemoryRowController = __decorate([
context_1.Bean('rowModel'),
__metadata('design:paramtypes', [])
], InMemoryRowController);
return InMemoryRowController;
})();
exports.InMemoryRowController = InMemoryRowController;
/***/ },
/* 64 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var utils_1 = __webpack_require__(7);
var gridOptionsWrapper_1 = __webpack_require__(3);
var rowNode_1 = __webpack_require__(19);
var context_1 = __webpack_require__(6);
var eventService_1 = __webpack_require__(4);
var selectionController_1 = __webpack_require__(29);
var context_2 = __webpack_require__(6);
var context_3 = __webpack_require__(6);
var events_1 = __webpack_require__(10);
var sortController_1 = __webpack_require__(39);
var filterManager_1 = __webpack_require__(40);
/*
* This row controller is used for infinite scrolling only. For normal 'in memory' table,
* or standard pagination, the inMemoryRowController is used.
*/
var logging = false;
var VirtualPageRowController = (function () {
function VirtualPageRowController() {
this.datasourceVersion = 0;
}
VirtualPageRowController.prototype.init = function () {
var _this = this;
var virtualEnabled = this.gridOptionsWrapper.isRowModelVirtual();
this.eventService.addEventListener(events_1.Events.EVENT_FILTER_CHANGED, function () {
if (virtualEnabled && _this.gridOptionsWrapper.isEnableServerSideFilter()) {
_this.reset();
}
});
this.eventService.addEventListener(events_1.Events.EVENT_SORT_CHANGED, function () {
if (virtualEnabled && _this.gridOptionsWrapper.isEnableServerSideSorting()) {
_this.reset();
}
});
if (virtualEnabled && this.gridOptionsWrapper.getDatasource()) {
this.setDatasource(this.gridOptionsWrapper.getDatasource());
}
};
VirtualPageRowController.prototype.getTopLevelNodes = function () {
return null;
};
VirtualPageRowController.prototype.setDatasource = function (datasource) {
this.datasource = datasource;
if (!datasource) {
// only continue if we have a valid datasource to working with
return;
}
this.reset();
};
VirtualPageRowController.prototype.isEmpty = function () {
return !this.datasource;
};
VirtualPageRowController.prototype.isRowsToRender = function () {
return utils_1.Utils.exists(this.datasource);
};
VirtualPageRowController.prototype.reset = function () {
this.selectionController.reset();
// see if datasource knows how many rows there are
if (typeof this.datasource.rowCount === 'number' && this.datasource.rowCount >= 0) {
this.virtualRowCount = this.datasource.rowCount;
this.foundMaxRow = true;
}
else {
this.virtualRowCount = 0;
this.foundMaxRow = false;
}
// in case any daemon requests coming from datasource, we know it ignore them
this.datasourceVersion++;
// map of page numbers to rows in that page
this.pageCache = {};
this.pageCacheSize = 0;
// if a number is in this array, it means we are pending a load from it
this.pageLoadsInProgress = [];
this.pageLoadsQueued = [];
this.pageAccessTimes = {}; // keeps a record of when each page was last viewed, used for LRU cache
this.accessTime = 0; // rather than using the clock, we use this counter
// the number of concurrent loads we are allowed to the server
if (typeof this.datasource.maxConcurrentRequests === 'number' && this.datasource.maxConcurrentRequests > 0) {
this.maxConcurrentDatasourceRequests = this.datasource.maxConcurrentRequests;
}
else {
this.maxConcurrentDatasourceRequests = 2;
}
// the number of pages to keep in browser cache
if (typeof this.datasource.maxPagesInCache === 'number' && this.datasource.maxPagesInCache > 0) {
this.maxPagesInCache = this.datasource.maxPagesInCache;
}
else {
// null is default, means don't have any max size on the cache
this.maxPagesInCache = null;
}
this.pageSize = this.datasource.pageSize; // take a copy of page size, we don't want it changing
this.overflowSize = this.datasource.overflowSize; // take a copy of page size, we don't want it changing
this.doLoadOrQueue(0);
this.rowRenderer.refreshView();
};
VirtualPageRowController.prototype.createNodesFromRows = function (pageNumber, rows) {
var nodes = [];
if (rows) {
for (var i = 0, j = rows.length; i < j; i++) {
var virtualRowIndex = (pageNumber * this.pageSize) + i;
var node = this.createNode(rows[i], virtualRowIndex, true);
nodes.push(node);
}
}
return nodes;
};
VirtualPageRowController.prototype.createNode = function (data, virtualRowIndex, realNode) {
var rowHeight = this.getRowHeightAsNumber();
var top = rowHeight * virtualRowIndex;
var rowNode;
if (realNode) {
// if a real node, then always create a new one
rowNode = new rowNode_1.RowNode(this.eventService, this.gridOptionsWrapper, this.selectionController);
rowNode.id = virtualRowIndex;
rowNode.data = data;
// and see if the previous one was selected, and if yes, swap it out
this.selectionController.syncInRowNode(rowNode);
}
else {
// if creating a proxy node, see if there is a copy in selected memory that we can use
var rowNode = this.selectionController.getNodeForIdIfSelected(virtualRowIndex);
if (!rowNode) {
rowNode = new rowNode_1.RowNode(this.eventService, this.gridOptionsWrapper, this.selectionController);
rowNode.id = virtualRowIndex;
rowNode.data = data;
}
}
rowNode.rowTop = top;
rowNode.rowHeight = rowHeight;
return rowNode;
};
VirtualPageRowController.prototype.removeFromLoading = function (pageNumber) {
var index = this.pageLoadsInProgress.indexOf(pageNumber);
this.pageLoadsInProgress.splice(index, 1);
};
VirtualPageRowController.prototype.pageLoadFailed = function (pageNumber) {
this.removeFromLoading(pageNumber);
this.checkQueueForNextLoad();
};
VirtualPageRowController.prototype.pageLoaded = function (pageNumber, rows, lastRow) {
this.putPageIntoCacheAndPurge(pageNumber, rows);
this.checkMaxRowAndInformRowRenderer(pageNumber, lastRow);
this.removeFromLoading(pageNumber);
this.checkQueueForNextLoad();
};
VirtualPageRowController.prototype.putPageIntoCacheAndPurge = function (pageNumber, rows) {
this.pageCache[pageNumber] = this.createNodesFromRows(pageNumber, rows);
this.pageCacheSize++;
if (logging) {
console.log('adding page ' + pageNumber);
}
var needToPurge = this.maxPagesInCache && this.maxPagesInCache < this.pageCacheSize;
if (needToPurge) {
// find the LRU page
var youngestPageIndex = this.findLeastRecentlyAccessedPage(Object.keys(this.pageCache));
if (logging) {
console.log('purging page ' + youngestPageIndex + ' from cache ' + Object.keys(this.pageCache));
}
delete this.pageCache[youngestPageIndex];
this.pageCacheSize--;
}
};
VirtualPageRowController.prototype.checkMaxRowAndInformRowRenderer = function (pageNumber, lastRow) {
if (!this.foundMaxRow) {
// if we know the last row, use if
if (typeof lastRow === 'number' && lastRow >= 0) {
this.virtualRowCount = lastRow;
this.foundMaxRow = true;
}
else {
// otherwise, see if we need to add some virtual rows
var thisPagePlusBuffer = ((pageNumber + 1) * this.pageSize) + this.overflowSize;
if (this.virtualRowCount < thisPagePlusBuffer) {
this.virtualRowCount = thisPagePlusBuffer;
}
}
// if rowCount changes, refreshView, otherwise just refreshAllVirtualRows
this.rowRenderer.refreshView();
}
else {
this.rowRenderer.refreshAllVirtualRows();
}
};
VirtualPageRowController.prototype.isPageAlreadyLoading = function (pageNumber) {
var result = this.pageLoadsInProgress.indexOf(pageNumber) >= 0 || this.pageLoadsQueued.indexOf(pageNumber) >= 0;
return result;
};
VirtualPageRowController.prototype.doLoadOrQueue = function (pageNumber) {
// if we already tried to load this page, then ignore the request,
// otherwise server would be hit 50 times just to display one page, the
// first row to find the page missing is enough.
if (this.isPageAlreadyLoading(pageNumber)) {
return;
}
// try the page load - if not already doing a load, then we can go ahead
if (this.pageLoadsInProgress.length < this.maxConcurrentDatasourceRequests) {
// go ahead, load the page
this.loadPage(pageNumber);
}
else {
// otherwise, queue the request
this.addToQueueAndPurgeQueue(pageNumber);
}
};
VirtualPageRowController.prototype.addToQueueAndPurgeQueue = function (pageNumber) {
if (logging) {
console.log('queueing ' + pageNumber + ' - ' + this.pageLoadsQueued);
}
this.pageLoadsQueued.push(pageNumber);
// see if there are more pages queued that are actually in our cache, if so there is
// no point in loading them all as some will be purged as soon as loaded
var needToPurge = this.maxPagesInCache && this.maxPagesInCache < this.pageLoadsQueued.length;
if (needToPurge) {
// find the LRU page
var youngestPageIndex = this.findLeastRecentlyAccessedPage(this.pageLoadsQueued);
if (logging) {
console.log('de-queueing ' + pageNumber + ' - ' + this.pageLoadsQueued);
}
var indexToRemove = this.pageLoadsQueued.indexOf(youngestPageIndex);
this.pageLoadsQueued.splice(indexToRemove, 1);
}
};
VirtualPageRowController.prototype.findLeastRecentlyAccessedPage = function (pageIndexes) {
var youngestPageIndex = -1;
var youngestPageAccessTime = Number.MAX_VALUE;
var that = this;
pageIndexes.forEach(function (pageIndex) {
var accessTimeThisPage = that.pageAccessTimes[pageIndex];
if (accessTimeThisPage < youngestPageAccessTime) {
youngestPageAccessTime = accessTimeThisPage;
youngestPageIndex = pageIndex;
}
});
return youngestPageIndex;
};
VirtualPageRowController.prototype.checkQueueForNextLoad = function () {
if (this.pageLoadsQueued.length > 0) {
// take from the front of the queue
var pageToLoad = this.pageLoadsQueued[0];
this.pageLoadsQueued.splice(0, 1);
if (logging) {
console.log('dequeueing ' + pageToLoad + ' - ' + this.pageLoadsQueued);
}
this.loadPage(pageToLoad);
}
};
VirtualPageRowController.prototype.loadPage = function (pageNumber) {
this.pageLoadsInProgress.push(pageNumber);
var startRow = pageNumber * this.pageSize;
var endRow = (pageNumber + 1) * this.pageSize;
var that = this;
var datasourceVersionCopy = this.datasourceVersion;
var sortModel;
if (this.gridOptionsWrapper.isEnableServerSideSorting()) {
sortModel = this.sortController.getSortModel();
}
var filterModel;
if (this.gridOptionsWrapper.isEnableServerSideFilter()) {
filterModel = this.filterManager.getFilterModel();
}
var params = {
startRow: startRow,
endRow: endRow,
successCallback: successCallback,
failCallback: failCallback,
sortModel: sortModel,
filterModel: filterModel
};
// check if old version of datasource used
var getRowsParams = utils_1.Utils.getFunctionParameters(this.datasource.getRows);
if (getRowsParams.length > 1) {
console.warn('ag-grid: It looks like your paging datasource is of the old type, taking more than one parameter.');
console.warn('ag-grid: From ag-grid 1.9.0, now the getRows takes one parameter. See the documentation for details.');
}
this.datasource.getRows(params);
function successCallback(rows, lastRowIndex) {
if (that.requestIsDaemon(datasourceVersionCopy)) {
return;
}
that.pageLoaded(pageNumber, rows, lastRowIndex);
}
function failCallback() {
if (that.requestIsDaemon(datasourceVersionCopy)) {
return;
}
that.pageLoadFailed(pageNumber);
}
};
VirtualPageRowController.prototype.expandOrCollapseAll = function (expand) {
console.warn('ag-Grid: can not expand or collapse all when doing virtual pagination');
};
// check that the datasource has not changed since the lats time we did a request
VirtualPageRowController.prototype.requestIsDaemon = function (datasourceVersionCopy) {
return this.datasourceVersion !== datasourceVersionCopy;
};
VirtualPageRowController.prototype.getRow = function (rowIndex) {
if (rowIndex > this.virtualRowCount) {
return null;
}
var pageNumber = Math.floor(rowIndex / this.pageSize);
var page = this.pageCache[pageNumber];
// for LRU cache, track when this page was last hit
this.pageAccessTimes[pageNumber] = this.accessTime++;
if (!page) {
this.doLoadOrQueue(pageNumber);
// return back an empty row, so table can at least render empty cells
var dummyNode = this.createNode(null, rowIndex, false);
return dummyNode;
}
else {
var indexInThisPage = rowIndex % this.pageSize;
return page[indexInThisPage];
}
};
VirtualPageRowController.prototype.forEachNode = function (callback) {
var pageKeys = Object.keys(this.pageCache);
for (var i = 0; i < pageKeys.length; i++) {
var pageKey = pageKeys[i];
var page = this.pageCache[pageKey];
for (var j = 0; j < page.length; j++) {
var node = page[j];
callback(node);
}
}
};
VirtualPageRowController.prototype.getRowHeightAsNumber = function () {
var rowHeight = this.gridOptionsWrapper.getRowHeightForVirtualPagination();
if (typeof rowHeight === 'number') {
return rowHeight;
}
else {
console.warn('ag-Grid row height must be a number when doing virtual paging');
return 25;
}
};
VirtualPageRowController.prototype.getRowCombinedHeight = function () {
return this.virtualRowCount * this.getRowHeightAsNumber();
};
VirtualPageRowController.prototype.getRowAtPixel = function (pixel) {
var rowHeight = this.getRowHeightAsNumber();
if (rowHeight !== 0) {
return Math.floor(pixel / rowHeight);
}
else {
return 0;
}
};
VirtualPageRowController.prototype.getRowCount = function () {
return this.virtualRowCount;
};
VirtualPageRowController.prototype.setRowData = function (rows, refresh, firstId) {
console.warn('setRowData - does not work with virtual pagination');
};
VirtualPageRowController.prototype.forEachNodeAfterFilter = function (callback) {
console.warn('forEachNodeAfterFilter - does not work with virtual pagination');
};
VirtualPageRowController.prototype.forEachNodeAfterFilterAndSort = function (callback) {
console.warn('forEachNodeAfterFilter - does not work with virtual pagination');
};
VirtualPageRowController.prototype.refreshModel = function () {
console.warn('forEachNodeAfterFilter - does not work with virtual pagination');
};
__decorate([
context_2.Autowired('rowRenderer'),
__metadata('design:type', Object)
], VirtualPageRowController.prototype, "rowRenderer", void 0);
__decorate([
context_2.Autowired('gridOptionsWrapper'),
__metadata('design:type', gridOptionsWrapper_1.GridOptionsWrapper)
], VirtualPageRowController.prototype, "gridOptionsWrapper", void 0);
__decorate([
context_2.Autowired('filterManager'),
__metadata('design:type', filterManager_1.FilterManager)
], VirtualPageRowController.prototype, "filterManager", void 0);
__decorate([
context_2.Autowired('sortController'),
__metadata('design:type', sortController_1.SortController)
], VirtualPageRowController.prototype, "sortController", void 0);
__decorate([
context_2.Autowired('selectionController'),
__metadata('design:type', selectionController_1.SelectionController)
], VirtualPageRowController.prototype, "selectionController", void 0);
__decorate([
context_2.Autowired('eventService'),
__metadata('design:type', eventService_1.EventService)
], VirtualPageRowController.prototype, "eventService", void 0);
__decorate([
context_3.PostConstruct,
__metadata('design:type', Function),
__metadata('design:paramtypes', []),
__metadata('design:returntype', void 0)
], VirtualPageRowController.prototype, "init", null);
VirtualPageRowController = __decorate([
context_1.Bean('rowModel'),
__metadata('design:paramtypes', [])
], VirtualPageRowController);
return VirtualPageRowController;
})();
exports.VirtualPageRowController = VirtualPageRowController;
/***/ },
/* 65 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
var utils_1 = __webpack_require__(7);
var logger_1 = __webpack_require__(5);
var context_1 = __webpack_require__(6);
var context_2 = __webpack_require__(6);
/** Functionality for internal DnD functionality between GUI widgets. Eg this service is used to drag columns
* from the 'available columns' list and putting them into the 'grouped columns' in the tool panel.
* This service is NOT used by the column headers for resizing and moving, that is a different use case. */
var OldToolPanelDragAndDropService = (function () {
function OldToolPanelDragAndDropService() {
this.destroyFunctions = [];
}
OldToolPanelDragAndDropService.prototype.agWire = function (loggerFactory) {
this.logger = loggerFactory.create('OldToolPanelDragAndDropService');
// need to clean this up, add to 'finished' logic in grid
var mouseUpListener = this.stopDragging.bind(this);
document.addEventListener('mouseup', mouseUpListener);
this.destroyFunctions.push(function () { document.removeEventListener('mouseup', mouseUpListener); });
};
OldToolPanelDragAndDropService.prototype.agDestroy = function () {
this.destroyFunctions.forEach(function (func) { return func(); });
document.removeEventListener('mouseup', this.mouseUpEventListener);
};
OldToolPanelDragAndDropService.prototype.stopDragging = function () {
if (this.dragItem) {
this.setDragCssClasses(this.dragItem.eDragSource, false);
this.dragItem = null;
}
};
OldToolPanelDragAndDropService.prototype.setDragCssClasses = function (eListItem, dragging) {
utils_1.Utils.addOrRemoveCssClass(eListItem, 'ag-dragging', dragging);
utils_1.Utils.addOrRemoveCssClass(eListItem, 'ag-not-dragging', !dragging);
};
OldToolPanelDragAndDropService.prototype.addDragSource = function (eDragSource, dragSourceCallback) {
this.setDragCssClasses(eDragSource, false);
eDragSource.addEventListener('mousedown', this.onMouseDownDragSource.bind(this, eDragSource, dragSourceCallback));
};
OldToolPanelDragAndDropService.prototype.onMouseDownDragSource = function (eDragSource, dragSourceCallback) {
if (this.dragItem) {
this.stopDragging();
}
var data;
if (dragSourceCallback.getData) {
data = dragSourceCallback.getData();
}
var containerId;
if (dragSourceCallback.getContainerId) {
containerId = dragSourceCallback.getContainerId();
}
this.dragItem = {
eDragSource: eDragSource,
data: data,
containerId: containerId
};
this.setDragCssClasses(this.dragItem.eDragSource, true);
};
OldToolPanelDragAndDropService.prototype.addDropTarget = function (eDropTarget, dropTargetCallback) {
var _this = this;
var mouseIn = false;
var acceptDrag = false;
eDropTarget.addEventListener('mouseover', function () {
if (!mouseIn) {
mouseIn = true;
if (_this.dragItem) {
acceptDrag = dropTargetCallback.acceptDrag(_this.dragItem);
}
else {
acceptDrag = false;
}
}
});
eDropTarget.addEventListener('mouseout', function () {
if (acceptDrag) {
dropTargetCallback.noDrop();
}
mouseIn = false;
acceptDrag = false;
});
eDropTarget.addEventListener('mouseup', function () {
// dragItem should never be null, checking just in case
if (acceptDrag && _this.dragItem) {
dropTargetCallback.drop(_this.dragItem);
}
});
};
__decorate([
__param(0, context_2.Qualifier('loggerFactory')),
__metadata('design:type', Function),
__metadata('design:paramtypes', [logger_1.LoggerFactory]),
__metadata('design:returntype', void 0)
], OldToolPanelDragAndDropService.prototype, "agWire", null);
OldToolPanelDragAndDropService = __decorate([
context_1.Bean('oldToolPanelDragAndDropService'),
__metadata('design:paramtypes', [])
], OldToolPanelDragAndDropService);
return OldToolPanelDragAndDropService;
})();
exports.OldToolPanelDragAndDropService = OldToolPanelDragAndDropService;
/***/ },
/* 66 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var context_1 = __webpack_require__(6);
var filterManager_1 = __webpack_require__(40);
var utils_1 = __webpack_require__(7);
var context_2 = __webpack_require__(6);
var popupService_1 = __webpack_require__(41);
var gridOptionsWrapper_1 = __webpack_require__(3);
var StandardMenuFactory = (function () {
function StandardMenuFactory() {
}
StandardMenuFactory.prototype.showMenu = function (column, eventSource) {
var filterWrapper = this.filterManager.getOrCreateFilterWrapper(column);
var eMenu = document.createElement('div');
utils_1.Utils.addCssClass(eMenu, 'ag-menu');
eMenu.appendChild(filterWrapper.gui);
// need to show filter before positioning, as only after filter
// is visible can we find out what the width of it is
var hidePopup = this.popupService.addAsModalPopup(eMenu, true);
this.popupService.positionPopupUnderComponent({ eventSource: eventSource, ePopup: eMenu, keepWithinBounds: true });
if (filterWrapper.filter.afterGuiAttached) {
var params = {
hidePopup: hidePopup,
eventSource: eventSource
};
filterWrapper.filter.afterGuiAttached(params);
}
};
StandardMenuFactory.prototype.isMenuEnabled = function (column) {
// for standard, we show menu if filter is enabled, and he menu is not suppressed
return this.gridOptionsWrapper.isEnableFilter();
};
__decorate([
context_2.Autowired('filterManager'),
__metadata('design:type', filterManager_1.FilterManager)
], StandardMenuFactory.prototype, "filterManager", void 0);
__decorate([
context_2.Autowired('popupService'),
__metadata('design:type', popupService_1.PopupService)
], StandardMenuFactory.prototype, "popupService", void 0);
__decorate([
context_2.Autowired('gridOptionsWrapper'),
__metadata('design:type', gridOptionsWrapper_1.GridOptionsWrapper)
], StandardMenuFactory.prototype, "gridOptionsWrapper", void 0);
StandardMenuFactory = __decorate([
context_1.Bean('menuFactory'),
__metadata('design:paramtypes', [])
], StandardMenuFactory);
return StandardMenuFactory;
})();
exports.StandardMenuFactory = StandardMenuFactory;
/***/ },
/* 67 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var context_1 = __webpack_require__(6);
var context_2 = __webpack_require__(6);
var gridOptionsWrapper_1 = __webpack_require__(3);
var filterManager_1 = __webpack_require__(40);
var FilterStage = (function () {
function FilterStage() {
}
FilterStage.prototype.execute = function (rowsToFilter) {
var filterActive;
if (this.gridOptionsWrapper.isEnableServerSideFilter()) {
filterActive = false;
}
else {
filterActive = this.filterManager.isAnyFilterPresent();
}
var result;
if (filterActive) {
result = this.filterItems(rowsToFilter);
}
else {
// do it here
result = rowsToFilter;
this.recursivelyResetFilter(rowsToFilter);
}
return result;
};
FilterStage.prototype.filterItems = function (rowNodes) {
var result = [];
for (var i = 0, l = rowNodes.length; i < l; i++) {
var node = rowNodes[i];
if (node.group) {
// deal with group
node.childrenAfterFilter = this.filterItems(node.children);
if (node.childrenAfterFilter.length > 0) {
node.allChildrenCount = this.getTotalChildCount(node.childrenAfterFilter);
result.push(node);
}
}
else {
if (this.filterManager.doesRowPassFilter(node)) {
result.push(node);
}
}
}
return result;
};
FilterStage.prototype.recursivelyResetFilter = function (nodes) {
if (!nodes) {
return;
}
for (var i = 0, l = nodes.length; i < l; i++) {
var node = nodes[i];
if (node.group && node.children) {
node.childrenAfterFilter = node.children;
this.recursivelyResetFilter(node.children);
node.allChildrenCount = this.getTotalChildCount(node.childrenAfterFilter);
}
}
};
FilterStage.prototype.getTotalChildCount = function (rowNodes) {
var count = 0;
for (var i = 0, l = rowNodes.length; i < l; i++) {
var item = rowNodes[i];
if (item.group) {
count += item.allChildrenCount;
}
else {
count++;
}
}
return count;
};
__decorate([
context_2.Autowired('gridOptionsWrapper'),
__metadata('design:type', gridOptionsWrapper_1.GridOptionsWrapper)
], FilterStage.prototype, "gridOptionsWrapper", void 0);
__decorate([
context_2.Autowired('filterManager'),
__metadata('design:type', filterManager_1.FilterManager)
], FilterStage.prototype, "filterManager", void 0);
FilterStage = __decorate([
context_1.Bean('filterStage'),
__metadata('design:paramtypes', [])
], FilterStage);
return FilterStage;
})();
exports.FilterStage = FilterStage;
/***/ },
/* 68 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var context_1 = __webpack_require__(6);
var context_2 = __webpack_require__(6);
var gridOptionsWrapper_1 = __webpack_require__(3);
var sortController_1 = __webpack_require__(39);
var valueService_1 = __webpack_require__(34);
var utils_1 = __webpack_require__(7);
var SortStage = (function () {
function SortStage() {
}
SortStage.prototype.execute = function (rowsToSort) {
var sorting;
// if the sorting is already done by the server, then we should not do it here
if (this.gridOptionsWrapper.isEnableServerSideSorting()) {
sorting = false;
}
else {
//see if there is a col we are sorting by
var sortingOptions = this.sortController.getSortForRowController();
sorting = sortingOptions.length > 0;
}
var result = rowsToSort.slice(0);
if (sorting) {
this.sortList(result, sortingOptions);
}
else {
// if no sorting, set all group children after sort to the original list.
// note: it is important to do this, even if doing server side sorting,
// to allow the rows to pass to the next stage (ie set the node value
// childrenAfterSort)
this.recursivelyResetSort(result);
}
return result;
};
SortStage.prototype.sortList = function (nodes, sortOptions) {
// sort any groups recursively
for (var i = 0, l = nodes.length; i < l; i++) {
var node = nodes[i];
if (node.group && node.children) {
node.childrenAfterSort = node.childrenAfterFilter.slice(0);
this.sortList(node.childrenAfterSort, sortOptions);
}
}
var that = this;
function compare(nodeA, nodeB, column, isInverted) {
var valueA = that.valueService.getValue(column, nodeA);
var valueB = that.valueService.getValue(column, nodeB);
if (column.getColDef().comparator) {
//if comparator provided, use it
return column.getColDef().comparator(valueA, valueB, nodeA, nodeB, isInverted);
}
else {
//otherwise do our own comparison
return utils_1.Utils.defaultComparator(valueA, valueB);
}
}
nodes.sort(function (nodeA, nodeB) {
// Iterate columns, return the first that doesn't match
for (var i = 0, len = sortOptions.length; i < len; i++) {
var sortOption = sortOptions[i];
var compared = compare(nodeA, nodeB, sortOption.column, sortOption.inverter === -1);
if (compared !== 0) {
return compared * sortOption.inverter;
}
}
// All matched, these are identical as far as the sort is concerned:
return 0;
});
this.updateChildIndexes(nodes);
};
SortStage.prototype.recursivelyResetSort = function (rowNodes) {
if (!rowNodes) {
return;
}
for (var i = 0, l = rowNodes.length; i < l; i++) {
var item = rowNodes[i];
if (item.group && item.children) {
item.childrenAfterSort = item.childrenAfterFilter;
this.recursivelyResetSort(item.children);
}
}
this.updateChildIndexes(rowNodes);
};
SortStage.prototype.updateChildIndexes = function (nodes) {
for (var j = 0; j < nodes.length; j++) {
var node = nodes[j];
node.firstChild = j === 0;
node.lastChild = j === nodes.length - 1;
node.childIndex = j;
}
};
__decorate([
context_2.Autowired('gridOptionsWrapper'),
__metadata('design:type', gridOptionsWrapper_1.GridOptionsWrapper)
], SortStage.prototype, "gridOptionsWrapper", void 0);
__decorate([
context_2.Autowired('sortController'),
__metadata('design:type', sortController_1.SortController)
], SortStage.prototype, "sortController", void 0);
__decorate([
context_2.Autowired('valueService'),
__metadata('design:type', valueService_1.ValueService)
], SortStage.prototype, "valueService", void 0);
SortStage = __decorate([
context_1.Bean('sortStage'),
__metadata('design:paramtypes', [])
], SortStage);
return SortStage;
})();
exports.SortStage = SortStage;
/***/ },
/* 69 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var context_1 = __webpack_require__(6);
var rowNode_1 = __webpack_require__(19);
var utils_1 = __webpack_require__(7);
var gridOptionsWrapper_1 = __webpack_require__(3);
var context_2 = __webpack_require__(6);
var selectionController_1 = __webpack_require__(29);
var eventService_1 = __webpack_require__(4);
var FlattenStage = (function () {
function FlattenStage() {
}
FlattenStage.prototype.execute = function (rowsToFlatten) {
// even if not doing grouping, we do the mapping, as the client might
// of passed in data that already has a grouping in it somewhere
var result = [];
// putting value into a wrapper so it's passed by reference
var nextRowTop = { value: 0 };
this.recursivelyAddToRowsToDisplay(rowsToFlatten, result, nextRowTop);
return result;
};
FlattenStage.prototype.recursivelyAddToRowsToDisplay = function (rowsToFlatten, result, nextRowTop) {
if (utils_1.Utils.missingOrEmpty(rowsToFlatten)) {
return;
}
var groupSuppressRow = this.gridOptionsWrapper.isGroupSuppressRow();
for (var i = 0; i < rowsToFlatten.length; i++) {
var rowNode = rowsToFlatten[i];
var skipGroupNode = groupSuppressRow && rowNode.group;
if (!skipGroupNode) {
this.addRowNodeToRowsToDisplay(rowNode, result, nextRowTop);
}
if (rowNode.group && rowNode.expanded) {
this.recursivelyAddToRowsToDisplay(rowNode.childrenAfterSort, result, nextRowTop);
// put a footer in if user is looking for it
if (this.gridOptionsWrapper.isGroupIncludeFooter()) {
var footerNode = this.createFooterNode(rowNode);
this.addRowNodeToRowsToDisplay(footerNode, result, nextRowTop);
}
}
}
};
// duplicated method, it's also in floatingRowModel
FlattenStage.prototype.addRowNodeToRowsToDisplay = function (rowNode, result, nextRowTop) {
result.push(rowNode);
rowNode.rowHeight = this.gridOptionsWrapper.getRowHeightForNode(rowNode);
rowNode.rowTop = nextRowTop.value;
nextRowTop.value += rowNode.rowHeight;
};
FlattenStage.prototype.createFooterNode = function (groupNode) {
var footerNode = new rowNode_1.RowNode(this.eventService, this.gridOptionsWrapper, this.selectionController);
Object.keys(groupNode).forEach(function (key) {
footerNode[key] = groupNode[key];
});
footerNode.footer = true;
// get both header and footer to reference each other as siblings. this is never undone,
// only overwritten. so if a group is expanded, then contracted, it will have a ghost
// sibling - but that's fine, as we can ignore this if the header is contracted.
footerNode.sibling = groupNode;
groupNode.sibling = footerNode;
return footerNode;
};
__decorate([
context_2.Autowired('gridOptionsWrapper'),
__metadata('design:type', gridOptionsWrapper_1.GridOptionsWrapper)
], FlattenStage.prototype, "gridOptionsWrapper", void 0);
__decorate([
context_2.Autowired('selectionController'),
__metadata('design:type', selectionController_1.SelectionController)
], FlattenStage.prototype, "selectionController", void 0);
__decorate([
context_2.Autowired('eventService'),
__metadata('design:type', eventService_1.EventService)
], FlattenStage.prototype, "eventService", void 0);
FlattenStage = __decorate([
context_1.Bean('flattenStage'),
__metadata('design:paramtypes', [])
], FlattenStage);
return FlattenStage;
})();
exports.FlattenStage = FlattenStage;
/***/ },
/* 70 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var grid_1 = __webpack_require__(2);
function initialiseAgGridWithAngular1(angular) {
var angularModule = angular.module("agGrid", []);
angularModule.directive("agGrid", function () {
return {
restrict: "A",
controller: ['$element', '$scope', '$compile', '$attrs', AngularDirectiveController],
scope: true
};
});
}
exports.initialiseAgGridWithAngular1 = initialiseAgGridWithAngular1;
function AngularDirectiveController($element, $scope, $compile, $attrs) {
var gridOptions;
var quickFilterOnScope;
var keyOfGridInScope = $attrs.agGrid;
quickFilterOnScope = keyOfGridInScope + '.quickFilterText';
gridOptions = $scope.$eval(keyOfGridInScope);
if (!gridOptions) {
console.warn("WARNING - grid options for ag-Grid not found. Please ensure the attribute ag-grid points to a valid object on the scope");
return;
}
var eGridDiv = $element[0];
var grid = new grid_1.Grid(eGridDiv, gridOptions, null, $scope, $compile, quickFilterOnScope);
$scope.$on("$destroy", function () {
grid.destroy();
});
}
/***/ },
/* 71 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var componentUtil_1 = __webpack_require__(9);
var grid_1 = __webpack_require__(2);
var registered = false;
function initialiseAgGridWithWebComponents() {
// only register to WebComponents once
if (registered) {
return;
}
registered = true;
if (typeof document === 'undefined' || !document.registerElement) {
console.error('ag-Grid: unable to find document.registerElement() function, unable to initialise ag-Grid as a Web Component');
}
// i don't think this type of extension is possible in TypeScript, so back to
// plain Javascript to create this object
var AgileGridProto = Object.create(HTMLElement.prototype);
// wrap each property with a get and set method, so we can track when changes are done
componentUtil_1.ComponentUtil.ALL_PROPERTIES.forEach(function (key) {
Object.defineProperty(AgileGridProto, key, {
set: function (v) {
this.__agGridSetProperty(key, v);
},
get: function () {
return this.__agGridGetProperty(key);
}
});
});
AgileGridProto.__agGridSetProperty = function (key, value) {
if (!this.__attributes) {
this.__attributes = {};
}
this.__attributes[key] = value;
// keeping this consistent with the ng2 onChange, so I can reuse the handling code
var changeObject = {};
changeObject[key] = { currentValue: value };
this.onChange(changeObject);
};
AgileGridProto.onChange = function (changes) {
if (this._initialised) {
componentUtil_1.ComponentUtil.processOnChange(changes, this._gridOptions, this.api);
}
};
AgileGridProto.__agGridGetProperty = function (key) {
if (!this.__attributes) {
this.__attributes = {};
}
return this.__attributes[key];
};
AgileGridProto.setGridOptions = function (options) {
var globalEventListener = this.globalEventListener.bind(this);
this._gridOptions = componentUtil_1.ComponentUtil.copyAttributesToGridOptions(options, this);
this._agGrid = new grid_1.Grid(this, this._gridOptions, globalEventListener);
this.api = options.api;
this.columnApi = options.columnApi;
this._initialised = true;
};
// copies all the attributes into this object
AgileGridProto.createdCallback = function () {
for (var i = 0; i < this.attributes.length; i++) {
var attribute = this.attributes[i];
this.setPropertyFromAttribute(attribute);
}
};
AgileGridProto.setPropertyFromAttribute = function (attribute) {
var name = toCamelCase(attribute.nodeName);
var value = attribute.nodeValue;
if (componentUtil_1.ComponentUtil.ALL_PROPERTIES.indexOf(name) >= 0) {
this[name] = value;
}
};
AgileGridProto.attachedCallback = function (params) { };
AgileGridProto.detachedCallback = function (params) { };
AgileGridProto.attributeChangedCallback = function (attributeName) {
var attribute = this.attributes[attributeName];
this.setPropertyFromAttribute(attribute);
};
AgileGridProto.globalEventListener = function (eventType, event) {
var eventLowerCase = eventType.toLowerCase();
var browserEvent = new Event(eventLowerCase);
var browserEventNoType = browserEvent;
browserEventNoType.agGridDetails = event;
this.dispatchEvent(browserEvent);
var callbackMethod = 'on' + eventLowerCase;
if (typeof this[callbackMethod] === 'function') {
this[callbackMethod](browserEvent);
}
};
// finally, register
document.registerElement('ag-grid', { prototype: AgileGridProto });
}
exports.initialiseAgGridWithWebComponents = initialiseAgGridWithWebComponents;
function toCamelCase(myString) {
if (typeof myString === 'string') {
var result = myString.replace(/-([a-z])/g, function (g) {
return g[1].toUpperCase();
});
return result;
}
else {
return myString;
}
}
/***/ },
/* 72 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var utils_1 = __webpack_require__(7);
var TabbedLayout = (function () {
function TabbedLayout(params) {
var _this = this;
this.items = [];
this.params = params;
this.eGui = document.createElement('div');
this.eGui.innerHTML = TabbedLayout.TEMPLATE;
this.eHeader = this.eGui.querySelector('#tabHeader');
this.eBody = this.eGui.querySelector('#tabBody');
utils_1.Utils.addCssClass(this.eGui, params.cssClass);
if (params.items) {
params.items.forEach(function (item) { return _this.addItem(item); });
}
}
TabbedLayout.prototype.setAfterAttachedParams = function (params) {
this.afterAttachedParams = params;
};
TabbedLayout.prototype.getMinWidth = function () {
var eDummyContainer = document.createElement('span');
// position fixed, so it isn't restricted to the boundaries of the parent
eDummyContainer.style.position = 'fixed';
// we put the dummy into the body container, so it will inherit all the
// css styles that the real cells are inheriting
this.eGui.appendChild(eDummyContainer);
var minWidth = 0;
this.items.forEach(function (itemWrapper) {
utils_1.Utils.removeAllChildren(eDummyContainer);
var eClone = itemWrapper.tabbedItem.body.cloneNode(true);
eDummyContainer.appendChild(eClone);
if (minWidth < eDummyContainer.offsetWidth) {
minWidth = eDummyContainer.offsetWidth;
}
});
this.eGui.removeChild(eDummyContainer);
return minWidth;
};
TabbedLayout.prototype.showFirstItem = function () {
if (this.items.length > 0) {
this.showItemWrapper(this.items[0]);
}
};
TabbedLayout.prototype.addItem = function (item) {
var eHeaderButton = document.createElement('span');
eHeaderButton.appendChild(item.title);
utils_1.Utils.addCssClass(eHeaderButton, 'ag-tab');
this.eHeader.appendChild(eHeaderButton);
var wrapper = {
tabbedItem: item,
eHeaderButton: eHeaderButton
};
this.items.push(wrapper);
eHeaderButton.addEventListener('click', this.showItemWrapper.bind(this, wrapper));
};
TabbedLayout.prototype.showItem = function (tabbedItem) {
var itemWrapper = utils_1.Utils.find(this.items, function (itemWrapper) {
return itemWrapper.tabbedItem === tabbedItem;
});
if (itemWrapper) {
this.showItemWrapper(itemWrapper);
}
};
TabbedLayout.prototype.showItemWrapper = function (wrapper) {
if (this.params.onItemClicked) {
this.params.onItemClicked({ item: wrapper.tabbedItem });
}
if (this.activeItem === wrapper) {
utils_1.Utils.callIfPresent(this.params.onActiveItemClicked);
return;
}
utils_1.Utils.removeAllChildren(this.eBody);
this.eBody.appendChild(wrapper.tabbedItem.body);
if (this.activeItem) {
utils_1.Utils.removeCssClass(this.activeItem.eHeaderButton, 'ag-tab-selected');
}
utils_1.Utils.addCssClass(wrapper.eHeaderButton, 'ag-tab-selected');
this.activeItem = wrapper;
if (wrapper.tabbedItem.afterAttachedCallback) {
wrapper.tabbedItem.afterAttachedCallback(this.afterAttachedParams);
}
};
TabbedLayout.prototype.getGui = function () {
return this.eGui;
};
TabbedLayout.TEMPLATE = '
' +
'' +
'' +
'
';
return TabbedLayout;
})();
exports.TabbedLayout = TabbedLayout;
/***/ },
/* 73 */
/***/ function(module, exports) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var VerticalStack = (function () {
function VerticalStack() {
this.isLayoutPanel = true;
this.childPanels = [];
this.eGui = document.createElement('div');
this.eGui.style.height = '100%';
}
VerticalStack.prototype.addPanel = function (panel, height) {
var component;
if (panel.isLayoutPanel) {
this.childPanels.push(panel);
component = panel.getGui();
}
else {
component = panel;
}
if (height) {
component.style.height = height;
}
this.eGui.appendChild(component);
};
VerticalStack.prototype.getGui = function () {
return this.eGui;
};
VerticalStack.prototype.doLayout = function () {
for (var i = 0; i < this.childPanels.length; i++) {
this.childPanels[i].doLayout();
}
};
return VerticalStack;
})();
exports.VerticalStack = VerticalStack;
/***/ },
/* 74 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __extends = (this && this.__extends) || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var component_1 = __webpack_require__(45);
var context_1 = __webpack_require__(6);
var popupService_1 = __webpack_require__(41);
var utils_1 = __webpack_require__(7);
var svgFactory_1 = __webpack_require__(36);
var svgFactory = svgFactory_1.SvgFactory.getInstance();
var CMenuItem = (function (_super) {
__extends(CMenuItem, _super);
function CMenuItem(params) {
_super.call(this, CMenuItem.TEMPLATE);
this.params = params;
if (params.checked) {
this.queryForHtmlElement('#eIcon').innerHTML = '✔';
}
else if (params.icon) {
if (utils_1.Utils.isNodeOrElement(params.icon)) {
this.queryForHtmlElement('#eIcon').appendChild(params.icon);
}
else if (typeof params.icon === 'string') {
this.queryForHtmlElement('#eIcon').innerHTML = params.icon;
}
else {
console.log('ag-Grid: menu item icon must be DOM node or string');
}
}
else {
// if i didn't put space here, the alignment was messed up, probably
// fixable with CSS but i was spending to much time trying to figure
// it out.
this.queryForHtmlElement('#eIcon').innerHTML = ' ';
}
if (params.shortcut) {
this.queryForHtmlElement('#eShortcut').innerHTML = params.shortcut;
}
if (params.childMenu) {
this.queryForHtmlElement('#ePopupPointer').appendChild(svgFactory.createSmallArrowRightSvg());
}
else {
this.queryForHtmlElement('#ePopupPointer').innerHTML = ' ';
}
this.queryForHtmlElement('#eName').innerHTML = params.name;
if (params.disabled) {
utils_1.Utils.addCssClass(this.getGui(), 'ag-menu-option-disabled');
}
this.addGuiEventListener('click', this.onOptionSelected.bind(this));
}
CMenuItem.prototype.onOptionSelected = function () {
this.dispatchEvent(CMenuItem.EVENT_ITEM_SELECTED, this.params);
if (this.params.action) {
this.params.action();
}
};
CMenuItem.TEMPLATE = '
' +
' ' +
' ' +
' ' +
' ' +
'
';
CMenuItem.EVENT_ITEM_SELECTED = 'itemSelected';
__decorate([
context_1.Autowired('popupService'),
__metadata('design:type', popupService_1.PopupService)
], CMenuItem.prototype, "popupService", void 0);
return CMenuItem;
})(component_1.Component);
exports.CMenuItem = CMenuItem;
/***/ },
/* 75 */
/***/ function(module, exports, __webpack_require__) {
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v4.0.4
* @link http://www.ag-grid.com/
* @license MIT
*/
var __extends = (this && this.__extends) || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var component_1 = __webpack_require__(45);
var utils_1 = __webpack_require__(7);
var context_1 = __webpack_require__(6);
var context_2 = __webpack_require__(6);
var popupService_1 = __webpack_require__(41);
var cMenuItem_1 = __webpack_require__(74);
var MenuList = (function (_super) {
__extends(MenuList, _super);
function MenuList() {
_super.call(this, MenuList.TEMPLATE);
this.timerCount = 0;
}
MenuList.prototype.clearActiveItem = function () {
this.removeActiveItem();
this.removeOldChildPopup();
};
MenuList.prototype.addMenuItems = function (menuItems, defaultMenuItems) {
var _this = this;
if (utils_1.Utils.missing(menuItems)) {
return;
}
menuItems.forEach(function (listItem) {
if (listItem === 'separator') {
_this.addSeparator();
}
else {
var menuItem;
if (typeof listItem === 'string') {
menuItem = defaultMenuItems[listItem];
}
else {
menuItem = listItem;
}
_this.addItem(menuItem);
}
});
};
MenuList.prototype.addItem = function (params) {
var _this = this;
var cMenuItem = new cMenuItem_1.CMenuItem(params);
this.context.wireBean(cMenuItem);
this.getGui().appendChild(cMenuItem.getGui());
cMenuItem.addEventListener(cMenuItem_1.CMenuItem.EVENT_ITEM_SELECTED, function (event) {
if (params.childMenu) {
_this.showChildMenu(params, cMenuItem);
}
else {
_this.dispatchEvent(cMenuItem_1.CMenuItem.EVENT_ITEM_SELECTED, event);
}
});
cMenuItem.addGuiEventListener('mouseenter', this.mouseEnterItem.bind(this, params, cMenuItem));
cMenuItem.addGuiEventListener('mouseleave', function () { return _this.timerCount++; });
if (params.childMenu) {
this.addDestroyFunc(function () { return params.childMenu.destroy(); });
}
};
MenuList.prototype.mouseEnterItem = function (menuItemParams, menuItem) {
if (menuItemParams.disabled) {
return;
}
if (this.activeMenuItemParams !== menuItemParams) {
this.removeOldChildPopup();
}
this.removeActiveItem();
this.activeMenuItemParams = menuItemParams;
this.activeMenuItem = menuItem;
utils_1.Utils.addCssClass(this.activeMenuItem.getGui(), 'ag-menu-option-active');
if (menuItemParams.childMenu) {
this.addHoverForChildPopup(menuItemParams, menuItem);
}
};
MenuList.prototype.removeActiveItem = function () {
if (this.activeMenuItem) {
utils_1.Utils.removeCssClass(this.activeMenuItem.getGui(), 'ag-menu-option-active');
this.activeMenuItem = null;
this.activeMenuItemParams = null;
}
};
MenuList.prototype.addHoverForChildPopup = function (menuItemParams, menuItem) {
var _this = this;
var timerCountCopy = this.timerCount;
setTimeout(function () {
var shouldShow = timerCountCopy === _this.timerCount;
var showingThisMenu = _this.showingChildMenu === menuItemParams.childMenu;
if (shouldShow && !showingThisMenu) {
_this.showChildMenu(menuItemParams, menuItem);
}
}, 500);
};
MenuList.prototype.showChildMenu = function (menuItemParams, menuItem) {
this.removeOldChildPopup();
var ePopup = utils_1.Utils.loadTemplate('');
ePopup.appendChild(menuItemParams.childMenu.getGui());
this.childPopupRemoveFunc = this.popupService.addAsModalPopup(ePopup, true);
this.popupService.positionPopupForMenu({
eventSource: menuItem.getGui(),
ePopup: ePopup
});
this.showingChildMenu = menuItemParams.childMenu;
};
MenuList.prototype.addSeparator = function () {
this.getGui().appendChild(utils_1.Utils.loadTemplate(MenuList.SEPARATOR_TEMPLATE));
};
MenuList.prototype.removeOldChildPopup = function () {
if (this.childPopupRemoveFunc) {
this.showingChildMenu.clearActiveItem();
this.childPopupRemoveFunc();
this.childPopupRemoveFunc = null;
this.showingChildMenu = null;
}
};
MenuList.prototype.destroy = function () {
this.removeOldChildPopup();
_super.prototype.destroy.call(this);
};
MenuList.TEMPLATE = '';
MenuList.SEPARATOR_TEMPLATE = '
' +
' ' +
' ' +
' ' +
' ' +
'
';
__decorate([
context_1.Autowired('context'),
__metadata('design:type', context_2.Context)
], MenuList.prototype, "context", void 0);
__decorate([
context_1.Autowired('popupService'),
__metadata('design:type', popupService_1.PopupService)
], MenuList.prototype, "popupService", void 0);
return MenuList;
})(component_1.Component);
exports.MenuList = MenuList;
/***/ },
/* 76 */
/***/ function(module, exports, __webpack_require__) {
// style-loader: Adds some css to the DOM by adding a