omf_web 0.9 → 0.9.1

data/share/htdocs/vendor/slickgrid/plugins/slick.rowselectionmodel.js

@@ -1,187 +0,0 @@
-(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) {
-        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);

data/share/htdocs/vendor/slickgrid/slick.core.js

@@ -1,424 +0,0 @@
-/***
- * 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.
-   * <p>This is pretty much identical to how W3C and jQuery implement events.</p>
-   * @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.
-     * <p>Event handler will receive two arguments - an <code>EventData</code> and the <code>data</code>
-     * object the event was fired with.<p>
-     * @method subscribe
-     * @param fn {Function} Event handler.
-     */
-    this.subscribe = function (fn) {
-      handlers.push(fn);
-    };
-
-    /***
-     * Removes an event handler added with <code>subscribe(fn)</code>.
-     * @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 <code>EventData</code> 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 <code>Event</code> 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);
-    };
-
-    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;
-        }
-      }
-    };
-
-    this.unsubscribeAll = function () {
-      var i = handlers.length;
-      while (i--) {
-        handlers[i].event.unsubscribe(handlers[i].handler);
-      }
-      handlers = [];
-    }
-  }
-
-  /***
-   * 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 <code>fromRow</code>.
-   * @param toCell {Integer} Optional. Ending cell. Defaults to <code>fromCell</code>.
-   */
-  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;
-    this.__updated = false;
-
-    /***
-     * 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;
-  }
-
-  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);
-
-