From f5b2d0efba23b1c1063103e02257cfded900d194 Mon Sep 17 00:00:00 2001 From: Thierry Parmentelat Date: Fri, 29 Nov 2013 18:13:36 +0100 Subject: [PATCH] slickgrid added to third-party --- third-party/slickgrid-2.1/MIT-LICENSE.txt | 20 + third-party/slickgrid-2.1/README.md | 22 + third-party/slickgrid-2.1/README.myslice | 2 + .../plugins/slick.autotooltips.js | 83 + .../plugins/slick.cellcopymanager.js | 86 + .../plugins/slick.cellrangedecorator.js | 64 + .../plugins/slick.cellrangeselector.js | 113 + .../plugins/slick.cellselectionmodel.js | 154 + .../plugins/slick.checkboxselectcolumn.js | 153 + .../plugins/slick.headerbuttons.css | 39 + .../plugins/slick.headerbuttons.js | 177 + .../plugins/slick.headermenu.css | 59 + .../slickgrid-2.1/plugins/slick.headermenu.js | 275 ++ .../plugins/slick.rowmovemanager.js | 138 + .../plugins/slick.rowselectionmodel.js | 187 + third-party/slickgrid-2.1/slick.core.js | 458 +++ third-party/slickgrid-2.1/slick.dataview.js | 1063 ++++++ third-party/slickgrid-2.1/slick.editors.js | 512 +++ third-party/slickgrid-2.1/slick.formatters.js | 59 + third-party/slickgrid-2.1/slick.grid.css | 157 + third-party/slickgrid-2.1/slick.grid.js | 3309 +++++++++++++++++ .../slick.groupitemmetadataprovider.js | 144 + .../slickgrid-2.1/slick.remotemodel.js | 173 + 23 files changed, 7447 insertions(+) create mode 100644 third-party/slickgrid-2.1/MIT-LICENSE.txt create mode 100644 third-party/slickgrid-2.1/README.md create mode 100644 third-party/slickgrid-2.1/README.myslice create mode 100644 third-party/slickgrid-2.1/plugins/slick.autotooltips.js create mode 100644 third-party/slickgrid-2.1/plugins/slick.cellcopymanager.js create mode 100644 third-party/slickgrid-2.1/plugins/slick.cellrangedecorator.js create mode 100644 third-party/slickgrid-2.1/plugins/slick.cellrangeselector.js create mode 100644 third-party/slickgrid-2.1/plugins/slick.cellselectionmodel.js create mode 100644 third-party/slickgrid-2.1/plugins/slick.checkboxselectcolumn.js create mode 100644 third-party/slickgrid-2.1/plugins/slick.headerbuttons.css create mode 100644 third-party/slickgrid-2.1/plugins/slick.headerbuttons.js create mode 100644 third-party/slickgrid-2.1/plugins/slick.headermenu.css create mode 100644 third-party/slickgrid-2.1/plugins/slick.headermenu.js create mode 100644 third-party/slickgrid-2.1/plugins/slick.rowmovemanager.js create mode 100644 third-party/slickgrid-2.1/plugins/slick.rowselectionmodel.js create mode 100644 third-party/slickgrid-2.1/slick.core.js create mode 100644 third-party/slickgrid-2.1/slick.dataview.js create mode 100644 third-party/slickgrid-2.1/slick.editors.js create mode 100644 third-party/slickgrid-2.1/slick.formatters.js create mode 100644 third-party/slickgrid-2.1/slick.grid.css create mode 100644 third-party/slickgrid-2.1/slick.grid.js create mode 100644 third-party/slickgrid-2.1/slick.groupitemmetadataprovider.js create mode 100644 third-party/slickgrid-2.1/slick.remotemodel.js diff --git a/third-party/slickgrid-2.1/MIT-LICENSE.txt b/third-party/slickgrid-2.1/MIT-LICENSE.txt new file mode 100644 index 00000000..60f65425 --- /dev/null +++ b/third-party/slickgrid-2.1/MIT-LICENSE.txt @@ -0,0 +1,20 @@ +Copyright (c) 2010 Michael Leibman, http://github.com/mleibman/slickgrid + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file diff --git a/third-party/slickgrid-2.1/README.md b/third-party/slickgrid-2.1/README.md new file mode 100644 index 00000000..7994a271 --- /dev/null +++ b/third-party/slickgrid-2.1/README.md @@ -0,0 +1,22 @@ +# Welcome to SlickGrid + +Find documentation and examples in [the wiki](https://github.com/mleibman/SlickGrid/wiki). + +## SlickGrid is an advanced JavaScript grid/spreadsheet component + +Some highlights: + +* Adaptive virtual scrolling (handle hundreds of thousands of rows with extreme responsiveness) +* Extremely fast rendering speed +* Supports jQuery UI Themes +* Background post-rendering for richer cells +* Configurable & customizable +* Full keyboard navigation +* Column resize/reorder/show/hide +* Column autosizing & force-fit +* Pluggable cell formatters & editors +* Support for editing and creating new rows. +* Grouping, filtering, custom aggregators, and more! +* Advanced detached & multi-field editors with undo/redo support. +* “GlobalEditorLock” to manage concurrent edits in cases where multiple Views on a page can edit the same data. +* Support for [millions of rows](http://stackoverflow.com/a/2569488/1269037) diff --git a/third-party/slickgrid-2.1/README.myslice b/third-party/slickgrid-2.1/README.myslice new file mode 100644 index 00000000..cd466031 --- /dev/null +++ b/third-party/slickgrid-2.1/README.myslice @@ -0,0 +1,2 @@ +I'm adding parts of the slickgrid download manually +so as to avoid any conflicts with the rest of our third-party stuff diff --git a/third-party/slickgrid-2.1/plugins/slick.autotooltips.js b/third-party/slickgrid-2.1/plugins/slick.autotooltips.js new file mode 100644 index 00000000..955684f2 --- /dev/null +++ b/third-party/slickgrid-2.1/plugins/slick.autotooltips.js @@ -0,0 +1,83 @@ +(function ($) { + // Register namespace + $.extend(true, window, { + "Slick": { + "AutoTooltips": AutoTooltips + } + }); + + /** + * AutoTooltips plugin to show/hide tooltips when columns are too narrow to fit content. + * @constructor + * @param {boolean} [options.enableForCells=true] - Enable tooltip for grid cells + * @param {boolean} [options.enableForHeaderCells=false] - Enable tooltip for header cells + * @param {number} [options.maxToolTipLength=null] - The maximum length for a tooltip + */ + function AutoTooltips(options) { + var _grid; + var _self = this; + var _defaults = { + enableForCells: true, + enableForHeaderCells: false, + maxToolTipLength: null + }; + + /** + * Initialize plugin. + */ + function init(grid) { + options = $.extend(true, {}, _defaults, options); + _grid = grid; + if (options.enableForCells) _grid.onMouseEnter.subscribe(handleMouseEnter); + if (options.enableForHeaderCells) _grid.onHeaderMouseEnter.subscribe(handleHeaderMouseEnter); + } + + /** + * Destroy plugin. + */ + function destroy() { + if (options.enableForCells) _grid.onMouseEnter.unsubscribe(handleMouseEnter); + if (options.enableForHeaderCells) _grid.onHeaderMouseEnter.unsubscribe(handleHeaderMouseEnter); + } + + /** + * Handle mouse entering grid cell to add/remove tooltip. + * @param {jQuery.Event} e - The event + */ + function handleMouseEnter(e) { + var cell = _grid.getCellFromEvent(e); + if (cell) { + var $node = $(_grid.getCellNode(cell.row, cell.cell)); + var text; + if ($node.innerWidth() < $node[0].scrollWidth) { + text = $.trim($node.text()); + if (options.maxToolTipLength && text.length > options.maxToolTipLength) { + text = text.substr(0, options.maxToolTipLength - 3) + "..."; + } + } else { + text = ""; + } + $node.attr("title", text); + } + } + + /** + * Handle mouse entering header cell to add/remove tooltip. + * @param {jQuery.Event} e - The event + * @param {object} args.column - The column definition + */ + function handleHeaderMouseEnter(e, args) { + var column = args.column, + $node = $(e.target).closest(".slick-header-column"); + if (!column.toolTip) { + $node.attr("title", ($node.innerWidth() < $node[0].scrollWidth) ? column.name : ""); + } + } + + // Public API + $.extend(this, { + "init": init, + "destroy": destroy + }); + } +})(jQuery); \ No newline at end of file diff --git a/third-party/slickgrid-2.1/plugins/slick.cellcopymanager.js b/third-party/slickgrid-2.1/plugins/slick.cellcopymanager.js new file mode 100644 index 00000000..c74018de --- /dev/null +++ b/third-party/slickgrid-2.1/plugins/slick.cellcopymanager.js @@ -0,0 +1,86 @@ +(function ($) { + // register namespace + $.extend(true, window, { + "Slick": { + "CellCopyManager": CellCopyManager + } + }); + + + function CellCopyManager() { + var _grid; + var _self = this; + var _copiedRanges; + + function init(grid) { + _grid = grid; + _grid.onKeyDown.subscribe(handleKeyDown); + } + + function destroy() { + _grid.onKeyDown.unsubscribe(handleKeyDown); + } + + function handleKeyDown(e, args) { + var ranges; + if (!_grid.getEditorLock().isActive()) { + if (e.which == $.ui.keyCode.ESCAPE) { + if (_copiedRanges) { + e.preventDefault(); + clearCopySelection(); + _self.onCopyCancelled.notify({ranges: _copiedRanges}); + _copiedRanges = null; + } + } + + if (e.which == 67 && (e.ctrlKey || e.metaKey)) { + ranges = _grid.getSelectionModel().getSelectedRanges(); + if (ranges.length != 0) { + e.preventDefault(); + _copiedRanges = ranges; + markCopySelection(ranges); + _self.onCopyCells.notify({ranges: ranges}); + } + } + + if (e.which == 86 && (e.ctrlKey || e.metaKey)) { + if (_copiedRanges) { + e.preventDefault(); + clearCopySelection(); + ranges = _grid.getSelectionModel().getSelectedRanges(); + _self.onPasteCells.notify({from: _copiedRanges, to: ranges}); + _copiedRanges = null; + } + } + } + } + + function markCopySelection(ranges) { + var columns = _grid.getColumns(); + var hash = {}; + for (var i = 0; i < ranges.length; i++) { + for (var j = ranges[i].fromRow; j <= ranges[i].toRow; j++) { + hash[j] = {}; + for (var k = ranges[i].fromCell; k <= ranges[i].toCell; k++) { + hash[j][columns[k].id] = "copied"; + } + } + } + _grid.setCellCssStyles("copy-manager", hash); + } + + function clearCopySelection() { + _grid.removeCellCssStyles("copy-manager"); + } + + $.extend(this, { + "init": init, + "destroy": destroy, + "clearCopySelection": clearCopySelection, + + "onCopyCells": new Slick.Event(), + "onCopyCancelled": new Slick.Event(), + "onPasteCells": new Slick.Event() + }); + } +})(jQuery); \ No newline at end of file diff --git a/third-party/slickgrid-2.1/plugins/slick.cellrangedecorator.js b/third-party/slickgrid-2.1/plugins/slick.cellrangedecorator.js new file mode 100644 index 00000000..a511a59d --- /dev/null +++ b/third-party/slickgrid-2.1/plugins/slick.cellrangedecorator.js @@ -0,0 +1,64 @@ +(function ($) { + // register namespace + $.extend(true, window, { + "Slick": { + "CellRangeDecorator": CellRangeDecorator + } + }); + + /*** + * Displays an overlay on top of a given cell range. + * + * TODO: + * Currently, it blocks mouse events to DOM nodes behind it. + * Use FF and WebKit-specific "pointer-events" CSS style, or some kind of event forwarding. + * Could also construct the borders separately using 4 individual DIVs. + * + * @param {Grid} grid + * @param {Object} options + */ + function CellRangeDecorator(grid, options) { + var _elem; + var _defaults = { + selectionCss: { + "zIndex": "9999", + "border": "2px dashed red" + } + }; + + options = $.extend(true, {}, _defaults, options); + + + function show(range) { + if (!_elem) { + _elem = $("
", {css: options.selectionCss}) + .css("position", "absolute") + .appendTo(grid.getCanvasNode()); + } + + var from = grid.getCellNodeBox(range.fromRow, range.fromCell); + var to = grid.getCellNodeBox(range.toRow, range.toCell); + + _elem.css({ + top: from.top - 1, + left: from.left - 1, + height: to.bottom - from.top - 2, + width: to.right - from.left - 2 + }); + + return _elem; + } + + function hide() { + if (_elem) { + _elem.remove(); + _elem = null; + } + } + + $.extend(this, { + "show": show, + "hide": hide + }); + } +})(jQuery); \ No newline at end of file diff --git a/third-party/slickgrid-2.1/plugins/slick.cellrangeselector.js b/third-party/slickgrid-2.1/plugins/slick.cellrangeselector.js new file mode 100644 index 00000000..520b17f3 --- /dev/null +++ b/third-party/slickgrid-2.1/plugins/slick.cellrangeselector.js @@ -0,0 +1,113 @@ +(function ($) { + // register namespace + $.extend(true, window, { + "Slick": { + "CellRangeSelector": CellRangeSelector + } + }); + + + function CellRangeSelector(options) { + var _grid; + var _canvas; + var _dragging; + var _decorator; + var _self = this; + var _handler = new Slick.EventHandler(); + var _defaults = { + selectionCss: { + "border": "2px dashed blue" + } + }; + + + function init(grid) { + options = $.extend(true, {}, _defaults, options); + _decorator = new Slick.CellRangeDecorator(grid, options); + _grid = grid; + _canvas = _grid.getCanvasNode(); + _handler + .subscribe(_grid.onDragInit, handleDragInit) + .subscribe(_grid.onDragStart, handleDragStart) + .subscribe(_grid.onDrag, handleDrag) + .subscribe(_grid.onDragEnd, handleDragEnd); + } + + function destroy() { + _handler.unsubscribeAll(); + } + + function handleDragInit(e, dd) { + // prevent the grid from cancelling drag'n'drop by default + e.stopImmediatePropagation(); + } + + function handleDragStart(e, dd) { + var cell = _grid.getCellFromEvent(e); + if (_self.onBeforeCellRangeSelected.notify(cell) !== false) { + if (_grid.canCellBeSelected(cell.row, cell.cell)) { + _dragging = true; + e.stopImmediatePropagation(); + } + } + if (!_dragging) { + return; + } + + _grid.focus(); + + var start = _grid.getCellFromPoint( + dd.startX - $(_canvas).offset().left, + dd.startY - $(_canvas).offset().top); + + dd.range = {start: start, end: {}}; + + return _decorator.show(new Slick.Range(start.row, start.cell)); + } + + function handleDrag(e, dd) { + if (!_dragging) { + return; + } + e.stopImmediatePropagation(); + + var end = _grid.getCellFromPoint( + e.pageX - $(_canvas).offset().left, + e.pageY - $(_canvas).offset().top); + + if (!_grid.canCellBeSelected(end.row, end.cell)) { + return; + } + + dd.range.end = end; + _decorator.show(new Slick.Range(dd.range.start.row, dd.range.start.cell, end.row, end.cell)); + } + + function handleDragEnd(e, dd) { + if (!_dragging) { + return; + } + + _dragging = false; + e.stopImmediatePropagation(); + + _decorator.hide(); + _self.onCellRangeSelected.notify({ + range: new Slick.Range( + dd.range.start.row, + dd.range.start.cell, + dd.range.end.row, + dd.range.end.cell + ) + }); + } + + $.extend(this, { + "init": init, + "destroy": destroy, + + "onBeforeCellRangeSelected": new Slick.Event(), + "onCellRangeSelected": new Slick.Event() + }); + } +})(jQuery); \ No newline at end of file diff --git a/third-party/slickgrid-2.1/plugins/slick.cellselectionmodel.js b/third-party/slickgrid-2.1/plugins/slick.cellselectionmodel.js new file mode 100644 index 00000000..74bc3eb7 --- /dev/null +++ b/third-party/slickgrid-2.1/plugins/slick.cellselectionmodel.js @@ -0,0 +1,154 @@ +(function ($) { + // register namespace + $.extend(true, window, { + "Slick": { + "CellSelectionModel": CellSelectionModel + } + }); + + + function CellSelectionModel(options) { + var _grid; + var _canvas; + var _ranges = []; + var _self = this; + var _selector = new Slick.CellRangeSelector({ + "selectionCss": { + "border": "2px solid black" + } + }); + var _options; + var _defaults = { + selectActiveCell: true + }; + + + function init(grid) { + _options = $.extend(true, {}, _defaults, options); + _grid = grid; + _canvas = _grid.getCanvasNode(); + _grid.onActiveCellChanged.subscribe(handleActiveCellChange); + _grid.onKeyDown.subscribe(handleKeyDown); + grid.registerPlugin(_selector); + _selector.onCellRangeSelected.subscribe(handleCellRangeSelected); + _selector.onBeforeCellRangeSelected.subscribe(handleBeforeCellRangeSelected); + } + + function destroy() { + _grid.onActiveCellChanged.unsubscribe(handleActiveCellChange); + _grid.onKeyDown.unsubscribe(handleKeyDown); + _selector.onCellRangeSelected.unsubscribe(handleCellRangeSelected); + _selector.onBeforeCellRangeSelected.unsubscribe(handleBeforeCellRangeSelected); + _grid.unregisterPlugin(_selector); + } + + function removeInvalidRanges(ranges) { + var result = []; + + for (var i = 0; i < ranges.length; i++) { + var r = ranges[i]; + if (_grid.canCellBeSelected(r.fromRow, r.fromCell) && _grid.canCellBeSelected(r.toRow, r.toCell)) { + result.push(r); + } + } + + return result; + } + + function setSelectedRanges(ranges) { + _ranges = removeInvalidRanges(ranges); + _self.onSelectedRangesChanged.notify(_ranges); + } + + function getSelectedRanges() { + return _ranges; + } + + function handleBeforeCellRangeSelected(e, args) { + if (_grid.getEditorLock().isActive()) { + e.stopPropagation(); + return false; + } + } + + function handleCellRangeSelected(e, args) { + setSelectedRanges([args.range]); + } + + function handleActiveCellChange(e, args) { + if (_options.selectActiveCell && args.row != null && args.cell != null) { + setSelectedRanges([new Slick.Range(args.row, args.cell)]); + } + } + + function handleKeyDown(e) { + /*** + * Кey codes + * 37 left + * 38 up + * 39 right + * 40 down + */ + var ranges, last; + var active = _grid.getActiveCell(); + + if ( active && e.shiftKey && !e.ctrlKey && !e.altKey && + (e.which == 37 || e.which == 39 || e.which == 38 || e.which == 40) ) { + + ranges = getSelectedRanges(); + if (!ranges.length) + ranges.push(new Slick.Range(active.row, active.cell)); + + // keyboard can work with last range only + last = ranges.pop(); + + // can't handle selection out of active cell + if (!last.contains(active.row, active.cell)) + last = new Slick.Range(active.row, active.cell); + + var dRow = last.toRow - last.fromRow, + dCell = last.toCell - last.fromCell, + // walking direction + dirRow = active.row == last.fromRow ? 1 : -1, + dirCell = active.cell == last.fromCell ? 1 : -1; + + if (e.which == 37) { + dCell -= dirCell; + } else if (e.which == 39) { + dCell += dirCell ; + } else if (e.which == 38) { + dRow -= dirRow; + } else if (e.which == 40) { + dRow += dirRow; + } + + // define new selection range + var new_last = new Slick.Range(active.row, active.cell, active.row + dirRow*dRow, active.cell + dirCell*dCell); + if (removeInvalidRanges([new_last]).length) { + ranges.push(new_last); + var viewRow = dirRow > 0 ? new_last.toRow : new_last.fromRow; + var viewCell = dirCell > 0 ? new_last.toCell : new_last.fromCell; + _grid.scrollRowIntoView(viewRow); + _grid.scrollCellIntoView(viewRow, viewCell); + } + else + ranges.push(last); + + setSelectedRanges(ranges); + + e.preventDefault(); + e.stopPropagation(); + } + } + + $.extend(this, { + "getSelectedRanges": getSelectedRanges, + "setSelectedRanges": setSelectedRanges, + + "init": init, + "destroy": destroy, + + "onSelectedRangesChanged": new Slick.Event() + }); + } +})(jQuery); diff --git a/third-party/slickgrid-2.1/plugins/slick.checkboxselectcolumn.js b/third-party/slickgrid-2.1/plugins/slick.checkboxselectcolumn.js new file mode 100644 index 00000000..83d8d500 --- /dev/null +++ b/third-party/slickgrid-2.1/plugins/slick.checkboxselectcolumn.js @@ -0,0 +1,153 @@ +(function ($) { + // register namespace + $.extend(true, window, { + "Slick": { + "CheckboxSelectColumn": CheckboxSelectColumn + } + }); + + + function CheckboxSelectColumn(options) { + var _grid; + var _self = this; + var _handler = new Slick.EventHandler(); + var _selectedRowsLookup = {}; + var _defaults = { + columnId: "_checkbox_selector", + cssClass: null, + toolTip: "Select/Deselect All", + width: 30 + }; + + var _options = $.extend(true, {}, _defaults, options); + + function init(grid) { + _grid = grid; + _handler + .subscribe(_grid.onSelectedRowsChanged, handleSelectedRowsChanged) + .subscribe(_grid.onClick, handleClick) + .subscribe(_grid.onHeaderClick, handleHeaderClick) + .subscribe(_grid.onKeyDown, handleKeyDown); + } + + function destroy() { + _handler.unsubscribeAll(); + } + + function handleSelectedRowsChanged(e, args) { + var selectedRows = _grid.getSelectedRows(); + var lookup = {}, row, i; + for (i = 0; i < selectedRows.length; i++) { + row = selectedRows[i]; + lookup[row] = true; + if (lookup[row] !== _selectedRowsLookup[row]) { + _grid.invalidateRow(row); + delete _selectedRowsLookup[row]; + } + } + for (i in _selectedRowsLookup) { + _grid.invalidateRow(i); + } + _selectedRowsLookup = lookup; + _grid.render(); + + if (selectedRows.length && selectedRows.length == _grid.getDataLength()) { + _grid.updateColumnHeader(_options.columnId, "", _options.toolTip); + } else { + _grid.updateColumnHeader(_options.columnId, "", _options.toolTip); + } + } + + function handleKeyDown(e, args) { + if (e.which == 32) { + if (_grid.getColumns()[args.cell].id === _options.columnId) { + // if editing, try to commit + if (!_grid.getEditorLock().isActive() || _grid.getEditorLock().commitCurrentEdit()) { + toggleRowSelection(args.row); + } + e.preventDefault(); + e.stopImmediatePropagation(); + } + } + } + + function handleClick(e, args) { + // clicking on a row select checkbox + if (_grid.getColumns()[args.cell].id === _options.columnId && $(e.target).is(":checkbox")) { + // if editing, try to commit + if (_grid.getEditorLock().isActive() && !_grid.getEditorLock().commitCurrentEdit()) { + e.preventDefault(); + e.stopImmediatePropagation(); + return; + } + + toggleRowSelection(args.row); + e.stopPropagation(); + e.stopImmediatePropagation(); + } + } + + function toggleRowSelection(row) { + if (_selectedRowsLookup[row]) { + _grid.setSelectedRows($.grep(_grid.getSelectedRows(), function (n) { + return n != row + })); + } else { + _grid.setSelectedRows(_grid.getSelectedRows().concat(row)); + } + } + + function handleHeaderClick(e, args) { + if (args.column.id == _options.columnId && $(e.target).is(":checkbox")) { + // if editing, try to commit + if (_grid.getEditorLock().isActive() && !_grid.getEditorLock().commitCurrentEdit()) { + e.preventDefault(); + e.stopImmediatePropagation(); + return; + } + + if ($(e.target).is(":checked")) { + var rows = []; + for (var i = 0; i < _grid.getDataLength(); i++) { + rows.push(i); + } + _grid.setSelectedRows(rows); + } else { + _grid.setSelectedRows([]); + } + e.stopPropagation(); + e.stopImmediatePropagation(); + } + } + + function getColumnDefinition() { + return { + id: _options.columnId, + name: "", + toolTip: _options.toolTip, + field: "sel", + width: _options.width, + resizable: false, + sortable: false, + cssClass: _options.cssClass, + formatter: checkboxSelectionFormatter + }; + } + + function checkboxSelectionFormatter(row, cell, value, columnDef, dataContext) { + if (dataContext) { + return _selectedRowsLookup[row] + ? "" + : ""; + } + return null; + } + + $.extend(this, { + "init": init, + "destroy": destroy, + + "getColumnDefinition": getColumnDefinition + }); + } +})(jQuery); \ No newline at end of file diff --git a/third-party/slickgrid-2.1/plugins/slick.headerbuttons.css b/third-party/slickgrid-2.1/plugins/slick.headerbuttons.css new file mode 100644 index 00000000..0ba79ea0 --- /dev/null +++ b/third-party/slickgrid-2.1/plugins/slick.headerbuttons.css @@ -0,0 +1,39 @@ +.slick-column-name, +.slick-sort-indicator { + /** + * This makes all "float:right" elements after it that spill over to the next line + * display way below the lower boundary of the column thus hiding them. + */ + display: inline-block; + float: left; + margin-bottom: 100px; +} + +.slick-header-button { + display: inline-block; + float: right; + vertical-align: top; + margin: 1px; + /** + * This makes all "float:right" elements after it that spill over to the next line + * display way below the lower boundary of the column thus hiding them. + */ + margin-bottom: 100px; + height: 15px; + width: 15px; + background-repeat: no-repeat; + background-position: center center; + cursor: pointer; +} + +.slick-header-button-hidden { + width: 0; + + -webkit-transition: 0.2s width; + -ms-transition: 0.2s width; + transition: 0.2s width; +} + +.slick-header-column:hover > .slick-header-button { + width: 15px; +} \ No newline at end of file diff --git a/third-party/slickgrid-2.1/plugins/slick.headerbuttons.js b/third-party/slickgrid-2.1/plugins/slick.headerbuttons.js new file mode 100644 index 00000000..8e612735 --- /dev/null +++ b/third-party/slickgrid-2.1/plugins/slick.headerbuttons.js @@ -0,0 +1,177 @@ +(function ($) { + // register namespace + $.extend(true, window, { + "Slick": { + "Plugins": { + "HeaderButtons": HeaderButtons + } + } + }); + + + /*** + * A plugin to add custom buttons to column headers. + * + * USAGE: + * + * Add the plugin .js & .css files and register it with the grid. + * + * To specify a custom button in a column header, extend the column definition like so: + * + * var columns = [ + * { + * id: 'myColumn', + * name: 'My column', + * + * // This is the relevant part + * header: { + * buttons: [ + * { + * // button options + * }, + * { + * // button options + * } + * ] + * } + * } + * ]; + * + * Available button options: + * cssClass: CSS class to add to the button. + * image: Relative button image path. + * tooltip: Button tooltip. + * showOnHover: Only show the button on hover. + * handler: Button click handler. + * command: A command identifier to be passed to the onCommand event handlers. + * + * The plugin exposes the following events: + * onCommand: Fired on button click for buttons with 'command' specified. + * Event args: + * grid: Reference to the grid. + * column: Column definition. + * command: Button command identified. + * button: Button options. Note that you can change the button options in your + * event handler, and the column header will be automatically updated to + * reflect them. This is useful if you want to implement something like a + * toggle button. + * + * + * @param options {Object} Options: + * buttonCssClass: a CSS class to use for buttons (default 'slick-header-button') + * @class Slick.Plugins.HeaderButtons + * @constructor + */ + function HeaderButtons(options) { + var _grid; + var _self = this; + var _handler = new Slick.EventHandler(); + var _defaults = { + buttonCssClass: "slick-header-button" + }; + + + function init(grid) { + options = $.extend(true, {}, _defaults, options); + _grid = grid; + _handler + .subscribe(_grid.onHeaderCellRendered, handleHeaderCellRendered) + .subscribe(_grid.onBeforeHeaderCellDestroy, handleBeforeHeaderCellDestroy); + + // Force the grid to re-render the header now that the events are hooked up. + _grid.setColumns(_grid.getColumns()); + } + + + function destroy() { + _handler.unsubscribeAll(); + } + + + function handleHeaderCellRendered(e, args) { + var column = args.column; + + if (column.header && column.header.buttons) { + // Append buttons in reverse order since they are floated to the right. + var i = column.header.buttons.length; + while (i--) { + var button = column.header.buttons[i]; + var btn = $("
") + .addClass(options.buttonCssClass) + .data("column", column) + .data("button", button); + + if (button.showOnHover) { + btn.addClass("slick-header-button-hidden"); + } + + if (button.image) { + btn.css("backgroundImage", "url(" + button.image + ")"); + } + + if (button.cssClass) { + btn.addClass(button.cssClass); + } + + if (button.tooltip) { + btn.attr("title", button.tooltip); + } + + if (button.command) { + btn.data("command", button.command); + } + + if (button.handler) { + btn.bind("click", button.handler); + } + + btn + .bind("click", handleButtonClick) + .appendTo(args.node); + } + } + } + + + function handleBeforeHeaderCellDestroy(e, args) { + var column = args.column; + + if (column.header && column.header.buttons) { + // Removing buttons via jQuery will also clean up any event handlers and data. + // NOTE: If you attach event handlers directly or using a different framework, + // you must also clean them up here to avoid memory leaks. + $(args.node).find("." + options.buttonCssClass).remove(); + } + } + + + function handleButtonClick(e) { + var command = $(this).data("command"); + var columnDef = $(this).data("column"); + var button = $(this).data("button"); + + if (command != null) { + _self.onCommand.notify({ + "grid": _grid, + "column": columnDef, + "command": command, + "button": button + }, e, _self); + + // Update the header in case the user updated the button definition in the handler. + _grid.updateColumnHeader(columnDef.id); + } + + // Stop propagation so that it doesn't register as a header click event. + e.preventDefault(); + e.stopPropagation(); + } + + $.extend(this, { + "init": init, + "destroy": destroy, + + "onCommand": new Slick.Event() + }); + } +})(jQuery); \ No newline at end of file diff --git a/third-party/slickgrid-2.1/plugins/slick.headermenu.css b/third-party/slickgrid-2.1/plugins/slick.headermenu.css new file mode 100644 index 00000000..8b0b6a9f --- /dev/null +++ b/third-party/slickgrid-2.1/plugins/slick.headermenu.css @@ -0,0 +1,59 @@ +/* Menu button */ +.slick-header-menubutton { + position: absolute; + right: 0; + top: 0; + bottom: 0; + width: 14px; + background-repeat: no-repeat; + background-position: left center; + background-image: url(../images/down.gif); + cursor: pointer; + + display: none; + border-left: thin ridge silver; +} + +.slick-header-column:hover > .slick-header-menubutton, +.slick-header-column-active .slick-header-menubutton { + display: inline-block; +} + +/* Menu */ +.slick-header-menu { + position: absolute; + display: inline-block; + margin: 0; + padding: 2px; + cursor: default; +} + + +/* Menu items */ +.slick-header-menuitem { + list-style: none; + margin: 0; + padding: 0; + cursor: pointer; +} + +.slick-header-menuicon { + display: inline-block; + width: 16px; + height: 16px; + vertical-align: middle; + margin-right: 4px; + background-repeat: no-repeat; + background-position: center center; +} + +.slick-header-menucontent { + display: inline-block; + vertical-align: middle; +} + + +/* Disabled */ +.slick-header-menuitem-disabled { + color: silver; +} diff --git a/third-party/slickgrid-2.1/plugins/slick.headermenu.js b/third-party/slickgrid-2.1/plugins/slick.headermenu.js new file mode 100644 index 00000000..ec8244da --- /dev/null +++ b/third-party/slickgrid-2.1/plugins/slick.headermenu.js @@ -0,0 +1,275 @@ +(function ($) { + // register namespace + $.extend(true, window, { + "Slick": { + "Plugins": { + "HeaderMenu": HeaderMenu + } + } + }); + + + /*** + * A plugin to add drop-down menus to column headers. + * + * USAGE: + * + * Add the plugin .js & .css files and register it with the grid. + * + * To specify a menu in a column header, extend the column definition like so: + * + * var columns = [ + * { + * id: 'myColumn', + * name: 'My column', + * + * // This is the relevant part + * header: { + * menu: { + * items: [ + * { + * // menu item options + * }, + * { + * // menu item options + * } + * ] + * } + * } + * } + * ]; + * + * + * Available menu options: + * tooltip: Menu button tooltip. + * + * + * Available menu item options: + * title: Menu item text. + * disabled: Whether the item is disabled. + * tooltip: Item tooltip. + * command: A command identifier to be passed to the onCommand event handlers. + * iconCssClass: A CSS class to be added to the menu item icon. + * iconImage: A url to the icon image. + * + * + * The plugin exposes the following events: + * onBeforeMenuShow: Fired before the menu is shown. You can customize the menu or dismiss it by returning false. + * Event args: + * grid: Reference to the grid. + * column: Column definition. + * menu: Menu options. Note that you can change the menu items here. + * + * onCommand: Fired on menu item click for buttons with 'command' specified. + * Event args: + * grid: Reference to the grid. + * column: Column definition. + * command: Button command identified. + * button: Button options. Note that you can change the button options in your + * event handler, and the column header will be automatically updated to + * reflect them. This is useful if you want to implement something like a + * toggle button. + * + * + * @param options {Object} Options: + * buttonCssClass: an extra CSS class to add to the menu button + * buttonImage: a url to the menu button image (default '../images/down.gif') + * @class Slick.Plugins.HeaderButtons + * @constructor + */ + function HeaderMenu(options) { + var _grid; + var _self = this; + var _handler = new Slick.EventHandler(); + var _defaults = { + buttonCssClass: null, + buttonImage: null + }; + var $menu; + var $activeHeaderColumn; + + + function init(grid) { + options = $.extend(true, {}, _defaults, options); + _grid = grid; + _handler + .subscribe(_grid.onHeaderCellRendered, handleHeaderCellRendered) + .subscribe(_grid.onBeforeHeaderCellDestroy, handleBeforeHeaderCellDestroy); + + // Force the grid to re-render the header now that the events are hooked up. + _grid.setColumns(_grid.getColumns()); + + // Hide the menu on outside click. + $(document.body).bind("mousedown", handleBodyMouseDown); + } + + + function destroy() { + _handler.unsubscribeAll(); + $(document.body).unbind("mousedown", handleBodyMouseDown); + } + + + function handleBodyMouseDown(e) { + if ($menu && $menu[0] != e.target && !$.contains($menu[0], e.target)) { + hideMenu(); + } + } + + + function hideMenu() { + if ($menu) { + $menu.remove(); + $menu = null; + $activeHeaderColumn + .removeClass("slick-header-column-active"); + } + } + + function handleHeaderCellRendered(e, args) { + var column = args.column; + var menu = column.header && column.header.menu; + + if (menu) { + var $el = $("
") + .addClass("slick-header-menubutton") + .data("column", column) + .data("menu", menu); + + if (options.buttonCssClass) { + $el.addClass(options.buttonCssClass); + } + + if (options.buttonImage) { + $el.css("background-image", "url(" + options.buttonImage + ")"); + } + + if (menu.tooltip) { + $el.attr("title", menu.tooltip); + } + + $el + .bind("click", showMenu) + .appendTo(args.node); + } + } + + + function handleBeforeHeaderCellDestroy(e, args) { + var column = args.column; + + if (column.header && column.header.menu) { + $(args.node).find(".slick-header-menubutton").remove(); + } + } + + + function showMenu(e) { + var $menuButton = $(this); + var menu = $menuButton.data("menu"); + var columnDef = $menuButton.data("column"); + + // Let the user modify the menu or cancel altogether, + // or provide alternative menu implementation. + if (_self.onBeforeMenuShow.notify({ + "grid": _grid, + "column": columnDef, + "menu": menu + }, e, _self) == false) { + return; + } + + + if (!$menu) { + $menu = $("
") + .appendTo(_grid.getContainerNode()); + } + $menu.empty(); + + + // Construct the menu items. + for (var i = 0; i < menu.items.length; i++) { + var item = menu.items[i]; + + var $li = $("
") + .data("command", item.command || '') + .data("column", columnDef) + .data("item", item) + .bind("click", handleMenuItemClick) + .appendTo($menu); + + if (item.disabled) { + $li.addClass("slick-header-menuitem-disabled"); + } + + if (item.tooltip) { + $li.attr("title", item.tooltip); + } + + var $icon = $("
") + .appendTo($li); + + if (item.iconCssClass) { + $icon.addClass(item.iconCssClass); + } + + if (item.iconImage) { + $icon.css("background-image", "url(" + item.iconImage + ")"); + } + + $("") + .text(item.title) + .appendTo($li); + } + + + // Position the menu. + $menu + .offset({ top: $(this).offset().top + $(this).height(), left: $(this).offset().left }); + + + // Mark the header as active to keep the highlighting. + $activeHeaderColumn = $menuButton.closest(".slick-header-column"); + $activeHeaderColumn + .addClass("slick-header-column-active"); + + // Stop propagation so that it doesn't register as a header click event. + e.preventDefault(); + e.stopPropagation(); + } + + + function handleMenuItemClick(e) { + var command = $(this).data("command"); + var columnDef = $(this).data("column"); + var item = $(this).data("item"); + + if (item.disabled) { + return; + } + + hideMenu(); + + if (command != null && command != '') { + _self.onCommand.notify({ + "grid": _grid, + "column": columnDef, + "command": command, + "item": item + }, e, _self); + } + + // Stop propagation so that it doesn't register as a header click event. + e.preventDefault(); + e.stopPropagation(); + } + + $.extend(this, { + "init": init, + "destroy": destroy, + + "onBeforeMenuShow": new Slick.Event(), + "onCommand": new Slick.Event() + }); + } +})(jQuery); diff --git a/third-party/slickgrid-2.1/plugins/slick.rowmovemanager.js b/third-party/slickgrid-2.1/plugins/slick.rowmovemanager.js new file mode 100644 index 00000000..5f87a1ed --- /dev/null +++ b/third-party/slickgrid-2.1/plugins/slick.rowmovemanager.js @@ -0,0 +1,138 @@ +(function ($) { + // register namespace + $.extend(true, window, { + "Slick": { + "RowMoveManager": RowMoveManager + } + }); + + function RowMoveManager(options) { + var _grid; + var _canvas; + var _dragging; + var _self = this; + var _handler = new Slick.EventHandler(); + var _defaults = { + cancelEditOnDrag: false + }; + + function init(grid) { + options = $.extend(true, {}, _defaults, options); + _grid = grid; + _canvas = _grid.getCanvasNode(); + _handler + .subscribe(_grid.onDragInit, handleDragInit) + .subscribe(_grid.onDragStart, handleDragStart) + .subscribe(_grid.onDrag, handleDrag) + .subscribe(_grid.onDragEnd, handleDragEnd); + } + + function destroy() { + _handler.unsubscribeAll(); + } + + function handleDragInit(e, dd) { + // prevent the grid from cancelling drag'n'drop by default + e.stopImmediatePropagation(); + } + + function handleDragStart(e, dd) { + var cell = _grid.getCellFromEvent(e); + + if (options.cancelEditOnDrag && _grid.getEditorLock().isActive()) { + _grid.getEditorLock().cancelCurrentEdit(); + } + + if (_grid.getEditorLock().isActive() || !/move|selectAndMove/.test(_grid.getColumns()[cell.cell].behavior)) { + return false; + } + + _dragging = true; + e.stopImmediatePropagation(); + + var selectedRows = _grid.getSelectedRows(); + + if (selectedRows.length == 0 || $.inArray(cell.row, selectedRows) == -1) { + selectedRows = [cell.row]; + _grid.setSelectedRows(selectedRows); + } + + var rowHeight = _grid.getOptions().rowHeight; + + dd.selectedRows = selectedRows; + + dd.selectionProxy = $("
") + .css("position", "absolute") + .css("zIndex", "99999") + .css("width", $(_canvas).innerWidth()) + .css("height", rowHeight * selectedRows.length) + .appendTo(_canvas); + + dd.guide = $("
") + .css("position", "absolute") + .css("zIndex", "99998") + .css("width", $(_canvas).innerWidth()) + .css("top", -1000) + .appendTo(_canvas); + + dd.insertBefore = -1; + } + + function handleDrag(e, dd) { + if (!_dragging) { + return; + } + + e.stopImmediatePropagation(); + + var top = e.pageY - $(_canvas).offset().top; + dd.selectionProxy.css("top", top - 5); + + var insertBefore = Math.max(0, Math.min(Math.round(top / _grid.getOptions().rowHeight), _grid.getDataLength())); + if (insertBefore !== dd.insertBefore) { + var eventData = { + "rows": dd.selectedRows, + "insertBefore": insertBefore + }; + + if (_self.onBeforeMoveRows.notify(eventData) === false) { + dd.guide.css("top", -1000); + dd.canMove = false; + } else { + dd.guide.css("top", insertBefore * _grid.getOptions().rowHeight); + dd.canMove = true; + } + + dd.insertBefore = insertBefore; + } + } + + function handleDragEnd(e, dd) { + if (!_dragging) { + return; + } + _dragging = false; + e.stopImmediatePropagation(); + + dd.guide.remove(); + dd.selectionProxy.remove(); + + if (dd.canMove) { + var eventData = { + "rows": dd.selectedRows, + "insertBefore": dd.insertBefore + }; + // TODO: _grid.remapCellCssClasses ? + _self.onMoveRows.notify(eventData); + } + } + + $.extend(this, { + "onBeforeMoveRows": new Slick.Event(), + "onMoveRows": new Slick.Event(), + + "init": init, + "destroy": destroy + }); + } +})(jQuery); \ No newline at end of file diff --git a/third-party/slickgrid-2.1/plugins/slick.rowselectionmodel.js b/third-party/slickgrid-2.1/plugins/slick.rowselectionmodel.js new file mode 100644 index 00000000..28e7e43a --- /dev/null +++ b/third-party/slickgrid-2.1/plugins/slick.rowselectionmodel.js @@ -0,0 +1,187 @@ +(function ($) { + // register namespace + $.extend(true, window, { + "Slick": { + "RowSelectionModel": RowSelectionModel + } + }); + + function RowSelectionModel(options) { + var _grid; + var _ranges = []; + var _self = this; + var _handler = new Slick.EventHandler(); + var _inHandler; + var _options; + var _defaults = { + selectActiveRow: true + }; + + function init(grid) { + _options = $.extend(true, {}, _defaults, options); + _grid = grid; + _handler.subscribe(_grid.onActiveCellChanged, + wrapHandler(handleActiveCellChange)); + _handler.subscribe(_grid.onKeyDown, + wrapHandler(handleKeyDown)); + _handler.subscribe(_grid.onClick, + wrapHandler(handleClick)); + } + + function destroy() { + _handler.unsubscribeAll(); + } + + function wrapHandler(handler) { + return function () { + if (!_inHandler) { + _inHandler = true; + handler.apply(this, arguments); + _inHandler = false; + } + }; + } + + function rangesToRows(ranges) { + var rows = []; + for (var i = 0; i < ranges.length; i++) { + for (var j = ranges[i].fromRow; j <= ranges[i].toRow; j++) { + rows.push(j); + } + } + return rows; + } + + function rowsToRanges(rows) { + var ranges = []; + var lastCell = _grid.getColumns().length - 1; + for (var i = 0; i < rows.length; i++) { + ranges.push(new Slick.Range(rows[i], 0, rows[i], lastCell)); + } + return ranges; + } + + function getRowsRange(from, to) { + var i, rows = []; + for (i = from; i <= to; i++) { + rows.push(i); + } + for (i = to; i < from; i++) { + rows.push(i); + } + return rows; + } + + function getSelectedRows() { + return rangesToRows(_ranges); + } + + function setSelectedRows(rows) { + setSelectedRanges(rowsToRanges(rows)); + } + + function setSelectedRanges(ranges) { + _ranges = ranges; + _self.onSelectedRangesChanged.notify(_ranges); + } + + function getSelectedRanges() { + return _ranges; + } + + function handleActiveCellChange(e, data) { + if (_options.selectActiveRow && data.row != null) { + setSelectedRanges([new Slick.Range(data.row, 0, data.row, _grid.getColumns().length - 1)]); + } + } + + function handleKeyDown(e) { + var activeRow = _grid.getActiveCell(); + if (activeRow && e.shiftKey && !e.ctrlKey && !e.altKey && !e.metaKey && (e.which == 38 || e.which == 40)) { + var selectedRows = getSelectedRows(); + selectedRows.sort(function (x, y) { + return x - y + }); + + if (!selectedRows.length) { + selectedRows = [activeRow.row]; + } + + var top = selectedRows[0]; + var bottom = selectedRows[selectedRows.length - 1]; + var active; + + if (e.which == 40) { + active = activeRow.row < bottom || top == bottom ? ++bottom : ++top; + } else { + active = activeRow.row < bottom ? --bottom : --top; + } + + if (active >= 0 && active < _grid.getDataLength()) { + _grid.scrollRowIntoView(active); + _ranges = rowsToRanges(getRowsRange(top, bottom)); + setSelectedRanges(_ranges); + } + + e.preventDefault(); + e.stopPropagation(); + } + } + + function handleClick(e) { + var cell = _grid.getCellFromEvent(e); + if (!cell || !_grid.canCellBeActive(cell.row, cell.cell)) { + return false; + } + + var selection = rangesToRows(_ranges); + var idx = $.inArray(cell.row, selection); + + if (!e.ctrlKey && !e.shiftKey && !e.metaKey) { + return false; + } + else if (_grid.getOptions().multiSelect) { + if (idx === -1 && (e.ctrlKey || e.metaKey)) { + selection.push(cell.row); + _grid.setActiveCell(cell.row, cell.cell); + } else if (idx !== -1 && (e.ctrlKey || e.metaKey)) { + selection = $.grep(selection, function (o, i) { + return (o !== cell.row); + }); + _grid.setActiveCell(cell.row, cell.cell); + } else if (selection.length && e.shiftKey) { + var last = selection.pop(); + var from = Math.min(cell.row, last); + var to = Math.max(cell.row, last); + selection = []; + for (var i = from; i <= to; i++) { + if (i !== last) { + selection.push(i); + } + } + selection.push(last); + _grid.setActiveCell(cell.row, cell.cell); + } + } + + _ranges = rowsToRanges(selection); + setSelectedRanges(_ranges); + e.stopImmediatePropagation(); + + return true; + } + + $.extend(this, { + "getSelectedRows": getSelectedRows, + "setSelectedRows": setSelectedRows, + + "getSelectedRanges": getSelectedRanges, + "setSelectedRanges": setSelectedRanges, + + "init": init, + "destroy": destroy, + + "onSelectedRangesChanged": new Slick.Event() + }); + } +})(jQuery); \ No newline at end of file diff --git a/third-party/slickgrid-2.1/slick.core.js b/third-party/slickgrid-2.1/slick.core.js new file mode 100644 index 00000000..5c4c6956 --- /dev/null +++ b/third-party/slickgrid-2.1/slick.core.js @@ -0,0 +1,458 @@ +/*** + * Contains core SlickGrid classes. + * @module Core + * @namespace Slick + */ + +(function ($) { + // register namespace + $.extend(true, window, { + "Slick": { + "Event": Event, + "EventData": EventData, + "EventHandler": EventHandler, + "Range": Range, + "NonDataRow": NonDataItem, + "Group": Group, + "GroupTotals": GroupTotals, + "EditorLock": EditorLock, + + /*** + * A global singleton editor lock. + * @class GlobalEditorLock + * @static + * @constructor + */ + "GlobalEditorLock": new EditorLock() + } + }); + + /*** + * An event object for passing data to event handlers and letting them control propagation. + *

