nifi-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mcgil...@apache.org
Subject [22/28] incubator-nifi git commit: NIFI-27: - Latest version of slickgrid.
Date Wed, 10 Dec 2014 18:01:06 GMT
http://git-wip-us.apache.org/repos/asf/incubator-nifi/blob/53f44060/nar-bundles/framework-bundle/framework/web/nifi-web-ui/src/main/webapp/js/jquery/slickgrid/slick.core.js
----------------------------------------------------------------------
diff --git a/nar-bundles/framework-bundle/framework/web/nifi-web-ui/src/main/webapp/js/jquery/slickgrid/slick.core.js
b/nar-bundles/framework-bundle/framework/web/nifi-web-ui/src/main/webapp/js/jquery/slickgrid/slick.core.js
index aea3567..2f097b1 100755
--- a/nar-bundles/framework-bundle/framework/web/nifi-web-ui/src/main/webapp/js/jquery/slickgrid/slick.core.js
+++ b/nar-bundles/framework-bundle/framework/web/nifi-web-ui/src/main/webapp/js/jquery/slickgrid/slick.core.js
@@ -5,419 +5,463 @@
  */
 
 (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()
-        }
-    });
+  // 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;
 
     /***
-     * 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
+     * Stops event from propagating up the DOM tree.
+     * @method stopPropagation
      */
-    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;
-        }
-    }
+    this.stopPropagation = function () {
+      isPropagationStopped = true;
+    };
 
     /***
-     * A simple publisher-subscriber implementation.
-     * @class Event
-     * @constructor
+     * Returns whether stopPropagation was called on this event object.
+     * @method isPropagationStopped
+     * @return {Boolean}
      */
-    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;
-        };
-    }
+    this.isPropagationStopped = function () {
+      return isPropagationStopped;
+    };
 
-    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 = [];
-        }
+    /***
+     * 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);
+    };
 
     /***
-     * 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>.
+     * Removes an event handler added with <code>subscribe(fn)</code>.
+     * @method unsubscribe
+     * @param fn {Function} Event handler to be removed.
      */
-    function Range(fromRow, fromCell, toRow, toCell) {
-        if (toRow === undefined && toCell === undefined) {
-            toRow = fromRow;
-            toCell = fromCell;
+    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;
 
-        /***
-         * @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 + ")";
-            }
+      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 <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);
 
     /***
-     * A base class that all special / non-data rows (like Group and GroupTotals) derive
from.
-     * @class NonDataItem
-     * @constructor
+     * @property fromCell
+     * @type {Integer}
      */
-    function NonDataItem() {
-        this.__nonDataRow = true;
-    }
+    this.fromCell = Math.min(fromCell, toCell);
 
+    /***
+     * @property toRow
+     * @type {Integer}
+     */
+    this.toRow = Math.max(fromRow, toRow);
 
     /***
-     * Information about a group of rows.
-     * @class Group
-     * @extends Slick.NonDataItem
-     * @constructor
+     * @property toCell
+     * @type {Integer}
      */
-    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;
-    }
+    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;
+    };
 
-    Group.prototype = new NonDataItem();
+    /***
+     * Returns whether a range represents a single cell.
+     * @method isSingleCell
+     * @return {Boolean}
+     */
+    this.isSingleCell = function () {
+      return this.fromRow == this.toRow && this.fromCell == this.toCell;
+    };
 
     /***
-     * Compares two Group instances.
-     * @method equals
+     * Returns whether a range contains a given cell.
+     * @method contains
+     * @param row {Integer}
+     * @param cell {Integer}
      * @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;
+    this.contains = function (row, cell) {
+      return row >= this.fromRow && row <= this.toRow &&
+          cell >= this.fromCell && cell <= this.toCell;
     };
 
     /***
-     * 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
+     * Returns a readable representation of a range.
+     * @method toString
+     * @return {String}
      */
-    function GroupTotals() {
-        this.__groupTotals = true;
-
-        /***
-         * Parent Group.
-         * @param group
-         * @type {Group}
-         */
-        this.group = null;
+    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;
 
-    GroupTotals.prototype = new NonDataItem();
+    /***
+     * Number of rows in the group.
+     * @property count
+     * @type {Integer}
+     */
+    this.count = 0;
 
     /***
-     * 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
+     * Grouping value.
+     * @property value
+     * @type {Object}
      */
-    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);
-        };
-    }
+    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 &&
+        this.title === group.title;
+  };
+
+  /***
+   * 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;
+
+    /***
+     * Whether the totals have been fully initialized / calculated.
+     * Will be set to false for lazy-calculated group totals.
+     * @param initialized
+     * @type {Boolean}
+     */
+    this.initialized = false;
+  }
+
+  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);
 
 


Mime
View raw message