' + renderTitle(this, c, this.calendars[c].year, this.calendars[c].month, this.calendars[0].year) + this.render(this.calendars[c].year, this.calendars[c].month) + '
';
+ }
+
+ this.el.innerHTML = html;
+
+ if (opts.bound) {
+ if(opts.field.type !== 'hidden') {
+ sto(function() {
+ opts.trigger.focus();
+ }, 1);
+ }
+ }
+
+ if (typeof this._o.onDraw === 'function') {
+ var self = this;
+ sto(function() {
+ self._o.onDraw.call(self);
+ }, 0);
+ }
+ },
+
+ adjustPosition: function()
+ {
+ var field, pEl, width, height, viewportWidth, viewportHeight, scrollTop, left, top, clientRect;
+
+ if (this._o.container) return;
+
+ this.el.style.position = 'absolute';
+
+ field = this._o.trigger;
+ pEl = field;
+ width = this.el.offsetWidth;
+ height = this.el.offsetHeight;
+ viewportWidth = window.innerWidth || document.documentElement.clientWidth;
+ viewportHeight = window.innerHeight || document.documentElement.clientHeight;
+ scrollTop = window.pageYOffset || document.body.scrollTop || document.documentElement.scrollTop;
+
+ if (typeof field.getBoundingClientRect === 'function') {
+ clientRect = field.getBoundingClientRect();
+ left = clientRect.left + window.pageXOffset;
+ top = clientRect.bottom + window.pageYOffset;
+ } else {
+ left = pEl.offsetLeft;
+ top = pEl.offsetTop + pEl.offsetHeight;
+ while((pEl = pEl.offsetParent)) {
+ left += pEl.offsetLeft;
+ top += pEl.offsetTop;
+ }
+ }
+
+ // default position is bottom & left
+ if ((this._o.reposition && left + width > viewportWidth) ||
+ (
+ this._o.position.indexOf('right') > -1 &&
+ left - width + field.offsetWidth > 0
+ )
+ ) {
+ left = left - width + field.offsetWidth;
+ }
+ if ((this._o.reposition && top + height > viewportHeight + scrollTop) ||
+ (
+ this._o.position.indexOf('top') > -1 &&
+ top - height - field.offsetHeight > 0
+ )
+ ) {
+ top = top - height - field.offsetHeight;
+ }
+
+ this.el.style.left = left + 'px';
+ this.el.style.top = top + 'px';
+ },
+
+ /**
+ * render HTML for a particular month
+ */
+ render: function(year, month)
+ {
+ var opts = this._o,
+ now = new Date(),
+ days = getDaysInMonth(year, month),
+ before = new Date(year, month, 1).getDay(),
+ data = [],
+ row = [];
+ setToStartOfDay(now);
+ if (opts.firstDay > 0) {
+ before -= opts.firstDay;
+ if (before < 0) {
+ before += 7;
+ }
+ }
+ var cells = days + before,
+ after = cells;
+ while(after > 7) {
+ after -= 7;
+ }
+ cells += 7 - after;
+ for (var i = 0, r = 0; i < cells; i++)
+ {
+ var dayConfig,
+ day = new Date(year, month, 1 + (i - before)),
+ isSelected = isDate(this._d) ? compareDates(day, this._d) : false,
+ isToday = compareDates(day, now),
+ isEmpty = i < before || i >= (days + before),
+ isStartRange = opts.startRange && compareDates(opts.startRange, day),
+ isEndRange = opts.endRange && compareDates(opts.endRange, day),
+ isInRange = opts.startRange && opts.endRange && opts.startRange < day && day < opts.endRange,
+ isDisabled = (opts.minDate && day < opts.minDate) ||
+ (opts.maxDate && day > opts.maxDate) ||
+ (opts.disableWeekends && isWeekend(day)) ||
+ (opts.disableDayFn && opts.disableDayFn(day)),
+ dayConfig = {
+ day: 1 + (i - before),
+ month: month,
+ year: year,
+ isSelected: isSelected,
+ isToday: isToday,
+ isDisabled: isDisabled,
+ isEmpty: isEmpty,
+ isStartRange: isStartRange,
+ isEndRange: isEndRange,
+ isInRange: isInRange
+ };
+
+ row.push(renderDay(dayConfig));
+
+ if (++r === 7) {
+ if (opts.showWeekNumber) {
+ row.unshift(renderWeek(i - before, month, year));
+ }
+ data.push(renderRow(row, opts.isRTL));
+ row = [];
+ r = 0;
+ }
+ }
+ return renderTable(opts, data);
+ },
+
+ isVisible: function()
+ {
+ return this._v;
+ },
+
+ show: function()
+ {
+ if (!this._v) {
+ removeClass(this.el, 'is-hidden');
+ this._v = true;
+ this.draw();
+ if (this._o.bound) {
+ addEvent(document, 'click', this._onClick);
+ this.adjustPosition();
+ }
+ if (typeof this._o.onOpen === 'function') {
+ this._o.onOpen.call(this);
+ }
+ }
+ },
+
+ hide: function()
+ {
+ var v = this._v;
+ if (v !== false) {
+ if (this._o.bound) {
+ removeEvent(document, 'click', this._onClick);
+ }
+ this.el.style.position = 'static'; // reset
+ this.el.style.left = 'auto';
+ this.el.style.top = 'auto';
+ addClass(this.el, 'is-hidden');
+ this._v = false;
+ if (v !== undefined && typeof this._o.onClose === 'function') {
+ this._o.onClose.call(this);
+ }
+ }
+ },
+
+ /**
+ * GAME OVER
+ */
+ destroy: function()
+ {
+ this.hide();
+ removeEvent(this.el, 'mousedown', this._onMouseDown, true);
+ removeEvent(this.el, 'change', this._onChange);
+ if (this._o.field) {
+ removeEvent(this._o.field, 'change', this._onInputChange);
+ if (this._o.bound) {
+ removeEvent(this._o.trigger, 'click', this._onInputClick);
+ removeEvent(this._o.trigger, 'focus', this._onInputFocus);
+ removeEvent(this._o.trigger, 'blur', this._onInputBlur);
+ }
+ }
+ if (this.el.parentNode) {
+ this.el.parentNode.removeChild(this.el);
+ }
+ }
+
+ };
+
+ return Pikaday;
+
+}));
+
+},{"moment":"moment"}],"zeroclipboard":[function(require,module,exports){
+/*!
+ * ZeroClipboard
+ * The ZeroClipboard library provides an easy way to copy text to the clipboard using an invisible Adobe Flash movie and a JavaScript interface.
+ * Copyright (c) 2009-2014 Jon Rohan, James M. Greene
+ * Licensed MIT
+ * http://zeroclipboard.org/
+ * v2.2.0
+ */
+(function(window, undefined) {
+ "use strict";
+ /**
+ * Store references to critically important global functions that may be
+ * overridden on certain web pages.
+ */
+ var _window = window, _document = _window.document, _navigator = _window.navigator, _setTimeout = _window.setTimeout, _clearTimeout = _window.clearTimeout, _setInterval = _window.setInterval, _clearInterval = _window.clearInterval, _getComputedStyle = _window.getComputedStyle, _encodeURIComponent = _window.encodeURIComponent, _ActiveXObject = _window.ActiveXObject, _Error = _window.Error, _parseInt = _window.Number.parseInt || _window.parseInt, _parseFloat = _window.Number.parseFloat || _window.parseFloat, _isNaN = _window.Number.isNaN || _window.isNaN, _now = _window.Date.now, _keys = _window.Object.keys, _defineProperty = _window.Object.defineProperty, _hasOwn = _window.Object.prototype.hasOwnProperty, _slice = _window.Array.prototype.slice, _unwrap = function() {
+ var unwrapper = function(el) {
+ return el;
+ };
+ if (typeof _window.wrap === "function" && typeof _window.unwrap === "function") {
+ try {
+ var div = _document.createElement("div");
+ var unwrappedDiv = _window.unwrap(div);
+ if (div.nodeType === 1 && unwrappedDiv && unwrappedDiv.nodeType === 1) {
+ unwrapper = _window.unwrap;
+ }
+ } catch (e) {}
+ }
+ return unwrapper;
+ }();
+ /**
+ * Convert an `arguments` object into an Array.
+ *
+ * @returns The arguments as an Array
+ * @private
+ */
+ var _args = function(argumentsObj) {
+ return _slice.call(argumentsObj, 0);
+ };
+ /**
+ * Shallow-copy the owned, enumerable properties of one object over to another, similar to jQuery's `$.extend`.
+ *
+ * @returns The target object, augmented
+ * @private
+ */
+ var _extend = function() {
+ var i, len, arg, prop, src, copy, args = _args(arguments), target = args[0] || {};
+ for (i = 1, len = args.length; i < len; i++) {
+ if ((arg = args[i]) != null) {
+ for (prop in arg) {
+ if (_hasOwn.call(arg, prop)) {
+ src = target[prop];
+ copy = arg[prop];
+ if (target !== copy && copy !== undefined) {
+ target[prop] = copy;
+ }
+ }
+ }
+ }
+ }
+ return target;
+ };
+ /**
+ * Return a deep copy of the source object or array.
+ *
+ * @returns Object or Array
+ * @private
+ */
+ var _deepCopy = function(source) {
+ var copy, i, len, prop;
+ if (typeof source !== "object" || source == null || typeof source.nodeType === "number") {
+ copy = source;
+ } else if (typeof source.length === "number") {
+ copy = [];
+ for (i = 0, len = source.length; i < len; i++) {
+ if (_hasOwn.call(source, i)) {
+ copy[i] = _deepCopy(source[i]);
+ }
+ }
+ } else {
+ copy = {};
+ for (prop in source) {
+ if (_hasOwn.call(source, prop)) {
+ copy[prop] = _deepCopy(source[prop]);
+ }
+ }
+ }
+ return copy;
+ };
+ /**
+ * Makes a shallow copy of `obj` (like `_extend`) but filters its properties based on a list of `keys` to keep.
+ * The inverse of `_omit`, mostly. The big difference is that these properties do NOT need to be enumerable to
+ * be kept.
+ *
+ * @returns A new filtered object.
+ * @private
+ */
+ var _pick = function(obj, keys) {
+ var newObj = {};
+ for (var i = 0, len = keys.length; i < len; i++) {
+ if (keys[i] in obj) {
+ newObj[keys[i]] = obj[keys[i]];
+ }
+ }
+ return newObj;
+ };
+ /**
+ * Makes a shallow copy of `obj` (like `_extend`) but filters its properties based on a list of `keys` to omit.
+ * The inverse of `_pick`.
+ *
+ * @returns A new filtered object.
+ * @private
+ */
+ var _omit = function(obj, keys) {
+ var newObj = {};
+ for (var prop in obj) {
+ if (keys.indexOf(prop) === -1) {
+ newObj[prop] = obj[prop];
+ }
+ }
+ return newObj;
+ };
+ /**
+ * Remove all owned, enumerable properties from an object.
+ *
+ * @returns The original object without its owned, enumerable properties.
+ * @private
+ */
+ var _deleteOwnProperties = function(obj) {
+ if (obj) {
+ for (var prop in obj) {
+ if (_hasOwn.call(obj, prop)) {
+ delete obj[prop];
+ }
+ }
+ }
+ return obj;
+ };
+ /**
+ * Determine if an element is contained within another element.
+ *
+ * @returns Boolean
+ * @private
+ */
+ var _containedBy = function(el, ancestorEl) {
+ if (el && el.nodeType === 1 && el.ownerDocument && ancestorEl && (ancestorEl.nodeType === 1 && ancestorEl.ownerDocument && ancestorEl.ownerDocument === el.ownerDocument || ancestorEl.nodeType === 9 && !ancestorEl.ownerDocument && ancestorEl === el.ownerDocument)) {
+ do {
+ if (el === ancestorEl) {
+ return true;
+ }
+ el = el.parentNode;
+ } while (el);
+ }
+ return false;
+ };
+ /**
+ * Get the URL path's parent directory.
+ *
+ * @returns String or `undefined`
+ * @private
+ */
+ var _getDirPathOfUrl = function(url) {
+ var dir;
+ if (typeof url === "string" && url) {
+ dir = url.split("#")[0].split("?")[0];
+ dir = url.slice(0, url.lastIndexOf("/") + 1);
+ }
+ return dir;
+ };
+ /**
+ * Get the current script's URL by throwing an `Error` and analyzing it.
+ *
+ * @returns String or `undefined`
+ * @private
+ */
+ var _getCurrentScriptUrlFromErrorStack = function(stack) {
+ var url, matches;
+ if (typeof stack === "string" && stack) {
+ matches = stack.match(/^(?:|[^:@]*@|.+\)@(?=http[s]?|file)|.+?\s+(?: at |@)(?:[^:\(]+ )*[\(]?)((?:http[s]?|file):\/\/[\/]?.+?\/[^:\)]*?)(?::\d+)(?::\d+)?/);
+ if (matches && matches[1]) {
+ url = matches[1];
+ } else {
+ matches = stack.match(/\)@((?:http[s]?|file):\/\/[\/]?.+?\/[^:\)]*?)(?::\d+)(?::\d+)?/);
+ if (matches && matches[1]) {
+ url = matches[1];
+ }
+ }
+ }
+ return url;
+ };
+ /**
+ * Get the current script's URL by throwing an `Error` and analyzing it.
+ *
+ * @returns String or `undefined`
+ * @private
+ */
+ var _getCurrentScriptUrlFromError = function() {
+ var url, err;
+ try {
+ throw new _Error();
+ } catch (e) {
+ err = e;
+ }
+ if (err) {
+ url = err.sourceURL || err.fileName || _getCurrentScriptUrlFromErrorStack(err.stack);
+ }
+ return url;
+ };
+ /**
+ * Get the current script's URL.
+ *
+ * @returns String or `undefined`
+ * @private
+ */
+ var _getCurrentScriptUrl = function() {
+ var jsPath, scripts, i;
+ if (_document.currentScript && (jsPath = _document.currentScript.src)) {
+ return jsPath;
+ }
+ scripts = _document.getElementsByTagName("script");
+ if (scripts.length === 1) {
+ return scripts[0].src || undefined;
+ }
+ if ("readyState" in scripts[0]) {
+ for (i = scripts.length; i--; ) {
+ if (scripts[i].readyState === "interactive" && (jsPath = scripts[i].src)) {
+ return jsPath;
+ }
+ }
+ }
+ if (_document.readyState === "loading" && (jsPath = scripts[scripts.length - 1].src)) {
+ return jsPath;
+ }
+ if (jsPath = _getCurrentScriptUrlFromError()) {
+ return jsPath;
+ }
+ return undefined;
+ };
+ /**
+ * Get the unanimous parent directory of ALL script tags.
+ * If any script tags are either (a) inline or (b) from differing parent
+ * directories, this method must return `undefined`.
+ *
+ * @returns String or `undefined`
+ * @private
+ */
+ var _getUnanimousScriptParentDir = function() {
+ var i, jsDir, jsPath, scripts = _document.getElementsByTagName("script");
+ for (i = scripts.length; i--; ) {
+ if (!(jsPath = scripts[i].src)) {
+ jsDir = null;
+ break;
+ }
+ jsPath = _getDirPathOfUrl(jsPath);
+ if (jsDir == null) {
+ jsDir = jsPath;
+ } else if (jsDir !== jsPath) {
+ jsDir = null;
+ break;
+ }
+ }
+ return jsDir || undefined;
+ };
+ /**
+ * Get the presumed location of the "ZeroClipboard.swf" file, based on the location
+ * of the executing JavaScript file (e.g. "ZeroClipboard.js", etc.).
+ *
+ * @returns String
+ * @private
+ */
+ var _getDefaultSwfPath = function() {
+ var jsDir = _getDirPathOfUrl(_getCurrentScriptUrl()) || _getUnanimousScriptParentDir() || "";
+ return jsDir + "ZeroClipboard.swf";
+ };
+ /**
+ * Keep track of if the page is framed (in an `iframe`). This can never change.
+ * @private
+ */
+ var _pageIsFramed = function() {
+ return window.opener == null && (!!window.top && window != window.top || !!window.parent && window != window.parent);
+ }();
+ /**
+ * Keep track of the state of the Flash object.
+ * @private
+ */
+ var _flashState = {
+ bridge: null,
+ version: "0.0.0",
+ pluginType: "unknown",
+ disabled: null,
+ outdated: null,
+ sandboxed: null,
+ unavailable: null,
+ degraded: null,
+ deactivated: null,
+ overdue: null,
+ ready: null
+ };
+ /**
+ * The minimum Flash Player version required to use ZeroClipboard completely.
+ * @readonly
+ * @private
+ */
+ var _minimumFlashVersion = "11.0.0";
+ /**
+ * The ZeroClipboard library version number, as reported by Flash, at the time the SWF was compiled.
+ */
+ var _zcSwfVersion;
+ /**
+ * Keep track of all event listener registrations.
+ * @private
+ */
+ var _handlers = {};
+ /**
+ * Keep track of the currently activated element.
+ * @private
+ */
+ var _currentElement;
+ /**
+ * Keep track of the element that was activated when a `copy` process started.
+ * @private
+ */
+ var _copyTarget;
+ /**
+ * Keep track of data for the pending clipboard transaction.
+ * @private
+ */
+ var _clipData = {};
+ /**
+ * Keep track of data formats for the pending clipboard transaction.
+ * @private
+ */
+ var _clipDataFormatMap = null;
+ /**
+ * Keep track of the Flash availability check timeout.
+ * @private
+ */
+ var _flashCheckTimeout = 0;
+ /**
+ * Keep track of SWF network errors interval polling.
+ * @private
+ */
+ var _swfFallbackCheckInterval = 0;
+ /**
+ * The `message` store for events
+ * @private
+ */
+ var _eventMessages = {
+ ready: "Flash communication is established",
+ error: {
+ "flash-disabled": "Flash is disabled or not installed. May also be attempting to run Flash in a sandboxed iframe, which is impossible.",
+ "flash-outdated": "Flash is too outdated to support ZeroClipboard",
+ "flash-sandboxed": "Attempting to run Flash in a sandboxed iframe, which is impossible",
+ "flash-unavailable": "Flash is unable to communicate bidirectionally with JavaScript",
+ "flash-degraded": "Flash is unable to preserve data fidelity when communicating with JavaScript",
+ "flash-deactivated": "Flash is too outdated for your browser and/or is configured as click-to-activate.\nThis may also mean that the ZeroClipboard SWF object could not be loaded, so please check your `swfPath` configuration and/or network connectivity.\nMay also be attempting to run Flash in a sandboxed iframe, which is impossible.",
+ "flash-overdue": "Flash communication was established but NOT within the acceptable time limit",
+ "version-mismatch": "ZeroClipboard JS version number does not match ZeroClipboard SWF version number",
+ "clipboard-error": "At least one error was thrown while ZeroClipboard was attempting to inject your data into the clipboard",
+ "config-mismatch": "ZeroClipboard configuration does not match Flash's reality",
+ "swf-not-found": "The ZeroClipboard SWF object could not be loaded, so please check your `swfPath` configuration and/or network connectivity"
+ }
+ };
+ /**
+ * The `name`s of `error` events that can only occur is Flash has at least
+ * been able to load the SWF successfully.
+ * @private
+ */
+ var _errorsThatOnlyOccurAfterFlashLoads = [ "flash-unavailable", "flash-degraded", "flash-overdue", "version-mismatch", "config-mismatch", "clipboard-error" ];
+ /**
+ * The `name`s of `error` events that should likely result in the `_flashState`
+ * variable's property values being updated.
+ * @private
+ */
+ var _flashStateErrorNames = [ "flash-disabled", "flash-outdated", "flash-sandboxed", "flash-unavailable", "flash-degraded", "flash-deactivated", "flash-overdue" ];
+ /**
+ * A RegExp to match the `name` property of `error` events related to Flash.
+ * @private
+ */
+ var _flashStateErrorNameMatchingRegex = new RegExp("^flash-(" + _flashStateErrorNames.map(function(errorName) {
+ return errorName.replace(/^flash-/, "");
+ }).join("|") + ")$");
+ /**
+ * A RegExp to match the `name` property of `error` events related to Flash,
+ * which is enabled.
+ * @private
+ */
+ var _flashStateEnabledErrorNameMatchingRegex = new RegExp("^flash-(" + _flashStateErrorNames.slice(1).map(function(errorName) {
+ return errorName.replace(/^flash-/, "");
+ }).join("|") + ")$");
+ /**
+ * ZeroClipboard configuration defaults for the Core module.
+ * @private
+ */
+ var _globalConfig = {
+ swfPath: _getDefaultSwfPath(),
+ trustedDomains: window.location.host ? [ window.location.host ] : [],
+ cacheBust: true,
+ forceEnhancedClipboard: false,
+ flashLoadTimeout: 3e4,
+ autoActivate: true,
+ bubbleEvents: true,
+ containerId: "global-zeroclipboard-html-bridge",
+ containerClass: "global-zeroclipboard-container",
+ swfObjectId: "global-zeroclipboard-flash-bridge",
+ hoverClass: "zeroclipboard-is-hover",
+ activeClass: "zeroclipboard-is-active",
+ forceHandCursor: false,
+ title: null,
+ zIndex: 999999999
+ };
+ /**
+ * The underlying implementation of `ZeroClipboard.config`.
+ * @private
+ */
+ var _config = function(options) {
+ if (typeof options === "object" && options !== null) {
+ for (var prop in options) {
+ if (_hasOwn.call(options, prop)) {
+ if (/^(?:forceHandCursor|title|zIndex|bubbleEvents)$/.test(prop)) {
+ _globalConfig[prop] = options[prop];
+ } else if (_flashState.bridge == null) {
+ if (prop === "containerId" || prop === "swfObjectId") {
+ if (_isValidHtml4Id(options[prop])) {
+ _globalConfig[prop] = options[prop];
+ } else {
+ throw new Error("The specified `" + prop + "` value is not valid as an HTML4 Element ID");
+ }
+ } else {
+ _globalConfig[prop] = options[prop];
+ }
+ }
+ }
+ }
+ }
+ if (typeof options === "string" && options) {
+ if (_hasOwn.call(_globalConfig, options)) {
+ return _globalConfig[options];
+ }
+ return;
+ }
+ return _deepCopy(_globalConfig);
+ };
+ /**
+ * The underlying implementation of `ZeroClipboard.state`.
+ * @private
+ */
+ var _state = function() {
+ _detectSandbox();
+ return {
+ browser: _pick(_navigator, [ "userAgent", "platform", "appName" ]),
+ flash: _omit(_flashState, [ "bridge" ]),
+ zeroclipboard: {
+ version: ZeroClipboard.version,
+ config: ZeroClipboard.config()
+ }
+ };
+ };
+ /**
+ * The underlying implementation of `ZeroClipboard.isFlashUnusable`.
+ * @private
+ */
+ var _isFlashUnusable = function() {
+ return !!(_flashState.disabled || _flashState.outdated || _flashState.sandboxed || _flashState.unavailable || _flashState.degraded || _flashState.deactivated);
+ };
+ /**
+ * The underlying implementation of `ZeroClipboard.on`.
+ * @private
+ */
+ var _on = function(eventType, listener) {
+ var i, len, events, added = {};
+ if (typeof eventType === "string" && eventType) {
+ events = eventType.toLowerCase().split(/\s+/);
+ } else if (typeof eventType === "object" && eventType && typeof listener === "undefined") {
+ for (i in eventType) {
+ if (_hasOwn.call(eventType, i) && typeof i === "string" && i && typeof eventType[i] === "function") {
+ ZeroClipboard.on(i, eventType[i]);
+ }
+ }
+ }
+ if (events && events.length) {
+ for (i = 0, len = events.length; i < len; i++) {
+ eventType = events[i].replace(/^on/, "");
+ added[eventType] = true;
+ if (!_handlers[eventType]) {
+ _handlers[eventType] = [];
+ }
+ _handlers[eventType].push(listener);
+ }
+ if (added.ready && _flashState.ready) {
+ ZeroClipboard.emit({
+ type: "ready"
+ });
+ }
+ if (added.error) {
+ for (i = 0, len = _flashStateErrorNames.length; i < len; i++) {
+ if (_flashState[_flashStateErrorNames[i].replace(/^flash-/, "")] === true) {
+ ZeroClipboard.emit({
+ type: "error",
+ name: _flashStateErrorNames[i]
+ });
+ break;
+ }
+ }
+ if (_zcSwfVersion !== undefined && ZeroClipboard.version !== _zcSwfVersion) {
+ ZeroClipboard.emit({
+ type: "error",
+ name: "version-mismatch",
+ jsVersion: ZeroClipboard.version,
+ swfVersion: _zcSwfVersion
+ });
+ }
+ }
+ }
+ return ZeroClipboard;
+ };
+ /**
+ * The underlying implementation of `ZeroClipboard.off`.
+ * @private
+ */
+ var _off = function(eventType, listener) {
+ var i, len, foundIndex, events, perEventHandlers;
+ if (arguments.length === 0) {
+ events = _keys(_handlers);
+ } else if (typeof eventType === "string" && eventType) {
+ events = eventType.split(/\s+/);
+ } else if (typeof eventType === "object" && eventType && typeof listener === "undefined") {
+ for (i in eventType) {
+ if (_hasOwn.call(eventType, i) && typeof i === "string" && i && typeof eventType[i] === "function") {
+ ZeroClipboard.off(i, eventType[i]);
+ }
+ }
+ }
+ if (events && events.length) {
+ for (i = 0, len = events.length; i < len; i++) {
+ eventType = events[i].toLowerCase().replace(/^on/, "");
+ perEventHandlers = _handlers[eventType];
+ if (perEventHandlers && perEventHandlers.length) {
+ if (listener) {
+ foundIndex = perEventHandlers.indexOf(listener);
+ while (foundIndex !== -1) {
+ perEventHandlers.splice(foundIndex, 1);
+ foundIndex = perEventHandlers.indexOf(listener, foundIndex);
+ }
+ } else {
+ perEventHandlers.length = 0;
+ }
+ }
+ }
+ }
+ return ZeroClipboard;
+ };
+ /**
+ * The underlying implementation of `ZeroClipboard.handlers`.
+ * @private
+ */
+ var _listeners = function(eventType) {
+ var copy;
+ if (typeof eventType === "string" && eventType) {
+ copy = _deepCopy(_handlers[eventType]) || null;
+ } else {
+ copy = _deepCopy(_handlers);
+ }
+ return copy;
+ };
+ /**
+ * The underlying implementation of `ZeroClipboard.emit`.
+ * @private
+ */
+ var _emit = function(event) {
+ var eventCopy, returnVal, tmp;
+ event = _createEvent(event);
+ if (!event) {
+ return;
+ }
+ if (_preprocessEvent(event)) {
+ return;
+ }
+ if (event.type === "ready" && _flashState.overdue === true) {
+ return ZeroClipboard.emit({
+ type: "error",
+ name: "flash-overdue"
+ });
+ }
+ eventCopy = _extend({}, event);
+ _dispatchCallbacks.call(this, eventCopy);
+ if (event.type === "copy") {
+ tmp = _mapClipDataToFlash(_clipData);
+ returnVal = tmp.data;
+ _clipDataFormatMap = tmp.formatMap;
+ }
+ return returnVal;
+ };
+ /**
+ * The underlying implementation of `ZeroClipboard.create`.
+ * @private
+ */
+ var _create = function() {
+ var previousState = _flashState.sandboxed;
+ _detectSandbox();
+ if (typeof _flashState.ready !== "boolean") {
+ _flashState.ready = false;
+ }
+ if (_flashState.sandboxed !== previousState && _flashState.sandboxed === true) {
+ _flashState.ready = false;
+ ZeroClipboard.emit({
+ type: "error",
+ name: "flash-sandboxed"
+ });
+ } else if (!ZeroClipboard.isFlashUnusable() && _flashState.bridge === null) {
+ var maxWait = _globalConfig.flashLoadTimeout;
+ if (typeof maxWait === "number" && maxWait >= 0) {
+ _flashCheckTimeout = _setTimeout(function() {
+ if (typeof _flashState.deactivated !== "boolean") {
+ _flashState.deactivated = true;
+ }
+ if (_flashState.deactivated === true) {
+ ZeroClipboard.emit({
+ type: "error",
+ name: "flash-deactivated"
+ });
+ }
+ }, maxWait);
+ }
+ _flashState.overdue = false;
+ _embedSwf();
+ }
+ };
+ /**
+ * The underlying implementation of `ZeroClipboard.destroy`.
+ * @private
+ */
+ var _destroy = function() {
+ ZeroClipboard.clearData();
+ ZeroClipboard.blur();
+ ZeroClipboard.emit("destroy");
+ _unembedSwf();
+ ZeroClipboard.off();
+ };
+ /**
+ * The underlying implementation of `ZeroClipboard.setData`.
+ * @private
+ */
+ var _setData = function(format, data) {
+ var dataObj;
+ if (typeof format === "object" && format && typeof data === "undefined") {
+ dataObj = format;
+ ZeroClipboard.clearData();
+ } else if (typeof format === "string" && format) {
+ dataObj = {};
+ dataObj[format] = data;
+ } else {
+ return;
+ }
+ for (var dataFormat in dataObj) {
+ if (typeof dataFormat === "string" && dataFormat && _hasOwn.call(dataObj, dataFormat) && typeof dataObj[dataFormat] === "string" && dataObj[dataFormat]) {
+ _clipData[dataFormat] = dataObj[dataFormat];
+ }
+ }
+ };
+ /**
+ * The underlying implementation of `ZeroClipboard.clearData`.
+ * @private
+ */
+ var _clearData = function(format) {
+ if (typeof format === "undefined") {
+ _deleteOwnProperties(_clipData);
+ _clipDataFormatMap = null;
+ } else if (typeof format === "string" && _hasOwn.call(_clipData, format)) {
+ delete _clipData[format];
+ }
+ };
+ /**
+ * The underlying implementation of `ZeroClipboard.getData`.
+ * @private
+ */
+ var _getData = function(format) {
+ if (typeof format === "undefined") {
+ return _deepCopy(_clipData);
+ } else if (typeof format === "string" && _hasOwn.call(_clipData, format)) {
+ return _clipData[format];
+ }
+ };
+ /**
+ * The underlying implementation of `ZeroClipboard.focus`/`ZeroClipboard.activate`.
+ * @private
+ */
+ var _focus = function(element) {
+ if (!(element && element.nodeType === 1)) {
+ return;
+ }
+ if (_currentElement) {
+ _removeClass(_currentElement, _globalConfig.activeClass);
+ if (_currentElement !== element) {
+ _removeClass(_currentElement, _globalConfig.hoverClass);
+ }
+ }
+ _currentElement = element;
+ _addClass(element, _globalConfig.hoverClass);
+ var newTitle = element.getAttribute("title") || _globalConfig.title;
+ if (typeof newTitle === "string" && newTitle) {
+ var htmlBridge = _getHtmlBridge(_flashState.bridge);
+ if (htmlBridge) {
+ htmlBridge.setAttribute("title", newTitle);
+ }
+ }
+ var useHandCursor = _globalConfig.forceHandCursor === true || _getStyle(element, "cursor") === "pointer";
+ _setHandCursor(useHandCursor);
+ _reposition();
+ };
+ /**
+ * The underlying implementation of `ZeroClipboard.blur`/`ZeroClipboard.deactivate`.
+ * @private
+ */
+ var _blur = function() {
+ var htmlBridge = _getHtmlBridge(_flashState.bridge);
+ if (htmlBridge) {
+ htmlBridge.removeAttribute("title");
+ htmlBridge.style.left = "0px";
+ htmlBridge.style.top = "-9999px";
+ htmlBridge.style.width = "1px";
+ htmlBridge.style.height = "1px";
+ }
+ if (_currentElement) {
+ _removeClass(_currentElement, _globalConfig.hoverClass);
+ _removeClass(_currentElement, _globalConfig.activeClass);
+ _currentElement = null;
+ }
+ };
+ /**
+ * The underlying implementation of `ZeroClipboard.activeElement`.
+ * @private
+ */
+ var _activeElement = function() {
+ return _currentElement || null;
+ };
+ /**
+ * Check if a value is a valid HTML4 `ID` or `Name` token.
+ * @private
+ */
+ var _isValidHtml4Id = function(id) {
+ return typeof id === "string" && id && /^[A-Za-z][A-Za-z0-9_:\-\.]*$/.test(id);
+ };
+ /**
+ * Create or update an `event` object, based on the `eventType`.
+ * @private
+ */
+ var _createEvent = function(event) {
+ var eventType;
+ if (typeof event === "string" && event) {
+ eventType = event;
+ event = {};
+ } else if (typeof event === "object" && event && typeof event.type === "string" && event.type) {
+ eventType = event.type;
+ }
+ if (!eventType) {
+ return;
+ }
+ eventType = eventType.toLowerCase();
+ if (!event.target && (/^(copy|aftercopy|_click)$/.test(eventType) || eventType === "error" && event.name === "clipboard-error")) {
+ event.target = _copyTarget;
+ }
+ _extend(event, {
+ type: eventType,
+ target: event.target || _currentElement || null,
+ relatedTarget: event.relatedTarget || null,
+ currentTarget: _flashState && _flashState.bridge || null,
+ timeStamp: event.timeStamp || _now() || null
+ });
+ var msg = _eventMessages[event.type];
+ if (event.type === "error" && event.name && msg) {
+ msg = msg[event.name];
+ }
+ if (msg) {
+ event.message = msg;
+ }
+ if (event.type === "ready") {
+ _extend(event, {
+ target: null,
+ version: _flashState.version
+ });
+ }
+ if (event.type === "error") {
+ if (_flashStateErrorNameMatchingRegex.test(event.name)) {
+ _extend(event, {
+ target: null,
+ minimumVersion: _minimumFlashVersion
+ });
+ }
+ if (_flashStateEnabledErrorNameMatchingRegex.test(event.name)) {
+ _extend(event, {
+ version: _flashState.version
+ });
+ }
+ }
+ if (event.type === "copy") {
+ event.clipboardData = {
+ setData: ZeroClipboard.setData,
+ clearData: ZeroClipboard.clearData
+ };
+ }
+ if (event.type === "aftercopy") {
+ event = _mapClipResultsFromFlash(event, _clipDataFormatMap);
+ }
+ if (event.target && !event.relatedTarget) {
+ event.relatedTarget = _getRelatedTarget(event.target);
+ }
+ return _addMouseData(event);
+ };
+ /**
+ * Get a relatedTarget from the target's `data-clipboard-target` attribute
+ * @private
+ */
+ var _getRelatedTarget = function(targetEl) {
+ var relatedTargetId = targetEl && targetEl.getAttribute && targetEl.getAttribute("data-clipboard-target");
+ return relatedTargetId ? _document.getElementById(relatedTargetId) : null;
+ };
+ /**
+ * Add element and position data to `MouseEvent` instances
+ * @private
+ */
+ var _addMouseData = function(event) {
+ if (event && /^_(?:click|mouse(?:over|out|down|up|move))$/.test(event.type)) {
+ var srcElement = event.target;
+ var fromElement = event.type === "_mouseover" && event.relatedTarget ? event.relatedTarget : undefined;
+ var toElement = event.type === "_mouseout" && event.relatedTarget ? event.relatedTarget : undefined;
+ var pos = _getElementPosition(srcElement);
+ var screenLeft = _window.screenLeft || _window.screenX || 0;
+ var screenTop = _window.screenTop || _window.screenY || 0;
+ var scrollLeft = _document.body.scrollLeft + _document.documentElement.scrollLeft;
+ var scrollTop = _document.body.scrollTop + _document.documentElement.scrollTop;
+ var pageX = pos.left + (typeof event._stageX === "number" ? event._stageX : 0);
+ var pageY = pos.top + (typeof event._stageY === "number" ? event._stageY : 0);
+ var clientX = pageX - scrollLeft;
+ var clientY = pageY - scrollTop;
+ var screenX = screenLeft + clientX;
+ var screenY = screenTop + clientY;
+ var moveX = typeof event.movementX === "number" ? event.movementX : 0;
+ var moveY = typeof event.movementY === "number" ? event.movementY : 0;
+ delete event._stageX;
+ delete event._stageY;
+ _extend(event, {
+ srcElement: srcElement,
+ fromElement: fromElement,
+ toElement: toElement,
+ screenX: screenX,
+ screenY: screenY,
+ pageX: pageX,
+ pageY: pageY,
+ clientX: clientX,
+ clientY: clientY,
+ x: clientX,
+ y: clientY,
+ movementX: moveX,
+ movementY: moveY,
+ offsetX: 0,
+ offsetY: 0,
+ layerX: 0,
+ layerY: 0
+ });
+ }
+ return event;
+ };
+ /**
+ * Determine if an event's registered handlers should be execute synchronously or asynchronously.
+ *
+ * @returns {boolean}
+ * @private
+ */
+ var _shouldPerformAsync = function(event) {
+ var eventType = event && typeof event.type === "string" && event.type || "";
+ return !/^(?:(?:before)?copy|destroy)$/.test(eventType);
+ };
+ /**
+ * Control if a callback should be executed asynchronously or not.
+ *
+ * @returns `undefined`
+ * @private
+ */
+ var _dispatchCallback = function(func, context, args, async) {
+ if (async) {
+ _setTimeout(function() {
+ func.apply(context, args);
+ }, 0);
+ } else {
+ func.apply(context, args);
+ }
+ };
+ /**
+ * Handle the actual dispatching of events to client instances.
+ *
+ * @returns `undefined`
+ * @private
+ */
+ var _dispatchCallbacks = function(event) {
+ if (!(typeof event === "object" && event && event.type)) {
+ return;
+ }
+ var async = _shouldPerformAsync(event);
+ var wildcardTypeHandlers = _handlers["*"] || [];
+ var specificTypeHandlers = _handlers[event.type] || [];
+ var handlers = wildcardTypeHandlers.concat(specificTypeHandlers);
+ if (handlers && handlers.length) {
+ var i, len, func, context, eventCopy, originalContext = this;
+ for (i = 0, len = handlers.length; i < len; i++) {
+ func = handlers[i];
+ context = originalContext;
+ if (typeof func === "string" && typeof _window[func] === "function") {
+ func = _window[func];
+ }
+ if (typeof func === "object" && func && typeof func.handleEvent === "function") {
+ context = func;
+ func = func.handleEvent;
+ }
+ if (typeof func === "function") {
+ eventCopy = _extend({}, event);
+ _dispatchCallback(func, context, [ eventCopy ], async);
+ }
+ }
+ }
+ return this;
+ };
+ /**
+ * Check an `error` event's `name` property to see if Flash has
+ * already loaded, which rules out possible `iframe` sandboxing.
+ * @private
+ */
+ var _getSandboxStatusFromErrorEvent = function(event) {
+ var isSandboxed = null;
+ if (_pageIsFramed === false || event && event.type === "error" && event.name && _errorsThatOnlyOccurAfterFlashLoads.indexOf(event.name) !== -1) {
+ isSandboxed = false;
+ }
+ return isSandboxed;
+ };
+ /**
+ * Preprocess any special behaviors, reactions, or state changes after receiving this event.
+ * Executes only once per event emitted, NOT once per client.
+ * @private
+ */
+ var _preprocessEvent = function(event) {
+ var element = event.target || _currentElement || null;
+ var sourceIsSwf = event._source === "swf";
+ delete event._source;
+ switch (event.type) {
+ case "error":
+ var isSandboxed = event.name === "flash-sandboxed" || _getSandboxStatusFromErrorEvent(event);
+ if (typeof isSandboxed === "boolean") {
+ _flashState.sandboxed = isSandboxed;
+ }
+ if (_flashStateErrorNames.indexOf(event.name) !== -1) {
+ _extend(_flashState, {
+ disabled: event.name === "flash-disabled",
+ outdated: event.name === "flash-outdated",
+ unavailable: event.name === "flash-unavailable",
+ degraded: event.name === "flash-degraded",
+ deactivated: event.name === "flash-deactivated",
+ overdue: event.name === "flash-overdue",
+ ready: false
+ });
+ } else if (event.name === "version-mismatch") {
+ _zcSwfVersion = event.swfVersion;
+ _extend(_flashState, {
+ disabled: false,
+ outdated: false,
+ unavailable: false,
+ degraded: false,
+ deactivated: false,
+ overdue: false,
+ ready: false
+ });
+ }
+ _clearTimeoutsAndPolling();
+ break;
+
+ case "ready":
+ _zcSwfVersion = event.swfVersion;
+ var wasDeactivated = _flashState.deactivated === true;
+ _extend(_flashState, {
+ disabled: false,
+ outdated: false,
+ sandboxed: false,
+ unavailable: false,
+ degraded: false,
+ deactivated: false,
+ overdue: wasDeactivated,
+ ready: !wasDeactivated
+ });
+ _clearTimeoutsAndPolling();
+ break;
+
+ case "beforecopy":
+ _copyTarget = element;
+ break;
+
+ case "copy":
+ var textContent, htmlContent, targetEl = event.relatedTarget;
+ if (!(_clipData["text/html"] || _clipData["text/plain"]) && targetEl && (htmlContent = targetEl.value || targetEl.outerHTML || targetEl.innerHTML) && (textContent = targetEl.value || targetEl.textContent || targetEl.innerText)) {
+ event.clipboardData.clearData();
+ event.clipboardData.setData("text/plain", textContent);
+ if (htmlContent !== textContent) {
+ event.clipboardData.setData("text/html", htmlContent);
+ }
+ } else if (!_clipData["text/plain"] && event.target && (textContent = event.target.getAttribute("data-clipboard-text"))) {
+ event.clipboardData.clearData();
+ event.clipboardData.setData("text/plain", textContent);
+ }
+ break;
+
+ case "aftercopy":
+ _queueEmitClipboardErrors(event);
+ ZeroClipboard.clearData();
+ if (element && element !== _safeActiveElement() && element.focus) {
+ element.focus();
+ }
+ break;
+
+ case "_mouseover":
+ ZeroClipboard.focus(element);
+ if (_globalConfig.bubbleEvents === true && sourceIsSwf) {
+ if (element && element !== event.relatedTarget && !_containedBy(event.relatedTarget, element)) {
+ _fireMouseEvent(_extend({}, event, {
+ type: "mouseenter",
+ bubbles: false,
+ cancelable: false
+ }));
+ }
+ _fireMouseEvent(_extend({}, event, {
+ type: "mouseover"
+ }));
+ }
+ break;
+
+ case "_mouseout":
+ ZeroClipboard.blur();
+ if (_globalConfig.bubbleEvents === true && sourceIsSwf) {
+ if (element && element !== event.relatedTarget && !_containedBy(event.relatedTarget, element)) {
+ _fireMouseEvent(_extend({}, event, {
+ type: "mouseleave",
+ bubbles: false,
+ cancelable: false
+ }));
+ }
+ _fireMouseEvent(_extend({}, event, {
+ type: "mouseout"
+ }));
+ }
+ break;
+
+ case "_mousedown":
+ _addClass(element, _globalConfig.activeClass);
+ if (_globalConfig.bubbleEvents === true && sourceIsSwf) {
+ _fireMouseEvent(_extend({}, event, {
+ type: event.type.slice(1)
+ }));
+ }
+ break;
+
+ case "_mouseup":
+ _removeClass(element, _globalConfig.activeClass);
+ if (_globalConfig.bubbleEvents === true && sourceIsSwf) {
+ _fireMouseEvent(_extend({}, event, {
+ type: event.type.slice(1)
+ }));
+ }
+ break;
+
+ case "_click":
+ _copyTarget = null;
+ if (_globalConfig.bubbleEvents === true && sourceIsSwf) {
+ _fireMouseEvent(_extend({}, event, {
+ type: event.type.slice(1)
+ }));
+ }
+ break;
+
+ case "_mousemove":
+ if (_globalConfig.bubbleEvents === true && sourceIsSwf) {
+ _fireMouseEvent(_extend({}, event, {
+ type: event.type.slice(1)
+ }));
+ }
+ break;
+ }
+ if (/^_(?:click|mouse(?:over|out|down|up|move))$/.test(event.type)) {
+ return true;
+ }
+ };
+ /**
+ * Check an "aftercopy" event for clipboard errors and emit a corresponding "error" event.
+ * @private
+ */
+ var _queueEmitClipboardErrors = function(aftercopyEvent) {
+ if (aftercopyEvent.errors && aftercopyEvent.errors.length > 0) {
+ var errorEvent = _deepCopy(aftercopyEvent);
+ _extend(errorEvent, {
+ type: "error",
+ name: "clipboard-error"
+ });
+ delete errorEvent.success;
+ _setTimeout(function() {
+ ZeroClipboard.emit(errorEvent);
+ }, 0);
+ }
+ };
+ /**
+ * Dispatch a synthetic MouseEvent.
+ *
+ * @returns `undefined`
+ * @private
+ */
+ var _fireMouseEvent = function(event) {
+ if (!(event && typeof event.type === "string" && event)) {
+ return;
+ }
+ var e, target = event.target || null, doc = target && target.ownerDocument || _document, defaults = {
+ view: doc.defaultView || _window,
+ canBubble: true,
+ cancelable: true,
+ detail: event.type === "click" ? 1 : 0,
+ button: typeof event.which === "number" ? event.which - 1 : typeof event.button === "number" ? event.button : doc.createEvent ? 0 : 1
+ }, args = _extend(defaults, event);
+ if (!target) {
+ return;
+ }
+ if (doc.createEvent && target.dispatchEvent) {
+ args = [ args.type, args.canBubble, args.cancelable, args.view, args.detail, args.screenX, args.screenY, args.clientX, args.clientY, args.ctrlKey, args.altKey, args.shiftKey, args.metaKey, args.button, args.relatedTarget ];
+ e = doc.createEvent("MouseEvents");
+ if (e.initMouseEvent) {
+ e.initMouseEvent.apply(e, args);
+ e._source = "js";
+ target.dispatchEvent(e);
+ }
+ }
+ };
+ /**
+ * Continuously poll the DOM until either:
+ * (a) the fallback content becomes visible, or
+ * (b) we receive an event from SWF (handled elsewhere)
+ *
+ * IMPORTANT:
+ * This is NOT a necessary check but it can result in significantly faster
+ * detection of bad `swfPath` configuration and/or network/server issues [in
+ * supported browsers] than waiting for the entire `flashLoadTimeout` duration
+ * to elapse before detecting that the SWF cannot be loaded. The detection
+ * duration can be anywhere from 10-30 times faster [in supported browsers] by
+ * using this approach.
+ *
+ * @returns `undefined`
+ * @private
+ */
+ var _watchForSwfFallbackContent = function() {
+ var maxWait = _globalConfig.flashLoadTimeout;
+ if (typeof maxWait === "number" && maxWait >= 0) {
+ var pollWait = Math.min(1e3, maxWait / 10);
+ var fallbackContentId = _globalConfig.swfObjectId + "_fallbackContent";
+ _swfFallbackCheckInterval = _setInterval(function() {
+ var el = _document.getElementById(fallbackContentId);
+ if (_isElementVisible(el)) {
+ _clearTimeoutsAndPolling();
+ _flashState.deactivated = null;
+ ZeroClipboard.emit({
+ type: "error",
+ name: "swf-not-found"
+ });
+ }
+ }, pollWait);
+ }
+ };
+ /**
+ * Create the HTML bridge element to embed the Flash object into.
+ * @private
+ */
+ var _createHtmlBridge = function() {
+ var container = _document.createElement("div");
+ container.id = _globalConfig.containerId;
+ container.className = _globalConfig.containerClass;
+ container.style.position = "absolute";
+ container.style.left = "0px";
+ container.style.top = "-9999px";
+ container.style.width = "1px";
+ container.style.height = "1px";
+ container.style.zIndex = "" + _getSafeZIndex(_globalConfig.zIndex);
+ return container;
+ };
+ /**
+ * Get the HTML element container that wraps the Flash bridge object/element.
+ * @private
+ */
+ var _getHtmlBridge = function(flashBridge) {
+ var htmlBridge = flashBridge && flashBridge.parentNode;
+ while (htmlBridge && htmlBridge.nodeName === "OBJECT" && htmlBridge.parentNode) {
+ htmlBridge = htmlBridge.parentNode;
+ }
+ return htmlBridge || null;
+ };
+ /**
+ * Create the SWF object.
+ *
+ * @returns The SWF object reference.
+ * @private
+ */
+ var _embedSwf = function() {
+ var len, flashBridge = _flashState.bridge, container = _getHtmlBridge(flashBridge);
+ if (!flashBridge) {
+ var allowScriptAccess = _determineScriptAccess(_window.location.host, _globalConfig);
+ var allowNetworking = allowScriptAccess === "never" ? "none" : "all";
+ var flashvars = _vars(_extend({
+ jsVersion: ZeroClipboard.version
+ }, _globalConfig));
+ var swfUrl = _globalConfig.swfPath + _cacheBust(_globalConfig.swfPath, _globalConfig);
+ container = _createHtmlBridge();
+ var divToBeReplaced = _document.createElement("div");
+ container.appendChild(divToBeReplaced);
+ _document.body.appendChild(container);
+ var tmpDiv = _document.createElement("div");
+ var usingActiveX = _flashState.pluginType === "activex";
+ tmpDiv.innerHTML = '
- * @constructor
- */
-function EditTableColumnMove() {
- var pressed,
- startCol,
- endCol,
- startX,
- startOffset;
-
- var ghost = document.createElement('DIV'),
- ghostStyle = ghost.style;
-
- ghost.className = 'ghost';
- ghostStyle.position = 'absolute';
- ghostStyle.top = '25px';
- ghostStyle.left = 0;
- ghostStyle.width = '10px';
- ghostStyle.height = '10px';
- ghostStyle.backgroundColor = '#CCC';
- ghostStyle.opacity = 0.7;
-
- /**
- * Attach all the events
- */
- var bindMoveColEvents = function () {
- var instance = this;
-
- /**
- * during drag operation
- */
- instance.rootElement.on('mousemove.editTableColumnMove', function (e) {
- if (pressed) {
- ghostStyle.left = startOffset + e.pageX - startX + 6 + 'px';
- if (ghostStyle.display === 'none') {
- ghostStyle.display = 'block';
- }
- }
- });
-
- /**
- * end of drag operation
- *
- * The column move is executed here
- */
- instance.rootElement.on('mouseup.editTableColumnMove', function () {
- if (pressed) {
- if (startCol < endCol) {
- endCol--;
- }
- if (instance.getSettings().rowHeaders) {
- startCol--;
- endCol--;
- }
- jQuery('.editTableColumnMover.active').removeClass('active');
- pressed = false;
- ghostStyle.display = 'none';
-
- if (startCol == endCol) return;
-
- // if this row is part of a row span, do not move
- if (instance.raw.colinfo[endCol].colspan) return;
-
- // swap cols in each row
- for (var i = 0; i < instance.raw.data.length; i++) {
- instance.raw.data[i].splice(endCol, 0, instance.raw.data[i].splice(startCol, 1)[0]);
- instance.raw.meta[i].splice(endCol, 0, instance.raw.meta[i].splice(startCol, 1)[0]);
- }
-
- instance.forceFullRender = true;
- instance.view.render(); //updates all
- }
- });
-
- /**
- * start drag operation
- */
- instance.rootElement.on('mousedown.editTableColumnMove', '.editTableColumnMover', function (e) {
-
- var mover = e.currentTarget;
- var TH = instance.view.wt.wtDom.closest(mover, 'TH');
- startCol = instance.view.wt.wtDom.index(TH) + instance.colOffset();
- endCol = startCol;
- pressed = true;
- startX = e.pageX;
-
- var TABLE = instance.$table[0];
- TABLE.parentNode.appendChild(ghost);
- ghostStyle.width = instance.view.wt.wtDom.outerWidth(TH) + 'px';
- ghostStyle.height = instance.view.wt.wtDom.outerHeight(TABLE) + 'px';
- startOffset = parseInt(instance.view.wt.wtDom.offset(TH).left - instance.view.wt.wtDom.offset(TABLE).left, 10);
- ghostStyle.left = startOffset + 6 + 'px';
- });
-
- /**
- * on mouseover, show drag handle
- */
- instance.rootElement.on('mouseenter.editTableColumnMove', 'td, th', function () {
- if (pressed) {
- var active = instance.view.THEAD.querySelector('.editTableColumnMover.active');
- if (active) {
- instance.view.wt.wtDom.removeClass(active, 'active');
- }
- endCol = instance.view.wt.wtDom.index(this) + instance.colOffset();
-
- // if this row is part of a row span, do not move
- if (instance.raw.colinfo[endCol - 1].colspan) return;
-
- var THs = instance.view.THEAD.querySelectorAll('th');
- var mover = THs[endCol].querySelector('.editTableColumnMover');
- instance.view.wt.wtDom.addClass(mover, 'active');
- }
- });
-
- instance.addHook('afterDestroy', unbindMoveColEvents);
- };
-
- /**
- * Remove all the Events
- */
- var unbindMoveColEvents = function () {
- var instance = this;
- instance.rootElement.off('mouseup.editTableColumnMove');
- instance.rootElement.off('mousemove.editTableColumnMove');
- instance.rootElement.off('mousedown.editTableColumnMove');
- instance.rootElement.off('mouseenter.editTableColumnMove');
- };
-
- /**
- * Initialize the plugin
- */
- this.init = function () {
- var instance = this;
- var editTableColMoveEnabled = !!(this.getSettings().editTableColumnMove);
-
- if (editTableColMoveEnabled) {
- instance.forceFullRender = true;
- bindMoveColEvents.call(this);
-
- } else {
- unbindMoveColEvents.call(this);
- }
- };
-
- /**
- * Add a move handler to each column head
- *
- * @param col
- * @param TH
- */
- this.getColHeader = function (col, TH) {
- if (this.getSettings().editTableColumnMove) {
- // if this col is part of a col span, do not add move handle
- if (this.raw.colinfo[col].colspan) return;
-
- var DIV = document.createElement('DIV');
- DIV.className = 'editTableColumnMover';
- TH.firstChild.appendChild(DIV);
- }
- };
-}
-
-var htEditTableColumnMove = new EditTableColumnMove();
-
-Handsontable.PluginHooks.add('afterInit', function () {
- htEditTableColumnMove.init.call(this);
-});
-
-Handsontable.PluginHooks.add('afterGetColHeader', htEditTableColumnMove.getColHeader);
diff --git a/script/jquery.handsontable.full.js b/script/jquery.handsontable.full.js
deleted file mode 100644
index 0cc08a9..0000000
--- a/script/jquery.handsontable.full.js
+++ /dev/null
@@ -1,14266 +0,0 @@
-/**
- * Handsontable 0.10.1
- * Handsontable is a simple jQuery plugin for editable tables with basic copy-paste compatibility with Excel and Google Docs
- *
- * Copyright 2012, Marcin Warpechowski
- * Licensed under the MIT license.
- * http://handsontable.com/
- *
- * Date: Wed May 14 2014 15:53:30 GMT+0200 (CEST)
- */
-/*jslint white: true, browser: true, plusplus: true, indent: 4, maxerr: 50 */
-
-var Handsontable = { //class namespace
- extension: {}, //extenstion namespace
- helper: {} //helper namespace
-};
-
-(function ($, window, Handsontable) {
- "use strict";
-//http://stackoverflow.com/questions/3629183/why-doesnt-indexof-work-on-an-array-ie8
-if (!Array.prototype.indexOf) {
- Array.prototype.indexOf = function (elt /*, from*/) {
- var len = this.length >>> 0;
-
- var from = Number(arguments[1]) || 0;
- from = (from < 0)
- ? Math.ceil(from)
- : Math.floor(from);
- if (from < 0)
- from += len;
-
- for (; from < len; from++) {
- if (from in this &&
- this[from] === elt)
- return from;
- }
- return -1;
- };
-}
-/**
- * Array.filter() shim by Trevor Menagh (https://github.com/trevmex) with some modifications
- */
-
-if (!Array.prototype.filter) {
- Array.prototype.filter = function (fun, thisp) {
- "use strict";
-
- if (typeof this === "undefined" || this === null) {
- throw new TypeError();
- }
- if (typeof fun !== "function") {
- throw new TypeError();
- }
-
- thisp = thisp || this;
-
- if (isNodeList(thisp)) {
- thisp = convertNodeListToArray(thisp);
- }
-
- var len = thisp.length,
- res = [],
- i,
- val;
-
- for (i = 0; i < len; i += 1) {
- if (thisp.hasOwnProperty(i)) {
- val = thisp[i]; // in case fun mutates this
- if (fun.call(thisp, val, i, thisp)) {
- res.push(val);
- }
- }
- }
-
- return res;
-
- function isNodeList(object) {
- return /NodeList/i.test(object.item);
- }
-
- function convertNodeListToArray(nodeList) {
- var array = [];
-
- for (var i = 0, len = nodeList.length; i < len; i++){
- array[i] = nodeList[i]
- }
-
- return array;
- }
- };
-}
-
-/*
- * Copyright 2012 The Polymer Authors. All rights reserved.
- * Use of this source code is governed by a BSD-style
- * license that can be found in the LICENSE file.
- */
-
-if (typeof WeakMap === 'undefined') {
- (function() {
- var defineProperty = Object.defineProperty;
-
- try {
- var properDefineProperty = true;
- defineProperty(function(){}, 'foo', {});
- } catch (e) {
- properDefineProperty = false;
- }
-
- /*
- IE8 does not support Date.now() but IE8 compatibility mode in IE9 and IE10 does.
- M$ deserves a high five for this one :)
- */
- var counter = +(new Date) % 1e9;
-
- var WeakMap = function() {
- this.name = '__st' + (Math.random() * 1e9 >>> 0) + (counter++ + '__');
- if(!properDefineProperty){
- this._wmCache = [];
- }
- };
-
- if(properDefineProperty){
- WeakMap.prototype = {
- set: function(key, value) {
- var entry = key[this.name];
- if (entry && entry[0] === key)
- entry[1] = value;
- else
- defineProperty(key, this.name, {value: [key, value], writable: true});
-
- },
- get: function(key) {
- var entry;
- return (entry = key[this.name]) && entry[0] === key ?
- entry[1] : undefined;
- },
- 'delete': function(key) {
- this.set(key, undefined);
- }
- };
- } else {
- WeakMap.prototype = {
- set: function(key, value) {
-
- if(typeof key == 'undefined' || typeof value == 'undefined') return;
-
- for(var i = 0, len = this._wmCache.length; i < len; i++){
- if(this._wmCache[i].key == key){
- this._wmCache[i].value = value;
- return;
- }
- }
-
- this._wmCache.push({key: key, value: value});
-
- },
- get: function(key) {
-
- if(typeof key == 'undefined') return;
-
- for(var i = 0, len = this._wmCache.length; i < len; i++){
- if(this._wmCache[i].key == key){
- return this._wmCache[i].value;
- }
- }
-
- return;
-
- },
- 'delete': function(key) {
-
- if(typeof key == 'undefined') return;
-
- for(var i = 0, len = this._wmCache.length; i < len; i++){
- if(this._wmCache[i].key == key){
- Array.prototype.slice.call(this._wmCache, i, 1);
- }
- }
- }
- };
- }
-
- window.WeakMap = WeakMap;
- })();
-}
-
-Handsontable.activeGuid = null;
-
-/**
- * Handsontable constructor
- * @param rootElement The jQuery element in which Handsontable DOM will be inserted
- * @param userSettings
- * @constructor
- */
-Handsontable.Core = function (rootElement, userSettings) {
- var priv
- , datamap
- , grid
- , selection
- , editorManager
- , autofill
- , instance = this
- , GridSettings = function () {};
-
- Handsontable.helper.extend(GridSettings.prototype, DefaultSettings.prototype); //create grid settings as a copy of default settings
- Handsontable.helper.extend(GridSettings.prototype, userSettings); //overwrite defaults with user settings
- Handsontable.helper.extend(GridSettings.prototype, expandType(userSettings));
-
- this.rootElement = rootElement;
- var $document = $(document.documentElement);
- var $body = $(document.body);
- this.guid = 'ht_' + Handsontable.helper.randomString(); //this is the namespace for global events
-
- if (!this.rootElement[0].id) {
- this.rootElement[0].id = this.guid; //if root element does not have an id, assign a random id
- }
-
- priv = {
- cellSettings: [],
- columnSettings: [],
- columnsSettingConflicts: ['data', 'width'],
- settings: new GridSettings(), // current settings instance
- settingsFromDOM: {},
- selStart: new Handsontable.SelectionPoint(),
- selEnd: new Handsontable.SelectionPoint(),
- isPopulated: null,
- scrollable: null,
- extensions: {},
- colToProp: null,
- propToCol: null,
- dataSchema: null,
- dataType: 'array',
- firstRun: true
- };
-
- datamap = {
- recursiveDuckSchema: function (obj) {
- var schema;
- if ($.isPlainObject(obj)) {
- schema = {};
- for (var i in obj) {
- if (obj.hasOwnProperty(i)) {
- if ($.isPlainObject(obj[i])) {
- schema[i] = datamap.recursiveDuckSchema(obj[i]);
- }
- else {
- schema[i] = null;
- }
- }
- }
- }
- else {
- schema = [];
- }
- return schema;
- },
-
- recursiveDuckColumns: function (schema, lastCol, parent) {
- var prop, i;
- if (typeof lastCol === 'undefined') {
- lastCol = 0;
- parent = '';
- }
- if ($.isPlainObject(schema)) {
- for (i in schema) {
- if (schema.hasOwnProperty(i)) {
- if (schema[i] === null) {
- prop = parent + i;
- priv.colToProp.push(prop);
- priv.propToCol[prop] = lastCol;
- lastCol++;
- }
- else {
- lastCol = datamap.recursiveDuckColumns(schema[i], lastCol, i + '.');
- }
- }
- }
- }
- return lastCol;
- },
-
- createMap: function () {
- if (typeof datamap.getSchema() === "undefined") {
- throw new Error("trying to create `columns` definition but you didnt' provide `schema` nor `data`");
- }
- var i, ilen, schema = datamap.getSchema();
- priv.colToProp = [];
- priv.propToCol = {};
- if (priv.settings.columns) {
- for (i = 0, ilen = priv.settings.columns.length; i < ilen; i++) {
- priv.colToProp[i] = priv.settings.columns[i].data;
- priv.propToCol[priv.settings.columns[i].data] = i;
- }
- }
- else {
- datamap.recursiveDuckColumns(schema);
- }
- },
-
- colToProp: function (col) {
- col = Handsontable.PluginHooks.execute(instance, 'modifyCol', col);
- if (priv.colToProp && typeof priv.colToProp[col] !== 'undefined') {
- return priv.colToProp[col];
- }
- else {
- return col;
- }
- },
-
- propToCol: function (prop) {
- var col;
- if (typeof priv.propToCol[prop] !== 'undefined') {
- col = priv.propToCol[prop];
- }
- else {
- col = prop;
- }
- col = Handsontable.PluginHooks.execute(instance, 'modifyCol', col);
- return col;
- },
-
- getSchema: function () {
- if (priv.settings.dataSchema) {
- if (typeof priv.settings.dataSchema === 'function') {
- return priv.settings.dataSchema();
- }
- return priv.settings.dataSchema;
- }
- return priv.duckDataSchema;
- },
-
- /**
- * Creates row at the bottom of the data array
- * @param {Number} [index] Optional. Index of the row before which the new row will be inserted
- */
- createRow: function (index, amount) {
- var row
- , colCount = instance.countCols()
- , numberOfCreatedRows = 0
- , currentIndex;
-
- if (!amount) {
- amount = 1;
- }
-
- if (typeof index !== 'number' || index >= instance.countRows()) {
- index = instance.countRows();
- }
-
- currentIndex = index;
- while (numberOfCreatedRows < amount && instance.countRows() < priv.settings.maxRows) {
-
- if (priv.dataType === 'array') {
- row = [];
- for (var c = 0; c < colCount; c++) {
- row.push(null);
- }
- }
- else if (priv.dataType === 'function') {
- row = priv.settings.dataSchema(index);
- }
- else {
- row = $.extend(true, {}, datamap.getSchema());
- }
-
- if (index === instance.countRows()) {
- GridSettings.prototype.data.push(row);
- }
- else {
- GridSettings.prototype.data.splice(index, 0, row);
- }
-
- numberOfCreatedRows++;
- currentIndex++;
- }
-
-
- instance.PluginHooks.run('afterCreateRow', index, numberOfCreatedRows);
- instance.forceFullRender = true; //used when data was changed
-
- return numberOfCreatedRows;
- },
-
- /**
- * Creates col at the right of the data array
- * @param {Number} [index] Optional. Index of the column before which the new column will be inserted
- * * @param {Number} [amount] Optional.
- */
- createCol: function (index, amount) {
- if (priv.dataType === 'object' || priv.settings.columns) {
- throw new Error("Cannot create new column. When data source in an object, " +
- "you can only have as much columns as defined in first data row, data schema or in the 'columns' setting." +
- "If you want to be able to add new columns, you have to use array datasource.");
- }
- var rlen = instance.countRows()
- , data = GridSettings.prototype.data
- , constructor
- , numberOfCreatedCols = 0
- , currentIndex;
-
- if (!amount) {
- amount = 1;
- }
-
- currentIndex = index;
-
- while (numberOfCreatedCols < amount && instance.countCols() < priv.settings.maxCols){
- constructor = Handsontable.helper.columnFactory(GridSettings, priv.columnsSettingConflicts);
- if (typeof index !== 'number' || index >= instance.countCols()) {
- for (var r = 0; r < rlen; r++) {
- if (typeof data[r] === 'undefined') {
- data[r] = [];
- }
- data[r].push(null);
- }
- // Add new column constructor
- priv.columnSettings.push(constructor);
- }
- else {
- for (var r = 0 ; r < rlen; r++) {
- data[r].splice(currentIndex, 0, null);
- }
- // Add new column constructor at given index
- priv.columnSettings.splice(currentIndex, 0, constructor);
- }
-
- numberOfCreatedCols++;
- currentIndex++;
- }
-
- instance.PluginHooks.run('afterCreateCol', index, numberOfCreatedCols);
- instance.forceFullRender = true; //used when data was changed
-
- return numberOfCreatedCols;
- },
-
- /**
- * Removes row from the data array
- * @param {Number} [index] Optional. Index of the row to be removed. If not provided, the last row will be removed
- * @param {Number} [amount] Optional. Amount of the rows to be removed. If not provided, one row will be removed
- */
- removeRow: function (index, amount) {
- if (!amount) {
- amount = 1;
- }
- if (typeof index !== 'number') {
- index = -amount;
- }
-
- index = (instance.countRows() + index) % instance.countRows();
-
- // We have to map the physical row ids to logical and than perform removing with (possibly) new row id
- var logicRows = this.physicalRowsToLogical(index, amount);
-
- var actionWasNotCancelled = instance.PluginHooks.execute('beforeRemoveRow', index, amount);
-
- if(actionWasNotCancelled === false){
- return;
- }
-
- var newData = GridSettings.prototype.data.filter(function (row, index) {
- return logicRows.indexOf(index) == -1;
- });
-
- GridSettings.prototype.data.length = 0;
- Array.prototype.push.apply(GridSettings.prototype.data, newData);
-
- instance.PluginHooks.run('afterRemoveRow', index, amount);
-
- instance.forceFullRender = true; //used when data was changed
- },
-
- /**
- * Removes column from the data array
- * @param {Number} [index] Optional. Index of the column to be removed. If not provided, the last column will be removed
- * @param {Number} [amount] Optional. Amount of the columns to be removed. If not provided, one column will be removed
- */
- removeCol: function (index, amount) {
- if (priv.dataType === 'object' || priv.settings.columns) {
- throw new Error("cannot remove column with object data source or columns option specified");
- }
- if (!amount) {
- amount = 1;
- }
- if (typeof index !== 'number') {
- index = -amount;
- }
-
- index = (instance.countCols() + index) % instance.countCols();
-
- var actionWasNotCancelled = instance.PluginHooks.execute('beforeRemoveCol', index, amount);
-
- if(actionWasNotCancelled === false){
- return;
- }
-
- var data = GridSettings.prototype.data;
- for (var r = 0, rlen = instance.countRows(); r < rlen; r++) {
- data[r].splice(index, amount);
- }
- priv.columnSettings.splice(index, amount);
-
- instance.PluginHooks.run('afterRemoveCol', index, amount);
- instance.forceFullRender = true; //used when data was changed
- },
-
- /**
- * Add / removes data from the column
- * @param {Number} col Index of column in which do you want to do splice.
- * @param {Number} index Index at which to start changing the array. If negative, will begin that many elements from the end
- * @param {Number} amount An integer indicating the number of old array elements to remove. If amount is 0, no elements are removed
- * param {...*} elements Optional. The elements to add to the array. If you don't specify any elements, spliceCol simply removes elements from the array
- */
- spliceCol: function (col, index, amount/*, elements...*/) {
- var elements = 4 <= arguments.length ? [].slice.call(arguments, 3) : [];
-
- var colData = instance.getDataAtCol(col);
- var removed = colData.slice(index, index + amount);
- var after = colData.slice(index + amount);
-
- Handsontable.helper.extendArray(elements, after);
- var i = 0;
- while (i < amount) {
- elements.push(null); //add null in place of removed elements
- i++;
- }
- Handsontable.helper.to2dArray(elements);
- instance.populateFromArray(index, col, elements, null, null, 'spliceCol');
-
- return removed;
- },
-
- /**
- * Add / removes data from the row
- * @param {Number} row Index of row in which do you want to do splice.
- * @param {Number} index Index at which to start changing the array. If negative, will begin that many elements from the end
- * @param {Number} amount An integer indicating the number of old array elements to remove. If amount is 0, no elements are removed
- * param {...*} elements Optional. The elements to add to the array. If you don't specify any elements, spliceCol simply removes elements from the array
- */
- spliceRow: function (row, index, amount/*, elements...*/) {
- var elements = 4 <= arguments.length ? [].slice.call(arguments, 3) : [];
-
- var rowData = instance.getDataAtRow(row);
- var removed = rowData.slice(index, index + amount);
- var after = rowData.slice(index + amount);
-
- Handsontable.helper.extendArray(elements, after);
- var i = 0;
- while (i < amount) {
- elements.push(null); //add null in place of removed elements
- i++;
- }
- instance.populateFromArray(row, index, [elements], null, null, 'spliceRow');
-
- return removed;
- },
-
- /**
- * Returns single value from the data array
- * @param {Number} row
- * @param {Number} prop
- */
- getVars: {},
- get: function (row, prop) {
- datamap.getVars.row = row;
- datamap.getVars.prop = prop;
- instance.PluginHooks.run('beforeGet', datamap.getVars);
- if (typeof datamap.getVars.prop === 'string' && datamap.getVars.prop.indexOf('.') > -1) {
- var sliced = datamap.getVars.prop.split(".");
- var out = priv.settings.data[datamap.getVars.row];
- if (!out) {
- return null;
- }
- for (var i = 0, ilen = sliced.length; i < ilen; i++) {
- out = out[sliced[i]];
- if (typeof out === 'undefined') {
- return null;
- }
- }
- return out;
- }
- else if (typeof datamap.getVars.prop === 'function') {
- /**
- * allows for interacting with complex structures, for example
- * d3/jQuery getter/setter properties:
- *
- * {columns: [{
- * data: function(row, value){
- * if(arguments.length === 1){
- * return row.property();
- * }
- * row.property(value);
- * }
- * }]}
- */
- return datamap.getVars.prop(priv.settings.data.slice(
- datamap.getVars.row,
- datamap.getVars.row + 1
- )[0]);
- }
- else {
- return priv.settings.data[datamap.getVars.row] ? priv.settings.data[datamap.getVars.row][datamap.getVars.prop] : null;
- }
- },
-
- /**
- * Saves single value to the data array
- * @param {Number} row
- * @param {Number} prop
- * @param {String} value
- * @param {String} [source] Optional. Source of hook runner.
- */
- setVars: {},
- set: function (row, prop, value, source) {
- datamap.setVars.row = row;
- datamap.setVars.prop = prop;
- datamap.setVars.value = value;
- instance.PluginHooks.run('beforeSet', datamap.setVars, source || "datamapGet");
- if (typeof datamap.setVars.prop === 'string' && datamap.setVars.prop.indexOf('.') > -1) {
- var sliced = datamap.setVars.prop.split(".");
- var out = priv.settings.data[datamap.setVars.row];
- for (var i = 0, ilen = sliced.length - 1; i < ilen; i++) {
- out = out[sliced[i]];
- }
- out[sliced[i]] = datamap.setVars.value;
- }
- else if (typeof datamap.setVars.prop === 'function') {
- /* see the `function` handler in `get` */
- datamap.setVars.prop(priv.settings.data.slice(
- datamap.setVars.row,
- datamap.setVars.row + 1
- )[0], datamap.setVars.value);
- }
- else {
- priv.settings.data[datamap.setVars.row][datamap.setVars.prop] = datamap.setVars.value;
- }
- },
- /**
- * This ridiculous piece of code maps rows Id that are present in table data to those displayed for user.
- * The trick is, the physical row id (stored in settings.data) is not necessary the same
- * as the logical (displayed) row id (e.g. when sorting is applied).
- */
- physicalRowsToLogical: function (index, amount) {
- var physicRow = (GridSettings.prototype.data.length + index) % GridSettings.prototype.data.length;
- var logicRows = [];
- var rowsToRemove = amount;
-
- while (physicRow < GridSettings.prototype.data.length && rowsToRemove) {
- this.get(physicRow, 0); //this performs an actual mapping and saves the result to getVars
- logicRows.push(this.getVars.row);
-
- rowsToRemove--;
- physicRow++;
- }
-
- return logicRows;
- },
-
- /**
- * Clears the data array
- */
- clear: function () {
- for (var r = 0; r < instance.countRows(); r++) {
- for (var c = 0; c < instance.countCols(); c++) {
- datamap.set(r, datamap.colToProp(c), '');
- }
- }
- },
-
- /**
- * Returns the data array
- * @return {Array}
- */
- getAll: function () {
- return priv.settings.data;
- },
-
- /**
- * Returns data range as array
- * @param {Object} start Start selection position
- * @param {Object} end End selection position
- * @return {Array}
- */
- getRange: function (start, end) {
- var r, rlen, c, clen, output = [], row;
- rlen = Math.max(start.row, end.row);
- clen = Math.max(start.col, end.col);
- for (r = Math.min(start.row, end.row); r <= rlen; r++) {
- row = [];
- for (c = Math.min(start.col, end.col); c <= clen; c++) {
- row.push(datamap.get(r, datamap.colToProp(c)));
- }
- output.push(row);
- }
- return output;
- },
-
- /**
- * Return data as text (tab separated columns)
- * @param {Object} start (Optional) Start selection position
- * @param {Object} end (Optional) End selection position
- * @return {String}
- */
- getText: function (start, end) {
- return SheetClip.stringify(datamap.getRange(start, end));
- }
- };
-
- grid = {
- /**
- * Inserts or removes rows and columns
- * @param {String} action Possible values: "insert_row", "insert_col", "remove_row", "remove_col"
- * @param {Number} index
- * @param {Number} amount
- * @param {String} [source] Optional. Source of hook runner.
- * @param {Boolean} [keepEmptyRows] Optional. Flag for preventing deletion of empty rows.
- */
- alter: function (action, index, amount, source, keepEmptyRows) {
- var delta;
-
- amount = amount || 1;
-
- switch (action) {
- case "insert_row":
- delta = datamap.createRow(index, amount);
-
- if (delta) {
- if (priv.selStart.exists() && priv.selStart.row() >= index) {
- priv.selStart.row(priv.selStart.row() + delta);
- selection.transformEnd(delta, 0); //will call render() internally
- }
- else {
- selection.refreshBorders(); //it will call render and prepare methods
- }
- }
- break;
-
- case "insert_col":
- delta = datamap.createCol(index, amount);
-
- if (delta) {
-
- if(Handsontable.helper.isArray(instance.getSettings().colHeaders)){
- var spliceArray = [index, 0];
- spliceArray.length += delta; //inserts empty (undefined) elements at the end of an array
- Array.prototype.splice.apply(instance.getSettings().colHeaders, spliceArray); //inserts empty (undefined) elements into the colHeader array
- }
-
- if (priv.selStart.exists() && priv.selStart.col() >= index) {
- priv.selStart.col(priv.selStart.col() + delta);
- selection.transformEnd(0, delta); //will call render() internally
- }
- else {
- selection.refreshBorders(); //it will call render and prepare methods
- }
- }
- break;
-
- case "remove_row":
- datamap.removeRow(index, amount);
- priv.cellSettings.splice(index, amount);
- grid.adjustRowsAndCols();
- selection.refreshBorders(); //it will call render and prepare methods
- break;
-
- case "remove_col":
- datamap.removeCol(index, amount);
-
- for(var row = 0, len = datamap.getAll().length; row < len; row++){
- if(row in priv.cellSettings){ //if row hasn't been rendered it wouldn't have cellSettings
- priv.cellSettings[row].splice(index, amount);
- }
- }
-
- if(Handsontable.helper.isArray(instance.getSettings().colHeaders)){
- if(typeof index == 'undefined'){
- index = -1;
- }
- instance.getSettings().colHeaders.splice(index, amount);
- }
-
- priv.columnSettings.splice(index, amount);
-
- grid.adjustRowsAndCols();
- selection.refreshBorders(); //it will call render and prepare methods
- break;
-
- default:
- throw new Error('There is no such action "' + action + '"');
- break;
- }
-
- if (!keepEmptyRows) {
- grid.adjustRowsAndCols(); //makes sure that we did not add rows that will be removed in next refresh
- }
- },
-
- /**
- * Makes sure there are empty rows at the bottom of the table
- */
- adjustRowsAndCols: function () {
- var r, rlen, emptyRows = instance.countEmptyRows(true), emptyCols;
-
- //should I add empty rows to data source to meet minRows?
- rlen = instance.countRows();
- if (rlen < priv.settings.minRows) {
- for (r = 0; r < priv.settings.minRows - rlen; r++) {
- datamap.createRow();
- }
- }
-
- //should I add empty rows to meet minSpareRows?
- if (emptyRows < priv.settings.minSpareRows) {
- for (; emptyRows < priv.settings.minSpareRows && instance.countRows() < priv.settings.maxRows; emptyRows++) {
- datamap.createRow();
- }
- }
-
- //count currently empty cols
- emptyCols = instance.countEmptyCols(true);
-
- //should I add empty cols to meet minCols?
- if (!priv.settings.columns && instance.countCols() < priv.settings.minCols) {
- for (; instance.countCols() < priv.settings.minCols; emptyCols++) {
- datamap.createCol();
- }
- }
-
- //should I add empty cols to meet minSpareCols?
- if (!priv.settings.columns && priv.dataType === 'array' && emptyCols < priv.settings.minSpareCols) {
- for (; emptyCols < priv.settings.minSpareCols && instance.countCols() < priv.settings.maxCols; emptyCols++) {
- datamap.createCol();
- }
- }
-
- if (priv.settings.enterBeginsEditing) {
- for (; (((priv.settings.minRows || priv.settings.minSpareRows) && instance.countRows() > priv.settings.minRows) && (priv.settings.minSpareRows && emptyRows > priv.settings.minSpareRows)); emptyRows--) {
- datamap.removeRow();
- }
- }
-
- if (priv.settings.enterBeginsEditing && !priv.settings.columns) {
- for (; (((priv.settings.minCols || priv.settings.minSpareCols) && instance.countCols() > priv.settings.minCols) && (priv.settings.minSpareCols && emptyCols > priv.settings.minSpareCols)); emptyCols--) {
- datamap.removeCol();
- }
- }
-
- var rowCount = instance.countRows();
- var colCount = instance.countCols();
-
- if (rowCount === 0 || colCount === 0) {
- selection.deselect();
- }
-
- if (priv.selStart.exists()) {
- var selectionChanged;
- var fromRow = priv.selStart.row();
- var fromCol = priv.selStart.col();
- var toRow = priv.selEnd.row();
- var toCol = priv.selEnd.col();
-
- //if selection is outside, move selection to last row
- if (fromRow > rowCount - 1) {
- fromRow = rowCount - 1;
- selectionChanged = true;
- if (toRow > fromRow) {
- toRow = fromRow;
- }
- } else if (toRow > rowCount - 1) {
- toRow = rowCount - 1;
- selectionChanged = true;
- if (fromRow > toRow) {
- fromRow = toRow;
- }
- }
-
- //if selection is outside, move selection to last row
- if (fromCol > colCount - 1) {
- fromCol = colCount - 1;
- selectionChanged = true;
- if (toCol > fromCol) {
- toCol = fromCol;
- }
- } else if (toCol > colCount - 1) {
- toCol = colCount - 1;
- selectionChanged = true;
- if (fromCol > toCol) {
- fromCol = toCol;
- }
- }
-
- if (selectionChanged) {
- instance.selectCell(fromRow, fromCol, toRow, toCol);
- }
- }
- },
-
- /**
- * Populate cells at position with 2d array
- * @param {Object} start Start selection position
- * @param {Array} input 2d array
- * @param {Object} [end] End selection position (only for drag-down mode)
- * @param {String} [source="populateFromArray"]
- * @param {String} [method="overwrite"]
- * @return {Object|undefined} ending td in pasted area (only if any cell was changed)
- */
- populateFromArray: function (start, input, end, source, method) {
- var r, rlen, c, clen, setData = [], current = {};
- rlen = input.length;
- if (rlen === 0) {
- return false;
- }
-
- var repeatCol
- , repeatRow
- , cmax
- , rmax;
-
- // insert data with specified pasteMode method
- switch (method) {
- case 'shift_down' :
- repeatCol = end ? end.col - start.col + 1 : 0;
- repeatRow = end ? end.row - start.row + 1 : 0;
- input = Handsontable.helper.translateRowsToColumns(input);
- for (c = 0, clen = input.length, cmax = Math.max(clen, repeatCol); c < cmax; c++) {
- if (c < clen) {
- for (r = 0, rlen = input[c].length; r < repeatRow - rlen; r++) {
- input[c].push(input[c][r % rlen]);
- }
- input[c].unshift(start.col + c, start.row, 0);
- instance.spliceCol.apply(instance, input[c]);
- }
- else {
- input[c % clen][0] = start.col + c;
- instance.spliceCol.apply(instance, input[c % clen]);
- }
- }
- break;
-
- case 'shift_right' :
- repeatCol = end ? end.col - start.col + 1 : 0;
- repeatRow = end ? end.row - start.row + 1 : 0;
- for (r = 0, rlen = input.length, rmax = Math.max(rlen, repeatRow); r < rmax; r++) {
- if (r < rlen) {
- for (c = 0, clen = input[r].length; c < repeatCol - clen; c++) {
- input[r].push(input[r][c % clen]);
- }
- input[r].unshift(start.row + r, start.col, 0);
- instance.spliceRow.apply(instance, input[r]);
- }
- else {
- input[r % rlen][0] = start.row + r;
- instance.spliceRow.apply(instance, input[r % rlen]);
- }
- }
- break;
-
- case 'overwrite' :
- default:
- // overwrite and other not specified options
- current.row = start.row;
- current.col = start.col;
- for (r = 0; r < rlen; r++) {
- if ((end && current.row > end.row) || (!priv.settings.minSpareRows && current.row > instance.countRows() - 1) || (current.row >= priv.settings.maxRows)) {
- break;
- }
- current.col = start.col;
- clen = input[r] ? input[r].length : 0;
- for (c = 0; c < clen; c++) {
- if ((end && current.col > end.col) || (!priv.settings.minSpareCols && current.col > instance.countCols() - 1) || (current.col >= priv.settings.maxCols)) {
- break;
- }
- if (!instance.getCellMeta(current.row, current.col).readOnly) {
- setData.push([current.row, current.col, input[r][c]]);
- }
- current.col++;
- if (end && c === clen - 1) {
- c = -1;
- }
- }
- current.row++;
- if (end && r === rlen - 1) {
- r = -1;
- }
- }
- instance.setDataAtCell(setData, null, null, source || 'populateFromArray');
- break;
- }
- },
-
- /**
- * Returns the top left (TL) and bottom right (BR) selection coordinates
- * @param {Object[]} coordsArr
- * @returns {Object}
- */
- getCornerCoords: function (coordsArr) {
- function mapProp(func, array, prop) {
- function getProp(el) {
- return el[prop];
- }
-
- if (Array.prototype.map) {
- return func.apply(Math, array.map(getProp));
- }
- return func.apply(Math, $.map(array, getProp));
- }
-
- return {
- TL: {
- row: mapProp(Math.min, coordsArr, "row"),
- col: mapProp(Math.min, coordsArr, "col")
- },
- BR: {
- row: mapProp(Math.max, coordsArr, "row"),
- col: mapProp(Math.max, coordsArr, "col")
- }
- };
- },
-
- /**
- * Returns array of td objects given start and end coordinates
- */
- getCellsAtCoords: function (start, end) {
- var corners = grid.getCornerCoords([start, end]);
- var r, c, output = [];
- for (r = corners.TL.row; r <= corners.BR.row; r++) {
- for (c = corners.TL.col; c <= corners.BR.col; c++) {
- output.push(instance.view.getCellAtCoords({
- row: r,
- col: c
- }));
- }
- }
- return output;
- }
- };
-
- this.selection = selection = { //this public assignment is only temporary
- inProgress: false,
-
- /**
- * Sets inProgress to true. This enables onSelectionEnd and onSelectionEndByProp to function as desired
- */
- begin: function () {
- instance.selection.inProgress = true;
- },
-
- /**
- * Sets inProgress to false. Triggers onSelectionEnd and onSelectionEndByProp
- */
- finish: function () {
- var sel = instance.getSelected();
- instance.PluginHooks.run("afterSelectionEnd", sel[0], sel[1], sel[2], sel[3]);
- instance.PluginHooks.run("afterSelectionEndByProp", sel[0], instance.colToProp(sel[1]), sel[2], instance.colToProp(sel[3]));
- instance.selection.inProgress = false;
- },
-
- isInProgress: function () {
- return instance.selection.inProgress;
- },
-
- /**
- * Starts selection range on given td object
- * @param {Object} coords
- */
- setRangeStart: function (coords) {
- priv.selStart.coords(coords);
- selection.setRangeEnd(coords);
- },
-
- /**
- * Ends selection range on given td object
- * @param {Object} coords
- * @param {Boolean} [scrollToCell=true] If true, viewport will be scrolled to range end
- */
- setRangeEnd: function (coords, scrollToCell) {
- instance.selection.begin();
-
- priv.selEnd.coords(coords);
- if (!priv.settings.multiSelect) {
- priv.selStart.coords(coords);
- }
-
- //set up current selection
- instance.view.wt.selections.current.clear();
- instance.view.wt.selections.current.add(priv.selStart.arr());
-
- //set up area selection
- instance.view.wt.selections.area.clear();
- if (selection.isMultiple()) {
- instance.view.wt.selections.area.add(priv.selStart.arr());
- instance.view.wt.selections.area.add(priv.selEnd.arr());
- }
-
- //set up highlight
- if (priv.settings.currentRowClassName || priv.settings.currentColClassName) {
- instance.view.wt.selections.highlight.clear();
- instance.view.wt.selections.highlight.add(priv.selStart.arr());
- instance.view.wt.selections.highlight.add(priv.selEnd.arr());
- }
-
- //trigger handlers
- instance.PluginHooks.run("afterSelection", priv.selStart.row(), priv.selStart.col(), priv.selEnd.row(), priv.selEnd.col());
- instance.PluginHooks.run("afterSelectionByProp", priv.selStart.row(), datamap.colToProp(priv.selStart.col()), priv.selEnd.row(), datamap.colToProp(priv.selEnd.col()));
-
- if (scrollToCell !== false) {
- instance.view.scrollViewport(coords);
- }
- selection.refreshBorders();
- },
-
- /**
- * Destroys editor, redraws borders around cells, prepares editor
- * @param {Boolean} revertOriginal
- * @param {Boolean} keepEditor
- */
- refreshBorders: function (revertOriginal, keepEditor) {
- if (!keepEditor) {
- editorManager.destroyEditor(revertOriginal);
- }
- instance.view.render();
- if (selection.isSelected() && !keepEditor) {
- editorManager.prepareEditor();
- }
- },
-
- /**
- * Returns information if we have a multiselection
- * @return {Boolean}
- */
- isMultiple: function () {
- return !(priv.selEnd.col() === priv.selStart.col() && priv.selEnd.row() === priv.selStart.row());
- },
-
- /**
- * Selects cell relative to current cell (if possible)
- */
- transformStart: function (rowDelta, colDelta, force) {
- if (priv.selStart.row() + rowDelta > instance.countRows() - 1) {
- if (force && priv.settings.minSpareRows > 0) {
- instance.alter("insert_row", instance.countRows());
- }
- else if (priv.settings.autoWrapCol) {
- rowDelta = 1 - instance.countRows();
- colDelta = priv.selStart.col() + colDelta == instance.countCols() - 1 ? 1 - instance.countCols() : 1;
- }
- }
- else if (priv.settings.autoWrapCol && priv.selStart.row() + rowDelta < 0 && priv.selStart.col() + colDelta >= 0) {
- rowDelta = instance.countRows() - 1;
- colDelta = priv.selStart.col() + colDelta == 0 ? instance.countCols() - 1 : -1;
- }
-
- if (priv.selStart.col() + colDelta > instance.countCols() - 1) {
- if (force && priv.settings.minSpareCols > 0) {
- instance.alter("insert_col", instance.countCols());
- }
- else if (priv.settings.autoWrapRow) {
- rowDelta = priv.selStart.row() + rowDelta == instance.countRows() - 1 ? 1 - instance.countRows() : 1;
- colDelta = 1 - instance.countCols();
- }
- }
- else if (priv.settings.autoWrapRow && priv.selStart.col() + colDelta < 0 && priv.selStart.row() + rowDelta >= 0) {
- rowDelta = priv.selStart.row() + rowDelta == 0 ? instance.countRows() - 1 : -1;
- colDelta = instance.countCols() - 1;
- }
-
- var totalRows = instance.countRows();
- var totalCols = instance.countCols();
- var coords = {
- row: priv.selStart.row() + rowDelta,
- col: priv.selStart.col() + colDelta
- };
-
- if (coords.row < 0) {
- coords.row = 0;
- }
- else if (coords.row > 0 && coords.row >= totalRows) {
- coords.row = totalRows - 1;
- }
-
- if (coords.col < 0) {
- coords.col = 0;
- }
- else if (coords.col > 0 && coords.col >= totalCols) {
- coords.col = totalCols - 1;
- }
-
- selection.setRangeStart(coords);
- },
-
- /**
- * Sets selection end cell relative to current selection end cell (if possible)
- */
- transformEnd: function (rowDelta, colDelta) {
- if (priv.selEnd.exists()) {
- var totalRows = instance.countRows();
- var totalCols = instance.countCols();
- var coords = {
- row: priv.selEnd.row() + rowDelta,
- col: priv.selEnd.col() + colDelta
- };
-
- if (coords.row < 0) {
- coords.row = 0;
- }
- else if (coords.row > 0 && coords.row >= totalRows) {
- coords.row = totalRows - 1;
- }
-
- if (coords.col < 0) {
- coords.col = 0;
- }
- else if (coords.col > 0 && coords.col >= totalCols) {
- coords.col = totalCols - 1;
- }
-
- selection.setRangeEnd(coords);
- }
- },
-
- /**
- * Returns true if currently there is a selection on screen, false otherwise
- * @return {Boolean}
- */
- isSelected: function () {
- return priv.selEnd.exists();
- },
-
- /**
- * Returns true if coords is within current selection coords
- * @return {Boolean}
- */
- inInSelection: function (coords) {
- if (!selection.isSelected()) {
- return false;
- }
- var sel = grid.getCornerCoords([priv.selStart.coords(), priv.selEnd.coords()]);
- return (sel.TL.row <= coords.row && sel.BR.row >= coords.row && sel.TL.col <= coords.col && sel.BR.col >= coords.col);
- },
-
- /**
- * Deselects all selected cells
- */
- deselect: function () {
- if (!selection.isSelected()) {
- return;
- }
- instance.selection.inProgress = false; //needed by HT inception
- priv.selEnd = new Handsontable.SelectionPoint(); //create new empty point to remove the existing one
- instance.view.wt.selections.current.clear();
- instance.view.wt.selections.area.clear();
- editorManager.destroyEditor();
- selection.refreshBorders();
- instance.PluginHooks.run('afterDeselect');
- },
-
- /**
- * Select all cells
- */
- selectAll: function () {
- if (!priv.settings.multiSelect) {
- return;
- }
- selection.setRangeStart({
- row: 0,
- col: 0
- });
- selection.setRangeEnd({
- row: instance.countRows() - 1,
- col: instance.countCols() - 1
- }, false);
- },
-
- /**
- * Deletes data from selected cells
- */
- empty: function () {
- if (!selection.isSelected()) {
- return;
- }
- var corners = grid.getCornerCoords([priv.selStart.coords(), priv.selEnd.coords()]);
- var r, c, changes = [];
- for (r = corners.TL.row; r <= corners.BR.row; r++) {
- for (c = corners.TL.col; c <= corners.BR.col; c++) {
- if (!instance.getCellMeta(r, c).readOnly) {
- changes.push([r, c, '']);
- }
- }
- }
- instance.setDataAtCell(changes);
- }
- };
-
- this.autofill = autofill = { //this public assignment is only temporary
- handle: null,
-
- /**
- * Create fill handle and fill border objects
- */
- init: function () {
- if (!autofill.handle) {
- autofill.handle = {};
- }
- else {
- autofill.handle.disabled = false;
- }
- },
-
- /**
- * Hide fill handle and fill border permanently
- */
- disable: function () {
- autofill.handle.disabled = true;
- },
-
- /**
- * Selects cells down to the last row in the left column, then fills down to that cell
- */
- selectAdjacent: function () {
- var select, data, r, maxR, c;
-
- if (selection.isMultiple()) {
- select = instance.view.wt.selections.area.getCorners();
- }
- else {
- select = instance.view.wt.selections.current.getCorners();
- }
-
- data = datamap.getAll();
- rows : for (r = select[2] + 1; r < instance.countRows(); r++) {
- for (c = select[1]; c <= select[3]; c++) {
- if (data[r][c]) {
- break rows;
- }
- }
- if (!!data[r][select[1] - 1] || !!data[r][select[3] + 1]) {
- maxR = r;
- }
- }
- if (maxR) {
- instance.view.wt.selections.fill.clear();
- instance.view.wt.selections.fill.add([select[0], select[1]]);
- instance.view.wt.selections.fill.add([maxR, select[3]]);
- autofill.apply();
- }
- },
-
- /**
- * Apply fill values to the area in fill border, omitting the selection border
- */
- apply: function () {
- var drag, select, start, end, _data;
-
- autofill.handle.isDragged = 0;
-
- drag = instance.view.wt.selections.fill.getCorners();
- if (!drag) {
- return;
- }
-
- instance.view.wt.selections.fill.clear();
-
- if (selection.isMultiple()) {
- select = instance.view.wt.selections.area.getCorners();
- }
- else {
- select = instance.view.wt.selections.current.getCorners();
- }
-
- if (drag[0] === select[0] && drag[1] < select[1]) {
- start = {
- row: drag[0],
- col: drag[1]
- };
- end = {
- row: drag[2],
- col: select[1] - 1
- };
- }
- else if (drag[0] === select[0] && drag[3] > select[3]) {
- start = {
- row: drag[0],
- col: select[3] + 1
- };
- end = {
- row: drag[2],
- col: drag[3]
- };
- }
- else if (drag[0] < select[0] && drag[1] === select[1]) {
- start = {
- row: drag[0],
- col: drag[1]
- };
- end = {
- row: select[0] - 1,
- col: drag[3]
- };
- }
- else if (drag[2] > select[2] && drag[1] === select[1]) {
- start = {
- row: select[2] + 1,
- col: drag[1]
- };
- end = {
- row: drag[2],
- col: drag[3]
- };
- }
-
- if (start) {
-
- _data = SheetClip.parse(datamap.getText(priv.selStart.coords(), priv.selEnd.coords()));
- instance.PluginHooks.run('beforeAutofill', start, end, _data);
-
- grid.populateFromArray(start, _data, end, 'autofill');
-
- selection.setRangeStart({row: drag[0], col: drag[1]});
- selection.setRangeEnd({row: drag[2], col: drag[3]});
- }
- /*else {
- //reset to avoid some range bug
- selection.refreshBorders();
- }*/
- },
-
- /**
- * Show fill border
- */
- showBorder: function (coords) {
- coords.row = coords[0];
- coords.col = coords[1];
-
- var corners = grid.getCornerCoords([priv.selStart.coords(), priv.selEnd.coords()]);
- if (priv.settings.fillHandle !== 'horizontal' && (corners.BR.row < coords.row || corners.TL.row > coords.row)) {
- coords = [coords.row, corners.BR.col];
- }
- else if (priv.settings.fillHandle !== 'vertical') {
- coords = [corners.BR.row, coords.col];
- }
- else {
- return; //wrong direction
- }
-
- instance.view.wt.selections.fill.clear();
- instance.view.wt.selections.fill.add([priv.selStart.coords().row, priv.selStart.coords().col]);
- instance.view.wt.selections.fill.add([priv.selEnd.coords().row, priv.selEnd.coords().col]);
- instance.view.wt.selections.fill.add(coords);
- instance.view.render();
- }
- };
-
- this.init = function () {
- instance.PluginHooks.run('beforeInit');
-
- this.view = new Handsontable.TableView(this);
- editorManager = new Handsontable.EditorManager(instance, priv, selection, datamap);
-
- this.updateSettings(priv.settings, true);
- this.parseSettingsFromDOM();
-
-
- this.forceFullRender = true; //used when data was changed
- this.view.render();
-
- if (typeof priv.firstRun === 'object') {
- instance.PluginHooks.run('afterChange', priv.firstRun[0], priv.firstRun[1]);
- priv.firstRun = false;
- }
- instance.PluginHooks.run('afterInit');
- };
-
- function ValidatorsQueue() { //moved this one level up so it can be used in any function here. Probably this should be moved to a separate file
- var resolved = false;
-
- return {
- validatorsInQueue: 0,
- addValidatorToQueue: function () {
- this.validatorsInQueue++;
- resolved = false;
- },
- removeValidatorFormQueue: function () {
- this.validatorsInQueue = this.validatorsInQueue - 1 < 0 ? 0 : this.validatorsInQueue - 1;
- this.checkIfQueueIsEmpty();
- },
- onQueueEmpty: function () {
- },
- checkIfQueueIsEmpty: function () {
- if (this.validatorsInQueue == 0 && resolved == false) {
- resolved = true;
- this.onQueueEmpty();
- }
- }
- };
- }
-
- function validateChanges(changes, source, callback) {
- var waitingForValidator = new ValidatorsQueue();
- waitingForValidator.onQueueEmpty = resolve;
-
- for (var i = changes.length - 1; i >= 0; i--) {
- if (changes[i] === null) {
- changes.splice(i, 1);
- }
- else {
- var row = changes[i][0];
- var col = datamap.propToCol(changes[i][1]);
- var logicalCol = instance.runHooksAndReturn('modifyCol', col); //column order may have changes, so we need to translate physical col index (stored in datasource) to logical (displayed to user)
- var cellProperties = instance.getCellMeta(row, logicalCol);
-
- if (cellProperties.type === 'numeric' && typeof changes[i][3] === 'string') {
- if (changes[i][3].length > 0 && /^-?[\d\s]*\.?\d*$/.test(changes[i][3])) {
- changes[i][3] = numeral().unformat(changes[i][3] || '0'); //numeral cannot unformat empty string
- }
- }
-
- if (instance.getCellValidator(cellProperties)) {
- waitingForValidator.addValidatorToQueue();
- instance.validateCell(changes[i][3], cellProperties, (function (i, cellProperties) {
- return function (result) {
- if (typeof result !== 'boolean') {
- throw new Error("Validation error: result is not boolean");
- }
- if (result === false && cellProperties.allowInvalid === false) {
- changes.splice(i, 1); // cancel the change
- cellProperties.valid = true; // we cancelled the change, so cell value is still valid
- --i;
- }
- waitingForValidator.removeValidatorFormQueue();
- }
- })(i, cellProperties)
- , source);
- }
- }
- }
- waitingForValidator.checkIfQueueIsEmpty();
-
- function resolve() {
- var beforeChangeResult;
-
- if (changes.length) {
- beforeChangeResult = instance.PluginHooks.execute("beforeChange", changes, source);
- if (typeof beforeChangeResult === 'function') {
- $.when(result).then(function () {
- callback(); //called when async validators and async beforeChange are resolved
- });
- }
- else if (beforeChangeResult === false) {
- changes.splice(0, changes.length); //invalidate all changes (remove everything from array)
- }
- }
- if (typeof beforeChangeResult !== 'function') {
- callback(); //called when async validators are resolved and beforeChange was not async
- }
- }
- }
-
- /**
- * Internal function to apply changes. Called after validateChanges
- * @param {Array} changes Array in form of [row, prop, oldValue, newValue]
- * @param {String} source String that identifies how this change will be described in changes array (useful in onChange callback)
- */
- function applyChanges(changes, source) {
- var i = changes.length - 1;
-
- if (i < 0) {
- return;
- }
-
- for (; 0 <= i; i--) {
- if (changes[i] === null) {
- changes.splice(i, 1);
- continue;
- }
-
- if (priv.settings.minSpareRows) {
- while (changes[i][0] > instance.countRows() - 1) {
- datamap.createRow();
- }
- }
-
- if (priv.dataType === 'array' && priv.settings.minSpareCols) {
- while (datamap.propToCol(changes[i][1]) > instance.countCols() - 1) {
- datamap.createCol();
- }
- }
-
- datamap.set(changes[i][0], changes[i][1], changes[i][3]);
- }
-
- instance.forceFullRender = true; //used when data was changed
- grid.adjustRowsAndCols();
- selection.refreshBorders(null, true);
- instance.PluginHooks.run('afterChange', changes, source || 'edit');
- }
-
- this.validateCell = function (value, cellProperties, callback, source) {
- var validator = instance.getCellValidator(cellProperties);
-
- if (Object.prototype.toString.call(validator) === '[object RegExp]') {
- validator = (function (validator) {
- return function (value, callback) {
- callback(validator.test(value));
- }
- })(validator);
- }
-
- if (typeof validator == 'function') {
-
- value = instance.PluginHooks.execute("beforeValidate", value, cellProperties.row, cellProperties.prop, source);
-
- // To provide consistent behaviour, validation should be always asynchronous
- setTimeout(function () {
- validator.call(cellProperties, value, function (valid) {
- cellProperties.valid = valid;
-
- valid = instance.PluginHooks.execute("afterValidate", valid, value, cellProperties.row, cellProperties.prop, source);
-
- callback(valid);
- });
- });
-
- } else { //resolve callback even if validator function was not found
- cellProperties.valid = true;
- callback(true);
- }
-
-
-
- };
-
- function setDataInputToArray(row, prop_or_col, value) {
- if (typeof row === "object") { //is it an array of changes
- return row;
- }
- else if ($.isPlainObject(value)) { //backwards compatibility
- return value;
- }
- else {
- return [
- [row, prop_or_col, value]
- ];
- }
- }
-
- /**
- * Set data at given cell
- * @public
- * @param {Number|Array} row or array of changes in format [[row, col, value], ...]
- * @param {Number|String} col or source String
- * @param {String} value
- * @param {String} source String that identifies how this change will be described in changes array (useful in onChange callback)
- */
- this.setDataAtCell = function (row, col, value, source) {
- var input = setDataInputToArray(row, col, value)
- , i
- , ilen
- , changes = []
- , prop;
-
- for (i = 0, ilen = input.length; i < ilen; i++) {
- if (typeof input[i] !== 'object') {
- throw new Error('Method `setDataAtCell` accepts row number or changes array of arrays as its first parameter');
- }
- if (typeof input[i][1] !== 'number') {
- throw new Error('Method `setDataAtCell` accepts row and column number as its parameters. If you want to use object property name, use method `setDataAtRowProp`');
- }
- prop = datamap.colToProp(input[i][1]);
- changes.push([
- input[i][0],
- prop,
- datamap.get(input[i][0], prop),
- input[i][2]
- ]);
- }
-
- if (!source && typeof row === "object") {
- source = col;
- }
-
- validateChanges(changes, source, function () {
- applyChanges(changes, source);
- });
- };
-
-
- /**
- * Set data at given row property
- * @public
- * @param {Number|Array} row or array of changes in format [[row, prop, value], ...]
- * @param {String} prop or source String
- * @param {String} value
- * @param {String} source String that identifies how this change will be described in changes array (useful in onChange callback)
- */
- this.setDataAtRowProp = function (row, prop, value, source) {
- var input = setDataInputToArray(row, prop, value)
- , i
- , ilen
- , changes = [];
-
- for (i = 0, ilen = input.length; i < ilen; i++) {
- changes.push([
- input[i][0],
- input[i][1],
- datamap.get(input[i][0], input[i][1]),
- input[i][2]
- ]);
- }
-
- if (!source && typeof row === "object") {
- source = prop;
- }
-
- validateChanges(changes, source, function () {
- applyChanges(changes, source);
- });
- };
-
- /**
- * Listen to document body keyboard input
- */
- this.listen = function () {
- Handsontable.activeGuid = instance.guid;
-
- if (document.activeElement && document.activeElement !== document.body) {
- document.activeElement.blur();
- }
- else if (!document.activeElement) { //IE
- document.body.focus();
- }
- };
-
- /**
- * Stop listening to document body keyboard input
- */
- this.unlisten = function () {
- Handsontable.activeGuid = null;
- };
-
- /**
- * Returns true if current Handsontable instance is listening on document body keyboard input
- */
- this.isListening = function () {
- return Handsontable.activeGuid === instance.guid;
- };
-
- /**
- * Destroys current editor, renders and selects current cell. If revertOriginal != true, edited data is saved
- * @param {Boolean} revertOriginal
- */
- this.destroyEditor = function (revertOriginal) {
- selection.refreshBorders(revertOriginal);
- };
-
- /**
- * Populate cells at position with 2d array
- * @param {Number} row Start row
- * @param {Number} col Start column
- * @param {Array} input 2d array
- * @param {Number=} endRow End row (use when you want to cut input when certain row is reached)
- * @param {Number=} endCol End column (use when you want to cut input when certain column is reached)
- * @param {String=} [source="populateFromArray"]
- * @param {String=} [method="overwrite"]
- * @return {Object|undefined} ending td in pasted area (only if any cell was changed)
- */
- this.populateFromArray = function (row, col, input, endRow, endCol, source, method) {
- if (!(typeof input === 'object' && typeof input[0] === 'object')) {
- throw new Error("populateFromArray parameter `input` must be an array of arrays"); //API changed in 0.9-beta2, let's check if you use it correctly
- }
- return grid.populateFromArray({row: row, col: col}, input, typeof endRow === 'number' ? {row: endRow, col: endCol} : null, source, method);
- };
-
- /**
- * Adds/removes data from the column
- * @param {Number} col Index of column in which do you want to do splice.
- * @param {Number} index Index at which to start changing the array. If negative, will begin that many elements from the end
- * @param {Number} amount An integer indicating the number of old array elements to remove. If amount is 0, no elements are removed
- * param {...*} elements Optional. The elements to add to the array. If you don't specify any elements, spliceCol simply removes elements from the array
- */
- this.spliceCol = function (col, index, amount/*, elements... */) {
- return datamap.spliceCol.apply(null, arguments);
- };
-
- /**
- * Adds/removes data from the row
- * @param {Number} row Index of column in which do you want to do splice.
- * @param {Number} index Index at which to start changing the array. If negative, will begin that many elements from the end
- * @param {Number} amount An integer indicating the number of old array elements to remove. If amount is 0, no elements are removed
- * param {...*} elements Optional. The elements to add to the array. If you don't specify any elements, spliceCol simply removes elements from the array
- */
- this.spliceRow = function (row, index, amount/*, elements... */) {
- return datamap.spliceRow.apply(null, arguments);
- };
-
- /**
- * Returns the top left (TL) and bottom right (BR) selection coordinates
- * @param {Object[]} coordsArr
- * @returns {Object}
- */
- this.getCornerCoords = function (coordsArr) {
- return grid.getCornerCoords(coordsArr);
- };
-
- /**
- * Returns current selection. Returns undefined if there is no selection.
- * @public
- * @return {Array} [`startRow`, `startCol`, `endRow`, `endCol`]
- */
- this.getSelected = function () { //https://github.com/warpech/jquery-handsontable/issues/44 //cjl
- if (selection.isSelected()) {
- return [priv.selStart.row(), priv.selStart.col(), priv.selEnd.row(), priv.selEnd.col()];
- }
- };
-
- /**
- * Parse settings from DOM and CSS
- * @public
- */
- this.parseSettingsFromDOM = function () {
- var overflow = this.rootElement.css('overflow');
- if (overflow === 'scroll' || overflow === 'auto') {
- this.rootElement[0].style.overflow = 'visible';
- priv.settingsFromDOM.overflow = overflow;
- }
- else if (priv.settings.width === void 0 || priv.settings.height === void 0) {
- priv.settingsFromDOM.overflow = 'auto';
- }
-
- if (priv.settings.width === void 0) {
- priv.settingsFromDOM.width = this.rootElement.width();
- }
- else {
- priv.settingsFromDOM.width = void 0;
- }
-
- priv.settingsFromDOM.height = void 0;
- if (priv.settings.height === void 0) {
- if (priv.settingsFromDOM.overflow === 'scroll' || priv.settingsFromDOM.overflow === 'auto') {
- //this needs to read only CSS/inline style and not actual height
- //so we need to call getComputedStyle on cloned container
- var clone = this.rootElement[0].cloneNode(false);
- var parent = this.rootElement[0].parentNode;
- if (parent) {
- clone.removeAttribute('id');
- parent.appendChild(clone);
- var computedHeight = parseInt(window.getComputedStyle(clone, null).getPropertyValue('height'), 10);
-
- if(isNaN(computedHeight) && clone.currentStyle){
- computedHeight = parseInt(clone.currentStyle.height, 10)
- }
-
- if (computedHeight > 0) {
- priv.settingsFromDOM.height = computedHeight;
- }
- parent.removeChild(clone);
- }
- }
- }
- };
-
- /**
- * Render visible data
- * @public
- */
- this.render = function () {
- if (instance.view) {
- instance.forceFullRender = true; //used when data was changed
- instance.parseSettingsFromDOM();
- selection.refreshBorders(null, true);
- }
- };
-
- /**
- * Load data from array
- * @public
- * @param {Array} data
- */
- this.loadData = function (data) {
- if (typeof data === 'object' && data !== null) {
- if (!(data.push && data.splice)) { //check if data is array. Must use duck-type check so Backbone Collections also pass it
- //when data is not an array, attempt to make a single-row array of it
- data = [data];
- }
- }
- else if(data === null) {
- data = [];
- var row;
- for (var r = 0, rlen = priv.settings.startRows; r < rlen; r++) {
- row = [];
- for (var c = 0, clen = priv.settings.startCols; c < clen; c++) {
- row.push(null);
- }
- data.push(row);
- }
- }
- else {
- throw new Error("loadData only accepts array of objects or array of arrays (" + typeof data + " given)");
- }
-
- priv.isPopulated = false;
- GridSettings.prototype.data = data;
-
- if (priv.settings.dataSchema instanceof Array || data[0] instanceof Array) {
- priv.dataType = 'array';
- }
- else if (typeof priv.settings.dataSchema === 'function') {
- priv.dataType = 'function';
- }
- else {
- priv.dataType = 'object';
- }
-
- if (data[0]) {
- priv.duckDataSchema = datamap.recursiveDuckSchema(data[0]);
- }
- else {
- priv.duckDataSchema = {};
- }
- datamap.createMap();
- clearCellSettingCache();
-
- grid.adjustRowsAndCols();
- instance.PluginHooks.run('afterLoadData');
-
- if (priv.firstRun) {
- priv.firstRun = [null, 'loadData'];
- }
- else {
- instance.PluginHooks.run('afterChange', null, 'loadData');
- instance.render();
- }
-
- priv.isPopulated = true;
-
-
-
- function clearCellSettingCache() {
- priv.cellSettings.length = 0;
- }
- };
-
- /**
- * Return the current data object (the same that was passed by `data` configuration option or `loadData` method). Optionally you can provide cell range `r`, `c`, `r2`, `c2` to get only a fragment of grid data
- * @public
- * @param {Number} r (Optional) From row
- * @param {Number} c (Optional) From col
- * @param {Number} r2 (Optional) To row
- * @param {Number} c2 (Optional) To col
- * @return {Array|Object}
- */
- this.getData = function (r, c, r2, c2) {
- if (typeof r === 'undefined') {
- return datamap.getAll();
- }
- else {
- return datamap.getRange({row: r, col: c}, {row: r2, col: c2});
- }
- };
-
- this.getCopyableData = function (startRow, startCol, endRow, endCol) {
- return datamap.getText({row: startRow, col: startCol}, {row: endRow, col: endCol});
- };
-
- /**
- * Update settings
- * @public
- */
- this.updateSettings = function (settings, init) {
- var i, clen;
-
- if (typeof settings.rows !== "undefined") {
- throw new Error("'rows' setting is no longer supported. do you mean startRows, minRows or maxRows?");
- }
- if (typeof settings.cols !== "undefined") {
- throw new Error("'cols' setting is no longer supported. do you mean startCols, minCols or maxCols?");
- }
-
- for (i in settings) {
- if (i === 'data') {
- continue; //loadData will be triggered later
- }
- else {
- if (instance.PluginHooks.hooks[i] !== void 0 || instance.PluginHooks.legacy[i] !== void 0) {
- if (typeof settings[i] === 'function' || Handsontable.helper.isArray(settings[i])) {
- instance.PluginHooks.add(i, settings[i]);
- }
- }
- else {
- // Update settings
- if (!init && settings.hasOwnProperty(i)) {
- GridSettings.prototype[i] = settings[i];
- }
-
- //launch extensions
- if (Handsontable.extension[i]) {
- priv.extensions[i] = new Handsontable.extension[i](instance, settings[i]);
- }
- }
- }
- }
-
- // Load data or create data map
- if (settings.data === void 0 && priv.settings.data === void 0) {
- instance.loadData(null); //data source created just now
- }
- else if (settings.data !== void 0) {
- instance.loadData(settings.data); //data source given as option
- }
- else if (settings.columns !== void 0) {
- datamap.createMap();
- }
-
- // Init columns constructors configuration
- clen = instance.countCols();
-
- //Clear cellSettings cache
- priv.cellSettings.length = 0;
-
- if (clen > 0) {
- var proto, column;
-
- for (i = 0; i < clen; i++) {
- priv.columnSettings[i] = Handsontable.helper.columnFactory(GridSettings, priv.columnsSettingConflicts);
-
- // shortcut for prototype
- proto = priv.columnSettings[i].prototype;
-
- // Use settings provided by user
- if (GridSettings.prototype.columns) {
- column = GridSettings.prototype.columns[i];
- Handsontable.helper.extend(proto, column);
- Handsontable.helper.extend(proto, expandType(column));
- }
- }
- }
-
- if (typeof settings.fillHandle !== "undefined") {
- if (autofill.handle && settings.fillHandle === false) {
- autofill.disable();
- }
- else if (!autofill.handle && settings.fillHandle !== false) {
- autofill.init();
- }
- }
-
- if (typeof settings.className !== "undefined") {
- if (GridSettings.prototype.className) {
- instance.rootElement.removeClass(GridSettings.prototype.className);
- }
- if (settings.className) {
- instance.rootElement.addClass(settings.className);
- }
- }
-
- if (!init) {
- instance.PluginHooks.run('afterUpdateSettings');
- }
-
- grid.adjustRowsAndCols();
- if (instance.view && !priv.firstRun) {
- instance.forceFullRender = true; //used when data was changed
- selection.refreshBorders(null, true);
- }
- };
-
- this.getValue = function () {
- var sel = instance.getSelected();
- if (GridSettings.prototype.getValue) {
- if (typeof GridSettings.prototype.getValue === 'function') {
- return GridSettings.prototype.getValue.call(instance);
- }
- else if (sel) {
- return instance.getData()[sel[0]][GridSettings.prototype.getValue];
- }
- }
- else if (sel) {
- return instance.getDataAtCell(sel[0], sel[1]);
- }
- };
-
- function expandType(obj) {
- if (!obj.hasOwnProperty('type')) return; //ignore obj.prototype.type
-
-
- var type, expandedType = {};
-
- if (typeof obj.type === 'object') {
- type = obj.type;
- }
- else if (typeof obj.type === 'string') {
- type = Handsontable.cellTypes[obj.type];
- if (type === void 0) {
- throw new Error('You declared cell type "' + obj.type + '" as a string that is not mapped to a known object. Cell type must be an object or a string mapped to an object in Handsontable.cellTypes');
- }
- }
-
-
- for (var i in type) {
- if (type.hasOwnProperty(i) && !obj.hasOwnProperty(i)) {
- expandedType[i] = type[i];
- }
- }
-
- return expandedType;
-
- }
-
- /**
- * Returns current settings object
- * @return {Object}
- */
- this.getSettings = function () {
- return priv.settings;
- };
-
- /**
- * Returns current settingsFromDOM object
- * @return {Object}
- */
- this.getSettingsFromDOM = function () {
- return priv.settingsFromDOM;
- };
-
- /**
- * Clears grid
- * @public
- */
- this.clear = function () {
- selection.selectAll();
- selection.empty();
- };
-
- /**
- * Inserts or removes rows and columns
- * @param {String} action See grid.alter for possible values
- * @param {Number} index
- * @param {Number} amount
- * @param {String} [source] Optional. Source of hook runner.
- * @param {Boolean} [keepEmptyRows] Optional. Flag for preventing deletion of empty rows.
- * @public
- */
- this.alter = function (action, index, amount, source, keepEmptyRows) {
- grid.alter(action, index, amount, source, keepEmptyRows);
- };
-
- /**
- * Returns element corresponding to params row, col
- * @param {Number} row
- * @param {Number} col
- * @public
- * @return {Element}
- */
- this.getCell = function (row, col) {
- return instance.view.getCellAtCoords({row: row, col: col});
- };
-
- /**
- * Returns property name associated with column number
- * @param {Number} col
- * @public
- * @return {String}
- */
- this.colToProp = function (col) {
- return datamap.colToProp(col);
- };
-
- /**
- * Returns column number associated with property name
- * @param {String} prop
- * @public
- * @return {Number}
- */
- this.propToCol = function (prop) {
- return datamap.propToCol(prop);
- };
-
- /**
- * Return value at `row`, `col`
- * @param {Number} row
- * @param {Number} col
- * @public
- * @return value (mixed data type)
- */
- this.getDataAtCell = function (row, col) {
- return datamap.get(row, datamap.colToProp(col));
- };
-
- /**
- * Return value at `row`, `prop`
- * @param {Number} row
- * @param {String} prop
- * @public
- * @return value (mixed data type)
- */
- this.getDataAtRowProp = function (row, prop) {
- return datamap.get(row, prop);
- };
-
- /**
- * Return value at `col`
- * @param {Number} col
- * @public
- * @return value (mixed data type)
- */
- this.getDataAtCol = function (col) {
- return [].concat.apply([], datamap.getRange({row: 0, col: col}, {row: priv.settings.data.length - 1, col: col}));
- };
-
- /**
- * Return value at `prop`
- * @param {String} prop
- * @public
- * @return value (mixed data type)
- */
- this.getDataAtProp = function (prop) {
- return [].concat.apply([], datamap.getRange({row: 0, col: datamap.propToCol(prop)}, {row: priv.settings.data.length - 1, col: datamap.propToCol(prop)}));
- };
-
- /**
- * Return value at `row`
- * @param {Number} row
- * @public
- * @return value (mixed data type)
- */
- this.getDataAtRow = function (row) {
- return priv.settings.data[row];
- };
-
- /**
- * Returns cell meta data object corresponding to params row, col
- * @param {Number} row
- * @param {Number} col
- * @public
- * @return {Object}
- */
- this.getCellMeta = function (row, col) {
- var prop = datamap.colToProp(col)
- , cellProperties;
-
- row = translateRowIndex(row);
- col = translateColIndex(col);
-
- if ("undefined" === typeof priv.columnSettings[col]) {
- priv.columnSettings[col] = Handsontable.helper.columnFactory(GridSettings, priv.columnsSettingConflicts);
- }
-
- if (!priv.cellSettings[row]) {
- priv.cellSettings[row] = [];
- }
- if (!priv.cellSettings[row][col]) {
- priv.cellSettings[row][col] = new priv.columnSettings[col]();
- }
-
- cellProperties = priv.cellSettings[row][col]; //retrieve cellProperties from cache
-
- cellProperties.row = row;
- cellProperties.col = col;
- cellProperties.prop = prop;
- cellProperties.instance = instance;
-
- instance.PluginHooks.run('beforeGetCellMeta', row, col, cellProperties);
- Handsontable.helper.extend(cellProperties, expandType(cellProperties)); //for `type` added in beforeGetCellMeta
-
- if (cellProperties.cells) {
- var settings = cellProperties.cells.call(cellProperties, row, col, prop);
-
- if (settings) {
- Handsontable.helper.extend(cellProperties, settings);
- Handsontable.helper.extend(cellProperties, expandType(settings)); //for `type` added in cells
- }
- }
-
- instance.PluginHooks.run('afterGetCellMeta', row, col, cellProperties);
-
- return cellProperties;
-
- /**
- * If displayed rows order is different than the order of rows stored in memory (i.e. sorting is applied)
- * we need to translate logical (stored) row index to physical (displayed) index.
- * @param row - original row index
- * @returns {int} translated row index
- */
- function translateRowIndex(row){
- var getVars = {row: row};
-
- instance.PluginHooks.execute('beforeGet', getVars);
-
- return getVars.row;
- }
-
- /**
- * If displayed columns order is different than the order of columns stored in memory (i.e. column were moved using manualColumnMove plugin)
- * we need to translate logical (stored) column index to physical (displayed) index.
- * @param col - original column index
- * @returns {int} - translated column index
- */
- function translateColIndex(col){
- return Handsontable.PluginHooks.execute(instance, 'modifyCol', col); // warning: this must be done after datamap.colToProp
- }
- };
-
- this.getCellRenderer = function (row, col) {
- var renderer = Handsontable.helper.cellMethodLookupFactory('renderer').call(this, row, col);
- return Handsontable.renderers.getRenderer(renderer);
-
- };
-
- this.getCellEditor = Handsontable.helper.cellMethodLookupFactory('editor');
-
- this.getCellValidator = Handsontable.helper.cellMethodLookupFactory('validator');
-
-
- /**
- * Validates all cells using their validator functions and calls callback when finished. Does not render the view
- * @param callback
- */
- this.validateCells = function (callback) {
- var waitingForValidator = new ValidatorsQueue();
- waitingForValidator.onQueueEmpty = callback;
-
- var i = instance.countRows() - 1;
- while (i >= 0) {
- var j = instance.countCols() - 1;
- while (j >= 0) {
- waitingForValidator.addValidatorToQueue();
- instance.validateCell(instance.getDataAtCell(i, j), instance.getCellMeta(i, j), function () {
- waitingForValidator.removeValidatorFormQueue();
- }, 'validateCells');
- j--;
- }
- i--;
- }
- waitingForValidator.checkIfQueueIsEmpty();
- };
-
- /**
- * Return array of row headers (if they are enabled). If param `row` given, return header at given row as string
- * @param {Number} row (Optional)
- * @return {Array|String}
- */
- this.getRowHeader = function (row) {
- if (row === void 0) {
- var out = [];
- for (var i = 0, ilen = instance.countRows(); i < ilen; i++) {
- out.push(instance.getRowHeader(i));
- }
- return out;
- }
- else if (Object.prototype.toString.call(priv.settings.rowHeaders) === '[object Array]' && priv.settings.rowHeaders[row] !== void 0) {
- return priv.settings.rowHeaders[row];
- }
- else if (typeof priv.settings.rowHeaders === 'function') {
- return priv.settings.rowHeaders(row);
- }
- else if (priv.settings.rowHeaders && typeof priv.settings.rowHeaders !== 'string' && typeof priv.settings.rowHeaders !== 'number') {
- return row + 1;
- }
- else {
- return priv.settings.rowHeaders;
- }
- };
-
- /**
- * Returns information of this table is configured to display row headers
- * @returns {boolean}
- */
- this.hasRowHeaders = function () {
- return !!priv.settings.rowHeaders;
- };
-
- /**
- * Returns information of this table is configured to display column headers
- * @returns {boolean}
- */
- this.hasColHeaders = function () {
- if (priv.settings.colHeaders !== void 0 && priv.settings.colHeaders !== null) { //Polymer has empty value = null
- return !!priv.settings.colHeaders;
- }
- for (var i = 0, ilen = instance.countCols(); i < ilen; i++) {
- if (instance.getColHeader(i)) {
- return true;
- }
- }
- return false;
- };
-
- /**
- * Return array of column headers (if they are enabled). If param `col` given, return header at given column as string
- * @param {Number} col (Optional)
- * @return {Array|String}
- */
- this.getColHeader = function (col) {
- if (col === void 0) {
- var out = [];
- for (var i = 0, ilen = instance.countCols(); i < ilen; i++) {
- out.push(instance.getColHeader(i));
- }
- return out;
- }
- else {
- col = Handsontable.PluginHooks.execute(instance, 'modifyCol', col);
-
- if (priv.settings.columns && priv.settings.columns[col] && priv.settings.columns[col].title) {
- return priv.settings.columns[col].title;
- }
- else if (Object.prototype.toString.call(priv.settings.colHeaders) === '[object Array]' && priv.settings.colHeaders[col] !== void 0) {
- return priv.settings.colHeaders[col];
- }
- else if (typeof priv.settings.colHeaders === 'function') {
- return priv.settings.colHeaders(col);
- }
- else if (priv.settings.colHeaders && typeof priv.settings.colHeaders !== 'string' && typeof priv.settings.colHeaders !== 'number') {
- return Handsontable.helper.spreadsheetColumnLabel(col);
- }
- else {
- return priv.settings.colHeaders;
- }
- }
- };
-
- /**
- * Return column width from settings (no guessing). Private use intended
- * @param {Number} col
- * @return {Number}
- */
- this._getColWidthFromSettings = function (col) {
- var cellProperties = instance.getCellMeta(0, col);
- var width = cellProperties.width;
- if (width === void 0 || width === priv.settings.width) {
- width = cellProperties.colWidths;
- }
- if (width !== void 0 && width !== null) {
- switch (typeof width) {
- case 'object': //array
- width = width[col];
- break;
-
- case 'function':
- width = width(col);
- break;
- }
- if (typeof width === 'string') {
- width = parseInt(width, 10);
- }
- }
- return width;
- };
-
- /**
- * Return column width
- * @param {Number} col
- * @return {Number}
- */
- this.getColWidth = function (col) {
- col = Handsontable.PluginHooks.execute(instance, 'modifyCol', col);
- var response = {
- width: instance._getColWidthFromSettings(col)
- };
- if (!response.width) {
- response.width = 50;
- }
- instance.PluginHooks.run('afterGetColWidth', col, response);
- return response.width;
- };
-
- /**
- * Return total number of rows in grid
- * @return {Number}
- */
- this.countRows = function () {
- return priv.settings.data.length;
- };
-
- /**
- * Return total number of columns in grid
- * @return {Number}
- */
- this.countCols = function () {
- if (priv.dataType === 'object' || priv.dataType === 'function') {
- if (priv.settings.columns && priv.settings.columns.length) {
- return priv.settings.columns.length;
- }
- else {
- return priv.colToProp.length;
- }
- }
- else if (priv.dataType === 'array') {
- if (priv.settings.columns && priv.settings.columns.length) {
- return priv.settings.columns.length;
- }
- else if (priv.settings.data && priv.settings.data[0] && priv.settings.data[0].length) {
- return priv.settings.data[0].length;
- }
- else {
- return 0;
- }
- }
- };
-
- /**
- * Return index of first visible row
- * @return {Number}
- */
- this.rowOffset = function () {
- return instance.view.wt.getSetting('offsetRow');
- };
-
- /**
- * Return index of first visible column
- * @return {Number}
- */
- this.colOffset = function () {
- return instance.view.wt.getSetting('offsetColumn');
- };
-
- /**
- * Return number of visible rows. Returns -1 if table is not visible
- * @return {Number}
- */
- this.countVisibleRows = function () {
- return instance.view.wt.drawn ? instance.view.wt.wtTable.rowStrategy.countVisible() : -1;
- };
-
- /**
- * Return number of visible columns. Returns -1 if table is not visible
- * @return {Number}
- */
- this.countVisibleCols = function () {
- return instance.view.wt.drawn ? instance.view.wt.wtTable.columnStrategy.countVisible() : -1;
- };
-
- /**
- * Return number of empty rows
- * @return {Boolean} ending If true, will only count empty rows at the end of the data source
- */
- this.countEmptyRows = function (ending) {
- var i = instance.countRows() - 1
- , empty = 0;
- while (i >= 0) {
- datamap.get(i, 0);
-
- if (instance.isEmptyRow(datamap.getVars.row)) {
- empty++;
- }
- else if (ending) {
- break;
- }
- i--;
- }
- return empty;
- };
-
- /**
- * Return number of empty columns
- * @return {Boolean} ending If true, will only count empty columns at the end of the data source row
- */
- this.countEmptyCols = function (ending) {
- if (instance.countRows() < 1) {
- return 0;
- }
-
- var i = instance.countCols() - 1
- , empty = 0;
- while (i >= 0) {
- if (instance.isEmptyCol(i)) {
- empty++;
- }
- else if (ending) {
- break;
- }
- i--;
- }
- return empty;
- };
-
- /**
- * Return true if the row at the given index is empty, false otherwise
- * @param {Number} r Row index
- * @return {Boolean}
- */
- this.isEmptyRow = function (r) {
- return priv.settings.isEmptyRow.call(instance, r);
- };
-
- /**
- * Return true if the column at the given index is empty, false otherwise
- * @param {Number} c Column index
- * @return {Boolean}
- */
- this.isEmptyCol = function (c) {
- return priv.settings.isEmptyCol.call(instance, c);
- };
-
- /**
- * Selects cell on grid. Optionally selects range to another cell
- * @param {Number} row
- * @param {Number} col
- * @param {Number} [endRow]
- * @param {Number} [endCol]
- * @param {Boolean} [scrollToCell=true] If true, viewport will be scrolled to the selection
- * @public
- * @return {Boolean}
- */
- this.selectCell = function (row, col, endRow, endCol, scrollToCell) {
- if (typeof row !== 'number' || row < 0 || row >= instance.countRows()) {
- return false;
- }
- if (typeof col !== 'number' || col < 0 || col >= instance.countCols()) {
- return false;
- }
- if (typeof endRow !== "undefined") {
- if (typeof endRow !== 'number' || endRow < 0 || endRow >= instance.countRows()) {
- return false;
- }
- if (typeof endCol !== 'number' || endCol < 0 || endCol >= instance.countCols()) {
- return false;
- }
- }
- priv.selStart.coords({row: row, col: col});
- if (document.activeElement && document.activeElement !== document.documentElement && document.activeElement !== document.body) {
- document.activeElement.blur(); //needed or otherwise prepare won't focus the cell. selectionSpec tests this (should move focus to selected cell)
- }
- instance.listen();
- if (typeof endRow === "undefined") {
- selection.setRangeEnd({row: row, col: col}, scrollToCell);
- }
- else {
- selection.setRangeEnd({row: endRow, col: endCol}, scrollToCell);
- }
-
- instance.selection.finish();
- return true;
- };
-
- this.selectCellByProp = function (row, prop, endRow, endProp, scrollToCell) {
- arguments[1] = datamap.propToCol(arguments[1]);
- if (typeof arguments[3] !== "undefined") {
- arguments[3] = datamap.propToCol(arguments[3]);
- }
- return instance.selectCell.apply(instance, arguments);
- };
-
- /**
- * Deselects current sell selection on grid
- * @public
- */
- this.deselectCell = function () {
- selection.deselect();
- };
-
- /**
- * Remove grid from DOM
- * @public
- */
- this.destroy = function () {
- instance.clearTimeouts();
- if (instance.view) { //in case HT is destroyed before initialization has finished
- instance.view.wt.destroy();
- }
- instance.rootElement.empty();
- instance.rootElement.removeData('handsontable');
- instance.rootElement.off('.handsontable');
- $(window).off('.' + instance.guid);
- $document.off('.' + instance.guid);
- $body.off('.' + instance.guid);
- instance.PluginHooks.run('afterDestroy');
- };
-
- /**
- * Returns active editor object
- * @returns {Object}
- */
- this.getActiveEditor = function(){
- return editorManager.getActiveEditor();
- };
-
- /**
- * Return Handsontable instance
- * @public
- * @return {Object}
- */
- this.getInstance = function () {
- return instance.rootElement.data("handsontable");
- };
-
- (function () {
- // Create new instance of plugin hooks
- instance.PluginHooks = new Handsontable.PluginHookClass();
-
- // Upgrade methods to call of global PluginHooks instance
- var _run = instance.PluginHooks.run
- , _exe = instance.PluginHooks.execute;
-
- instance.PluginHooks.run = function (key, p1, p2, p3, p4, p5) {
- _run.call(this, instance, key, p1, p2, p3, p4, p5);
- Handsontable.PluginHooks.run(instance, key, p1, p2, p3, p4, p5);
- };
-
- instance.PluginHooks.execute = function (key, p1, p2, p3, p4, p5) {
- var globalHandlerResult = Handsontable.PluginHooks.execute(instance, key, p1, p2, p3, p4, p5);
- var localHandlerResult = _exe.call(this, instance, key, globalHandlerResult, p2, p3, p4, p5);
-
- return typeof localHandlerResult == 'undefined' ? globalHandlerResult : localHandlerResult;
-
- };
-
- // Map old API with new methods
- instance.addHook = function () {
- instance.PluginHooks.add.apply(instance.PluginHooks, arguments);
- };
- instance.addHookOnce = function () {
- instance.PluginHooks.once.apply(instance.PluginHooks, arguments);
- };
-
- instance.removeHook = function () {
- instance.PluginHooks.remove.apply(instance.PluginHooks, arguments);
- };
-
- instance.runHooks = function () {
- instance.PluginHooks.run.apply(instance.PluginHooks, arguments);
- };
- instance.runHooksAndReturn = function () {
- return instance.PluginHooks.execute.apply(instance.PluginHooks, arguments);
- };
-
- })();
-
- this.timeouts = {};
-
- /**
- * Sets timeout. Purpose of this method is to clear all known timeouts when `destroy` method is called
- * @public
- */
- this.registerTimeout = function (key, handle, ms) {
- clearTimeout(this.timeouts[key]);
- this.timeouts[key] = setTimeout(handle, ms || 0);
- };
-
- /**
- * Clears all known timeouts
- * @public
- */
- this.clearTimeouts = function () {
- for (var key in this.timeouts) {
- if (this.timeouts.hasOwnProperty(key)) {
- clearTimeout(this.timeouts[key]);
- }
- }
- };
-
- /**
- * Handsontable version
- */
- this.version = '0.10.1'; //inserted by grunt from package.json
-};
-
-var DefaultSettings = function () {};
-
-DefaultSettings.prototype = {
- data: void 0,
- width: void 0,
- height: void 0,
- startRows: 5,
- startCols: 5,
- rowHeaders: null,
- colHeaders: null,
- minRows: 0,
- minCols: 0,
- maxRows: Infinity,
- maxCols: Infinity,
- minSpareRows: 0,
- minSpareCols: 0,
- multiSelect: true,
- fillHandle: true,
- fixedRowsTop: 0,
- fixedColumnsLeft: 0,
- outsideClickDeselects: true,
- enterBeginsEditing: true,
- enterMoves: {row: 1, col: 0},
- tabMoves: {row: 0, col: 1},
- autoWrapRow: false,
- autoWrapCol: false,
- copyRowsLimit: 1000,
- copyColsLimit: 1000,
- pasteMode: 'overwrite',
- currentRowClassName: void 0,
- currentColClassName: void 0,
- stretchH: 'hybrid',
- isEmptyRow: function (r) {
- var val;
- for (var c = 0, clen = this.countCols(); c < clen; c++) {
- val = this.getDataAtCell(r, c);
- if (val !== '' && val !== null && typeof val !== 'undefined') {
- return false;
- }
- }
- return true;
- },
- isEmptyCol: function (c) {
- var val;
- for (var r = 0, rlen = this.countRows(); r < rlen; r++) {
- val = this.getDataAtCell(r, c);
- if (val !== '' && val !== null && typeof val !== 'undefined') {
- return false;
- }
- }
- return true;
- },
- observeDOMVisibility: true,
- allowInvalid: true,
- invalidCellClassName: 'htInvalid',
- placeholderCellClassName: 'htPlaceholder',
- readOnlyCellClassName: 'htDimmed',
- fragmentSelection: false,
- readOnly: false,
- nativeScrollbars: false,
- type: 'text',
- debug: false //shows debug overlays in Walkontable
-};
-Handsontable.DefaultSettings = DefaultSettings;
-
-$.fn.handsontable = function (action) {
- var i
- , ilen
- , args
- , output
- , userSettings
- , $this = this.first() // Use only first element from list
- , instance = $this.data('handsontable');
-
- // Init case
- if (typeof action !== 'string') {
- userSettings = action || {};
- if (instance) {
- instance.updateSettings(userSettings);
- }
- else {
- instance = new Handsontable.Core($this, userSettings);
- $this.data('handsontable', instance);
- instance.init();
- }
-
- return $this;
- }
- // Action case
- else {
- args = [];
- if (arguments.length > 1) {
- for (i = 1, ilen = arguments.length; i < ilen; i++) {
- args.push(arguments[i]);
- }
- }
-
- if (instance) {
- if (typeof instance[action] !== 'undefined') {
- output = instance[action].apply(instance, args);
- }
- else {
- throw new Error('Handsontable do not provide action: ' + action);
- }
- }
-
- return output;
- }
-};
-
-/**
- * Handsontable TableView constructor
- * @param {Object} instance
- */
-Handsontable.TableView = function (instance) {
- var that = this
- , $window = $(window)
- , $documentElement = $(document.documentElement);
-
- this.instance = instance;
- this.settings = instance.getSettings();
- this.settingsFromDOM = instance.getSettingsFromDOM();
-
- instance.rootElement.data('originalStyle', instance.rootElement[0].getAttribute('style')); //needed to retrieve original style in jsFiddle link generator in HT examples. may be removed in future versions
- // in IE7 getAttribute('style') returns an object instead of a string, but we only support IE8+
-
- instance.rootElement.addClass('handsontable');
-
- var table = document.createElement('TABLE');
- table.className = 'htCore';
- this.THEAD = document.createElement('THEAD');
- table.appendChild(this.THEAD);
- this.TBODY = document.createElement('TBODY');
- table.appendChild(this.TBODY);
-
- instance.$table = $(table);
- instance.rootElement.prepend(instance.$table);
-
- instance.rootElement.on('mousedown.handsontable', function (event) {
- if (!that.isTextSelectionAllowed(event.target)) {
- clearTextSelection();
- event.preventDefault();
- window.focus(); //make sure that window that contains HOT is active. Important when HOT is in iframe.
- }
- });
-
- $documentElement.on('keyup.' + instance.guid, function (event) {
- if (instance.selection.isInProgress() && !event.shiftKey) {
- instance.selection.finish();
- }
- });
-
- var isMouseDown;
-
- $documentElement.on('mouseup.' + instance.guid, function (event) {
- if (instance.selection.isInProgress() && event.which === 1) { //is left mouse button
- instance.selection.finish();
- }
-
- isMouseDown = false;
-
- if (instance.autofill.handle && instance.autofill.handle.isDragged) {
- if (instance.autofill.handle.isDragged > 1) {
- instance.autofill.apply();
- }
- instance.autofill.handle.isDragged = 0;
- }
-
- if (Handsontable.helper.isOutsideInput(document.activeElement)) {
- instance.unlisten();
- }
- });
-
- $documentElement.on('mousedown.' + instance.guid, function (event) {
- var next = event.target;
-
- if (next !== that.wt.wtTable.spreader) { //immediate click on "spreader" means click on the right side of vertical scrollbar
- while (next !== document.documentElement) {
- if (next === null) {
- return; //click on something that was a row but now is detached (possibly because your click triggered a rerender)
- }
- if (next === instance.rootElement[0] || next.nodeName === 'HANDSONTABLE-TABLE') {
- return; //click inside container or Web Component (HANDSONTABLE-TABLE is the name of the custom element)
- }
- if ($(next).hasClass('toolbutton')) return; //ANDI, issue #1267
- if ($(next).hasClass('pickerbutton')) return; //ANDI, issue #1267
-
- next = next.parentNode;
- }
- }
-
- if (that.settings.outsideClickDeselects) {
- instance.deselectCell();
- }
- else {
- instance.destroyEditor();
- }
- });
-
- instance.rootElement.on('mousedown.handsontable', '.dragdealer', function () {
- instance.destroyEditor();
- });
-
- instance.$table.on('selectstart', function (event) {
- if (that.settings.fragmentSelection) {
- return;
- }
-
- //https://github.com/warpech/jquery-handsontable/issues/160
- //selectstart is IE only event. Prevent text from being selected when performing drag down in IE8
- event.preventDefault();
- });
-
- var clearTextSelection = function () {
- //http://stackoverflow.com/questions/3169786/clear-text-selection-with-javascript
- if (document.getSelection) {
- if (document.getSelection().empty) { // Chrome
- document.getSelection().empty();
- } else if (document.getSelection().removeAllRanges) { // Firefox
- document.getSelection().removeAllRanges();
- }
- } else if (document.selection) { // IE?
- try { document.selection.empty(); } catch(e) { /* absorb ie8 bug */ }
- }
- };
-
- var walkontableConfig = {
- debug: function () {
- return that.settings.debug;
- },
- table: table,
- stretchH: this.settings.stretchH,
- data: instance.getDataAtCell,
- totalRows: instance.countRows,
- totalColumns: instance.countCols,
- nativeScrollbars: this.settings.nativeScrollbars,
- offsetRow: 0,
- offsetColumn: 0,
- width: this.getWidth(),
- height: this.getHeight(),
- fixedColumnsLeft: function () {
- return that.settings.fixedColumnsLeft;
- },
- fixedRowsTop: function () {
- return that.settings.fixedRowsTop;
- },
- rowHeaders: function () {
- return instance.hasRowHeaders() ? [function (index, TH) {
- that.appendRowHeader(index, TH);
- }] : []
- },
- columnHeaders: function () {
- return instance.hasColHeaders() ? [function (index, TH) {
- that.appendColHeader(index, TH);
- }] : []
- },
- columnWidth: instance.getColWidth,
- cellRenderer: function (row, col, TD) {
-
- var prop = that.instance.colToProp(col)
- , cellProperties = that.instance.getCellMeta(row, col)
- , renderer = that.instance.getCellRenderer(cellProperties);
-
- var value = that.instance.getDataAtRowProp(row, prop);
-
- renderer(that.instance, TD, row, col, prop, value, cellProperties);
-
- that.instance.PluginHooks.run('afterRenderer', TD, row, col, prop, value, cellProperties);
-
- },
- selections: {
- current: {
- className: 'current',
- border: {
- width: 2,
- color: '#5292F7',
- style: 'solid',
- cornerVisible: function () {
- return that.settings.fillHandle && !that.isCellEdited() && !instance.selection.isMultiple()
- }
- }
- },
- area: {
- className: 'area',
- border: {
- width: 1,
- color: '#89AFF9',
- style: 'solid',
- cornerVisible: function () {
- return that.settings.fillHandle && !that.isCellEdited() && instance.selection.isMultiple()
- }
- }
- },
- highlight: {
- highlightRowClassName: that.settings.currentRowClassName,
- highlightColumnClassName: that.settings.currentColClassName
- },
- fill: {
- className: 'fill',
- border: {
- width: 1,
- color: 'red',
- style: 'solid'
- }
- }
- },
- hideBorderOnMouseDownOver: function () {
- return that.settings.fragmentSelection;
- },
- onCellMouseDown: function (event, coords, TD) {
- instance.listen();
-
- isMouseDown = true;
- var coordsObj = {row: coords[0], col: coords[1]};
- if (event.button === 2 && instance.selection.inInSelection(coordsObj)) { //right mouse button
- //do nothing
- }
- else if (event.shiftKey) {
- instance.selection.setRangeEnd(coordsObj);
- }
- else {
- instance.selection.setRangeStart(coordsObj);
- }
-
- instance.PluginHooks.run('afterOnCellMouseDown', event, coords, TD);
- },
- /*onCellMouseOut: function (/*event, coords, TD* /) {
- if (isMouseDown && that.settings.fragmentSelection === 'single') {
- clearTextSelection(); //otherwise text selection blinks during multiple cells selection
- }
- },*/
- onCellMouseOver: function (event, coords, TD) {
- var coordsObj = {row: coords[0], col: coords[1]};
- if (isMouseDown) {
- /*if (that.settings.fragmentSelection === 'single') {
- clearTextSelection(); //otherwise text selection blinks during multiple cells selection
- }*/
- instance.selection.setRangeEnd(coordsObj);
- }
- else if (instance.autofill.handle && instance.autofill.handle.isDragged) {
- instance.autofill.handle.isDragged++;
- instance.autofill.showBorder(coords);
- }
- instance.PluginHooks.run('afterOnCellMouseOver', event, coords, TD);
- },
- onCellCornerMouseDown: function (event) {
- instance.autofill.handle.isDragged = 1;
- event.preventDefault();
- instance.PluginHooks.run('afterOnCellCornerMouseDown', event);
- },
- onCellCornerDblClick: function () {
- instance.autofill.selectAdjacent();
- },
- beforeDraw: function (force) {
- that.beforeRender(force);
- },
- onDraw: function(force){
- that.onDraw(force);
- },
- onScrollVertically: function () {
- instance.runHooks('afterScrollVertically');
- },
- onScrollHorizontally: function () {
- instance.runHooks('afterScrollHorizontally');
- }
- };
-
- instance.PluginHooks.run('beforeInitWalkontable', walkontableConfig);
-
- this.wt = new Walkontable(walkontableConfig);
-
- $window.on('resize.' + instance.guid, function () {
- instance.registerTimeout('resizeTimeout', function () {
- instance.parseSettingsFromDOM();
- var newWidth = that.getWidth();
- var newHeight = that.getHeight();
- if (walkontableConfig.width !== newWidth || walkontableConfig.height !== newHeight) {
- instance.forceFullRender = true;
- that.render();
- walkontableConfig.width = newWidth;
- walkontableConfig.height = newHeight;
- }
- }, 60);
- });
-
- $(that.wt.wtTable.spreader).on('mousedown.handsontable, contextmenu.handsontable', function (event) {
- if (event.target === that.wt.wtTable.spreader && event.which === 3) { //right mouse button exactly on spreader means right clickon the right hand side of vertical scrollbar
- event.stopPropagation();
- }
- });
-
- $documentElement.on('click.' + instance.guid, function () {
- if (that.settings.observeDOMVisibility) {
- if (that.wt.drawInterrupted) {
- that.instance.forceFullRender = true;
- that.render();
- }
- }
- });
-};
-
-Handsontable.TableView.prototype.isTextSelectionAllowed = function (el) {
- if ( Handsontable.helper.isInput(el) ) {
- return (true);
- }
- if (this.settings.fragmentSelection && this.wt.wtDom.isChildOf(el, this.TBODY)) {
- return (true);
- }
- return false;
-};
-
-Handsontable.TableView.prototype.isCellEdited = function () {
- var activeEditor = this.instance.getActiveEditor();
- return activeEditor && activeEditor.isOpened();
-};
-
-Handsontable.TableView.prototype.getWidth = function () {
- var val = this.settings.width !== void 0 ? this.settings.width : this.settingsFromDOM.width;
- return typeof val === 'function' ? val() : val;
-};
-
-Handsontable.TableView.prototype.getHeight = function () {
- var val = this.settings.height !== void 0 ? this.settings.height : this.settingsFromDOM.height;
- return typeof val === 'function' ? val() : val;
-};
-
-Handsontable.TableView.prototype.beforeRender = function (force) {
- if (force) { //force = did Walkontable decide to do full render
- this.instance.PluginHooks.run('beforeRender', this.instance.forceFullRender); //this.instance.forceFullRender = did Handsontable request full render?
- this.wt.update('width', this.getWidth());
- this.wt.update('height', this.getHeight());
- }
-};
-
-Handsontable.TableView.prototype.onDraw = function(force){
- if (force) { //force = did Walkontable decide to do full render
- this.instance.PluginHooks.run('afterRender', this.instance.forceFullRender); //this.instance.forceFullRender = did Handsontable request full render?
- }
-};
-
-Handsontable.TableView.prototype.render = function () {
- this.wt.draw(!this.instance.forceFullRender);
- this.instance.forceFullRender = false;
- this.instance.rootElement.triggerHandler('render.handsontable');
-};
-
-/**
- * Returns td object given coordinates
- */
-Handsontable.TableView.prototype.getCellAtCoords = function (coords) {
- var td = this.wt.wtTable.getCell([coords.row, coords.col]);
- if (td < 0) { //there was an exit code (cell is out of bounds)
- return null;
- }
- else {
- return td;
- }
-};
-
-/**
- * Scroll viewport to selection
- * @param coords
- */
-Handsontable.TableView.prototype.scrollViewport = function (coords) {
- this.wt.scrollViewport([coords.row, coords.col]);
-};
-
-/**
- * Append row header to a TH element
- * @param row
- * @param TH
- */
-Handsontable.TableView.prototype.appendRowHeader = function (row, TH) {
- var DIV = document.createElement('DIV')
- , SPAN = document.createElement('SPAN');
-
- DIV.className = 'relative';
- SPAN.className = 'colHeader';
-
- if (row < 0) {
- this.wt.wtDom.fastInnerText(DIV, '\u00A0');
- } else {
- this.wt.wtDom.fastInnerHTML(SPAN, this.instance.getRowHeader(row));
- DIV.appendChild(SPAN);
- }
-
- this.wt.wtDom.empty(TH);
- TH.appendChild(DIV);
-
- this.instance.PluginHooks.run('afterGetRowHeader', row, TH);
-};
-
-/**
- * Append column header to a TH element
- * @param col
- * @param TH
- */
-Handsontable.TableView.prototype.appendColHeader = function (col, TH) {
- var DIV = document.createElement('DIV')
- , SPAN = document.createElement('SPAN');
-
- DIV.className = 'relative';
- SPAN.className = 'colHeader';
-
- this.wt.wtDom.fastInnerHTML(SPAN, this.instance.getColHeader(col));
- DIV.appendChild(SPAN);
-
- this.wt.wtDom.empty(TH);
- TH.appendChild(DIV);
- this.instance.PluginHooks.run('afterGetColHeader', col, TH);
-};
-
-/**
- * Given a element's left position relative to the viewport, returns maximum element width until the right edge of the viewport (before scrollbar)
- * @param {Number} left
- * @return {Number}
- */
-Handsontable.TableView.prototype.maximumVisibleElementWidth = function (left) {
- var rootWidth = this.wt.wtViewport.getWorkspaceWidth();
- if(this.settings.nativeScrollbars) {
- return rootWidth;
- }
- return rootWidth - left;
-};
-
-/**
- * Given a element's top position relative to the viewport, returns maximum element height until the bottom edge of the viewport (before scrollbar)
- * @param {Number} top
- * @return {Number}
- */
-Handsontable.TableView.prototype.maximumVisibleElementHeight = function (top) {
- var rootHeight = this.wt.wtViewport.getWorkspaceHeight();
- if(this.settings.nativeScrollbars) {
- return rootHeight;
- }
- return rootHeight - top;
-};
-
-/**
- * Utility to register editors and common namespace for keeping reference to all editor classes
- */
-(function (Handsontable) {
- 'use strict';
-
- function RegisteredEditor(editorClass) {
- var clazz, instances;
-
- instances = {};
- clazz = editorClass;
-
- this.getInstance = function (hotInstance) {
- if (!(hotInstance.guid in instances)) {
- instances[hotInstance.guid] = new clazz(hotInstance);
- }
-
- return instances[hotInstance.guid];
- }
-
- }
-
- var registeredEditorNames = {};
- var registeredEditorClasses = new WeakMap();
-
- Handsontable.editors = {
-
- /**
- * Registers editor under given name
- * @param {String} editorName
- * @param {Function} editorClass
- */
- registerEditor: function (editorName, editorClass) {
- var editor = new RegisteredEditor(editorClass);
- if (typeof editorName === "string") {
- registeredEditorNames[editorName] = editor;
- }
- registeredEditorClasses.set(editorClass, editor);
- },
-
- /**
- * Returns instance (singleton) of editor class
- * @param {String|Function} editorName/editorClass
- * @returns {Function} editorClass
- */
- getEditor: function (editorName, hotInstance) {
- var editor;
- if (typeof editorName == 'function') {
- if (!(registeredEditorClasses.get(editorName))) {
- this.registerEditor(null, editorName);
- }
- editor = registeredEditorClasses.get(editorName);
- }
- else if (typeof editorName == 'string') {
- editor = registeredEditorNames[editorName];
- }
- else {
- throw Error('Only strings and functions can be passed as "editor" parameter ');
- }
-
- if (!editor) {
- throw Error('No editor registered under name "' + editorName + '"');
- }
-
- return editor.getInstance(hotInstance);
- }
-
- };
-
-
-})(Handsontable);
-
-(function(Handsontable){
- 'use strict';
-
- Handsontable.EditorManager = function(instance, priv, selection){
- var that = this;
- var $document = $(document);
- var keyCodes = Handsontable.helper.keyCode;
-
- var activeEditor;
-
- var init = function () {
-
- function onKeyDown(event) {
-
- if (!instance.isListening()) {
- return;
- }
-
- if (priv.settings.beforeOnKeyDown) { // HOT in HOT Plugin
- priv.settings.beforeOnKeyDown.call(instance, event);
- }
-
- instance.PluginHooks.run('beforeKeyDown', event);
-
- if (!event.isImmediatePropagationStopped()) {
-
- priv.lastKeyCode = event.keyCode;
- if (selection.isSelected()) {
- var ctrlDown = (event.ctrlKey || event.metaKey) && !event.altKey; //catch CTRL but not right ALT (which in some systems triggers ALT+CTRL)
-
- if (!activeEditor.isWaiting()) {
- if (!Handsontable.helper.isMetaKey(event.keyCode) && !ctrlDown) {
- that.openEditor('');
- event.stopPropagation(); //required by HandsontableEditor
- return;
- }
- }
-
- var rangeModifier = event.shiftKey ? selection.setRangeEnd : selection.setRangeStart;
-
- switch (event.keyCode) {
-
- case keyCodes.A:
- if (ctrlDown) {
- selection.selectAll(); //select all cells
-
- event.preventDefault();
- event.stopPropagation();
- break;
- }
-
- case keyCodes.ARROW_UP:
-
- if (that.isEditorOpened() && !activeEditor.isWaiting()){
- that.closeEditorAndSaveChanges(ctrlDown);
- }
-
- moveSelectionUp(event.shiftKey);
-
- event.preventDefault();
- event.stopPropagation(); //required by HandsontableEditor
- break;
-
- case keyCodes.ARROW_DOWN:
- if (that.isEditorOpened() && !activeEditor.isWaiting()){
- that.closeEditorAndSaveChanges(ctrlDown);
- }
-
- moveSelectionDown(event.shiftKey);
-
- event.preventDefault();
- event.stopPropagation(); //required by HandsontableEditor
- break;
-
- case keyCodes.ARROW_RIGHT:
- if(that.isEditorOpened() && !activeEditor.isWaiting()){
- that.closeEditorAndSaveChanges(ctrlDown);
- }
-
- moveSelectionRight(event.shiftKey);
-
- event.preventDefault();
- event.stopPropagation(); //required by HandsontableEditor
- break;
-
- case keyCodes.ARROW_LEFT:
- if(that.isEditorOpened() && !activeEditor.isWaiting()){
- that.closeEditorAndSaveChanges(ctrlDown);
- }
-
- moveSelectionLeft(event.shiftKey);
-
- event.preventDefault();
- event.stopPropagation(); //required by HandsontableEditor
- break;
-
- case keyCodes.TAB:
- var tabMoves = typeof priv.settings.tabMoves === 'function' ? priv.settings.tabMoves(event) : priv.settings.tabMoves;
- if (event.shiftKey) {
- selection.transformStart(-tabMoves.row, -tabMoves.col); //move selection left
- }
- else {
- selection.transformStart(tabMoves.row, tabMoves.col, true); //move selection right (add a new column if needed)
- }
- event.preventDefault();
- event.stopPropagation(); //required by HandsontableEditor
- break;
-
- case keyCodes.BACKSPACE:
- case keyCodes.DELETE:
- selection.empty(event);
- that.prepareEditor();
- event.preventDefault();
- break;
-
- case keyCodes.F2: /* F2 */
- that.openEditor();
- event.preventDefault(); //prevent Opera from opening Go to Page dialog
- break;
-
- case keyCodes.ENTER: /* return/enter */
- if(that.isEditorOpened()){
-
- if (activeEditor.state !== Handsontable.EditorState.WAITING){
- that.closeEditorAndSaveChanges(ctrlDown);
- }
-
- moveSelectionAfterEnter(event.shiftKey);
-
- } else {
-
- if (instance.getSettings().enterBeginsEditing){
- that.openEditor();
- } else {
- moveSelectionAfterEnter(event.shiftKey);
- }
-
- }
-
- event.preventDefault(); //don't add newline to field
- event.stopImmediatePropagation(); //required by HandsontableEditor
- break;
-
- case keyCodes.ESCAPE:
- if(that.isEditorOpened()){
- that.closeEditorAndRestoreOriginalValue(ctrlDown);
- }
- event.preventDefault();
- break;
-
- case keyCodes.HOME:
- if (event.ctrlKey || event.metaKey) {
- rangeModifier({row: 0, col: priv.selStart.col()});
- }
- else {
- rangeModifier({row: priv.selStart.row(), col: 0});
- }
- event.preventDefault(); //don't scroll the window
- event.stopPropagation(); //required by HandsontableEditor
- break;
-
- case keyCodes.END:
- if (event.ctrlKey || event.metaKey) {
- rangeModifier({row: instance.countRows() - 1, col: priv.selStart.col()});
- }
- else {
- rangeModifier({row: priv.selStart.row(), col: instance.countCols() - 1});
- }
- event.preventDefault(); //don't scroll the window
- event.stopPropagation(); //required by HandsontableEditor
- break;
-
- case keyCodes.PAGE_UP:
- selection.transformStart(-instance.countVisibleRows(), 0);
- instance.view.wt.scrollVertical(-instance.countVisibleRows());
- instance.view.render();
- event.preventDefault(); //don't page up the window
- event.stopPropagation(); //required by HandsontableEditor
- break;
-
- case keyCodes.PAGE_DOWN:
- selection.transformStart(instance.countVisibleRows(), 0);
- instance.view.wt.scrollVertical(instance.countVisibleRows());
- instance.view.render();
- event.preventDefault(); //don't page down the window
- event.stopPropagation(); //required by HandsontableEditor
- break;
-
- default:
- break;
- }
-
- }
- }
- }
- $document.on('keydown.handsontable.' + instance.guid, onKeyDown);
-
- function onDblClick() {
-// that.instance.destroyEditor();
- that.openEditor();
- }
-
- instance.view.wt.update('onCellDblClick', onDblClick);
-
- instance.addHook('afterDestroy', function(){
- $document.off('keydown.handsontable.' + instance.guid);
- });
-
- function moveSelectionAfterEnter(shiftKey){
- var enterMoves = typeof priv.settings.enterMoves === 'function' ? priv.settings.enterMoves(event) : priv.settings.enterMoves;
-
- if (shiftKey) {
- selection.transformStart(-enterMoves.row, -enterMoves.col); //move selection up
- }
- else {
- selection.transformStart(enterMoves.row, enterMoves.col, true); //move selection down (add a new row if needed)
- }
- }
-
- function moveSelectionUp(shiftKey){
- if (shiftKey) {
- selection.transformEnd(-1, 0);
- }
- else {
- selection.transformStart(-1, 0);
- }
- }
-
- function moveSelectionDown(shiftKey){
- if (shiftKey) {
- selection.transformEnd(1, 0); //expanding selection down with shift
- }
- else {
- selection.transformStart(1, 0); //move selection down
- }
- }
-
- function moveSelectionRight(shiftKey){
- if (shiftKey) {
- selection.transformEnd(0, 1);
- }
- else {
- selection.transformStart(0, 1);
- }
- }
-
- function moveSelectionLeft(shiftKey){
- if (shiftKey) {
- selection.transformEnd(0, -1);
- }
- else {
- selection.transformStart(0, -1);
- }
- }
- };
-
- /**
- * Destroy current editor, if exists
- * @param {Boolean} revertOriginal
- */
- this.destroyEditor = function (revertOriginal) {
- this.closeEditor(revertOriginal);
- };
-
- this.getActiveEditor = function () {
- return activeEditor;
- };
-
- /**
- * Prepare text input to be displayed at given grid cell
- */
- this.prepareEditor = function () {
-
- if (activeEditor && activeEditor.isWaiting()){
-
- this.closeEditor(false, false, function(dataSaved){
- if(dataSaved){
- that.prepareEditor();
- }
- });
-
- return;
- }
-
- var row = priv.selStart.row();
- var col = priv.selStart.col();
- var prop = instance.colToProp(col);
- var td = instance.getCell(row, col);
- var originalValue = instance.getDataAtCell(row, col);
- var cellProperties = instance.getCellMeta(row, col);
-
- var editorClass = instance.getCellEditor(cellProperties);
- activeEditor = Handsontable.editors.getEditor(editorClass, instance);
-
- activeEditor.prepare(row, col, prop, td, originalValue, cellProperties);
-
- };
-
- this.isEditorOpened = function () {
- return activeEditor.isOpened();
- };
-
- this.openEditor = function (initialValue) {
- activeEditor.beginEditing(initialValue);
- };
-
- this.closeEditor = function (restoreOriginalValue, ctrlDown, callback) {
-
- if (!activeEditor){
- if(callback) {
- callback(false);
- }
- }
- else {
- activeEditor.finishEditing(restoreOriginalValue, ctrlDown, callback);
- }
- };
-
- this.closeEditorAndSaveChanges = function(ctrlDown){
- return this.closeEditor(false, ctrlDown);
- };
-
- this.closeEditorAndRestoreOriginalValue = function(ctrlDown){
- return this.closeEditor(true, ctrlDown);
- };
-
- init();
- };
-
-})(Handsontable);
-
-/**
- * Utility to register renderers and common namespace for keeping reference to all renderers classes
- */
-(function (Handsontable) {
- 'use strict';
-
- var registeredRenderers = {};
-
- Handsontable.renderers = {
-
- /**
- * Registers renderer under given name
- * @param {String} rendererName
- * @param {Function} rendererFunction
- */
- registerRenderer: function (rendererName, rendererFunction) {
- registeredRenderers[rendererName] = rendererFunction
- },
-
- /**
- * @param {String|Function} rendererName/rendererFunction
- * @returns {Function} rendererFunction
- */
- getRenderer: function (rendererName) {
- if (typeof rendererName == 'function'){
- return rendererName;
- }
-
- if (typeof rendererName != 'string'){
- throw Error('Only strings and functions can be passed as "renderer" parameter ');
- }
-
- if (!(rendererName in registeredRenderers)) {
- throw Error('No editor registered under name "' + rendererName + '"');
- }
-
- return registeredRenderers[rendererName];
- }
-
- };
-
-
-})(Handsontable);
-
-/**
- * DOM helper optimized for maximum performance
- * It is recommended for Handsontable plugins and renderers, because it is much faster than jQuery
- * @type {WalkonableDom}
- */
-Handsontable.Dom = new WalkontableDom();
-
-/**
- * Returns true if keyCode represents a printable character
- * @param {Number} keyCode
- * @return {Boolean}
- */
-Handsontable.helper.isPrintableChar = function (keyCode) {
- return ((keyCode == 32) || //space
- (keyCode >= 48 && keyCode <= 57) || //0-9
- (keyCode >= 96 && keyCode <= 111) || //numpad
- (keyCode >= 186 && keyCode <= 192) || //;=,-./`
- (keyCode >= 219 && keyCode <= 222) || //[]{}\|"'
- keyCode >= 226 || //special chars (229 for Asian chars)
- (keyCode >= 65 && keyCode <= 90)); //a-z
-};
-
-Handsontable.helper.isMetaKey = function (keyCode) {
- var keyCodes = Handsontable.helper.keyCode;
- var metaKeys = [
- keyCodes.ARROW_DOWN,
- keyCodes.ARROW_UP,
- keyCodes.ARROW_LEFT,
- keyCodes.ARROW_RIGHT,
- keyCodes.HOME,
- keyCodes.END,
- keyCodes.DELETE,
- keyCodes.BACKSPACE,
- keyCodes.F1,
- keyCodes.F2,
- keyCodes.F3,
- keyCodes.F4,
- keyCodes.F5,
- keyCodes.F6,
- keyCodes.F7,
- keyCodes.F8,
- keyCodes.F9,
- keyCodes.F10,
- keyCodes.F11,
- keyCodes.F12,
- keyCodes.TAB,
- keyCodes.PAGE_DOWN,
- keyCodes.PAGE_UP,
- keyCodes.ENTER,
- keyCodes.ESCAPE,
- keyCodes.SHIFT,
- keyCodes.CAPS_LOCK,
- keyCodes.ALT
- ];
-
- return metaKeys.indexOf(keyCode) != -1;
-};
-
-Handsontable.helper.isCtrlKey = function (keyCode) {
-
- var keys = Handsontable.helper.keyCode;
-
- return [keys.CONTROL_LEFT, 224, keys.COMMAND_LEFT, keys.COMMAND_RIGHT].indexOf(keyCode) != -1;
-};
-
-/**
- * Converts a value to string
- * @param value
- * @return {String}
- */
-Handsontable.helper.stringify = function (value) {
- switch (typeof value) {
- case 'string':
- case 'number':
- return value + '';
- break;
-
- case 'object':
- if (value === null) {
- return '';
- }
- else {
- return value.toString();
- }
- break;
-
- case 'undefined':
- return '';
- break;
-
- default:
- return value.toString();
- }
-};
-
-/**
- * Generates spreadsheet-like column names: A, B, C, ..., Z, AA, AB, etc
- * @param index
- * @returns {String}
- */
-Handsontable.helper.spreadsheetColumnLabel = function (index) {
- var dividend = index + 1;
- var columnLabel = '';
- var modulo;
- while (dividend > 0) {
- modulo = (dividend - 1) % 26;
- columnLabel = String.fromCharCode(65 + modulo) + columnLabel;
- dividend = parseInt((dividend - modulo) / 26, 10);
- }
- return columnLabel;
-};
-
-/**
- * Checks if value of n is a numeric one
- * http://jsperf.com/isnan-vs-isnumeric/4
- * @param n
- * @returns {boolean}
- */
-Handsontable.helper.isNumeric = function (n) {
- var t = typeof n;
- return t == 'number' ? !isNaN(n) && isFinite(n) :
- t == 'string' ? !n.length ? false :
- n.length == 1 ? /\d/.test(n) :
- /^\s*[+-]?\s*(?:(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?)|(?:0x[a-f\d]+))\s*$/i.test(n) :
- t == 'object' ? !!n && typeof n.valueOf() == "number" && !(n instanceof Date) : false;
-};
-
-Handsontable.helper.isArray = function (obj) {
- return Object.prototype.toString.call(obj).match(/array/i) !== null;
-};
-
-/**
- * Checks if child is a descendant of given parent node
- * http://stackoverflow.com/questions/2234979/how-to-check-in-javascript-if-one-element-is-a-child-of-another
- * @param parent
- * @param child
- * @returns {boolean}
- */
-Handsontable.helper.isDescendant = function (parent, child) {
- var node = child.parentNode;
- while (node != null) {
- if (node == parent) {
- return true;
- }
- node = node.parentNode;
- }
- return false;
-};
-
-/**
- * Generates a random hex string. Used as namespace for Handsontable instance events.
- * @return {String} - 16 character random string: "92b1bfc74ec4"
- */
-Handsontable.helper.randomString = function () {
- return walkontableRandomString();
-};
-
-/**
- * Inherit without without calling parent constructor, and setting `Child.prototype.constructor` to `Child` instead of `Parent`.
- * Creates temporary dummy function to call it as constructor.
- * Described in ticket: https://github.com/warpech/jquery-handsontable/pull/516
- * @param {Object} Child child class
- * @param {Object} Parent parent class
- * @return {Object} extended Child
- */
-Handsontable.helper.inherit = function (Child, Parent) {
- Parent.prototype.constructor = Parent;
- Child.prototype = new Parent();
- Child.prototype.constructor = Child;
- return Child;
-};
-
-/**
- * Perform shallow extend of a target object with extension's own properties
- * @param {Object} target An object that will receive the new properties
- * @param {Object} extension An object containing additional properties to merge into the target
- */
-Handsontable.helper.extend = function (target, extension) {
- for (var i in extension) {
- if (extension.hasOwnProperty(i)) {
- target[i] = extension[i];
- }
- }
-};
-
-Handsontable.helper.getPrototypeOf = function (obj) {
- var prototype;
-
- if(typeof obj.__proto__ == "object"){
- prototype = obj.__proto__;
- } else {
- var oldConstructor,
- constructor = obj.constructor;
-
- if (typeof obj.constructor == "function") {
- oldConstructor = constructor;
-
- if (delete obj.constructor){
- constructor = obj.constructor; // get real constructor
- obj.constructor = oldConstructor; // restore constructor
- }
-
-
- }
-
- prototype = constructor ? constructor.prototype : null; // needed for IE
-
- }
-
- return prototype;
-};
-
-/**
- * Factory for columns constructors.
- * @param {Object} GridSettings
- * @param {Array} conflictList
- * @return {Object} ColumnSettings
- */
-Handsontable.helper.columnFactory = function (GridSettings, conflictList) {
- function ColumnSettings () {}
-
- Handsontable.helper.inherit(ColumnSettings, GridSettings);
-
- // Clear conflict settings
- for (var i = 0, len = conflictList.length; i < len; i++) {
- ColumnSettings.prototype[conflictList[i]] = void 0;
- }
-
- return ColumnSettings;
-};
-
-Handsontable.helper.translateRowsToColumns = function (input) {
- var i
- , ilen
- , j
- , jlen
- , output = []
- , olen = 0;
-
- for (i = 0, ilen = input.length; i < ilen; i++) {
- for (j = 0, jlen = input[i].length; j < jlen; j++) {
- if (j == olen) {
- output.push([]);
- olen++;
- }
- output[j].push(input[i][j])
- }
- }
- return output;
-};
-
-Handsontable.helper.to2dArray = function (arr) {
- var i = 0
- , ilen = arr.length;
- while (i < ilen) {
- arr[i] = [arr[i]];
- i++;
- }
-};
-
-Handsontable.helper.extendArray = function (arr, extension) {
- var i = 0
- , ilen = extension.length;
- while (i < ilen) {
- arr.push(extension[i]);
- i++;
- }
-};
-
-/**
- * Determines if the given DOM element is an input field.
- * Notice: By 'input' we mean input, textarea and select nodes
- * @param element - DOM element
- * @returns {boolean}
- */
-Handsontable.helper.isInput = function (element) {
- var inputs = ['INPUT', 'SELECT', 'TEXTAREA'];
-
- return inputs.indexOf(element.nodeName) > -1;
-};
-
-/**
- * Determines if the given DOM element is an input field placed OUTSIDE of HOT.
- * Notice: By 'input' we mean input, textarea and select nodes
- * @param element - DOM element
- * @returns {boolean}
- */
-Handsontable.helper.isOutsideInput = function (element) {
- return Handsontable.helper.isInput(element) && element.className.indexOf('handsontableInput') == -1;
-};
-
-Handsontable.helper.keyCode = {
- MOUSE_LEFT: 1,
- MOUSE_RIGHT: 3,
- MOUSE_MIDDLE: 2,
- BACKSPACE: 8,
- COMMA: 188,
- DELETE: 46,
- END: 35,
- ENTER: 13,
- ESCAPE: 27,
- CONTROL_LEFT: 91,
- COMMAND_LEFT: 17,
- COMMAND_RIGHT: 93,
- ALT: 18,
- HOME: 36,
- PAGE_DOWN: 34,
- PAGE_UP: 33,
- PERIOD: 190,
- SPACE: 32,
- SHIFT: 16,
- CAPS_LOCK: 20,
- TAB: 9,
- ARROW_RIGHT: 39,
- ARROW_LEFT: 37,
- ARROW_UP: 38,
- ARROW_DOWN: 40,
- F1: 112,
- F2: 113,
- F3: 114,
- F4: 115,
- F5: 116,
- F6: 117,
- F7: 118,
- F8: 119,
- F9: 120,
- F10: 121,
- F11: 122,
- F12: 123,
- A: 65,
- X: 88,
- C: 67,
- V: 86
-};
-
-/**
- * Determines whether given object is a plain Object.
- * Note: String and Array are not plain Objects
- * @param {*} obj
- * @returns {boolean}
- */
-Handsontable.helper.isObject = function (obj) {
- return Object.prototype.toString.call(obj) == '[object Object]';
-};
-
-/**
- * Determines whether given object is an Array.
- * Note: String is not an Array
- * @param {*} obj
- * @returns {boolean}
- */
-Handsontable.helper.isArray = function(obj){
- return Array.isArray ? Array.isArray(obj) : Object.prototype.toString.call(obj) == '[object Array]';
-};
-
-Handsontable.helper.pivot = function (arr) {
- var pivotedArr = [];
-
- if(!arr || arr.length == 0 || !arr[0] || arr[0].length == 0){
- return pivotedArr;
- }
-
- var rowCount = arr.length;
- var colCount = arr[0].length;
-
- for(var i = 0; i < rowCount; i++){
- for(var j = 0; j < colCount; j++){
- if(!pivotedArr[j]){
- pivotedArr[j] = [];
- }
-
- pivotedArr[j][i] = arr[i][j];
- }
- }
-
- return pivotedArr;
-
-};
-
-Handsontable.helper.proxy = function (fun, context) {
- return function () {
- return fun.apply(context, arguments);
- };
-};
-
-Handsontable.helper.cellMethodLookupFactory = function (methodName) {
-
- return function cellMethodLookup (row, col) {
-
- return (function getMethodFromProperties(properties) {
-
- if (!properties){
-
- return; //method not found
-
- }
- else if (properties.hasOwnProperty(methodName) && properties[methodName]) { //check if it is own and is not empty
-
- return properties[methodName]; //method defined directly
-
- } else if (properties.hasOwnProperty('type') && properties.type) { //check if it is own and is not empty
-
- var type;
-
- if(typeof properties.type != 'string' ){
- throw new Error('Cell type must be a string ');
- }
-
- type = translateTypeNameToObject(properties.type);
-
- return type[methodName]; //method defined in type. if does not exist (eg. validator), returns undefined
- }
-
- return getMethodFromProperties(Handsontable.helper.getPrototypeOf(properties));
-
- })(typeof row == 'number' ? this.getCellMeta(row, col) : row);
-
- };
-
- function translateTypeNameToObject(typeName) {
- var type = Handsontable.cellTypes[typeName];
-
- if(typeof type == 'undefined'){
- throw new Error('You declared cell type "' + typeName + '" as a string that is not mapped to a known object. Cell type must be an object or a string mapped to an object in Handsontable.cellTypes');
- }
-
- return type;
- }
-};
-Handsontable.SelectionPoint = function () {
- this._row = null; //private use intended
- this._col = null;
-};
-
-Handsontable.SelectionPoint.prototype.exists = function () {
- return (this._row !== null);
-};
-
-Handsontable.SelectionPoint.prototype.row = function (val) {
- if (val !== void 0) {
- this._row = val;
- }
- return this._row;
-};
-
-Handsontable.SelectionPoint.prototype.col = function (val) {
- if (val !== void 0) {
- this._col = val;
- }
- return this._col;
-};
-
-Handsontable.SelectionPoint.prototype.coords = function (coords) {
- if (coords !== void 0) {
- this._row = coords.row;
- this._col = coords.col;
- }
- return {
- row: this._row,
- col: this._col
- }
-};
-
-Handsontable.SelectionPoint.prototype.arr = function (arr) {
- if (arr !== void 0) {
- this._row = arr[0];
- this._col = arr[1];
- }
- return [this._row, this._col]
-};
-(function (Handsontable) {
- 'use strict';
-
- /*
- Adds appropriate CSS class to table cell, based on cellProperties
- */
- Handsontable.renderers.cellDecorator = function (instance, TD, row, col, prop, value, cellProperties) {
- if (cellProperties.readOnly) {
- instance.view.wt.wtDom.addClass(TD, cellProperties.readOnlyCellClassName);
- }
-
- if (cellProperties.valid === false && cellProperties.invalidCellClassName) {
- instance.view.wt.wtDom.addClass(TD, cellProperties.invalidCellClassName);
- }
-
- if (!value && cellProperties.placeholder) {
- instance.view.wt.wtDom.addClass(TD, cellProperties.placeholderCellClassName);
- }
- }
-
-})(Handsontable);
-/**
- * Default text renderer
- * @param {Object} instance Handsontable instance
- * @param {Element} TD Table cell where to render
- * @param {Number} row
- * @param {Number} col
- * @param {String|Number} prop Row object property name
- * @param value Value to render (remember to escape unsafe HTML before inserting to DOM!)
- * @param {Object} cellProperties Cell properites (shared by cell renderer and editor)
- */
-(function (Handsontable) {
- 'use strict';
-
- var TextRenderer = function (instance, TD, row, col, prop, value, cellProperties) {
-
- Handsontable.renderers.cellDecorator.apply(this, arguments);
-
- if (!value && cellProperties.placeholder) {
- value = cellProperties.placeholder;
- }
-
- var escaped = Handsontable.helper.stringify(value);
-
- if (cellProperties.rendererTemplate) {
- instance.view.wt.wtDom.empty(TD);
- var TEMPLATE = document.createElement('TEMPLATE');
- TEMPLATE.setAttribute('bind', '{{}}');
- TEMPLATE.innerHTML = cellProperties.rendererTemplate;
- HTMLTemplateElement.decorate(TEMPLATE);
- TEMPLATE.model = instance.getDataAtRow(row);
- TD.appendChild(TEMPLATE);
- }
- else {
- instance.view.wt.wtDom.fastInnerText(TD, escaped); //this is faster than innerHTML. See: https://github.com/warpech/jquery-handsontable/wiki/JavaScript-&-DOM-performance-tips
- }
-
- };
-
- //Handsontable.TextRenderer = TextRenderer; //Left for backward compatibility
- Handsontable.renderers.TextRenderer = TextRenderer;
- Handsontable.renderers.registerRenderer('text', TextRenderer);
-
-})(Handsontable);
-(function (Handsontable) {
-
- var clonableWRAPPER = document.createElement('DIV');
- clonableWRAPPER.className = 'htAutocompleteWrapper';
-
- var clonableARROW = document.createElement('DIV');
- clonableARROW.className = 'htAutocompleteArrow';
- clonableARROW.appendChild(document.createTextNode('\u25BC'));
-//this is faster than innerHTML. See: https://github.com/warpech/jquery-handsontable/wiki/JavaScript-&-DOM-performance-tips
-
- var wrapTdContentWithWrapper = function(TD, WRAPPER){
- WRAPPER.innerHTML = TD.innerHTML;
- Handsontable.Dom.empty(TD);
- TD.appendChild(WRAPPER);
- };
-
- /**
- * Autocomplete renderer
- * @param {Object} instance Handsontable instance
- * @param {Element} TD Table cell where to render
- * @param {Number} row
- * @param {Number} col
- * @param {String|Number} prop Row object property name
- * @param value Value to render (remember to escape unsafe HTML before inserting to DOM!)
- * @param {Object} cellProperties Cell properites (shared by cell renderer and editor)
- */
- var AutocompleteRenderer = function (instance, TD, row, col, prop, value, cellProperties) {
-
- var WRAPPER = clonableWRAPPER.cloneNode(true); //this is faster than createElement
- var ARROW = clonableARROW.cloneNode(true); //this is faster than createElement
-
- Handsontable.renderers.TextRenderer(instance, TD, row, col, prop, value, cellProperties);
-
- TD.appendChild(ARROW);
- Handsontable.Dom.addClass(TD, 'htAutocomplete');
-
-
- if (!TD.firstChild) { //http://jsperf.com/empty-node-if-needed
- //otherwise empty fields appear borderless in demo/renderers.html (IE)
- TD.appendChild(document.createTextNode('\u00A0')); //\u00A0 equals for a text node
- //this is faster than innerHTML. See: https://github.com/warpech/jquery-handsontable/wiki/JavaScript-&-DOM-performance-tips
- }
-
- if (!instance.acArrowListener) {
- //not very elegant but easy and fast
- instance.acArrowListener = function () {
- instance.view.wt.getSetting('onCellDblClick');
- };
-
- instance.rootElement.on('mousedown', '.htAutocompleteArrow', instance.acArrowListener); //this way we don't bind event listener to each arrow. We rely on propagation instead
-
- }
- };
-
- Handsontable.AutocompleteRenderer = AutocompleteRenderer;
- Handsontable.renderers.AutocompleteRenderer = AutocompleteRenderer;
- Handsontable.renderers.registerRenderer('autocomplete', AutocompleteRenderer);
-})(Handsontable);
-/**
- * Checkbox renderer
- * @param {Object} instance Handsontable instance
- * @param {Element} TD Table cell where to render
- * @param {Number} row
- * @param {Number} col
- * @param {String|Number} prop Row object property name
- * @param value Value to render (remember to escape unsafe HTML before inserting to DOM!)
- * @param {Object} cellProperties Cell properites (shared by cell renderer and editor)
- */
-(function (Handsontable) {
-
- 'use strict';
-
- var clonableINPUT = document.createElement('INPUT');
- clonableINPUT.className = 'htCheckboxRendererInput';
- clonableINPUT.type = 'checkbox';
- clonableINPUT.setAttribute('autocomplete', 'off');
-
- var CheckboxRenderer = function (instance, TD, row, col, prop, value, cellProperties) {
-
- if (typeof cellProperties.checkedTemplate === "undefined") {
- cellProperties.checkedTemplate = true;
- }
- if (typeof cellProperties.uncheckedTemplate === "undefined") {
- cellProperties.uncheckedTemplate = false;
- }
-
- instance.view.wt.wtDom.empty(TD); //TODO identify under what circumstances this line can be removed
-
- var INPUT = clonableINPUT.cloneNode(false); //this is faster than createElement
-
- if (value === cellProperties.checkedTemplate || value === Handsontable.helper.stringify(cellProperties.checkedTemplate)) {
- INPUT.checked = true;
- TD.appendChild(INPUT);
- }
- else if (value === cellProperties.uncheckedTemplate || value === Handsontable.helper.stringify(cellProperties.uncheckedTemplate)) {
- TD.appendChild(INPUT);
- }
- else if (value === null) { //default value
- INPUT.className += ' noValue';
- TD.appendChild(INPUT);
- }
- else {
- instance.view.wt.wtDom.fastInnerText(TD, '#bad value#'); //this is faster than innerHTML. See: https://github.com/warpech/jquery-handsontable/wiki/JavaScript-&-DOM-performance-tips
- }
-
- var $input = $(INPUT);
-
- if (cellProperties.readOnly) {
- $input.on('click', function (event) {
- event.preventDefault();
- });
- }
- else {
- $input.on('mousedown', function (event) {
- event.stopPropagation(); //otherwise can confuse cell mousedown handler
- });
-
- $input.on('mouseup', function (event) {
- event.stopPropagation(); //otherwise can confuse cell dblclick handler
- });
-
- $input.on('change', function(){
- if (this.checked) {
- instance.setDataAtRowProp(row, prop, cellProperties.checkedTemplate);
- }
- else {
- instance.setDataAtRowProp(row, prop, cellProperties.uncheckedTemplate);
- }
- });
- }
-
- if(!instance.CheckboxRenderer || !instance.CheckboxRenderer.beforeKeyDownHookBound){
- instance.CheckboxRenderer = {
- beforeKeyDownHookBound : true
- };
-
- instance.addHook('beforeKeyDown', function(event){
- if(event.keyCode == Handsontable.helper.keyCode.SPACE){
-
- var selection = instance.getSelected();
- var cell, checkbox, cellProperties;
-
- var selStart = {
- row: Math.min(selection[0], selection[2]),
- col: Math.min(selection[1], selection[3])
- };
-
- var selEnd = {
- row: Math.max(selection[0], selection[2]),
- col: Math.max(selection[1], selection[3])
- };
-
- for(var row = selStart.row; row <= selEnd.row; row++ ){
- for(var col = selEnd.col; col <= selEnd.col; col++){
- cell = instance.getCell(row, col);
- cellProperties = instance.getCellMeta(row, col);
-
- checkbox = cell.querySelectorAll('input[type=checkbox]');
-
- if(checkbox.length > 0 && !cellProperties.readOnly){
-
- if(!event.isImmediatePropagationStopped()){
- event.stopImmediatePropagation();
- event.preventDefault();
- }
-
- for(var i = 0, len = checkbox.length; i < len; i++){
- checkbox[i].checked = !checkbox[i].checked;
- $(checkbox[i]).trigger('change');
- }
-
- }
-
- }
- }
- }
- });
- }
-
- };
-
- Handsontable.CheckboxRenderer = CheckboxRenderer;
- Handsontable.renderers.CheckboxRenderer = CheckboxRenderer;
- Handsontable.renderers.registerRenderer('checkbox', CheckboxRenderer);
-
-})(Handsontable);
-/**
- * Numeric cell renderer
- * @param {Object} instance Handsontable instance
- * @param {Element} TD Table cell where to render
- * @param {Number} row
- * @param {Number} col
- * @param {String|Number} prop Row object property name
- * @param value Value to render (remember to escape unsafe HTML before inserting to DOM!)
- * @param {Object} cellProperties Cell properites (shared by cell renderer and editor)
- */
-(function (Handsontable) {
-
- 'use strict';
-
- var NumericRenderer = function (instance, TD, row, col, prop, value, cellProperties) {
- if (Handsontable.helper.isNumeric(value)) {
- if (typeof cellProperties.language !== 'undefined') {
- numeral.language(cellProperties.language)
- }
- value = numeral(value).format(cellProperties.format || '0'); //docs: http://numeraljs.com/
- instance.view.wt.wtDom.addClass(TD, 'htNumeric');
- }
- Handsontable.renderers.TextRenderer(instance, TD, row, col, prop, value, cellProperties);
- };
-
- Handsontable.NumericRenderer = NumericRenderer; //Left for backward compatibility with versions prior 0.10.0
- Handsontable.renderers.NumericRenderer = NumericRenderer;
- Handsontable.renderers.registerRenderer('numeric', NumericRenderer);
-
-})(Handsontable);
-(function(Handosntable){
-
- 'use strict';
-
- var PasswordRenderer = function (instance, TD, row, col, prop, value, cellProperties) {
- Handsontable.renderers.TextRenderer.apply(this, arguments);
-
- value = TD.innerHTML;
-
- var hash;
- var hashLength = cellProperties.hashLength || value.length;
- var hashSymbol = cellProperties.hashSymbol || '*';
-
- for( hash = ''; hash.split(hashSymbol).length - 1 < hashLength; hash += hashSymbol);
-
- instance.view.wt.wtDom.fastInnerHTML(TD, hash);
-
- };
-
- Handosntable.PasswordRenderer = PasswordRenderer;
- Handosntable.renderers.PasswordRenderer = PasswordRenderer;
- Handosntable.renderers.registerRenderer('password', PasswordRenderer);
-
-})(Handsontable);
-(function (Handsontable) {
-
- function HtmlRenderer(instance, TD, row, col, prop, value, cellProperties){
-
- Handsontable.renderers.cellDecorator.apply(this, arguments);
-
- Handsontable.Dom.fastInnerHTML(TD, value);
- }
-
- Handsontable.renderers.registerRenderer('html', HtmlRenderer);
- Handsontable.renderers.HtmlRenderer = HtmlRenderer;
-
-})(Handsontable);
-
-(function (Handsontable) {
- 'use strict';
-
- Handsontable.EditorState = {
- VIRGIN: 'STATE_VIRGIN', //before editing
- EDITING: 'STATE_EDITING',
- WAITING: 'STATE_WAITING', //waiting for async validation
- FINISHED: 'STATE_FINISHED'
- };
-
- function BaseEditor(instance) {
- this.instance = instance;
- this.state = Handsontable.EditorState.VIRGIN;
-
- this._opened = false;
- this._closeCallback = null;
-
- this.init();
- }
-
- BaseEditor.prototype._fireCallbacks = function(result) {
- if(this._closeCallback){
- this._closeCallback(result);
- this._closeCallback = null;
- }
-
- };
-
- BaseEditor.prototype.init = function(){};
-
- BaseEditor.prototype.getValue = function(){
- throw Error('Editor getValue() method unimplemented');
- };
-
- BaseEditor.prototype.setValue = function(newValue){
- throw Error('Editor setValue() method unimplemented');
- };
-
- BaseEditor.prototype.open = function(){
- throw Error('Editor open() method unimplemented');
- };
-
- BaseEditor.prototype.close = function(){
- throw Error('Editor close() method unimplemented');
- };
-
- BaseEditor.prototype.prepare = function(row, col, prop, td, originalValue, cellProperties){
- this.TD = td;
- this.row = row;
- this.col = col;
- this.prop = prop;
- this.originalValue = originalValue;
- this.cellProperties = cellProperties;
-
- this.state = Handsontable.EditorState.VIRGIN;
- };
-
- BaseEditor.prototype.extend = function(){
- var baseClass = this.constructor;
- function Editor(){
- baseClass.apply(this, arguments);
- }
-
- function inherit(Child, Parent){
- function Bridge() {
- }
-
- Bridge.prototype = Parent.prototype;
- Child.prototype = new Bridge();
- Child.prototype.constructor = Child;
- return Child;
- }
-
- return inherit(Editor, baseClass);
- };
-
- BaseEditor.prototype.saveValue = function (val, ctrlDown) {
- if (ctrlDown) { //if ctrl+enter and multiple cells selected, behave like Excel (finish editing and apply to all cells)
- var sel = this.instance.getSelected();
- this.instance.populateFromArray(sel[0], sel[1], val, sel[2], sel[3], 'edit');
- }
- else {
- this.instance.populateFromArray(this.row, this.col, val, null, null, 'edit');
- }
- };
-
- BaseEditor.prototype.beginEditing = function(initialValue){
- if (this.state != Handsontable.EditorState.VIRGIN) {
- return;
- }
-
- if (this.cellProperties.readOnly) {
- return;
- }
-
- this.instance.view.scrollViewport({row: this.row, col: this.col});
- this.instance.view.render();
-
- this.state = Handsontable.EditorState.EDITING;
-
- initialValue = typeof initialValue == 'string' ? initialValue : this.originalValue;
-
- this.setValue(Handsontable.helper.stringify(initialValue));
-
- this.open();
- this._opened = true;
- this.focus();
-
- this.instance.view.render(); //only rerender the selections (FillHandle should disappear when beginediting is triggered)
- };
-
- BaseEditor.prototype.finishEditing = function (restoreOriginalValue, ctrlDown, callback) {
-
- if (callback) {
- var previousCloseCallback = this._closeCallback;
- this._closeCallback = function (result) {
- if(previousCloseCallback){
- previousCloseCallback(result);
- }
-
- callback(result);
- };
- }
-
- if (this.isWaiting()) {
- return;
- }
-
- if (this.state == Handsontable.EditorState.VIRGIN) {
- var that = this;
- setTimeout(function () {
- that._fireCallbacks(true);
- });
- return;
- }
-
- if (this.state == Handsontable.EditorState.EDITING) {
-
- if (restoreOriginalValue) {
-
- this.cancelChanges();
- return;
-
- }
-
-
- var val = [
- [String.prototype.trim.call(this.getValue())] //String.prototype.trim is defined in Walkontable polyfill.js
- ];
-
- this.state = Handsontable.EditorState.WAITING;
-
- this.saveValue(val, ctrlDown);
-
- if(this.instance.getCellValidator(this.cellProperties)){
- var that = this;
- this.instance.addHookOnce('afterValidate', function (result) {
- that.state = Handsontable.EditorState.FINISHED;
- that.discardEditor(result);
- });
- } else {
- this.state = Handsontable.EditorState.FINISHED;
- this.discardEditor(true);
- }
-
- }
- };
-
- BaseEditor.prototype.cancelChanges = function () {
- this.state = Handsontable.EditorState.FINISHED;
- this.discardEditor();
- };
-
- BaseEditor.prototype.discardEditor = function (result) {
- if (this.state !== Handsontable.EditorState.FINISHED) {
- return;
- }
-
- if (result === false && this.cellProperties.allowInvalid !== true) { //validator was defined and failed
-
- this.instance.selectCell(this.row, this.col);
- this.focus();
-
- this.state = Handsontable.EditorState.EDITING;
-
- this._fireCallbacks(false);
- }
- else {
- this.close();
- this._opened = false;
-
- this.state = Handsontable.EditorState.VIRGIN;
-
- this._fireCallbacks(true);
- }
-
- };
-
- BaseEditor.prototype.isOpened = function(){
- return this._opened;
- };
-
- BaseEditor.prototype.isWaiting = function () {
- return this.state === Handsontable.EditorState.WAITING;
- };
-
- Handsontable.editors.BaseEditor = BaseEditor;
-
-})(Handsontable);
-
-(function(Handsontable){
- var TextEditor = Handsontable.editors.BaseEditor.prototype.extend();
-
- TextEditor.prototype.init = function(){
- this.createElements();
- this.bindEvents();
- };
-
- TextEditor.prototype.getValue = function(){
- return this.TEXTAREA.value
- };
-
- TextEditor.prototype.setValue = function(newValue){
- this.TEXTAREA.value = newValue;
- };
-
- var onBeforeKeyDown = function onBeforeKeyDown(event){
-
- var instance = this;
- var that = instance.getActiveEditor();
-
- var keyCodes = Handsontable.helper.keyCode;
- var ctrlDown = (event.ctrlKey || event.metaKey) && !event.altKey; //catch CTRL but not right ALT (which in some systems triggers ALT+CTRL)
-
-
- //Process only events that have been fired in the editor
- if (event.target !== that.TEXTAREA || event.isImmediatePropagationStopped()){
- return;
- }
-
- if (event.keyCode === 17 || event.keyCode === 224 || event.keyCode === 91 || event.keyCode === 93) {
- //when CTRL or its equivalent is pressed and cell is edited, don't prepare selectable text in textarea
- event.stopImmediatePropagation();
- return;
- }
-
- switch (event.keyCode) {
- case keyCodes.ARROW_RIGHT:
- if (that.wtDom.getCaretPosition(that.TEXTAREA) !== that.TEXTAREA.value.length) {
- event.stopImmediatePropagation();
- }
- break;
-
- case keyCodes.ARROW_LEFT: /* arrow left */
- if (that.wtDom.getCaretPosition(that.TEXTAREA) !== 0) {
- event.stopImmediatePropagation();
- }
- break;
-
- case keyCodes.ENTER:
- var selected = that.instance.getSelected();
- var isMultipleSelection = !(selected[0] === selected[2] && selected[1] === selected[3]);
- if ((ctrlDown && !isMultipleSelection) || event.altKey) { //if ctrl+enter or alt+enter, add new line
- if(that.isOpened()){
- that.setValue(that.getValue() + '\n');
- that.focus();
- } else {
- that.beginEditing(that.originalValue + '\n')
- }
- event.stopImmediatePropagation();
- }
- event.preventDefault(); //don't add newline to field
- break;
-
- case keyCodes.A:
- case keyCodes.X:
- case keyCodes.C:
- case keyCodes.V:
- if(ctrlDown){
- event.stopImmediatePropagation(); //CTRL+A, CTRL+C, CTRL+V, CTRL+X should only work locally when cell is edited (not in table context)
- break;
- }
- case keyCodes.BACKSPACE:
- case keyCodes.DELETE:
- case keyCodes.HOME:
- case keyCodes.END:
- event.stopImmediatePropagation(); //backspace, delete, home, end should only work locally when cell is edited (not in table context)
- break;
- }
-
- };
-
- TextEditor.prototype.open = function(){
- this.refreshDimensions(); //need it instantly, to prevent https://github.com/warpech/jquery-handsontable/issues/348
-
- this.instance.addHook('beforeKeyDown', onBeforeKeyDown);
- };
-
- TextEditor.prototype.close = function(){
- this.textareaParentStyle.display = 'none';
-
- if (document.activeElement === this.TEXTAREA) {
- this.instance.listen(); //don't refocus the table if user focused some cell outside of HT on purpose
- }
-
- this.instance.removeHook('beforeKeyDown', onBeforeKeyDown);
- };
-
- TextEditor.prototype.focus = function(){
- this.TEXTAREA.focus();
- this.wtDom.setCaretPosition(this.TEXTAREA, this.TEXTAREA.value.length);
- };
-
- TextEditor.prototype.createElements = function () {
- this.$body = $(document.body);
- this.wtDom = new WalkontableDom();
-
- this.TEXTAREA = document.createElement('TEXTAREA');
- this.$textarea = $(this.TEXTAREA);
-
- this.wtDom.addClass(this.TEXTAREA, 'handsontableInput');
-
- this.textareaStyle = this.TEXTAREA.style;
- this.textareaStyle.width = 0;
- this.textareaStyle.height = 0;
-
- this.TEXTAREA_PARENT = document.createElement('DIV');
- this.wtDom.addClass(this.TEXTAREA_PARENT, 'handsontableInputHolder');
-
- this.textareaParentStyle = this.TEXTAREA_PARENT.style;
- this.textareaParentStyle.top = 0;
- this.textareaParentStyle.left = 0;
- this.textareaParentStyle.display = 'none';
-
- this.TEXTAREA_PARENT.appendChild(this.TEXTAREA);
-
- this.instance.rootElement[0].appendChild(this.TEXTAREA_PARENT);
-
- var that = this;
- Handsontable.PluginHooks.add('afterRender', function () {
- that.instance.registerTimeout('refresh_editor_dimensions', function () {
- that.refreshDimensions();
- }, 0);
- });
- };
-
- TextEditor.prototype.refreshDimensions = function () {
- if (this.state !== Handsontable.EditorState.EDITING) {
- return;
- }
-
- ///start prepare textarea position
- this.TD = this.instance.getCell(this.row, this.col);
- if (!this.TD) {
- //TD is outside of the viewport. Otherwise throws exception when scrolling the table while a cell is edited
- return;
- }
- var $td = $(this.TD); //because old td may have been scrolled out with scrollViewport
- var currentOffset = this.wtDom.offset(this.TD);
- var containerOffset = this.wtDom.offset(this.instance.rootElement[0]);
- var scrollTop = this.instance.rootElement.scrollTop();
- var scrollLeft = this.instance.rootElement.scrollLeft();
- var editTop = currentOffset.top - containerOffset.top + scrollTop - 1;
- var editLeft = currentOffset.left - containerOffset.left + scrollLeft - 1;
-
- var settings = this.instance.getSettings();
- var rowHeadersCount = settings.rowHeaders === false ? 0 : 1;
- var colHeadersCount = settings.colHeaders === false ? 0 : 1;
-
- if (editTop < 0) {
- editTop = 0;
- }
- if (editLeft < 0) {
- editLeft = 0;
- }
-
- if (rowHeadersCount > 0 && parseInt($td.css('border-top-width'), 10) > 0) {
- editTop += 1;
- }
- if (colHeadersCount > 0 && parseInt($td.css('border-left-width'), 10) > 0) {
- editLeft += 1;
- }
-
- this.textareaParentStyle.top = editTop + 'px';
- this.textareaParentStyle.left = editLeft + 'px';
- ///end prepare textarea position
-
- var width = $td.width()
- , maxWidth = this.instance.view.maximumVisibleElementWidth(editLeft) - 10 //10 is TEXTAREAs border and padding
- , height = $td.outerHeight() - 4
- , maxHeight = this.instance.view.maximumVisibleElementHeight(editTop) - 5; //10 is TEXTAREAs border and padding
-
- if (parseInt($td.css('border-top-width'), 10) > 0) {
- height -= 1;
- }
- if (parseInt($td.css('border-left-width'), 10) > 0) {
- if (rowHeadersCount > 0) {
- width -= 1;
- }
- }
-
- //in future may change to pure JS http://stackoverflow.com/questions/454202/creating-a-textarea-with-auto-resize
- this.$textarea.autoResize({
- minHeight: Math.min(height, maxHeight),
- maxHeight: maxHeight, //TEXTAREA should never be wider than visible part of the viewport (should not cover the scrollbar)
- minWidth: Math.min(width, maxWidth),
- maxWidth: maxWidth, //TEXTAREA should never be wider than visible part of the viewport (should not cover the scrollbar)
- animate: false,
- extraSpace: 0
- });
-
- this.textareaParentStyle.display = 'block';
- };
-
- TextEditor.prototype.bindEvents = function () {
- this.$textarea.on('cut.editor', function (event) {
- event.stopPropagation();
- });
-
- this.$textarea.on('paste.editor', function (event) {
- event.stopPropagation();
- });
- };
-
- Handsontable.editors.TextEditor = TextEditor;
- Handsontable.editors.registerEditor('text', Handsontable.editors.TextEditor);
-
-})(Handsontable);
-
-(function(Handsontable){
-
- //Blank editor, because all the work is done by renderer
- var CheckboxEditor = Handsontable.editors.BaseEditor.prototype.extend();
-
- CheckboxEditor.prototype.beginEditing = function () {
- this.saveValue([
- [!this.originalValue]
- ]);
- };
- CheckboxEditor.prototype.finishEditing = function () {};
-
- CheckboxEditor.prototype.init = function () {};
- CheckboxEditor.prototype.open = function () {};
- CheckboxEditor.prototype.close = function () {};
- CheckboxEditor.prototype.getValue = function () {};
- CheckboxEditor.prototype.setValue = function () {};
- CheckboxEditor.prototype.focus = function () {};
-
- Handsontable.editors.CheckboxEditor = CheckboxEditor;
- Handsontable.editors.registerEditor('checkbox', CheckboxEditor);
-
-})(Handsontable);
-
-
-(function (Handsontable) {
- var DateEditor = Handsontable.editors.TextEditor.prototype.extend();
-
- DateEditor.prototype.init = function () {
- if (!$.datepicker) {
- throw new Error("jQuery UI Datepicker dependency not found. Did you forget to include jquery-ui.custom.js or its substitute?");
- }
-
- Handsontable.editors.TextEditor.prototype.init.apply(this, arguments);
-
- this.isCellEdited = false;
- var that = this;
-
- this.instance.addHook('afterDestroy', function () {
- that.destroyElements();
- })
-
- };
-
- DateEditor.prototype.createElements = function () {
- Handsontable.editors.TextEditor.prototype.createElements.apply(this, arguments);
-
- this.datePicker = document.createElement('DIV');
- this.instance.view.wt.wtDom.addClass(this.datePicker, 'htDatepickerHolder');
- this.datePickerStyle = this.datePicker.style;
- this.datePickerStyle.position = 'absolute';
- this.datePickerStyle.top = 0;
- this.datePickerStyle.left = 0;
- this.datePickerStyle.zIndex = 99;
- document.body.appendChild(this.datePicker);
- this.$datePicker = $(this.datePicker);
-
- var that = this;
- var defaultOptions = {
- dateFormat: "yy-mm-dd",
- showButtonPanel: true,
- changeMonth: true,
- changeYear: true,
- altField: this.$textarea,
- onSelect: function () {
- that.finishEditing(false);
- }
- };
- this.$datePicker.datepicker(defaultOptions);
-
- /**
- * Prevent recognizing clicking on jQuery Datepicker as clicking outside of table
- */
- this.$datePicker.on('mousedown', function (event) {
- event.stopPropagation();
- });
-
- this.hideDatepicker();
- };
-
- DateEditor.prototype.destroyElements = function () {
- this.$datePicker.datepicker('destroy');
- this.$datePicker.remove();
- };
-
- DateEditor.prototype.beginEditing = function (row, col, prop, useOriginalValue, suffix) {
- Handsontable.editors.TextEditor.prototype.beginEditing.apply(this, arguments);
- this.showDatepicker();
- };
-
- DateEditor.prototype.finishEditing = function (isCancelled, ctrlDown) {
- this.hideDatepicker();
- Handsontable.editors.TextEditor.prototype.finishEditing.apply(this, arguments);
- };
-
- DateEditor.prototype.showDatepicker = function () {
- var $td = $(this.TD);
- var offset = $td.offset();
- this.datePickerStyle.top = (offset.top + $td.height()) + 'px';
- this.datePickerStyle.left = offset.left + 'px';
-
- var dateOptions = {
- defaultDate: this.originalValue || void 0
- };
- $.extend(dateOptions, this.cellProperties);
- this.$datePicker.datepicker("option", dateOptions);
- if (this.originalValue) {
- this.$datePicker.datepicker("setDate", this.originalValue);
- }
- this.datePickerStyle.display = 'block';
- };
-
- DateEditor.prototype.hideDatepicker = function () {
- this.datePickerStyle.display = 'none';
- };
-
-
- Handsontable.editors.DateEditor = DateEditor;
- Handsontable.editors.registerEditor('date', DateEditor);
-})(Handsontable);
-/**
- * This is inception. Using Handsontable as Handsontable editor
- */
-(function (Handsontable) {
- "use strict";
-
- var HandsontableEditor = Handsontable.editors.TextEditor.prototype.extend();
-
- HandsontableEditor.prototype.createElements = function () {
- Handsontable.editors.TextEditor.prototype.createElements.apply(this, arguments);
-
- var DIV = document.createElement('DIV');
- DIV.className = 'handsontableEditor';
- this.TEXTAREA_PARENT.appendChild(DIV);
-
- this.$htContainer = $(DIV);
- this.$htContainer.handsontable();
- };
-
- HandsontableEditor.prototype.prepare = function (td, row, col, prop, value, cellProperties) {
-
- Handsontable.editors.TextEditor.prototype.prepare.apply(this, arguments);
-
- var parent = this;
-
- var options = {
- startRows: 0,
- startCols: 0,
- minRows: 0,
- minCols: 0,
- className: 'listbox',
- copyPaste: false,
- cells: function () {
- return {
- readOnly: true
- }
- },
- fillHandle: false,
- afterOnCellMouseDown: function () {
- var value = this.getValue();
- if (value !== void 0) { //if the value is undefined then it means we don't want to set the value
- parent.setValue(value);
- }
- parent.instance.destroyEditor();
- },
- beforeOnKeyDown: function (event) {
- var instance = this;
-
- switch (event.keyCode) {
- case Handsontable.helper.keyCode.ESCAPE:
- parent.instance.destroyEditor(true);
- event.stopImmediatePropagation();
- event.preventDefault();
- break;
-
- case Handsontable.helper.keyCode.ENTER: //enter
- var sel = instance.getSelected();
- var value = this.getDataAtCell(sel[0], sel[1]);
- if (value !== void 0) { //if the value is undefined then it means we don't want to set the value
- parent.setValue(value);
- }
- parent.instance.destroyEditor();
- break;
-
- case Handsontable.helper.keyCode.ARROW_UP:
- if (instance.getSelected() && instance.getSelected()[0] == 0 && !parent.cellProperties.strict){
- instance.deselectCell();
- parent.instance.listen();
- parent.focus();
- event.preventDefault();
- event.stopImmediatePropagation();
- }
- break;
- }
- }
- };
-
- if (this.cellProperties.handsontable) {
- options = $.extend(options, cellProperties.handsontable);
- }
- this.$htContainer.handsontable('destroy');
- this.$htContainer.handsontable(options);
- };
-
- var onBeforeKeyDown = function (event) {
-
- if (event.isImmediatePropagationStopped()) {
- return;
- }
-
- var editor = this.getActiveEditor();
- var innerHOT = editor.$htContainer.handsontable('getInstance');
-
- if (event.keyCode == Handsontable.helper.keyCode.ARROW_DOWN) {
-
- if (!innerHOT.getSelected()){
- innerHOT.selectCell(0, 0);
- } else {
- var selectedRow = innerHOT.getSelected()[0];
- var rowToSelect = selectedRow < innerHOT.countRows() - 1 ? selectedRow + 1 : selectedRow;
-
- innerHOT.selectCell(rowToSelect, 0);
- }
-
- event.preventDefault();
- event.stopImmediatePropagation();
- }
-
- };
-
- HandsontableEditor.prototype.open = function () {
-
- this.instance.addHook('beforeKeyDown', onBeforeKeyDown);
-
- Handsontable.editors.TextEditor.prototype.open.apply(this, arguments);
-
- this.$htContainer.handsontable('render');
-
- if (this.cellProperties.strict) {
- this.$htContainer.handsontable('selectCell', 0, 0);
- this.$textarea[0].style.visibility = 'hidden';
- } else {
- this.$htContainer.handsontable('deselectCell');
- this.$textarea[0].style.visibility = 'visible';
- }
-
- this.wtDom.setCaretPosition(this.$textarea[0], 0, this.$textarea[0].value.length);
-
- };
-
- HandsontableEditor.prototype.close = function () {
-
- this.instance.removeHook('beforeKeyDown', onBeforeKeyDown);
- this.instance.listen();
-
- Handsontable.editors.TextEditor.prototype.close.apply(this, arguments);
- };
-
- HandsontableEditor.prototype.focus = function () {
-
- this.instance.listen();
-
- Handsontable.editors.TextEditor.prototype.focus.apply(this, arguments);
- };
-
- HandsontableEditor.prototype.beginEditing = function (initialValue) {
- var onBeginEditing = this.instance.getSettings().onBeginEditing;
- if (onBeginEditing && onBeginEditing() === false) {
- return;
- }
-
- Handsontable.editors.TextEditor.prototype.beginEditing.apply(this, arguments);
-
- };
-
- HandsontableEditor.prototype.finishEditing = function (isCancelled, ctrlDown) {
- if (this.$htContainer.handsontable('isListening')) { //if focus is still in the HOT editor
- this.instance.listen(); //return the focus to the parent HOT instance
- }
-
- if (this.$htContainer.handsontable('getSelected')) {
- var value = this.$htContainer.handsontable('getInstance').getValue();
- if (value !== void 0) { //if the value is undefined then it means we don't want to set the value
- this.setValue(value);
- }
- }
-
- return Handsontable.editors.TextEditor.prototype.finishEditing.apply(this, arguments);
- };
-
- Handsontable.editors.HandsontableEditor = HandsontableEditor;
- Handsontable.editors.registerEditor('handsontable', HandsontableEditor);
-
-})(Handsontable);
-
-
-
-
-
-
-(function (Handsontable) {
- var AutocompleteEditor = Handsontable.editors.HandsontableEditor.prototype.extend();
-
- AutocompleteEditor.prototype.init = function () {
- Handsontable.editors.HandsontableEditor.prototype.init.apply(this, arguments);
-
- this.query = null;
- };
-
- AutocompleteEditor.prototype.createElements = function(){
- Handsontable.editors.HandsontableEditor.prototype.createElements.apply(this, arguments);
-
- this.$htContainer.addClass('autocompleteEditor');
-
- };
-
- AutocompleteEditor.prototype.bindEvents = function(){
-
- var that = this;
- this.$textarea.on('keydown.autocompleteEditor', function(event){
- if(!Handsontable.helper.isMetaKey(event.keyCode) || [Handsontable.helper.keyCode.BACKSPACE, Handsontable.helper.keyCode.DELETE].indexOf(event.keyCode) != -1){
- setTimeout(function () {
- that.queryChoices(that.$textarea.val());
- });
- } else if (event.keyCode == Handsontable.helper.keyCode.ENTER && that.cellProperties.strict !== true){
- that.$htContainer.handsontable('deselectCell');
- }
-
- });
-
- this.$htContainer.on('mouseenter', function () {
- that.$htContainer.handsontable('deselectCell');
- });
-
- this.$htContainer.on('mouseleave', function () {
- that.queryChoices(that.query);
- });
-
- Handsontable.editors.HandsontableEditor.prototype.bindEvents.apply(this, arguments);
-
- };
-
- AutocompleteEditor.prototype.beginEditing = function () {
- Handsontable.editors.HandsontableEditor.prototype.beginEditing.apply(this, arguments);
-
- var that = this;
- setTimeout(function () {
- that.queryChoices(that.TEXTAREA.value);
- });
-
- var hot = this.$htContainer.handsontable('getInstance');
-
- hot.updateSettings({
- 'colWidths': [this.wtDom.outerWidth(this.TEXTAREA) - 2],
- afterRenderer: function (TD, row, col, prop, value, cellProperties) {
- var match = TD.innerHTML.match(new RegExp(that.query, 'i'));
- if(match){
- TD.innerHTML = value.replace(match[0], '' + match[0] + '');
- }
- }
- });
-
-
- };
-
- var onBeforeKeyDownInner;
-
- AutocompleteEditor.prototype.open = function () {
-
- var parent = this;
-
- onBeforeKeyDownInner = function (event) {
- var instance = this;
-
- if (event.keyCode == Handsontable.helper.keyCode.ARROW_UP){
- if (instance.getSelected() && instance.getSelected()[0] == 0){
-
- if(!parent.cellProperties.strict){
- instance.deselectCell();
- }
-
- parent.instance.listen();
- parent.focus();
- event.preventDefault();
- event.stopImmediatePropagation();
- }
- }
-
- };
-
- this.$htContainer.handsontable('getInstance').addHook('beforeKeyDown', onBeforeKeyDownInner);
-
- Handsontable.editors.HandsontableEditor.prototype.open.apply(this, arguments);
-
- this.$textarea[0].style.visibility = 'visible';
- parent.focus();
- };
-
- AutocompleteEditor.prototype.close = function () {
-
- this.$htContainer.handsontable('getInstance').removeHook('beforeKeyDown', onBeforeKeyDownInner);
-
- Handsontable.editors.HandsontableEditor.prototype.close.apply(this, arguments);
- };
-
- AutocompleteEditor.prototype.queryChoices = function(query){
-
- this.query = query;
-
- if (typeof this.cellProperties.source == 'function'){
- var that = this;
-
- this.cellProperties.source(query, function(choices){
- that.updateChoicesList(choices)
- });
-
- } else if (Handsontable.helper.isArray(this.cellProperties.source)) {
-
- var choices;
-
- if(!query || this.cellProperties.filter === false){
- choices = this.cellProperties.source;
- } else {
-
- var queryRegex = new RegExp(query, this.cellProperties.filteringCaseSensitive === true ? '' : 'i');
-
- choices = this.cellProperties.source.filter(function(choice){
- return queryRegex.test(choice);
- });
- }
-
- this.updateChoicesList(choices)
-
- } else {
- this.updateChoicesList([]);
- }
-
- };
-
- function findItemIndexToHighlight(items, value){
- var bestMatch = {};
- var valueLength = value.length;
- var currentItem;
- var indexOfValue;
- var charsLeft;
-
-
- for(var i = 0, len = items.length; i < len; i++){
- currentItem = items[i];
-
- if(valueLength > 0){
- indexOfValue = currentItem.indexOf(value)
- } else {
- indexOfValue = currentItem === value ? 0 : -1;
- }
-
- if(indexOfValue == -1) continue;
-
- charsLeft = currentItem.length - indexOfValue - valueLength;
-
- if( typeof bestMatch.indexOfValue == 'undefined'
- || bestMatch.indexOfValue > indexOfValue
- || ( bestMatch.indexOfValue == indexOfValue && bestMatch.charsLeft > charsLeft ) ){
-
- bestMatch.indexOfValue = indexOfValue;
- bestMatch.charsLeft = charsLeft;
- bestMatch.index = i;
-
- }
-
- }
-
-
- return bestMatch.index;
- }
-
- AutocompleteEditor.prototype.updateChoicesList = function (choices) {
- this.$htContainer.handsontable('loadData', Handsontable.helper.pivot([choices]));
-
- var value = this.getValue();
- var rowToHighlight;
-
- if(this.cellProperties.strict === true){
-
- rowToHighlight = findItemIndexToHighlight(choices, value);
-
- if ( typeof rowToHighlight == 'undefined'){
- rowToHighlight = 0;
- }
-
- }
-
- if(typeof rowToHighlight == 'undefined'){
- this.$htContainer.handsontable('deselectCell');
- } else {
- this.$htContainer.handsontable('selectCell', rowToHighlight, 0);
- }
-
- this.focus();
- };
-
- Handsontable.editors.AutocompleteEditor = AutocompleteEditor;
- Handsontable.editors.registerEditor('autocomplete', AutocompleteEditor);
-
-})(Handsontable);
-
-(function(Handsontable){
-
- var PasswordEditor = Handsontable.editors.TextEditor.prototype.extend();
- var wtDom = new WalkontableDom();
-
- PasswordEditor.prototype.createElements = function () {
- Handsontable.editors.TextEditor.prototype.createElements.apply(this, arguments);
-
- this.TEXTAREA = document.createElement('input');
- this.TEXTAREA.setAttribute('type', 'password');
- this.TEXTAREA.className = 'handsontableInput';
- this.textareaStyle = this.TEXTAREA.style;
- this.textareaStyle.width = 0;
- this.textareaStyle.height = 0;
- this.$textarea = $(this.TEXTAREA);
-
- wtDom.empty(this.TEXTAREA_PARENT);
- this.TEXTAREA_PARENT.appendChild(this.TEXTAREA);
-
- };
-
- Handsontable.editors.PasswordEditor = PasswordEditor;
- Handsontable.editors.registerEditor('password', PasswordEditor);
-
-})(Handsontable);
-
-(function (Handsontable) {
-
- var SelectEditor = Handsontable.editors.BaseEditor.prototype.extend();
-
- SelectEditor.prototype.init = function(){
- this.select = $('')
- .addClass('htSelectEditor')
- .hide();
- this.instance.rootElement.append(this.select);
- };
-
- SelectEditor.prototype.prepare = function(){
- Handsontable.editors.BaseEditor.prototype.prepare.apply(this, arguments);
-
-
- var selectOptions = this.cellProperties.selectOptions;
- var options;
-
- if (typeof selectOptions == 'function'){
- options = this.prepareOptions(selectOptions(this.row, this.col, this.prop))
- } else {
- options = this.prepareOptions(selectOptions);
- }
-
- var optionElements = [];
-
- for (var option in options){
- if (options.hasOwnProperty(option)){
- var optionElement = $('');
- optionElement.val(option);
- optionElement.html(options[option]);
-
- optionElements.push(optionElement);
- }
- }
-
- this.select.empty();
- this.select.append(optionElements);
-
- };
-
- SelectEditor.prototype.prepareOptions = function(optionsToPrepare){
-
- var preparedOptions = {};
-
- if (Handsontable.helper.isArray(optionsToPrepare)){
- for(var i = 0, len = optionsToPrepare.length; i < len; i++){
- preparedOptions[optionsToPrepare[i]] = optionsToPrepare[i];
- }
- }
- else if (typeof optionsToPrepare == 'object') {
- preparedOptions = optionsToPrepare;
- }
-
- return preparedOptions;
-
- };
-
- SelectEditor.prototype.getValue = function () {
- return this.select.val();
- };
-
- SelectEditor.prototype.setValue = function (value) {
- this.select.val(value);
- };
-
- var onBeforeKeyDown = function (event) {
- var instance = this;
- var editor = instance.getActiveEditor();
-
- switch (event.keyCode){
- case Handsontable.helper.keyCode.ARROW_UP:
-
- var previousOption = editor.select.find('option:selected').prev();
-
- if (previousOption.length == 1){
- previousOption.prop('selected', true);
- }
-
- event.stopImmediatePropagation();
- event.preventDefault();
- break;
-
- case Handsontable.helper.keyCode.ARROW_DOWN:
-
- var nextOption = editor.select.find('option:selected').next();
-
- if (nextOption.length == 1){
- nextOption.prop('selected', true);
- }
-
- event.stopImmediatePropagation();
- event.preventDefault();
- break;
- }
- };
-
- SelectEditor.prototype.open = function () {
- this.select.css({
- height: $(this.TD).height(),
- 'min-width' : $(this.TD).outerWidth()
- });
-
- this.select.show();
- this.select.offset($(this.TD).offset());
-
- this.instance.addHook('beforeKeyDown', onBeforeKeyDown);
- };
-
- SelectEditor.prototype.close = function () {
- this.select.hide();
- this.instance.removeHook('beforeKeyDown', onBeforeKeyDown);
- };
-
- SelectEditor.prototype.focus = function () {
- this.select.focus();
- };
-
- Handsontable.editors.SelectEditor = SelectEditor;
- Handsontable.editors.registerEditor('select', SelectEditor);
-
-})(Handsontable);
-
-(function (Handsontable) {
-
- var DropdownEditor = Handsontable.editors.AutocompleteEditor.prototype.extend();
-
- DropdownEditor.prototype.prepare = function () {
- Handsontable.editors.AutocompleteEditor.prototype.prepare.apply(this, arguments);
-
- this.cellProperties.filter = false;
- this.cellProperties.strict = true;
-
- };
-
-
- Handsontable.editors.DropdownEditor = DropdownEditor;
- Handsontable.editors.registerEditor('dropdown', DropdownEditor);
-
-
-})(Handsontable);
-/**
- * Numeric cell validator
- * @param {*} value - Value of edited cell
- * @param {*} callback - Callback called with validation result
- */
-Handsontable.NumericValidator = function (value, callback) {
- if (value === null) {
- value = '';
- }
- callback(/^-?\d*\.?\d*$/.test(value));
-};
-/**
- * Function responsible for validation of autocomplete value
- * @param {*} value - Value of edited cell
- * @param {*} calback - Callback called with validation result
- */
-var process = function (value, callback) {
-
- var originalVal = value;
- var lowercaseVal = typeof originalVal === 'string' ? originalVal.toLowerCase() : null;
-
- return function (source) {
- var found = false;
- for (var s = 0, slen = source.length; s < slen; s++) {
- if (originalVal === source[s]) {
- found = true; //perfect match
- break;
- }
- else if (lowercaseVal === source[s].toLowerCase()) {
- // changes[i][3] = source[s]; //good match, fix the case << TODO?
- found = true;
- break;
- }
- }
-
- callback(found);
- }
-};
-
-/**
- * Autocomplete cell validator
- * @param {*} value - Value of edited cell
- * @param {*} calback - Callback called with validation result
- */
-Handsontable.AutocompleteValidator = function (value, callback) {
- if (this.strict && this.source) {
- typeof this.source === 'function' ? this.source(value, process(value, callback)) : process(value, callback)(this.source);
- } else {
- callback(true);
- }
-};
-
-/**
- * Cell type is just a shortcut for setting bunch of cellProperties (used in getCellMeta)
- */
-
-Handsontable.AutocompleteCell = {
- editor: Handsontable.editors.AutocompleteEditor,
- renderer: Handsontable.renderers.AutocompleteRenderer,
- validator: Handsontable.AutocompleteValidator
-};
-
-Handsontable.CheckboxCell = {
- editor: Handsontable.editors.CheckboxEditor,
- renderer: Handsontable.renderers.CheckboxRenderer
-};
-
-Handsontable.TextCell = {
- editor: Handsontable.editors.TextEditor,
- renderer: Handsontable.renderers.TextRenderer
-};
-
-Handsontable.NumericCell = {
- editor: Handsontable.editors.TextEditor,
- renderer: Handsontable.renderers.NumericRenderer,
- validator: Handsontable.NumericValidator,
- dataType: 'number'
-};
-
-Handsontable.DateCell = {
- editor: Handsontable.editors.DateEditor,
- renderer: Handsontable.renderers.AutocompleteRenderer //displays small gray arrow on right side of the cell
-};
-
-Handsontable.HandsontableCell = {
- editor: Handsontable.editors.HandsontableEditor,
- renderer: Handsontable.renderers.AutocompleteRenderer //displays small gray arrow on right side of the cell
-};
-
-Handsontable.PasswordCell = {
- editor: Handsontable.editors.PasswordEditor,
- renderer: Handsontable.renderers.PasswordRenderer
-};
-
-Handsontable.DropdownCell = {
- editor: Handsontable.editors.DropdownEditor,
- renderer: Handsontable.renderers.AutocompleteRenderer, //displays small gray arrow on right side of the cell
- validator: Handsontable.AutocompleteValidator
-};
-
-//here setup the friendly aliases that are used by cellProperties.type
-Handsontable.cellTypes = {
- text: Handsontable.TextCell,
- date: Handsontable.DateCell,
- numeric: Handsontable.NumericCell,
- checkbox: Handsontable.CheckboxCell,
- autocomplete: Handsontable.AutocompleteCell,
- handsontable: Handsontable.HandsontableCell,
- password: Handsontable.PasswordCell,
- dropdown: Handsontable.DropdownCell
-};
-
-//here setup the friendly aliases that are used by cellProperties.renderer and cellProperties.editor
-Handsontable.cellLookup = {
- validator: {
- numeric: Handsontable.NumericValidator,
- autocomplete: Handsontable.AutocompleteValidator
- }
-};
-/*
- * jQuery.fn.autoResize 1.1+
- * --
- * https://github.com/warpech/jQuery.fn.autoResize
- *
- * This fork differs from others in a way that it autoresizes textarea in 2-dimensions (horizontally and vertically).
- * It was originally forked from alexbardas's repo but maybe should be merged with dpashkevich's repo in future.
- *
- * originally forked from:
- * https://github.com/jamespadolsey/jQuery.fn.autoResize
- * which is now located here:
- * https://github.com/alexbardas/jQuery.fn.autoResize
- * though the mostly maintained for is here:
- * https://github.com/dpashkevich/jQuery.fn.autoResize/network
- *
- * --
- * This program is free software. It comes without any warranty, to
- * the extent permitted by applicable law. You can redistribute it
- * and/or modify it under the terms of the Do What The Fuck You Want
- * To Public License, Version 2, as published by Sam Hocevar. See
- * http://sam.zoy.org/wtfpl/COPYING for more details. */
-
-(function($){
-
- autoResize.defaults = {
- onResize: function(){},
- animate: {
- duration: 200,
- complete: function(){}
- },
- extraSpace: 50,
- minHeight: 'original',
- maxHeight: 500,
- minWidth: 'original',
- maxWidth: 500
- };
-
- autoResize.cloneCSSProperties = [
- 'lineHeight', 'textDecoration', 'letterSpacing',
- 'fontSize', 'fontFamily', 'fontStyle', 'fontWeight',
- 'textTransform', 'textAlign', 'direction', 'wordSpacing', 'fontSizeAdjust',
- 'padding'
- ];
-
- autoResize.cloneCSSValues = {
- position: 'absolute',
- top: -9999,
- left: -9999,
- opacity: 0,
- overflow: 'hidden',
- overflowX: 'hidden',
- overflowY: 'hidden',
- border: '1px solid black',
- padding: '0.49em' //this must be about the width of caps W character
- };
-
- autoResize.resizableFilterSelector = 'textarea,input:not(input[type]),input[type=text],input[type=password]';
-
- autoResize.AutoResizer = AutoResizer;
-
- $.fn.autoResize = autoResize;
-
- function autoResize(config) {
- this.filter(autoResize.resizableFilterSelector).each(function(){
- new AutoResizer( $(this), config );
- });
- return this;
- }
-
- function AutoResizer(el, config) {
-
- if(this.clones) return;
-
- this.config = $.extend({}, autoResize.defaults, config);
-
- this.el = el;
-
- this.nodeName = el[0].nodeName.toLowerCase();
-
- this.previousScrollTop = null;
-
- if (config.maxWidth === 'original') config.maxWidth = el.width();
- if (config.minWidth === 'original') config.minWidth = el.width();
- if (config.maxHeight === 'original') config.maxHeight = el.height();
- if (config.minHeight === 'original') config.minHeight = el.height();
-
- if (this.nodeName === 'textarea') {
- el.css({
- resize: 'none',
- overflowY: 'none'
- });
- }
-
- el.data('AutoResizer', this);
-
- this.createClone();
- this.injectClone();
- this.bind();
-
- }
-
- AutoResizer.prototype = {
-
- bind: function() {
-
- var check = $.proxy(function(){
- this.check();
- return true;
- }, this);
-
- this.unbind();
-
- this.el
- .bind('keyup.autoResize', check)
- //.bind('keydown.autoResize', check)
- .bind('change.autoResize', check);
-
- this.check(null, true);
-
- },
-
- unbind: function() {
- this.el.unbind('.autoResize');
- },
-
- createClone: function() {
-
- var el = this.el,
- self = this,
- config = this.config;
-
- this.clones = $();
-
- if (config.minHeight !== 'original' || config.maxHeight !== 'original') {
- this.hClone = el.clone().height('auto');
- this.clones = this.clones.add(this.hClone);
- }
- if (config.minWidth !== 'original' || config.maxWidth !== 'original') {
- this.wClone = $('').width('auto').css({
- whiteSpace: 'nowrap',
- 'float': 'left'
- });
- this.clones = this.clones.add(this.wClone);
- }
-
- $.each(autoResize.cloneCSSProperties, function(i, p){
- self.clones.css(p, el.css(p));
- });
-
- this.clones
- .removeAttr('name')
- .removeAttr('id')
- .attr('tabIndex', -1)
- .css(autoResize.cloneCSSValues)
- .css('overflowY', 'scroll');
-
- },
-
- check: function(e, immediate) {
-
- var config = this.config,
- wClone = this.wClone,
- hClone = this.hClone,
- el = this.el,
- value = el.val();
-
- if (wClone) {
-
- wClone.text(value);
-
- // Calculate new width + whether to change
- var cloneWidth = wClone.outerWidth(),
- newWidth = (cloneWidth + config.extraSpace) >= config.minWidth ?
- cloneWidth + config.extraSpace : config.minWidth,
- currentWidth = el.width();
-
- newWidth = Math.min(newWidth, config.maxWidth);
-
- if (
- (newWidth < currentWidth && newWidth >= config.minWidth) ||
- (newWidth >= config.minWidth && newWidth <= config.maxWidth)
- ) {
-
- config.onResize.call(el);
-
- el.scrollLeft(0);
-
- config.animate && !immediate ?
- el.stop(1,1).animate({
- width: newWidth
- }, config.animate)
- : el.width(newWidth);
-
- }
-
- }
-
- if (hClone) {
-
- if (newWidth) {
- hClone.width(newWidth);
- }
-
- hClone.height(0).val(value).scrollTop(10000);
-
- var scrollTop = hClone[0].scrollTop + config.extraSpace;
-
- // Don't do anything if scrollTop hasen't changed:
- if (this.previousScrollTop === scrollTop) {
- return;
- }
-
- this.previousScrollTop = scrollTop;
-
- if (scrollTop >= config.maxHeight) {
- scrollTop = config.maxHeight;
- }
-
- if (scrollTop < config.minHeight) {
- scrollTop = config.minHeight;
- }
-
- if(scrollTop == config.maxHeight && newWidth == config.maxWidth) {
- el.css('overflowY', 'scroll');
- }
- else {
- el.css('overflowY', 'hidden');
- }
-
- config.onResize.call(el);
-
- // Either animate or directly apply height:
- config.animate && !immediate ?
- el.stop(1,1).animate({
- height: scrollTop
- }, config.animate)
- : el.height(scrollTop);
- }
- },
-
- destroy: function() {
- this.unbind();
- this.el.removeData('AutoResizer');
- this.clones.remove();
- delete this.el;
- delete this.hClone;
- delete this.wClone;
- delete this.clones;
- },
-
- injectClone: function() {
- (
- autoResize.cloneContainer ||
- (autoResize.cloneContainer = $('').appendTo('body'))
- ).empty().append(this.clones); //this should be refactored so that a node is never cloned more than once
- }
-
- };
-
-})(jQuery);
-/**
- * SheetClip - Spreadsheet Clipboard Parser
- * version 0.2
- *
- * This tiny library transforms JavaScript arrays to strings that are pasteable by LibreOffice, OpenOffice,
- * Google Docs and Microsoft Excel.
- *
- * Copyright 2012, Marcin Warpechowski
- * Licensed under the MIT license.
- * http://github.com/warpech/sheetclip/
- */
-/*jslint white: true*/
-(function (global) {
- "use strict";
-
- function countQuotes(str) {
- return str.split('"').length - 1;
- }
-
- global.SheetClip = {
- parse: function (str) {
- var r, rlen, rows, arr = [], a = 0, c, clen, multiline, last;
- rows = str.split('\n');
- if (rows.length > 1 && rows[rows.length - 1] === '') {
- rows.pop();
- }
- for (r = 0, rlen = rows.length; r < rlen; r += 1) {
- rows[r] = rows[r].split('\t');
- for (c = 0, clen = rows[r].length; c < clen; c += 1) {
- if (!arr[a]) {
- arr[a] = [];
- }
- if (multiline && c === 0) {
- last = arr[a].length - 1;
- arr[a][last] = arr[a][last] + '\n' + rows[r][0];
- if (multiline && (countQuotes(rows[r][0]) & 1)) { //& 1 is a bitwise way of performing mod 2
- multiline = false;
- arr[a][last] = arr[a][last].substring(0, arr[a][last].length - 1).replace(/""/g, '"');
- }
- }
- else {
- if (c === clen - 1 && rows[r][c].indexOf('"') === 0) {
- arr[a].push(rows[r][c].substring(1).replace(/""/g, '"'));
- multiline = true;
- }
- else {
- arr[a].push(rows[r][c].replace(/""/g, '"'));
- multiline = false;
- }
- }
- }
- if (!multiline) {
- a += 1;
- }
- }
- return arr;
- },
-
- stringify: function (arr) {
- var r, rlen, c, clen, str = '', val;
- for (r = 0, rlen = arr.length; r < rlen; r += 1) {
- for (c = 0, clen = arr[r].length; c < clen; c += 1) {
- if (c > 0) {
- str += '\t';
- }
- val = arr[r][c];
- if (typeof val === 'string') {
- if (val.indexOf('\n') > -1) {
- str += '"' + val.replace(/"/g, '""') + '"';
- }
- else {
- str += val;
- }
- }
- else if (val === null || val === void 0) { //void 0 resolves to undefined
- str += '';
- }
- else {
- str += val;
- }
- }
- str += '\n';
- }
- return str;
- }
- };
-}(window));
-/**
- * CopyPaste.js
- * Creates a textarea that stays hidden on the page and gets focused when user presses CTRL while not having a form input focused
- * In future we may implement a better driver when better APIs are available
- * @constructor
- */
-var CopyPaste = (function () {
- var instance;
- return {
- getInstance: function () {
- if (!instance) {
- instance = new CopyPasteClass();
- } else if (instance.hasBeenDestroyed()){
- instance.init();
- }
-
- instance.refCounter++;
-
- return instance;
- }
- };
-})();
-
-function CopyPasteClass() {
- this.refCounter = 0;
- this.init();
-}
-
-CopyPasteClass.prototype.init = function () {
- var that = this
- , style
- , parent;
-
- this.copyCallbacks = [];
- this.cutCallbacks = [];
- this.pasteCallbacks = [];
-
- this.listenerElement = document.documentElement;
- parent = document.body;
-
- if (document.getElementById('CopyPasteDiv')) {
- this.elDiv = document.getElementById('CopyPasteDiv');
- this.elTextarea = this.elDiv.firstChild;
- }
- else {
- this.elDiv = document.createElement('DIV');
- this.elDiv.id = 'CopyPasteDiv';
- style = this.elDiv.style;
- style.position = 'fixed';
- style.top = 0;
- style.left = 0;
- parent.appendChild(this.elDiv);
-
- this.elTextarea = document.createElement('TEXTAREA');
- this.elTextarea.className = 'copyPaste';
- style = this.elTextarea.style;
- style.width = '1px';
- style.height = '1px';
- this.elDiv.appendChild(this.elTextarea);
-
- if (typeof style.opacity !== 'undefined') {
- style.opacity = 0;
- }
- else {
- /*@cc_on @if (@_jscript)
- if(typeof style.filter === 'string') {
- style.filter = 'alpha(opacity=0)';
- }
- @end @*/
- }
- }
-
- this.keydownListener = function (event) {
- var isCtrlDown = false;
- if (event.metaKey) { //mac
- isCtrlDown = true;
- }
- else if (event.ctrlKey && navigator.userAgent.indexOf('Mac') === -1) { //pc
- isCtrlDown = true;
- }
-
- if (isCtrlDown) {
- if (document.activeElement !== that.elTextarea && (that.getSelectionText() != '' || ['INPUT', 'SELECT', 'TEXTAREA'].indexOf(document.activeElement.nodeName) != -1)) {
- return; //this is needed by fragmentSelection in Handsontable. Ignore copypaste.js behavior if fragment of cell text is selected
- }
-
- that.selectNodeText(that.elTextarea);
- setTimeout(function () {
- that.selectNodeText(that.elTextarea);
- }, 0);
- }
-
- /* 67 = c
- * 86 = v
- * 88 = x
- */
- if (isCtrlDown && (event.keyCode === 67 || event.keyCode === 86 || event.keyCode === 88)) {
- // that.selectNodeText(that.elTextarea);
-
- if (event.keyCode === 88) { //works in all browsers, incl. Opera < 12.12
- setTimeout(function () {
- that.triggerCut(event);
- }, 0);
- }
- else if (event.keyCode === 86) {
- setTimeout(function () {
- that.triggerPaste(event);
- }, 0);
- }
- }
- };
-
- this._bindEvent(this.listenerElement, 'keydown', this.keydownListener);
-};
-
-//http://jsperf.com/textara-selection
-//http://stackoverflow.com/questions/1502385/how-can-i-make-this-code-work-in-ie
-CopyPasteClass.prototype.selectNodeText = function (el) {
- el.select();
-};
-
-//http://stackoverflow.com/questions/5379120/get-the-highlighted-selected-text
-CopyPasteClass.prototype.getSelectionText = function () {
- var text = "";
- if (document.getSelection) {
- text = document.getSelection().toString();
- } else if (document.selection && document.selection.type != "Control") {
- text = document.selection.createRange().text;
- }
- return text;
-};
-
-CopyPasteClass.prototype.copyable = function (str) {
- if (typeof str !== 'string' && str.toString === void 0) {
- throw new Error('copyable requires string parameter');
- }
- this.elTextarea.value = str;
-};
-
-/*CopyPasteClass.prototype.onCopy = function (fn) {
- this.copyCallbacks.push(fn);
-};*/
-
-CopyPasteClass.prototype.onCut = function (fn) {
- this.cutCallbacks.push(fn);
-};
-
-CopyPasteClass.prototype.onPaste = function (fn) {
- this.pasteCallbacks.push(fn);
-};
-
-CopyPasteClass.prototype.removeCallback = function (fn) {
- var i, ilen;
- for (i = 0, ilen = this.copyCallbacks.length; i < ilen; i++) {
- if (this.copyCallbacks[i] === fn) {
- this.copyCallbacks.splice(i, 1);
- return true;
- }
- }
- for (i = 0, ilen = this.cutCallbacks.length; i < ilen; i++) {
- if (this.cutCallbacks[i] === fn) {
- this.cutCallbacks.splice(i, 1);
- return true;
- }
- }
- for (i = 0, ilen = this.pasteCallbacks.length; i < ilen; i++) {
- if (this.pasteCallbacks[i] === fn) {
- this.pasteCallbacks.splice(i, 1);
- return true;
- }
- }
- return false;
-};
-
-CopyPasteClass.prototype.triggerCut = function (event) {
- var that = this;
- if (that.cutCallbacks) {
- setTimeout(function () {
- for (var i = 0, ilen = that.cutCallbacks.length; i < ilen; i++) {
- that.cutCallbacks[i](event);
- }
- }, 50);
- }
-};
-
-CopyPasteClass.prototype.triggerPaste = function (event, str) {
- var that = this;
- if (that.pasteCallbacks) {
- setTimeout(function () {
- var val = (str || that.elTextarea.value).replace(/\n$/, ''); //remove trailing newline
- for (var i = 0, ilen = that.pasteCallbacks.length; i < ilen; i++) {
- that.pasteCallbacks[i](val, event);
- }
- }, 50);
- }
-};
-
-CopyPasteClass.prototype.destroy = function () {
-
- if(!this.hasBeenDestroyed() && --this.refCounter == 0){
- if (this.elDiv && this.elDiv.parentNode) {
- this.elDiv.parentNode.removeChild(this.elDiv);
- }
-
- this._unbindEvent(this.listenerElement, 'keydown', this.keydownListener);
-
- }
-
-};
-
-CopyPasteClass.prototype.hasBeenDestroyed = function () {
- return !this.refCounter;
-};
-
-//old version used this:
-// - http://net.tutsplus.com/tutorials/javascript-ajax/javascript-from-null-cross-browser-event-binding/
-// - http://stackoverflow.com/questions/4643249/cross-browser-event-object-normalization
-//but that cannot work with jQuery.trigger
-CopyPasteClass.prototype._bindEvent = (function () {
- if (window.jQuery) { //if jQuery exists, use jQuery event (for compatibility with $.trigger and $.triggerHandler, which can only trigger jQuery events - and we use that in tests)
- return function (elem, type, cb) {
- $(elem).on(type + '.copypaste', cb);
- };
- }
- else {
- return function (elem, type, cb) {
- elem.addEventListener(type, cb, false); //sorry, IE8 will only work with jQuery
- };
- }
-})();
-
-CopyPasteClass.prototype._unbindEvent = (function () {
- if (window.jQuery) { //if jQuery exists, use jQuery event (for compatibility with $.trigger and $.triggerHandler, which can only trigger jQuery events - and we use that in tests)
- return function (elem, type, cb) {
- $(elem).off(type + '.copypaste', cb);
- };
- }
- else {
- return function (elem, type, cb) {
- elem.removeEventListener(type, cb, false); //sorry, IE8 will only work with jQuery
- };
- }
-})();
-// json-patch-duplex.js 0.3.6
-// (c) 2013 Joachim Wester
-// MIT license
-var jsonpatch;
-(function (jsonpatch) {
- var objOps = {
- add: function (obj, key) {
- obj[key] = this.value;
- return true;
- },
- remove: function (obj, key) {
- delete obj[key];
- return true;
- },
- replace: function (obj, key) {
- obj[key] = this.value;
- return true;
- },
- move: function (obj, key, tree) {
- var temp = { op: "_get", path: this.from };
- apply(tree, [temp]);
- apply(tree, [
- { op: "remove", path: this.from }
- ]);
- apply(tree, [
- { op: "add", path: this.path, value: temp.value }
- ]);
- return true;
- },
- copy: function (obj, key, tree) {
- var temp = { op: "_get", path: this.from };
- apply(tree, [temp]);
- apply(tree, [
- { op: "add", path: this.path, value: temp.value }
- ]);
- return true;
- },
- test: function (obj, key) {
- return (JSON.stringify(obj[key]) === JSON.stringify(this.value));
- },
- _get: function (obj, key) {
- this.value = obj[key];
- }
- };
-
- var arrOps = {
- add: function (arr, i) {
- arr.splice(i, 0, this.value);
- return true;
- },
- remove: function (arr, i) {
- arr.splice(i, 1);
- return true;
- },
- replace: function (arr, i) {
- arr[i] = this.value;
- return true;
- },
- move: objOps.move,
- copy: objOps.copy,
- test: objOps.test,
- _get: objOps._get
- };
-
- var observeOps = {
- add: function (patches, path) {
- var patch = {
- op: "add",
- path: path + escapePathComponent(this.name),
- value: this.object[this.name]
- };
- patches.push(patch);
- },
- 'delete': function (patches, path) {
- var patch = {
- op: "remove",
- path: path + escapePathComponent(this.name)
- };
- patches.push(patch);
- },
- update: function (patches, path) {
- var patch = {
- op: "replace",
- path: path + escapePathComponent(this.name),
- value: this.object[this.name]
- };
- patches.push(patch);
- }
- };
-
- function escapePathComponent(str) {
- if (str.indexOf('/') === -1 && str.indexOf('~') === -1)
- return str;
- return str.replace(/~/g, '~0').replace(/\//g, '~1');
- }
-
- function _getPathRecursive(root, obj) {
- var found;
- for (var key in root) {
- if (root.hasOwnProperty(key)) {
- if (root[key] === obj) {
- return escapePathComponent(key) + '/';
- } else if (typeof root[key] === 'object') {
- found = _getPathRecursive(root[key], obj);
- if (found != '') {
- return escapePathComponent(key) + '/' + found;
- }
- }
- }
- }
- return '';
- }
-
- function getPath(root, obj) {
- if (root === obj) {
- return '/';
- }
- var path = _getPathRecursive(root, obj);
- if (path === '') {
- throw new Error("Object not found in root");
- }
- return '/' + path;
- }
-
- var beforeDict = [];
-
- jsonpatch.intervals;
-
- var Mirror = (function () {
- function Mirror(obj) {
- this.observers = [];
- this.obj = obj;
- }
- return Mirror;
- })();
-
- var ObserverInfo = (function () {
- function ObserverInfo(callback, observer) {
- this.callback = callback;
- this.observer = observer;
- }
- return ObserverInfo;
- })();
-
- function getMirror(obj) {
- for (var i = 0, ilen = beforeDict.length; i < ilen; i++) {
- if (beforeDict[i].obj === obj) {
- return beforeDict[i];
- }
- }
- }
-
- function getObserverFromMirror(mirror, callback) {
- for (var j = 0, jlen = mirror.observers.length; j < jlen; j++) {
- if (mirror.observers[j].callback === callback) {
- return mirror.observers[j].observer;
- }
- }
- }
-
- function removeObserverFromMirror(mirror, observer) {
- for (var j = 0, jlen = mirror.observers.length; j < jlen; j++) {
- if (mirror.observers[j].observer === observer) {
- mirror.observers.splice(j, 1);
- return;
- }
- }
- }
-
- function unobserve(root, observer) {
- generate(observer);
- if (Object.observe) {
- _unobserve(observer, root);
- } else {
- clearTimeout(observer.next);
- }
-
- var mirror = getMirror(root);
- removeObserverFromMirror(mirror, observer);
- }
- jsonpatch.unobserve = unobserve;
-
- function observe(obj, callback) {
- var patches = [];
- var root = obj;
- var observer;
- var mirror = getMirror(obj);
-
- if (!mirror) {
- mirror = new Mirror(obj);
- beforeDict.push(mirror);
- } else {
- observer = getObserverFromMirror(mirror, callback);
- }
-
- if (observer) {
- return observer;
- }
-
- if (Object.observe) {
- observer = function (arr) {
- //This "refresh" is needed to begin observing new object properties
- _unobserve(observer, obj);
- _observe(observer, obj);
-
- var a = 0, alen = arr.length;
- while (a < alen) {
- if (!(arr[a].name === 'length' && _isArray(arr[a].object)) && !(arr[a].name === '__Jasmine_been_here_before__')) {
- var type = arr[a].type;
-
- switch (type) {
- case 'new':
- type = 'add';
- break;
-
- case 'deleted':
- type = 'delete';
- break;
-
- case 'updated':
- type = 'update';
- break;
- }
-
- observeOps[type].call(arr[a], patches, getPath(root, arr[a].object));
- }
- a++;
- }
-
- if (patches) {
- if (callback) {
- callback(patches);
- }
- }
- observer.patches = patches;
- patches = [];
- };
- } else {
- observer = {};
-
- mirror.value = JSON.parse(JSON.stringify(obj));
-
- if (callback) {
- //callbacks.push(callback); this has no purpose
- observer.callback = callback;
- observer.next = null;
- var intervals = this.intervals || [100, 1000, 10000, 60000];
- var currentInterval = 0;
-
- var dirtyCheck = function () {
- generate(observer);
- };
- var fastCheck = function () {
- clearTimeout(observer.next);
- observer.next = setTimeout(function () {
- dirtyCheck();
- currentInterval = 0;
- observer.next = setTimeout(slowCheck, intervals[currentInterval++]);
- }, 0);
- };
- var slowCheck = function () {
- dirtyCheck();
- if (currentInterval == intervals.length)
- currentInterval = intervals.length - 1;
- observer.next = setTimeout(slowCheck, intervals[currentInterval++]);
- };
- if (typeof window !== 'undefined') {
- if (window.addEventListener) {
- window.addEventListener('mousedown', fastCheck);
- window.addEventListener('mouseup', fastCheck);
- window.addEventListener('keydown', fastCheck);
- } else {
- window.attachEvent('onmousedown', fastCheck);
- window.attachEvent('onmouseup', fastCheck);
- window.attachEvent('onkeydown', fastCheck);
- }
- }
- observer.next = setTimeout(slowCheck, intervals[currentInterval++]);
- }
- }
- observer.patches = patches;
- observer.object = obj;
-
- mirror.observers.push(new ObserverInfo(callback, observer));
-
- return _observe(observer, obj);
- }
- jsonpatch.observe = observe;
-
- /// Listen to changes on an object tree, accumulate patches
- function _observe(observer, obj) {
- if (Object.observe) {
- Object.observe(obj, observer);
- for (var key in obj) {
- if (obj.hasOwnProperty(key)) {
- var v = obj[key];
- if (v && typeof (v) === "object") {
- _observe(observer, v);
- }
- }
- }
- }
- return observer;
- }
-
- function _unobserve(observer, obj) {
- if (Object.observe) {
- Object.unobserve(obj, observer);
- for (var key in obj) {
- if (obj.hasOwnProperty(key)) {
- var v = obj[key];
- if (v && typeof (v) === "object") {
- _unobserve(observer, v);
- }
- }
- }
- }
- return observer;
- }
-
- function generate(observer) {
- if (Object.observe) {
- Object.deliverChangeRecords(observer);
- } else {
- var mirror;
- for (var i = 0, ilen = beforeDict.length; i < ilen; i++) {
- if (beforeDict[i].obj === observer.object) {
- mirror = beforeDict[i];
- break;
- }
- }
- _generate(mirror.value, observer.object, observer.patches, "");
- }
- var temp = observer.patches;
- if (temp.length > 0) {
- observer.patches = [];
- if (observer.callback) {
- observer.callback(temp);
- }
- }
- return temp;
- }
- jsonpatch.generate = generate;
-
- var _objectKeys;
- if (Object.keys) {
- _objectKeys = Object.keys;
- } else {
- _objectKeys = function (obj) {
- var keys = [];
- for (var o in obj) {
- if (obj.hasOwnProperty(o)) {
- keys.push(o);
- }
- }
- return keys;
- };
- }
-
- // Dirty check if obj is different from mirror, generate patches and update mirror
- function _generate(mirror, obj, patches, path) {
- var newKeys = _objectKeys(obj);
- var oldKeys = _objectKeys(mirror);
- var changed = false;
- var deleted = false;
-
- for (var t = oldKeys.length - 1; t >= 0; t--) {
- var key = oldKeys[t];
- var oldVal = mirror[key];
- if (obj.hasOwnProperty(key)) {
- var newVal = obj[key];
- if (oldVal instanceof Object) {
- _generate(oldVal, newVal, patches, path + "/" + escapePathComponent(key));
- } else {
- if (oldVal != newVal) {
- changed = true;
- patches.push({ op: "replace", path: path + "/" + escapePathComponent(key), value: newVal });
- mirror[key] = newVal;
- }
- }
- } else {
- patches.push({ op: "remove", path: path + "/" + escapePathComponent(key) });
- delete mirror[key];
- deleted = true;
- }
- }
-
- if (!deleted && newKeys.length == oldKeys.length) {
- return;
- }
-
- for (var t = 0; t < newKeys.length; t++) {
- var key = newKeys[t];
- if (!mirror.hasOwnProperty(key)) {
- patches.push({ op: "add", path: path + "/" + escapePathComponent(key), value: obj[key] });
- mirror[key] = JSON.parse(JSON.stringify(obj[key]));
- }
- }
- }
-
- var _isArray;
- if (Array.isArray) {
- _isArray = Array.isArray;
- } else {
- _isArray = function (obj) {
- return obj.push && typeof obj.length === 'number';
- };
- }
-
- /// Apply a json-patch operation on an object tree
- function apply(tree, patches) {
- var result = false, p = 0, plen = patches.length, patch;
- while (p < plen) {
- patch = patches[p];
-
- // Find the object
- var keys = patch.path.split('/');
- var obj = tree;
- var t = 1;
- var len = keys.length;
- while (true) {
- if (_isArray(obj)) {
- var index = parseInt(keys[t], 10);
- t++;
- if (t >= len) {
- result = arrOps[patch.op].call(patch, obj, index, tree);
- break;
- }
- obj = obj[index];
- } else {
- var key = keys[t];
- if (key.indexOf('~') != -1)
- key = key.replace(/~1/g, '/').replace(/~0/g, '~');
- t++;
- if (t >= len) {
- result = objOps[patch.op].call(patch, obj, key, tree);
- break;
- }
- obj = obj[key];
- }
- }
- p++;
- }
- return result;
- }
- jsonpatch.apply = apply;
-})(jsonpatch || (jsonpatch = {}));
-
-if (typeof exports !== "undefined") {
- exports.apply = jsonpatch.apply;
- exports.observe = jsonpatch.observe;
- exports.unobserve = jsonpatch.unobserve;
- exports.generate = jsonpatch.generate;
-}
-
-Handsontable.PluginHookClass = (function () {
-
- var Hooks = function () {
- return {
- // Hooks
- beforeInitWalkontable: [],
-
- beforeInit: [],
- beforeRender: [],
- beforeChange: [],
- beforeRemoveCol: [],
- beforeRemoveRow: [],
- beforeValidate: [],
- beforeGet: [],
- beforeSet: [],
- beforeGetCellMeta: [],
- beforeAutofill: [],
- beforeKeyDown: [],
- beforeColumnSort: [],
-
- afterInit : [],
- afterLoadData : [],
- afterUpdateSettings: [],
- afterRender : [],
- afterRenderer : [],
- afterChange : [],
- afterValidate: [],
- afterGetCellMeta: [],
- afterGetColHeader: [],
- afterGetRowHeader: [],
- afterGetColWidth: [],
- afterDestroy: [],
- afterRemoveRow: [],
- afterCreateRow: [],
- afterRemoveCol: [],
- afterCreateCol: [],
- afterColumnResize: [],
- afterColumnMove: [],
- afterColumnSort: [],
- afterDeselect: [],
- afterSelection: [],
- afterSelectionByProp: [],
- afterSelectionEnd: [],
- afterSelectionEndByProp: [],
- afterCopyLimit: [],
- afterOnCellMouseDown: [],
- afterOnCellMouseOver: [],
- afterOnCellCornerMouseDown: [],
- afterScrollVertically: [],
- afterScrollHorizontally: [],
-
- // Modifiers
- modifyCol: []
- }
- };
-
- var legacy = {
- onBeforeChange: "beforeChange",
- onChange: "afterChange",
- onCreateRow: "afterCreateRow",
- onCreateCol: "afterCreateCol",
- onSelection: "afterSelection",
- onCopyLimit: "afterCopyLimit",
- onSelectionEnd: "afterSelectionEnd",
- onSelectionByProp: "afterSelectionByProp",
- onSelectionEndByProp: "afterSelectionEndByProp"
- };
-
- function PluginHookClass() {
-
- this.hooks = Hooks();
-
- this.legacy = legacy;
-
- }
-
- PluginHookClass.prototype.add = function (key, fn) {
- // provide support for old versions of HOT
- if (key in legacy) {
- key = legacy[key];
- }
-
- if (typeof this.hooks[key] === "undefined") {
- this.hooks[key] = [];
- }
-
- if (Handsontable.helper.isArray(fn)) {
- for (var i = 0, len = fn.length; i < len; i++) {
- this.hooks[key].push(fn[i]);
- }
- } else {
- if (this.hooks[key].indexOf(fn) > -1) {
- throw new Error("Seems that you are trying to set the same plugin hook twice (" + key + ", " + fn + ")"); //error here should help writing bug-free plugins
- }
- this.hooks[key].push(fn);
- }
-
- return this;
- };
-
- PluginHookClass.prototype.once = function(key, fn){
-
- if(Handsontable.helper.isArray(fn)){
-
- for(var i = 0, len = fn.length; i < len; i++){
- fn[i].runOnce = true;
- this.add(key, fn[i]);
- }
-
- } else {
- fn.runOnce = true;
- this.add(key, fn);
-
- }
-
- };
-
- PluginHookClass.prototype.remove = function (key, fn) {
- var status = false;
-
- // provide support for old versions of HOT
- if (key in legacy) {
- key = legacy[key];
- }
-
- if (typeof this.hooks[key] !== 'undefined') {
-
- for (var i = 0, leni = this.hooks[key].length; i < leni; i++) {
-
- if (this.hooks[key][i] == fn) {
- delete this.hooks[key][i].runOnce;
- this.hooks[key].splice(i, 1);
- status = true;
- break;
- }
-
- }
-
- }
-
- return status;
- };
-
- PluginHookClass.prototype.run = function (instance, key, p1, p2, p3, p4, p5) {
-
- // provide support for old versions of HOT
- if (key in legacy) {
- key = legacy[key];
- }
-
- //performance considerations - http://jsperf.com/call-vs-apply-for-a-plugin-architecture
- if (typeof this.hooks[key] !== 'undefined') {
-
- //Make a copy of handler array
- var handlers = Array.prototype.slice.call(this.hooks[key]);
-
- for (var i = 0, leni = handlers.length; i < leni; i++) {
- handlers[i].call(instance, p1, p2, p3, p4, p5);
-
- if(handlers[i].runOnce){
- this.remove(key, handlers[i]);
- }
- }
-
- }
-
- };
-
- PluginHookClass.prototype.execute = function (instance, key, p1, p2, p3, p4, p5) {
- var res, handlers;
-
- // provide support for old versions of HOT
- if (key in legacy) {
- key = legacy[key];
- }
-
- //performance considerations - http://jsperf.com/call-vs-apply-for-a-plugin-architecture
- if (typeof this.hooks[key] !== 'undefined') {
-
- handlers = Array.prototype.slice.call(this.hooks[key]);
-
- for (var i = 0, leni = handlers.length; i < leni; i++) {
-
- res = handlers[i].call(instance, p1, p2, p3, p4, p5);
- if (res !== void 0) {
- p1 = res;
- }
-
- if(handlers[i].runOnce){
- this.remove(key, handlers[i]);
- }
-
- if(res === false){ //if any handler returned false
- return false; //event has been cancelled and further execution of handler queue is being aborted
- }
-
- }
-
- }
-
- return p1;
- };
-
- return PluginHookClass;
-
-})();
-
-Handsontable.PluginHooks = new Handsontable.PluginHookClass();
-
-(function (Handsontable) {
-
- function HandsontableAutoColumnSize() {
- var plugin = this
- , sampleCount = 5; //number of samples to take of each value length
-
- this.beforeInit = function () {
- var instance = this;
- instance.autoColumnWidths = [];
-
- if (instance.getSettings().autoColumnSize !== false) {
- if (!instance.autoColumnSizeTmp) {
- instance.autoColumnSizeTmp = {
- table: null,
- tableStyle: null,
- theadTh: null,
- tbody: null,
- container: null,
- containerStyle: null,
- determineBeforeNextRender: true
- };
-
- instance.addHook('beforeRender', htAutoColumnSize.determineIfChanged);
- instance.addHook('afterGetColWidth', htAutoColumnSize.getColWidth);
- instance.addHook('afterDestroy', htAutoColumnSize.afterDestroy);
-
- instance.determineColumnWidth = plugin.determineColumnWidth;
- }
- } else {
- if (instance.autoColumnSizeTmp) {
- instance.removeHook('beforeRender', htAutoColumnSize.determineIfChanged);
- instance.removeHook('afterGetColWidth', htAutoColumnSize.getColWidth);
- instance.removeHook('afterDestroy', htAutoColumnSize.afterDestroy);
-
- delete instance.determineColumnWidth;
-
- plugin.afterDestroy.call(instance);
- }
- }
- };
-
- this.determineIfChanged = function (force) {
- if (force) {
- htAutoColumnSize.determineColumnsWidth.apply(this, arguments);
- }
- };
-
- this.determineColumnWidth = function (col) {
- var instance = this
- , tmp = instance.autoColumnSizeTmp;
-
- if (!tmp.container) {
- createTmpContainer.call(tmp, instance);
- }
-
- tmp.container.className = instance.rootElement[0].className + ' htAutoColumnSize';
- tmp.table.className = instance.$table[0].className;
-
- var rows = instance.countRows();
- var samples = {};
- var maxLen = 0;
- for (var r = 0; r < rows; r++) {
- var value = Handsontable.helper.stringify(instance.getDataAtCell(r, col));
- var len = value.length;
- if (len > maxLen) {
- maxLen = len;
- }
- if (!samples[len]) {
- samples[len] = {
- needed: sampleCount,
- strings: []
- };
- }
- if (samples[len].needed) {
- samples[len].strings.push({value: value, row: r});
- samples[len].needed--;
- }
- }
-
- var settings = instance.getSettings();
- if (settings.colHeaders) {
- instance.view.appendColHeader(col, tmp.theadTh); //TH innerHTML
- }
-
- instance.view.wt.wtDom.empty(tmp.tbody);
-
- for (var i in samples) {
- if (samples.hasOwnProperty(i)) {
- for (var j = 0, jlen = samples[i].strings.length; j < jlen; j++) {
- var row = samples[i].strings[j].row;
-
- var cellProperties = instance.getCellMeta(row, col);
- cellProperties.col = col;
- cellProperties.row = row;
-
- var renderer = instance.getCellRenderer(cellProperties);
-
- var tr = document.createElement('tr');
- var td = document.createElement('td');
-
- renderer(instance, td, row, col, instance.colToProp(col), samples[i].strings[j].value, cellProperties);
- r++;
- tr.appendChild(td);
- tmp.tbody.appendChild(tr);
- }
- }
- }
-
- var parent = instance.rootElement[0].parentNode;
- parent.appendChild(tmp.container);
- var width = instance.view.wt.wtDom.outerWidth(tmp.table);
- parent.removeChild(tmp.container);
-
- if (!settings.nativeScrollbars) { //with native scrollbars a cell size can safely exceed the width of the viewport
- var maxWidth = instance.view.wt.wtViewport.getViewportWidth() - 2; //2 is some overhead for cell border
- if (width > maxWidth) {
- width = maxWidth;
- }
- }
-
- width += 10; // added a bit of padding ANDI
-
- // we limit the size to a third of the table ANDI
- var widthLimit = Math.floor(instance.view.wt.wtViewport.getViewportWidth() / 3.0);
- if(width > widthLimit) width = widthLimit;
-
- return width;
- };
-
- this.determineColumnsWidth = function () {
- var instance = this;
- var settings = this.getSettings();
- if (settings.autoColumnSize || !settings.colWidths) {
- var cols = this.countCols();
- for (var c = 0; c < cols; c++) {
- if (!instance._getColWidthFromSettings(c)) {
- this.autoColumnWidths[c] = plugin.determineColumnWidth.call(instance, c);
- }
- }
- }
- };
-
- this.getColWidth = function (col, response) {
- if (this.autoColumnWidths[col] && this.autoColumnWidths[col] > response.width) {
- response.width = this.autoColumnWidths[col];
- }
- };
-
- this.afterDestroy = function () {
- var instance = this;
- if (instance.autoColumnSizeTmp && instance.autoColumnSizeTmp.container && instance.autoColumnSizeTmp.container.parentNode) {
- instance.autoColumnSizeTmp.container.parentNode.removeChild(instance.autoColumnSizeTmp.container);
- }
- instance.autoColumnSizeTmp = null;
- };
-
- function createTmpContainer(instance) {
- var d = document
- , tmp = this;
-
- tmp.table = d.createElement('table');
- tmp.theadTh = d.createElement('th');
- tmp.table.appendChild(d.createElement('thead')).appendChild(d.createElement('tr')).appendChild(tmp.theadTh);
-
- tmp.tableStyle = tmp.table.style;
- tmp.tableStyle.tableLayout = 'auto';
- tmp.tableStyle.width = 'auto';
-
- tmp.tbody = d.createElement('tbody');
- tmp.table.appendChild(tmp.tbody);
-
- tmp.container = d.createElement('div');
- tmp.container.className = instance.rootElement[0].className + ' hidden';
- tmp.containerStyle = tmp.container.style;
-
- tmp.container.appendChild(tmp.table);
- }
- }
-
- var htAutoColumnSize = new HandsontableAutoColumnSize();
-
- Handsontable.PluginHooks.add('beforeInit', htAutoColumnSize.beforeInit);
- Handsontable.PluginHooks.add('afterUpdateSettings', htAutoColumnSize.beforeInit);
-
-})(Handsontable);
-
-/**
- * This plugin sorts the view by a column (but does not sort the data source!)
- * @constructor
- */
-function HandsontableColumnSorting() {
- var plugin = this;
-
- this.init = function (source) {
- var instance = this;
- var sortingSettings = instance.getSettings().columnSorting;
- var sortingColumn, sortingOrder;
-
- instance.sortingEnabled = !!(sortingSettings);
-
- if (instance.sortingEnabled) {
- instance.sortIndex = [];
-
- var loadedSortingState = loadSortingState.call(instance);
-
- if (typeof loadedSortingState != 'undefined') {
- sortingColumn = loadedSortingState.sortColumn;
- sortingOrder = loadedSortingState.sortOrder;
- } else {
- sortingColumn = sortingSettings.column;
- sortingOrder = sortingSettings.sortOrder;
- }
- plugin.sortByColumn.call(instance, sortingColumn, sortingOrder);
-
- instance.sort = function(){
- var args = Array.prototype.slice.call(arguments);
-
- return plugin.sortByColumn.apply(instance, args)
- };
-
- if (typeof instance.getSettings().observeChanges == 'undefined'){
- enableObserveChangesPlugin.call(instance);
- }
-
- if (source == 'afterInit') {
- bindColumnSortingAfterClick.call(instance);
-
- instance.addHook('afterCreateRow', plugin.afterCreateRow);
- instance.addHook('afterRemoveRow', plugin.afterRemoveRow);
- instance.addHook('afterLoadData', plugin.init);
- }
- } else {
- delete instance.sort;
-
- instance.removeHook('afterCreateRow', plugin.afterCreateRow);
- instance.removeHook('afterRemoveRow', plugin.afterRemoveRow);
- instance.removeHook('afterLoadData', plugin.init);
- }
- };
-
- this.setSortingColumn = function (col, order) {
- var instance = this;
-
- if (typeof col == 'undefined') {
- delete instance.sortColumn;
- delete instance.sortOrder;
-
- return;
- } else if (instance.sortColumn === col && typeof order == 'undefined') {
- instance.sortOrder = !instance.sortOrder;
- } else {
- instance.sortOrder = typeof order != 'undefined' ? order : true;
- }
-
- instance.sortColumn = col;
-
- };
-
- this.sortByColumn = function (col, order) {
- var instance = this;
-
- plugin.setSortingColumn.call(instance, col, order);
-
- if(typeof instance.sortColumn == 'undefined'){
- return;
- }
-
- instance.PluginHooks.run('beforeColumnSort', instance.sortColumn, instance.sortOrder);
-
- plugin.sort.call(instance);
- instance.render();
-
- saveSortingState.call(instance);
-
- instance.PluginHooks.run('afterColumnSort', instance.sortColumn, instance.sortOrder);
- };
-
- var saveSortingState = function () {
- var instance = this;
-
- var sortingState = {};
-
- if (typeof instance.sortColumn != 'undefined') {
- sortingState.sortColumn = instance.sortColumn;
- }
-
- if (typeof instance.sortOrder != 'undefined') {
- sortingState.sortOrder = instance.sortOrder;
- }
-
- if (sortingState.hasOwnProperty('sortColumn') || sortingState.hasOwnProperty('sortOrder')) {
- instance.PluginHooks.run('persistentStateSave', 'columnSorting', sortingState);
- }
-
- };
-
- var loadSortingState = function () {
- var instance = this;
- var storedState = {};
- instance.PluginHooks.run('persistentStateLoad', 'columnSorting', storedState);
-
- return storedState.value;
- };
-
- var bindColumnSortingAfterClick = function () {
- var instance = this;
-
- instance.rootElement.on('click.handsontable', '.columnSorting', function (e) {
- if (instance.view.wt.wtDom.hasClass(e.target, 'columnSorting')) {
- var col = getColumn(e.target);
- plugin.sortByColumn.call(instance, col);
- }
- });
-
- function countRowHeaders() {
- var THs = instance.view.TBODY.querySelector('tr').querySelectorAll('th');
- return THs.length;
- }
-
- function getColumn(target) {
- var TH = instance.view.wt.wtDom.closest(target, 'TH');
- return instance.view.wt.wtDom.index(TH) - countRowHeaders();
- }
- };
-
- function enableObserveChangesPlugin () {
- var instance = this;
- instance.registerTimeout('enableObserveChanges', function(){
- instance.updateSettings({
- observeChanges: true
- });
- }, 0);
- }
-
- function defaultSort(sortOrder) {
- return function (a, b) {
- if (a[1] === b[1]) {
- return 0;
- }
- if (a[1] === null) {
- return 1;
- }
- if (b[1] === null) {
- return -1;
- }
- if (a[1] < b[1]) return sortOrder ? -1 : 1;
- if (a[1] > b[1]) return sortOrder ? 1 : -1;
- return 0;
- }
- }
-
- function dateSort(sortOrder) {
- return function (a, b) {
- if (a[1] === b[1]) {
- return 0;
- }
- if (a[1] === null) {
- return 1;
- }
- if (b[1] === null) {
- return -1;
- }
-
- var aDate = new Date(a[1]);
- var bDate = new Date(b[1]);
-
- if (aDate < bDate) return sortOrder ? -1 : 1;
- if (aDate > bDate) return sortOrder ? 1 : -1;
-
- return 0;
- }
- }
-
- this.sort = function () {
- var instance = this;
-
- if (typeof instance.sortOrder == 'undefined') {
- return;
- }
-
- instance.sortingEnabled = false; //this is required by translateRow plugin hook
- instance.sortIndex.length = 0;
-
- var colOffset = this.colOffset();
- for (var i = 0, ilen = this.countRows() - instance.getSettings()['minSpareRows']; i < ilen; i++) {
- this.sortIndex.push([i, instance.getDataAtCell(i, this.sortColumn + colOffset)]);
- }
-
- var colMeta = instance.getCellMeta(0, instance.sortColumn);
- var sortFunction;
- switch (colMeta.type) {
- case 'date':
- sortFunction = dateSort;
- break;
- default:
- sortFunction = defaultSort;
- }
-
- this.sortIndex.sort(sortFunction(instance.sortOrder));
-
- //Append spareRows
- for(var i = this.sortIndex.length; i < instance.countRows(); i++){
- this.sortIndex.push([i, instance.getDataAtCell(i, this.sortColumn + colOffset)]);
- }
-
- instance.sortingEnabled = true; //this is required by translateRow plugin hook
- };
-
- this.translateRow = function (row) {
- var instance = this;
-
- if (instance.sortingEnabled && instance.sortIndex && instance.sortIndex.length && instance.sortIndex[row]) {
- return instance.sortIndex[row][0];
- }
-
- return row;
- };
-
- this.onBeforeGetSet = function (getVars) {
- var instance = this;
- getVars.row = plugin.translateRow.call(instance, getVars.row);
- };
-
- this.untranslateRow = function (row) {
- var instance = this;
- if (instance.sortingEnabled && instance.sortIndex && instance.sortIndex.length) {
- for (var i = 0; i < instance.sortIndex.length; i++) {
- if (instance.sortIndex[i][0] == row) {
- return i;
- }
- }
- }
- };
-
- this.getColHeader = function (col, TH) {
- if (this.getSettings().columnSorting) {
- this.view.wt.wtDom.addClass(TH.querySelector('.colHeader'), 'columnSorting');
- }
- };
-
- function isSorted(instance){
- return typeof instance.sortColumn != 'undefined';
- }
-
- this.afterCreateRow = function(index, amount){
- var instance = this;
-
- if(!isSorted(instance)){
- return;
- }
-
-
- for(var i = 0; i < instance.sortIndex.length; i++){
- if (instance.sortIndex[i][0] >= index){
- instance.sortIndex[i][0] += amount;
- }
- }
-
- for(var i=0; i < amount; i++){
- instance.sortIndex.splice(index+i, 0, [index+i, instance.getData()[index+i][instance.sortColumn + instance.colOffset()]]);
- }
-
-
-
- saveSortingState.call(instance);
-
- };
-
- this.afterRemoveRow = function(index, amount){
- var instance = this;
-
- if(!isSorted(instance)){
- return;
- }
-
- var physicalRemovedIndex = plugin.translateRow.call(instance, index);
-
- instance.sortIndex.splice(index, amount);
-
- for(var i = 0; i < instance.sortIndex.length; i++){
-
- if (instance.sortIndex[i][0] > physicalRemovedIndex){
- instance.sortIndex[i][0] -= amount;
- }
- }
-
- saveSortingState.call(instance);
-
- };
-
- this.afterChangeSort = function (changes/*, source*/) {
- var instance = this;
- var sortColumnChanged = false;
- var selection = {};
- if (!changes) {
- return;
- }
-
- for (var i = 0; i < changes.length; i++) {
- if (changes[i][1] == instance.sortColumn) {
- sortColumnChanged = true;
- selection.row = plugin.translateRow.call(instance, changes[i][0]);
- selection.col = changes[i][1];
- break;
- }
- }
-
- if (sortColumnChanged) {
- setTimeout(function () {
- plugin.sort.call(instance);
- instance.render();
- instance.selectCell(plugin.untranslateRow.call(instance, selection.row), selection.col);
- }, 0);
- }
- };
-}
-var htSortColumn = new HandsontableColumnSorting();
-
-Handsontable.PluginHooks.add('afterInit', function () {
- htSortColumn.init.call(this, 'afterInit')
-});
-Handsontable.PluginHooks.add('afterUpdateSettings', function () {
- htSortColumn.init.call(this, 'afterUpdateSettings')
-});
-Handsontable.PluginHooks.add('beforeGet', htSortColumn.onBeforeGetSet);
-Handsontable.PluginHooks.add('beforeSet', htSortColumn.onBeforeGetSet);
-Handsontable.PluginHooks.add('afterGetColHeader', htSortColumn.getColHeader);
-
-
-(function (Handsontable) {
- 'use strict';
-
- function ContextMenu(instance, customOptions){
- this.instance = instance;
- var contextMenu = this;
-
- this.menu = createMenu();
- this.enabled = true;
-
- this.bindMouseEvents();
- this.bindTableEvents();
-
- this.instance.addHook('afterDestroy', function () {
- contextMenu.destroy();
- });
-
- this.defaultOptions = {
- items: {
- 'row_above': {
- name: 'Insert row above',
- callback: function(key, selection){
- this.alter("insert_row", selection.start.row());
- },
- disabled: function () {
- return this.countRows() >= this.getSettings().maxRows;
- }
- },
- 'row_below': {
- name: 'Insert row below',
- callback: function(key, selection){
- this.alter("insert_row", selection.end.row() + 1);
- },
- disabled: function () {
- return this.countRows() >= this.getSettings().maxRows;
- }
- },
- "hsep1": ContextMenu.SEPARATOR,
- 'col_left': {
- name: 'Insert column on the left',
- callback: function(key, selection){
- this.alter("insert_col", selection.start.col());
- },
- disabled: function () {
- return this.countCols() >= this.getSettings().maxCols;
- }
- },
- 'col_right': {
- name: 'Insert column on the right',
- callback: function(key, selection){
- this.alter("insert_col", selection.end.col() + 1);
- },
- disabled: function () {
- return this.countCols() >= this.getSettings().maxCols;
- }
- },
- "hsep2": ContextMenu.SEPARATOR,
- 'remove_row': {
- name: 'Remove row',
- callback: function(key, selection){
- var amount = selection.end.row() - selection.start.row() + 1;
- this.alter("remove_row", selection.start.row(), amount);
- }
- },
- 'remove_col': {
- name: 'Remove column',
- callback: function(key, selection){
- var amount = selection.end.col() - selection.start.col() + 1;
- this.alter("remove_col", selection.start.col(), amount);
- }
- },
- "hsep3": ContextMenu.SEPARATOR,
- 'undo': {
- name: 'Undo',
- callback: function(){
- this.undo();
- },
- disabled: function () {
- return this.undoRedo && !this.undoRedo.isUndoAvailable();
- }
- },
- 'redo': {
- name: 'Redo',
- callback: function(){
- this.redo();
- },
- disabled: function () {
- return this.undoRedo && !this.undoRedo.isRedoAvailable();
- }
- }
-
- }
- };
-
- this.options = {};
- Handsontable.helper.extend(this.options, this.defaultOptions);
-
- this.updateOptions(customOptions);
-
- function createMenu(){
-
- var menu = $('body > .htContextMenu')[0];
-
- if(!menu){
- menu = document.createElement('DIV');
- Handsontable.Dom.addClass(menu, 'htContextMenu');
- document.getElementsByTagName('body')[0].appendChild(menu);
- }
-
- return menu;
- }
- }
-
- ContextMenu.prototype.bindMouseEvents = function (){
-
- function contextMenuOpenListener(event){
-
- event.preventDefault();
-
- if(event.target.nodeName != 'TD' && !(Handsontable.Dom.hasClass(event.target, 'current') && Handsontable.Dom.hasClass(event.target, 'wtBorder'))){
- return;
- }
-
- this.show(event.pageY, event.pageX);
-
- $(document).on('mousedown.htContextMenu', Handsontable.helper.proxy(ContextMenu.prototype.close, this));
- }
-
- this.instance.rootElement.on('contextmenu.htContextMenu', Handsontable.helper.proxy(contextMenuOpenListener, this));
-
- };
-
- ContextMenu.prototype.bindTableEvents = function () {
- var that = this;
-
- this._afterScrollCallback = function () {
- that.close();
- };
-
- this.instance.addHook('afterScrollVertically', this._afterScrollCallback);
- this.instance.addHook('afterScrollHorizontally', this._afterScrollCallback);
- };
-
- ContextMenu.prototype.unbindTableEvents = function () {
- var that = this;
-
- if(this._afterScrollCallback){
- this.instance.removeHook('afterScrollVertically', this._afterScrollCallback);
- this.instance.removeHook('afterScrollHorizontally', this._afterScrollCallback);
- this._afterScrollCallback = null;
- }
-
-
- };
-
- ContextMenu.prototype.performAction = function (){
-
- var hot = $(this.menu).handsontable('getInstance');
- var selectedItemIndex = hot.getSelected()[0];
- var selectedItem = hot.getData()[selectedItemIndex];
-
- if (selectedItem.disabled === true || (typeof selectedItem.disabled == 'function' && selectedItem.disabled.call(this.instance) === true)){
- return;
- }
-
- if(typeof selectedItem.callback != 'function'){
- return;
- }
-
- var corners = this.instance.getSelected();
- var normalizedSelection = ContextMenu.utils.normalizeSelection(corners);
-
- selectedItem.callback.call(this.instance, selectedItem.key, normalizedSelection);
-
- };
-
- ContextMenu.prototype.unbindMouseEvents = function () {
- this.instance.rootElement.off('contextmenu.htContextMenu');
- $(document).off('mousedown.htContextMenu');
- };
-
- ContextMenu.prototype.show = function(top, left){
-
- this.menu.style.display = 'block';
-
- $(this.menu)
- .off('mousedown.htContextMenu')
- .on('mousedown.htContextMenu', Handsontable.helper.proxy(this.performAction, this));
-
- $(this.menu).handsontable({
- data: ContextMenu.utils.convertItemsToArray(this.getItems()),
- colHeaders: false,
- colWidths: [200], // ANDI we need some more space
- readOnly: true,
- copyPaste: false,
- columns: [
- {
- data: 'name',
- renderer: Handsontable.helper.proxy(this.renderer, this)
- }
- ],
- beforeKeyDown: Handsontable.helper.proxy(this.onBeforeKeyDown, this)
- });
- this.bindTableEvents();
-
- this.setMenuPosition(top, left);
-
- $(this.menu).handsontable('listen');
-
- };
-
- ContextMenu.prototype.close = function () {
- this.hide();
- $(document).off('mousedown.htContextMenu');
- this.unbindTableEvents();
- this.instance.listen();
- };
-
- ContextMenu.prototype.hide = function(){
- this.menu.style.display = 'none';
- $(this.menu).handsontable('destroy');
- };
-
- ContextMenu.prototype.renderer = function(instance, TD, row, col, prop, value, cellProperties){
- var contextMenu = this;
- var item = instance.getData()[row];
- var wrapper = document.createElement('DIV');
-
- Handsontable.Dom.empty(TD);
- TD.appendChild(wrapper);
-
- Handsontable.Dom.addClass(wrapper, item.key); // ANDI add class to menu entries
-
- if(itemIsSeparator(item)){
- Handsontable.Dom.addClass(TD, 'htSeparator');
- } else {
- Handsontable.Dom.fastInnerText(wrapper, value);
- }
-
- if (itemIsDisabled(item, contextMenu.instance)){
- Handsontable.Dom.addClass(TD, 'htDisabled');
-
- $(wrapper).on('mouseenter', function () {
- instance.deselectCell();
- });
-
- } else {
- Handsontable.Dom.removeClass(TD, 'htDisabled');
-
- $(wrapper).on('mouseenter', function () {
- instance.selectCell(row, col);
- });
-
- }
-
- function itemIsSeparator(item){
- return new RegExp(ContextMenu.SEPARATOR, 'i').test(item.name);
- }
-
- function itemIsDisabled(item, instance){
- return item.disabled === true || (typeof item.disabled == 'function' && item.disabled.call(contextMenu.instance) === true);
- }
- };
-
- ContextMenu.prototype.onBeforeKeyDown = function (event) {
- var contextMenu = this;
- var instance = $(contextMenu.menu).handsontable('getInstance');
- var selection = instance.getSelected();
-
- switch(event.keyCode){
-
- case Handsontable.helper.keyCode.ESCAPE:
- contextMenu.close();
- event.preventDefault();
- event.stopImmediatePropagation();
- break;
-
- case Handsontable.helper.keyCode.ENTER:
- if(instance.getSelected()){
- contextMenu.performAction();
- contextMenu.close();
- }
- break;
-
- case Handsontable.helper.keyCode.ARROW_DOWN:
- if(!selection){
-
- selectFirstCell(instance);
-
- } else {
-
- selectNextCell(selection[0], selection[1], instance);
-
- }
-
- event.preventDefault();
- event.stopImmediatePropagation();
-
- break;
-
- case Handsontable.helper.keyCode.ARROW_UP:
- if(!selection){
-
- selectLastCell(instance);
-
- } else {
-
- selectPrevCell(selection[0], selection[1], instance);
-
- }
-
- event.preventDefault();
- event.stopImmediatePropagation();
-
- break;
-
- }
-
- function selectFirstCell(instance) {
-
- var firstCell = instance.getCell(0, 0);
-
- if(ContextMenu.utils.isSeparator(firstCell) || ContextMenu.utils.isDisabled(firstCell)){
- selectNextCell(0, 0, instance);
- } else {
- instance.selectCell(0, 0);
- }
-
- }
-
-
- function selectLastCell(instance) {
-
- var lastRow = instance.countRows() - 1;
- var lastCell = instance.getCell(lastRow, 0);
-
- if(ContextMenu.utils.isSeparator(lastCell) || ContextMenu.utils.isDisabled(lastCell)){
- selectPrevCell(lastRow, 0, instance);
- } else {
- instance.selectCell(lastRow, 0);
- }
-
- }
-
- function selectNextCell(row, col, instance){
- var nextRow = row + 1;
- var nextCell = nextRow < instance.countRows() ? instance.getCell(nextRow, col) : null;
-
- if(!nextCell){
- return;
- }
-
- if(ContextMenu.utils.isSeparator(nextCell) || ContextMenu.utils.isDisabled(nextCell)){
- selectNextCell(nextRow, col, instance);
- } else {
- instance.selectCell(nextRow, col);
- }
- }
-
- function selectPrevCell(row, col, instance) {
-
- var prevRow = row - 1;
- var prevCell = prevRow >= 0 ? instance.getCell(prevRow, col) : null;
-
- if (!prevCell) {
- return;
- }
-
- if(ContextMenu.utils.isSeparator(prevCell) || ContextMenu.utils.isDisabled(prevCell)){
- selectPrevCell(prevRow, col, instance);
- } else {
- instance.selectCell(prevRow, col);
- }
-
- }
-
- };
-
- ContextMenu.prototype.getItems = function () {
- var items = {};
- function Item(rawItem){
- if(typeof rawItem == 'string'){
- this.name = rawItem;
- } else {
- Handsontable.helper.extend(this, rawItem);
- }
- }
- Item.prototype = this.options;
-
- for(var itemName in this.options.items){
- if(this.options.items.hasOwnProperty(itemName) && (!this.itemsFilter || this.itemsFilter.indexOf(itemName) != -1)){
- items[itemName] = new Item(this.options.items[itemName]);
- }
- }
-
- return items;
-
- };
-
- ContextMenu.prototype.updateOptions = function(newOptions){
- newOptions = newOptions || {};
-
- if(newOptions.items){
- for(var itemName in newOptions.items){
- var item = {};
-
- if(newOptions.items.hasOwnProperty(itemName)) {
- if(this.defaultOptions.items.hasOwnProperty(itemName)
- && Handsontable.helper.isObject(newOptions.items[itemName])){
- Handsontable.helper.extend(item, this.defaultOptions.items[itemName]);
- Handsontable.helper.extend(item, newOptions.items[itemName]);
- newOptions.items[itemName] = item;
- }
- }
-
- }
- }
-
- Handsontable.helper.extend(this.options, newOptions);
- };
-
- ContextMenu.prototype.setMenuPosition = function (cursorY, cursorX) {
-
- var cursor = {
- top: cursorY,
- topRelative: cursorY - document.documentElement.scrollTop,
- left: cursorX,
- leftRelative:cursorX - document.documentElement.scrollLeft
- };
-
- if(this.menuFitsBelowCursor(cursor)){
- this.positionMenuBelowCursor(cursor);
- } else {
- this.positionMenuAboveCursor(cursor);
- }
-
- if(this.menuFitsOnRightOfCursor(cursor)){
- this.positionMenuOnRightOfCursor(cursor);
- } else {
- this.positionMenuOnLeftOfCursor(cursor);
- }
-
- };
-
- ContextMenu.prototype.menuFitsBelowCursor = function (cursor) {
- return cursor.topRelative + this.menu.offsetHeight <= document.documentElement.scrollTop + document.documentElement.clientHeight;
- };
-
- ContextMenu.prototype.menuFitsOnRightOfCursor = function (cursor) {
- return cursor.leftRelative + this.menu.offsetWidth <= document.documentElement.scrollLeft + document.documentElement.clientWidth;
- };
-
- ContextMenu.prototype.positionMenuBelowCursor = function (cursor) {
- this.menu.style.top = cursor.top + 'px';
- };
-
- ContextMenu.prototype.positionMenuAboveCursor = function (cursor) {
- this.menu.style.top = (cursor.top - this.menu.offsetHeight) + 'px';
- };
-
- ContextMenu.prototype.positionMenuOnRightOfCursor = function (cursor) {
- this.menu.style.left = cursor.left + 'px';
- };
-
- ContextMenu.prototype.positionMenuOnLeftOfCursor = function (cursor) {
- this.menu.style.left = (cursor.left - this.menu.offsetWidth) + 'px';
- };
-
- ContextMenu.utils = {};
- ContextMenu.utils.convertItemsToArray = function (items) {
- var itemArray = [];
- var item;
- for(var itemName in items){
- if(items.hasOwnProperty(itemName)){
- if(typeof items[itemName] == 'string'){
- item = {name: items[itemName]};
- } else if (items[itemName].visible !== false) {
- item = items[itemName];
- } else {
- continue;
- }
-
- item.key = itemName;
- itemArray.push(item);
- }
- }
-
- return itemArray;
- };
-
- ContextMenu.utils.normalizeSelection = function(corners){
- var selection = {
- start: new Handsontable.SelectionPoint(),
- end: new Handsontable.SelectionPoint()
- };
-
- selection.start.row(Math.min(corners[0], corners[2]));
- selection.start.col(Math.min(corners[1], corners[3]));
-
- selection.end.row(Math.max(corners[0], corners[2]));
- selection.end.col(Math.max(corners[1], corners[3]));
-
- return selection;
- };
-
- ContextMenu.utils.isSeparator = function (cell) {
- return Handsontable.Dom.hasClass(cell, 'htSeparator');
- };
-
- ContextMenu.utils.isDisabled = function (cell) {
- return Handsontable.Dom.hasClass(cell, 'htDisabled');
- };
-
- ContextMenu.prototype.enable = function () {
- if(!this.enabled){
- this.enabled = true;
- this.bindMouseEvents();
- }
- };
-
- ContextMenu.prototype.disable = function () {
- if(this.enabled){
- this.enabled = false;
- this.close();
- this.unbindMouseEvents();
- this.unbindTableEvents();
- }
- };
-
- ContextMenu.prototype.destroy = function () {
- this.close();
- this.unbindMouseEvents();
- this.unbindTableEvents();
-
- if(!this.isMenuEnabledByOtherHotInstance()){
- this.removeMenu();
- }
-
- };
-
- ContextMenu.prototype.isMenuEnabledByOtherHotInstance = function () {
- var hotContainers = $('.handsontable');
- var menuEnabled = false;
-
- for(var i = 0, len = hotContainers.length; i < len; i++){
- var instance = $(hotContainers[i]).handsontable('getInstance');
- if(instance && instance.getSettings().contextMenu){
- menuEnabled = true;
- break;
- }
- }
-
- return menuEnabled;
- };
-
- ContextMenu.prototype.removeMenu = function () {
- if(this.menu.parentNode){
- this.menu.parentNode.removeChild(this.menu);
- }
- };
-
- ContextMenu.prototype.filterItems = function(itemsToLeave){
- this.itemsFilter = itemsToLeave;
- };
-
- ContextMenu.SEPARATOR = "---------";
-
- function init(){
- var instance = this;
- var contextMenuSetting = instance.getSettings().contextMenu;
- var customOptions = Handsontable.helper.isObject(contextMenuSetting) ? contextMenuSetting : {};
-
- if(contextMenuSetting){
- if(!instance.contextMenu){
- instance.contextMenu = new ContextMenu(instance, customOptions);
- }
-
- instance.contextMenu.enable();
-
- if(Handsontable.helper.isArray(contextMenuSetting)){
- instance.contextMenu.filterItems(contextMenuSetting);
- }
-
- } else if(instance.contextMenu){
- instance.contextMenu.destroy();
- delete instance.contextMenu;
- }
-
-
-
- }
-
- Handsontable.PluginHooks.add('afterInit', init);
- Handsontable.PluginHooks.add('afterUpdateSettings', init);
-
- Handsontable.ContextMenu = ContextMenu;
-
-})(Handsontable);
-
-/**
- * This plugin adds support for legacy features, deprecated APIs, etc.
- */
-
-/**
- * Support for old autocomplete syntax
- * For old syntax, see: https://github.com/warpech/jquery-handsontable/blob/8c9e701d090ea4620fe08b6a1a048672fadf6c7e/README.md#defining-autocomplete
- */
-Handsontable.PluginHooks.add('beforeGetCellMeta', function (row, col, cellProperties) {
- //isWritable - deprecated since 0.8.0
- cellProperties.isWritable = !cellProperties.readOnly;
-
- //autocomplete - deprecated since 0.7.1 (see CHANGELOG.md)
- if (cellProperties.autoComplete) {
- throw new Error("Support for legacy autocomplete syntax was removed in Handsontable 0.10.0. Please remove the property named 'autoComplete' from your config. For replacement instructions, see wiki page https://github.com/warpech/jquery-handsontable/wiki/Migration-guide-to-0.10.x");
- }
-});
-function HandsontableManualColumnMove() {
- var pressed
- , startCol
- , endCol
- , startX
- , startOffset;
-
- var ghost = document.createElement('DIV')
- , ghostStyle = ghost.style;
-
- ghost.className = 'ghost';
- ghostStyle.position = 'absolute';
- ghostStyle.top = '25px';
- ghostStyle.left = 0;
- ghostStyle.width = '10px';
- ghostStyle.height = '10px';
- ghostStyle.backgroundColor = '#CCC';
- ghostStyle.opacity = 0.7;
-
- var saveManualColumnPositions = function () {
- var instance = this;
-
- instance.PluginHooks.run('persistentStateSave', 'manualColumnPositions', instance.manualColumnPositions);
- };
-
- var loadManualColumnPositions = function () {
- var instance = this;
- var storedState = {};
- instance.PluginHooks.run('persistentStateLoad', 'manualColumnPositions', storedState);
-
- return storedState.value;
- };
-
-
- var bindMoveColEvents = function () {
- var instance = this;
-
- instance.rootElement.on('mousemove.manualColumnMove', function (e) {
- if (pressed) {
- ghostStyle.left = startOffset + e.pageX - startX + 6 + 'px';
- if (ghostStyle.display === 'none') {
- ghostStyle.display = 'block';
- }
- }
- });
-
- instance.rootElement.on('mouseup.manualColumnMove', function () {
- if (pressed) {
- if (startCol < endCol) {
- endCol--;
- }
- if (instance.getSettings().rowHeaders) {
- startCol--;
- endCol--;
- }
- instance.manualColumnPositions.splice(endCol, 0, instance.manualColumnPositions.splice(startCol, 1)[0]);
- $('.manualColumnMover.active').removeClass('active');
- pressed = false;
- instance.forceFullRender = true;
- instance.view.render(); //updates all
- ghostStyle.display = 'none';
-
- saveManualColumnPositions.call(instance);
-
- instance.PluginHooks.run('afterColumnMove', startCol, endCol);
- }
- });
-
- instance.rootElement.on('mousedown.manualColumnMove', '.manualColumnMover', function (e) {
-
- var mover = e.currentTarget;
- var TH = instance.view.wt.wtDom.closest(mover, 'TH');
- startCol = instance.view.wt.wtDom.index(TH) + instance.colOffset();
- endCol = startCol;
- pressed = true;
- startX = e.pageX;
-
- var TABLE = instance.$table[0];
- TABLE.parentNode.appendChild(ghost);
- ghostStyle.width = instance.view.wt.wtDom.outerWidth(TH) + 'px';
- ghostStyle.height = instance.view.wt.wtDom.outerHeight(TABLE) + 'px';
- startOffset = parseInt(instance.view.wt.wtDom.offset(TH).left - instance.view.wt.wtDom.offset(TABLE).left, 10);
- ghostStyle.left = startOffset + 6 + 'px';
- });
-
- instance.rootElement.on('mouseenter.manualColumnMove', 'td, th', function () {
- if (pressed) {
- var active = instance.view.THEAD.querySelector('.manualColumnMover.active');
- if (active) {
- instance.view.wt.wtDom.removeClass(active, 'active');
- }
- endCol = instance.view.wt.wtDom.index(this) + instance.colOffset();
- var THs = instance.view.THEAD.querySelectorAll('th');
- var mover = THs[endCol].querySelector('.manualColumnMover');
- instance.view.wt.wtDom.addClass(mover, 'active');
- }
- });
-
- instance.addHook('afterDestroy', unbindMoveColEvents);
- };
-
- var unbindMoveColEvents = function(){
- var instance = this;
- instance.rootElement.off('mouseup.manualColumnMove');
- instance.rootElement.off('mousemove.manualColumnMove');
- instance.rootElement.off('mousedown.manualColumnMove');
- instance.rootElement.off('mouseenter.manualColumnMove');
- };
-
- this.beforeInit = function () {
- this.manualColumnPositions = [];
- };
-
- this.init = function (source) {
- var instance = this;
-
- var manualColMoveEnabled = !!(this.getSettings().manualColumnMove);
-
- if (manualColMoveEnabled) {
- var initialManualColumnPositions = this.getSettings().manualColumnMove;
-
- var loadedManualColumnPositions = loadManualColumnPositions.call(instance);
-
- if (typeof loadedManualColumnPositions != 'undefined') {
- this.manualColumnPositions = loadedManualColumnPositions;
- } else if (initialManualColumnPositions instanceof Array) {
- this.manualColumnPositions = initialManualColumnPositions;
- } else {
- this.manualColumnPositions = [];
- }
-
-
- instance.forceFullRender = true;
-
- if (source == 'afterInit') {
- bindMoveColEvents.call(this);
- if (this.manualColumnPositions.length > 0) {
- this.forceFullRender = true;
- this.render();
- }
-
- }
-
- } else {
- unbindMoveColEvents.call(this);
- this.manualColumnPositions = [];
- }
- };
-
- this.modifyCol = function (col) {
- //TODO test performance: http://jsperf.com/object-wrapper-vs-primitive/2
- if (this.getSettings().manualColumnMove) {
- if (typeof this.manualColumnPositions[col] === 'undefined') {
- this.manualColumnPositions[col] = col;
- }
- return this.manualColumnPositions[col];
- }
- return col;
- };
-
- this.getColHeader = function (col, TH) {
- if (this.getSettings().manualColumnMove) {
- var DIV = document.createElement('DIV');
- DIV.className = 'manualColumnMover';
- TH.firstChild.appendChild(DIV);
- }
- };
-}
-var htManualColumnMove = new HandsontableManualColumnMove();
-
-Handsontable.PluginHooks.add('beforeInit', htManualColumnMove.beforeInit);
-Handsontable.PluginHooks.add('afterInit', function () {
- htManualColumnMove.init.call(this, 'afterInit')
-});
-
-Handsontable.PluginHooks.add('afterUpdateSettings', function () {
- htManualColumnMove.init.call(this, 'afterUpdateSettings')
-});
-Handsontable.PluginHooks.add('afterGetColHeader', htManualColumnMove.getColHeader);
-Handsontable.PluginHooks.add('modifyCol', htManualColumnMove.modifyCol);
-
-function HandsontableManualColumnResize() {
- var pressed
- , currentTH
- , currentCol
- , currentWidth
- , instance
- , newSize
- , startX
- , startWidth
- , startOffset
- , resizer = document.createElement('DIV')
- , handle = document.createElement('DIV')
- , line = document.createElement('DIV')
- , lineStyle = line.style;
-
- resizer.className = 'manualColumnResizer';
-
- handle.className = 'manualColumnResizerHandle';
- resizer.appendChild(handle);
-
- line.className = 'manualColumnResizerLine';
- resizer.appendChild(line);
-
- var $document = $(document);
-
- $document.mousemove(function (e) {
- if (pressed) {
- currentWidth = startWidth + (e.pageX - startX);
- newSize = setManualSize(currentCol, currentWidth); //save col width
- resizer.style.left = startOffset + currentWidth + 'px';
- }
- });
-
- $document.mouseup(function () {
- if (pressed) {
- instance.view.wt.wtDom.removeClass(resizer, 'active');
- pressed = false;
-
- if(newSize != startWidth){
- instance.forceFullRender = true;
- instance.view.render(); //updates all
-
- saveManualColumnWidths.call(instance);
-
- instance.PluginHooks.run('afterColumnResize', currentCol, newSize);
- }
-
- refreshResizerPosition.call(instance, currentTH);
- }
- });
-
- var saveManualColumnWidths = function () {
- var instance = this;
-
- instance.PluginHooks.run('persistentStateSave', 'manualColumnWidths', instance.manualColumnWidths);
- };
-
- var loadManualColumnWidths = function () {
- var instance = this;
- var storedState = {};
- instance.PluginHooks.run('persistentStateLoad', 'manualColumnWidths', storedState);
-
- return storedState.value;
- };
-
- function refreshResizerPosition(TH) {
- instance = this;
- currentTH = TH;
-
- var col = this.view.wt.wtTable.getCoords(TH)[1]; //getCoords returns array [row, col]
- if (col >= 0) { //if not row header
- currentCol = col;
- var rootOffset = this.view.wt.wtDom.offset(this.rootElement[0]).left;
- var thOffset = this.view.wt.wtDom.offset(TH).left;
- startOffset = (thOffset - rootOffset) - 6;
- resizer.style.left = startOffset + parseInt(this.view.wt.wtDom.outerWidth(TH), 10) + 'px';
-
- this.rootElement[0].appendChild(resizer);
- }
- }
-
- function refreshLinePosition() {
- var instance = this;
- startWidth = parseInt(this.view.wt.wtDom.outerWidth(currentTH), 10);
- instance.view.wt.wtDom.addClass(resizer, 'active');
- lineStyle.height = instance.view.wt.wtDom.outerHeight(instance.$table[0]) + 'px';
- pressed = instance;
- }
-
- var bindManualColumnWidthEvents = function () {
- var instance = this;
- var dblclick = 0;
- var autoresizeTimeout = null;
-
- this.rootElement.on('mouseenter.handsontable', 'th', function (e) {
- if (!pressed) {
- refreshResizerPosition.call(instance, e.currentTarget);
- }
- });
-
- this.rootElement.on('mousedown.handsontable', '.manualColumnResizer', function () {
- if (autoresizeTimeout == null) {
- autoresizeTimeout = setTimeout(function () {
- if (dblclick >= 2) {
- newSize = instance.determineColumnWidth.call(instance, currentCol);
- setManualSize(currentCol, newSize);
- instance.forceFullRender = true;
- instance.view.render(); //updates all
- instance.PluginHooks.run('afterColumnResize', currentCol, newSize);
- }
- dblclick = 0;
- autoresizeTimeout = null;
- }, 500);
- }
- dblclick++;
- });
-
- this.rootElement.on('mousedown.handsontable', '.manualColumnResizer', function (e) {
- startX = e.pageX;
- refreshLinePosition.call(instance);
- newSize = startWidth;
- });
- };
-
- this.beforeInit = function () {
- this.manualColumnWidths = [];
- };
-
- this.init = function (source) {
- var instance = this;
- var manualColumnWidthEnabled = !!(this.getSettings().manualColumnResize);
-
- if (manualColumnWidthEnabled) {
- var initialColumnWidths = this.getSettings().manualColumnResize;
-
- var loadedManualColumnWidths = loadManualColumnWidths.call(instance);
-
- if (typeof loadedManualColumnWidths != 'undefined') {
- this.manualColumnWidths = loadedManualColumnWidths;
- } else if (initialColumnWidths instanceof Array) {
- this.manualColumnWidths = initialColumnWidths;
- } else {
- this.manualColumnWidths = [];
- }
-
- if (source == 'afterInit') {
- bindManualColumnWidthEvents.call(this);
- instance.forceFullRender = true;
- instance.render();
- }
- }
- };
-
-
- var setManualSize = function (col, width) {
- width = Math.max(width, 20);
-
- /**
- * We need to run col through modifyCol hook, in case the order of displayed columns is different than the order
- * in data source. For instance, this order can be modified by manualColumnMove plugin.
- */
- col = instance.PluginHooks.execute('modifyCol', col);
-
- instance.manualColumnWidths[col] = width;
- return width;
- };
-
- this.getColWidth = function (col, response) {
- if (this.getSettings().manualColumnResize && this.manualColumnWidths[col]) {
- response.width = this.manualColumnWidths[col];
- }
- };
-}
-var htManualColumnResize = new HandsontableManualColumnResize();
-
-Handsontable.PluginHooks.add('beforeInit', htManualColumnResize.beforeInit);
-Handsontable.PluginHooks.add('afterInit', function () {
- htManualColumnResize.init.call(this, 'afterInit')
-});
-Handsontable.PluginHooks.add('afterUpdateSettings', function () {
- htManualColumnResize.init.call(this, 'afterUpdateSettings')
-});
-Handsontable.PluginHooks.add('afterGetColWidth', htManualColumnResize.getColWidth);
-
-(function HandsontableObserveChanges() {
-
- Handsontable.PluginHooks.add('afterLoadData', init);
- Handsontable.PluginHooks.add('afterUpdateSettings', init);
-
- function init() {
- var instance = this;
- var pluginEnabled = instance.getSettings().observeChanges;
-
- if (pluginEnabled) {
- if(instance.observer) {
- destroy.call(instance); //destroy observer for old data object
- }
- createObserver.call(instance);
- bindEvents.call(instance);
-
- } else if (!pluginEnabled){
- destroy.call(instance);
- }
- }
-
- function createObserver(){
- var instance = this;
-
- instance.observeChangesActive = true;
-
- instance.pauseObservingChanges = function(){
- instance.observeChangesActive = false;
- };
-
- instance.resumeObservingChanges = function(){
- instance.observeChangesActive = true;
- };
-
- instance.observedData = instance.getData();
- instance.observer = jsonpatch.observe(instance.observedData, function (patches) {
- if(instance.observeChangesActive){
- runHookForOperation.call(instance, patches);
- instance.render();
- }
-
- instance.runHooks('afterChangesObserved');
- });
- }
-
- function runHookForOperation(rawPatches){
- var instance = this;
- var patches = cleanPatches(rawPatches);
-
- for(var i = 0, len = patches.length; i < len; i++){
- var patch = patches[i];
- var parsedPath = parsePath(patch.path);
-
-
- switch(patch.op){
- case 'add':
- if(isNaN(parsedPath.col)){
- instance.runHooks('afterCreateRow', parsedPath.row);
- } else {
- instance.runHooks('afterCreateCol', parsedPath.col);
- }
- break;
-
- case 'remove':
- if(isNaN(parsedPath.col)){
- instance.runHooks('afterRemoveRow', parsedPath.row, 1);
- } else {
- instance.runHooks('afterRemoveCol', parsedPath.col, 1);
- }
- break;
-
- case 'replace':
- instance.runHooks('afterChange', [parsedPath.row, parsedPath.col, null, patch.value], 'external');
- break;
- }
- }
-
- function cleanPatches(rawPatches){
- var patches;
-
- patches = removeLengthRelatedPatches(rawPatches);
- patches = removeMultipleAddOrRemoveColPatches(patches);
-
- return patches;
- }
-
- /**
- * Removing or adding column will produce one patch for each table row.
- * This function leaves only one patch for each column add/remove operation
- */
- function removeMultipleAddOrRemoveColPatches(rawPatches){
- var newOrRemovedColumns = [];
-
- return rawPatches.filter(function(patch){
- var parsedPath = parsePath(patch.path);
-
- if(['add', 'remove'].indexOf(patch.op) != -1 && !isNaN(parsedPath.col)){
- if(newOrRemovedColumns.indexOf(parsedPath.col) != -1){
- return false;
- } else {
- newOrRemovedColumns.push(parsedPath.col);
- }
- }
-
- return true;
- });
-
- }
-
- /**
- * If observeChanges uses native Object.observe method, then it produces patches for length property.
- * This function removes them.
- */
- function removeLengthRelatedPatches(rawPatches){
- return rawPatches.filter(function(patch){
- return !/[/]length/ig.test(patch.path);
- })
- }
-
- function parsePath(path){
- var match = path.match(/^\/(\d+)\/?(.*)?$/);
- return {
- row: parseInt(match[1], 10),
- col: /^\d*$/.test(match[2]) ? parseInt(match[2], 10) : match[2]
- }
- }
- }
-
- function destroy(){
- var instance = this;
-
- if (instance.observer){
- destroyObserver.call(instance);
- unbindEvents.call(instance);
- }
- }
-
- function destroyObserver(){
- var instance = this;
-
- jsonpatch.unobserve(instance.observedData, instance.observer);
- delete instance.observeChangesActive;
- delete instance.pauseObservingChanges;
- delete instance.resumeObservingChanges;
- }
-
- function bindEvents(){
- var instance = this;
- instance.addHook('afterDestroy', destroy);
-
- instance.addHook('afterCreateRow', afterTableAlter);
- instance.addHook('afterRemoveRow', afterTableAlter);
-
- instance.addHook('afterCreateCol', afterTableAlter);
- instance.addHook('afterRemoveCol', afterTableAlter);
-
- instance.addHook('afterChange', function(changes, source){
- if(source != 'loadData'){
- afterTableAlter.call(this);
- }
- });
- }
-
- function unbindEvents(){
- var instance = this;
- instance.removeHook('afterDestroy', destroy);
-
- instance.removeHook('afterCreateRow', afterTableAlter);
- instance.removeHook('afterRemoveRow', afterTableAlter);
-
- instance.removeHook('afterCreateCol', afterTableAlter);
- instance.removeHook('afterRemoveCol', afterTableAlter);
-
- instance.removeHook('afterChange', afterTableAlter);
- }
-
- function afterTableAlter(){
- var instance = this;
-
- instance.pauseObservingChanges();
-
- instance.addHookOnce('afterChangesObserved', function(){
- instance.resumeObservingChanges();
- });
-
- }
-})();
-
-
-/*
- *
- * Plugin enables saving table state
- *
- * */
-
-
-function Storage(prefix) {
-
- var savedKeys;
-
- var saveSavedKeys = function () {
- window.localStorage[prefix + '__' + 'persistentStateKeys'] = JSON.stringify(savedKeys);
- };
-
- var loadSavedKeys = function () {
- var keysJSON = window.localStorage[prefix + '__' + 'persistentStateKeys'];
- var keys = typeof keysJSON == 'string' ? JSON.parse(keysJSON) : void 0;
- savedKeys = keys ? keys : [];
- };
-
- var clearSavedKeys = function () {
- savedKeys = [];
- saveSavedKeys();
- };
-
- loadSavedKeys();
-
- this.saveValue = function (key, value) {
- window.localStorage[prefix + '_' + key] = JSON.stringify(value);
- if (savedKeys.indexOf(key) == -1) {
- savedKeys.push(key);
- saveSavedKeys();
- }
-
- };
-
- this.loadValue = function (key, defaultValue) {
-
- key = typeof key != 'undefined' ? key : defaultValue;
-
- var value = window.localStorage[prefix + '_' + key];
-
- return typeof value == "undefined" ? void 0 : JSON.parse(value);
-
- };
-
- this.reset = function (key) {
- window.localStorage.removeItem(prefix + '_' + key);
- };
-
- this.resetAll = function () {
- for (var index = 0; index < savedKeys.length; index++) {
- window.localStorage.removeItem(prefix + '_' + savedKeys[index]);
- }
-
- clearSavedKeys();
- };
-
-}
-
-
-(function (StorageClass) {
- function HandsontablePersistentState() {
- var plugin = this;
-
-
- this.init = function () {
- var instance = this,
- pluginSettings = instance.getSettings()['persistentState'];
-
- plugin.enabled = !!(pluginSettings);
-
- if (!plugin.enabled) {
- removeHooks.call(instance);
- return;
- }
-
- if (!instance.storage) {
- instance.storage = new StorageClass(instance.rootElement[0].id);
- }
-
- instance.resetState = plugin.resetValue;
-
- addHooks.call(instance);
-
- };
-
- this.saveValue = function (key, value) {
- var instance = this;
-
- instance.storage.saveValue(key, value);
- };
-
- this.loadValue = function (key, saveTo) {
- var instance = this;
-
- saveTo.value = instance.storage.loadValue(key);
- };
-
- this.resetValue = function (key) {
- var instance = this;
-
- if (typeof key != 'undefined') {
- instance.storage.reset(key);
- } else {
- instance.storage.resetAll();
- }
-
- };
-
- var hooks = {
- 'persistentStateSave': plugin.saveValue,
- 'persistentStateLoad': plugin.loadValue,
- 'persistentStateReset': plugin.resetValue
- };
-
- function addHooks() {
- var instance = this;
-
- for (var hookName in hooks) {
- if (hooks.hasOwnProperty(hookName) && !hookExists.call(instance, hookName)) {
- instance.PluginHooks.add(hookName, hooks[hookName]);
- }
- }
- }
-
- function removeHooks() {
- var instance = this;
-
- for (var hookName in hooks) {
- if (hooks.hasOwnProperty(hookName) && hookExists.call(instance, hookName)) {
- instance.PluginHooks.remove(hookName, hooks[hookName]);
- }
- }
- }
-
- function hookExists(hookName) {
- var instance = this;
- return instance.PluginHooks.hooks.hasOwnProperty(hookName);
- }
- }
-
- var htPersistentState = new HandsontablePersistentState();
- Handsontable.PluginHooks.add('beforeInit', htPersistentState.init);
- Handsontable.PluginHooks.add('afterUpdateSettings', htPersistentState.init);
-})(Storage);
-
-/**
- * Handsontable UndoRedo class
- */
-(function(Handsontable){
- Handsontable.UndoRedo = function (instance) {
- var plugin = this;
- this.instance = instance;
- this.doneActions = [];
- this.undoneActions = [];
- this.ignoreNewActions = false;
- instance.addHook("afterChange", function (changes, origin) {
- if(changes){
- var action = new Handsontable.UndoRedo.ChangeAction(changes);
- plugin.done(action);
- }
- });
-
- instance.addHook("afterCreateRow", function (index, amount) {
- var action = new Handsontable.UndoRedo.CreateRowAction(index, amount);
- plugin.done(action);
- });
-
- instance.addHook("beforeRemoveRow", function (index, amount) {
- var originalData = plugin.instance.getData();
- index = ( originalData.length + index ) % originalData.length;
- var removedData = originalData.slice(index, index + amount);
- var action = new Handsontable.UndoRedo.RemoveRowAction(index, removedData);
- plugin.done(action);
- });
-
- instance.addHook("afterCreateCol", function (index, amount) {
- var action = new Handsontable.UndoRedo.CreateColumnAction(index, amount);
- plugin.done(action);
- });
-
- instance.addHook("beforeRemoveCol", function (index, amount) {
- var originalData = plugin.instance.getData();
- index = ( plugin.instance.countCols() + index ) % plugin.instance.countCols();
- var removedData = [];
-
- for (var i = 0, len = originalData.length; i < len; i++) {
- removedData[i] = originalData[i].slice(index, index + amount);
- }
-
- var headers;
- if(Handsontable.helper.isArray(instance.getSettings().colHeaders)){
- headers = instance.getSettings().colHeaders.slice(index, index + removedData.length);
- }
-
- var action = new Handsontable.UndoRedo.RemoveColumnAction(index, removedData, headers);
- plugin.done(action);
- });
- };
-
- Handsontable.UndoRedo.prototype.done = function (action) {
- if (!this.ignoreNewActions) {
- this.doneActions.push(action);
- this.undoneActions.length = 0;
- }
- };
-
- /**
- * Undo operation from current revision
- */
- Handsontable.UndoRedo.prototype.undo = function () {
- if (this.isUndoAvailable()) {
- var action = this.doneActions.pop();
-
- this.ignoreNewActions = true;
- action.undo(this.instance);
- this.ignoreNewActions = false;
-
- this.undoneActions.push(action);
- }
- };
-
- /**
- * Redo operation from current revision
- */
- Handsontable.UndoRedo.prototype.redo = function () {
- if (this.isRedoAvailable()) {
- var action = this.undoneActions.pop();
-
- this.ignoreNewActions = true;
- action.redo(this.instance);
- this.ignoreNewActions = true;
-
- this.doneActions.push(action);
- }
- };
-
- /**
- * Returns true if undo point is available
- * @return {Boolean}
- */
- Handsontable.UndoRedo.prototype.isUndoAvailable = function () {
- return this.doneActions.length > 0;
- };
-
- /**
- * Returns true if redo point is available
- * @return {Boolean}
- */
- Handsontable.UndoRedo.prototype.isRedoAvailable = function () {
- return this.undoneActions.length > 0;
- };
-
- /**
- * Clears undo history
- */
- Handsontable.UndoRedo.prototype.clear = function () {
- this.doneActions.length = 0;
- this.undoneActions.length = 0;
- };
-
- Handsontable.UndoRedo.Action = function () {
- };
- Handsontable.UndoRedo.Action.prototype.undo = function () {
- };
- Handsontable.UndoRedo.Action.prototype.redo = function () {
- };
-
- Handsontable.UndoRedo.ChangeAction = function (changes) {
- this.changes = changes;
- };
- Handsontable.helper.inherit(Handsontable.UndoRedo.ChangeAction, Handsontable.UndoRedo.Action);
- Handsontable.UndoRedo.ChangeAction.prototype.undo = function (instance) {
- var data = $.extend(true, [], this.changes);
- for (var i = 0, len = data.length; i < len; i++) {
- data[i].splice(3, 1);
- }
- instance.setDataAtRowProp(data, null, null, 'undo');
-
- };
- Handsontable.UndoRedo.ChangeAction.prototype.redo = function (instance) {
- var data = $.extend(true, [], this.changes);
- for (var i = 0, len = data.length; i < len; i++) {
- data[i].splice(2, 1);
- }
- instance.setDataAtRowProp(data, null, null, 'redo');
-
- };
-
- Handsontable.UndoRedo.CreateRowAction = function (index, amount) {
- this.index = index;
- this.amount = amount;
- };
- Handsontable.helper.inherit(Handsontable.UndoRedo.CreateRowAction, Handsontable.UndoRedo.Action);
- Handsontable.UndoRedo.CreateRowAction.prototype.undo = function (instance) {
- instance.alter('remove_row', this.index, this.amount);
- };
- Handsontable.UndoRedo.CreateRowAction.prototype.redo = function (instance) {
- instance.alter('insert_row', this.index + 1, this.amount);
- };
-
- Handsontable.UndoRedo.RemoveRowAction = function (index, data) {
- this.index = index;
- this.data = data;
- };
- Handsontable.helper.inherit(Handsontable.UndoRedo.RemoveRowAction, Handsontable.UndoRedo.Action);
- Handsontable.UndoRedo.RemoveRowAction.prototype.undo = function (instance) {
- var spliceArgs = [this.index, 0];
- Array.prototype.push.apply(spliceArgs, this.data);
-
- Array.prototype.splice.apply(instance.getData(), spliceArgs);
-
- instance.render();
- };
- Handsontable.UndoRedo.RemoveRowAction.prototype.redo = function (instance) {
- instance.alter('remove_row', this.index, this.data.length);
- };
-
- Handsontable.UndoRedo.CreateColumnAction = function (index, amount) {
- this.index = index;
- this.amount = amount;
- };
- Handsontable.helper.inherit(Handsontable.UndoRedo.CreateColumnAction, Handsontable.UndoRedo.Action);
- Handsontable.UndoRedo.CreateColumnAction.prototype.undo = function (instance) {
- instance.alter('remove_col', this.index, this.amount);
- };
- Handsontable.UndoRedo.CreateColumnAction.prototype.redo = function (instance) {
- instance.alter('insert_col', this.index + 1, this.amount);
- };
-
- Handsontable.UndoRedo.RemoveColumnAction = function (index, data, headers) {
- this.index = index;
- this.data = data;
- this.amount = this.data[0].length;
- this.headers = headers;
- };
- Handsontable.helper.inherit(Handsontable.UndoRedo.RemoveColumnAction, Handsontable.UndoRedo.Action);
- Handsontable.UndoRedo.RemoveColumnAction.prototype.undo = function (instance) {
- var row, spliceArgs;
- for (var i = 0, len = instance.getData().length; i < len; i++) {
- row = instance.getDataAtRow(i);
-
- spliceArgs = [this.index, 0];
- Array.prototype.push.apply(spliceArgs, this.data[i]);
-
- Array.prototype.splice.apply(row, spliceArgs);
-
- }
-
- if(typeof this.headers != 'undefined'){
- spliceArgs = [this.index, 0];
- Array.prototype.push.apply(spliceArgs, this.headers);
- Array.prototype.splice.apply(instance.getSettings().colHeaders, spliceArgs);
- }
-
- instance.render();
- };
- Handsontable.UndoRedo.RemoveColumnAction.prototype.redo = function (instance) {
- instance.alter('remove_col', this.index, this.amount);
- };
-})(Handsontable);
-
-(function(Handsontable){
-
- function init(){
- var instance = this;
- var pluginEnabled = typeof instance.getSettings().undo == 'undefined' || instance.getSettings().undo;
-
- if(pluginEnabled){
- if(!instance.undoRedo){
- instance.undoRedo = new Handsontable.UndoRedo(instance);
-
- exposeUndoRedoMethods(instance);
-
- instance.addHook('beforeKeyDown', onBeforeKeyDown);
- instance.addHook('afterChange', onAfterChange);
- }
- } else {
- if(instance.undoRedo){
- delete instance.undoRedo;
-
- removeExposedUndoRedoMethods(instance);
-
- instance.removeHook('beforeKeyDown', onBeforeKeyDown);
- instance.removeHook('afterChange', onAfterChange);
- }
- }
- }
-
- function onBeforeKeyDown(event){
- var instance = this;
-
- var ctrlDown = (event.ctrlKey || event.metaKey) && !event.altKey;
-
- if(ctrlDown){
- if (event.keyCode === 89 || (event.shiftKey && event.keyCode === 90)) { //CTRL + Y or CTRL + SHIFT + Z
- instance.undoRedo.redo();
- event.stopImmediatePropagation();
- }
- else if (event.keyCode === 90) { //CTRL + Z
- instance.undoRedo.undo();
- event.stopImmediatePropagation();
- }
- }
- }
-
- function onAfterChange(changes, source){
- var instance = this;
- if (source == 'loadData'){
- return instance.undoRedo.clear();
- }
- }
-
- function exposeUndoRedoMethods(instance){
- instance.undo = function(){
- return instance.undoRedo.undo();
- };
-
- instance.redo = function(){
- return instance.undoRedo.redo();
- };
-
- instance.isUndoAvailable = function(){
- return instance.undoRedo.isUndoAvailable();
- };
-
- instance.isRedoAvailable = function(){
- return instance.undoRedo.isRedoAvailable();
- };
-
- instance.clearUndo = function(){
- return instance.undoRedo.clear();
- };
- }
-
- function removeExposedUndoRedoMethods(instance){
- delete instance.undo;
- delete instance.redo;
- delete instance.isUndoAvailable;
- delete instance.isRedoAvailable;
- delete instance.clearUndo;
- }
-
- Handsontable.PluginHooks.add('afterInit', init);
- Handsontable.PluginHooks.add('afterUpdateSettings', init);
-
-})(Handsontable);
-/**
- * Plugin used to scroll Handsontable by selecting a cell and dragging outside of visible viewport
- * @constructor
- */
-function DragToScroll() {
- this.boundaries = null;
- this.callback = null;
-}
-
-/**
- * @param boundaries {Object} compatible with getBoundingClientRect
- */
-DragToScroll.prototype.setBoundaries = function (boundaries) {
- this.boundaries = boundaries;
-};
-
-/**
- * @param callback {Function}
- */
-DragToScroll.prototype.setCallback = function (callback) {
- this.callback = callback;
-};
-
-/**
- * Check if mouse position (x, y) is outside of the viewport
- * @param x
- * @param y
- */
-DragToScroll.prototype.check = function (x, y) {
- var diffX = 0;
- var diffY = 0;
-
- if (y < this.boundaries.top) {
- //y is less than top
- diffY = y - this.boundaries.top;
- }
- else if (y > this.boundaries.bottom) {
- //y is more than bottom
- diffY = y - this.boundaries.bottom;
- }
-
- if (x < this.boundaries.left) {
- //x is less than left
- diffX = x - this.boundaries.left;
- }
- else if (x > this.boundaries.right) {
- //x is more than right
- diffX = x - this.boundaries.right;
- }
-
- this.callback(diffX, diffY);
-};
-
-var listening = false;
-var dragToScroll;
-var instance;
-
-if (typeof Handsontable !== 'undefined') {
- var setupListening = function (instance) {
- var scrollHandler = instance.view.wt.wtScrollbars.vertical.scrollHandler; //native scroll
- dragToScroll = new DragToScroll();
- if (scrollHandler === window) {
- //not much we can do currently
- return;
- }
- else if (scrollHandler) {
- dragToScroll.setBoundaries(scrollHandler.getBoundingClientRect());
- }
- else {
- dragToScroll.setBoundaries(instance.$table[0].getBoundingClientRect());
- }
-
- dragToScroll.setCallback(function (scrollX, scrollY) {
- if (scrollX < 0) {
- if (scrollHandler) {
- scrollHandler.scrollLeft -= 50;
- }
- else {
- instance.view.wt.scrollHorizontal(-1).draw();
- }
- }
- else if (scrollX > 0) {
- if (scrollHandler) {
- scrollHandler.scrollLeft += 50;
- }
- else {
- instance.view.wt.scrollHorizontal(1).draw();
- }
- }
-
- if (scrollY < 0) {
- if (scrollHandler) {
- scrollHandler.scrollTop -= 20;
- }
- else {
- instance.view.wt.scrollVertical(-1).draw();
- }
- }
- else if (scrollY > 0) {
- if (scrollHandler) {
- scrollHandler.scrollTop += 20;
- }
- else {
- instance.view.wt.scrollVertical(1).draw();
- }
- }
- });
-
- listening = true;
- };
-
- Handsontable.PluginHooks.add('afterInit', function () {
- $(document).on('mouseup.' + this.guid, function () {
- listening = false;
- });
-
- $(document).on('mousemove.' + this.guid, function (event) {
- if (listening) {
- dragToScroll.check(event.clientX, event.clientY);
- }
- });
- });
-
- Handsontable.PluginHooks.add('destroy', function () {
- $(document).off('.' + this.guid);
- });
-
- Handsontable.PluginHooks.add('afterOnCellMouseDown', function () {
- setupListening(this);
- });
-
- Handsontable.PluginHooks.add('afterOnCellCornerMouseDown', function () {
- setupListening(this);
- });
-}
-
-(function (Handsontable, CopyPaste, SheetClip) {
-
- function CopyPastePlugin(instance) {
- this.copyPasteInstance = CopyPaste.getInstance();
-
- this.copyPasteInstance.onCut(onCut);
- this.copyPasteInstance.onPaste(onPaste);
- var plugin = this;
-
- instance.addHook('beforeKeyDown', onBeforeKeyDown);
-
- function onCut() {
- if (!instance.isListening()) {
- return;
- }
-
- instance.selection.empty();
- }
-
- function onPaste(str) {
- if (!instance.isListening() || !instance.selection.isSelected()) {
- return;
- }
-
- var input = str.replace(/^[\r\n]*/g, '').replace(/[\r\n]*$/g, '') //remove newline from the start and the end of the input
- , inputArray = SheetClip.parse(input)
- , selected = instance.getSelected()
- , coords = instance.getCornerCoords([{row: selected[0], col: selected[1]}, {row: selected[2], col: selected[3]}])
- , areaStart = coords.TL
- , areaEnd = {
- row: Math.max(coords.BR.row, inputArray.length - 1 + coords.TL.row),
- col: Math.max(coords.BR.col, inputArray[0].length - 1 + coords.TL.col)
- };
-
- instance.PluginHooks.once('afterChange', function (changes, source) {
- if (changes && changes.length) {
- this.selectCell(areaStart.row, areaStart.col, areaEnd.row, areaEnd.col);
- }
- });
-
- instance.populateFromArray(areaStart.row, areaStart.col, inputArray, areaEnd.row, areaEnd.col, 'paste', instance.getSettings().pasteMode);
- };
-
- function onBeforeKeyDown (event) {
- if (Handsontable.helper.isCtrlKey(event.keyCode) && instance.getSelected()) {
- //when CTRL is pressed, prepare selectable text in textarea
- //http://stackoverflow.com/questions/3902635/how-does-one-capture-a-macs-command-key-via-javascript
- plugin.setCopyableText();
- event.stopImmediatePropagation();
- return;
- }
-
- var ctrlDown = (event.ctrlKey || event.metaKey) && !event.altKey; //catch CTRL but not right ALT (which in some systems triggers ALT+CTRL)
-
- if (event.keyCode == Handsontable.helper.keyCode.A && ctrlDown) {
- setTimeout(Handsontable.helper.proxy(plugin.setCopyableText, plugin));
- }
-
- }
-
- this.destroy = function () {
- this.copyPasteInstance.removeCallback(onCut);
- this.copyPasteInstance.removeCallback(onPaste);
- this.copyPasteInstance.destroy();
- instance.removeHook('beforeKeyDown', onBeforeKeyDown);
- };
-
- instance.addHook('afterDestroy', Handsontable.helper.proxy(this.destroy, this));
-
- this.triggerPaste = Handsontable.helper.proxy(this.copyPasteInstance.triggerPaste, this.copyPasteInstance);
- this.triggerCut = Handsontable.helper.proxy(this.copyPasteInstance.triggerCut, this.copyPasteInstance);
-
- /**
- * Prepares copyable text in the invisible textarea
- */
- this.setCopyableText = function () {
-
- var selection = instance.getSelected();
- var settings = instance.getSettings();
- var copyRowsLimit = settings.copyRowsLimit;
- var copyColsLimit = settings.copyColsLimit;
-
- var startRow = Math.min(selection[0], selection[2]);
- var startCol = Math.min(selection[1], selection[3]);
- var endRow = Math.max(selection[0], selection[2]);
- var endCol = Math.max(selection[1], selection[3]);
- var finalEndRow = Math.min(endRow, startRow + copyRowsLimit - 1);
- var finalEndCol = Math.min(endCol, startCol + copyColsLimit - 1);
-
- instance.copyPaste.copyPasteInstance.copyable(instance.getCopyableData(startRow, startCol, finalEndRow, finalEndCol));
-
- if (endRow !== finalEndRow || endCol !== finalEndCol) {
- instance.PluginHooks.run("afterCopyLimit", endRow - startRow + 1, endCol - startCol + 1, copyRowsLimit, copyColsLimit);
- }
- };
-
- }
-
-
-
- function init() {
- var instance = this;
- var pluginEnabled = instance.getSettings().copyPaste !== false;
-
- if(pluginEnabled && !instance.copyPaste){
-
- instance.copyPaste = new CopyPastePlugin(instance);
-
- } else if (!pluginEnabled && instance.copyPaste) {
-
- instance.copyPaste.destroy();
- delete instance.copyPaste;
-
- }
-
- }
-
- Handsontable.PluginHooks.add('afterInit', init);
- Handsontable.PluginHooks.add('afterUpdateSettings', init);
-
-})(Handsontable, CopyPaste, SheetClip);
-/**
- * Creates an overlay over the original Walkontable instance. The overlay renders the clone of the original Walkontable
- * and (optionally) implements behavior needed for native horizontal and vertical scrolling
- */
-function WalkontableOverlay() {
- this.maxOuts = 10; //max outs in one direction (before and after table)
-}
-
-/*
- Possible optimizations:
- [x] don't rerender if scroll delta is smaller than the fragment outside of the viewport
- [ ] move .style.top change before .draw()
- [ ] put .draw() in requestAnimationFrame
- [ ] don't rerender rows that remain visible after the scroll
- */
-
-WalkontableOverlay.prototype.init = function () {
- this.TABLE = this.instance.wtTable.TABLE;
- this.fixed = this.instance.wtTable.hider;
- this.fixedContainer = this.instance.wtTable.holder;
- this.fixed.style.position = 'absolute';
- this.fixed.style.left = '0';
- this.scrollHandler = this.getScrollableElement(this.TABLE);
- this.$scrollHandler = $(this.scrollHandler); //in future remove jQuery from here
-};
-
-WalkontableOverlay.prototype.makeClone = function (direction) {
- var clone = document.createElement('DIV');
- clone.className = 'ht_clone_' + direction + ' handsontable';
- clone.style.position = 'fixed';
- clone.style.overflow = 'hidden';
-
- var table2 = document.createElement('TABLE');
- table2.className = this.instance.wtTable.TABLE.className;
- clone.appendChild(table2);
-
- this.instance.wtTable.holder.parentNode.appendChild(clone);
-
- return new Walkontable({
- cloneSource: this.instance,
- cloneOverlay: this,
- table: table2
- });
-};
-
-WalkontableOverlay.prototype.getScrollableElement = function (TABLE) {
- var el = TABLE.parentNode;
- while (el && el.style) {
- if (el.style.overflow !== 'visible' && el.style.overflow !== '') {
- return el;
- }
- if (this instanceof WalkontableHorizontalScrollbarNative && el.style.overflowX !== 'visible' && el.style.overflowX !== '') {
- return el;
- }
- el = el.parentNode;
- }
- return window;
-};
-
-WalkontableOverlay.prototype.prepare = function () {
-};
-
-WalkontableOverlay.prototype.onScroll = function (forcePosition) {
-
- this.windowScrollPosition = this.getScrollPosition();
- this.readSettings(); //read window scroll position
-
- if (forcePosition) {
- this.windowScrollPosition = forcePosition;
- }
-
- this.resetFixedPosition(); //may be redundant
-};
-
-WalkontableOverlay.prototype.availableSize = function () {
- var availableSize;
-
- if (this.windowScrollPosition > this.tableParentOffset /*&& last > -1*/) { //last -1 means that viewport is scrolled behind the table
- if (this.instance.wtTable.getLastVisibleRow() === this.total - 1) {
- availableSize = this.instance.wtDom.outerHeight(this.TABLE);
- }
- else {
- availableSize = this.windowSize;
- }
- }
- else {
- availableSize = this.windowSize - (this.tableParentOffset);
- }
-
- return availableSize;
-};
-
-WalkontableOverlay.prototype.refresh = function (selectionsOnly) {
- var last = this.getLastCell();
- this.measureBefore = this.sumCellSizes(0, this.offset);
- if (last === -1) { //last -1 means that viewport is scrolled behind the table
- this.measureAfter = 0;
- }
- else {
- this.measureAfter = this.sumCellSizes(last, this.total - last);
- }
- this.applyToDOM();
- this.clone && this.clone.draw(selectionsOnly);
-};
-
-WalkontableOverlay.prototype.destroy = function () {
- this.$scrollHandler.off('.' + this.instance.guid);
- $(window).off('.' + this.instance.guid);
- $(document).off('.' + this.instance.guid);
-};
-function WalkontableBorder(instance, settings) {
- var style;
-
- //reference to instance
- this.instance = instance;
- this.settings = settings;
- this.wtDom = this.instance.wtDom;
-
- this.main = document.createElement("div");
- style = this.main.style;
- style.position = 'absolute';
- style.top = 0;
- style.left = 0;
-// style.visibility = 'hidden';
-
- for (var i = 0; i < 5; i++) {
- var DIV = document.createElement('DIV');
- DIV.className = 'wtBorder ' + (settings.className || '');
- style = DIV.style;
- style.backgroundColor = settings.border.color;
- style.height = settings.border.width + 'px';
- style.width = settings.border.width + 'px';
- this.main.appendChild(DIV);
- }
-
- this.top = this.main.childNodes[0];
- this.left = this.main.childNodes[1];
- this.bottom = this.main.childNodes[2];
- this.right = this.main.childNodes[3];
-
-
- /*$(this.top).on(sss, function(event) {
- event.preventDefault();
- event.stopImmediatePropagation();
- $(this).hide();
- });
- $(this.left).on(sss, function(event) {
- event.preventDefault();
- event.stopImmediatePropagation();
- $(this).hide();
- });
- $(this.bottom).on(sss, function(event) {
- event.preventDefault();
- event.stopImmediatePropagation();
- $(this).hide();
- });
- $(this.right).on(sss, function(event) {
- event.preventDefault();
- event.stopImmediatePropagation();
- $(this).hide();
- });*/
-
- this.topStyle = this.top.style;
- this.leftStyle = this.left.style;
- this.bottomStyle = this.bottom.style;
- this.rightStyle = this.right.style;
-
- this.corner = this.main.childNodes[4];
- this.corner.className += ' corner';
- this.cornerStyle = this.corner.style;
- this.cornerStyle.width = '5px';
- this.cornerStyle.height = '5px';
- this.cornerStyle.border = '2px solid #FFF';
-
- this.disappear();
- if (!instance.wtTable.bordersHolder) {
- instance.wtTable.bordersHolder = document.createElement('div');
- instance.wtTable.bordersHolder.className = 'htBorders';
- instance.wtTable.hider.appendChild(instance.wtTable.bordersHolder);
-
- }
- instance.wtTable.bordersHolder.appendChild(this.main);
-
- var down = false;
- var $body = $(document.body);
-
- $body.on('mousedown.walkontable.' + instance.guid, function () {
- down = true;
- });
-
- $body.on('mouseup.walkontable.' + instance.guid, function () {
- down = false
- });
-
- $(this.main.childNodes).on('mouseenter', function (event) {
- if (!down || !instance.getSetting('hideBorderOnMouseDownOver')) {
- return;
- }
- event.preventDefault();
- event.stopImmediatePropagation();
-
- var bounds = this.getBoundingClientRect();
-
- var $this = $(this);
- $this.hide();
-
- var isOutside = function (event) {
- if (event.clientY < Math.floor(bounds.top)) {
- return true;
- }
- if (event.clientY > Math.ceil(bounds.top + bounds.height)) {
- return true;
- }
- if (event.clientX < Math.floor(bounds.left)) {
- return true;
- }
- if (event.clientX > Math.ceil(bounds.left + bounds.width)) {
- return true;
- }
- };
-
- $body.on('mousemove.border.' + instance.guid, function (event) {
- if (isOutside(event)) {
- $body.off('mousemove.border.' + instance.guid);
- $this.show();
- }
- });
- });
-}
-
-/**
- * Show border around one or many cells
- * @param {Array} corners
- */
-WalkontableBorder.prototype.appear = function (corners) {
- var isMultiple, fromTD, toTD, fromOffset, toOffset, containerOffset, top, minTop, left, minLeft, height, width;
- if (this.disabled) {
- return;
- }
-
- var instance = this.instance
- , fromRow
- , fromColumn
- , toRow
- , toColumn
- , hideTop = false
- , hideLeft = false
- , hideBottom = false
- , hideRight = false
- , i
- , ilen
- , s;
-
- if (!instance.wtTable.isRowInViewport(corners[0])) {
- hideTop = true;
- }
-
- if (!instance.wtTable.isRowInViewport(corners[2])) {
- hideBottom = true;
- }
-
- ilen = instance.wtTable.rowStrategy.countVisible();
-
- for (i = 0; i < ilen; i++) {
- s = instance.wtTable.rowFilter.visibleToSource(i);
- if (s >= corners[0] && s <= corners[2]) {
- fromRow = s;
- break;
- }
- }
-
- for (i = ilen - 1; i >= 0; i--) {
- s = instance.wtTable.rowFilter.visibleToSource(i);
- if (s >= corners[0] && s <= corners[2]) {
- toRow = s;
- break;
- }
- }
-
- if (hideTop && hideBottom) {
- hideLeft = true;
- hideRight = true;
- }
- else {
- if (!instance.wtTable.isColumnInViewport(corners[1])) {
- hideLeft = true;
- }
-
- if (!instance.wtTable.isColumnInViewport(corners[3])) {
- hideRight = true;
- }
-
- ilen = instance.wtTable.columnStrategy.countVisible();
-
- for (i = 0; i < ilen; i++) {
- s = instance.wtTable.columnFilter.visibleToSource(i);
- if (s >= corners[1] && s <= corners[3]) {
- fromColumn = s;
- break;
- }
- }
-
- for (i = ilen - 1; i >= 0; i--) {
- s = instance.wtTable.columnFilter.visibleToSource(i);
- if (s >= corners[1] && s <= corners[3]) {
- toColumn = s;
- break;
- }
- }
- }
-
- if (fromRow !== void 0 && fromColumn !== void 0) {
- isMultiple = (fromRow !== toRow || fromColumn !== toColumn);
- fromTD = instance.wtTable.getCell([fromRow, fromColumn]);
- toTD = isMultiple ? instance.wtTable.getCell([toRow, toColumn]) : fromTD;
- fromOffset = this.wtDom.offset(fromTD);
- toOffset = isMultiple ? this.wtDom.offset(toTD) : fromOffset;
- containerOffset = this.wtDom.offset(instance.wtTable.TABLE);
-
- minTop = fromOffset.top;
- height = toOffset.top + this.wtDom.outerHeight(toTD) - minTop;
- minLeft = fromOffset.left;
- width = toOffset.left + this.wtDom.outerWidth(toTD) - minLeft;
-
- top = minTop - containerOffset.top - 1;
- left = minLeft - containerOffset.left - 1;
-
- var style = this.wtDom.getComputedStyle(fromTD);
- if (parseInt(style['borderTopWidth'], 10) > 0) {
- top += 1;
- height = height > 0 ? height - 1 : 0;
- }
- if (parseInt(style['borderLeftWidth'], 10) > 0) {
- left += 1;
- width = width > 0 ? width - 1 : 0;
- }
- }
- else {
- this.disappear();
- return;
- }
-
- if (hideTop) {
- this.topStyle.display = 'none';
- }
- else {
- this.topStyle.top = top + 'px';
- this.topStyle.left = left + 'px';
- this.topStyle.width = width + 'px';
- this.topStyle.display = 'block';
- }
-
- if (hideLeft) {
- this.leftStyle.display = 'none';
- }
- else {
- this.leftStyle.top = top + 'px';
- this.leftStyle.left = left + 'px';
- this.leftStyle.height = height + 'px';
- this.leftStyle.display = 'block';
- }
-
- var delta = Math.floor(this.settings.border.width / 2);
-
- if (hideBottom) {
- this.bottomStyle.display = 'none';
- }
- else {
- this.bottomStyle.top = top + height - delta + 'px';
- this.bottomStyle.left = left + 'px';
- this.bottomStyle.width = width + 'px';
- this.bottomStyle.display = 'block';
- }
-
- if (hideRight) {
- this.rightStyle.display = 'none';
- }
- else {
- this.rightStyle.top = top + 'px';
- this.rightStyle.left = left + width - delta + 'px';
- this.rightStyle.height = height + 1 + 'px';
- this.rightStyle.display = 'block';
- }
-
- if (hideBottom || hideRight || !this.hasSetting(this.settings.border.cornerVisible)) {
- this.cornerStyle.display = 'none';
- }
- else {
- this.cornerStyle.top = top + height - 4 + 'px';
- this.cornerStyle.left = left + width - 4 + 'px';
- this.cornerStyle.display = 'block';
- }
-};
-
-/**
- * Hide border
- */
-WalkontableBorder.prototype.disappear = function () {
- this.topStyle.display = 'none';
- this.leftStyle.display = 'none';
- this.bottomStyle.display = 'none';
- this.rightStyle.display = 'none';
- this.cornerStyle.display = 'none';
-};
-
-WalkontableBorder.prototype.hasSetting = function (setting) {
- if (typeof setting === 'function') {
- return setting();
- }
- return !!setting;
-};
-/**
- * WalkontableCellFilter
- * @constructor
- */
-function WalkontableCellFilter() {
- this.offset = 0;
- this.total = 0;
- this.fixedCount = 0;
-}
-
-WalkontableCellFilter.prototype.source = function (n) {
- return n;
-};
-
-WalkontableCellFilter.prototype.offsetted = function (n) {
- return n + this.offset;
-};
-
-WalkontableCellFilter.prototype.unOffsetted = function (n) {
- return n - this.offset;
-};
-
-WalkontableCellFilter.prototype.fixed = function (n) {
- if (n < this.fixedCount) {
- return n - this.offset;
- }
- else {
- return n;
- }
-};
-
-WalkontableCellFilter.prototype.unFixed = function (n) {
- if (n < this.fixedCount) {
- return n + this.offset;
- }
- else {
- return n;
- }
-};
-
-WalkontableCellFilter.prototype.visibleToSource = function (n) {
- return this.source(this.offsetted(this.fixed(n)));
-};
-
-WalkontableCellFilter.prototype.sourceToVisible = function (n) {
- return this.source(this.unOffsetted(this.unFixed(n)));
-};
-/**
- * WalkontableCellStrategy
- * @constructor
- */
-function WalkontableCellStrategy(instance) {
- this.instance = instance;
-}
-
-WalkontableCellStrategy.prototype.getSize = function (index) {
- return this.cellSizes[index];
-};
-
-WalkontableCellStrategy.prototype.getContainerSize = function (proposedSize) {
- return typeof this.containerSizeFn === 'function' ? this.containerSizeFn(proposedSize) : this.containerSizeFn;
-};
-
-WalkontableCellStrategy.prototype.countVisible = function () {
- return this.cellCount;
-};
-
-WalkontableCellStrategy.prototype.isLastIncomplete = function () {
-
- if(this.instance.getSetting('nativeScrollbars')){
-
- var nativeScrollbar = this.instance.cloneFrom ? this.instance.cloneFrom.wtScrollbars.vertical : this.instance.wtScrollbars.vertical;
- return this.remainingSize > nativeScrollbar.sumCellSizes(nativeScrollbar.offset, nativeScrollbar.offset + nativeScrollbar.curOuts + 1);
-
- } else {
- return this.remainingSize > 0;
- }
-
-};
-/**
- * WalkontableClassNameList
- * @constructor
- */
-function WalkontableClassNameCache() {
- this.cache = [];
-}
-
-WalkontableClassNameCache.prototype.add = function (r, c, cls) {
- if (!this.cache[r]) {
- this.cache[r] = [];
- }
- if (!this.cache[r][c]) {
- this.cache[r][c] = [];
- }
- this.cache[r][c][cls] = true;
-};
-
-WalkontableClassNameCache.prototype.test = function (r, c, cls) {
- return (this.cache[r] && this.cache[r][c] && this.cache[r][c][cls]);
-};
-/**
- * WalkontableColumnFilter
- * @constructor
- */
-function WalkontableColumnFilter() {
- this.countTH = 0;
-}
-
-WalkontableColumnFilter.prototype = new WalkontableCellFilter();
-
-WalkontableColumnFilter.prototype.readSettings = function (instance) {
- this.offset = instance.wtSettings.settings.offsetColumn;
- this.total = instance.getSetting('totalColumns');
- this.fixedCount = instance.getSetting('fixedColumnsLeft');
- this.countTH = instance.getSetting('rowHeaders').length;
-};
-
-WalkontableColumnFilter.prototype.offsettedTH = function (n) {
- return n - this.countTH;
-};
-
-WalkontableColumnFilter.prototype.unOffsettedTH = function (n) {
- return n + this.countTH;
-};
-
-WalkontableColumnFilter.prototype.visibleRowHeadedColumnToSourceColumn = function (n) {
- return this.visibleToSource(this.offsettedTH(n));
-};
-
-WalkontableColumnFilter.prototype.sourceColumnToVisibleRowHeadedColumn = function (n) {
- return this.unOffsettedTH(this.sourceToVisible(n));
-};
-/**
- * WalkontableColumnStrategy
- * @param containerSizeFn
- * @param sizeAtIndex
- * @param strategy - all, last, none
- * @constructor
- */
-function WalkontableColumnStrategy(instance, containerSizeFn, sizeAtIndex, strategy) {
- var size
- , i = 0;
-
- WalkontableCellStrategy.apply(this, arguments);
-
- this.containerSizeFn = containerSizeFn;
- this.cellSizesSum = 0;
- this.cellSizes = [];
- this.cellStretch = [];
- this.cellCount = 0;
- this.remainingSize = 0;
- this.strategy = strategy;
-
- //step 1 - determine cells that fit containerSize and cache their widths
- while (true) {
- size = sizeAtIndex(i);
- if (size === void 0) {
- break; //total columns exceeded
- }
- if (this.cellSizesSum >= this.getContainerSize(this.cellSizesSum + size)) {
- break; //total width exceeded
- }
- this.cellSizes.push(size);
- this.cellSizesSum += size;
- this.cellCount++;
-
- i++;
- }
-
- var containerSize = this.getContainerSize(this.cellSizesSum);
- this.remainingSize = this.cellSizesSum - containerSize;
- //negative value means the last cell is fully visible and there is some space left for stretching
- //positive value means the last cell is not fully visible
-}
-
-WalkontableColumnStrategy.prototype = new WalkontableCellStrategy();
-
-WalkontableColumnStrategy.prototype.getSize = function (index) {
- return this.cellSizes[index] + (this.cellStretch[index] || 0);
-};
-
-WalkontableColumnStrategy.prototype.stretch = function () {
- //step 2 - apply stretching strategy
- var containerSize = this.getContainerSize(this.cellSizesSum)
- , i = 0;
- this.remainingSize = this.cellSizesSum - containerSize;
-
- this.cellStretch.length = 0; //clear previous stretch
-
- if (this.strategy === 'all') {
- if (this.remainingSize < 0) {
- var ratio = containerSize / this.cellSizesSum;
- var newSize;
-
- while (i < this.cellCount - 1) { //"i < this.cellCount - 1" is needed because last cellSize is adjusted after the loop
- newSize = Math.floor(ratio * this.cellSizes[i]);
- this.remainingSize += newSize - this.cellSizes[i];
- this.cellStretch[i] = newSize - this.cellSizes[i];
- i++;
- }
- this.cellStretch[this.cellCount - 1] = -this.remainingSize;
- this.remainingSize = 0;
- }
- }
- else if (this.strategy === 'last') {
- if (this.remainingSize < 0 && containerSize !== Infinity) { //Infinity is with native scroll when the table is wider than the viewport (TODO: test)
- this.cellStretch[this.cellCount - 1] = -this.remainingSize;
- this.remainingSize = 0;
- }
- }
-};
-function Walkontable(settings) {
- var that = this,
- originalHeaders = [];
-
- this.guid = 'wt_' + walkontableRandomString(); //this is the namespace for global events
-
- //bootstrap from settings
- this.wtDom = new WalkontableDom();
- if (settings.cloneSource) {
- this.cloneSource = settings.cloneSource;
- this.cloneOverlay = settings.cloneOverlay;
- this.wtSettings = settings.cloneSource.wtSettings;
- this.wtTable = new WalkontableTable(this, settings.table);
- this.wtScroll = new WalkontableScroll(this);
- this.wtViewport = settings.cloneSource.wtViewport;
- }
- else {
- this.wtSettings = new WalkontableSettings(this, settings);
- this.wtTable = new WalkontableTable(this, settings.table);
- this.wtScroll = new WalkontableScroll(this);
- this.wtViewport = new WalkontableViewport(this);
- this.wtScrollbars = new WalkontableScrollbars(this);
- this.wtWheel = new WalkontableWheel(this);
- this.wtEvent = new WalkontableEvent(this);
- }
-
- //find original headers
- if (this.wtTable.THEAD.childNodes.length && this.wtTable.THEAD.childNodes[0].childNodes.length) {
- for (var c = 0, clen = this.wtTable.THEAD.childNodes[0].childNodes.length; c < clen; c++) {
- originalHeaders.push(this.wtTable.THEAD.childNodes[0].childNodes[c].innerHTML);
- }
- if (!this.getSetting('columnHeaders').length) {
- this.update('columnHeaders', [function (column, TH) {
- that.wtDom.fastInnerText(TH, originalHeaders[column]);
- }]);
- }
- }
-
- //initialize selections
- this.selections = {};
- var selectionsSettings = this.getSetting('selections');
- if (selectionsSettings) {
- for (var i in selectionsSettings) {
- if (selectionsSettings.hasOwnProperty(i)) {
- this.selections[i] = new WalkontableSelection(this, selectionsSettings[i]);
- }
- }
- }
-
- this.drawn = false;
- this.drawInterrupted = false;
-
- //at this point the cached row heights may be invalid, but it is better not to reset the cache, which could cause scrollbar jumping when there are multiline cells outside of the rendered part of the table
- /*if (window.Handsontable) {
- Handsontable.PluginHooks.add('beforeChange', function () {
- if (that.rowHeightCache) {
- that.rowHeightCache.length = 0;
- }
- });
-
- }*/
-}
-
-Walkontable.prototype.draw = function (selectionsOnly) {
- this.drawInterrupted = false;
- if (!selectionsOnly && !this.wtDom.isVisible(this.wtTable.TABLE)) {
- this.drawInterrupted = true; //draw interrupted because TABLE is not visible
- return;
- }
-
- this.getSetting('beforeDraw', !selectionsOnly);
- selectionsOnly = selectionsOnly && this.getSetting('offsetRow') === this.lastOffsetRow && this.getSetting('offsetColumn') === this.lastOffsetColumn;
- if (this.drawn) { //fix offsets that might have changed
- this.scrollVertical(0);
- this.scrollHorizontal(0);
- }
- this.lastOffsetRow = this.getSetting('offsetRow');
- this.lastOffsetColumn = this.getSetting('offsetColumn');
- this.wtTable.draw(selectionsOnly);
- if (!this.cloneSource) {
- this.getSetting('onDraw', !selectionsOnly);
- }
- return this;
-};
-
-Walkontable.prototype.update = function (settings, value) {
- return this.wtSettings.update(settings, value);
-};
-
-Walkontable.prototype.scrollVertical = function (delta) {
- var result = this.wtScroll.scrollVertical(delta);
-
- this.getSetting('onScrollVertically');
-
- return result;
-};
-
-Walkontable.prototype.scrollHorizontal = function (delta) {
- var result = this.wtScroll.scrollHorizontal(delta);
-
- this.getSetting('onScrollHorizontally');
-
- return result;
-};
-
-Walkontable.prototype.scrollViewport = function (coords) {
- this.wtScroll.scrollViewport(coords);
- return this;
-};
-
-Walkontable.prototype.getViewport = function () {
- return [
- this.wtTable.rowFilter.visibleToSource(0),
- this.wtTable.columnFilter.visibleToSource(0),
- this.wtTable.getLastVisibleRow(),
- this.wtTable.getLastVisibleColumn()
- ];
-};
-
-Walkontable.prototype.getSetting = function (key, param1, param2, param3) {
- return this.wtSettings.getSetting(key, param1, param2, param3);
-};
-
-Walkontable.prototype.hasSetting = function (key) {
- return this.wtSettings.has(key);
-};
-
-Walkontable.prototype.destroy = function () {
- $(document.body).off('.' + this.guid);
- this.wtScrollbars.destroy();
- clearTimeout(this.wheelTimeout);
- this.wtEvent && this.wtEvent.destroy();
-};
-/**
- * A overlay that renders ALL available rows & columns positioned on top of the original Walkontable instance and all other overlays.
- * Used for debugging purposes to see if the other overlays (that render only part of the rows & columns) are positioned correctly
- * @param instance
- * @constructor
- */
-function WalkontableDebugOverlay(instance) {
- this.instance = instance;
- this.init();
- this.clone = this.makeClone('debug');
- this.clone.wtTable.holder.style.opacity = 0.4;
- this.clone.wtTable.holder.style.textShadow = '0 0 2px #ff0000';
-
- var that = this;
- var lastTimeout;
- var lastX = 0;
- var lastY = 0;
- var overlayContainer = that.clone.wtTable.holder.parentNode;
-
- $(document.body).on('mousemove.' + this.instance.guid, function (event) {
- if (!that.instance.wtTable.holder.parentNode) {
- return; //removed from DOM
- }
- if ((event.clientX - lastX > -5 && event.clientX - lastX < 5) && (event.clientY - lastY > -5 && event.clientY - lastY < 5)) {
- return; //ignore minor mouse movement
- }
- lastX = event.clientX;
- lastY = event.clientY;
- WalkontableDom.prototype.addClass(overlayContainer, 'wtDebugHidden');
- WalkontableDom.prototype.removeClass(overlayContainer, 'wtDebugVisible');
- clearTimeout(lastTimeout);
- lastTimeout = setTimeout(function () {
- WalkontableDom.prototype.removeClass(overlayContainer, 'wtDebugHidden');
- WalkontableDom.prototype.addClass(overlayContainer, 'wtDebugVisible');
- }, 1000);
- });
-}
-
-WalkontableDebugOverlay.prototype = new WalkontableOverlay();
-
-WalkontableDebugOverlay.prototype.resetFixedPosition = function () {
- if (!this.instance.wtTable.holder.parentNode) {
- return; //removed from DOM
- }
- var elem = this.clone.wtTable.holder.parentNode;
- var box = this.instance.wtTable.holder.getBoundingClientRect();
- elem.style.top = Math.ceil(box.top, 10) + 'px';
- elem.style.left = Math.ceil(box.left, 10) + 'px';
-};
-
-WalkontableDebugOverlay.prototype.prepare = function () {
-};
-
-WalkontableDebugOverlay.prototype.refresh = function (selectionsOnly) {
- this.clone && this.clone.draw(selectionsOnly);
-};
-
-WalkontableDebugOverlay.prototype.getScrollPosition = function () {
-};
-
-WalkontableDebugOverlay.prototype.getLastCell = function () {
-};
-
-WalkontableDebugOverlay.prototype.applyToDOM = function () {
-};
-
-WalkontableDebugOverlay.prototype.scrollTo = function () {
-};
-
-WalkontableDebugOverlay.prototype.readWindowSize = function () {
-};
-
-WalkontableDebugOverlay.prototype.readSettings = function () {
-};
-function WalkontableDom() {
-}
-
-//goes up the DOM tree (including given element) until it finds an element that matches the nodeName
-WalkontableDom.prototype.closest = function (elem, nodeNames, until) {
- while (elem != null && elem !== until) {
- if (elem.nodeType === 1 && nodeNames.indexOf(elem.nodeName) > -1) {
- return elem;
- }
- elem = elem.parentNode;
- }
- return null;
-};
-
-//goes up the DOM tree and checks if element is child of another element
-WalkontableDom.prototype.isChildOf = function (child, parent) {
- var node = child.parentNode;
- while (node != null) {
- if (node == parent) {
- return true;
- }
- node = node.parentNode;
- }
- return false;
-};
-
-/**
- * Counts index of element within its parent
- * WARNING: for performance reasons, assumes there are only element nodes (no text nodes). This is true for Walkotnable
- * Otherwise would need to check for nodeType or use previousElementSibling
- * @see http://jsperf.com/sibling-index/10
- * @param {Element} elem
- * @return {Number}
- */
-WalkontableDom.prototype.index = function (elem) {
- var i = 0;
- while (elem = elem.previousSibling) {
- ++i
- }
- return i;
-};
-
-if (document.documentElement.classList) {
- // HTML5 classList API
- WalkontableDom.prototype.hasClass = function (ele, cls) {
- return ele.classList.contains(cls);
- };
-
- WalkontableDom.prototype.addClass = function (ele, cls) {
- ele.classList.add(cls);
- };
-
- WalkontableDom.prototype.removeClass = function (ele, cls) {
- ele.classList.remove(cls);
- };
-}
-else {
- //http://snipplr.com/view/3561/addclass-removeclass-hasclass/
- WalkontableDom.prototype.hasClass = function (ele, cls) {
- return ele.className.match(new RegExp('(\\s|^)' + cls + '(\\s|$)'));
- };
-
- WalkontableDom.prototype.addClass = function (ele, cls) {
- if (!this.hasClass(ele, cls)) ele.className += " " + cls;
- };
-
- WalkontableDom.prototype.removeClass = function (ele, cls) {
- if (this.hasClass(ele, cls)) { //is this really needed?
- var reg = new RegExp('(\\s|^)' + cls + '(\\s|$)');
- ele.className = ele.className.replace(reg, ' ').trim(); //String.prototype.trim is defined in polyfill.js
- }
- };
-}
-
-/*//http://net.tutsplus.com/tutorials/javascript-ajax/javascript-from-null-cross-browser-event-binding/
- WalkontableDom.prototype.addEvent = (function () {
- var that = this;
- if (document.addEventListener) {
- return function (elem, type, cb) {
- if ((elem && !elem.length) || elem === window) {
- elem.addEventListener(type, cb, false);
- }
- else if (elem && elem.length) {
- var len = elem.length;
- for (var i = 0; i < len; i++) {
- that.addEvent(elem[i], type, cb);
- }
- }
- };
- }
- else {
- return function (elem, type, cb) {
- if ((elem && !elem.length) || elem === window) {
- elem.attachEvent('on' + type, function () {
-
- //normalize
- //http://stackoverflow.com/questions/4643249/cross-browser-event-object-normalization
- var e = window['event'];
- e.target = e.srcElement;
- //e.offsetX = e.layerX;
- //e.offsetY = e.layerY;
- e.relatedTarget = e.relatedTarget || e.type == 'mouseover' ? e.fromElement : e.toElement;
- if (e.target.nodeType === 3) e.target = e.target.parentNode; //Safari bug
-
- return cb.call(elem, e)
- });
- }
- else if (elem.length) {
- var len = elem.length;
- for (var i = 0; i < len; i++) {
- that.addEvent(elem[i], type, cb);
- }
- }
- };
- }
- })();
-
- WalkontableDom.prototype.triggerEvent = function (element, eventName, target) {
- var event;
- if (document.createEvent) {
- event = document.createEvent("MouseEvents");
- event.initEvent(eventName, true, true);
- } else {
- event = document.createEventObject();
- event.eventType = eventName;
- }
-
- event.eventName = eventName;
- event.target = target;
-
- if (document.createEvent) {
- target.dispatchEvent(event);
- } else {
- target.fireEvent("on" + event.eventType, event);
- }
- };*/
-
-WalkontableDom.prototype.removeTextNodes = function (elem, parent) {
- if (elem.nodeType === 3) {
- parent.removeChild(elem); //bye text nodes!
- }
- else if (['TABLE', 'THEAD', 'TBODY', 'TFOOT', 'TR'].indexOf(elem.nodeName) > -1) {
- var childs = elem.childNodes;
- for (var i = childs.length - 1; i >= 0; i--) {
- this.removeTextNodes(childs[i], elem);
- }
- }
-};
-
-/**
- * Remove childs function
- * WARNING - this doesn't unload events and data attached by jQuery
- * http://jsperf.com/jquery-html-vs-empty-vs-innerhtml/9
- * http://jsperf.com/jquery-html-vs-empty-vs-innerhtml/11 - no siginificant improvement with Chrome remove() method
- * @param element
- * @returns {void}
- */
-//
-WalkontableDom.prototype.empty = function (element) {
- var child;
- while (child = element.lastChild) {
- element.removeChild(child);
- }
-};
-
-WalkontableDom.prototype.HTML_CHARACTERS = /(<(.*)>|&(.*);)/;
-
-/**
- * Insert content into element trying avoid innerHTML method.
- * @return {void}
- */
-WalkontableDom.prototype.fastInnerHTML = function (element, content) {
- if (this.HTML_CHARACTERS.test(content)) {
- element.innerHTML = content;
- }
- else {
- this.fastInnerText(element, content);
- }
-};
-
-/**
- * Insert text content into element
- * @return {void}
- */
-if (document.createTextNode('test').textContent) { //STANDARDS
- WalkontableDom.prototype.fastInnerText = function (element, content) {
- var child = element.firstChild;
- if (child && child.nodeType === 3 && child.nextSibling === null) {
- //fast lane - replace existing text node
- //http://jsperf.com/replace-text-vs-reuse
- child.textContent = content;
- }
- else {
- //slow lane - empty element and insert a text node
- this.empty(element);
- element.appendChild(document.createTextNode(content));
- }
- };
-}
-else { //IE8
- WalkontableDom.prototype.fastInnerText = function (element, content) {
- var child = element.firstChild;
- if (child && child.nodeType === 3 && child.nextSibling === null) {
- //fast lane - replace existing text node
- //http://jsperf.com/replace-text-vs-reuse
- child.data = content;
- }
- else {
- //slow lane - empty element and insert a text node
- this.empty(element);
- element.appendChild(document.createTextNode(content));
- }
- };
-}
-
-/**
- * Returns true/false depending if element has offset parent
- * @param elem
- * @returns {boolean}
- */
-/*if (document.createTextNode('test').textContent) { //STANDARDS
- WalkontableDom.prototype.hasOffsetParent = function (elem) {
- return !!elem.offsetParent;
- }
-}
-else {
- WalkontableDom.prototype.hasOffsetParent = function (elem) {
- try {
- if (!elem.offsetParent) {
- return false;
- }
- }
- catch (e) {
- return false; //IE8 throws "Unspecified error" when offsetParent is not found - we catch it here
- }
- return true;
- }
-}*/
-
-/**
- * Returns true if element is attached to the DOM and visible, false otherwise
- * @param elem
- * @returns {boolean}
- */
-WalkontableDom.prototype.isVisible = function (elem) {
- //fast method according to benchmarks, but requires layout so slow in our case
- /*
- if (!WalkontableDom.prototype.hasOffsetParent(elem)) {
- return false; //fixes problem with UI Bootstrap directive
- }
-
-// if (elem.offsetWidth > 0 || (elem.parentNode && elem.parentNode.offsetWidth > 0)) { //IE10 was mistaken here
- if (elem.offsetWidth > 0) {
- return true;
- }
- */
-
- //slow method
- var next = elem;
- while (next !== document.documentElement) { //until reached
- if (next === null) { //parent detached from DOM
- return false;
- }
- else if (next.nodeType === 11) { //nodeType == 1 -> DOCUMENT_FRAGMENT_NODE
- if (next.host) { //this is Web Components Shadow DOM
- //see: http://w3c.github.io/webcomponents/spec/shadow/#encapsulation
- //according to spec, should be if (next.ownerDocument !== window.document), but that doesn't work yet
- if (next.host.impl) { //Chrome 33.0.1723.0 canary (2013-11-29) Web Platform features disabled
- return WalkontableDom.prototype.isVisible(next.host.impl);
- }
- else if (next.host) { //Chrome 33.0.1723.0 canary (2013-11-29) Web Platform features enabled
- return WalkontableDom.prototype.isVisible(next.host);
- }
- else {
- throw new Error("Lost in Web Components world");
- }
- }
- else {
- return false; //this is a node detached from document in IE8
- }
- }
- else if (next.style.display === 'none') {
- return false;
- }
- next = next.parentNode;
- }
- return true;
-};
-
-/**
- * Returns elements top and left offset relative to the document. In our usage case compatible with jQuery but 2x faster
- * @param {HTMLElement} elem
- * @return {Object}
- */
-WalkontableDom.prototype.offset = function (elem) {
- if (this.hasCaptionProblem() && elem.firstChild && elem.firstChild.nodeName === 'CAPTION') {
- //fixes problem with Firefox ignoring in TABLE offset (see also WalkontableDom.prototype.outerHeight)
- //http://jsperf.com/offset-vs-getboundingclientrect/8
- var box = elem.getBoundingClientRect();
- return {
- top: box.top + (window.pageYOffset || document.documentElement.scrollTop) - (document.documentElement.clientTop || 0),
- left: box.left + (window.pageXOffset || document.documentElement.scrollLeft) - (document.documentElement.clientLeft || 0)
- };
- }
-
- var offsetLeft = elem.offsetLeft
- , offsetTop = elem.offsetTop
- , lastElem = elem;
-
- while (elem = elem.offsetParent) {
- if (elem === document.body) { //from my observation, document.body always has scrollLeft/scrollTop == 0
- break;
- }
- offsetLeft += elem.offsetLeft;
- offsetTop += elem.offsetTop;
- lastElem = elem;
- }
-
- if (lastElem && lastElem.style.position === 'fixed') { //slow - http://jsperf.com/offset-vs-getboundingclientrect/6
- //if(lastElem !== document.body) { //faster but does gives false positive in Firefox
- offsetLeft += window.pageXOffset || document.documentElement.scrollLeft;
- offsetTop += window.pageYOffset || document.documentElement.scrollTop;
- }
-
- return {
- left: offsetLeft,
- top: offsetTop
- };
-};
-
-WalkontableDom.prototype.getComputedStyle = function (elem) {
- return elem.currentStyle || document.defaultView.getComputedStyle(elem);
-};
-
-WalkontableDom.prototype.outerWidth = function (elem) {
- return elem.offsetWidth;
-};
-
-WalkontableDom.prototype.outerHeight = function (elem) {
- if (this.hasCaptionProblem() && elem.firstChild && elem.firstChild.nodeName === 'CAPTION') {
- //fixes problem with Firefox ignoring in TABLE.offsetHeight
- //jQuery (1.10.1) still has this unsolved
- //may be better to just switch to getBoundingClientRect
- //http://bililite.com/blog/2009/03/27/finding-the-size-of-a-table/
- //http://lists.w3.org/Archives/Public/www-style/2009Oct/0089.html
- //http://bugs.jquery.com/ticket/2196
- //http://lists.w3.org/Archives/Public/www-style/2009Oct/0140.html#start140
- return elem.offsetHeight + elem.firstChild.offsetHeight;
- }
- else {
- return elem.offsetHeight;
- }
-};
-
-(function () {
- var hasCaptionProblem;
-
- function detectCaptionProblem() {
- var TABLE = document.createElement('TABLE');
- TABLE.style.borderSpacing = 0;
- TABLE.style.borderWidth = 0;
- TABLE.style.padding = 0;
- var TBODY = document.createElement('TBODY');
- TABLE.appendChild(TBODY);
- TBODY.appendChild(document.createElement('TR'));
- TBODY.firstChild.appendChild(document.createElement('TD'));
- TBODY.firstChild.firstChild.innerHTML = 't
t | ';
-
- var CAPTION = document.createElement('CAPTION');
- CAPTION.innerHTML = 'c
c
c
c';
- CAPTION.style.padding = 0;
- CAPTION.style.margin = 0;
- TABLE.insertBefore(CAPTION, TBODY);
-
- document.body.appendChild(TABLE);
- hasCaptionProblem = (TABLE.offsetHeight < 2 * TABLE.lastChild.offsetHeight); //boolean
- document.body.removeChild(TABLE);
- }
-
- WalkontableDom.prototype.hasCaptionProblem = function () {
- if (hasCaptionProblem === void 0) {
- detectCaptionProblem();
- }
- return hasCaptionProblem;
- };
-
- /**
- * Returns caret position in text input
- * @author http://stackoverflow.com/questions/263743/how-to-get-caret-position-in-textarea
- * @return {Number}
- */
- WalkontableDom.prototype.getCaretPosition = function (el) {
- if (el.selectionStart) {
- return el.selectionStart;
- }
- else if (document.selection) { //IE8
- el.focus();
- var r = document.selection.createRange();
- if (r == null) {
- return 0;
- }
- var re = el.createTextRange(),
- rc = re.duplicate();
- re.moveToBookmark(r.getBookmark());
- rc.setEndPoint('EndToStart', re);
- return rc.text.length;
- }
- return 0;
- };
-
- /**
- * Sets caret position in text input
- * @author http://blog.vishalon.net/index.php/javascript-getting-and-setting-caret-position-in-textarea/
- * @param {Element} el
- * @param {Number} pos
- * @param {Number} endPos
- */
- WalkontableDom.prototype.setCaretPosition = function (el, pos, endPos) {
- if (endPos === void 0) {
- endPos = pos;
- }
- if (el.setSelectionRange) {
- el.focus();
- el.setSelectionRange(pos, endPos);
- }
- else if (el.createTextRange) { //IE8
- var range = el.createTextRange();
- range.collapse(true);
- range.moveEnd('character', endPos);
- range.moveStart('character', pos);
- range.select();
- }
- };
-
- var cachedScrollbarWidth;
- //http://stackoverflow.com/questions/986937/how-can-i-get-the-browsers-scrollbar-sizes
- function walkontableCalculateScrollbarWidth() {
- var inner = document.createElement('p');
- inner.style.width = "100%";
- inner.style.height = "200px";
-
- var outer = document.createElement('div');
- outer.style.position = "absolute";
- outer.style.top = "0px";
- outer.style.left = "0px";
- outer.style.visibility = "hidden";
- outer.style.width = "200px";
- outer.style.height = "150px";
- outer.style.overflow = "hidden";
- outer.appendChild(inner);
-
- (document.body || document.documentElement).appendChild(outer);
- var w1 = inner.offsetWidth;
- outer.style.overflow = 'scroll';
- var w2 = inner.offsetWidth;
- if (w1 == w2) w2 = outer.clientWidth;
-
- (document.body || document.documentElement).removeChild(outer);
-
- return (w1 - w2);
- }
-
- /**
- * Returns the computed width of the native browser scroll bar
- * @return {Number} width
- */
- WalkontableDom.prototype.getScrollbarWidth = function () {
- if (cachedScrollbarWidth === void 0) {
- cachedScrollbarWidth = walkontableCalculateScrollbarWidth();
- }
- return cachedScrollbarWidth;
- }
-})();
-
-function WalkontableEvent(instance) {
- var that = this;
-
- //reference to instance
- this.instance = instance;
-
- this.wtDom = this.instance.wtDom;
-
- var dblClickOrigin = [null, null];
- var dblClickTimeout = [null, null];
-
- var onMouseDown = function (event) {
- var cell = that.parentCell(event.target);
-
- if (that.wtDom.hasClass(event.target, 'corner')) {
- that.instance.getSetting('onCellCornerMouseDown', event, event.target);
- }
- else if (cell.TD && cell.TD.nodeName === 'TD') {
- if (that.instance.hasSetting('onCellMouseDown')) {
- that.instance.getSetting('onCellMouseDown', event, cell.coords, cell.TD);
- }
- }
-
- if (event.button !== 2) { //if not right mouse button
- if (cell.TD && cell.TD.nodeName === 'TD') {
- dblClickOrigin[0] = cell.TD;
- clearTimeout(dblClickTimeout[0]);
- dblClickTimeout[0] = setTimeout(function () {
- dblClickOrigin[0] = null;
- }, 1000);
- }
- }
- };
-
- var lastMouseOver;
- var onMouseOver = function (event) {
- if (that.instance.hasSetting('onCellMouseOver')) {
- var TABLE = that.instance.wtTable.TABLE;
- var TD = that.wtDom.closest(event.target, ['TD', 'TH'], TABLE);
- if (TD && TD !== lastMouseOver && that.wtDom.isChildOf(TD, TABLE)) {
- lastMouseOver = TD;
- if (TD.nodeName === 'TD') {
- that.instance.getSetting('onCellMouseOver', event, that.instance.wtTable.getCoords(TD), TD);
- }
- }
- }
- };
-
-/* var lastMouseOut;
- var onMouseOut = function (event) {
- if (that.instance.hasSetting('onCellMouseOut')) {
- var TABLE = that.instance.wtTable.TABLE;
- var TD = that.wtDom.closest(event.target, ['TD', 'TH'], TABLE);
- if (TD && TD !== lastMouseOut && that.wtDom.isChildOf(TD, TABLE)) {
- lastMouseOut = TD;
- if (TD.nodeName === 'TD') {
- that.instance.getSetting('onCellMouseOut', event, that.instance.wtTable.getCoords(TD), TD);
- }
- }
- }
- };*/
-
- var onMouseUp = function (event) {
- if (event.button !== 2) { //if not right mouse button
- var cell = that.parentCell(event.target);
-
- if (cell.TD === dblClickOrigin[0] && cell.TD === dblClickOrigin[1]) {
- if (that.wtDom.hasClass(event.target, 'corner')) {
- that.instance.getSetting('onCellCornerDblClick', event, cell.coords, cell.TD);
- }
- else if (cell.TD) {
- that.instance.getSetting('onCellDblClick', event, cell.coords, cell.TD);
- }
-
- dblClickOrigin[0] = null;
- dblClickOrigin[1] = null;
- }
- else if (cell.TD === dblClickOrigin[0]) {
- dblClickOrigin[1] = cell.TD;
- clearTimeout(dblClickTimeout[1]);
- dblClickTimeout[1] = setTimeout(function () {
- dblClickOrigin[1] = null;
- }, 500);
- }
- }
- };
-
- $(this.instance.wtTable.holder).on('mousedown', onMouseDown);
- $(this.instance.wtTable.TABLE).on('mouseover', onMouseOver);
-// $(this.instance.wtTable.TABLE).on('mouseout', onMouseOut);
- $(this.instance.wtTable.holder).on('mouseup', onMouseUp);
-}
-
-WalkontableEvent.prototype.parentCell = function (elem) {
- var cell = {};
- var TABLE = this.instance.wtTable.TABLE;
- var TD = this.wtDom.closest(elem, ['TD', 'TH'], TABLE);
- if (TD && this.wtDom.isChildOf(TD, TABLE)) {
- cell.coords = this.instance.wtTable.getCoords(TD);
- cell.TD = TD;
- }
- else if (this.wtDom.hasClass(elem, 'wtBorder') && this.wtDom.hasClass(elem, 'current')) {
- cell.coords = this.instance.selections.current.selected[0];
- cell.TD = this.instance.wtTable.getCell(cell.coords);
- }
- return cell;
-};
-
-WalkontableEvent.prototype.destroy = function () {
- clearTimeout(this.dblClickTimeout0);
- clearTimeout(this.dblClickTimeout1);
-};
-function walkontableRangesIntersect() {
- var from = arguments[0];
- var to = arguments[1];
- for (var i = 1, ilen = arguments.length / 2; i < ilen; i++) {
- if (from <= arguments[2 * i + 1] && to >= arguments[2 * i]) {
- return true;
- }
- }
- return false;
-}
-
-/**
- * Generates a random hex string. Used as namespace for Walkontable instance events.
- * @return {String} - 16 character random string: "92b1bfc74ec4"
- */
-function walkontableRandomString() {
- function s4() {
- return Math.floor((1 + Math.random()) * 0x10000)
- .toString(16)
- .substring(1);
- }
-
- return s4() + s4() + s4() + s4();
-}
-/**
- * http://notes.jetienne.com/2011/05/18/cancelRequestAnimFrame-for-paul-irish-requestAnimFrame.html
- */
-window.requestAnimFrame = (function () {
- return window.requestAnimationFrame ||
- window.webkitRequestAnimationFrame ||
- window.mozRequestAnimationFrame ||
- window.oRequestAnimationFrame ||
- window.msRequestAnimationFrame ||
- function (/* function */ callback, /* DOMElement */ element) {
- return window.setTimeout(callback, 1000 / 60);
- };
-})();
-
-window.cancelRequestAnimFrame = (function () {
- return window.cancelAnimationFrame ||
- window.webkitCancelRequestAnimationFrame ||
- window.mozCancelRequestAnimationFrame ||
- window.oCancelRequestAnimationFrame ||
- window.msCancelRequestAnimationFrame ||
- clearTimeout
-})();
-
-//http://snipplr.com/view/13523/
-//modified for speed
-//http://jsperf.com/getcomputedstyle-vs-style-vs-css/8
-if (!window.getComputedStyle) {
- (function () {
- var elem;
-
- var styleObj = {
- getPropertyValue: function getPropertyValue(prop) {
- if (prop == 'float') prop = 'styleFloat';
- return elem.currentStyle[prop.toUpperCase()] || null;
- }
- };
-
- window.getComputedStyle = function (el) {
- elem = el;
- return styleObj;
- }
- })();
-}
-
-/**
- * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim
- */
-if (!String.prototype.trim) {
- var trimRegex = /^\s+|\s+$/g;
- String.prototype.trim = function () {
- return this.replace(trimRegex, '');
- };
-}
-/**
- * WalkontableRowFilter
- * @constructor
- */
-function WalkontableRowFilter() {
-}
-
-WalkontableRowFilter.prototype = new WalkontableCellFilter();
-
-WalkontableRowFilter.prototype.readSettings = function (instance) {
- if (instance.cloneOverlay instanceof WalkontableDebugOverlay) {
- this.offset = 0;
- }
- else {
- this.offset = instance.wtSettings.settings.offsetRow;
- }
- this.total = instance.getSetting('totalRows');
- this.fixedCount = instance.getSetting('fixedRowsTop');
-};
-/**
- * WalkontableRowStrategy
- * @param containerSizeFn
- * @param sizeAtIndex
- * @constructor
- */
-function WalkontableRowStrategy(instance, containerSizeFn, sizeAtIndex) {
-
- WalkontableCellStrategy.apply(this, arguments);
-
- this.containerSizeFn = containerSizeFn;
- this.sizeAtIndex = sizeAtIndex;
- this.cellSizesSum = 0;
- this.cellSizes = [];
- this.cellCount = 0;
- this.remainingSize = -Infinity;
-}
-
-WalkontableRowStrategy.prototype = new WalkontableCellStrategy();
-
-WalkontableRowStrategy.prototype.add = function (i, TD, reverse) {
- if (!this.isLastIncomplete() && this.remainingSize != 0) {
- var size = this.sizeAtIndex(i, TD);
- if (size === void 0) {
- return false; //total rows exceeded
- }
- var containerSize = this.getContainerSize(this.cellSizesSum + size);
- if (reverse) {
- this.cellSizes.unshift(size);
- }
- else {
- this.cellSizes.push(size);
- }
- this.cellSizesSum += size;
- this.cellCount++;
- this.remainingSize = this.cellSizesSum - containerSize;
-
- if (reverse && this.isLastIncomplete()) { //something is outside of the screen, maybe even some full rows?
- return false;
- }
- return true;
- }
- return false;
-};
-
-WalkontableRowStrategy.prototype.remove = function () {
- var size = this.cellSizes.pop();
- this.cellSizesSum -= size;
- this.cellCount--;
- this.remainingSize -= size;
-};
-
-WalkontableRowStrategy.prototype.removeOutstanding = function () {
- while (this.cellCount > 0 && this.cellSizes[this.cellCount - 1] < this.remainingSize) { //this row is completely off screen!
- this.remove();
- }
-};
-function WalkontableScroll(instance) {
- this.instance = instance;
-}
-
-WalkontableScroll.prototype.scrollVertical = function (delta) {
- if (!this.instance.drawn) {
- throw new Error('scrollVertical can only be called after table was drawn to DOM');
- }
-
- var instance = this.instance
- , newOffset
- , offset = instance.getSetting('offsetRow')
- , fixedCount = instance.getSetting('fixedRowsTop')
- , total = instance.getSetting('totalRows')
- , maxSize = instance.wtViewport.getViewportHeight();
-
- if (total > 0) {
- newOffset = this.scrollLogicVertical(delta, offset, total, fixedCount, maxSize, function (row) {
- if (row - offset < fixedCount && row - offset >= 0) {
- return instance.getSetting('rowHeight', row - offset);
- }
- else {
- return instance.getSetting('rowHeight', row);
- }
- }, function (isReverse) {
- instance.wtTable.verticalRenderReverse = isReverse;
- });
- }
- else {
- newOffset = 0;
- }
-
- if (newOffset !== offset) {
- this.instance.wtScrollbars.vertical.scrollTo(newOffset);
- }
- return instance;
-};
-
-WalkontableScroll.prototype.scrollHorizontal = function (delta) {
- if (!this.instance.drawn) {
- throw new Error('scrollHorizontal can only be called after table was drawn to DOM');
- }
-
- var instance = this.instance
- , newOffset
- , offset = instance.getSetting('offsetColumn')
- , fixedCount = instance.getSetting('fixedColumnsLeft')
- , total = instance.getSetting('totalColumns')
- , maxSize = instance.wtViewport.getViewportWidth();
-
- if (total > 0) {
- newOffset = this.scrollLogicHorizontal(delta, offset, total, fixedCount, maxSize, function (col) {
- if (col - offset < fixedCount && col - offset >= 0) {
- return instance.getSetting('columnWidth', col - offset);
- }
- else {
- return instance.getSetting('columnWidth', col);
- }
- });
- }
- else {
- newOffset = 0;
- }
-
- if (newOffset !== offset) {
- this.instance.wtScrollbars.horizontal.scrollTo(newOffset);
- }
- return instance;
-};
-
-WalkontableScroll.prototype.scrollLogicVertical = function (delta, offset, total, fixedCount, maxSize, cellSizeFn, setReverseRenderFn) {
- var newOffset = offset + delta;
-
- if (newOffset >= total - fixedCount) {
- newOffset = total - fixedCount - 1;
- setReverseRenderFn(true);
- }
-
- if (newOffset < 0) {
- newOffset = 0;
- }
-
- return newOffset;
-};
-
-WalkontableScroll.prototype.scrollLogicHorizontal = function (delta, offset, total, fixedCount, maxSize, cellSizeFn) {
- var newOffset = offset + delta
- , sum = 0
- , col;
-
- if (newOffset > fixedCount) {
- if (newOffset >= total - fixedCount) {
- newOffset = total - fixedCount - 1;
- }
-
- col = newOffset;
- while (sum < maxSize && col < total) {
- sum += cellSizeFn(col);
- col++;
- }
-
- if (sum < maxSize) {
- while (newOffset > 0) {
- //if sum still less than available width, we cannot scroll that far (must move offset to the left)
- sum += cellSizeFn(newOffset - 1);
- if (sum < maxSize) {
- newOffset--;
- }
- else {
- break;
- }
- }
- }
- }
- else if (newOffset < 0) {
- newOffset = 0;
- }
-
- return newOffset;
-};
-
-/**
- * Scrolls viewport to a cell by minimum number of cells
- */
-WalkontableScroll.prototype.scrollViewport = function (coords) {
- if (!this.instance.drawn) {
- return;
- }
-
- var offsetRow = this.instance.getSetting('offsetRow')
- , offsetColumn = this.instance.getSetting('offsetColumn')
- , lastVisibleRow = this.instance.wtTable.getLastVisibleRow()
- , totalRows = this.instance.getSetting('totalRows')
- , totalColumns = this.instance.getSetting('totalColumns')
- , fixedRowsTop = this.instance.getSetting('fixedRowsTop')
- , fixedColumnsLeft = this.instance.getSetting('fixedColumnsLeft');
-
- if (this.instance.getSetting('nativeScrollbars')) {
- var TD = this.instance.wtTable.getCell(coords);
- if (typeof TD === 'object') {
- var offset = WalkontableDom.prototype.offset(TD);
- var outerWidth = WalkontableDom.prototype.outerWidth(TD);
- var outerHeight = WalkontableDom.prototype.outerHeight(TD);
- var scrollX = this.instance.wtScrollbars.horizontal.getScrollPosition();
- var scrollY = this.instance.wtScrollbars.vertical.getScrollPosition();
- var clientWidth = WalkontableDom.prototype.outerWidth(this.instance.wtScrollbars.horizontal.scrollHandler);
- var clientHeight = WalkontableDom.prototype.outerHeight(this.instance.wtScrollbars.vertical.scrollHandler);
- if (this.instance.wtScrollbars.horizontal.scrollHandler !== window) {
- offset.left = offset.left - WalkontableDom.prototype.offset(this.instance.wtScrollbars.horizontal.scrollHandler).left;
- }
- if (this.instance.wtScrollbars.vertical.scrollHandler !== window) {
- offset.top = offset.top - WalkontableDom.prototype.offset(this.instance.wtScrollbars.vertical.scrollHandler).top;
- }
-
- clientWidth -= 20;
- clientHeight -= 20;
-
- if (outerWidth < clientWidth) {
- if (offset.left < scrollX) {
- this.instance.wtScrollbars.horizontal.setScrollPosition(offset.left);
- }
- else if (offset.left + outerWidth > scrollX + clientWidth) {
- this.instance.wtScrollbars.horizontal.setScrollPosition(offset.left - clientWidth + outerWidth);
- }
- }
- if (outerHeight < clientHeight) {
- if (offset.top < scrollY) {
- this.instance.wtScrollbars.vertical.setScrollPosition(offset.top);
- }
- else if (offset.top + outerHeight > scrollY + clientHeight) {
- this.instance.wtScrollbars.vertical.setScrollPosition(offset.top - clientHeight + outerHeight);
- }
- }
- return;
- }
- }
-
- if (coords[0] < 0 || coords[0] > totalRows - 1) {
- throw new Error('row ' + coords[0] + ' does not exist');
- }
- else if (coords[1] < 0 || coords[1] > totalColumns - 1) {
- throw new Error('column ' + coords[1] + ' does not exist');
- }
-
- if (coords[0] > lastVisibleRow) {
-// this.scrollVertical(coords[0] - lastVisibleRow + 1);
- this.scrollVertical(coords[0] - fixedRowsTop - offsetRow);
- this.instance.wtTable.verticalRenderReverse = true;
- }
- else if (coords[0] === lastVisibleRow && this.instance.wtTable.rowStrategy.isLastIncomplete()) {
-// this.scrollVertical(coords[0] - lastVisibleRow + 1);
- this.scrollVertical(coords[0] - fixedRowsTop - offsetRow);
- this.instance.wtTable.verticalRenderReverse = true;
- }
- else if (coords[0] - fixedRowsTop < offsetRow) {
- this.scrollVertical(coords[0] - fixedRowsTop - offsetRow);
- }
- else {
- this.scrollVertical(0); //Craig's issue: remove row from the last scroll page should scroll viewport a row up if needed
- }
-
- if (this.instance.wtTable.isColumnBeforeViewport(coords[1])) {
- //scroll left
- this.instance.wtScrollbars.horizontal.scrollTo(coords[1] - fixedColumnsLeft);
- }
- else if (this.instance.wtTable.isColumnAfterViewport(coords[1]) || (this.instance.wtTable.getLastVisibleColumn() === coords[1] && !this.instance.wtTable.isLastColumnFullyVisible())) {
- //scroll right
- var sum = 0;
- for (var i = 0; i < fixedColumnsLeft; i++) {
- sum += this.instance.getSetting('columnWidth', i);
- }
- var scrollTo = coords[1];
- sum += this.instance.getSetting('columnWidth', scrollTo);
- var available = this.instance.wtViewport.getViewportWidth();
- if (sum < available) {
- var next = this.instance.getSetting('columnWidth', scrollTo - 1);
- while (sum + next <= available && scrollTo >= fixedColumnsLeft) {
- scrollTo--;
- sum += next;
- next = this.instance.getSetting('columnWidth', scrollTo - 1);
- }
- }
-
- this.instance.wtScrollbars.horizontal.scrollTo(scrollTo - fixedColumnsLeft);
- }
- /*else {
- //no scroll
- }*/
-
- return this.instance;
-};
-
-function WalkontableScrollbar() {
-}
-
-WalkontableScrollbar.prototype.init = function () {
- var that = this;
-
- //reference to instance
- this.$table = $(this.instance.wtTable.TABLE);
-
- //create elements
- this.slider = document.createElement('DIV');
- this.sliderStyle = this.slider.style;
- this.sliderStyle.position = 'absolute';
- this.sliderStyle.top = '0';
- this.sliderStyle.left = '0';
- this.sliderStyle.display = 'none';
- this.slider.className = 'dragdealer ' + this.type;
-
- this.handle = document.createElement('DIV');
- this.handleStyle = this.handle.style;
- this.handle.className = 'handle';
-
- this.slider.appendChild(this.handle);
- this.container = this.instance.wtTable.holder;
- this.container.appendChild(this.slider);
-
- var firstRun = true;
- this.dragTimeout = null;
- var dragDelta;
- var dragRender = function () {
- that.onScroll(dragDelta);
- };
-
- this.dragdealer = new Dragdealer(this.slider, {
- vertical: (this.type === 'vertical'),
- horizontal: (this.type === 'horizontal'),
- slide: false,
- speed: 100,
- animationCallback: function (x, y) {
- if (firstRun) {
- firstRun = false;
- return;
- }
- that.skipRefresh = true;
- dragDelta = that.type === 'vertical' ? y : x;
- if (that.dragTimeout === null) {
- that.dragTimeout = setInterval(dragRender, 100);
- dragRender();
- }
- },
- callback: function (x, y) {
- that.skipRefresh = false;
- clearInterval(that.dragTimeout);
- that.dragTimeout = null;
- dragDelta = that.type === 'vertical' ? y : x;
- that.onScroll(dragDelta);
- }
- });
- this.skipRefresh = false;
-};
-
-WalkontableScrollbar.prototype.onScroll = function (delta) {
- if (this.instance.drawn) {
- this.readSettings();
- if (this.total > this.visibleCount) {
- var newOffset = Math.round(this.handlePosition * this.total / this.sliderSize);
-
- if (delta === 1) {
- if (this.type === 'vertical') {
- this.instance.scrollVertical(Infinity).draw();
- }
- else {
- this.instance.scrollHorizontal(Infinity).draw();
- }
- }
- else if (newOffset !== this.offset) { //is new offset different than old offset
- if (this.type === 'vertical') {
- this.instance.scrollVertical(newOffset - this.offset).draw();
- }
- else {
- this.instance.scrollHorizontal(newOffset - this.offset).draw();
- }
- }
- else {
- this.refresh();
- }
- }
- }
-};
-
-/**
- * Returns what part of the scroller should the handle take
- * @param viewportCount {Number} number of visible rows or columns
- * @param totalCount {Number} total number of rows or columns
- * @return {Number} 0..1
- */
-WalkontableScrollbar.prototype.getHandleSizeRatio = function (viewportCount, totalCount) {
- if (!totalCount || viewportCount > totalCount || viewportCount == totalCount) {
- return 1;
- }
- return 1 / totalCount;
-};
-
-WalkontableScrollbar.prototype.prepare = function () {
- if (this.skipRefresh) {
- return;
- }
- var ratio = this.getHandleSizeRatio(this.visibleCount, this.total);
- if (((ratio === 1 || isNaN(ratio)) && this.scrollMode === 'auto') || this.scrollMode === 'none') {
- //isNaN is needed because ratio equals NaN when totalRows/totalColumns equals 0
- this.visible = false;
- }
- else {
- this.visible = true;
- }
-};
-
-WalkontableScrollbar.prototype.refresh = function () {
- if (this.skipRefresh) {
- return;
- }
- else if (!this.visible) {
- this.sliderStyle.display = 'none';
- return;
- }
-
- var ratio
- , sliderSize
- , handleSize
- , handlePosition
- , visibleCount = this.visibleCount
- , tableWidth = this.instance.wtViewport.getWorkspaceWidth()
- , tableHeight = this.instance.wtViewport.getWorkspaceHeight();
-
- if (tableWidth === Infinity) {
- tableWidth = this.instance.wtViewport.getWorkspaceActualWidth();
- }
-
- if (tableHeight === Infinity) {
- tableHeight = this.instance.wtViewport.getWorkspaceActualHeight();
- }
-
- if (this.type === 'vertical') {
- if (this.instance.wtTable.rowStrategy.isLastIncomplete()) {
- visibleCount--;
- }
-
- sliderSize = tableHeight - 2; //2 is sliders border-width
-
- this.sliderStyle.top = this.instance.wtDom.offset(this.$table[0]).top - this.instance.wtDom.offset(this.container).top + 'px';
- this.sliderStyle.left = tableWidth - 1 + 'px'; //1 is sliders border-width
- this.sliderStyle.height = Math.max(sliderSize, 0) + 'px';
- }
- else { //horizontal
- sliderSize = tableWidth - 2; //2 is sliders border-width
-
- this.sliderStyle.left = this.instance.wtDom.offset(this.$table[0]).left - this.instance.wtDom.offset(this.container).left + 'px';
- this.sliderStyle.top = tableHeight - 1 + 'px'; //1 is sliders border-width
- this.sliderStyle.width = Math.max(sliderSize, 0) + 'px';
- }
-
- ratio = this.getHandleSizeRatio(visibleCount, this.total);
- handleSize = Math.round(sliderSize * ratio);
- if (handleSize < 10) {
- handleSize = 15;
- }
-
- handlePosition = Math.floor(sliderSize * (this.offset / this.total));
- if (handleSize + handlePosition > sliderSize) {
- handlePosition = sliderSize - handleSize;
- }
-
- if (this.type === 'vertical') {
- this.handleStyle.height = handleSize + 'px';
- this.handleStyle.top = handlePosition + 'px';
-
- }
- else { //horizontal
- this.handleStyle.width = handleSize + 'px';
- this.handleStyle.left = handlePosition + 'px';
- }
-
- this.sliderStyle.display = 'block';
-};
-
-WalkontableScrollbar.prototype.destroy = function () {
- clearInterval(this.dragdealer.interval);
-};
-
-///
-
-var WalkontableVerticalScrollbar = function (instance) {
- this.instance = instance;
- this.type = 'vertical';
- this.init();
-};
-
-WalkontableVerticalScrollbar.prototype = new WalkontableScrollbar();
-
-WalkontableVerticalScrollbar.prototype.scrollTo = function (cell) {
- this.instance.update('offsetRow', cell);
-};
-
-WalkontableVerticalScrollbar.prototype.readSettings = function () {
- this.scrollMode = this.instance.getSetting('scrollV');
- this.offset = this.instance.getSetting('offsetRow');
- this.total = this.instance.getSetting('totalRows');
- this.visibleCount = this.instance.wtTable.rowStrategy.countVisible();
- if(this.visibleCount > 1 && this.instance.wtTable.rowStrategy.isLastIncomplete()) {
- this.visibleCount--;
- }
- this.handlePosition = parseInt(this.handleStyle.top, 10);
- this.sliderSize = parseInt(this.sliderStyle.height, 10);
- this.fixedCount = this.instance.getSetting('fixedRowsTop');
-};
-
-///
-
-var WalkontableHorizontalScrollbar = function (instance) {
- this.instance = instance;
- this.type = 'horizontal';
- this.init();
-};
-
-WalkontableHorizontalScrollbar.prototype = new WalkontableScrollbar();
-
-WalkontableHorizontalScrollbar.prototype.scrollTo = function (cell) {
- this.instance.update('offsetColumn', cell);
-};
-
-WalkontableHorizontalScrollbar.prototype.readSettings = function () {
- this.scrollMode = this.instance.getSetting('scrollH');
- this.offset = this.instance.getSetting('offsetColumn');
- this.total = this.instance.getSetting('totalColumns');
- this.visibleCount = this.instance.wtTable.columnStrategy.countVisible();
- if(this.visibleCount > 1 && this.instance.wtTable.columnStrategy.isLastIncomplete()) {
- this.visibleCount--;
- }
- this.handlePosition = parseInt(this.handleStyle.left, 10);
- this.sliderSize = parseInt(this.sliderStyle.width, 10);
- this.fixedCount = this.instance.getSetting('fixedColumnsLeft');
-};
-
-WalkontableHorizontalScrollbar.prototype.getHandleSizeRatio = function (viewportCount, totalCount) {
- if (!totalCount || viewportCount > totalCount || viewportCount == totalCount) {
- return 1;
- }
- return viewportCount / totalCount;
-};
-function WalkontableCornerScrollbarNative(instance) {
- this.instance = instance;
- this.init();
- this.clone = this.makeClone('corner');
-}
-
-WalkontableCornerScrollbarNative.prototype = new WalkontableOverlay();
-
-WalkontableCornerScrollbarNative.prototype.resetFixedPosition = function () {
- if (!this.instance.wtTable.holder.parentNode) {
- return; //removed from DOM
- }
- var elem = this.clone.wtTable.holder.parentNode;
-
- var box;
- if (this.scrollHandler === window) {
- box = this.instance.wtTable.hider.getBoundingClientRect();
- var top = Math.ceil(box.top, 10);
- var bottom = Math.ceil(box.bottom, 10);
-
- if (top < 0 && bottom > 0) {
- elem.style.top = '0';
- }
- else {
- elem.style.top = top + 'px';
- }
-
- var left = Math.ceil(box.left, 10);
- var right = Math.ceil(box.right, 10);
-
- if (left < 0 && right > 0) {
- elem.style.left = '0';
- }
- else {
- elem.style.left = left + 'px';
- }
- }
- else {
- box = this.scrollHandler.getBoundingClientRect();
- elem.style.top = Math.ceil(box.top, 10) + 'px';
- elem.style.left = Math.ceil(box.left, 10) + 'px';
- }
-
- elem.style.width = WalkontableDom.prototype.outerWidth(this.clone.wtTable.TABLE) + 4 + 'px';
- elem.style.height = WalkontableDom.prototype.outerHeight(this.clone.wtTable.TABLE) + 4 + 'px';
-};
-
-WalkontableCornerScrollbarNative.prototype.prepare = function () {
-};
-
-WalkontableCornerScrollbarNative.prototype.refresh = function (selectionsOnly) {
- this.measureBefore = 0;
- this.measureAfter = 0;
- this.clone && this.clone.draw(selectionsOnly);
-};
-
-WalkontableCornerScrollbarNative.prototype.getScrollPosition = function () {
-};
-
-WalkontableCornerScrollbarNative.prototype.getLastCell = function () {
-};
-
-WalkontableCornerScrollbarNative.prototype.applyToDOM = function () {
-};
-
-WalkontableCornerScrollbarNative.prototype.scrollTo = function () {
-};
-
-WalkontableCornerScrollbarNative.prototype.readWindowSize = function () {
-};
-
-WalkontableCornerScrollbarNative.prototype.readSettings = function () {
-};
-function WalkontableHorizontalScrollbarNative(instance) {
- this.instance = instance;
- this.type = 'horizontal';
- this.cellSize = 50;
- this.init();
- this.clone = this.makeClone('left');
-}
-
-WalkontableHorizontalScrollbarNative.prototype = new WalkontableOverlay();
-
-//resetFixedPosition (in future merge it with this.refresh?)
-WalkontableHorizontalScrollbarNative.prototype.resetFixedPosition = function () {
- if (!this.instance.wtTable.holder.parentNode) {
- return; //removed from DOM
- }
- var elem = this.clone.wtTable.holder.parentNode;
-
- var box;
- if (this.scrollHandler === window) {
- box = this.instance.wtTable.hider.getBoundingClientRect();
- var left = Math.ceil(box.left, 10);
- var right = Math.ceil(box.right, 10);
-
- if (left < 0 && right > 0) {
- elem.style.left = '0';
- }
- else {
- elem.style.left = left + 'px';
- }
- }
- else {
- box = this.scrollHandler.getBoundingClientRect();
- elem.style.top = Math.ceil(box.top, 10) + 'px';
- elem.style.left = Math.ceil(box.left, 10) + 'px';
- }
-};
-
-//react on movement of the other dimension scrollbar (in future merge it with this.refresh?)
-WalkontableHorizontalScrollbarNative.prototype.react = function () {
- if (!this.instance.wtTable.holder.parentNode) {
- return; //removed from DOM
- }
- var overlayContainer = this.clone.wtTable.holder.parentNode;
- if (this.instance.wtScrollbars.vertical.scrollHandler === window) {
- var box = this.instance.wtTable.hider.getBoundingClientRect();
- overlayContainer.style.top = Math.ceil(box.top, 10) + 'px';
- overlayContainer.style.height = WalkontableDom.prototype.outerHeight(this.clone.wtTable.TABLE) + 'px';
- }
- else {
- this.clone.wtTable.holder.style.top = -(this.instance.wtScrollbars.vertical.windowScrollPosition - this.instance.wtScrollbars.vertical.measureBefore) + 'px';
- overlayContainer.style.height = this.instance.wtViewport.getWorkspaceHeight() + 'px'
- }
- overlayContainer.style.width = WalkontableDom.prototype.outerWidth(this.clone.wtTable.TABLE) + 4 + 'px'; //4 is for the box shadow
-};
-
-WalkontableHorizontalScrollbarNative.prototype.prepare = function () {
-};
-
-WalkontableHorizontalScrollbarNative.prototype.refresh = function (selectionsOnly) {
- this.measureBefore = 0;
- this.measureAfter = 0;
- this.clone && this.clone.draw(selectionsOnly);
-};
-
-WalkontableHorizontalScrollbarNative.prototype.getScrollPosition = function () {
- if (this.scrollHandler === window) {
- return this.scrollHandler.scrollX;
- }
- else {
- return this.scrollHandler.scrollLeft;
- }
-};
-
-WalkontableHorizontalScrollbarNative.prototype.setScrollPosition = function (pos) {
- this.scrollHandler.scrollLeft = pos;
-};
-
-WalkontableHorizontalScrollbarNative.prototype.onScroll = function () {
- WalkontableOverlay.prototype.onScroll.apply(this, arguments);
-
- this.instance.getSetting('onScrollHorizontally');
-};
-
-WalkontableHorizontalScrollbarNative.prototype.getLastCell = function () {
- return this.instance.wtTable.getLastVisibleColumn();
-};
-
-//applyToDOM (in future merge it with this.refresh?)
-WalkontableHorizontalScrollbarNative.prototype.applyToDOM = function () {
- this.fixedContainer.style.paddingLeft = this.measureBefore + 'px';
- this.fixedContainer.style.paddingRight = this.measureAfter + 'px';
-};
-
-WalkontableHorizontalScrollbarNative.prototype.scrollTo = function (cell) {
- this.$scrollHandler.scrollLeft(this.tableParentOffset + cell * this.cellSize);
-};
-
-//readWindowSize (in future merge it with this.prepare?)
-WalkontableHorizontalScrollbarNative.prototype.readWindowSize = function () {
- if (this.scrollHandler === window) {
- this.windowSize = document.documentElement.clientWidth;
- this.tableParentOffset = this.instance.wtTable.holderOffset.left;
- }
- else {
- this.windowSize = WalkontableDom.prototype.outerWidth(this.scrollHandler);
- this.tableParentOffset = 0;
- }
- this.windowScrollPosition = this.getScrollPosition();
-};
-
-//readSettings (in future merge it with this.prepare?)
-WalkontableHorizontalScrollbarNative.prototype.readSettings = function () {
- this.offset = this.instance.getSetting('offsetColumn');
- this.total = this.instance.getSetting('totalColumns');
-};
-function WalkontableVerticalScrollbarNative(instance) {
- this.instance = instance;
- this.type = 'vertical';
- this.cellSize = 23;
- this.init();
- this.clone = this.makeClone('top');
-}
-
-WalkontableVerticalScrollbarNative.prototype = new WalkontableOverlay();
-
-//resetFixedPosition (in future merge it with this.refresh?)
-WalkontableVerticalScrollbarNative.prototype.resetFixedPosition = function () {
- if (!this.instance.wtTable.holder.parentNode) {
- return; //removed from DOM
- }
- var elem = this.clone.wtTable.holder.parentNode;
-
- var box;
- if (this.scrollHandler === window) {
- box = this.instance.wtTable.hider.getBoundingClientRect();
- var top = Math.ceil(box.top, 10);
- var bottom = Math.ceil(box.bottom, 10);
-
- if (top < 0 && bottom > 0) {
- elem.style.top = '0';
- }
- else {
- elem.style.top = top + 'px';
- }
- }
- else {
- box = this.instance.wtScrollbars.horizontal.scrollHandler.getBoundingClientRect();
- elem.style.top = Math.ceil(box.top, 10) + 'px';
- elem.style.left = Math.ceil(box.left, 10) + 'px';
- }
-
- if (this.instance.wtScrollbars.horizontal.scrollHandler === window) {
- elem.style.width = this.instance.wtViewport.getWorkspaceActualWidth() + 'px';
- }
- else {
- elem.style.width = WalkontableDom.prototype.outerWidth(this.instance.wtTable.holder.parentNode) + 'px';
- }
-
- elem.style.height = WalkontableDom.prototype.outerHeight(this.clone.wtTable.TABLE) + 4 + 'px';
-};
-
-//react on movement of the other dimension scrollbar (in future merge it with this.refresh?)
-WalkontableVerticalScrollbarNative.prototype.react = function () {
- if (!this.instance.wtTable.holder.parentNode) {
- return; //removed from DOM
- }
- if (this.instance.wtScrollbars.horizontal.scrollHandler !== window) {
- var elem = this.clone.wtTable.holder.parentNode;
- elem.firstChild.style.left = -this.instance.wtScrollbars.horizontal.windowScrollPosition + 'px';
- }
-};
-
-WalkontableVerticalScrollbarNative.prototype.getScrollPosition = function () {
- if (this.scrollHandler === window) {
- return this.scrollHandler.scrollY;
- }
- else {
- return this.scrollHandler.scrollTop;
- }
-};
-
-WalkontableVerticalScrollbarNative.prototype.setScrollPosition = function (pos) {
- this.scrollHandler.scrollTop = pos;
-};
-
-WalkontableVerticalScrollbarNative.prototype.onScroll = function (forcePosition) {
- WalkontableOverlay.prototype.onScroll.apply(this, arguments);
-
- var scrollDelta;
- var newOffset = 0;
-
- if (1 == 1 || this.windowScrollPosition > this.tableParentOffset) {
- scrollDelta = this.windowScrollPosition - this.tableParentOffset;
-
- partialOffset = 0;
- if (scrollDelta > 0) {
- var sum = 0;
- var last;
- for (var i = 0; i < this.total; i++) {
- last = this.instance.getSetting('rowHeight', i);
- sum += last;
- if (sum > scrollDelta) {
- break;
- }
- }
-
- if (this.offset > 0) {
- partialOffset = (sum - scrollDelta);
- }
- newOffset = i;
- newOffset = Math.min(newOffset, this.total);
- }
- }
-
- this.curOuts = newOffset > this.maxOuts ? this.maxOuts : newOffset;
- newOffset -= this.curOuts;
-
- this.instance.update('offsetRow', newOffset);
- this.readSettings(); //read new offset
- this.instance.draw();
-
- this.instance.getSetting('onScrollVertically');
-};
-
-WalkontableVerticalScrollbarNative.prototype.getLastCell = function () {
- return this.instance.getSetting('offsetRow') + this.instance.wtTable.tbodyChildrenLength - 1;
-};
-
-var partialOffset = 0;
-
-WalkontableVerticalScrollbarNative.prototype.sumCellSizes = function (from, length) {
- var sum = 0;
- while (from < length) {
- sum += this.instance.getSetting('rowHeight', from);
- from++;
- }
- return sum;
-};
-
-//applyToDOM (in future merge it with this.refresh?)
-WalkontableVerticalScrollbarNative.prototype.applyToDOM = function () {
- var headerSize = this.instance.wtViewport.getColumnHeaderHeight();
- this.fixedContainer.style.height = headerSize + this.sumCellSizes(0, this.total) + 4 + 'px'; //+4 is needed, otherwise vertical scroll appears in Chrome (window scroll mode) - maybe because of fill handle in last row or because of box shadow
- this.fixed.style.top = this.measureBefore + 'px';
- this.fixed.style.bottom = '';
-};
-
-WalkontableVerticalScrollbarNative.prototype.scrollTo = function (cell) {
- var newY = this.tableParentOffset + cell * this.cellSize;
- this.$scrollHandler.scrollTop(newY);
- this.onScroll(newY);
-};
-
-//readWindowSize (in future merge it with this.prepare?)
-WalkontableVerticalScrollbarNative.prototype.readWindowSize = function () {
- if (this.scrollHandler === window) {
- this.windowSize = document.documentElement.clientHeight;
- this.tableParentOffset = this.instance.wtTable.holderOffset.top;
- }
- else {
- //this.windowSize = WalkontableDom.prototype.outerHeight(this.scrollHandler);
- this.windowSize = this.scrollHandler.clientHeight; //returns height without DIV scrollbar
- this.tableParentOffset = 0;
- }
- this.windowScrollPosition = this.getScrollPosition();
-};
-
-//readSettings (in future merge it with this.prepare?)
-WalkontableVerticalScrollbarNative.prototype.readSettings = function () {
- this.offset = this.instance.getSetting('offsetRow');
- this.total = this.instance.getSetting('totalRows');
-};
-function WalkontableScrollbars(instance) {
- this.instance = instance;
- if (instance.getSetting('nativeScrollbars')) {
- instance.update('scrollbarWidth', instance.wtDom.getScrollbarWidth());
- instance.update('scrollbarHeight', instance.wtDom.getScrollbarWidth());
- this.vertical = new WalkontableVerticalScrollbarNative(instance);
- this.horizontal = new WalkontableHorizontalScrollbarNative(instance);
- this.corner = new WalkontableCornerScrollbarNative(instance);
- if (instance.getSetting('debug')) {
- this.debug = new WalkontableDebugOverlay(instance);
- }
- this.registerListeners();
- }
- else {
- this.vertical = new WalkontableVerticalScrollbar(instance);
- this.horizontal = new WalkontableHorizontalScrollbar(instance);
- }
-}
-
-WalkontableScrollbars.prototype.registerListeners = function () {
- var that = this;
-
- var oldVerticalScrollPosition
- , oldHorizontalScrollPosition
- , oldBoxTop
- , oldBoxLeft
- , oldBoxWidth
- , oldBoxHeight;
-
- function refreshAll() {
- if (!that.instance.wtTable.holder.parentNode) {
- //Walkontable was detached from DOM, but this handler was not removed
- that.destroy();
- return;
- }
-
- that.vertical.windowScrollPosition = that.vertical.getScrollPosition();
- that.horizontal.windowScrollPosition = that.horizontal.getScrollPosition();
- that.box = that.instance.wtTable.hider.getBoundingClientRect();
-
- if((that.box.width !== oldBoxWidth || that.box.height !== oldBoxHeight) && that.instance.rowHeightCache) {
- //that.instance.rowHeightCache.length = 0; //at this point the cached row heights may be invalid, but it is better not to reset the cache, which could cause scrollbar jumping when there are multiline cells outside of the rendered part of the table
- oldBoxWidth = that.box.width;
- oldBoxHeight = that.box.height;
- that.instance.draw();
- }
-
- if (that.vertical.windowScrollPosition !== oldVerticalScrollPosition || that.horizontal.windowScrollPosition !== oldHorizontalScrollPosition || that.box.top !== oldBoxTop || that.box.left !== oldBoxLeft) {
- that.vertical.onScroll();
- that.horizontal.onScroll(); //it's done here to make sure that all onScroll's are executed before changing styles
-
- that.vertical.react();
- that.horizontal.react(); //it's done here to make sure that all onScroll's are executed before changing styles
-
- oldVerticalScrollPosition = that.vertical.windowScrollPosition;
- oldHorizontalScrollPosition = that.horizontal.windowScrollPosition;
- oldBoxTop = that.box.top;
- oldBoxLeft = that.box.left;
- }
- }
-
- var $window = $(window);
- this.vertical.$scrollHandler.on('scroll.' + this.instance.guid, refreshAll);
- if (this.vertical.scrollHandler !== this.horizontal.scrollHandler) {
- this.horizontal.$scrollHandler.on('scroll.' + this.instance.guid, refreshAll);
- }
-
- if (this.vertical.scrollHandler !== window && this.horizontal.scrollHandler !== window) {
- $window.on('scroll.' + this.instance.guid, refreshAll);
- }
- $window.on('load.' + this.instance.guid, refreshAll);
- $window.on('resize.' + this.instance.guid, refreshAll);
- $(document).on('ready.' + this.instance.guid, refreshAll);
- setInterval(refreshAll, 100); //Marcin - only idea I have to reposition scrollbars on CSS change of the container (container was moved using some styles after page was loaded)
-};
-
-WalkontableScrollbars.prototype.destroy = function () {
- this.vertical && this.vertical.destroy();
- this.horizontal && this.horizontal.destroy();
-};
-
-WalkontableScrollbars.prototype.refresh = function (selectionsOnly) {
- this.horizontal && this.horizontal.readSettings();
- this.vertical && this.vertical.readSettings();
- this.horizontal && this.horizontal.prepare();
- this.vertical && this.vertical.prepare();
- this.horizontal && this.horizontal.refresh(selectionsOnly);
- this.vertical && this.vertical.refresh(selectionsOnly);
- this.corner && this.corner.refresh(selectionsOnly);
- this.debug && this.debug.refresh(selectionsOnly);
-};
-function WalkontableSelection(instance, settings) {
- this.instance = instance;
- this.settings = settings;
- this.selected = [];
- if (settings.border) {
- this.border = new WalkontableBorder(instance, settings);
- }
-}
-
-WalkontableSelection.prototype.add = function (coords) {
- this.selected.push(coords);
-};
-
-WalkontableSelection.prototype.clear = function () {
- this.selected.length = 0; //http://jsperf.com/clear-arrayxxx
-};
-
-/**
- * Returns the top left (TL) and bottom right (BR) selection coordinates
- * @returns {Object}
- */
-WalkontableSelection.prototype.getCorners = function () {
- var minRow
- , minColumn
- , maxRow
- , maxColumn
- , i
- , ilen = this.selected.length;
-
- if (ilen > 0) {
- minRow = maxRow = this.selected[0][0];
- minColumn = maxColumn = this.selected[0][1];
-
- if (ilen > 1) {
- for (i = 1; i < ilen; i++) {
- if (this.selected[i][0] < minRow) {
- minRow = this.selected[i][0];
- }
- else if (this.selected[i][0] > maxRow) {
- maxRow = this.selected[i][0];
- }
-
- if (this.selected[i][1] < minColumn) {
- minColumn = this.selected[i][1];
- }
- else if (this.selected[i][1] > maxColumn) {
- maxColumn = this.selected[i][1];
- }
- }
- }
- }
-
- return [minRow, minColumn, maxRow, maxColumn];
-};
-
-WalkontableSelection.prototype.draw = function () {
- var corners, r, c, source_r, source_c;
-
- var visibleRows = this.instance.wtTable.rowStrategy.countVisible()
- , visibleColumns = this.instance.wtTable.columnStrategy.countVisible();
-
- if (this.selected.length) {
- corners = this.getCorners();
-
- for (r = 0; r < visibleRows; r++) {
- for (c = 0; c < visibleColumns; c++) {
- source_r = this.instance.wtTable.rowFilter.visibleToSource(r);
- source_c = this.instance.wtTable.columnFilter.visibleToSource(c);
-
- if (source_r >= corners[0] && source_r <= corners[2] && source_c >= corners[1] && source_c <= corners[3]) {
- //selected cell
- this.instance.wtTable.currentCellCache.add(r, c, this.settings.className);
- }
- else if (source_r >= corners[0] && source_r <= corners[2]) {
- //selection is in this row
- this.instance.wtTable.currentCellCache.add(r, c, this.settings.highlightRowClassName);
- }
- else if (source_c >= corners[1] && source_c <= corners[3]) {
- //selection is in this column
- this.instance.wtTable.currentCellCache.add(r, c, this.settings.highlightColumnClassName);
- }
- }
- }
-
- this.border && this.border.appear(corners); //warning! border.appear modifies corners!
- }
- else {
- this.border && this.border.disappear();
- }
-};
-
-function WalkontableSettings(instance, settings) {
- var that = this;
- this.instance = instance;
-
- //default settings. void 0 means it is required, null means it can be empty
- this.defaults = {
- table: void 0,
- debug: false, //shows WalkontableDebugOverlay
-
- //presentation mode
- scrollH: 'auto', //values: scroll (always show scrollbar), auto (show scrollbar if table does not fit in the container), none (never show scrollbar)
- scrollV: 'auto', //values: see above
- nativeScrollbars: false, //values: false (dragdealer), true (native)
- stretchH: 'hybrid', //values: hybrid, all, last, none
- currentRowClassName: null,
- currentColumnClassName: null,
-
- //data source
- data: void 0,
- offsetRow: 0,
- offsetColumn: 0,
- fixedColumnsLeft: 0,
- fixedRowsTop: 0,
- rowHeaders: function () {
- return []
- }, //this must be array of functions: [function (row, TH) {}]
- columnHeaders: function () {
- return []
- }, //this must be array of functions: [function (column, TH) {}]
- totalRows: void 0,
- totalColumns: void 0,
- width: null,
- height: null,
- cellRenderer: function (row, column, TD) {
- var cellData = that.getSetting('data', row, column);
- that.instance.wtDom.fastInnerText(TD, cellData === void 0 || cellData === null ? '' : cellData);
- },
- columnWidth: 50,
- selections: null,
- hideBorderOnMouseDownOver: false,
-
- //callbacks
- onCellMouseDown: null,
- onCellMouseOver: null,
-// onCellMouseOut: null,
- onCellDblClick: null,
- onCellCornerMouseDown: null,
- onCellCornerDblClick: null,
- beforeDraw: null,
- onDraw: null,
- onScrollVertically: null,
- onScrollHorizontally: null,
-
- //constants
- scrollbarWidth: 10,
- scrollbarHeight: 10
- };
-
- //reference to settings
- this.settings = {};
- for (var i in this.defaults) {
- if (this.defaults.hasOwnProperty(i)) {
- if (settings[i] !== void 0) {
- this.settings[i] = settings[i];
- }
- else if (this.defaults[i] === void 0) {
- throw new Error('A required setting "' + i + '" was not provided');
- }
- else {
- this.settings[i] = this.defaults[i];
- }
- }
- }
-}
-
-/**
- * generic methods
- */
-
-WalkontableSettings.prototype.update = function (settings, value) {
- if (value === void 0) { //settings is object
- for (var i in settings) {
- if (settings.hasOwnProperty(i)) {
- this.settings[i] = settings[i];
- }
- }
- }
- else { //if value is defined then settings is the key
- this.settings[settings] = value;
- }
- return this.instance;
-};
-
-WalkontableSettings.prototype.getSetting = function (key, param1, param2, param3) {
- if (this[key]) {
- return this[key](param1, param2, param3);
- }
- else {
- return this._getSetting(key, param1, param2, param3);
- }
-};
-
-WalkontableSettings.prototype._getSetting = function (key, param1, param2, param3) {
- if (typeof this.settings[key] === 'function') {
- return this.settings[key](param1, param2, param3);
- }
- else if (param1 !== void 0 && Object.prototype.toString.call(this.settings[key]) === '[object Array]') {
- return this.settings[key][param1];
- }
- else {
- return this.settings[key];
- }
-};
-
-WalkontableSettings.prototype.has = function (key) {
- return !!this.settings[key]
-};
-
-/**
- * specific methods
- */
-WalkontableSettings.prototype.rowHeight = function (row, TD) {
- if (!this.instance.rowHeightCache) {
- this.instance.rowHeightCache = []; //hack. This cache is being invalidated in WOT core.js
- }
- if (this.instance.rowHeightCache[row] === void 0) {
- var size = 23; //guess
- if (TD) {
- size = this.instance.wtDom.outerHeight(TD); //measure
- this.instance.rowHeightCache[row] = size; //cache only something we measured
- }
- return size;
- }
- else {
- return this.instance.rowHeightCache[row];
- }
-};
-function WalkontableTable(instance, table) {
- //reference to instance
- this.instance = instance;
- this.TABLE = table;
- this.wtDom = this.instance.wtDom;
- this.wtDom.removeTextNodes(this.TABLE);
-
- //wtSpreader
- var parent = this.TABLE.parentNode;
- if (!parent || parent.nodeType !== 1 || !this.wtDom.hasClass(parent, 'wtHolder')) {
- var spreader = document.createElement('DIV');
- spreader.className = 'wtSpreader';
- if (parent) {
- parent.insertBefore(spreader, this.TABLE); //if TABLE is detached (e.g. in Jasmine test), it has no parentNode so we cannot attach holder to it
- }
- spreader.appendChild(this.TABLE);
- }
- this.spreader = this.TABLE.parentNode;
-
- //wtHider
- parent = this.spreader.parentNode;
- if (!parent || parent.nodeType !== 1 || !this.wtDom.hasClass(parent, 'wtHolder')) {
- var hider = document.createElement('DIV');
- hider.className = 'wtHider';
- if (parent) {
- parent.insertBefore(hider, this.spreader); //if TABLE is detached (e.g. in Jasmine test), it has no parentNode so we cannot attach holder to it
- }
- hider.appendChild(this.spreader);
- }
- this.hider = this.spreader.parentNode;
- this.hiderStyle = this.hider.style;
- this.hiderStyle.position = 'relative';
-
- //wtHolder
- parent = this.hider.parentNode;
- if (!parent || parent.nodeType !== 1 || !this.wtDom.hasClass(parent, 'wtHolder')) {
- var holder = document.createElement('DIV');
- holder.style.position = 'relative';
- holder.className = 'wtHolder';
- if (parent) {
- parent.insertBefore(holder, this.hider); //if TABLE is detached (e.g. in Jasmine test), it has no parentNode so we cannot attach holder to it
- }
- holder.appendChild(this.hider);
- }
- this.holder = this.hider.parentNode;
-
- //bootstrap from settings
- this.TBODY = this.TABLE.getElementsByTagName('TBODY')[0];
- if (!this.TBODY) {
- this.TBODY = document.createElement('TBODY');
- this.TABLE.appendChild(this.TBODY);
- }
- this.THEAD = this.TABLE.getElementsByTagName('THEAD')[0];
- if (!this.THEAD) {
- this.THEAD = document.createElement('THEAD');
- this.TABLE.insertBefore(this.THEAD, this.TBODY);
- }
- this.COLGROUP = this.TABLE.getElementsByTagName('COLGROUP')[0];
- if (!this.COLGROUP) {
- this.COLGROUP = document.createElement('COLGROUP');
- this.TABLE.insertBefore(this.COLGROUP, this.THEAD);
- }
-
- if (this.instance.getSetting('columnHeaders').length) {
- if (!this.THEAD.childNodes.length) {
- var TR = document.createElement('TR');
- this.THEAD.appendChild(TR);
- }
- }
-
- this.colgroupChildrenLength = this.COLGROUP.childNodes.length;
- this.theadChildrenLength = this.THEAD.firstChild ? this.THEAD.firstChild.childNodes.length : 0;
- this.tbodyChildrenLength = this.TBODY.childNodes.length;
-
- this.oldCellCache = new WalkontableClassNameCache();
- this.currentCellCache = new WalkontableClassNameCache();
-
- this.rowFilter = new WalkontableRowFilter();
- this.columnFilter = new WalkontableColumnFilter();
-
- this.verticalRenderReverse = false;
-}
-
-WalkontableTable.prototype.refreshHiderDimensions = function () {
- var height = this.instance.wtViewport.getWorkspaceHeight();
- var width = this.instance.wtViewport.getWorkspaceWidth();
-
- var spreaderStyle = this.spreader.style;
-
- if ((height !== Infinity || width !== Infinity) && !this.instance.getSetting('nativeScrollbars')) {
- if (height === Infinity) {
- height = this.instance.wtViewport.getWorkspaceActualHeight();
- }
- if (width === Infinity) {
- width = this.instance.wtViewport.getWorkspaceActualWidth();
- }
-
- this.hiderStyle.overflow = 'hidden';
-
- spreaderStyle.position = 'absolute';
- spreaderStyle.top = '0';
- spreaderStyle.left = '0';
-
- if (!this.instance.getSetting('nativeScrollbars')) {
- spreaderStyle.height = '4000px';
- spreaderStyle.width = '4000px';
- }
-
- if (height < 0) { //this happens with WalkontableOverlay and causes "Invalid argument" error in IE8
- height = 0;
- }
-
- this.hiderStyle.height = height + 'px';
- this.hiderStyle.width = width + 'px';
- }
- else {
- spreaderStyle.position = 'relative';
- spreaderStyle.width = 'auto';
- spreaderStyle.height = 'auto';
- }
-};
-
-WalkontableTable.prototype.refreshStretching = function () {
- if (this.instance.cloneSource) {
- return;
- }
-
- var instance = this.instance
- , stretchH = instance.getSetting('stretchH')
- , totalRows = instance.getSetting('totalRows')
- , totalColumns = instance.getSetting('totalColumns')
- , offsetColumn = instance.getSetting('offsetColumn');
-
- var containerWidthFn = function (cacheWidth) {
- var viewportWidth = that.instance.wtViewport.getViewportWidth(cacheWidth);
- if (viewportWidth < cacheWidth && that.instance.getSetting('nativeScrollbars')) {
- return Infinity; //disable stretching when viewport is bigger than sum of the cell widths
- }
- return viewportWidth;
- };
-
- var that = this;
-
- var columnWidthFn = function (i) {
- var source_c = that.columnFilter.visibleToSource(i);
- if (source_c < totalColumns) {
- return instance.getSetting('columnWidth', source_c);
- }
- };
-
- if (stretchH === 'hybrid') {
- if (offsetColumn > 0) {
- stretchH = 'last';
- }
- else {
- stretchH = 'none';
- }
- }
-
- var containerHeightFn = function (cacheHeight) {
- if (that.instance.getSetting('nativeScrollbars')) {
- if (that.instance.cloneOverlay instanceof WalkontableDebugOverlay) {
- return Infinity;
- }
- else {
- return 2 * that.instance.wtViewport.getViewportHeight(cacheHeight);
- }
- }
- return that.instance.wtViewport.getViewportHeight(cacheHeight);
- };
-
- var rowHeightFn = function (i, TD) {
- if (that.instance.getSetting('nativeScrollbars')) {
- return 20;
- }
- var source_r = that.rowFilter.visibleToSource(i);
- if (source_r < totalRows) {
- if (that.verticalRenderReverse && i === 0) {
- return that.instance.getSetting('rowHeight', source_r, TD) - 1;
- }
- else {
- return that.instance.getSetting('rowHeight', source_r, TD);
- }
- }
- };
-
- this.columnStrategy = new WalkontableColumnStrategy(instance, containerWidthFn, columnWidthFn, stretchH);
- this.rowStrategy = new WalkontableRowStrategy(instance, containerHeightFn, rowHeightFn);
-};
-
-WalkontableTable.prototype.adjustAvailableNodes = function () {
- var displayTds
- , rowHeaders = this.instance.getSetting('rowHeaders')
- , displayThs = rowHeaders.length
- , columnHeaders = this.instance.getSetting('columnHeaders')
- , TR
- , TD
- , c;
-
- //adjust COLGROUP
- while (this.colgroupChildrenLength < displayThs) {
- this.COLGROUP.appendChild(document.createElement('COL'));
- this.colgroupChildrenLength++;
- }
-
- this.refreshStretching(); //actually it is wrong position because it assumes rowHeader would be always 50px wide (because we measure before it is filled with text). TODO: debug
- if (this.instance.cloneSource && (this.instance.cloneOverlay instanceof WalkontableHorizontalScrollbarNative || this.instance.cloneOverlay instanceof WalkontableCornerScrollbarNative)) {
- displayTds = this.instance.getSetting('fixedColumnsLeft');
- }
- else {
- displayTds = this.columnStrategy.cellCount;
- }
-
- //adjust COLGROUP
- while (this.colgroupChildrenLength < displayTds + displayThs) {
- this.COLGROUP.appendChild(document.createElement('COL'));
- this.colgroupChildrenLength++;
- }
- while (this.colgroupChildrenLength > displayTds + displayThs) {
- this.COLGROUP.removeChild(this.COLGROUP.lastChild);
- this.colgroupChildrenLength--;
- }
-
- //adjust THEAD
- TR = this.THEAD.firstChild;
- if (columnHeaders.length) {
- if (!TR) {
- TR = document.createElement('TR');
- this.THEAD.appendChild(TR);
- }
-
- this.theadChildrenLength = TR.childNodes.length;
- while (this.theadChildrenLength < displayTds + displayThs) {
- TR.appendChild(document.createElement('TH'));
- this.theadChildrenLength++;
- }
- while (this.theadChildrenLength > displayTds + displayThs) {
- TR.removeChild(TR.lastChild);
- this.theadChildrenLength--;
- }
- }
- else if (TR) {
- this.wtDom.empty(TR);
- }
-
- //draw COLGROUP
- for (c = 0; c < this.colgroupChildrenLength; c++) {
- if (c < displayThs) {
- this.wtDom.addClass(this.COLGROUP.childNodes[c], 'rowHeader');
- }
- else {
- this.wtDom.removeClass(this.COLGROUP.childNodes[c], 'rowHeader');
- }
- }
-
- //draw THEAD
- if (columnHeaders.length) {
- TR = this.THEAD.firstChild;
- if (displayThs) {
- TD = TR.firstChild; //actually it is TH but let's reuse single variable
- for (c = 0; c < displayThs; c++) {
- rowHeaders[c](-displayThs + c, TD);
- TD = TD.nextSibling;
- }
- }
- }
-
- for (c = 0; c < displayTds; c++) {
- if (columnHeaders.length) {
- columnHeaders[0](this.columnFilter.visibleToSource(c), TR.childNodes[displayThs + c]);
- }
- }
-};
-
-WalkontableTable.prototype.adjustColumns = function (TR, desiredCount) {
- var count = TR.childNodes.length;
- while (count < desiredCount) {
- var TD = document.createElement('TD');
- TR.appendChild(TD);
- count++;
- }
- while (count > desiredCount) {
- TR.removeChild(TR.lastChild);
- count--;
- }
-};
-
-WalkontableTable.prototype.draw = function (selectionsOnly) {
- if (this.instance.getSetting('nativeScrollbars')) {
- this.verticalRenderReverse = false; //this is only supported in dragdealer mode, not in native
- }
-
- this.rowFilter.readSettings(this.instance);
- this.columnFilter.readSettings(this.instance);
-
- if (!selectionsOnly) {
- if (this.instance.getSetting('nativeScrollbars')) {
- if (this.instance.cloneSource) {
- this.tableOffset = this.instance.cloneSource.wtTable.tableOffset;
- }
- else {
- this.holderOffset = this.wtDom.offset(this.holder);
- this.tableOffset = this.wtDom.offset(this.TABLE);
- this.instance.wtScrollbars.vertical.readWindowSize();
- this.instance.wtScrollbars.horizontal.readWindowSize();
- this.instance.wtViewport.resetSettings();
- }
- }
- else {
- this.tableOffset = this.wtDom.offset(this.TABLE);
- this.instance.wtViewport.resetSettings();
- }
- this._doDraw();
- }
- else {
- this.instance.wtScrollbars && this.instance.wtScrollbars.refresh(true);
- }
-
- this.refreshPositions(selectionsOnly);
-
- if (!selectionsOnly) {
- if (this.instance.getSetting('nativeScrollbars')) {
- if (!this.instance.cloneSource) {
- this.instance.wtScrollbars.vertical.resetFixedPosition();
- this.instance.wtScrollbars.horizontal.resetFixedPosition();
- this.instance.wtScrollbars.corner.resetFixedPosition();
- this.instance.wtScrollbars.debug && this.instance.wtScrollbars.debug.resetFixedPosition();
- }
- }
- }
-
- this.instance.drawn = true;
- return this;
-};
-
-WalkontableTable.prototype._doDraw = function () {
- var r = 0
- , source_r
- , c
- , source_c
- , offsetRow = this.instance.getSetting('offsetRow')
- , totalRows = this.instance.getSetting('totalRows')
- , totalColumns = this.instance.getSetting('totalColumns')
- , displayTds
- , rowHeaders = this.instance.getSetting('rowHeaders')
- , displayThs = rowHeaders.length
- , TR
- , TD
- , TH
- , adjusted = false
- , workspaceWidth
- , mustBeInViewport
- , res;
-
- if (this.verticalRenderReverse) {
- mustBeInViewport = offsetRow;
- }
-
- var noPartial = false;
- if (this.verticalRenderReverse) {
- if (offsetRow === totalRows - this.rowFilter.fixedCount - 1) {
- noPartial = true;
- }
- else {
- this.instance.update('offsetRow', offsetRow + 1); //if we are scrolling reverse
- this.rowFilter.readSettings(this.instance);
- }
- }
-
- if (this.instance.cloneSource) {
- this.columnStrategy = this.instance.cloneSource.wtTable.columnStrategy;
- this.rowStrategy = this.instance.cloneSource.wtTable.rowStrategy;
- }
-
- //draw TBODY
- if (totalColumns > 0) {
- source_r = this.rowFilter.visibleToSource(r);
-
- var fixedRowsTop = this.instance.getSetting('fixedRowsTop');
- var cloneLimit;
- if (this.instance.cloneSource) { //must be run after adjustAvailableNodes because otherwise this.rowStrategy is not yet defined
- if (this.instance.cloneOverlay instanceof WalkontableVerticalScrollbarNative || this.instance.cloneOverlay instanceof WalkontableCornerScrollbarNative) {
- cloneLimit = fixedRowsTop;
- }
- else if (this.instance.cloneOverlay instanceof WalkontableHorizontalScrollbarNative) {
- cloneLimit = this.rowStrategy.countVisible();
- }
- //else if WalkontableDebugOverlay do nothing. No cloneLimit means render ALL rows
- }
-
- this.adjustAvailableNodes();
- adjusted = true;
-
- if (this.instance.cloneSource && (this.instance.cloneOverlay instanceof WalkontableHorizontalScrollbarNative || this.instance.cloneOverlay instanceof WalkontableCornerScrollbarNative)) {
- displayTds = this.instance.getSetting('fixedColumnsLeft');
- }
- else {
- displayTds = this.columnStrategy.cellCount;
- }
-
- if (!this.instance.cloneSource) {
- workspaceWidth = this.instance.wtViewport.getWorkspaceWidth();
- this.columnStrategy.stretch();
- }
-
- for (c = 0; c < displayTds; c++) {
- this.COLGROUP.childNodes[c + displayThs].style.width = this.columnStrategy.getSize(c) + 'px';
- }
-
- while (source_r < totalRows && source_r >= 0) {
- if (r > 1000) {
- throw new Error('Security brake: Too much TRs. Please define height for your table, which will enforce scrollbars.');
- }
-
- if (cloneLimit !== void 0 && r === cloneLimit) {
- break; //we have as much rows as needed for this clone
- }
-
- if (r >= this.tbodyChildrenLength || (this.verticalRenderReverse && r >= this.rowFilter.fixedCount)) {
- TR = document.createElement('TR');
- for (c = 0; c < displayThs; c++) {
- TR.appendChild(document.createElement('TH'));
- }
- if (this.verticalRenderReverse && r >= this.rowFilter.fixedCount) {
- this.TBODY.insertBefore(TR, this.TBODY.childNodes[this.rowFilter.fixedCount] || this.TBODY.firstChild);
- }
- else {
- this.TBODY.appendChild(TR);
- }
- this.tbodyChildrenLength++;
- }
- else if (r === 0) {
- TR = this.TBODY.firstChild;
- }
- else {
- TR = TR.nextSibling; //http://jsperf.com/nextsibling-vs-indexed-childnodes
- }
-
- //TH
- TH = TR.firstChild;
- for (c = 0; c < displayThs; c++) {
-
- //If the number of row headers increased we need to replace TD with TH
- if (TH.nodeName == 'TD') {
- TD = TH;
- TH = document.createElement('TH');
- TR.insertBefore(TH, TD);
- TR.removeChild(TD);
- }
-
- rowHeaders[c](source_r, TH); //actually TH
- TH = TH.nextSibling; //http://jsperf.com/nextsibling-vs-indexed-childnodes
- }
-
- this.adjustColumns(TR, displayTds + displayThs);
-
- for (c = 0; c < displayTds; c++) {
- source_c = this.columnFilter.visibleToSource(c);
- if (c === 0) {
- TD = TR.childNodes[this.columnFilter.sourceColumnToVisibleRowHeadedColumn(source_c)];
- }
- else {
- TD = TD.nextSibling; //http://jsperf.com/nextsibling-vs-indexed-childnodes
- }
-
- //If the number of headers has been reduced, we need to replace excess TH with TD
- if (TD.nodeName == 'TH') {
- TH = TD;
- TD = document.createElement('TD');
- TR.insertBefore(TD, TH);
- TR.removeChild(TH);
- }
-
- TD.className = '';
- TD.removeAttribute('style');
- this.instance.getSetting('cellRenderer', source_r, source_c, TD);
- }
-
- offsetRow = this.instance.getSetting('offsetRow'); //refresh the value
-
- //after last column is rendered, check if last cell is fully displayed
- if (this.verticalRenderReverse && noPartial) {
- if (-this.wtDom.outerHeight(TR.firstChild) < this.rowStrategy.remainingSize) {
- this.TBODY.removeChild(TR);
- this.instance.update('offsetRow', offsetRow + 1);
- this.tbodyChildrenLength--;
- this.rowFilter.readSettings(this.instance);
- break;
-
- }
- else if (!this.instance.cloneSource) {
- res = this.rowStrategy.add(r, TD, this.verticalRenderReverse);
- if (res === false) {
- this.rowStrategy.removeOutstanding();
- }
- }
- }
- else if (!this.instance.cloneSource) {
- res = this.rowStrategy.add(r, TD, this.verticalRenderReverse);
-
- if (res === false) {
- if (!this.instance.getSetting('nativeScrollbars')) {
- this.rowStrategy.removeOutstanding();
- }
- }
-
- if (this.rowStrategy.isLastIncomplete()) {
- if (this.verticalRenderReverse && !this.isRowInViewport(mustBeInViewport)) {
- //we failed because one of the cells was by far too large. Recover by rendering from top
- this.verticalRenderReverse = false;
- this.instance.update('offsetRow', mustBeInViewport);
- this.draw();
- return;
- }
- break;
- }
- }
-
- if (this.instance.getSetting('nativeScrollbars')) {
- if (this.instance.cloneSource) {
- TR.style.height = this.instance.getSetting('rowHeight', source_r) + 'px'; //if I have 2 fixed columns with one-line content and the 3rd column has a multiline content, this is the way to make sure that the overlay will has same row height
- }
- else {
- this.instance.getSetting('rowHeight', source_r, TD); //this trick saves rowHeight in rowHeightCache. It is then read in WalkontableVerticalScrollbarNative.prototype.sumCellSizes and reset in Walkontable constructor
- }
- }
-
- if (this.verticalRenderReverse && r >= this.rowFilter.fixedCount) {
- if (offsetRow === 0) {
- break;
- }
- this.instance.update('offsetRow', offsetRow - 1);
- this.rowFilter.readSettings(this.instance);
- }
- else {
- r++;
- }
-
- source_r = this.rowFilter.visibleToSource(r);
- }
- }
-
- if (!adjusted) {
- this.adjustAvailableNodes();
- }
-
- if (!(this.instance.cloneOverlay instanceof WalkontableDebugOverlay)) {
- r = this.rowStrategy.countVisible();
- while (this.tbodyChildrenLength > r) {
- this.TBODY.removeChild(this.TBODY.lastChild);
- this.tbodyChildrenLength--;
- }
- }
-
- this.instance.wtScrollbars && this.instance.wtScrollbars.refresh(false);
-
- if (!this.instance.cloneSource) {
- if (workspaceWidth !== this.instance.wtViewport.getWorkspaceWidth()) {
- //workspace width changed though to shown/hidden vertical scrollbar. Let's reapply stretching
- this.columnStrategy.stretch();
- for (c = 0; c < this.columnStrategy.cellCount; c++) {
- this.COLGROUP.childNodes[c + displayThs].style.width = this.columnStrategy.getSize(c) + 'px';
- }
- }
- }
-
- this.verticalRenderReverse = false;
-};
-
-WalkontableTable.prototype.refreshPositions = function (selectionsOnly) {
- this.refreshHiderDimensions();
- this.refreshSelections(selectionsOnly);
-};
-
-WalkontableTable.prototype.refreshSelections = function (selectionsOnly) {
- var vr
- , r
- , vc
- , c
- , s
- , slen
- , classNames = []
- , visibleRows = this.rowStrategy.countVisible()
- , visibleColumns = this.columnStrategy.countVisible();
-
- this.oldCellCache = this.currentCellCache;
- this.currentCellCache = new WalkontableClassNameCache();
-
- if (this.instance.selections) {
- for (r in this.instance.selections) {
- if (this.instance.selections.hasOwnProperty(r)) {
- this.instance.selections[r].draw();
- if (this.instance.selections[r].settings.className) {
- classNames.push(this.instance.selections[r].settings.className);
- }
- if (this.instance.selections[r].settings.highlightRowClassName) {
- classNames.push(this.instance.selections[r].settings.highlightRowClassName);
- }
- if (this.instance.selections[r].settings.highlightColumnClassName) {
- classNames.push(this.instance.selections[r].settings.highlightColumnClassName);
- }
- }
- }
- }
-
- slen = classNames.length;
-
- for (vr = 0; vr < visibleRows; vr++) {
- for (vc = 0; vc < visibleColumns; vc++) {
- r = this.rowFilter.visibleToSource(vr);
- c = this.columnFilter.visibleToSource(vc);
- for (s = 0; s < slen; s++) {
- if (this.currentCellCache.test(vr, vc, classNames[s])) {
- this.wtDom.addClass(this.getCell([r, c]), classNames[s]);
- }
- else if (selectionsOnly && this.oldCellCache.test(vr, vc, classNames[s])) {
- this.wtDom.removeClass(this.getCell([r, c]), classNames[s]);
- }
- }
- }
- }
-};
-
-/**
- * getCell
- * @param {Array} coords
- * @return {Object} HTMLElement on success or {Number} one of the exit codes on error:
- * -1 row before viewport
- * -2 row after viewport
- * -3 column before viewport
- * -4 column after viewport
- *
- */
-WalkontableTable.prototype.getCell = function (coords) {
- if (this.isRowBeforeViewport(coords[0])) {
- return -1; //row before viewport
- }
- else if (this.isRowAfterViewport(coords[0])) {
- return -2; //row after viewport
- }
- else {
- if (this.isColumnBeforeViewport(coords[1])) {
- return -3; //column before viewport
- }
- else if (this.isColumnAfterViewport(coords[1])) {
- return -4; //column after viewport
- }
- else {
- return this.TBODY.childNodes[this.rowFilter.sourceToVisible(coords[0])].childNodes[this.columnFilter.sourceColumnToVisibleRowHeadedColumn(coords[1])];
- }
- }
-};
-
-WalkontableTable.prototype.getCoords = function (TD) {
- return [
- this.rowFilter.visibleToSource(this.wtDom.index(TD.parentNode)),
- this.columnFilter.visibleRowHeadedColumnToSourceColumn(TD.cellIndex)
- ];
-};
-
-//returns -1 if no row is visible
-WalkontableTable.prototype.getLastVisibleRow = function () {
- return this.rowFilter.visibleToSource(this.rowStrategy.cellCount - 1);
-};
-
-//returns -1 if no column is visible
-WalkontableTable.prototype.getLastVisibleColumn = function () {
- return this.columnFilter.visibleToSource(this.columnStrategy.cellCount - 1);
-};
-
-WalkontableTable.prototype.isRowBeforeViewport = function (r) {
- return (this.rowFilter.sourceToVisible(r) < this.rowFilter.fixedCount && r >= this.rowFilter.fixedCount);
-};
-
-WalkontableTable.prototype.isRowAfterViewport = function (r) {
- return (r > this.getLastVisibleRow());
-};
-
-WalkontableTable.prototype.isColumnBeforeViewport = function (c) {
- return (this.columnFilter.sourceToVisible(c) < this.columnFilter.fixedCount && c >= this.columnFilter.fixedCount);
-};
-
-WalkontableTable.prototype.isColumnAfterViewport = function (c) {
- return (c > this.getLastVisibleColumn());
-};
-
-WalkontableTable.prototype.isRowInViewport = function (r) {
- return (!this.isRowBeforeViewport(r) && !this.isRowAfterViewport(r));
-};
-
-WalkontableTable.prototype.isColumnInViewport = function (c) {
- return (!this.isColumnBeforeViewport(c) && !this.isColumnAfterViewport(c));
-};
-
-WalkontableTable.prototype.isLastRowFullyVisible = function () {
- return (this.getLastVisibleRow() === this.instance.getSetting('totalRows') - 1 && !this.rowStrategy.isLastIncomplete());
-};
-
-WalkontableTable.prototype.isLastColumnFullyVisible = function () {
- return (this.getLastVisibleColumn() === this.instance.getSetting('totalColumns') - 1 && !this.columnStrategy.isLastIncomplete());
-};
-
-function WalkontableViewport(instance) {
- this.instance = instance;
- this.resetSettings();
-
- if (this.instance.getSetting('nativeScrollbars')) {
- var that = this;
- $(window).on('resize', function () {
- that.clientHeight = that.getWorkspaceHeight();
- });
- }
-}
-
-/*WalkontableViewport.prototype.isInSightVertical = function () {
- //is table outside viewport bottom edge
- if (tableTop > windowHeight + scrollTop) {
- return -1;
- }
-
- //is table outside viewport top edge
- else if (scrollTop > tableTop + tableFakeHeight) {
- return -2;
- }
-
- //table is in viewport but how much exactly?
- else {
-
- }
-};*/
-
-//used by scrollbar
-WalkontableViewport.prototype.getWorkspaceHeight = function (proposedHeight) {
- if (this.instance.getSetting('nativeScrollbars')) {
- return this.instance.wtScrollbars.vertical.windowSize;
- }
-
- var height = this.instance.getSetting('height');
-
- if (height === Infinity || height === void 0 || height === null || height < 1) {
- if (this.instance.wtScrollbars.vertical instanceof WalkontableOverlay) {
- height = this.instance.wtScrollbars.vertical.availableSize();
- }
- else {
- height = Infinity;
- }
- }
-
- if (height !== Infinity) {
- if (proposedHeight >= height) {
- height -= this.instance.getSetting('scrollbarHeight');
- }
- else if (this.instance.wtScrollbars.horizontal.visible) {
- height -= this.instance.getSetting('scrollbarHeight');
- }
- }
-
- return height;
-};
-
-WalkontableViewport.prototype.getWorkspaceWidth = function (proposedWidth) {
- var width = this.instance.getSetting('width');
-
- if (width === Infinity || width === void 0 || width === null || width < 1) {
- if (this.instance.wtScrollbars.horizontal instanceof WalkontableOverlay) {
- width = this.instance.wtScrollbars.horizontal.availableSize();
- }
- else {
- width = Infinity;
- }
- }
-
- if (width !== Infinity) {
- if (proposedWidth >= width) {
- width -= this.instance.getSetting('scrollbarWidth');
- }
- else if (this.instance.wtScrollbars.vertical.visible) {
- width -= this.instance.getSetting('scrollbarWidth');
- }
- }
- return width;
-};
-
-WalkontableViewport.prototype.getWorkspaceActualHeight = function () {
- return this.instance.wtDom.outerHeight(this.instance.wtTable.TABLE);
-};
-
-WalkontableViewport.prototype.getWorkspaceActualWidth = function () {
- return this.instance.wtDom.outerWidth(this.instance.wtTable.TABLE) || this.instance.wtDom.outerWidth(this.instance.wtTable.TBODY) || this.instance.wtDom.outerWidth(this.instance.wtTable.THEAD); //IE8 reports 0 as offsetWidth;
-};
-
-WalkontableViewport.prototype.getColumnHeaderHeight = function () {
- if (isNaN(this.columnHeaderHeight)) {
- var cellOffset = this.instance.wtDom.offset(this.instance.wtTable.TBODY)
- , tableOffset = this.instance.wtTable.tableOffset;
- this.columnHeaderHeight = cellOffset.top - tableOffset.top;
- }
- return this.columnHeaderHeight;
-};
-
-WalkontableViewport.prototype.getViewportHeight = function (proposedHeight) {
- var containerHeight = this.getWorkspaceHeight(proposedHeight);
-
- if (containerHeight === Infinity) {
- return containerHeight;
- }
-
- var columnHeaderHeight = this.getColumnHeaderHeight();
- if (columnHeaderHeight > 0) {
- return containerHeight - columnHeaderHeight;
- }
- else {
- return containerHeight;
- }
-};
-
-WalkontableViewport.prototype.getRowHeaderWidth = function () {
- if (this.instance.cloneSource) {
- return this.instance.cloneSource.wtViewport.getRowHeaderWidth();
- }
- if (isNaN(this.rowHeaderWidth)) {
- var rowHeaders = this.instance.getSetting('rowHeaders');
- if (rowHeaders.length) {
- var TH = this.instance.wtTable.TABLE.querySelector('TH');
- this.rowHeaderWidth = 0;
- for (var i = 0, ilen = rowHeaders.length; i < ilen; i++) {
- if (TH) {
- this.rowHeaderWidth += this.instance.wtDom.outerWidth(TH);
- TH = TH.nextSibling;
- }
- else {
- this.rowHeaderWidth += 50; //yes this is a cheat but it worked like that before, just taking assumption from CSS instead of measuring. TODO: proper fix
- }
- }
- }
- else {
- this.rowHeaderWidth = 0;
- }
- }
- return this.rowHeaderWidth;
-};
-
-WalkontableViewport.prototype.getViewportWidth = function (proposedWidth) {
- var containerWidth = this.getWorkspaceWidth(proposedWidth);
-
- if (containerWidth === Infinity) {
- return containerWidth;
- }
-
- var rowHeaderWidth = this.getRowHeaderWidth();
- if (rowHeaderWidth > 0) {
- return containerWidth - rowHeaderWidth;
- }
- else {
- return containerWidth;
- }
-};
-
-WalkontableViewport.prototype.resetSettings = function () {
- this.rowHeaderWidth = NaN;
- this.columnHeaderHeight = NaN;
-};
-function WalkontableWheel(instance) {
- if (instance.getSetting('nativeScrollbars')) {
- return;
- }
-
- //spreader === instance.wtTable.TABLE.parentNode
- $(instance.wtTable.spreader).on('mousewheel', function (event, delta, deltaX, deltaY) {
- if (!deltaX && !deltaY && delta) { //we are in IE8, see https://github.com/brandonaaron/jquery-mousewheel/issues/53
- deltaY = delta;
- }
-
- if (!deltaX && !deltaY) { //this happens in IE8 test case
- return;
- }
-
- if (deltaY > 0 && instance.getSetting('offsetRow') === 0) {
- return; //attempt to scroll up when it's already showing first row
- }
- else if (deltaY < 0 && instance.wtTable.isLastRowFullyVisible()) {
- return; //attempt to scroll down when it's already showing last row
- }
- else if (deltaX < 0 && instance.getSetting('offsetColumn') === 0) {
- return; //attempt to scroll left when it's already showing first column
- }
- else if (deltaX > 0 && instance.wtTable.isLastColumnFullyVisible()) {
- return; //attempt to scroll right when it's already showing last column
- }
-
- //now we are sure we really want to scroll
- clearTimeout(instance.wheelTimeout);
- instance.wheelTimeout = setTimeout(function () { //timeout is needed because with fast-wheel scrolling mousewheel event comes dozen times per second
- if (deltaY) {
- //ceil is needed because jquery-mousewheel reports fractional mousewheel deltas on touchpad scroll
- //see http://stackoverflow.com/questions/5527601/normalizing-mousewheel-speed-across-browsers
- if (instance.wtScrollbars.vertical.visible) { // if we see scrollbar
- instance.scrollVertical(-Math.ceil(deltaY)).draw();
- }
- }
- else if (deltaX) {
- if (instance.wtScrollbars.horizontal.visible) { // if we see scrollbar
- instance.scrollHorizontal(Math.ceil(deltaX)).draw();
- }
- }
- }, 0);
-
- event.preventDefault();
- });
-}
-/**
- * Dragdealer JS v0.9.5 - patched by Walkontable at lines 66, 309-310, 339-340
- * http://code.ovidiu.ch/dragdealer-js
- *
- * Copyright (c) 2010, Ovidiu Chereches
- * MIT License
- * http://legal.ovidiu.ch/licenses/MIT
- */
-
-/* Cursor */
-
-var Cursor =
-{
- x: 0, y: 0,
- init: function()
- {
- this.setEvent('mouse');
- this.setEvent('touch');
- },
- setEvent: function(type)
- {
- var moveHandler = document['on' + type + 'move'] || function(){};
- document['on' + type + 'move'] = function(e)
- {
- moveHandler(e);
- Cursor.refresh(e);
- }
- },
- refresh: function(e)
- {
- if(!e)
- {
- e = window.event;
- }
- if(e.type == 'mousemove')
- {
- this.set(e);
- }
- else if(e.touches)
- {
- this.set(e.touches[0]);
- }
- },
- set: function(e)
- {
- if(e.pageX || e.pageY)
- {
- this.x = e.pageX;
- this.y = e.pageY;
- }
- else if(document.body && (e.clientX || e.clientY)) //need to check whether body exists, because of IE8 issue (#1084)
- {
- this.x = e.clientX + document.body.scrollLeft + document.documentElement.scrollLeft;
- this.y = e.clientY + document.body.scrollTop + document.documentElement.scrollTop;
- }
- }
-};
-Cursor.init();
-
-/* Position */
-
-var Position =
-{
- get: function(obj)
- {
- var curtop = 0, curleft = 0; //Walkontable patch. Original (var curleft = curtop = 0;) created curtop in global scope
- if(obj.offsetParent)
- {
- do
- {
- curleft += obj.offsetLeft;
- curtop += obj.offsetTop;
- }
- while((obj = obj.offsetParent));
- }
- return [curleft, curtop];
- }
-};
-
-/* Dragdealer */
-
-var Dragdealer = function(wrapper, options)
-{
- if(typeof(wrapper) == 'string')
- {
- wrapper = document.getElementById(wrapper);
- }
- if(!wrapper)
- {
- return;
- }
- var handle = wrapper.getElementsByTagName('div')[0];
- if(!handle || handle.className.search(/(^|\s)handle(\s|$)/) == -1)
- {
- return;
- }
- this.init(wrapper, handle, options || {});
- this.setup();
-};
-Dragdealer.prototype =
-{
- init: function(wrapper, handle, options)
- {
- this.wrapper = wrapper;
- this.handle = handle;
- this.options = options;
-
- this.disabled = this.getOption('disabled', false);
- this.horizontal = this.getOption('horizontal', true);
- this.vertical = this.getOption('vertical', false);
- this.slide = this.getOption('slide', true);
- this.steps = this.getOption('steps', 0);
- this.snap = this.getOption('snap', false);
- this.loose = this.getOption('loose', false);
- this.speed = this.getOption('speed', 10) / 100;
- this.xPrecision = this.getOption('xPrecision', 0);
- this.yPrecision = this.getOption('yPrecision', 0);
-
- this.callback = options.callback || null;
- this.animationCallback = options.animationCallback || null;
-
- this.bounds = {
- left: options.left || 0, right: -(options.right || 0),
- top: options.top || 0, bottom: -(options.bottom || 0),
- x0: 0, x1: 0, xRange: 0,
- y0: 0, y1: 0, yRange: 0
- };
- this.value = {
- prev: [-1, -1],
- current: [options.x || 0, options.y || 0],
- target: [options.x || 0, options.y || 0]
- };
- this.offset = {
- wrapper: [0, 0],
- mouse: [0, 0],
- prev: [-999999, -999999],
- current: [0, 0],
- target: [0, 0]
- };
- this.change = [0, 0];
-
- this.activity = false;
- this.dragging = false;
- this.tapping = false;
- },
- getOption: function(name, defaultValue)
- {
- return this.options[name] !== undefined ? this.options[name] : defaultValue;
- },
- setup: function()
- {
- this.setWrapperOffset();
- this.setBoundsPadding();
- this.setBounds();
- this.setSteps();
-
- this.addListeners();
- },
- setWrapperOffset: function()
- {
- this.offset.wrapper = Position.get(this.wrapper);
- },
- setBoundsPadding: function()
- {
- if(!this.bounds.left && !this.bounds.right)
- {
- this.bounds.left = Position.get(this.handle)[0] - this.offset.wrapper[0];
- this.bounds.right = -this.bounds.left;
- }
- if(!this.bounds.top && !this.bounds.bottom)
- {
- this.bounds.top = Position.get(this.handle)[1] - this.offset.wrapper[1];
- this.bounds.bottom = -this.bounds.top;
- }
- },
- setBounds: function()
- {
- this.bounds.x0 = this.bounds.left;
- this.bounds.x1 = this.wrapper.offsetWidth + this.bounds.right;
- this.bounds.xRange = (this.bounds.x1 - this.bounds.x0) - this.handle.offsetWidth;
-
- this.bounds.y0 = this.bounds.top;
- this.bounds.y1 = this.wrapper.offsetHeight + this.bounds.bottom;
- this.bounds.yRange = (this.bounds.y1 - this.bounds.y0) - this.handle.offsetHeight;
-
- this.bounds.xStep = 1 / (this.xPrecision || Math.max(this.wrapper.offsetWidth, this.handle.offsetWidth));
- this.bounds.yStep = 1 / (this.yPrecision || Math.max(this.wrapper.offsetHeight, this.handle.offsetHeight));
- },
- setSteps: function()
- {
- if(this.steps > 1)
- {
- this.stepRatios = [];
- for(var i = 0; i <= this.steps - 1; i++)
- {
- this.stepRatios[i] = i / (this.steps - 1);
- }
- }
- },
- addListeners: function()
- {
- var self = this;
-
- this.wrapper.onselectstart = function()
- {
- return false;
- };
- this.handle.onmousedown = this.handle.ontouchstart = function(e)
- {
- self.handleDownHandler(e);
- };
- this.wrapper.onmousedown = this.wrapper.ontouchstart = function(e)
- {
- self.wrapperDownHandler(e);
- };
- var mouseUpHandler = document.onmouseup || function(){};
- document.onmouseup = function(e)
- {
- mouseUpHandler(e);
- self.documentUpHandler(e);
- };
- var touchEndHandler = document.ontouchend || function(){};
- document.ontouchend = function(e)
- {
- touchEndHandler(e);
- self.documentUpHandler(e);
- };
- var resizeHandler = window.onresize || function(){};
- window.onresize = function(e)
- {
- resizeHandler(e);
- self.documentResizeHandler(e);
- };
- this.wrapper.onmousemove = function(e)
- {
- self.activity = true;
- };
- this.wrapper.onclick = function(e)
- {
- return !self.activity;
- };
-
- this.interval = setInterval(function(){ self.animate() }, 25);
- self.animate(false, true);
- },
- handleDownHandler: function(e)
- {
- this.activity = false;
- Cursor.refresh(e);
-
- this.preventDefaults(e, true);
- this.startDrag();
- },
- wrapperDownHandler: function(e)
- {
- Cursor.refresh(e);
-
- this.preventDefaults(e, true);
- this.startTap();
- },
- documentUpHandler: function(e)
- {
- this.stopDrag();
- this.stopTap();
- },
- documentResizeHandler: function(e)
- {
- this.setWrapperOffset();
- this.setBounds();
-
- this.update();
- },
- enable: function()
- {
- this.disabled = false;
- this.handle.className = this.handle.className.replace(/\s?disabled/g, '');
- },
- disable: function()
- {
- this.disabled = true;
- this.handle.className += ' disabled';
- },
- setStep: function(x, y, snap)
- {
- this.setValue(
- this.steps && x > 1 ? (x - 1) / (this.steps - 1) : 0,
- this.steps && y > 1 ? (y - 1) / (this.steps - 1) : 0,
- snap
- );
- },
- setValue: function(x, y, snap)
- {
- this.setTargetValue([x, y || 0]);
- if(snap)
- {
- this.groupCopy(this.value.current, this.value.target);
- }
- },
- startTap: function(target)
- {
- if(this.disabled)
- {
- return;
- }
- this.tapping = true;
-
- this.setWrapperOffset();
- this.setBounds();
-
- if(target === undefined)
- {
- target = [
- Cursor.x - this.offset.wrapper[0] - (this.handle.offsetWidth / 2),
- Cursor.y - this.offset.wrapper[1] - (this.handle.offsetHeight / 2)
- ];
- }
- this.setTargetOffset(target);
- },
- stopTap: function()
- {
- if(this.disabled || !this.tapping)
- {
- return;
- }
- this.tapping = false;
-
- this.setTargetValue(this.value.current);
- this.result();
- },
- startDrag: function()
- {
- if(this.disabled)
- {
- return;
- }
-
- this.setWrapperOffset();
- this.setBounds();
-
- this.offset.mouse = [
- Cursor.x - Position.get(this.handle)[0],
- Cursor.y - Position.get(this.handle)[1]
- ];
-
- this.dragging = true;
- },
- stopDrag: function()
- {
- if(this.disabled || !this.dragging)
- {
- return;
- }
- this.dragging = false;
-
- var target = this.groupClone(this.value.current);
- if(this.slide)
- {
- var ratioChange = this.change;
- target[0] += ratioChange[0] * 4;
- target[1] += ratioChange[1] * 4;
- }
- this.setTargetValue(target);
- this.result();
- },
- feedback: function()
- {
- var value = this.value.current;
- if(this.snap && this.steps > 1)
- {
- value = this.getClosestSteps(value);
- }
- if(!this.groupCompare(value, this.value.prev))
- {
- if(typeof(this.animationCallback) == 'function')
- {
- this.animationCallback(value[0], value[1]);
- }
- this.groupCopy(this.value.prev, value);
- }
- },
- result: function()
- {
- if(typeof(this.callback) == 'function')
- {
- this.callback(this.value.target[0], this.value.target[1]);
- }
- },
- animate: function(direct, first)
- {
- if(direct && !this.dragging)
- {
- return;
- }
- if(this.dragging)
- {
- var prevTarget = this.groupClone(this.value.target);
-
- var offset = [
- Cursor.x - this.offset.wrapper[0] - this.offset.mouse[0],
- Cursor.y - this.offset.wrapper[1] - this.offset.mouse[1]
- ];
- this.setTargetOffset(offset, this.loose);
-
- this.change = [
- this.value.target[0] - prevTarget[0],
- this.value.target[1] - prevTarget[1]
- ];
- }
- if(this.dragging || first)
- {
- this.groupCopy(this.value.current, this.value.target);
- }
- if(this.dragging || this.glide() || first)
- {
- this.update();
- this.feedback();
- }
- },
- glide: function()
- {
- var diff = [
- this.value.target[0] - this.value.current[0],
- this.value.target[1] - this.value.current[1]
- ];
- if(!diff[0] && !diff[1])
- {
- return false;
- }
- if(Math.abs(diff[0]) > this.bounds.xStep || Math.abs(diff[1]) > this.bounds.yStep)
- {
- this.value.current[0] += diff[0] * this.speed;
- this.value.current[1] += diff[1] * this.speed;
- }
- else
- {
- this.groupCopy(this.value.current, this.value.target);
- }
- return true;
- },
- update: function()
- {
- if(!this.snap)
- {
- this.offset.current = this.getOffsetsByRatios(this.value.current);
- }
- else
- {
- this.offset.current = this.getOffsetsByRatios(
- this.getClosestSteps(this.value.current)
- );
- }
- this.show();
- },
- show: function()
- {
- if(!this.groupCompare(this.offset.current, this.offset.prev))
- {
- if(this.horizontal)
- {
- this.handle.style.left = String(this.offset.current[0]) + 'px';
- }
- if(this.vertical)
- {
- this.handle.style.top = String(this.offset.current[1]) + 'px';
- }
- this.groupCopy(this.offset.prev, this.offset.current);
- }
- },
- setTargetValue: function(value, loose)
- {
- var target = loose ? this.getLooseValue(value) : this.getProperValue(value);
-
- this.groupCopy(this.value.target, target);
- this.offset.target = this.getOffsetsByRatios(target);
- },
- setTargetOffset: function(offset, loose)
- {
- var value = this.getRatiosByOffsets(offset);
- var target = loose ? this.getLooseValue(value) : this.getProperValue(value);
-
- this.groupCopy(this.value.target, target);
- this.offset.target = this.getOffsetsByRatios(target);
- },
- getLooseValue: function(value)
- {
- var proper = this.getProperValue(value);
- return [
- proper[0] + ((value[0] - proper[0]) / 4),
- proper[1] + ((value[1] - proper[1]) / 4)
- ];
- },
- getProperValue: function(value)
- {
- var proper = this.groupClone(value);
-
- proper[0] = Math.max(proper[0], 0);
- proper[1] = Math.max(proper[1], 0);
- proper[0] = Math.min(proper[0], 1);
- proper[1] = Math.min(proper[1], 1);
-
- if((!this.dragging && !this.tapping) || this.snap)
- {
- if(this.steps > 1)
- {
- proper = this.getClosestSteps(proper);
- }
- }
- return proper;
- },
- getRatiosByOffsets: function(group)
- {
- return [
- this.getRatioByOffset(group[0], this.bounds.xRange, this.bounds.x0),
- this.getRatioByOffset(group[1], this.bounds.yRange, this.bounds.y0)
- ];
- },
- getRatioByOffset: function(offset, range, padding)
- {
- return range ? (offset - padding) / range : 0;
- },
- getOffsetsByRatios: function(group)
- {
- return [
- this.getOffsetByRatio(group[0], this.bounds.xRange, this.bounds.x0),
- this.getOffsetByRatio(group[1], this.bounds.yRange, this.bounds.y0)
- ];
- },
- getOffsetByRatio: function(ratio, range, padding)
- {
- return Math.round(ratio * range) + padding;
- },
- getClosestSteps: function(group)
- {
- return [
- this.getClosestStep(group[0]),
- this.getClosestStep(group[1])
- ];
- },
- getClosestStep: function(value)
- {
- var k = 0;
- var min = 1;
- for(var i = 0; i <= this.steps - 1; i++)
- {
- if(Math.abs(this.stepRatios[i] - value) < min)
- {
- min = Math.abs(this.stepRatios[i] - value);
- k = i;
- }
- }
- return this.stepRatios[k];
- },
- groupCompare: function(a, b)
- {
- return a[0] == b[0] && a[1] == b[1];
- },
- groupCopy: function(a, b)
- {
- a[0] = b[0];
- a[1] = b[1];
- },
- groupClone: function(a)
- {
- return [a[0], a[1]];
- },
- preventDefaults: function(e, selection)
- {
- if(!e)
- {
- e = window.event;
- }
- if(e.preventDefault)
- {
- e.preventDefault();
- }
- e.returnValue = false;
-
- if(selection && document.selection)
- {
- document.selection.empty();
- }
- },
- cancelEvent: function(e)
- {
- if(!e)
- {
- e = window.event;
- }
- if(e.stopPropagation)
- {
- e.stopPropagation();
- }
- e.cancelBubble = true;
- }
-};
-
-/*! Copyright (c) 2013 Brandon Aaron (http://brandonaaron.net)
- * Licensed under the MIT License (LICENSE.txt).
- *
- * Thanks to: http://adomas.org/javascript-mouse-wheel/ for some pointers.
- * Thanks to: Mathias Bank(http://www.mathias-bank.de) for a scope bug fix.
- * Thanks to: Seamus Leahy for adding deltaX and deltaY
- *
- * Version: 3.1.3
- *
- * Requires: 1.2.2+
- */
-
-(function (factory) {
- if ( typeof define === 'function' && define.amd ) {
- // AMD. Register as an anonymous module.
- define(['jquery'], factory);
- } else if (typeof exports === 'object') {
- // Node/CommonJS style for Browserify
- module.exports = factory;
- } else {
- // Browser globals
- factory(jQuery);
- }
-}(function ($) {
-
- var toFix = ['wheel', 'mousewheel', 'DOMMouseScroll', 'MozMousePixelScroll'];
- var toBind = 'onwheel' in document || document.documentMode >= 9 ? ['wheel'] : ['mousewheel', 'DomMouseScroll', 'MozMousePixelScroll'];
- var lowestDelta, lowestDeltaXY;
-
- if ( $.event.fixHooks ) {
- for ( var i = toFix.length; i; ) {
- $.event.fixHooks[ toFix[--i] ] = $.event.mouseHooks;
- }
- }
-
- $.event.special.mousewheel = {
- setup: function() {
- if ( this.addEventListener ) {
- for ( var i = toBind.length; i; ) {
- this.addEventListener( toBind[--i], handler, false );
- }
- } else {
- this.onmousewheel = handler;
- }
- },
-
- teardown: function() {
- if ( this.removeEventListener ) {
- for ( var i = toBind.length; i; ) {
- this.removeEventListener( toBind[--i], handler, false );
- }
- } else {
- this.onmousewheel = null;
- }
- }
- };
-
- $.fn.extend({
- mousewheel: function(fn) {
- return fn ? this.bind("mousewheel", fn) : this.trigger("mousewheel");
- },
-
- unmousewheel: function(fn) {
- return this.unbind("mousewheel", fn);
- }
- });
-
-
- function handler(event) {
- var orgEvent = event || window.event,
- args = [].slice.call(arguments, 1),
- delta = 0,
- deltaX = 0,
- deltaY = 0,
- absDelta = 0,
- absDeltaXY = 0,
- fn;
- event = $.event.fix(orgEvent);
- event.type = "mousewheel";
-
- // Old school scrollwheel delta
- if ( orgEvent.wheelDelta ) { delta = orgEvent.wheelDelta; }
- if ( orgEvent.detail ) { delta = orgEvent.detail * -1; }
-
- // New school wheel delta (wheel event)
- if ( orgEvent.deltaY ) {
- deltaY = orgEvent.deltaY * -1;
- delta = deltaY;
- }
- if ( orgEvent.deltaX ) {
- deltaX = orgEvent.deltaX;
- delta = deltaX * -1;
- }
-
- // Webkit
- if ( orgEvent.wheelDeltaY !== undefined ) { deltaY = orgEvent.wheelDeltaY; }
- if ( orgEvent.wheelDeltaX !== undefined ) { deltaX = orgEvent.wheelDeltaX * -1; }
-
- // Look for lowest delta to normalize the delta values
- absDelta = Math.abs(delta);
- if ( !lowestDelta || absDelta < lowestDelta ) { lowestDelta = absDelta; }
- absDeltaXY = Math.max(Math.abs(deltaY), Math.abs(deltaX));
- if ( !lowestDeltaXY || absDeltaXY < lowestDeltaXY ) { lowestDeltaXY = absDeltaXY; }
-
- // Get a whole value for the deltas
- fn = delta > 0 ? 'floor' : 'ceil';
- delta = Math[fn](delta / lowestDelta);
- deltaX = Math[fn](deltaX / lowestDeltaXY);
- deltaY = Math[fn](deltaY / lowestDeltaXY);
-
- // Add event and delta to the front of the arguments
- args.unshift(event, delta, deltaX, deltaY);
-
- return ($.event.dispatch || $.event.handle).apply(this, args);
- }
-
-}));
-
-})(jQuery, window, Handsontable);
-// numeral.js
-// version : 1.4.7
-// author : Adam Draper
-// license : MIT
-// http://adamwdraper.github.com/Numeral-js/
-
-(function () {
-
- /************************************
- Constants
- ************************************/
-
- var numeral,
- VERSION = '1.4.7',
- // internal storage for language config files
- languages = {},
- currentLanguage = 'en',
- zeroFormat = null,
- // check for nodeJS
- hasModule = (typeof module !== 'undefined' && module.exports);
-
-
- /************************************
- Constructors
- ************************************/
-
-
- // Numeral prototype object
- function Numeral (number) {
- this._n = number;
- }
-
- /**
- * Implementation of toFixed() that treats floats more like decimals
- *
- * Fixes binary rounding issues (eg. (0.615).toFixed(2) === '0.61') that present
- * problems for accounting- and finance-related software.
- */
- function toFixed (value, precision, optionals) {
- var power = Math.pow(10, precision),
- output;
-
- // Multiply up by precision, round accurately, then divide and use native toFixed():
- output = (Math.round(value * power) / power).toFixed(precision);
-
- if (optionals) {
- var optionalsRegExp = new RegExp('0{1,' + optionals + '}$');
- output = output.replace(optionalsRegExp, '');
- }
-
- return output;
- }
-
- /************************************
- Formatting
- ************************************/
-
- // determine what type of formatting we need to do
- function formatNumeral (n, format) {
- var output;
-
- // figure out what kind of format we are dealing with
- if (format.indexOf('$') > -1) { // currency!!!!!
- output = formatCurrency(n, format);
- } else if (format.indexOf('%') > -1) { // percentage
- output = formatPercentage(n, format);
- } else if (format.indexOf(':') > -1) { // time
- output = formatTime(n, format);
- } else { // plain ol' numbers or bytes
- output = formatNumber(n, format);
- }
-
- // return string
- return output;
- }
-
- // revert to number
- function unformatNumeral (n, string) {
- if (string.indexOf(':') > -1) {
- n._n = unformatTime(string);
- } else {
- if (string === zeroFormat) {
- n._n = 0;
- } else {
- var stringOriginal = string;
- if (languages[currentLanguage].delimiters.decimal !== '.') {
- string = string.replace(/\./g,'').replace(languages[currentLanguage].delimiters.decimal, '.');
- }
-
- // see if abbreviations are there so that we can multiply to the correct number
- var thousandRegExp = new RegExp(languages[currentLanguage].abbreviations.thousand + '(?:\\)|(\\' + languages[currentLanguage].currency.symbol + ')?(?:\\))?)?$'),
- millionRegExp = new RegExp(languages[currentLanguage].abbreviations.million + '(?:\\)|(\\' + languages[currentLanguage].currency.symbol + ')?(?:\\))?)?$'),
- billionRegExp = new RegExp(languages[currentLanguage].abbreviations.billion + '(?:\\)|(\\' + languages[currentLanguage].currency.symbol + ')?(?:\\))?)?$'),
- trillionRegExp = new RegExp(languages[currentLanguage].abbreviations.trillion + '(?:\\)|(\\' + languages[currentLanguage].currency.symbol + ')?(?:\\))?)?$');
-
- // see if bytes are there so that we can multiply to the correct number
- var prefixes = ['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'],
- bytesMultiplier = false;
-
- for (var power = 0; power <= prefixes.length; power++) {
- bytesMultiplier = (string.indexOf(prefixes[power]) > -1) ? Math.pow(1024, power + 1) : false;
-
- if (bytesMultiplier) {
- break;
- }
- }
-
- // do some math to create our number
- n._n = ((bytesMultiplier) ? bytesMultiplier : 1) * ((stringOriginal.match(thousandRegExp)) ? Math.pow(10, 3) : 1) * ((stringOriginal.match(millionRegExp)) ? Math.pow(10, 6) : 1) * ((stringOriginal.match(billionRegExp)) ? Math.pow(10, 9) : 1) * ((stringOriginal.match(trillionRegExp)) ? Math.pow(10, 12) : 1) * ((string.indexOf('%') > -1) ? 0.01 : 1) * Number(((string.indexOf('(') > -1) ? '-' : '') + string.replace(/[^0-9\.-]+/g, ''));
-
- // round if we are talking about bytes
- n._n = (bytesMultiplier) ? Math.ceil(n._n) : n._n;
- }
- }
- return n._n;
- }
-
- function formatCurrency (n, format) {
- var prependSymbol = (format.indexOf('$') <= 1) ? true : false;
-
- // remove $ for the moment
- var space = '';
-
- // check for space before or after currency
- if (format.indexOf(' $') > -1) {
- space = ' ';
- format = format.replace(' $', '');
- } else if (format.indexOf('$ ') > -1) {
- space = ' ';
- format = format.replace('$ ', '');
- } else {
- format = format.replace('$', '');
- }
-
- // format the number
- var output = formatNumeral(n, format);
-
- // position the symbol
- if (prependSymbol) {
- if (output.indexOf('(') > -1 || output.indexOf('-') > -1) {
- output = output.split('');
- output.splice(1, 0, languages[currentLanguage].currency.symbol + space);
- output = output.join('');
- } else {
- output = languages[currentLanguage].currency.symbol + space + output;
- }
- } else {
- if (output.indexOf(')') > -1) {
- output = output.split('');
- output.splice(-1, 0, space + languages[currentLanguage].currency.symbol);
- output = output.join('');
- } else {
- output = output + space + languages[currentLanguage].currency.symbol;
- }
- }
-
- return output;
- }
-
- function formatPercentage (n, format) {
- var space = '';
- // check for space before %
- if (format.indexOf(' %') > -1) {
- space = ' ';
- format = format.replace(' %', '');
- } else {
- format = format.replace('%', '');
- }
-
- n._n = n._n * 100;
- var output = formatNumeral(n, format);
- if (output.indexOf(')') > -1 ) {
- output = output.split('');
- output.splice(-1, 0, space + '%');
- output = output.join('');
- } else {
- output = output + space + '%';
- }
- return output;
- }
-
- function formatTime (n, format) {
- var hours = Math.floor(n._n/60/60),
- minutes = Math.floor((n._n - (hours * 60 * 60))/60),
- seconds = Math.round(n._n - (hours * 60 * 60) - (minutes * 60));
- return hours + ':' + ((minutes < 10) ? '0' + minutes : minutes) + ':' + ((seconds < 10) ? '0' + seconds : seconds);
- }
-
- function unformatTime (string) {
- var timeArray = string.split(':'),
- seconds = 0;
- // turn hours and minutes into seconds and add them all up
- if (timeArray.length === 3) {
- // hours
- seconds = seconds + (Number(timeArray[0]) * 60 * 60);
- // minutes
- seconds = seconds + (Number(timeArray[1]) * 60);
- // seconds
- seconds = seconds + Number(timeArray[2]);
- } else if (timeArray.lenght === 2) {
- // minutes
- seconds = seconds + (Number(timeArray[0]) * 60);
- // seconds
- seconds = seconds + Number(timeArray[1]);
- }
- return Number(seconds);
- }
-
- function formatNumber (n, format) {
- var negP = false,
- optDec = false,
- abbr = '',
- bytes = '',
- ord = '',
- abs = Math.abs(n._n);
-
- // check if number is zero and a custom zero format has been set
- if (n._n === 0 && zeroFormat !== null) {
- return zeroFormat;
- } else {
- // see if we should use parentheses for negative number
- if (format.indexOf('(') > -1) {
- negP = true;
- format = format.slice(1, -1);
- }
-
- // see if abbreviation is wanted
- if (format.indexOf('a') > -1) {
- // check for space before abbreviation
- if (format.indexOf(' a') > -1) {
- abbr = ' ';
- format = format.replace(' a', '');
- } else {
- format = format.replace('a', '');
- }
-
- if (abs >= Math.pow(10, 12)) {
- // trillion
- abbr = abbr + languages[currentLanguage].abbreviations.trillion;
- n._n = n._n / Math.pow(10, 12);
- } else if (abs < Math.pow(10, 12) && abs >= Math.pow(10, 9)) {
- // billion
- abbr = abbr + languages[currentLanguage].abbreviations.billion;
- n._n = n._n / Math.pow(10, 9);
- } else if (abs < Math.pow(10, 9) && abs >= Math.pow(10, 6)) {
- // million
- abbr = abbr + languages[currentLanguage].abbreviations.million;
- n._n = n._n / Math.pow(10, 6);
- } else if (abs < Math.pow(10, 6) && abs >= Math.pow(10, 3)) {
- // thousand
- abbr = abbr + languages[currentLanguage].abbreviations.thousand;
- n._n = n._n / Math.pow(10, 3);
- }
- }
-
- // see if we are formatting bytes
- if (format.indexOf('b') > -1) {
- // check for space before
- if (format.indexOf(' b') > -1) {
- bytes = ' ';
- format = format.replace(' b', '');
- } else {
- format = format.replace('b', '');
- }
-
- var prefixes = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'],
- min,
- max;
-
- for (var power = 0; power <= prefixes.length; power++) {
- min = Math.pow(1024, power);
- max = Math.pow(1024, power+1);
-
- if (n._n >= min && n._n < max) {
- bytes = bytes + prefixes[power];
- if (min > 0) {
- n._n = n._n / min;
- }
- break;
- }
- }
- }
-
- // see if ordinal is wanted
- if (format.indexOf('o') > -1) {
- // check for space before
- if (format.indexOf(' o') > -1) {
- ord = ' ';
- format = format.replace(' o', '');
- } else {
- format = format.replace('o', '');
- }
-
- ord = ord + languages[currentLanguage].ordinal(n._n);
- }
-
- if (format.indexOf('[.]') > -1) {
- optDec = true;
- format = format.replace('[.]', '.');
- }
-
- var w = n._n.toString().split('.')[0],
- precision = format.split('.')[1],
- thousands = format.indexOf(','),
- d = '',
- neg = false;
-
- if (precision) {
- if (precision.indexOf('[') > -1) {
- precision = precision.replace(']', '');
- precision = precision.split('[');
- d = toFixed(n._n, (precision[0].length + precision[1].length), precision[1].length);
- } else {
- d = toFixed(n._n, precision.length);
- }
-
- w = d.split('.')[0];
-
- if (d.split('.')[1].length) {
- d = languages[currentLanguage].delimiters.decimal + d.split('.')[1];
- } else {
- d = '';
- }
-
- if (optDec && Number(d) === 0) {
- d = '';
- }
- } else {
- w = toFixed(n._n, null);
- }
-
- // format number
- if (w.indexOf('-') > -1) {
- w = w.slice(1);
- neg = true;
- }
-
- if (thousands > -1) {
- w = w.toString().replace(/(\d)(?=(\d{3})+(?!\d))/g, '$1' + languages[currentLanguage].delimiters.thousands);
- }
-
- if (format.indexOf('.') === 0) {
- w = '';
- }
-
- return ((negP && neg) ? '(' : '') + ((!negP && neg) ? '-' : '') + w + d + ((ord) ? ord : '') + ((abbr) ? abbr : '') + ((bytes) ? bytes : '') + ((negP && neg) ? ')' : '');
- }
- }
-
- /************************************
- Top Level Functions
- ************************************/
-
- numeral = function (input) {
- if (numeral.isNumeral(input)) {
- input = input.value();
- } else if (!Number(input)) {
- input = 0;
- }
-
- return new Numeral(Number(input));
- };
-
- // version number
- numeral.version = VERSION;
-
- // compare numeral object
- numeral.isNumeral = function (obj) {
- return obj instanceof Numeral;
- };
-
- // This function will load languages and then set the global language. If
- // no arguments are passed in, it will simply return the current global
- // language key.
- numeral.language = function (key, values) {
- if (!key) {
- return currentLanguage;
- }
-
- if (key && !values) {
- currentLanguage = key;
- }
-
- if (values || !languages[key]) {
- loadLanguage(key, values);
- }
-
- return numeral;
- };
-
- numeral.language('en', {
- delimiters: {
- thousands: ',',
- decimal: '.'
- },
- abbreviations: {
- thousand: 'k',
- million: 'm',
- billion: 'b',
- trillion: 't'
- },
- ordinal: function (number) {
- var b = number % 10;
- return (~~ (number % 100 / 10) === 1) ? 'th' :
- (b === 1) ? 'st' :
- (b === 2) ? 'nd' :
- (b === 3) ? 'rd' : 'th';
- },
- currency: {
- symbol: '$'
- }
- });
-
- numeral.zeroFormat = function (format) {
- if (typeof(format) === 'string') {
- zeroFormat = format;
- } else {
- zeroFormat = null;
- }
- };
-
- /************************************
- Helpers
- ************************************/
-
- function loadLanguage(key, values) {
- languages[key] = values;
- }
-
-
- /************************************
- Numeral Prototype
- ************************************/
-
-
- numeral.fn = Numeral.prototype = {
-
- clone : function () {
- return numeral(this);
- },
-
- format : function (inputString) {
- return formatNumeral(this, inputString ? inputString : numeral.defaultFormat);
- },
-
- unformat : function (inputString) {
- return unformatNumeral(this, inputString ? inputString : numeral.defaultFormat);
- },
-
- value : function () {
- return this._n;
- },
-
- valueOf : function () {
- return this._n;
- },
-
- set : function (value) {
- this._n = Number(value);
- return this;
- },
-
- add : function (value) {
- this._n = this._n + Number(value);
- return this;
- },
-
- subtract : function (value) {
- this._n = this._n - Number(value);
- return this;
- },
-
- multiply : function (value) {
- this._n = this._n * Number(value);
- return this;
- },
-
- divide : function (value) {
- this._n = this._n / Number(value);
- return this;
- },
-
- difference : function (value) {
- var difference = this._n - Number(value);
-
- if (difference < 0) {
- difference = -difference;
- }
-
- return difference;
- }
-
- };
-
- /************************************
- Exposing Numeral
- ************************************/
-
- // CommonJS module is defined
- if (hasModule) {
- module.exports = numeral;
- }
-
- /*global ender:false */
- if (typeof ender === 'undefined') {
- // here, `this` means `window` in the browser, or `global` on the server
- // add `numeral` as a global object via a string identifier,
- // for Closure Compiler 'advanced' mode
- this['numeral'] = numeral;
- }
-
- /*global define:false */
- if (typeof define === 'function' && define.amd) {
- define([], function () {
- return numeral;
- });
- }
-}).call(this);
diff --git a/script/jquery.handsontable.rowmove.js b/script/jquery.handsontable.rowmove.js
deleted file mode 100644
index 29df249..0000000
--- a/script/jquery.handsontable.rowmove.js
+++ /dev/null
@@ -1,177 +0,0 @@
-/**
- * Handle Row Moves on our Editor
- *
- * based on the example plugin that comes with Handsontable but simplified and adjusted to work on our
- * custom data/meta datastructure
- *
- * @author Andreas Gohr
- * @constructor
- */
-function EditTableRowMove() {
- var pressed,
- startRow,
- endRow,
- startY,
- startOffset;
-
- var ghost = document.createElement('DIV'),
- ghostStyle = ghost.style;
-
- ghost.className = 'ghost';
- ghostStyle.position = 'absolute';
- ghostStyle.top = '25px';
- ghostStyle.left = '50px';
- ghostStyle.width = '10px';
- ghostStyle.height = '10px';
- ghostStyle.backgroundColor = '#CCC';
- ghostStyle.opacity = 0.7;
-
- /**
- * Attach all the events
- */
- var bindMoveRowEvents = function () {
- var instance = this;
-
- /**
- * during drag operation
- */
- instance.rootElement.on('mousemove.editTableRowMove', function (e) {
- if (pressed) {
- ghostStyle.top = startOffset + e.pageY - startY + 6 + 'px';
- if (ghostStyle.display === 'none') {
- ghostStyle.display = 'block';
- }
- }
- });
-
- /**
- * end of drag operation
- *
- * The row move is executed here
- */
- instance.rootElement.on('mouseup.editTableRowMove', function () {
- if (pressed) {
- if (startRow < endRow) {
- endRow--;
- }
- if (instance.getSettings().colHeaders) {
- startRow--;
- endRow--;
- }
- jQuery('.editTableRowMover.active').removeClass('active');
- pressed = false;
- ghostStyle.display = 'none';
-
- // rows are off by one
- startRow += 1;
- endRow += 1;
-
- if (startRow == endRow) return;
-
- // if this row is part of a row span, do not move
- if (instance.raw.rowinfo[endRow].rowspan) return;
-
- // swap the rows
- instance.raw.data.splice(endRow, 0, instance.raw.data.splice(startRow, 1)[0]);
- instance.raw.meta.splice(endRow, 0, instance.raw.meta.splice(startRow, 1)[0]);
-
- instance.forceFullRender = true;
- instance.view.render(); //updates all
- }
- });
-
- /**
- * start drag operation
- */
- instance.rootElement.on('mousedown.editTableRowMove', '.editTableRowMover', function (e) {
-
- var mover = e.currentTarget;
- var TH = instance.view.wt.wtDom.closest(mover, 'TH');
- startRow = instance.view.wt.wtDom.index(TH.parentNode) + instance.rowOffset();
- endRow = startRow;
- pressed = true;
- startY = e.pageY;
-
- var TABLE = instance.$table[0];
- TABLE.parentNode.appendChild(ghost);
- ghostStyle.height = instance.view.wt.wtDom.outerHeight(TH) + 'px';
- ghostStyle.width = instance.view.wt.wtDom.outerWidth(TABLE) + 'px';
- startOffset = parseInt(instance.view.wt.wtDom.offset(TH).top - instance.view.wt.wtDom.offset(TABLE).top, 10);
- ghostStyle.top = startOffset + 6 + 'px';
- });
-
- /**
- * on mouseover, show drag handle
- */
- instance.rootElement.on('mouseenter.editTableRowMove', 'td, th', function () {
- if (pressed) {
- var active = instance.view.TBODY.querySelector('.editTableRowMover.active');
- if (active) {
- instance.view.wt.wtDom.removeClass(active, 'active');
- }
- endRow = instance.view.wt.wtDom.index(this.parentNode) + instance.rowOffset();
-
- // if this row is part of a row span, do not move
- if (instance.raw.rowinfo[endRow].rowspan) return;
-
- var THs = instance.view.TBODY.querySelectorAll('th');
- var mover = THs[endRow].querySelector('.editTableRowMover');
- instance.view.wt.wtDom.addClass(mover, 'active');
- }
- });
-
- instance.addHook('afterDestroy', unbindMoveRowEvents);
- };
-
- /**
- * Remove all the Events
- */
- var unbindMoveRowEvents = function () {
- var instance = this;
- instance.rootElement.off('mouseup.editTableRowMove');
- instance.rootElement.off('mousemove.editTableRowMove');
- instance.rootElement.off('mousedown.editTableRowMove');
- instance.rootElement.off('mouseenter.editTableRowMove');
- };
-
- /**
- * Initialize the plugin
- */
- this.init = function () {
- var instance = this;
- var editTableRowMoveEnabled = !!(this.getSettings().editTableRowMove);
-
- if (editTableRowMoveEnabled) {
- instance.forceFullRender = true;
- bindMoveRowEvents.call(this);
-
- } else {
- unbindMoveRowEvents.call(this);
- }
- };
-
- /**
- * Add a move handler to each row head
- *
- * @param row
- * @param TH
- */
- this.getRowHeader = function (row, TH) {
- if (row > -1 && this.getSettings().editTableRowMove) {
- // if this row is part of a row span, do not add move handle
- if (this.raw.rowinfo[row].rowspan) return;
-
- var DIV = document.createElement('DIV');
- DIV.className = 'editTableRowMover';
- TH.firstChild.appendChild(DIV);
- }
- };
-}
-
-var htEditTableRowMove = new EditTableRowMove();
-
-Handsontable.PluginHooks.add('afterInit', function () {
- htEditTableRowMove.init.call(this);
-});
-
-Handsontable.PluginHooks.add('afterGetRowHeader', htEditTableRowMove.getRowHeader);
diff --git a/style.less b/style.less
index 61c6f75..391b60d 100644
--- a/style.less
+++ b/style.less
@@ -1,6 +1,5 @@
-@import "less/jquery.handsontable.full.less";
-@import "less/jquery.handsontable.columnmove.less";
-@import "less/jquery.handsontable.rowmove.less";
+@import "less/handsontable.full.less";
@import "less/editbutton.less";
@import "less/editor.less";
-@import "less/contextmenu.less";
\ No newline at end of file
+@import "less/contextmenu.less";
+@import "less/foo.less";
|