This is pretty much identical to how W3C and jQuery implement events.

+ * @class EventData + * @constructor + */ + function EventData() { + var isPropagationStopped = false; + var isImmediatePropagationStopped = false; + + /*** + * Stops event from propagating up the DOM tree. + * @method stopPropagation + */ + this.stopPropagation = function () { + isPropagationStopped = true; + }; + + /*** + * Returns whether stopPropagation was called on this event object. + * @method isPropagationStopped + * @return {Boolean} + */ + this.isPropagationStopped = function () { + return isPropagationStopped; + }; + + /*** + * Prevents the rest of the handlers from being executed. + * @method stopImmediatePropagation + */ + this.stopImmediatePropagation = function () { + isImmediatePropagationStopped = true; + }; + + /*** + * Returns whether stopImmediatePropagation was called on this event object.\ + * @method isImmediatePropagationStopped + * @return {Boolean} + */ + this.isImmediatePropagationStopped = function () { + return isImmediatePropagationStopped; + } + } + + /*** + * A simple publisher-subscriber implementation. + * @class Event + * @constructor + */ + function Event() { + var handlers = []; + + /*** + * Adds an event handler to be called when the event is fired. + *

Event handler will receive two arguments - an EventData and the data + * object the event was fired with.

+ * @method subscribe + * @param fn {Function} Event handler. + */ + this.subscribe = function (fn) { + handlers.push(fn); + }; + + /*** + * Removes an event handler added with subscribe(fn). + * @method unsubscribe + * @param fn {Function} Event handler to be removed. + */ + this.unsubscribe = function (fn) { + for (var i = handlers.length - 1; i >= 0; i--) { + if (handlers[i] === fn) { + handlers.splice(i, 1); + } + } + }; + + /*** + * Fires an event notifying all subscribers. + * @method notify + * @param args {Object} Additional data object to be passed to all handlers. + * @param e {EventData} + * Optional. + * An EventData object to be passed to all handlers. + * For DOM events, an existing W3C/jQuery event object can be passed in. + * @param scope {Object} + * Optional. + * The scope ("this") within which the handler will be executed. + * If not specified, the scope will be set to the Event instance. + */ + this.notify = function (args, e, scope) { + e = e || new EventData(); + scope = scope || this; + + var returnValue; + for (var i = 0; i < handlers.length && !(e.isPropagationStopped() || e.isImmediatePropagationStopped()); i++) { + returnValue = handlers[i].call(scope, e, args); + } + + return returnValue; + }; + } + + function EventHandler() { + var handlers = []; + + this.subscribe = function (event, handler) { + handlers.push({ + event: event, + handler: handler + }); + event.subscribe(handler); + + return this; // allow chaining + }; + + this.unsubscribe = function (event, handler) { + var i = handlers.length; + while (i--) { + if (handlers[i].event === event && + handlers[i].handler === handler) { + handlers.splice(i, 1); + event.unsubscribe(handler); + return; + } + } + + return this; // allow chaining + }; + + this.unsubscribeAll = function () { + var i = handlers.length; + while (i--) { + handlers[i].event.unsubscribe(handlers[i].handler); + } + handlers = []; + + return this; // allow chaining + } + } + + /*** + * A structure containing a range of cells. + * @class Range + * @constructor + * @param fromRow {Integer} Starting row. + * @param fromCell {Integer} Starting cell. + * @param toRow {Integer} Optional. Ending row. Defaults to fromRow. + * @param toCell {Integer} Optional. Ending cell. Defaults to fromCell. + */ + function Range(fromRow, fromCell, toRow, toCell) { + if (toRow === undefined && toCell === undefined) { + toRow = fromRow; + toCell = fromCell; + } + + /*** + * @property fromRow + * @type {Integer} + */ + this.fromRow = Math.min(fromRow, toRow); + + /*** + * @property fromCell + * @type {Integer} + */ + this.fromCell = Math.min(fromCell, toCell); + + /*** + * @property toRow + * @type {Integer} + */ + this.toRow = Math.max(fromRow, toRow); + + /*** + * @property toCell + * @type {Integer} + */ + this.toCell = Math.max(fromCell, toCell); + + /*** + * Returns whether a range represents a single row. + * @method isSingleRow + * @return {Boolean} + */ + this.isSingleRow = function () { + return this.fromRow == this.toRow; + }; + + /*** + * Returns whether a range represents a single cell. + * @method isSingleCell + * @return {Boolean} + */ + this.isSingleCell = function () { + return this.fromRow == this.toRow && this.fromCell == this.toCell; + }; + + /*** + * Returns whether a range contains a given cell. + * @method contains + * @param row {Integer} + * @param cell {Integer} + * @return {Boolean} + */ + this.contains = function (row, cell) { + return row >= this.fromRow && row <= this.toRow && + cell >= this.fromCell && cell <= this.toCell; + }; + + /*** + * Returns a readable representation of a range. + * @method toString + * @return {String} + */ + this.toString = function () { + if (this.isSingleCell()) { + return "(" + this.fromRow + ":" + this.fromCell + ")"; + } + else { + return "(" + this.fromRow + ":" + this.fromCell + " - " + this.toRow + ":" + this.toCell + ")"; + } + } + } + + + /*** + * A base class that all special / non-data rows (like Group and GroupTotals) derive from. + * @class NonDataItem + * @constructor + */ + function NonDataItem() { + this.__nonDataRow = true; + } + + + /*** + * Information about a group of rows. + * @class Group + * @extends Slick.NonDataItem + * @constructor + */ + function Group() { + this.__group = true; + + /** + * Grouping level, starting with 0. + * @property level + * @type {Number} + */ + this.level = 0; + + /*** + * Number of rows in the group. + * @property count + * @type {Integer} + */ + this.count = 0; + + /*** + * Grouping value. + * @property value + * @type {Object} + */ + this.value = null; + + /*** + * Formatted display value of the group. + * @property title + * @type {String} + */ + this.title = null; + + /*** + * Whether a group is collapsed. + * @property collapsed + * @type {Boolean} + */ + this.collapsed = false; + + /*** + * GroupTotals, if any. + * @property totals + * @type {GroupTotals} + */ + this.totals = null; + + /** + * Rows that are part of the group. + * @property rows + * @type {Array} + */ + this.rows = []; + + /** + * Sub-groups that are part of the group. + * @property groups + * @type {Array} + */ + this.groups = null; + + /** + * A unique key used to identify the group. This key can be used in calls to DataView + * collapseGroup() or expandGroup(). + * @property groupingKey + * @type {Object} + */ + this.groupingKey = null; + } + + Group.prototype = new NonDataItem(); + + /*** + * Compares two Group instances. + * @method equals + * @return {Boolean} + * @param group {Group} Group instance to compare to. + */ + Group.prototype.equals = function (group) { + return this.value === group.value && + this.count === group.count && + this.collapsed === group.collapsed; + }; + + /*** + * Information about group totals. + * An instance of GroupTotals will be created for each totals row and passed to the aggregators + * so that they can store arbitrary data in it. That data can later be accessed by group totals + * formatters during the display. + * @class GroupTotals + * @extends Slick.NonDataItem + * @constructor + */ + function GroupTotals() { + this.__groupTotals = true; + + /*** + * Parent Group. + * @param group + * @type {Group} + */ + this.group = null; + } + + GroupTotals.prototype = new NonDataItem(); + + /*** + * A locking helper to track the active edit controller and ensure that only a single controller + * can be active at a time. This prevents a whole class of state and validation synchronization + * issues. An edit controller (such as SlickGrid) can query if an active edit is in progress + * and attempt a commit or cancel before proceeding. + * @class EditorLock + * @constructor + */ + function EditorLock() { + var activeEditController = null; + + /*** + * Returns true if a specified edit controller is active (has the edit lock). + * If the parameter is not specified, returns true if any edit controller is active. + * @method isActive + * @param editController {EditController} + * @return {Boolean} + */ + this.isActive = function (editController) { + return (editController ? activeEditController === editController : activeEditController !== null); + }; + + /*** + * Sets the specified edit controller as the active edit controller (acquire edit lock). + * If another edit controller is already active, and exception will be thrown. + * @method activate + * @param editController {EditController} edit controller acquiring the lock + */ + this.activate = function (editController) { + if (editController === activeEditController) { // already activated? + return; + } + if (activeEditController !== null) { + throw "SlickGrid.EditorLock.activate: an editController is still active, can't activate another editController"; + } + if (!editController.commitCurrentEdit) { + throw "SlickGrid.EditorLock.activate: editController must implement .commitCurrentEdit()"; + } + if (!editController.cancelCurrentEdit) { + throw "SlickGrid.EditorLock.activate: editController must implement .cancelCurrentEdit()"; + } + activeEditController = editController; + }; + + /*** + * Unsets the specified edit controller as the active edit controller (release edit lock). + * If the specified edit controller is not the active one, an exception will be thrown. + * @method deactivate + * @param editController {EditController} edit controller releasing the lock + */ + this.deactivate = function (editController) { + if (activeEditController !== editController) { + throw "SlickGrid.EditorLock.deactivate: specified editController is not the currently active one"; + } + activeEditController = null; + }; + + /*** + * Attempts to commit the current edit by calling "commitCurrentEdit" method on the active edit + * controller and returns whether the commit attempt was successful (commit may fail due to validation + * errors, etc.). Edit controller's "commitCurrentEdit" must return true if the commit has succeeded + * and false otherwise. If no edit controller is active, returns true. + * @method commitCurrentEdit + * @return {Boolean} + */ + this.commitCurrentEdit = function () { + return (activeEditController ? activeEditController.commitCurrentEdit() : true); + }; + + /*** + * Attempts to cancel the current edit by calling "cancelCurrentEdit" method on the active edit + * controller and returns whether the edit was successfully cancelled. If no edit controller is + * active, returns true. + * @method cancelCurrentEdit + * @return {Boolean} + */ + this.cancelCurrentEdit = function cancelCurrentEdit() { + return (activeEditController ? activeEditController.cancelCurrentEdit() : true); + }; + } +})(jQuery); + + diff --git a/third-party/slickgrid-2.1/slick.dataview.js b/third-party/slickgrid-2.1/slick.dataview.js new file mode 100644 index 00000000..5bee4ff4 --- /dev/null +++ b/third-party/slickgrid-2.1/slick.dataview.js @@ -0,0 +1,1063 @@ +(function ($) { + $.extend(true, window, { + Slick: { + Data: { + DataView: DataView, + Aggregators: { + Avg: AvgAggregator, + Min: MinAggregator, + Max: MaxAggregator, + Sum: SumAggregator + } + } + } + }); + + + /*** + * A sample Model implementation. + * Provides a filtered view of the underlying data. + * + * Relies on the data item having an "id" property uniquely identifying it. + */ + function DataView(options) { + var self = this; + + var defaults = { + groupItemMetadataProvider: null, + inlineFilters: false + }; + + + // private + var idProperty = "id"; // property holding a unique row id + var items = []; // data by index + var rows = []; // data by row + var idxById = {}; // indexes by id + var rowsById = null; // rows by id; lazy-calculated + var filter = null; // filter function + var updated = null; // updated item ids + var suspend = false; // suspends the recalculation + var sortAsc = true; + var fastSortField; + var sortComparer; + var refreshHints = {}; + var prevRefreshHints = {}; + var filterArgs; + var filteredItems = []; + var compiledFilter; + var compiledFilterWithCaching; + var filterCache = []; + + // grouping + var groupingInfoDefaults = { + getter: null, + formatter: null, + comparer: function(a, b) { return a.value - b.value; }, + predefinedValues: [], + aggregators: [], + aggregateEmpty: false, + aggregateCollapsed: false, + aggregateChildGroups: false, + collapsed: false, + displayTotalsRow: true + }; + var groupingInfos = []; + var groups = []; + var toggledGroupsByLevel = []; + var groupingDelimiter = ':|:'; + + var pagesize = 0; + var pagenum = 0; + var totalRows = 0; + + // events + var onRowCountChanged = new Slick.Event(); + var onRowsChanged = new Slick.Event(); + var onPagingInfoChanged = new Slick.Event(); + + options = $.extend(true, {}, defaults, options); + + + function beginUpdate() { + suspend = true; + } + + function endUpdate() { + suspend = false; + refresh(); + } + + function setRefreshHints(hints) { + refreshHints = hints; + } + + function setFilterArgs(args) { + filterArgs = args; + } + + function updateIdxById(startingIndex) { + startingIndex = startingIndex || 0; + var id; + for (var i = startingIndex, l = items.length; i < l; i++) { + id = items[i][idProperty]; + if (id === undefined) { + throw "Each data element must implement a unique 'id' property"; + } + idxById[id] = i; + } + } + + function ensureIdUniqueness() { + var id; + for (var i = 0, l = items.length; i < l; i++) { + id = items[i][idProperty]; + if (id === undefined || idxById[id] !== i) { + throw "Each data element must implement a unique 'id' property"; + } + } + } + + function getItems() { + return items; + } + + function setItems(data, objectIdProperty) { + if (objectIdProperty !== undefined) { + idProperty = objectIdProperty; + } + items = filteredItems = data; + idxById = {}; + updateIdxById(); + ensureIdUniqueness(); + refresh(); + } + + function setPagingOptions(args) { + if (args.pageSize != undefined) { + pagesize = args.pageSize; + pagenum = pagesize ? Math.min(pagenum, Math.max(0, Math.ceil(totalRows / pagesize) - 1)) : 0; + } + + if (args.pageNum != undefined) { + pagenum = Math.min(args.pageNum, Math.max(0, Math.ceil(totalRows / pagesize) - 1)); + } + + onPagingInfoChanged.notify(getPagingInfo(), null, self); + + refresh(); + } + + function getPagingInfo() { + var totalPages = pagesize ? Math.max(1, Math.ceil(totalRows / pagesize)) : 1; + return {pageSize: pagesize, pageNum: pagenum, totalRows: totalRows, totalPages: totalPages}; + } + + function sort(comparer, ascending) { + sortAsc = ascending; + sortComparer = comparer; + fastSortField = null; + if (ascending === false) { + items.reverse(); + } + items.sort(comparer); + if (ascending === false) { + items.reverse(); + } + idxById = {}; + updateIdxById(); + refresh(); + } + + /*** + * Provides a workaround for the extremely slow sorting in IE. + * Does a [lexicographic] sort on a give column by temporarily overriding Object.prototype.toString + * to return the value of that field and then doing a native Array.sort(). + */ + function fastSort(field, ascending) { + sortAsc = ascending; + fastSortField = field; + sortComparer = null; + var oldToString = Object.prototype.toString; + Object.prototype.toString = (typeof field == "function") ? field : function () { + return this[field] + }; + // an extra reversal for descending sort keeps the sort stable + // (assuming a stable native sort implementation, which isn't true in some cases) + if (ascending === false) { + items.reverse(); + } + items.sort(); + Object.prototype.toString = oldToString; + if (ascending === false) { + items.reverse(); + } + idxById = {}; + updateIdxById(); + refresh(); + } + + function reSort() { + if (sortComparer) { + sort(sortComparer, sortAsc); + } else if (fastSortField) { + fastSort(fastSortField, sortAsc); + } + } + + function setFilter(filterFn) { + filter = filterFn; + if (options.inlineFilters) { + compiledFilter = compileFilter(); + compiledFilterWithCaching = compileFilterWithCaching(); + } + refresh(); + } + + function getGrouping() { + return groupingInfos; + } + + function setGrouping(groupingInfo) { + if (!options.groupItemMetadataProvider) { + options.groupItemMetadataProvider = new Slick.Data.GroupItemMetadataProvider(); + } + + groups = []; + toggledGroupsByLevel = []; + groupingInfo = groupingInfo || []; + groupingInfos = (groupingInfo instanceof Array) ? groupingInfo : [groupingInfo]; + + for (var i = 0; i < groupingInfos.length; i++) { + var gi = groupingInfos[i] = $.extend(true, {}, groupingInfoDefaults, groupingInfos[i]); + gi.getterIsAFn = typeof gi.getter === "function"; + + // pre-compile accumulator loops + gi.compiledAccumulators = []; + var idx = gi.aggregators.length; + while (idx--) { + gi.compiledAccumulators[idx] = compileAccumulatorLoop(gi.aggregators[idx]); + } + + toggledGroupsByLevel[i] = {}; + } + + refresh(); + } + + /** + * @deprecated Please use {@link setGrouping}. + */ + function groupBy(valueGetter, valueFormatter, sortComparer) { + if (valueGetter == null) { + setGrouping([]); + return; + } + + setGrouping({ + getter: valueGetter, + formatter: valueFormatter, + comparer: sortComparer + }); + } + + /** + * @deprecated Please use {@link setGrouping}. + */ + function setAggregators(groupAggregators, includeCollapsed) { + if (!groupingInfos.length) { + throw new Error("At least one grouping must be specified before calling setAggregators()."); + } + + groupingInfos[0].aggregators = groupAggregators; + groupingInfos[0].aggregateCollapsed = includeCollapsed; + + setGrouping(groupingInfos); + } + + function getItemByIdx(i) { + return items[i]; + } + + function getIdxById(id) { + return idxById[id]; + } + + function ensureRowsByIdCache() { + if (!rowsById) { + rowsById = {}; + for (var i = 0, l = rows.length; i < l; i++) { + rowsById[rows[i][idProperty]] = i; + } + } + } + + function getRowById(id) { + ensureRowsByIdCache(); + return rowsById[id]; + } + + function getItemById(id) { + return items[idxById[id]]; + } + + function mapIdsToRows(idArray) { + var rows = []; + ensureRowsByIdCache(); + for (var i = 0; i < idArray.length; i++) { + var row = rowsById[idArray[i]]; + if (row != null) { + rows[rows.length] = row; + } + } + return rows; + } + + function mapRowsToIds(rowArray) { + var ids = []; + for (var i = 0; i < rowArray.length; i++) { + if (rowArray[i] < rows.length) { + ids[ids.length] = rows[rowArray[i]][idProperty]; + } + } + return ids; + } + + function updateItem(id, item) { + if (idxById[id] === undefined || id !== item[idProperty]) { + throw "Invalid or non-matching id"; + } + items[idxById[id]] = item; + if (!updated) { + updated = {}; + } + updated[id] = true; + refresh(); + } + + function insertItem(insertBefore, item) { + items.splice(insertBefore, 0, item); + updateIdxById(insertBefore); + refresh(); + } + + function addItem(item) { + items.push(item); + updateIdxById(items.length - 1); + refresh(); + } + + function deleteItem(id) { + var idx = idxById[id]; + if (idx === undefined) { + throw "Invalid id"; + } + delete idxById[id]; + items.splice(idx, 1); + updateIdxById(idx); + refresh(); + } + + function getLength() { + return rows.length; + } + + function getItem(i) { + return rows[i]; + } + + function getItemMetadata(i) { + var item = rows[i]; + if (item === undefined) { + return null; + } + + // overrides for grouping rows + if (item.__group) { + return options.groupItemMetadataProvider.getGroupRowMetadata(item); + } + + // overrides for totals rows + if (item.__groupTotals) { + return options.groupItemMetadataProvider.getTotalsRowMetadata(item); + } + + return null; + } + + function expandCollapseAllGroups(level, collapse) { + if (level == null) { + for (var i = 0; i < groupingInfos.length; i++) { + toggledGroupsByLevel[i] = {}; + groupingInfos[i].collapsed = collapse; + } + } else { + toggledGroupsByLevel[level] = {}; + groupingInfos[level].collapsed = collapse; + } + refresh(); + } + + /** + * @param level {Number} Optional level to collapse. If not specified, applies to all levels. + */ + function collapseAllGroups(level) { + expandCollapseAllGroups(level, true); + } + + /** + * @param level {Number} Optional level to expand. If not specified, applies to all levels. + */ + function expandAllGroups(level) { + expandCollapseAllGroups(level, false); + } + + function expandCollapseGroup(level, groupingKey, collapse) { + toggledGroupsByLevel[level][groupingKey] = groupingInfos[level].collapsed ^ collapse; + refresh(); + } + + /** + * @param varArgs Either a Slick.Group's "groupingKey" property, or a + * variable argument list of grouping values denoting a unique path to the row. For + * example, calling collapseGroup('high', '10%') will collapse the '10%' subgroup of + * the 'high' setGrouping. + */ + function collapseGroup(varArgs) { + var args = Array.prototype.slice.call(arguments); + var arg0 = args[0]; + if (args.length == 1 && arg0.indexOf(groupingDelimiter) != -1) { + expandCollapseGroup(arg0.split(groupingDelimiter).length - 1, arg0, true); + } else { + expandCollapseGroup(args.length - 1, args.join(groupingDelimiter), true); + } + } + + /** + * @param varArgs Either a Slick.Group's "groupingKey" property, or a + * variable argument list of grouping values denoting a unique path to the row. For + * example, calling expandGroup('high', '10%') will expand the '10%' subgroup of + * the 'high' setGrouping. + */ + function expandGroup(varArgs) { + var args = Array.prototype.slice.call(arguments); + var arg0 = args[0]; + if (args.length == 1 && arg0.indexOf(groupingDelimiter) != -1) { + expandCollapseGroup(arg0.split(groupingDelimiter).length - 1, arg0, false); + } else { + expandCollapseGroup(args.length - 1, args.join(groupingDelimiter), false); + } + } + + function getGroups() { + return groups; + } + + function extractGroups(rows, parentGroup) { + var group; + var val; + var groups = []; + var groupsByVal = []; + var r; + var level = parentGroup ? parentGroup.level + 1 : 0; + var gi = groupingInfos[level]; + + for (var i = 0, l = gi.predefinedValues.length; i < l; i++) { + val = gi.predefinedValues[i]; + group = groupsByVal[val]; + if (!group) { + group = new Slick.Group(); + group.value = val; + group.level = level; + group.groupingKey = (parentGroup ? parentGroup.groupingKey + groupingDelimiter : '') + val; + groups[groups.length] = group; + groupsByVal[val] = group; + } + } + + for (var i = 0, l = rows.length; i < l; i++) { + r = rows[i]; + val = gi.getterIsAFn ? gi.getter(r) : r[gi.getter]; + group = groupsByVal[val]; + if (!group) { + group = new Slick.Group(); + group.value = val; + group.level = level; + group.groupingKey = (parentGroup ? parentGroup.groupingKey + groupingDelimiter : '') + val; + groups[groups.length] = group; + groupsByVal[val] = group; + } + + group.rows[group.count++] = r; + } + + if (level < groupingInfos.length - 1) { + for (var i = 0; i < groups.length; i++) { + group = groups[i]; + group.groups = extractGroups(group.rows, group); + } + } + + groups.sort(groupingInfos[level].comparer); + + return groups; + } + + // TODO: lazy totals calculation + function calculateGroupTotals(group) { + // TODO: try moving iterating over groups into compiled accumulator + var gi = groupingInfos[group.level]; + var isLeafLevel = (group.level == groupingInfos.length); + var totals = new Slick.GroupTotals(); + var agg, idx = gi.aggregators.length; + while (idx--) { + agg = gi.aggregators[idx]; + agg.init(); + gi.compiledAccumulators[idx].call(agg, + (!isLeafLevel && gi.aggregateChildGroups) ? group.groups : group.rows); + agg.storeResult(totals); + } + totals.group = group; + group.totals = totals; + } + + function calculateTotals(groups, level) { + level = level || 0; + var gi = groupingInfos[level]; + var idx = groups.length, g; + while (idx--) { + g = groups[idx]; + + if (g.collapsed && !gi.aggregateCollapsed) { + continue; + } + + // Do a depth-first aggregation so that parent setGrouping aggregators can access subgroup totals. + if (g.groups) { + calculateTotals(g.groups, level + 1); + } + + if (gi.aggregators.length && ( + gi.aggregateEmpty || g.rows.length || (g.groups && g.groups.length))) { + calculateGroupTotals(g); + } + } + } + + function finalizeGroups(groups, level) { + level = level || 0; + var gi = groupingInfos[level]; + var groupCollapsed = gi.collapsed; + var toggledGroups = toggledGroupsByLevel[level]; + var idx = groups.length, g; + while (idx--) { + g = groups[idx]; + g.collapsed = groupCollapsed ^ toggledGroups[g.groupingKey]; + g.title = gi.formatter ? gi.formatter(g) : g.value; + + if (g.groups) { + finalizeGroups(g.groups, level + 1); + // Let the non-leaf setGrouping rows get garbage-collected. + // They may have been used by aggregates that go over all of the descendants, + // but at this point they are no longer needed. + g.rows = []; + } + } + } + + function flattenGroupedRows(groups, level) { + level = level || 0; + var gi = groupingInfos[level]; + var groupedRows = [], rows, gl = 0, g; + for (var i = 0, l = groups.length; i < l; i++) { + g = groups[i]; + groupedRows[gl++] = g; + + if (!g.collapsed) { + rows = g.groups ? flattenGroupedRows(g.groups, level + 1) : g.rows; + for (var j = 0, jj = rows.length; j < jj; j++) { + groupedRows[gl++] = rows[j]; + } + } + + if (g.totals && gi.displayTotalsRow && (!g.collapsed || gi.aggregateCollapsed)) { + groupedRows[gl++] = g.totals; + } + } + return groupedRows; + } + + function getFunctionInfo(fn) { + var fnRegex = /^function[^(]*\(([^)]*)\)\s*{([\s\S]*)}$/; + var matches = fn.toString().match(fnRegex); + return { + params: matches[1].split(","), + body: matches[2] + }; + } + + function compileAccumulatorLoop(aggregator) { + var accumulatorInfo = getFunctionInfo(aggregator.accumulate); + var fn = new Function( + "_items", + "for (var " + accumulatorInfo.params[0] + ", _i=0, _il=_items.length; _i<_il; _i++) {" + + accumulatorInfo.params[0] + " = _items[_i]; " + + accumulatorInfo.body + + "}" + ); + fn.displayName = fn.name = "compiledAccumulatorLoop"; + return fn; + } + + function compileFilter() { + var filterInfo = getFunctionInfo(filter); + + var filterBody = filterInfo.body + .replace(/return false\s*([;}]|$)/gi, "{ continue _coreloop; }$1") + .replace(/return true\s*([;}]|$)/gi, "{ _retval[_idx++] = $item$; continue _coreloop; }$1") + .replace(/return ([^;}]+?)\s*([;}]|$)/gi, + "{ if ($1) { _retval[_idx++] = $item$; }; continue _coreloop; }$2"); + + // This preserves the function template code after JS compression, + // so that replace() commands still work as expected. + var tpl = [ + //"function(_items, _args) { ", + "var _retval = [], _idx = 0; ", + "var $item$, $args$ = _args; ", + "_coreloop: ", + "for (var _i = 0, _il = _items.length; _i < _il; _i++) { ", + "$item$ = _items[_i]; ", + "$filter$; ", + "} ", + "return _retval; " + //"}" + ].join(""); + tpl = tpl.replace(/\$filter\$/gi, filterBody); + tpl = tpl.replace(/\$item\$/gi, filterInfo.params[0]); + tpl = tpl.replace(/\$args\$/gi, filterInfo.params[1]); + + var fn = new Function("_items,_args", tpl); + fn.displayName = fn.name = "compiledFilter"; + return fn; + } + + function compileFilterWithCaching() { + var filterInfo = getFunctionInfo(filter); + + var filterBody = filterInfo.body + .replace(/return false\s*([;}]|$)/gi, "{ continue _coreloop; }$1") + .replace(/return true\s*([;}]|$)/gi, "{ _cache[_i] = true;_retval[_idx++] = $item$; continue _coreloop; }$1") + .replace(/return ([^;}]+?)\s*([;}]|$)/gi, + "{ if ((_cache[_i] = $1)) { _retval[_idx++] = $item$; }; continue _coreloop; }$2"); + + // This preserves the function template code after JS compression, + // so that replace() commands still work as expected. + var tpl = [ + //"function(_items, _args, _cache) { ", + "var _retval = [], _idx = 0; ", + "var $item$, $args$ = _args; ", + "_coreloop: ", + "for (var _i = 0, _il = _items.length; _i < _il; _i++) { ", + "$item$ = _items[_i]; ", + "if (_cache[_i]) { ", + "_retval[_idx++] = $item$; ", + "continue _coreloop; ", + "} ", + "$filter$; ", + "} ", + "return _retval; " + //"}" + ].join(""); + tpl = tpl.replace(/\$filter\$/gi, filterBody); + tpl = tpl.replace(/\$item\$/gi, filterInfo.params[0]); + tpl = tpl.replace(/\$args\$/gi, filterInfo.params[1]); + + var fn = new Function("_items,_args,_cache", tpl); + fn.displayName = fn.name = "compiledFilterWithCaching"; + return fn; + } + + function uncompiledFilter(items, args) { + var retval = [], idx = 0; + + for (var i = 0, ii = items.length; i < ii; i++) { + if (filter(items[i], args)) { + retval[idx++] = items[i]; + } + } + + return retval; + } + + function uncompiledFilterWithCaching(items, args, cache) { + var retval = [], idx = 0, item; + + for (var i = 0, ii = items.length; i < ii; i++) { + item = items[i]; + if (cache[i]) { + retval[idx++] = item; + } else if (filter(item, args)) { + retval[idx++] = item; + cache[i] = true; + } + } + + return retval; + } + + function getFilteredAndPagedItems(items) { + if (filter) { + var batchFilter = options.inlineFilters ? compiledFilter : uncompiledFilter; + var batchFilterWithCaching = options.inlineFilters ? compiledFilterWithCaching : uncompiledFilterWithCaching; + + if (refreshHints.isFilterNarrowing) { + filteredItems = batchFilter(filteredItems, filterArgs); + } else if (refreshHints.isFilterExpanding) { + filteredItems = batchFilterWithCaching(items, filterArgs, filterCache); + } else if (!refreshHints.isFilterUnchanged) { + filteredItems = batchFilter(items, filterArgs); + } + } else { + // special case: if not filtering and not paging, the resulting + // rows collection needs to be a copy so that changes due to sort + // can be caught + filteredItems = pagesize ? items : items.concat(); + } + + // get the current page + var paged; + if (pagesize) { + if (filteredItems.length < pagenum * pagesize) { + pagenum = Math.floor(filteredItems.length / pagesize); + } + paged = filteredItems.slice(pagesize * pagenum, pagesize * pagenum + pagesize); + } else { + paged = filteredItems; + } + + return {totalRows: filteredItems.length, rows: paged}; + } + + function getRowDiffs(rows, newRows) { + var item, r, eitherIsNonData, diff = []; + var from = 0, to = newRows.length; + + if (refreshHints && refreshHints.ignoreDiffsBefore) { + from = Math.max(0, + Math.min(newRows.length, refreshHints.ignoreDiffsBefore)); + } + + if (refreshHints && refreshHints.ignoreDiffsAfter) { + to = Math.min(newRows.length, + Math.max(0, refreshHints.ignoreDiffsAfter)); + } + + for (var i = from, rl = rows.length; i < to; i++) { + if (i >= rl) { + diff[diff.length] = i; + } else { + item = newRows[i]; + r = rows[i]; + + if ((groupingInfos.length && (eitherIsNonData = (item.__nonDataRow) || (r.__nonDataRow)) && + item.__group !== r.__group || + item.__group && !item.equals(r)) + || (eitherIsNonData && + // no good way to compare totals since they are arbitrary DTOs + // deep object comparison is pretty expensive + // always considering them 'dirty' seems easier for the time being + (item.__groupTotals || r.__groupTotals)) + || item[idProperty] != r[idProperty] + || (updated && updated[item[idProperty]]) + ) { + diff[diff.length] = i; + } + } + } + return diff; + } + + function recalc(_items) { + rowsById = null; + + if (refreshHints.isFilterNarrowing != prevRefreshHints.isFilterNarrowing || + refreshHints.isFilterExpanding != prevRefreshHints.isFilterExpanding) { + filterCache = []; + } + + var filteredItems = getFilteredAndPagedItems(_items); + totalRows = filteredItems.totalRows; + var newRows = filteredItems.rows; + + groups = []; + if (groupingInfos.length) { + groups = extractGroups(newRows); + if (groups.length) { + calculateTotals(groups); + finalizeGroups(groups); + newRows = flattenGroupedRows(groups); + } + } + + var diff = getRowDiffs(rows, newRows); + + rows = newRows; + + return diff; + } + + function refresh() { + if (suspend) { + return; + } + + var countBefore = rows.length; + var totalRowsBefore = totalRows; + + var diff = recalc(items, filter); // pass as direct refs to avoid closure perf hit + + // if the current page is no longer valid, go to last page and recalc + // we suffer a performance penalty here, but the main loop (recalc) remains highly optimized + if (pagesize && totalRows < pagenum * pagesize) { + pagenum = Math.max(0, Math.ceil(totalRows / pagesize) - 1); + diff = recalc(items, filter); + } + + updated = null; + prevRefreshHints = refreshHints; + refreshHints = {}; + + if (totalRowsBefore != totalRows) { + onPagingInfoChanged.notify(getPagingInfo(), null, self); + } + if (countBefore != rows.length) { + onRowCountChanged.notify({previous: countBefore, current: rows.length}, null, self); + } + if (diff.length > 0) { + onRowsChanged.notify({rows: diff}, null, self); + } + } + + function syncGridSelection(grid, preserveHidden) { + var self = this; + var selectedRowIds = self.mapRowsToIds(grid.getSelectedRows());; + var inHandler; + + function update() { + if (selectedRowIds.length > 0) { + inHandler = true; + var selectedRows = self.mapIdsToRows(selectedRowIds); + if (!preserveHidden) { + selectedRowIds = self.mapRowsToIds(selectedRows); + } + grid.setSelectedRows(selectedRows); + inHandler = false; + } + } + + grid.onSelectedRowsChanged.subscribe(function(e, args) { + if (inHandler) { return; } + selectedRowIds = self.mapRowsToIds(grid.getSelectedRows()); + }); + + this.onRowsChanged.subscribe(update); + + this.onRowCountChanged.subscribe(update); + } + + function syncGridCellCssStyles(grid, key) { + var hashById; + var inHandler; + + // since this method can be called after the cell styles have been set, + // get the existing ones right away + storeCellCssStyles(grid.getCellCssStyles(key)); + + function storeCellCssStyles(hash) { + hashById = {}; + for (var row in hash) { + var id = rows[row][idProperty]; + hashById[id] = hash[row]; + } + } + + function update() { + if (hashById) { + inHandler = true; + ensureRowsByIdCache(); + var newHash = {}; + for (var id in hashById) { + var row = rowsById[id]; + if (row != undefined) { + newHash[row] = hashById[id]; + } + } + grid.setCellCssStyles(key, newHash); + inHandler = false; + } + } + + grid.onCellCssStylesChanged.subscribe(function(e, args) { + if (inHandler) { return; } + if (key != args.key) { return; } + if (args.hash) { + storeCellCssStyles(args.hash); + } + }); + + this.onRowsChanged.subscribe(update); + + this.onRowCountChanged.subscribe(update); + } + + $.extend(this, { + // methods + "beginUpdate": beginUpdate, + "endUpdate": endUpdate, + "setPagingOptions": setPagingOptions, + "getPagingInfo": getPagingInfo, + "getItems": getItems, + "setItems": setItems, + "setFilter": setFilter, + "sort": sort, + "fastSort": fastSort, + "reSort": reSort, + "setGrouping": setGrouping, + "getGrouping": getGrouping, + "groupBy": groupBy, + "setAggregators": setAggregators, + "collapseAllGroups": collapseAllGroups, + "expandAllGroups": expandAllGroups, + "collapseGroup": collapseGroup, + "expandGroup": expandGroup, + "getGroups": getGroups, + "getIdxById": getIdxById, + "getRowById": getRowById, + "getItemById": getItemById, + "getItemByIdx": getItemByIdx, + "mapRowsToIds": mapRowsToIds, + "mapIdsToRows": mapIdsToRows, + "setRefreshHints": setRefreshHints, + "setFilterArgs": setFilterArgs, + "refresh": refresh, + "updateItem": updateItem, + "insertItem": insertItem, + "addItem": addItem, + "deleteItem": deleteItem, + "syncGridSelection": syncGridSelection, + "syncGridCellCssStyles": syncGridCellCssStyles, + + // data provider methods + "getLength": getLength, + "getItem": getItem, + "getItemMetadata": getItemMetadata, + + // events + "onRowCountChanged": onRowCountChanged, + "onRowsChanged": onRowsChanged, + "onPagingInfoChanged": onPagingInfoChanged + }); + } + + function AvgAggregator(field) { + this.field_ = field; + + this.init = function () { + this.count_ = 0; + this.nonNullCount_ = 0; + this.sum_ = 0; + }; + + this.accumulate = function (item) { + var val = item[this.field_]; + this.count_++; + if (val != null && val !== "" && val !== NaN) { + this.nonNullCount_++; + this.sum_ += parseFloat(val); + } + }; + + this.storeResult = function (groupTotals) { + if (!groupTotals.avg) { + groupTotals.avg = {}; + } + if (this.nonNullCount_ != 0) { + groupTotals.avg[this.field_] = this.sum_ / this.nonNullCount_; + } + }; + } + + function MinAggregator(field) { + this.field_ = field; + + this.init = function () { + this.min_ = null; + }; + + this.accumulate = function (item) { + var val = item[this.field_]; + if (val != null && val !== "" && val !== NaN) { + if (this.min_ == null || val < this.min_) { + this.min_ = val; + } + } + }; + + this.storeResult = function (groupTotals) { + if (!groupTotals.min) { + groupTotals.min = {}; + } + groupTotals.min[this.field_] = this.min_; + } + } + + function MaxAggregator(field) { + this.field_ = field; + + this.init = function () { + this.max_ = null; + }; + + this.accumulate = function (item) { + var val = item[this.field_]; + if (val != null && val !== "" && val !== NaN) { + if (this.max_ == null || val > this.max_) { + this.max_ = val; + } + } + }; + + this.storeResult = function (groupTotals) { + if (!groupTotals.max) { + groupTotals.max = {}; + } + groupTotals.max[this.field_] = this.max_; + } + } + + function SumAggregator(field) { + this.field_ = field; + + this.init = function () { + this.sum_ = null; + }; + + this.accumulate = function (item) { + var val = item[this.field_]; + if (val != null && val !== "" && val !== NaN) { + this.sum_ += parseFloat(val); + } + }; + + this.storeResult = function (groupTotals) { + if (!groupTotals.sum) { + groupTotals.sum = {}; + } + groupTotals.sum[this.field_] = this.sum_; + } + } + + // TODO: add more built-in aggregators + // TODO: merge common aggregators in one to prevent needles iterating + +})(jQuery); diff --git a/third-party/slickgrid-2.1/slick.editors.js b/third-party/slickgrid-2.1/slick.editors.js new file mode 100644 index 00000000..f3ef8e9d --- /dev/null +++ b/third-party/slickgrid-2.1/slick.editors.js @@ -0,0 +1,512 @@ +/*** + * Contains basic SlickGrid editors. + * @module Editors + * @namespace Slick + */ + +(function ($) { + // register namespace + $.extend(true, window, { + "Slick": { + "Editors": { + "Text": TextEditor, + "Integer": IntegerEditor, + "Date": DateEditor, + "YesNoSelect": YesNoSelectEditor, + "Checkbox": CheckboxEditor, + "PercentComplete": PercentCompleteEditor, + "LongText": LongTextEditor + } + } + }); + + function TextEditor(args) { + var $input; + var defaultValue; + var scope = this; + + this.init = function () { + $input = $("") + .appendTo(args.container) + .bind("keydown.nav", function (e) { + if (e.keyCode === $.ui.keyCode.LEFT || e.keyCode === $.ui.keyCode.RIGHT) { + e.stopImmediatePropagation(); + } + }) + .focus() + .select(); + }; + + this.destroy = function () { + $input.remove(); + }; + + this.focus = function () { + $input.focus(); + }; + + this.getValue = function () { + return $input.val(); + }; + + this.setValue = function (val) { + $input.val(val); + }; + + this.loadValue = function (item) { + defaultValue = item[args.column.field] || ""; + $input.val(defaultValue); + $input[0].defaultValue = defaultValue; + $input.select(); + }; + + this.serializeValue = function () { + return $input.val(); + }; + + this.applyValue = function (item, state) { + item[args.column.field] = state; + }; + + this.isValueChanged = function () { + return (!($input.val() == "" && defaultValue == null)) && ($input.val() != defaultValue); + }; + + this.validate = function () { + if (args.column.validator) { + var validationResults = args.column.validator($input.val()); + if (!validationResults.valid) { + return validationResults; + } + } + + return { + valid: true, + msg: null + }; + }; + + this.init(); + } + + function IntegerEditor(args) { + var $input; + var defaultValue; + var scope = this; + + this.init = function () { + $input = $(""); + + $input.bind("keydown.nav", function (e) { + if (e.keyCode === $.ui.keyCode.LEFT || e.keyCode === $.ui.keyCode.RIGHT) { + e.stopImmediatePropagation(); + } + }); + + $input.appendTo(args.container); + $input.focus().select(); + }; + + this.destroy = function () { + $input.remove(); + }; + + this.focus = function () { + $input.focus(); + }; + + this.loadValue = function (item) { + defaultValue = item[args.column.field]; + $input.val(defaultValue); + $input[0].defaultValue = defaultValue; + $input.select(); + }; + + this.serializeValue = function () { + return parseInt($input.val(), 10) || 0; + }; + + this.applyValue = function (item, state) { + item[args.column.field] = state; + }; + + this.isValueChanged = function () { + return (!($input.val() == "" && defaultValue == null)) && ($input.val() != defaultValue); + }; + + this.validate = function () { + if (isNaN($input.val())) { + return { + valid: false, + msg: "Please enter a valid integer" + }; + } + + return { + valid: true, + msg: null + }; + }; + + this.init(); + } + + function DateEditor(args) { + var $input; + var defaultValue; + var scope = this; + var calendarOpen = false; + + this.init = function () { + $input = $(""); + $input.appendTo(args.container); + $input.focus().select(); + $input.datepicker({ + showOn: "button", + buttonImageOnly: true, + buttonImage: "../images/calendar.gif", + beforeShow: function () { + calendarOpen = true + }, + onClose: function () { + calendarOpen = false + } + }); + $input.width($input.width() - 18); + }; + + this.destroy = function () { + $.datepicker.dpDiv.stop(true, true); + $input.datepicker("hide"); + $input.datepicker("destroy"); + $input.remove(); + }; + + this.show = function () { + if (calendarOpen) { + $.datepicker.dpDiv.stop(true, true).show(); + } + }; + + this.hide = function () { + if (calendarOpen) { + $.datepicker.dpDiv.stop(true, true).hide(); + } + }; + + this.position = function (position) { + if (!calendarOpen) { + return; + } + $.datepicker.dpDiv + .css("top", position.top + 30) + .css("left", position.left); + }; + + this.focus = function () { + $input.focus(); + }; + + this.loadValue = function (item) { + defaultValue = item[args.column.field]; + $input.val(defaultValue); + $input[0].defaultValue = defaultValue; + $input.select(); + }; + + this.serializeValue = function () { + return $input.val(); + }; + + this.applyValue = function (item, state) { + item[args.column.field] = state; + }; + + this.isValueChanged = function () { + return (!($input.val() == "" && defaultValue == null)) && ($input.val() != defaultValue); + }; + + this.validate = function () { + return { + valid: true, + msg: null + }; + }; + + this.init(); + } + + function YesNoSelectEditor(args) { + var $select; + var defaultValue; + var scope = this; + + this.init = function () { + $select = $(""); + $select.appendTo(args.container); + $select.focus(); + }; + + this.destroy = function () { + $select.remove(); + }; + + this.focus = function () { + $select.focus(); + }; + + this.loadValue = function (item) { + $select.val((defaultValue = item[args.column.field]) ? "yes" : "no"); + $select.select(); + }; + + this.serializeValue = function () { + return ($select.val() == "yes"); + }; + + this.applyValue = function (item, state) { + item[args.column.field] = state; + }; + + this.isValueChanged = function () { + return ($select.val() != defaultValue); + }; + + this.validate = function () { + return { + valid: true, + msg: null + }; + }; + + this.init(); + } + + function CheckboxEditor(args) { + var $select; + var defaultValue; + var scope = this; + + this.init = function () { + $select = $(""); + $select.appendTo(args.container); + $select.focus(); + }; + + this.destroy = function () { + $select.remove(); + }; + + this.focus = function () { + $select.focus(); + }; + + this.loadValue = function (item) { + defaultValue = !!item[args.column.field]; + if (defaultValue) { + $select.attr("checked", "checked"); + } else { + $select.removeAttr("checked"); + } + }; + + this.serializeValue = function () { + return !!$select.attr("checked"); + }; + + this.applyValue = function (item, state) { + item[args.column.field] = state; + }; + + this.isValueChanged = function () { + return (this.serializeValue() !== defaultValue); + }; + + this.validate = function () { + return { + valid: true, + msg: null + }; + }; + + this.init(); + } + + function PercentCompleteEditor(args) { + var $input, $picker; + var defaultValue; + var scope = this; + + this.init = function () { + $input = $(""); + $input.width($(args.container).innerWidth() - 25); + $input.appendTo(args.container); + + $picker = $("

").appendTo(args.container); + $picker.append("
"); + + $picker.find(".editor-percentcomplete-buttons").append("

"); + + $input.focus().select(); + + $picker.find(".editor-percentcomplete-slider").slider({ + orientation: "vertical", + range: "min", + value: defaultValue, + slide: function (event, ui) { + $input.val(ui.value) + } + }); + + $picker.find(".editor-percentcomplete-buttons button").bind("click", function (e) { + $input.val($(this).attr("val")); + $picker.find(".editor-percentcomplete-slider").slider("value", $(this).attr("val")); + }) + }; + + this.destroy = function () { + $input.remove(); + $picker.remove(); + }; + + this.focus = function () { + $input.focus(); + }; + + this.loadValue = function (item) { + $input.val(defaultValue = item[args.column.field]); + $input.select(); + }; + + this.serializeValue = function () { + return parseInt($input.val(), 10) || 0; + }; + + this.applyValue = function (item, state) { + item[args.column.field] = state; + }; + + this.isValueChanged = function () { + return (!($input.val() == "" && defaultValue == null)) && ((parseInt($input.val(), 10) || 0) != defaultValue); + }; + + this.validate = function () { + if (isNaN(parseInt($input.val(), 10))) { + return { + valid: false, + msg: "Please enter a valid positive number" + }; + } + + return { + valid: true, + msg: null + }; + }; + + this.init(); + } + + /* + * An example of a "detached" editor. + * The UI is added onto document BODY and .position(), .show() and .hide() are implemented. + * KeyDown events are also handled to provide handling for Tab, Shift-Tab, Esc and Ctrl-Enter. + */ + function LongTextEditor(args) { + var $input, $wrapper; + var defaultValue; + var scope = this; + + this.init = function () { + var $container = $("body"); + + $wrapper = $("
") + .appendTo($container); + + $input = $("