(.*)<\/div>$/,
'$1'
];
},
applicable: function (html) {
return /class="?Apple-style-span|style="[^"]*-webkit-nbsp-mode/i.test(html);
}
});
var DomCleaner = Cleaner.extend({
clean: function (html) {
var container = dom.create(document, 'div', { innerHTML: html });
container = this.cleanDom(container);
return container.innerHTML;
},
cleanDom: function (container) {
return container;
}
});
var HtmlTagsCleaner = DomCleaner.extend({
cleanDom: function (container) {
var tags = this.collectTags();
$(container).find(tags).each(function () {
dom.unwrap(this);
});
return container;
},
collectTags: function () {
if (this.options.span) {
return 'span';
}
},
applicable: function () {
return this.options.span;
}
});
var HtmlAttrCleaner = DomCleaner.extend({
cleanDom: function (container) {
var attributes = this.collectAttr();
var nodes = $(container).find('[' + attributes.join('],[') + ']');
nodes.removeAttr(attributes.join(' '));
return container;
},
collectAttr: function () {
if (this.options.css) {
return [
'class',
'style'
];
}
return [];
},
applicable: function () {
return this.options.css;
}
});
var TextContainer = function () {
this.text = '';
this.add = function (text) {
this.text += text;
};
};
var HtmlTextLines = Class.extend({
init: function (separators) {
this.separators = separators || {
text: ' ',
line: '
'
};
this.lines = [];
this.inlineBlockText = [];
this.resetLine();
},
appendText: function (text) {
if (text.nodeType === 3) {
text = text.nodeValue;
}
this.textContainer.add(text);
},
appendInlineBlockText: function (text) {
this.inlineBlockText.push(text);
},
flashInlineBlockText: function () {
if (this.inlineBlockText.length) {
this.appendText(this.inlineBlockText.join(' '));
this.inlineBlockText = [];
}
},
endLine: function () {
this.flashInlineBlockText();
this.resetLine();
},
html: function () {
var separators = this.separators;
var result = '';
var lines = this.lines;
this.flashInlineBlockText();
for (var i = 0, il = lines.length, il1 = il - 1; i < il; i++) {
var line = lines[i];
for (var j = 0, jl = line.length, jl1 = jl - 1; j < jl; j++) {
var text = line[j].text;
result += text;
if (j !== jl1) {
result += separators.text;
}
}
if (i !== il1) {
result += separators.line;
}
}
return result;
},
resetLine: function () {
this.textContainer = new TextContainer();
this.line = [];
this.line.push(this.textContainer);
this.lines.push(this.line);
}
});
var DomEnumerator = Class.extend({
init: function (callback) {
this.callback = callback;
},
enumerate: function (node) {
if (!node) {
return;
}
var preventDown = this.callback(node);
var child = node.firstChild;
if (!preventDown && child) {
this.enumerate(child);
}
this.enumerate(node.nextSibling);
}
});
var HtmlContentCleaner = Cleaner.extend({
init: function (options) {
Cleaner.fn.init.call(this, options);
this.hasText = false;
this.enumerator = new DomEnumerator($.proxy(this.buildText, this));
},
clean: function (html) {
var container = dom.create(document, 'div', { innerHTML: html });
return this.cleanDom(container);
},
cleanDom: function (container) {
this.separators = this.getDefaultSeparators();
this.htmlLines = new HtmlTextLines(this.separators);
this.enumerator.enumerate(container.firstChild);
this.hasText = false;
return this.htmlLines.html();
},
buildText: function (node) {
if (dom.isDataNode(node)) {
if (dom.isEmptyspace(node)) {
return;
}
this.htmlLines.appendText(node.nodeValue.replace('\n', this.separators.line));
this.hasText = true;
} else if (dom.isBlock(node) && this.hasText) {
var action = this.actions[dom.name(node)] || this.actions.block;
return action(this, node);
} else if (dom.isBr(node)) {
this.htmlLines.appendText(this.separators.line);
}
},
applicable: function () {
var o = this.options;
return o.all || o.keepNewLines;
},
getDefaultSeparators: function () {
if (this.options.all) {
return {
text: ' ',
line: ' '
};
} else {
return {
text: ' ',
line: '
'
};
}
},
actions: {
ul: $.noop,
ol: $.noop,
table: $.noop,
thead: $.noop,
tbody: $.noop,
td: function (cleaner, node) {
var tdCleaner = new HtmlContentCleaner({ all: true });
var cellText = tdCleaner.cleanDom(node);
cleaner.htmlLines.appendInlineBlockText(cellText);
return true;
},
block: function (cleaner) {
cleaner.htmlLines.endLine();
}
}
});
var CustomCleaner = Cleaner.extend({
clean: function (html) {
return this.options.custom(html);
},
applicable: function () {
return typeof this.options.custom === 'function';
}
});
extend(editorNS, {
Clipboard: Clipboard,
Cleaner: Cleaner,
ScriptCleaner: ScriptCleaner,
TabCleaner: TabCleaner,
MSWordFormatCleaner: MSWordFormatCleaner,
WebkitFormatCleaner: WebkitFormatCleaner,
HtmlTagsCleaner: HtmlTagsCleaner,
HtmlAttrCleaner: HtmlAttrCleaner,
HtmlContentCleaner: HtmlContentCleaner,
HtmlTextLines: HtmlTextLines,
CustomCleaner: CustomCleaner
});
}(window.kendo.jQuery));
}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {
(a3 || a2)();
}));
(function (f, define) {
define('editor/plugins/keyboard', ['editor/command'], f);
}(function () {
(function ($) {
var kendo = window.kendo, Class = kendo.Class, editorNS = kendo.ui.editor, RangeUtils = editorNS.RangeUtils, dom = editorNS.Dom, RestorePoint = editorNS.RestorePoint, Marker = editorNS.Marker, browser = kendo.support.browser, br = '
', extend = $.extend;
var nodeTypes = dom.nodeTypes;
var PREVIOUS_SIBLING = 'previousSibling';
function selected(node, range) {
return range.startContainer === node && range.endContainer === node && range.startOffset === 0 && range.endOffset == node.childNodes.length;
}
function getSibling(node, direction, condition) {
var sibling = node ? node[direction] : null;
while (sibling && !condition(sibling)) {
sibling = sibling[direction];
}
return sibling;
}
var tableCells = 'td,th,caption';
var tableCellsWrappers = 'table,tbody,thead,tfoot,tr';
var tableElements = tableCellsWrappers + ',' + tableCells;
var inTable = function (range) {
return !range.collapsed && $(range.commonAncestorContainer).is(tableCellsWrappers);
};
var RemoveTableContent = Class.extend({
remove: function (range) {
var that = this;
var marker = new Marker();
marker.add(range, false);
var nodes = RangeUtils.getAll(range, function (node) {
return $(node).is(tableElements);
});
var doc = RangeUtils.documentFromRange(range);
var start = marker.start;
var end = marker.end;
var cellsTypes = tableCells.split(',');
var startCell = dom.parentOfType(start, cellsTypes);
var endCell = dom.parentOfType(end, cellsTypes);
that._removeContent(start, startCell, true);
that._removeContent(end, endCell, false);
$(nodes).each(function (i, node) {
node = $(node);
(node.is(tableCells) ? node : node.find(tableCells)).each(function (j, cell) {
cell.innerHTML = '';
});
});
if (startCell && !start.previousSibling) {
dom.insertBefore(doc.createTextNode('\uFEFF'), start);
}
if (endCell && !end.nextSibling) {
dom.insertAfter(doc.createTextNode('\uFEFF'), end);
}
if (startCell) {
range.setStartBefore(start);
} else if (nodes[0]) {
startCell = $(nodes[0]);
startCell = startCell.is(tableCells) ? startCell : startCell.find(tableCells).first();
if (startCell.length) {
range.setStart(startCell.get(0), 0);
}
}
range.collapse(true);
dom.remove(start);
dom.remove(end);
},
_removeContent: function (start, top, forwards) {
if (top) {
var sibling = forwards ? 'nextSibling' : 'previousSibling', next, getNext = function (node) {
while (node && !node[sibling]) {
node = node.parentNode;
}
return node && $.contains(top, node) ? node[sibling] : null;
};
start = getNext(start);
while (start) {
next = getNext(start);
dom.remove(start);
start = next;
}
}
}
});
var TypingHandler = Class.extend({
init: function (editor) {
this.editor = editor;
},
keydown: function (e) {
var that = this, editor = that.editor, keyboard = editor.keyboard, isTypingKey = keyboard.isTypingKey(e), evt = extend($.Event(), e);
that.editor.trigger('keydown', evt);
if (evt.isDefaultPrevented()) {
e.preventDefault();
return true;
}
if (!evt.isDefaultPrevented() && isTypingKey && !keyboard.isTypingInProgress()) {
var range = editor.getRange();
var body = editor.body;
that.startRestorePoint = new RestorePoint(range, body);
if (inTable(range)) {
var removeTableContent = new RemoveTableContent(editor);
removeTableContent.remove(range);
editor.selectRange(range);
}
if (browser.webkit && !range.collapsed && selected(body, range)) {
body.innerHTML = '';
}
if (editor.immutables && editorNS.Immutables.immutablesContext(range)) {
var backspaceHandler = new editorNS.BackspaceHandler(editor);
backspaceHandler.deleteSelection(range);
}
keyboard.startTyping(function () {
that.endRestorePoint = editorNS._finishUpdate(editor, that.startRestorePoint);
});
return true;
}
return false;
},
keyup: function (e) {
var keyboard = this.editor.keyboard;
this.editor.trigger('keyup', e);
if (keyboard.isTypingInProgress()) {
keyboard.endTyping();
return true;
}
return false;
}
});
var BackspaceHandler = Class.extend({
init: function (editor) {
this.editor = editor;
},
_addCaret: function (container) {
var caret = dom.create(this.editor.document, 'a');
if (!kendo.support.browser.chrome && container.firstChild && container.firstChild.nodeType === nodeTypes.ELEMENT_NODE) {
container = container.firstChild;
}
dom.insertAt(container, caret, 0);
dom.stripBomNode(caret.previousSibling);
dom.stripBomNode(caret.nextSibling);
return caret;
},
_restoreCaret: function (caret) {
var range = this.editor.createRange();
if (!caret.nextSibling && dom.isDataNode(caret.previousSibling)) {
range.setStart(caret.previousSibling, caret.previousSibling.length);
} else {
range.setStartAfter(caret);
}
range.collapse(true);
this.editor.selectRange(range);
dom.remove(caret);
},
_handleDelete: function (range) {
var node = range.endContainer;
var block = dom.closestEditableOfType(node, dom.blockElements);
if (block && editorNS.RangeUtils.isEndOf(range, block)) {
var next = dom.next(block);
if (!next || dom.name(next) != 'p') {
return false;
}
var caret = this._addCaret(next);
this._merge(block, next);
this._restoreCaret(caret);
return true;
}
return false;
},
_cleanBomBefore: function (range) {
var offset = range.startOffset;
var node = range.startContainer;
var text = node.nodeValue;
var count = 0;
while (offset - count >= 0 && text[offset - count - 1] == '\uFEFF') {
count++;
}
if (count > 0) {
node.deleteData(offset - count, count);
range.setStart(node, Math.max(0, offset - count));
range.collapse(true);
this.editor.selectRange(range);
}
},
_handleBackspace: function (range) {
var node = range.startContainer;
var li = dom.closestEditableOfType(node, ['li']);
var block = dom.closestEditableOfType(node, 'p,h1,h2,h3,h4,h5,h6'.split(','));
var editor = this.editor;
var previousSibling;
if (dom.isDataNode(node)) {
if (range.collapsed && /^\s[\ufeff]+$/.test(node.nodeValue)) {
range.setStart(node, 0);
range.setEnd(node, node.length);
editor.selectRange(range);
return false;
}
this._cleanBomBefore(range);
}
previousSibling = getSibling(block, PREVIOUS_SIBLING, function (sibling) {
return !dom.htmlIndentSpace(sibling);
});
if (range.collapsed && range.startOffset !== range.endOffset && range.startOffset < 0) {
range.startOffset = 0;
range.endOffset = 0;
editor.selectRange(range);
}
var startAtLi = li && editorNS.RangeUtils.isStartOf(range, li);
var liIndex = li && $(li).index();
var startAtNonFirstLi = startAtLi && liIndex > 0;
if (startAtNonFirstLi) {
block = li;
previousSibling = dom.prev(li);
}
if (block && previousSibling && dom.is(previousSibling, 'table') && editorNS.RangeUtils.isStartOf(range, block)) {
if (block.innerText === '') {
block.innerHTML = '\uFEFF';
}
return true;
}
if (editorNS.RangeUtils.isStartOf(range, block) && (parseInt(block.style.marginLeft, 10) > 0 || parseInt(block.style.marginRight, 10) > 0)) {
editor.exec('outdent');
return true;
}
if (block && previousSibling && editorNS.RangeUtils.isStartOf(range, block) || startAtNonFirstLi) {
var caret = this._addCaret(block);
this._merge(previousSibling, block);
this._restoreCaret(caret);
return true;
}
if (startAtLi && liIndex === 0) {
var child = li.firstChild;
if (!child) {
li.innerHTML = editorNS.emptyElementContent;
child = li.firstChild;
}
var formatter = new editorNS.ListFormatter(dom.name(li.parentNode), 'p');
range.selectNodeContents(li);
formatter.toggle(range);
if (dom.insignificant(child)) {
range.setStartBefore(child);
} else {
range.setStart(child, 0);
}
editor.selectRange(range);
return true;
}
var rangeStartNode = node.childNodes[range.startOffset - 1];
var linkRange = range;
var anchor = rangeStartNode && dom.closestEditableOfType(rangeStartNode, ['a']);
var previousNode = getSibling(rangeStartNode || node, PREVIOUS_SIBLING, function (sibling) {
return !dom.isDataNode(sibling) || !dom.isBom(sibling) && sibling.length > 0;
});
if (anchor || (range.startOffset === 0 || rangeStartNode) && dom.is(previousNode, 'a')) {
anchor = anchor || previousNode;
linkRange = editor.createRange();
linkRange.setStart(anchor, anchor.childNodes.length);
linkRange.collapse(true);
}
anchor = anchor || dom.closestEditableOfType(rangeStartNode || linkRange.startContainer, ['a']);
var isEndOfLink = anchor && editorNS.RangeUtils.isEndOf(linkRange, anchor);
if (isEndOfLink) {
var command = new editorNS.UnlinkCommand({
range: linkRange,
body: editor.body,
immutables: !!editor.immutables
});
editor.execCommand(command);
editor._selectionChange();
}
return false;
},
_handleSelection: function (range) {
var ancestor = range.commonAncestorContainer;
var table = dom.closest(ancestor, 'table');
var emptyParagraphContent = editorNS.emptyElementContent;
var editor = this.editor;
if (inTable(range)) {
var removeTableContent = new RemoveTableContent(editor);
removeTableContent.remove(range);
editor.selectRange(range);
return true;
}
var marker = new Marker();
marker.add(range, false);
if (range.commonAncestorContainer === editor.body) {
this._surroundFullyContent(marker, range);
}
if (editor.immutables) {
this._handleImmutables(marker);
}
this._surroundFullySelectedAnchor(marker, range);
range.setStartAfter(marker.start);
range.setEndBefore(marker.end);
var start = range.startContainer;
var end = range.endContainer;
range.deleteContents();
if (end.tagName.toLocaleLowerCase() === 'li' && dom.emptyNode(end)) {
range.selectNode(end);
range.deleteContents();
}
if (table && $(table).text() === '') {
range.selectNode(table);
range.deleteContents();
}
ancestor = range.commonAncestorContainer;
if (dom.name(ancestor) === 'p' && ancestor.innerHTML === '') {
ancestor.innerHTML = emptyParagraphContent;
range.setStart(ancestor, 0);
}
this._join(start, end);
dom.insertAfter(editor.document.createTextNode('\uFEFF'), marker.start);
marker.remove(range);
start = range.startContainer;
if (dom.name(start) == 'tr') {
start = start.childNodes[Math.max(0, range.startOffset - 1)];
range.setStart(start, dom.getNodeLength(start));
}
range.collapse(true);
editor.selectRange(range);
return true;
},
_handleImmutables: function (marker) {
var immutableParent = editorNS.Immutables.immutableParent;
var startImmutable = immutableParent(marker.start);
var endImmutable = immutableParent(marker.start);
if (startImmutable) {
dom.insertBefore(marker.start, startImmutable);
}
if (endImmutable) {
dom.insertAfter(marker.end, endImmutable);
}
if (startImmutable) {
dom.remove(startImmutable);
}
if (endImmutable && endImmutable.parentNode) {
dom.remove(endImmutable);
}
},
_surroundFullyContent: function (marker, range) {
var children = range.commonAncestorContainer.children, startParent = children[0], endParent = children[children.length - 1];
this._moveMarker(marker, range, startParent, endParent);
},
_surroundFullySelectedAnchor: function (marker, range) {
var start = marker.start, startParent = $(start).closest('a').get(0), end = marker.end, endParent = $(end).closest('a').get(0);
this._moveMarker(marker, range, startParent, endParent);
},
_moveMarker: function (marker, range, startParent, endParent) {
var start = marker.start, end = marker.end;
if (startParent && RangeUtils.isStartOf(range, startParent)) {
dom.insertBefore(start, startParent);
}
if (endParent && RangeUtils.isEndOf(range, endParent)) {
dom.insertAfter(end, endParent);
}
},
_root: function (node) {
while (node && dom.name(node) != 'body' && node.parentNode && dom.name(node.parentNode) != 'body') {
node = node.parentNode;
}
return node;
},
_join: function (start, end) {
start = this._root(start);
end = this._root(end);
if (start != end && dom.is(end, 'p')) {
this._merge(start, end);
}
},
_merge: function (dest, src) {
dom.removeTrailingBreak(dest);
while (dest && src.firstChild) {
if (dest.nodeType == 1) {
dest = dom.list(dest) ? dest.children[dest.children.length - 1] : dest;
if (dest) {
dest.appendChild(src.firstChild);
}
} else if (dest.nodeType === nodeTypes.TEXT_NODE) {
this._mergeWithTextNode(dest, src.firstChild);
} else {
dest.parentNode.appendChild(src.firstChild);
}
}
dom.remove(src);
},
_mergeWithTextNode: function (textNode, appendedNode) {
if (textNode && textNode.nodeType === nodeTypes.TEXT_NODE) {
if (textNode.nextSibling && this._isCaret(textNode.nextSibling)) {
dom.insertAfter(appendedNode, textNode.nextSibling);
} else {
dom.insertAfter(appendedNode, textNode);
}
}
},
_isCaret: function (element) {
return $(element).is('a');
},
keydown: function (e) {
var method, startRestorePoint;
var editor = this.editor;
var range = editor.getRange();
var keyCode = e.keyCode;
var keys = kendo.keys;
var backspace = keyCode === keys.BACKSPACE;
var del = keyCode == keys.DELETE;
if (editor.immutables && editor.immutables.keydown(e, range)) {
return;
}
if ((backspace || del) && !range.collapsed) {
method = '_handleSelection';
} else if (backspace) {
method = '_handleBackspace';
} else if (del) {
method = '_handleDelete';
}
if (!method) {
return;
}
startRestorePoint = new RestorePoint(range, editor.body);
if (this[method](range)) {
e.preventDefault();
editorNS._finishUpdate(editor, startRestorePoint);
}
},
deleteSelection: function (range) {
this._handleSelection(range);
},
keyup: $.noop
});
var SystemHandler = Class.extend({
init: function (editor) {
this.editor = editor;
this.systemCommandIsInProgress = false;
},
createUndoCommand: function () {
this.startRestorePoint = this.endRestorePoint = editorNS._finishUpdate(this.editor, this.startRestorePoint);
},
changed: function () {
if (this.startRestorePoint) {
return this.startRestorePoint.html != this.editor.body.innerHTML;
}
return false;
},
keydown: function (e) {
var that = this, editor = that.editor, keyboard = editor.keyboard;
if (keyboard.isModifierKey(e)) {
if (keyboard.isTypingInProgress()) {
keyboard.endTyping(true);
}
that.startRestorePoint = new RestorePoint(editor.getRange(), editor.body);
return true;
}
if (keyboard.isSystem(e)) {
that.systemCommandIsInProgress = true;
if (that.changed()) {
that.systemCommandIsInProgress = false;
that.createUndoCommand();
}
return true;
}
return false;
},
keyup: function () {
var that = this;
if (that.systemCommandIsInProgress && that.changed()) {
that.systemCommandIsInProgress = false;
that.createUndoCommand();
return true;
}
return false;
}
});
var SelectAllHandler = Class.extend({
init: function (editor) {
this.editor = editor;
},
keydown: function (e) {
if (!browser.webkit || e.isDefaultPrevented() || !(e.ctrlKey && e.keyCode == 65 && !e.altKey && !e.shiftKey)) {
return;
}
if (this.editor.options.immutables) {
this._toSelectableImmutables();
}
this._selectEditorBody();
},
_selectEditorBody: function () {
var editor = this.editor;
var range = editor.getRange();
range.selectNodeContents(editor.body);
editor.selectRange(range);
},
_toSelectableImmutables: function () {
var editor = this.editor, body = editor.body, immutable = editorNS.Immutables.immutable, emptyTextNode = dom.emptyTextNode, first = body.firstChild, last = body.lastChild;
while (emptyTextNode(first)) {
first = first.nextSibling;
}
while (emptyTextNode(last)) {
last = last.previousSibling;
}
if (first && immutable(first)) {
$(br).prependTo(body);
}
if (last && immutable(last)) {
$(br).appendTo(body);
}
},
keyup: $.noop
});
var Keyboard = Class.extend({
init: function (handlers) {
this.handlers = handlers;
this.typingInProgress = false;
},
isCharacter: function (keyCode) {
return keyCode >= 48 && keyCode <= 90 || keyCode >= 96 && keyCode <= 111 || keyCode >= 186 && keyCode <= 192 || keyCode >= 219 && keyCode <= 222 || keyCode == 229;
},
toolFromShortcut: function (tools, e) {
var key = String.fromCharCode(e.keyCode), toolName, toolOptions, modifier = this._getShortcutModifier(e, navigator.platform);
for (toolName in tools) {
toolOptions = $.extend({
ctrl: false,
alt: false,
shift: false
}, tools[toolName].options);
if ((toolOptions.key == key || toolOptions.key == e.keyCode) && toolOptions.ctrl == modifier && toolOptions.alt == e.altKey && toolOptions.shift == e.shiftKey) {
return toolName;
}
}
},
_getShortcutModifier: function (e, platform) {
var mac = platform.toUpperCase().indexOf('MAC') >= 0;
return mac ? e.metaKey : e.ctrlKey;
},
toolsFromShortcut: function (tools, e) {
var key = String.fromCharCode(e.keyCode), toolName, o, matchesKey, found = [];
var matchKey = function (toolKey) {
return toolKey == key || toolKey == e.keyCode || toolKey == e.charCode;
};
for (toolName in tools) {
o = $.extend({
ctrl: false,
alt: false,
shift: false
}, tools[toolName].options);
matchesKey = $.isArray(o.key) ? $.grep(o.key, matchKey).length > 0 : matchKey(o.key);
if (matchesKey && o.ctrl == e.ctrlKey && o.alt == e.altKey && o.shift == e.shiftKey) {
found.push(tools[toolName]);
}
}
return found;
},
isTypingKey: function (e) {
var keyCode = e.keyCode;
return this.isCharacter(keyCode) && !e.ctrlKey && !e.altKey || keyCode == 32 || keyCode == 13 || keyCode == 8 || keyCode == 46 && !e.shiftKey && !e.ctrlKey && !e.altKey;
},
isModifierKey: function (e) {
var keyCode = e.keyCode;
return keyCode == 17 && !e.shiftKey && !e.altKey || keyCode == 16 && !e.ctrlKey && !e.altKey || keyCode == 18 && !e.ctrlKey && !e.shiftKey;
},
isSystem: function (e) {
return e.keyCode == 46 && e.ctrlKey && !e.altKey && !e.shiftKey;
},
startTyping: function (callback) {
this.onEndTyping = callback;
this.typingInProgress = true;
},
stopTyping: function () {
if (this.typingInProgress && this.onEndTyping) {
this.onEndTyping();
}
this.typingInProgress = false;
},
endTyping: function (force) {
var that = this;
that.clearTimeout();
if (force) {
that.stopTyping();
} else {
that.timeout = window.setTimeout($.proxy(that.stopTyping, that), 1000);
}
},
isTypingInProgress: function () {
return this.typingInProgress;
},
clearTimeout: function () {
window.clearTimeout(this.timeout);
},
notify: function (e, what) {
var i, handlers = this.handlers;
for (i = 0; i < handlers.length; i++) {
if (handlers[i][what](e)) {
break;
}
}
},
keydown: function (e) {
this.notify(e, 'keydown');
},
keyup: function (e) {
this.notify(e, 'keyup');
}
});
extend(editorNS, {
TypingHandler: TypingHandler,
SystemHandler: SystemHandler,
BackspaceHandler: BackspaceHandler,
SelectAllHandler: SelectAllHandler,
Keyboard: Keyboard
});
}(window.kendo.jQuery));
}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {
(a3 || a2)();
}));
(function (f, define) {
define('editor/plugins/exportpdf', ['editor/command'], f);
}(function () {
(function ($) {
var kendo = window.kendo, editorNS = kendo.ui.editor, Command = editorNS.Command, EditorUtils = editorNS.EditorUtils, registerTool = EditorUtils.registerTool, Tool = editorNS.Tool, ToolTemplate = editorNS.ToolTemplate, extend = $.extend;
var ExportPdfCommand = Command.extend({
init: function (options) {
this.async = true;
Command.fn.init.call(this, options);
},
exec: function () {
var that = this;
var range = that.lockRange(true);
var editor = that.editor;
editor._destroyResizings();
editor.saveAsPDF().then(function () {
that.releaseRange(range);
editor._initializeColumnResizing();
editor._initializeRowResizing();
editor._initializeTableResizing();
});
}
});
extend(editorNS, { ExportPdfCommand: ExportPdfCommand });
registerTool('pdf', new Tool({
command: ExportPdfCommand,
template: new ToolTemplate({
template: EditorUtils.buttonTemplate,
title: 'Export PDF'
})
}));
}(window.kendo.jQuery));
}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {
(a3 || a2)();
}));
(function (f, define) {
define('editor/plugins/print', ['editor/command'], f);
}(function () {
(function ($) {
var kendo = window.kendo, editorNS = kendo.ui.editor, Command = editorNS.Command, EditorUtils = editorNS.EditorUtils, registerTool = EditorUtils.registerTool, Tool = editorNS.Tool, ToolTemplate = editorNS.ToolTemplate, extend = $.extend;
var PrintCommand = Command.extend({
init: function (options) {
Command.fn.init.call(this, options);
this.managesUndoRedo = true;
},
exec: function () {
var editor = this.editor;
if (kendo.support.browser.msie) {
editor.document.execCommand('print', false, null);
} else if (editor.window.print) {
editor.window.print();
}
}
});
extend(editorNS, { PrintCommand: PrintCommand });
registerTool('print', new Tool({
command: PrintCommand,
template: new ToolTemplate({
template: EditorUtils.buttonTemplate,
title: 'Print'
})
}));
}(window.kendo.jQuery));
}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {
(a3 || a2)();
}));
(function (f, define) {
define('editor/resizing/resizing-utils', ['editor/main'], f);
}(function () {
(function (kendo, undefined) {
var global = window;
var math = global.Math;
var min = math.min;
var max = math.max;
var parseFloat = global.parseFloat;
var $ = kendo.jQuery;
var extend = $.extend;
var Editor = kendo.ui.editor;
var PERCENTAGE = '%';
var PIXEL = 'px';
var REGEX_NUMBER_IN_PERCENTAGES = /(\d+)(\.?)(\d*)%/;
var REGEX_NUMBER_IN_PIXELS = /(\d+)(\.?)(\d*)px/;
var STRING = 'string';
function constrain(options) {
var value = options.value;
var lowerBound = options.min;
var upperBound = options.max;
return max(min(parseFloat(value), parseFloat(upperBound)), parseFloat(lowerBound));
}
function getScrollBarWidth(element) {
if (element && !$(element).is('body') && element.scrollHeight > element.clientHeight) {
return kendo.support.scrollbar();
}
return 0;
}
function calculatePercentageRatio(value, total) {
if (inPercentages(value)) {
return parseFloat(value);
} else {
return parseFloat(value) / total * 100;
}
}
function inPercentages(value) {
return typeof value === STRING && REGEX_NUMBER_IN_PERCENTAGES.test(value);
}
function inPixels(value) {
return typeof value === STRING && REGEX_NUMBER_IN_PIXELS.test(value);
}
function toPercentages(value) {
return parseFloat(value) + PERCENTAGE;
}
function toPixels(value) {
return parseFloat(value) + PIXEL;
}
var ResizingUtils = {
constrain: constrain,
getScrollBarWidth: getScrollBarWidth,
calculatePercentageRatio: calculatePercentageRatio,
inPercentages: inPercentages,
inPixels: inPixels,
toPercentages: toPercentages,
toPixels: toPixels
};
extend(Editor, { ResizingUtils: ResizingUtils });
}(window.kendo));
}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {
(a3 || a2)();
}));
(function (f, define) {
define('editor/resizing/table-element-resizing', [
'editor/main',
'kendo.resizable',
'editor/resizing/resizing-utils'
], f);
}(function () {
(function (kendo, undefined) {
var $ = kendo.jQuery;
var extend = $.extend;
var noop = $.noop;
var proxy = $.proxy;
var Editor = kendo.ui.editor;
var Class = kendo.Class;
var KEY_DOWN = 'keydown';
var MOUSE_DOWN = 'mousedown';
var MOUSE_ENTER = 'mouseenter';
var MOUSE_LEAVE = 'mouseleave';
var MOUSE_MOVE = 'mousemove';
var MOUSE_UP = 'mouseup';
var COMMA = ',';
var DOT = '.';
var LAST_CHILD = ':last-child';
var TABLE = 'table';
var TableElementResizing = Class.extend({
init: function (element, options) {
var that = this;
that.options = extend({}, that.options, options);
that.options.tags = $.isArray(that.options.tags) ? that.options.tags : [that.options.tags];
if ($(element).is(TABLE)) {
that.element = element;
that._attachEventHandlers();
}
},
destroy: function () {
var that = this;
var eventNamespace = that.options.eventNamespace;
if (that.element) {
$(that.element).off(eventNamespace);
that.element = null;
}
$(that.options.rootElement).off(KEY_DOWN + eventNamespace);
that._destroyResizeHandle();
},
options: {
tags: [],
min: 0,
rootElement: null,
eventNamespace: '',
rtl: false,
handle: {
dataAttribute: '',
height: 0,
width: 0,
classNames: {},
template: ''
}
},
_attachEventHandlers: function () {
var that = this;
var options = that.options;
$(that.element).on(MOUSE_MOVE + options.eventNamespace, options.tags.join(COMMA), proxy(that.detectElementBorderHovering, that));
},
resizingInProgress: function () {
var that = this;
var resizable = that._resizable;
if (resizable) {
return !!resizable.resizing;
}
return false;
},
resize: noop,
detectElementBorderHovering: function (e) {
var that = this;
var options = that.options;
var handleOptions = options.handle;
var tableElement = $(e.currentTarget);
var resizeHandle = that.resizeHandle;
var dataAttribute = handleOptions.dataAttribute;
if (!that.resizingInProgress()) {
if (!tableElement.is(LAST_CHILD) && that.elementBorderHovered(tableElement, e)) {
if (resizeHandle) {
if (resizeHandle.data(dataAttribute) && resizeHandle.data(dataAttribute) !== tableElement[0]) {
that.showResizeHandle(tableElement, e);
}
} else {
that.showResizeHandle(tableElement, e);
}
} else {
if (resizeHandle) {
that._destroyResizeHandle();
}
}
}
},
elementBorderHovered: noop,
showResizeHandle: function (tableElement, e) {
var that = this;
if (e.buttons !== 0) {
return;
}
that._initResizeHandle();
that.setResizeHandlePosition(tableElement);
that.setResizeHandleDimensions();
that.setResizeHandleDataAttributes(tableElement[0]);
that._attachResizeHandleEventHandlers();
that._initResizable(tableElement);
that._hideResizeMarker();
that.resizeHandle.show();
},
_initResizeHandle: function () {
var that = this;
var options = that.options;
that._destroyResizeHandle();
that.resizeHandle = $(options.handle.template).appendTo(options.rootElement);
},
setResizeHandlePosition: noop,
setResizeHandleDimensions: noop,
setResizeHandleDataAttributes: function (tableElement) {
var that = this;
that.resizeHandle.data(that.options.handle.dataAttribute, tableElement);
},
_attachResizeHandleEventHandlers: function () {
var that = this;
var options = that.options;
var eventNamespace = options.eventNamespace;
var markerClass = options.handle.classNames.marker;
var resizeHandle = that.resizeHandle;
that.resizeHandle.on(MOUSE_DOWN + eventNamespace, function () {
resizeHandle.find(DOT + markerClass).show();
}).on(MOUSE_UP + eventNamespace, function () {
resizeHandle.find(DOT + markerClass).hide();
});
},
_hideResizeMarker: function () {
var that = this;
that.resizeHandle.find(DOT + that.options.handle.classNames.marker).hide();
},
_destroyResizeHandle: function () {
var that = this;
if (that.resizeHandle) {
that._destroyResizable();
that.resizeHandle.off(that.options.eventNamespace).remove();
that.resizeHandle = null;
}
},
_initResizable: function (tableElement) {
var that = this;
if (!that.resizeHandle) {
return;
}
that._destroyResizable();
that._resizable = new kendo.ui.Resizable(tableElement, {
draggableElement: that.resizeHandle[0],
start: proxy(that.onResizeStart, that),
resize: proxy(that.onResize, that),
resizeend: proxy(that.onResizeEnd, that)
});
},
_destroyResizable: function () {
var that = this;
if (that._resizable) {
that._resizable.destroy();
that._resizable = null;
}
},
onResizeStart: function () {
this._disableKeyboard();
},
onResize: function (e) {
this.setResizeHandleDragPosition(e);
},
setResizeHandleDragPosition: noop,
onResizeEnd: function (e) {
var that = this;
that.resize(e);
that._destroyResizeHandle();
that._enableKeyboard();
},
_enableKeyboard: function () {
var options = this.options;
$(options.rootElement).off(KEY_DOWN + options.eventNamespace);
},
_disableKeyboard: function () {
var options = this.options;
$(options.rootElement).on(KEY_DOWN + options.eventNamespace, function (e) {
e.preventDefault();
});
},
_forceResizing: function (e) {
var resizable = this._resizable;
if (resizable && resizable.userEvents) {
resizable.userEvents._end(e);
}
}
});
var ResizingFactory = Class.extend({
create: function (editor, options) {
var that = this;
var resizingName = options.name;
var NS = options.eventNamespace;
$(editor.body).on(MOUSE_ENTER + NS, TABLE, function (e) {
var table = e.currentTarget;
var resizing = editor[resizingName];
e.stopPropagation();
if (resizing) {
if (resizing.element !== table && !resizing.resizingInProgress()) {
that._destroyResizing(editor, options);
that._initResizing(editor, table, options);
}
} else {
that._initResizing(editor, table, options);
}
}).on(MOUSE_LEAVE + NS, TABLE, function (e) {
var parentTable;
var resizing = editor[resizingName];
e.stopPropagation();
if (resizing && !resizing.resizingInProgress() && !resizing.resizeHandle) {
parentTable = $(resizing.element).parents(TABLE)[0];
if (parentTable) {
that._destroyResizing(editor, options);
that._initResizing(editor, parentTable, options);
}
}
}).on(MOUSE_LEAVE + NS, function () {
var resizing = editor[resizingName];
if (resizing && !resizing.resizingInProgress()) {
that._destroyResizing(editor, options);
}
}).on(MOUSE_UP + NS, function (e) {
var resizing = editor[resizingName];
var parentTable;
if (resizing && resizing.resizingInProgress()) {
parentTable = $(e.target).parents(TABLE)[0];
if (parentTable) {
resizing._forceResizing(e);
that._destroyResizing(editor, options);
that._initResizing(editor, parentTable, options);
}
}
});
},
dispose: function (editor, options) {
$(editor.body).off(options.eventNamespace);
},
_initResizing: function (editor, tableElement, options) {
var resizingName = options.name;
var resizingType = options.type;
editor[resizingName] = new resizingType(tableElement, {
rtl: kendo.support.isRtl(editor.element),
rootElement: editor.body
});
},
_destroyResizing: function (editor, options) {
var resizingName = options.name;
if (editor[resizingName]) {
editor[resizingName].destroy();
editor[resizingName] = null;
}
}
});
ResizingFactory.current = new ResizingFactory();
TableElementResizing.create = function (editor, options) {
ResizingFactory.current.create(editor, options);
};
TableElementResizing.dispose = function (editor, options) {
ResizingFactory.current.dispose(editor, options);
};
extend(Editor, { TableElementResizing: TableElementResizing });
}(window.kendo));
}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {
(a3 || a2)();
}));
(function (f, define) {
define('editor/resizing/column-resizing', [
'editor/main',
'editor/resizing/resizing-utils',
'editor/resizing/table-element-resizing'
], f);
}(function () {
(function (kendo, undefined) {
var global = window;
var math = global.Math;
var abs = math.abs;
var $ = kendo.jQuery;
var extend = $.extend;
var Editor = kendo.ui.editor;
var TableElementResizing = Editor.TableElementResizing;
var ResizingUtils = Editor.ResizingUtils;
var constrain = ResizingUtils.constrain;
var calculatePercentageRatio = ResizingUtils.calculatePercentageRatio;
var getScrollBarWidth = ResizingUtils.getScrollBarWidth;
var inPercentages = ResizingUtils.inPercentages;
var toPercentages = ResizingUtils.toPercentages;
var toPixels = ResizingUtils.toPixels;
var outerWidth = kendo._outerWidth;
var NS = '.kendoEditorColumnResizing';
var RESIZE_HANDLE_CLASS = 'k-column-resize-handle';
var RESIZE_MARKER_CLASS = 'k-column-resize-marker';
var BODY = 'body';
var TBODY = 'tbody';
var TD = 'td';
var TH = 'th';
var TR = 'tr';
var COMMA = ',';
var WIDTH = 'width';
var ColumnResizing = TableElementResizing.extend({
options: {
tags: [
TD,
TH
],
min: 20,
rootElement: null,
eventNamespace: NS,
rtl: false,
handle: {
dataAttribute: 'column',
width: 10,
height: 0,
classNames: {
handle: RESIZE_HANDLE_CLASS,
marker: RESIZE_MARKER_CLASS
},
template: '
'
}
},
elementBorderHovered: function (column, e) {
var that = this;
var options = that.options;
var handleWidth = options.handle.width;
var borderOffset = column.offset().left + (options.rtl ? 0 : outerWidth(column));
var mousePosition = e.clientX + $(column[0].ownerDocument).scrollLeft();
if (mousePosition > borderOffset - handleWidth && mousePosition < borderOffset + handleWidth) {
return true;
} else {
return false;
}
},
setResizeHandlePosition: function (column) {
var that = this;
var tableBody = $(that.element).children(TBODY);
var options = that.options;
var rtl = options.rtl;
var handleWidth = options.handle.width;
var rootElement = $(options.rootElement);
var scrollTopOffset = rootElement.is(BODY) ? 0 : rootElement.scrollTop();
var scrollLeftOffset = rootElement.is(BODY) ? 0 : rootElement.scrollLeft();
var columnWidthOffset = rtl ? 0 : outerWidth(column);
var scrollBarWidth = rtl ? getScrollBarWidth(rootElement[0]) : 0;
var columnOffsetLeft = column.offset().left - (rootElement.offset().left + parseFloat(rootElement.css('borderLeftWidth'))) - parseFloat(column.css('marginLeft'));
var tBodyOffsetTop = tableBody.offset().top - (rootElement.offset().top + parseFloat(rootElement.css('borderTopWidth'))) - parseFloat(tableBody.css('marginTop'));
that.resizeHandle.css({
top: tBodyOffsetTop + scrollTopOffset,
left: columnOffsetLeft + columnWidthOffset + (scrollLeftOffset - scrollBarWidth) - handleWidth / 2,
position: 'absolute'
});
},
setResizeHandleDimensions: function () {
var that = this;
var tableBody = $(that.element).children(TBODY);
that.resizeHandle.css({
width: that.options.handle.width,
height: tableBody.height()
});
},
setResizeHandleDragPosition: function (e) {
var that = this;
var column = $($(e.currentTarget).data(that.options.handle.dataAttribute));
var options = that.options;
var rootElement = $(options.rootElement);
var handleWidth = options.handle ? options.handle.width : 0;
var min = options.min;
var rtl = options.rtl;
var columnWidth = outerWidth(column);
var columnLeftOffset = column.offset().left - (rootElement.offset().left + parseFloat(rootElement.css('borderLeftWidth'))) - parseFloat(column.css('marginLeft'));
var adjacentColumnWidth = outerWidth(column.next());
var resizeHandle = $(that.resizeHandle);
var scrollLeftOffset = rootElement.is(BODY) ? 0 : rootElement.scrollLeft();
var scrollBarWidth = rtl ? getScrollBarWidth(rootElement[0]) : 0;
var resizeHandleOffsetLeft = resizeHandle.offset().left - (rootElement.offset().left + parseFloat(rootElement.css('borderLeftWidth'))) - parseFloat(resizeHandle.css('marginLeft'));
var handleOffset = constrain({
value: resizeHandleOffsetLeft + (scrollLeftOffset - scrollBarWidth) + e.x.delta,
min: columnLeftOffset + (scrollLeftOffset - scrollBarWidth) - (rtl ? adjacentColumnWidth : 0) + min,
max: columnLeftOffset + columnWidth + (scrollLeftOffset - scrollBarWidth) + (rtl ? 0 : adjacentColumnWidth) - handleWidth - min
});
resizeHandle.css({ left: handleOffset });
},
resize: function (e) {
var that = this;
var column = $($(e.currentTarget).data(that.options.handle.dataAttribute));
var options = that.options;
var rtlModifier = options.rtl ? -1 : 1;
var min = options.min;
var initialDeltaX = rtlModifier * e.x.initialDelta;
var newWidth;
var initialAdjacentColumnWidth;
var initialColumnWidth;
that._setTableComputedWidth();
that._setColumnsComputedWidth();
initialColumnWidth = outerWidth(column);
initialAdjacentColumnWidth = outerWidth(column.next());
newWidth = constrain({
value: initialColumnWidth + initialDeltaX,
min: min,
max: initialColumnWidth + initialAdjacentColumnWidth - min
});
that._resizeColumn(column[0], newWidth);
that._resizeTopAndBottomColumns(column[0], newWidth);
that._resizeAdjacentColumns(column.index(), initialAdjacentColumnWidth, initialColumnWidth, initialColumnWidth - newWidth);
},
_setTableComputedWidth: function () {
var element = this.element;
if (element.style[WIDTH] === '') {
element.style[WIDTH] = toPixels(outerWidth($(element)));
}
},
_setColumnsComputedWidth: function () {
var that = this;
var tableBody = $(that.element).children(TBODY);
var tableBodyWidth = outerWidth(tableBody);
var columns = tableBody.children(TR).children(TD);
var length = columns.length;
var currentColumnsWidths = columns.map(function () {
return outerWidth($(this));
});
var i;
for (i = 0; i < length; i++) {
if (inPercentages(columns[i].style[WIDTH])) {
columns[i].style[WIDTH] = toPercentages(calculatePercentageRatio(currentColumnsWidths[i], tableBodyWidth));
} else {
columns[i].style[WIDTH] = toPixels(currentColumnsWidths[i]);
}
}
},
_resizeTopAndBottomColumns: function (column, newWidth) {
var that = this;
var columnIndex = $(column).index();
var topAndBottomColumns = $(that.element).children(TBODY).children(TR).children(that.options.tags.join(COMMA)).filter(function () {
var cell = this;
return $(cell).index() === columnIndex && cell !== column;
});
var length = topAndBottomColumns.length;
var i;
for (i = 0; i < length; i++) {
that._resizeColumn(topAndBottomColumns[i], newWidth);
}
},
_resizeColumn: function (column, newWidth) {
if (inPercentages(column.style[WIDTH])) {
column.style[WIDTH] = toPercentages(calculatePercentageRatio(newWidth, outerWidth($(this.element).children(TBODY))));
} else {
column.style[WIDTH] = toPixels(newWidth);
}
},
_resizeAdjacentColumns: function (columnIndex, initialAdjacentColumnWidth, initialColumnWidth, deltaWidth) {
var that = this;
var adjacentColumns = $(that.element).children(TBODY).children(TR).children(that.options.tags.join(COMMA)).filter(function () {
return $(this).index() === columnIndex + 1;
});
var length = adjacentColumns.length;
var i;
for (i = 0; i < length; i++) {
that._resizeAdjacentColumn(adjacentColumns[i], initialAdjacentColumnWidth, initialColumnWidth, deltaWidth);
}
},
_resizeAdjacentColumn: function (adjacentColumn, initialAdjacentColumnWidth, initialColumnWidth, deltaWidth) {
var that = this;
var min = that.options.min;
var newWidth;
newWidth = constrain({
value: initialAdjacentColumnWidth + deltaWidth,
min: min,
max: abs(initialColumnWidth + initialAdjacentColumnWidth - min)
});
that._resizeColumn(adjacentColumn, newWidth);
}
});
ColumnResizing.create = function (editor) {
TableElementResizing.create(editor, {
name: 'columnResizing',
type: ColumnResizing,
eventNamespace: NS
});
};
ColumnResizing.dispose = function (editor) {
TableElementResizing.dispose(editor, { eventNamespace: NS });
};
extend(Editor, { ColumnResizing: ColumnResizing });
}(window.kendo));
}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {
(a3 || a2)();
}));
(function (f, define) {
define('editor/resizing/row-resizing', [
'editor/main',
'editor/resizing/resizing-utils',
'editor/resizing/table-element-resizing'
], f);
}(function () {
(function (kendo, undefined) {
var math = window.Math;
var abs = math.abs;
var $ = kendo.jQuery;
var extend = $.extend;
var Editor = kendo.ui.editor;
var TableElementResizing = Editor.TableElementResizing;
var ResizingUtils = Editor.ResizingUtils;
var getScrollBarWidth = ResizingUtils.getScrollBarWidth;
var constrain = ResizingUtils.constrain;
var calculatePercentageRatio = ResizingUtils.calculatePercentageRatio;
var inPercentages = ResizingUtils.inPercentages;
var toPercentages = ResizingUtils.toPercentages;
var toPixels = ResizingUtils.toPixels;
var outerHeight = kendo._outerHeight;
var NS = '.kendoEditorRowResizing';
var RESIZE_HANDLE_CLASS = 'k-row-resize-handle';
var RESIZE_HANDLE_MARKER_WRAPPER_CLASS = 'k-row-resize-marker-wrapper';
var RESIZE_MARKER_CLASS = 'k-row-resize-marker';
var BODY = 'body';
var TR = 'tr';
var TBODY = 'tbody';
var HEIGHT = 'height';
var RowResizing = TableElementResizing.extend({
options: {
tags: [TR],
min: 20,
rootElement: null,
eventNamespace: NS,
rtl: false,
handle: {
dataAttribute: 'row',
width: 0,
height: 10,
classNames: {
handle: RESIZE_HANDLE_CLASS,
marker: RESIZE_MARKER_CLASS
},
template: '
'
}
},
elementBorderHovered: function (tableElement, e) {
var that = this;
var handleHeight = that.options.handle[HEIGHT];
var borderOffset = tableElement.offset().top + outerHeight(tableElement);
var mousePosition = e.clientY + $(tableElement[0].ownerDocument).scrollTop();
if (mousePosition > borderOffset - handleHeight && mousePosition < borderOffset + handleHeight) {
return true;
} else {
return false;
}
},
setResizeHandlePosition: function (row) {
var that = this;
var options = that.options;
var handleHeight = options.handle[HEIGHT];
var rootElement = $(options.rootElement);
var scrollTopOffset = rootElement.is(BODY) ? 0 : rootElement.scrollTop();
var scrollLeftOffset = rootElement.is(BODY) ? 0 : rootElement.scrollLeft();
var scrollBarWidth = options.rtl ? getScrollBarWidth(rootElement[0]) : 0;
var rowOffsetLeft = row.offset().left - (rootElement.offset().left + parseFloat(rootElement.css('borderLeftWidth'))) - parseFloat(row.css('marginLeft'));
var rowOffsetTop = row.offset().top - (rootElement.offset().top + parseFloat(rootElement.css('borderTopWidth'))) - parseFloat(row.css('marginTop'));
that.resizeHandle.css({
top: rowOffsetTop + outerHeight(row) + scrollTopOffset - handleHeight / 2,
left: rowOffsetLeft + (scrollLeftOffset - scrollBarWidth),
position: 'absolute'
});
},
setResizeHandleDimensions: function () {
var that = this;
that.resizeHandle.css({
width: $(that.element).children(TBODY).width(),
height: that.options.handle[HEIGHT]
});
},
setResizeHandleDragPosition: function (e) {
var that = this;
var options = that.options;
var min = options.min;
var tableBody = $(that.element).children(TBODY);
var resizeHandle = $(that.resizeHandle);
var row = $(e.currentTarget).data(options.handle.dataAttribute);
var $row = $(row);
var rootElement = $(options.rootElement);
var scrollTopOffset = rootElement.is(BODY) ? 0 : rootElement.scrollTop();
var tableBodyTopOffset = tableBody.offset().top - (rootElement.offset().top + parseFloat(rootElement.css('borderTopWidth'))) - parseFloat(tableBody.css('marginTop'));
var rowOffsetTop = $row.offset().top - (rootElement.offset().top + parseFloat(rootElement.css('borderTopWidth'))) - parseFloat($row.css('marginTop'));
var resizeHandleOffsetTop = resizeHandle.offset().top - (rootElement.offset().top + parseFloat(rootElement.css('borderTopWidth'))) - parseFloat(resizeHandle.css('marginTop'));
var handleOffset = constrain({
value: resizeHandleOffsetTop + scrollTopOffset + e.y.delta,
min: rowOffsetTop + scrollTopOffset + min,
max: tableBodyTopOffset + outerHeight(tableBody) + scrollTopOffset - options.handle[HEIGHT] - min
});
resizeHandle.css({ top: handleOffset });
},
resize: function (e) {
var that = this;
var options = that.options;
var row = $(e.currentTarget).data(options.handle.dataAttribute);
var currentRowHeight = outerHeight($(row));
var element = $(that.element);
var initialTableHeight = outerHeight(element);
var tableBody = element.children(TBODY);
var tableBodyHeight = tableBody.height();
var initialStyleHeight = row.style[HEIGHT];
var newRowHeight = constrain({
value: currentRowHeight + e.y.initialDelta,
min: options.min,
max: abs(tableBodyHeight - options.min)
});
that._setRowsHeightInPixels();
row.style[HEIGHT] = toPixels(newRowHeight);
that._setTableHeight(initialTableHeight + (newRowHeight - currentRowHeight));
if (inPercentages(initialStyleHeight)) {
that._setRowsHeightInPercentages();
}
},
_setRowsHeightInPixels: function () {
var that = this;
var rows = $(that.element).children(TBODY).children(TR);
var length = rows.length;
var currentRowsHeights = rows.map(function () {
return outerHeight($(this));
});
var i;
for (i = 0; i < length; i++) {
rows[i].style[HEIGHT] = toPixels(currentRowsHeights[i]);
}
},
_setRowsHeightInPercentages: function () {
var that = this;
var tableBody = $(that.element).children(TBODY);
var tableBodyHeight = tableBody.height();
var rows = tableBody.children(TR);
var length = rows.length;
var currentRowsHeights = rows.map(function () {
return outerHeight($(this));
});
var i;
for (i = 0; i < length; i++) {
rows[i].style[HEIGHT] = toPercentages(calculatePercentageRatio(currentRowsHeights[i], tableBodyHeight));
}
},
_setTableHeight: function (newHeight) {
var element = this.element;
if (inPercentages(element.style[HEIGHT])) {
element.style[HEIGHT] = toPercentages(calculatePercentageRatio(newHeight, $(element).parent().height()));
} else {
element.style[HEIGHT] = toPixels(newHeight);
}
}
});
RowResizing.create = function (editor) {
TableElementResizing.create(editor, {
name: 'rowResizing',
type: RowResizing,
eventNamespace: NS
});
};
RowResizing.dispose = function (editor) {
TableElementResizing.dispose(editor, { eventNamespace: NS });
};
extend(Editor, { RowResizing: RowResizing });
}(window.kendo));
}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {
(a3 || a2)();
}));
(function (f, define) {
define('editor/resizing/table-resize-handle', [
'editor/main',
'kendo.draganddrop',
'editor/resizing/resizing-utils'
], f);
}(function () {
(function (kendo, undefined) {
var $ = kendo.jQuery;
var extend = $.extend;
var noop = $.noop;
var proxy = $.proxy;
var Editor = kendo.ui.editor;
var Class = kendo.Class;
var Draggable = kendo.ui.Draggable;
var Observable = kendo.Observable;
var getScrollBarWidth = Editor.ResizingUtils.getScrollBarWidth;
var outerWidth = kendo._outerWidth;
var outerHeight = kendo._outerHeight;
var NS = '.kendoEditorTableResizeHandle';
var RESIZE_HANDLE_CLASS = 'k-table-resize-handle';
var DRAG_START = 'dragStart';
var DRAG = 'drag';
var DRAG_END = 'dragEnd';
var HALF_INSIDE = 'halfInside';
var MOUSE_OVER = 'mouseover';
var MOUSE_OUT = 'mouseout';
var BODY = 'body';
var TABLE = 'table';
var EAST = 'east';
var NORTH = 'north';
var NORTHEAST = 'northeast';
var NORTHWEST = 'northwest';
var SOUTH = 'south';
var SOUTHEAST = 'southeast';
var SOUTHWEST = 'southwest';
var WEST = 'west';
var DOT = '.';
var TableResizeHandle = Observable.extend({
init: function (options) {
var that = this;
Observable.fn.init.call(that);
that.options = extend({}, that.options, options);
that.element = $(that.options.template).appendTo(that.options.appendTo)[0];
that._attachEventHandlers();
that._addStyles();
that._initDraggable();
that._initPositioningStrategy();
that._initDraggingStrategy();
$(that.element).data(TABLE, that.options.resizableElement);
},
destroy: function () {
var that = this;
$(that.element).off(NS).remove();
that.element = null;
that._destroyDraggable();
that.unbind();
},
options: {
appendTo: null,
direction: SOUTHEAST,
resizableElement: null,
rtl: false,
template: '
'
},
events: [
DRAG_START,
DRAG,
DRAG_END,
MOUSE_OVER,
MOUSE_OUT
],
show: function () {
this._setPosition();
},
_setPosition: function () {
var that = this;
var position = that._positioningStrategy.getPosition();
$(that.element).css({
top: position.top,
left: position.left,
position: 'absolute'
});
},
_attachEventHandlers: function () {
var that = this;
$(that.element).on(MOUSE_OVER + NS, proxy(that._onMouseOver, that)).on(MOUSE_OUT + NS, proxy(that._onMouseOut, that));
},
_onMouseOver: function () {
this.trigger(MOUSE_OVER);
},
_onMouseOut: function () {
this.trigger(MOUSE_OUT);
},
_addStyles: function () {
var that = this;
$(that.element).children(DOT + RESIZE_HANDLE_CLASS).addClass('k-resize-' + that.options.direction);
},
_initPositioningStrategy: function () {
var that = this;
var options = that.options;
that._positioningStrategy = HandlePositioningStrategy.create({
name: options.direction,
handle: that.element,
resizableElement: options.resizableElement,
rootElement: options.rootElement,
rtl: options.rtl
});
},
_initDraggable: function () {
var that = this;
var element = that.element;
if (that._draggable || !element) {
return;
}
that._draggable = new Draggable(element, {
dragstart: proxy(that._onDragStart, that),
drag: proxy(that._onDrag, that),
dragend: proxy(that._onDragEnd, that)
});
},
_onDragStart: function () {
this.trigger(DRAG_START);
},
_onDrag: function (e) {
var that = this;
that.trigger(DRAG, that._draggingStrategy.adjustDragDelta({
deltaX: e.x.delta,
deltaY: e.y.delta,
initialDeltaX: e.x.initialDelta,
initialDeltaY: e.y.initialDelta
}));
},
_onDragEnd: function () {
this.trigger(DRAG_END);
},
_destroyDraggable: function () {
var that = this;
if (that._draggable) {
that._draggable.destroy();
that._draggable = null;
}
},
_initDraggingStrategy: function () {
var that = this;
that._draggingStrategy = HandleDraggingStrategy.create({ name: that.options.direction });
}
});
var StrategyFactory = Class.extend({
init: function () {
this._items = [];
},
register: function (name, type) {
this._items.push({
name: name,
type: type
});
},
create: function (options) {
var items = this._items;
var itemsLength = items.length;
var name = options.name ? options.name.toLowerCase() : '';
var match;
var item;
var i;
for (i = 0; i < itemsLength; i++) {
item = items[i];
if (item.name.toLowerCase() === name) {
match = item;
break;
}
}
if (match) {
return new match.type(options);
}
}
});
var PositioningStrategyFactory = StrategyFactory.extend({});
PositioningStrategyFactory.current = new PositioningStrategyFactory();
var HandlePositioningStrategy = Class.extend({
init: function (options) {
var that = this;
that.options = extend({}, that.options, options);
},
options: {
handle: null,
offset: HALF_INSIDE,
resizableElement: null,
rootElement: null,
rtl: false
},
getPosition: function () {
var that = this;
var position = that.calculatePosition();
var handleOffsetPosition = that.applyHandleOffset(position);
var scrollOffsetPosition = that.applyScrollOffset(handleOffsetPosition);
return scrollOffsetPosition;
},
calculatePosition: noop,
applyHandleOffset: function (position) {
var options = this.options;
var handle = $(options.handle);
if (options.offset === HALF_INSIDE) {
return {
top: position.top - outerHeight(handle) / 2,
left: position.left - outerWidth(handle) / 2
};
}
return position;
},
applyScrollOffset: function (position) {
var options = this.options;
var rootElement = $(options.rootElement);
var scrollBarWidth = options.rtl ? getScrollBarWidth(rootElement[0]) : 0;
if (!rootElement.is(BODY)) {
return {
top: position.top + (rootElement.scrollTop() || 0),
left: position.left + (rootElement.scrollLeft() || 0) - scrollBarWidth
};
}
return position;
}
});
HandlePositioningStrategy.create = function (options) {
return PositioningStrategyFactory.current.create(options);
};
var EastPositioningStrategy = HandlePositioningStrategy.extend({
calculatePosition: function () {
var resizableElement = $(this.options.resizableElement);
var offset = resizableElement.position();
return {
top: offset.top + outerHeight(resizableElement) / 2,
left: offset.left + outerWidth(resizableElement)
};
}
});
PositioningStrategyFactory.current.register(EAST, EastPositioningStrategy);
var NorthPositioningStrategy = HandlePositioningStrategy.extend({
calculatePosition: function () {
var resizableElement = $(this.options.resizableElement);
var offset = resizableElement.position();
return {
top: offset.top,
left: offset.left + outerWidth(resizableElement) / 2
};
}
});
PositioningStrategyFactory.current.register(NORTH, NorthPositioningStrategy);
var NortheastPositioningStrategy = HandlePositioningStrategy.extend({
calculatePosition: function () {
var resizableElement = $(this.options.resizableElement);
var offset = resizableElement.position();
return {
top: offset.top,
left: offset.left + outerWidth(resizableElement)
};
}
});
PositioningStrategyFactory.current.register(NORTHEAST, NortheastPositioningStrategy);
var NorthwestPositioningStrategy = HandlePositioningStrategy.extend({
calculatePosition: function () {
var resizableElement = $(this.options.resizableElement);
var offset = resizableElement.position();
return {
top: offset.top,
left: offset.left
};
}
});
PositioningStrategyFactory.current.register(NORTHWEST, NorthwestPositioningStrategy);
var SouthPositioningStrategy = HandlePositioningStrategy.extend({
calculatePosition: function () {
var resizableElement = $(this.options.resizableElement);
var offset = resizableElement.position();
return {
top: offset.top + outerHeight(resizableElement),
left: offset.left + outerWidth(resizableElement) / 2
};
}
});
PositioningStrategyFactory.current.register(SOUTH, SouthPositioningStrategy);
var SoutheastPositioningStrategy = HandlePositioningStrategy.extend({
calculatePosition: function () {
var resizableElement = $(this.options.resizableElement);
var offset = resizableElement.position();
return {
top: offset.top + outerHeight(resizableElement),
left: offset.left + outerWidth(resizableElement)
};
}
});
PositioningStrategyFactory.current.register(SOUTHEAST, SoutheastPositioningStrategy);
var SouthwestPositioningStrategy = HandlePositioningStrategy.extend({
calculatePosition: function () {
var resizableElement = $(this.options.resizableElement);
var offset = resizableElement.position();
return {
top: offset.top + outerHeight(resizableElement),
left: offset.left
};
}
});
PositioningStrategyFactory.current.register(SOUTHWEST, SouthwestPositioningStrategy);
var WestPositioningStrategy = HandlePositioningStrategy.extend({
calculatePosition: function () {
var resizableElement = $(this.options.resizableElement);
var offset = resizableElement.position();
return {
top: offset.top + outerHeight(resizableElement) / 2,
left: offset.left
};
}
});
PositioningStrategyFactory.current.register(WEST, WestPositioningStrategy);
var DraggingStrategyFactory = StrategyFactory.extend({});
DraggingStrategyFactory.current = new DraggingStrategyFactory();
var HandleDraggingStrategy = Class.extend({
init: function (options) {
var that = this;
that.options = extend({}, that.options, options);
},
options: {
deltaX: {
adjustment: null,
modifier: null
},
deltaY: {
adjustment: null,
modifier: null
}
},
adjustDragDelta: function (deltas) {
var options = this.options;
var xAxisAdjustment = options.deltaX.adjustment * options.deltaX.modifier;
var yAxisAdjustment = options.deltaY.adjustment * options.deltaY.modifier;
return {
deltaX: deltas.deltaX * xAxisAdjustment,
deltaY: deltas.deltaY * yAxisAdjustment,
initialDeltaX: deltas.initialDeltaX * xAxisAdjustment,
initialDeltaY: deltas.initialDeltaY * yAxisAdjustment
};
}
});
HandleDraggingStrategy.create = function (options) {
return DraggingStrategyFactory.current.create(options);
};
var HorizontalDraggingStrategy = HandleDraggingStrategy.extend({
options: {
deltaX: {
adjustment: 1,
modifier: 1
},
deltaY: {
adjustment: 0,
modifier: 0
}
}
});
var EastDraggingStrategy = HorizontalDraggingStrategy.extend({ options: { deltaX: { modifier: 1 } } });
DraggingStrategyFactory.current.register(EAST, EastDraggingStrategy);
var WestDraggingStrategy = HorizontalDraggingStrategy.extend({ options: { deltaX: { modifier: -1 } } });
DraggingStrategyFactory.current.register(WEST, WestDraggingStrategy);
var VerticalDraggingStrategy = HandleDraggingStrategy.extend({
options: {
deltaX: {
adjustment: 0,
modifier: 0
},
deltaY: {
adjustment: 1,
modifier: 1
}
}
});
var NorthDraggingStrategy = VerticalDraggingStrategy.extend({ options: { deltaY: { modifier: -1 } } });
DraggingStrategyFactory.current.register(NORTH, NorthDraggingStrategy);
var SouthDraggingStrategy = VerticalDraggingStrategy.extend({ options: { deltaY: { modifier: 1 } } });
DraggingStrategyFactory.current.register(SOUTH, SouthDraggingStrategy);
var HorizontalAndVerticalDraggingStrategy = HandleDraggingStrategy.extend({
options: {
deltaX: {
adjustment: 1,
modifier: 1
},
deltaY: {
adjustment: 1,
modifier: 1
}
}
});
var NorthEastDraggingStrategy = HorizontalAndVerticalDraggingStrategy.extend({
options: {
deltaX: { modifier: 1 },
deltaY: { modifier: -1 }
}
});
DraggingStrategyFactory.current.register(NORTHEAST, NorthEastDraggingStrategy);
var NorthWestDraggingStrategy = HorizontalAndVerticalDraggingStrategy.extend({
options: {
deltaX: { modifier: -1 },
deltaY: { modifier: -1 }
}
});
DraggingStrategyFactory.current.register(NORTHWEST, NorthWestDraggingStrategy);
var SouthEastDraggingStrategy = HorizontalAndVerticalDraggingStrategy.extend({
options: {
deltaX: { modifier: 1 },
deltaY: { modifier: 1 }
}
});
DraggingStrategyFactory.current.register(SOUTHEAST, SouthEastDraggingStrategy);
var SouthWestDraggingStrategy = HorizontalAndVerticalDraggingStrategy.extend({
options: {
deltaX: { modifier: -1 },
deltaY: { modifier: 1 }
}
});
DraggingStrategyFactory.current.register(SOUTHWEST, SouthWestDraggingStrategy);
extend(Editor, { TableResizeHandle: TableResizeHandle });
}(window.kendo));
}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {
(a3 || a2)();
}));
(function (f, define) {
define('editor/resizing/table-resizing', [
'editor/main',
'editor/resizing/table-resize-handle',
'editor/resizing/resizing-utils'
], f);
}(function () {
(function (kendo, undefined) {
var global = window;
var math = global.Math;
var min = math.min;
var max = math.max;
var $ = kendo.jQuery;
var contains = $.contains;
var extend = $.extend;
var proxy = $.proxy;
var browser = kendo.support.browser;
var Editor = kendo.ui.editor;
var Class = kendo.Class;
var TableResizeHandle = Editor.TableResizeHandle;
var ResizingUtils = Editor.ResizingUtils;
var calculatePercentageRatio = ResizingUtils.calculatePercentageRatio;
var constrain = ResizingUtils.constrain;
var inPercentages = ResizingUtils.inPercentages;
var inPixels = ResizingUtils.inPixels;
var toPercentages = ResizingUtils.toPercentages;
var toPixels = ResizingUtils.toPixels;
var outerWidth = kendo._outerWidth;
var outerHeight = kendo._outerHeight;
var NS = '.kendoEditorTableResizing';
var RESIZE_HANDLE_WRAPPER_CLASS = 'k-table-resize-handle-wrapper';
var TABLE_CLASS = 'k-table';
var TABLE_RESIZING_CLASS = 'k-table-resizing';
var DRAG_START = 'dragStart';
var DRAG = 'drag';
var DRAG_END = 'dragEnd';
var KEY_DOWN = 'keydown';
var MOUSE_DOWN = 'mousedown';
var MOUSE_OVER = 'mouseover';
var MOUSE_OUT = 'mouseout';
var COLUMN = 'td';
var ROW = 'tr';
var TBODY = 'tbody';
var TABLE = 'table';
var WIDTH = 'width';
var HEIGHT = 'height';
var EAST = 'east';
var NORTH = 'north';
var NORTHEAST = 'northeast';
var NORTHWEST = 'northwest';
var SOUTH = 'south';
var SOUTHEAST = 'southeast';
var SOUTHWEST = 'southwest';
var WEST = 'west';
var DOT = '.';
function isUndefined(value) {
return typeof value === 'undefined';
}
var TableResizing = Class.extend({
init: function (element, options) {
var that = this;
that.options = extend({}, that.options, options);
that.handles = [];
if ($(element).is(TABLE)) {
that.element = element;
}
},
destroy: function () {
var that = this;
$(that.element).off(NS);
that.element = null;
$(that.options.rootElement).off(KEY_DOWN + NS);
that._destroyResizeHandles();
},
options: {
appendHandlesTo: null,
rtl: false,
rootElement: null,
minWidth: 10,
minHeight: 10,
handles: [
{ direction: NORTHWEST },
{ direction: NORTH },
{ direction: NORTHEAST },
{ direction: EAST },
{ direction: SOUTHEAST },
{ direction: SOUTH },
{ direction: SOUTHWEST },
{ direction: WEST }
]
},
resize: function (args) {
var that = this;
var deltas = extend({}, {
deltaX: 0,
deltaY: 0,
initialDeltaX: 0,
initialDeltaY: 0
}, args);
that._resizeWidth(deltas.deltaX, deltas.initialDeltaX);
that._resizeHeight(deltas.deltaY, deltas.initialDeltaY);
that.showResizeHandles();
},
_resizeWidth: function (delta, initialDelta) {
var that = this;
var element = $(that.element);
var styleWidth = element[0].style[WIDTH];
var currentWidth = outerWidth(element);
var parentWidth = element.parent().width();
var maxWidth = that._getMaxDimensionValue(WIDTH);
var newWidth;
var ratioValue;
var ratioTotalValue;
var constrainedWidth;
if (delta === 0) {
return;
}
if (isUndefined(that._initialElementWidth)) {
that._initialElementWidth = currentWidth;
}
constrainedWidth = constrain({
value: that._initialElementWidth + initialDelta,
min: that.options.minWidth,
max: maxWidth
});
if (inPercentages(styleWidth)) {
if (currentWidth + delta > parentWidth) {
ratioValue = max(constrainedWidth, parentWidth);
ratioTotalValue = min(constrainedWidth, parentWidth);
} else {
ratioValue = min(constrainedWidth, parentWidth);
ratioTotalValue = max(constrainedWidth, parentWidth);
}
newWidth = toPercentages(calculatePercentageRatio(ratioValue, ratioTotalValue));
} else {
newWidth = toPixels(constrainedWidth);
}
that._setColumnsWidth();
element[0].style[WIDTH] = newWidth;
},
_resizeHeight: function (delta, initialDelta) {
var that = this;
var element = $(that.element);
var styleHeight = element[0].style[HEIGHT];
var currentHeight = outerHeight(element);
var parent = element.parent();
var parentHeight = parent.height();
var maxHeight = that._getMaxDimensionValue(HEIGHT);
var newHeight;
var ratioValue;
var ratioTotalValue;
var constrainedHeight;
var minHeight = that.options.minHeight;
var hasRowsInPixels = that._hasRowsInPixels();
if (delta === 0) {
return;
}
if (isUndefined(that._initialElementHeight)) {
that._initialElementHeight = currentHeight;
}
constrainedHeight = constrain({
value: that._initialElementHeight + initialDelta,
min: minHeight,
max: maxHeight
});
if (hasRowsInPixels && delta < 0) {
that._setRowsHeightInPercentages();
}
if (inPercentages(styleHeight)) {
if (currentHeight + delta > parentHeight) {
ratioValue = max(constrainedHeight, parentHeight);
ratioTotalValue = min(constrainedHeight, parentHeight);
} else {
ratioValue = min(constrainedHeight, parentHeight);
ratioTotalValue = max(constrainedHeight, parentHeight);
}
newHeight = toPercentages(calculatePercentageRatio(ratioValue, ratioTotalValue));
} else {
newHeight = toPixels(constrainedHeight);
}
element[0].style[HEIGHT] = newHeight;
if (hasRowsInPixels && delta < 0) {
that._setRowsHeightInPixels();
}
},
_getMaxDimensionValue: function (dimension) {
var that = this;
var element = $(that.element);
var dimensionLowercase = dimension.toLowerCase();
var rtlModifier = that.options.rtl ? -1 : 1;
var parent = $(that.element).parent();
var parentElement = parent[0];
var parentDimension = parent[dimensionLowercase]();
var parentScrollOffset = rtlModifier * (dimension === WIDTH ? parent.scrollLeft() : parent.scrollTop());
if (parentElement === element.closest(COLUMN)[0]) {
if (parentElement.style[dimensionLowercase] === '' && !inPercentages(that.element.style[dimensionLowercase])) {
return Infinity;
} else {
return parentDimension + parentScrollOffset;
}
} else {
return parentDimension + parentScrollOffset;
}
},
_setColumnsWidth: function () {
var that = this;
var element = $(that.element);
var parentElement = element.parent()[0];
var parentColumn = element.closest(COLUMN);
var columns = parentColumn.closest(ROW).children();
var columnsLength = columns.length;
var i;
function isWidthInPercentages(element) {
var styleWidth = element.style.width;
if (styleWidth !== '') {
return inPercentages(styleWidth) ? true : false;
} else {
return $(element).hasClass(TABLE_CLASS) ? true : false;
}
}
if (isWidthInPercentages(element[0]) && parentElement === parentColumn[0] && parentElement.style[WIDTH] === '') {
for (i = 0; i < columnsLength; i++) {
columns[i].style[WIDTH] = toPixels($(columns[i]).width());
}
}
},
_hasRowsInPixels: function () {
var that = this;
var rows = $(that.element).children(TBODY).children(ROW);
for (var i = 0; i < rows.length; i++) {
if (rows[i].style.height === '' || inPixels(rows[i].style.height)) {
return true;
}
}
return false;
},
_setRowsHeightInPercentages: function () {
var that = this;
var tableBody = $(that.element).children(TBODY);
var tableBodyHeight = tableBody.height();
var rows = tableBody.children(ROW);
var length = rows.length;
var currentRowsHeights = rows.map(function () {
return outerHeight($(this));
});
var i;
for (i = 0; i < length; i++) {
rows[i].style[HEIGHT] = toPercentages(calculatePercentageRatio(currentRowsHeights[i], tableBodyHeight));
}
},
_setRowsHeightInPixels: function () {
var that = this;
var rows = $(that.element).children(TBODY).children(ROW);
var length = rows.length;
var currentRowsHeights = rows.map(function () {
return outerHeight($(this));
});
var i;
for (i = 0; i < length; i++) {
rows[i].style[HEIGHT] = toPixels(currentRowsHeights[i]);
}
},
showResizeHandles: function () {
var that = this;
that._initResizeHandles();
that._showResizeHandles();
},
_initResizeHandles: function () {
var that = this;
var handles = that.handles;
var options = that.options;
var handleOptions = that.options.handles;
var length = handleOptions.length;
var i;
if (handles && handles.length > 0) {
return;
}
for (i = 0; i < length; i++) {
that.handles.push(new TableResizeHandle(extend({
appendTo: options.appendHandlesTo,
resizableElement: that.element,
rootElement: options.rootElement,
rtl: options.rtl
}, handleOptions[i])));
}
that._bindToResizeHandlesEvents();
},
_destroyResizeHandles: function () {
var that = this;
var length = that.handles ? that.handles.length : 0;
for (var i = 0; i < length; i++) {
that.handles[i].destroy();
}
},
_showResizeHandles: function () {
var that = this;
var handles = that.handles || [];
var length = handles.length;
var i;
for (i = 0; i < length; i++) {
that.handles[i].show();
}
},
_bindToResizeHandlesEvents: function () {
var that = this;
var handles = that.handles || [];
var length = handles.length;
var i;
var handle;
for (i = 0; i < length; i++) {
handle = handles[i];
handle.bind(DRAG_START, proxy(that._onResizeHandleDragStart, that));
handle.bind(DRAG, proxy(that._onResizeHandleDrag, that));
handle.bind(DRAG_END, proxy(that._onResizeHandleDragEnd, that));
handle.bind(MOUSE_OVER, proxy(that._onResizeHandleMouseOver, that));
handle.bind(MOUSE_OUT, proxy(that._onResizeHandleMouseOut, that));
}
},
_onResizeHandleDragStart: function () {
var that = this;
var element = $(that.element);
element.addClass(TABLE_RESIZING_CLASS);
that._initialElementHeight = outerHeight(element);
that._initialElementWidth = outerWidth(element);
that._disableKeyboard();
},
_onResizeHandleDrag: function (e) {
this.resize(e);
},
_onResizeHandleDragEnd: function () {
var that = this;
$(that.element).removeClass(TABLE_RESIZING_CLASS);
that._enableKeyboard();
},
_enableKeyboard: function () {
$(this.options.rootElement).off(KEY_DOWN + NS);
},
_disableKeyboard: function () {
$(this.options.rootElement).on(KEY_DOWN + NS, function (e) {
e.preventDefault();
});
}
});
var TableResizingFactory = Class.extend({
create: function (editor) {
var factory = this;
$(editor.body).on(MOUSE_DOWN + NS, TABLE, function (e) {
var eventTarget = e.target;
var eventCurrentTarget = e.currentTarget;
var tableResizing = editor.tableResizing;
var element = tableResizing ? tableResizing.element : null;
if (tableResizing) {
if (element && eventCurrentTarget !== element) {
if (contains(eventCurrentTarget, element) && element !== eventTarget && contains(element, eventTarget)) {
return;
} else {
if (element !== eventTarget) {
editor._destroyTableResizing();
factory._initResizing(editor, eventCurrentTarget);
}
}
}
} else {
factory._initResizing(editor, eventCurrentTarget);
}
editor._showTableResizeHandles();
}).on(MOUSE_DOWN + NS, function (e) {
var tableResizing = editor.tableResizing;
var element = tableResizing ? tableResizing.element : null;
var target = e.target;
var isResizeHandleOrChild = $(target).hasClass(RESIZE_HANDLE_WRAPPER_CLASS) || $(target).parents(DOT + RESIZE_HANDLE_WRAPPER_CLASS).length > 0;
if (tableResizing && element !== target && !contains(element, target) && !isResizeHandleOrChild) {
editor._destroyTableResizing();
}
});
},
dispose: function (editor) {
$(editor.body).off(NS);
},
_initResizing: function (editor, table) {
if (!browser.msie && !browser.mozilla) {
editor.tableResizing = new TableResizing(table, {
appendHandlesTo: editor.body,
rtl: kendo.support.isRtl(editor.element),
rootElement: editor.body
});
}
}
});
TableResizingFactory.current = new TableResizingFactory();
TableResizing.create = function (editor) {
TableResizingFactory.current.create(editor);
};
TableResizing.dispose = function (editor) {
TableResizingFactory.current.dispose(editor);
};
extend(Editor, { TableResizing: TableResizing });
}(window.kendo));
}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {
(a3 || a2)();
}));
(function (f, define) {
define('editor/table-wizard/table-wizard-command', ['editor/plugins/tables'], f);
}(function () {
(function ($, undefined) {
var kendo = window.kendo, Editor = kendo.ui.editor, EditorUtils = Editor.EditorUtils, RangeUtils = Editor.RangeUtils, dom = Editor.Dom, registerTool = EditorUtils.registerTool, ToolTemplate = Editor.ToolTemplate, Command = Editor.Command;
var tableFormatFinder = new Editor.BlockFormatFinder([{ tags: ['table'] }]);
var cellsFormatFinder = new Editor.BlockFormatFinder([{
tags: [
'td',
'th'
]
}]);
var reUnit = /([a-z]+|%)$/i;
var TableWizardCommand = Command.extend({
exec: function () {
var cmd = this;
var editor = cmd.editor;
var range = cmd.range = cmd.lockRange();
var selectedTable = cmd._sourceTable = !cmd.options.insertNewTable ? cmd._selectedTable(range) : undefined;
var selectedCells = cmd._selectedTableCells = selectedTable ? cmd._selectedCells(range) : undefined;
var options = {
visible: false,
messages: editor.options.messages,
closeCallback: $.proxy(cmd.onDialogClose, cmd),
table: cmd.parseTable(selectedTable, selectedCells),
dialogOptions: editor.options.dialogOptions,
isRtl: kendo.support.isRtl(editor.wrapper)
};
var dialog = new Editor.TableWizardDialog(options);
dialog.open();
},
onDialogClose: function (data) {
var cmd = this;
cmd.releaseRange(cmd.range);
if (data) {
if (cmd.options.insertNewTable) {
cmd.insertTable(cmd.createNewTable(data));
} else {
cmd.updateTable(data, cmd._sourceTable, cmd._selectedTableCells);
}
}
},
releaseRange: function (range) {
var cmd = this;
var doc = cmd.editor.document;
dom.windowFromDocument(doc).focus();
Command.fn.releaseRange.call(cmd, range);
},
insertTable: function (table) {
var range = this.range;
range.insertNode(table);
range.collapse(true);
this.editor.selectRange(range);
this._ensureFocusableAfterTable(table);
},
_ensureFocusableAfterTable: function (table) {
var siblingNodes = $(table).parent().contents();
var lastSiblingIndex = siblingNodes.length - 1;
var lastSibling = siblingNodes.get(lastSiblingIndex);
while (lastSibling.nodeValue !== null && (lastSibling.nodeValue === ' ' || lastSibling.nodeValue === '')) {
lastSiblingIndex -= 1;
lastSibling = siblingNodes.get(lastSiblingIndex);
}
if (lastSibling === table) {
dom.insertAfter(dom.createEmptyNode(this.editor.document, 'p'), table);
}
},
updateTable: function (data, table, selectedCells) {
var cmd = this;
var tableRows = $(table.rows).toArray();
var tableProp = data.tableProperties;
var rows = tableProp.rows;
var columns = tableProp.columns;
var last = function (collection) {
return collection[collection.length - 1];
};
while (selectedCells.length > 1) {
selectedCells.pop();
}
var lastSelectedRow = selectedCells.length ? last(selectedCells).parentNode : last(tableRows);
var row, parent;
cmd._deleteTableRows(tableRows, tableRows.length - rows);
if (tableRows.length < rows) {
var rowIndex = $(lastSelectedRow).index();
var cellsLength = lastSelectedRow.cells.length;
var newRowsCount = rows - tableRows.length;
parent = lastSelectedRow.parentNode;
while (newRowsCount) {
row = parent.insertRow(rowIndex + 1);
cmd._insertCells(cellsLength - row.cells.length, row);
newRowsCount--;
}
}
if (tableRows[0].cells.length > columns) {
$(tableRows).each(function (i, row) {
while (row.cells.length > columns) {
row.deleteCell(-1);
}
});
}
if (tableRows[0].cells.length < columns) {
var cellIndex = $(last(selectedCells) || last(lastSelectedRow.cells)).index();
$(tableRows).each(function (i, row) {
cmd._insertCells(columns - row.cells.length, row, cellIndex + 1);
});
}
cmd._updateTableProperties(table, tableProp);
var cellProp = data.cellProperties;
if (selectedCells[0]) {
dom.attr(selectedCells[0], { id: cellProp.id || null });
}
(cellProp.selectAllCells ? $(tableRows).children() : $(selectedCells)).each(function (i, cell) {
cmd._updateCellProperties(cell, cellProp);
});
cmd._updateCaption(table, tableProp);
tableProp.cellsWithHeaders = tableProp.cellsWithHeaders || false;
if (cmd.cellsWithHeadersAssociated(table) != tableProp.cellsWithHeaders) {
cmd.associateCellsWithHeader(table, tableProp.cellsWithHeaders);
}
},
_isHeadingRow: function (row) {
return dom.is(row.parentNode, 'thead') || dom.is(row.cells[0], 'th');
},
associateCellsWithHeader: function (table, associate) {
var timestamp = new Date().getTime();
var ids = [];
var columns = table.rows[0].cells.length;
var index, nextRow, isDataRow;
var generateIds = function () {
for (var i = 0; i < columns; i++) {
ids[i] = 'table' + ++timestamp;
}
};
var modifySellsIds = function (c, cell) {
$(cell)[associate ? 'attr' : 'removeAttr']('id', ids[c]);
};
var modifyCellsHeadings = function (c, cell) {
$(cell)[associate ? 'attr' : 'removeAttr']('headers', ids[c]);
};
var isHeadingRow = this._isHeadingRow;
$(table.rows).each(function (r, row) {
if (isHeadingRow(row)) {
index = r;
nextRow = table.rows[++index];
isDataRow = nextRow && !isHeadingRow(nextRow);
if (isDataRow) {
generateIds();
$(row.cells).each(modifySellsIds);
}
while (isDataRow) {
$(nextRow.cells).each(modifyCellsHeadings);
nextRow = table.rows[++index];
isDataRow = nextRow && !isHeadingRow(nextRow);
}
}
});
},
cellsWithHeadersAssociated: function (table) {
var cells = $(table.rows).children();
var isHeadingRow = this._isHeadingRow;
var headingIds = [];
cells.each(function (c, cell) {
if (cell.id && isHeadingRow(cell.parentNode)) {
headingIds.push(cell.id);
}
});
var associatedCells = cells.filter(function (c, cell) {
var headersAttr = cell.getAttribute('headers');
return headersAttr && !isHeadingRow(cell.parentNode) && $.inArray(headersAttr, headingIds) > -1;
});
return !!associatedCells.length;
},
_insertCells: function (count, row, index) {
index = isNaN(index) ? -1 : index;
for (var i = 0, cell; i < count; i++) {
cell = row.insertCell(index);
cell.innerHTML = ' ';
}
},
_deleteTableRows: function (rows, count) {
for (var i = 0, row, rowParent; i < count; i++) {
row = rows.pop();
rowParent = row.parentNode;
rowParent.removeChild(row);
if (!rowParent.rows.length) {
dom.remove(rowParent);
}
}
},
createNewTable: function (data) {
var cmd = this;
var doc = cmd.editor.document;
var tableProp = data.tableProperties;
var cellProp = data.cellProperties;
var cellPropToAll = cellProp.selectAllCells;
var table = dom.create(doc, 'table');
cmd._updateTableProperties(table, tableProp);
cmd._updateCaption(table, tableProp);
var tbody = table.createTBody();
for (var r = 0, row; r < tableProp.rows; r++) {
row = tbody.insertRow();
for (var c = 0, cell; c < tableProp.columns; c++) {
cell = row.insertCell();
cell.innerHTML = ' ';
if (r === 0 && c === 0 && cellProp.id) {
cell.id = cellProp.id;
}
cmd._updateCellProperties(cell, cellPropToAll || r === 0 && c === 0 ? cellProp : {});
}
}
if (tableProp.cellsWithHeaders) {
cmd.associateCellsWithHeader(table, tableProp.cellsWithHeaders);
}
return table;
},
_updateTableProperties: function (table, data) {
var style = this._getStylesData(data);
dom.attr(table, {
cellSpacing: data.cellSpacing || null,
cellPadding: data.cellPadding || null,
className: data.className || null,
id: data.id || null,
summary: data.summary || null,
style: style || null
});
$(table).addClass('k-table');
},
_updateCellProperties: function (cell, data) {
var style = this._getStylesData(data);
style.padding = data.cellPadding || null;
style.margin = data.cellMargin || null;
dom.attr(cell, {
style: style || null,
className: data.className || null
});
},
_updateCaption: function (table, data) {
if (table.caption && !data.captionContent) {
table.deleteCaption();
} else if (data.captionContent) {
var caption = table.createCaption();
caption.innerHTML = data.captionContent;
var alignment = this._getAlignmentData(data.captionAlignment);
dom.attr(caption, {
style: {
textAlign: alignment.textAlign,
verticalAlign: alignment.verticalAlign
}
});
}
},
_getStylesData: function (data) {
var alignment = this._getAlignmentData(data.alignment);
var whiteSpace = 'wrapText' in data ? data.wrapText ? '' : 'nowrap' : null;
return {
width: data.width ? data.width + data.widthUnit : null,
height: data.height ? data.height + data.heightUnit : null,
textAlign: alignment.textAlign,
verticalAlign: alignment.verticalAlign,
backgroundColor: data.bgColor || '',
borderWidth: data.borderWidth,
borderStyle: data.borderStyle,
borderColor: data.borderColor || '',
borderCollapse: data.collapseBorders ? 'collapse' : null,
whiteSpace: whiteSpace
};
},
_getAlignmentData: function (alignment) {
var textAlign = '';
var verticalAlign = textAlign;
if (alignment) {
if (alignment.indexOf(' ') != -1) {
var align = alignment.split(' ');
textAlign = align[0];
verticalAlign = align[1];
} else {
textAlign = alignment;
}
}
return {
textAlign: textAlign,
verticalAlign: verticalAlign
};
},
parseTable: function (table, selectedCells) {
if (!table) {
return {
tableProperties: {},
selectedCells: []
};
}
var cmd = this;
var tStyle = table.style;
var rows = table.rows;
var caption = table.caption;
var captionClone = $(caption ? caption.cloneNode(true) : undefined);
captionClone.find('.k-marker').remove();
var cssClass = table.className;
cssClass = cssClass.replace(/^k-table\s|\sk-table$/, '');
cssClass = cssClass.replace(/\sk-table\s/, ' ');
cssClass = cssClass.replace(/^k-table$/, '');
var tableAlignment = cmd._getAlignment(table, true);
var captionAlignment = caption ? cmd._getAlignment(caption) : undefined;
var cellsWithHeaders = cmd.cellsWithHeadersAssociated(table);
var tableJson = {
tableProperties: {
width: tStyle.width || table.width ? parseFloat(tStyle.width || table.width) : null,
height: tStyle.height || table.height ? parseFloat(tStyle.height || table.height) : null,
columns: rows[0] ? rows[0].children.length : 0,
rows: rows.length,
widthUnit: cmd._getUnit(tStyle.width),
heightUnit: cmd._getUnit(tStyle.height),
cellSpacing: table.cellSpacing,
cellPadding: table.cellPadding,
alignment: tableAlignment.textAlign,
bgColor: tStyle.backgroundColor || table.bgColor,
className: cssClass,
id: table.id,
borderWidth: tStyle.borderWidth || table.border,
borderColor: tStyle.borderColor,
borderStyle: tStyle.borderStyle || '',
collapseBorders: !!tStyle.borderCollapse,
summary: table.summary,
captionContent: caption ? captionClone.html() : '',
captionAlignment: caption && captionAlignment.textAlign ? captionAlignment.textAlign + ' ' + captionAlignment.verticalAlign : '',
cellsWithHeaders: cellsWithHeaders
},
selectedCells: []
};
tableJson.rows = cmd.parseTableRows(rows, selectedCells, tableJson);
return tableJson;
},
parseTableRows: function (rows, selectedCells, tableJson) {
var cmd = this;
var data = [], row, rowData, cells, cell, cellData;
for (var i = 0; i < rows.length; i++) {
row = rows[i];
rowData = { cells: [] };
cells = row.cells;
data.push(rowData);
for (var j = 0; j < cells.length; j++) {
cell = cells[j];
cellData = cmd.parseCell(cell);
if ($.inArray(cell, selectedCells) != -1) {
tableJson.selectedCells.push(cellData);
}
rowData.cells.push(cellData);
}
}
return data;
},
parseCell: function (cell) {
var cmd = this;
var cStyle = cell.style;
var alignment = cmd._getAlignment(cell);
alignment = alignment.textAlign ? alignment.textAlign + ' ' + alignment.verticalAlign : '';
var data = {
width: cStyle.width || cell.width ? parseFloat(cStyle.width || cell.width) : null,
height: cStyle.height || cell.height ? parseFloat(cStyle.height || cell.height) : null,
widthUnit: cmd._getUnit(cStyle.width),
heightUnit: cmd._getUnit(cStyle.height),
cellMargin: cStyle.margin,
cellPadding: cStyle.padding,
alignment: alignment,
bgColor: cStyle.backgroundColor || cell.bgColor,
className: cell.className,
id: cell.id,
borderWidth: cStyle.borderWidth || cell.border,
borderColor: cStyle.borderColor,
borderStyle: cStyle.borderStyle,
wrapText: cStyle.whiteSpace != 'nowrap'
};
return data;
},
_getAlignment: function (element, horizontalOnly) {
var style = element.style;
var hAlign = style.textAlign || element.align || '';
if (horizontalOnly) {
return { textAlign: hAlign };
}
var vAlign = style.verticalAlign || element.vAlign || '';
if (hAlign && vAlign) {
return {
textAlign: hAlign,
verticalAlign: vAlign
};
}
if (!hAlign && vAlign) {
return {
textAlign: 'left',
verticalAlign: vAlign
};
}
if (hAlign && !vAlign) {
return {
textAlign: hAlign,
verticalAlign: 'top'
};
}
return {
textAlign: '',
verticalAlign: ''
};
},
_getUnit: function (value) {
var unit = (value || '').match(reUnit);
return unit ? unit[0] : 'px';
},
_selectedTable: function (range) {
var nodes = dom.filterBy(RangeUtils.nodes(range), dom.htmlIndentSpace, true);
return tableFormatFinder.findSuitable(nodes)[0];
},
_selectedCells: function (range) {
var nodes = dom.filterBy(RangeUtils.nodes(range), dom.htmlIndentSpace, true);
return cellsFormatFinder.findSuitable(nodes);
}
});
var TableWizardTool = Editor.Tool.extend({
command: function (options) {
options.insertNewTable = this.options.insertNewTable;
return new TableWizardCommand(options);
}
});
var TableWizardEditTool = TableWizardTool.extend({
update: function (ui, nodes) {
var isFormatted = !tableFormatFinder.isFormatted(nodes);
ui.toggleClass('k-state-disabled', isFormatted);
}
});
kendo.ui.editor.TableWizardTool = TableWizardTool;
kendo.ui.editor.TableWizardCommand = TableWizardCommand;
registerTool('tableWizard', new TableWizardEditTool({
command: TableWizardCommand,
insertNewTable: false,
template: new ToolTemplate({
template: EditorUtils.buttonTemplate,
title: 'Table Wizard'
})
}));
}(window.kendo.jQuery));
}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {
(a3 || a2)();
}));
(function (f, define) {
define('kendo.tabstrip', ['kendo.data'], f);
}(function () {
var __meta__ = {
id: 'tabstrip',
name: 'TabStrip',
category: 'web',
description: 'The TabStrip widget displays a collection of tabs with associated tab content.',
depends: ['data'],
features: [{
id: 'tabstrip-fx',
name: 'Animation',
description: 'Support for animation',
depends: ['fx']
}]
};
(function ($, undefined) {
var kendo = window.kendo, ui = kendo.ui, keys = kendo.keys, map = $.map, each = $.each, trim = $.trim, extend = $.extend, isFunction = kendo.isFunction, template = kendo.template, outerWidth = kendo._outerWidth, outerHeight = kendo._outerHeight, Widget = ui.Widget, excludedNodesRegExp = /^(a|div)$/i, NS = '.kendoTabStrip', IMG = 'img', HREF = 'href', PREV = 'prev', NEXT = 'next', SHOW = 'show', LINK = 'k-link', LAST = 'k-last', CLICK = 'click', ERROR = 'error', EMPTY = ':empty', IMAGE = 'k-image', FIRST = 'k-first', SELECT = 'select', ACTIVATE = 'activate', CONTENT = 'k-content', CONTENTURL = 'contentUrl', MOUSEENTER = 'mouseenter', MOUSELEAVE = 'mouseleave', CONTENTLOAD = 'contentLoad', DISABLEDSTATE = 'k-state-disabled', DEFAULTSTATE = 'k-state-default', ACTIVESTATE = 'k-state-active', FOCUSEDSTATE = 'k-state-focused', HOVERSTATE = 'k-state-hover', TABONTOP = 'k-tab-on-top', NAVIGATABLEITEMS = '.k-item:not(.' + DISABLEDSTATE + ')', KEYBOARDNAVIGATABLEITEMS = '.k-item', HOVERABLEITEMS = '.k-tabstrip-items > ' + NAVIGATABLEITEMS + ':not(.' + ACTIVESTATE + ')', DEFAULTDISTANCE = 200, templates = {
content: template('
#= content(item) #
'),
itemWrapper: template('<#= tag(item) # class=\'k-link\'#= contentUrl(item) ##= textAttributes(item) #>' + '#= image(item) ##= sprite(item) ##= text(item) #' + ''),
item: template('
' + '#= itemWrapper(data) #' + ''),
image: template('
'),
sprite: template('
'),
empty: template('')
}, rendering = {
wrapperCssClass: function (group, item) {
var result = 'k-item', index = item.index;
if (item.enabled === false) {
result += ' k-state-disabled';
} else {
result += ' k-state-default';
}
if (index === 0) {
result += ' k-first';
}
if (index == group.length - 1) {
result += ' k-last';
}
return result;
},
textAttributes: function (item) {
return item.url ? ' href=\'' + item.url + '\'' : '';
},
text: function (item) {
return item.encoded === false ? item.text : kendo.htmlEncode(item.text);
},
tag: function (item) {
return item.url ? 'a' : 'span';
},
contentAttributes: function (content) {
return content.active !== true ? ' style=\'display:none\' aria-hidden=\'true\' aria-expanded=\'false\'' : '';
},
content: function (item) {
return item.content ? item.content : item.contentUrl ? '' : ' ';
},
contentUrl: function (item) {
return item.contentUrl ? kendo.attr('content-url') + '="' + item.contentUrl + '"' : '';
}
};
function updateTabClasses(tabs) {
tabs.children(IMG).addClass(IMAGE);
tabs.children('a').addClass(LINK).children(IMG).addClass(IMAGE);
tabs.filter(':not([disabled]):not([class*=k-state-disabled])').addClass(DEFAULTSTATE);
tabs.filter('li[disabled]').addClass(DISABLEDSTATE).attr('aria-disabled', 'true').removeAttr('disabled');
tabs.filter(':not([class*=k-state])').children('a').filter(':focus').parent().addClass(ACTIVESTATE + ' ' + TABONTOP);
tabs.attr('role', 'tab');
tabs.filter('.' + ACTIVESTATE).attr('aria-selected', true);
tabs.each(function () {
var item = $(this);
if (!item.children('.' + LINK).length) {
item.contents().filter(function () {
return !this.nodeName.match(excludedNodesRegExp) && !(this.nodeType == 3 && !trim(this.nodeValue));
}).wrapAll('
');
}
});
}
function updateFirstLast(tabGroup) {
var tabs = tabGroup.children('.k-item');
tabs.filter('.k-first:not(:first-child)').removeClass(FIRST);
tabs.filter('.k-last:not(:last-child)').removeClass(LAST);
tabs.filter(':first-child').addClass(FIRST);
tabs.filter(':last-child').addClass(LAST);
}
function scrollButtonHtml(buttonClass, iconClass) {
return '
';
}
var TabStrip = Widget.extend({
init: function (element, options) {
var that = this, value;
Widget.fn.init.call(that, element, options);
that._animations(that.options);
options = that.options;
that._contentUrls = options.contentUrls || [];
that._wrapper();
that._isRtl = kendo.support.isRtl(that.wrapper);
that._tabindex();
that._updateClasses();
that._dataSource();
if (options.dataSource) {
that.dataSource.fetch();
}
that._tabPosition();
that._scrollable();
if (that._contentUrls.length) {
that.wrapper.find('.k-tabstrip-items > .k-item').each(function (index, item) {
var url = that._contentUrls[index];
if (typeof url === 'string') {
$(item).find('>.' + LINK).data(CONTENTURL, url);
}
});
} else {
that._contentUrls.length = that.tabGroup.find('li.k-item').length;
}
that.wrapper.on(MOUSEENTER + NS + ' ' + MOUSELEAVE + NS, HOVERABLEITEMS, that._toggleHover).on('focus' + NS, $.proxy(that._active, that)).on('blur' + NS, function () {
that._current(null);
});
that._keyDownProxy = $.proxy(that._keydown, that);
if (options.navigatable) {
that.wrapper.on('keydown' + NS, that._keyDownProxy);
}
if (that.options.value) {
value = that.options.value;
}
that.wrapper.children('.k-tabstrip-items').on(CLICK + NS, '.k-state-disabled .k-link', false).on(CLICK + NS, ' > ' + NAVIGATABLEITEMS, function (e) {
var wr = that.wrapper[0];
if (wr !== document.activeElement) {
var msie = kendo.support.browser.msie;
if (msie) {
try {
wr.setActive();
} catch (j) {
wr.focus();
}
} else {
wr.focus();
}
}
if (that._click($(e.currentTarget))) {
e.preventDefault();
}
});
var selectedItems = that.tabGroup.children('li.' + ACTIVESTATE), content = that.contentHolder(selectedItems.index());
if (selectedItems[0] && content.length > 0 && content[0].childNodes.length === 0) {
that.activateTab(selectedItems.eq(0));
}
that.element.attr('role', 'tablist');
if (that.element[0].id) {
that._ariaId = that.element[0].id + '_ts_active';
}
that.value(value);
kendo.notify(that);
},
_active: function () {
var item = this.tabGroup.children().filter('.' + ACTIVESTATE);
item = item[0] ? item : this._endItem('first');
if (item[0]) {
this._current(item);
}
},
_endItem: function (action) {
return this.tabGroup.children(NAVIGATABLEITEMS)[action]();
},
_getItem: function (action) {
return this.tabGroup.children(KEYBOARDNAVIGATABLEITEMS)[action]();
},
_item: function (item, action) {
var endItem;
if (action === PREV) {
endItem = 'last';
} else {
endItem = 'first';
}
if (!item) {
return this._endItem(endItem);
}
item = item[action]();
if (!item[0]) {
item = this.tabGroup.children(KEYBOARDNAVIGATABLEITEMS)[endItem]();
}
if (item.hasClass(DISABLEDSTATE)) {
item.addClass(FOCUSEDSTATE);
}
if (item.hasClass(DISABLEDSTATE) || item.hasClass(ACTIVESTATE)) {
this._focused = item;
}
return item;
},
_current: function (candidate) {
var that = this, focused = that._focused, id = that._ariaId;
if (candidate === undefined) {
return focused;
}
if (focused) {
that.tabGroup.children('#' + id).removeAttr('id');
focused.removeClass(FOCUSEDSTATE);
}
if (candidate) {
if (!candidate.hasClass(ACTIVESTATE)) {
candidate.addClass(FOCUSEDSTATE);
}
that.element.removeAttr('aria-activedescendant');
id = candidate[0].id || id;
if (id) {
candidate.attr('id', id);
that.element.attr('aria-activedescendant', id);
}
}
that._focused = candidate;
},
_keydown: function (e) {
var that = this, key = e.keyCode, current = that._current(), rtl = that._isRtl, isHorizontal = /top|bottom/.test(that.options.tabPosition), action;
if (e.target != e.currentTarget) {
return;
}
if (key === keys.DOWN && !isHorizontal) {
action = NEXT;
} else if (key === keys.UP && !isHorizontal) {
action = PREV;
} else if (key === keys.RIGHT && isHorizontal) {
action = rtl ? PREV : NEXT;
} else if (key === keys.LEFT && isHorizontal) {
action = rtl ? NEXT : PREV;
} else if (key == keys.ENTER || key == keys.SPACEBAR) {
that._click(current);
e.preventDefault();
} else if (key == keys.HOME) {
that._click(that._getItem('first'));
e.preventDefault();
return;
} else if (key == keys.END) {
that._click(that._getItem('last'));
e.preventDefault();
return;
}
if (action) {
that._click(that._item(current, action));
e.preventDefault();
}
},
_dataSource: function () {
var that = this;
if (that.dataSource && that._refreshHandler) {
that.dataSource.unbind('change', that._refreshHandler);
} else {
that._refreshHandler = $.proxy(that.refresh, that);
}
that.dataSource = kendo.data.DataSource.create(that.options.dataSource).bind('change', that._refreshHandler);
},
setDataSource: function (dataSource) {
var that = this;
that.options.dataSource = dataSource;
that._dataSource();
that.dataSource.fetch();
},
_animations: function (options) {
if (options && 'animation' in options && !options.animation) {
options.animation = {
open: { effects: {} },
close: { effects: {} }
};
}
},
refresh: function (e) {
var that = this, options = that.options, encoded = kendo.getter(options.dataEncodedField), text = kendo.getter(options.dataTextField), content = kendo.getter(options.dataContentField), contentUrl = kendo.getter(options.dataContentUrlField), image = kendo.getter(options.dataImageUrlField), url = kendo.getter(options.dataUrlField), sprite = kendo.getter(options.dataSpriteCssClass), idx, tabs = [], tab, action, view = that.dataSource.view(), length;
e = e || {};
action = e.action;
if (action) {
view = e.items;
}
for (idx = 0, length = view.length; idx < length; idx++) {
tab = { text: text(view[idx]) };
if (options.dataEncodedField) {
tab.encoded = encoded(view[idx]);
}
if (options.dataContentField) {
tab.content = content(view[idx]);
}
if (options.dataContentUrlField) {
tab.contentUrl = contentUrl(view[idx]);
}
if (options.dataUrlField) {
tab.url = url(view[idx]);
}
if (options.dataImageUrlField) {
tab.imageUrl = image(view[idx]);
}
if (options.dataSpriteCssClass) {
tab.spriteCssClass = sprite(view[idx]);
}
tabs[idx] = tab;
}
if (e.action == 'add') {
if (e.index < that.tabGroup.children().length) {
that.insertBefore(tabs, that.tabGroup.children().eq(e.index));
} else {
that.append(tabs);
}
} else if (e.action == 'remove') {
for (idx = 0; idx < view.length; idx++) {
that.remove(e.index);
}
} else if (e.action == 'itemchange') {
idx = that.dataSource.view().indexOf(view[0]);
if (e.field === options.dataTextField) {
that.tabGroup.children().eq(idx).find('.k-link').text(view[0].get(e.field));
}
if (e.field === options.dataUrlField) {
that._contentUrls[idx] = view[0].get(e.field);
}
} else {
that.trigger('dataBinding');
that.remove('li');
that._contentUrls = [];
that.append(tabs);
that.trigger('dataBound');
}
},
value: function (value) {
var that = this;
if (value !== undefined) {
if (value != that.value()) {
that.tabGroup.children().each(function () {
if ($.trim($(this).text()) == value) {
that.select(this);
}
});
}
} else {
return that.select().text();
}
},
items: function () {
return this.tabGroup[0].children;
},
setOptions: function (options) {
var that = this, animation = that.options.animation;
that._animations(options);
if (options.contentUrls) {
that._contentUrls = options.contentUrls;
}
options.animation = extend(true, animation, options.animation);
if (options.navigatable) {
that.wrapper.on('keydown' + NS, that._keyDownProxy);
} else {
that.wrapper.off('keydown' + NS, that._keyDownProxy);
}
Widget.fn.setOptions.call(that, options);
},
events: [
SELECT,
ACTIVATE,
SHOW,
ERROR,
CONTENTLOAD,
'change',
'dataBinding',
'dataBound'
],
options: {
name: 'TabStrip',
dataEncodedField: '',
dataTextField: '',
dataContentField: '',
dataImageUrlField: '',
dataUrlField: '',
dataSpriteCssClass: '',
dataContentUrlField: '',
tabPosition: 'top',
animation: {
open: {
effects: 'expand:vertical fadeIn',
duration: 200
},
close: { duration: 200 }
},
collapsible: false,
navigatable: true,
contentUrls: false,
scrollable: { distance: DEFAULTDISTANCE }
},
destroy: function () {
var that = this, scrollWrap = that.scrollWrap;
Widget.fn.destroy.call(that);
if (that._refreshHandler) {
that.dataSource.unbind('change', that._refreshHandler);
}
that.wrapper.off(NS);
that.wrapper.children('.k-tabstrip-items').off(NS);
if (that._scrollableModeActive) {
that._scrollPrevButton.off().remove();
that._scrollNextButton.off().remove();
}
kendo.destroy(that.wrapper);
scrollWrap.children('.k-tabstrip').unwrap();
},
select: function (element) {
var that = this;
if (arguments.length === 0) {
return that.tabGroup.children('li.' + ACTIVESTATE);
}
if (!isNaN(element)) {
element = that.tabGroup.children().get(element);
}
element = that.tabGroup.find(element);
$(element).each(function (index, item) {
item = $(item);
if (!item.hasClass(ACTIVESTATE) && !that.trigger(SELECT, {
item: item[0],
contentElement: that.contentHolder(item.index())[0]
})) {
that.activateTab(item);
}
});
return that;
},
enable: function (element, state) {
this._toggleDisabled(element, state !== false);
return this;
},
disable: function (element) {
this._toggleDisabled(element, false);
return this;
},
reload: function (element) {
element = this.tabGroup.find(element);
var that = this;
var contentUrls = that._contentUrls;
element.each(function () {
var item = $(this), contentUrl = item.find('.' + LINK).data(CONTENTURL) || contentUrls[item.index()], content = that.contentHolder(item.index());
if (contentUrl) {
that.ajaxRequest(item, content, null, contentUrl);
}
});
return that;
},
append: function (tab) {
var that = this, inserted = that._create(tab);
each(inserted.tabs, function (idx) {
var contents = inserted.contents[idx];
that.tabGroup.append(this);
if (that.options.tabPosition == 'bottom') {
that.tabGroup.before(contents);
} else if (that._scrollableModeActive) {
that._scrollPrevButton.before(contents);
} else {
that.wrapper.append(contents);
}
that.angular('compile', function () {
return { elements: [contents] };
});
});
updateFirstLast(that.tabGroup);
that._updateContentElements();
that.resize(true);
return that;
},
_appendUrlItem: function (url) {
this._contentUrls.push(url);
},
_moveUrlItem: function (from, to) {
this._contentUrls.splice(to, 0, this._contentUrls.splice(from, 1)[0]);
},
_removeUrlItem: function (index) {
this._contentUrls.splice(index, 1);
},
insertBefore: function (tab, referenceTab) {
if ($(tab).is($(referenceTab))) {
referenceTab = this.tabGroup.find(referenceTab).next();
} else {
referenceTab = this.tabGroup.find(referenceTab);
}
var that = this, inserted = that._create(tab), referenceContent = that.element.find('[id=\'' + referenceTab.attr('aria-controls') + '\']');
each(inserted.tabs, function (idx) {
var contents = inserted.contents[idx];
var fromIndex = inserted.newTabsCreated ? that._contentUrls.length - (inserted.tabs.length - idx) : $(contents).index() - 1;
referenceTab.before(this);
referenceContent.before(contents);
that._moveUrlItem(fromIndex, $(this).index());
that.angular('compile', function () {
return { elements: [contents] };
});
});
updateFirstLast(that.tabGroup);
that._updateContentElements(inserted.newTabsCreated);
that.resize(true);
return that;
},
insertAfter: function (tab, referenceTab) {
if ($(tab).is($(referenceTab))) {
referenceTab = this.tabGroup.find(referenceTab).prev();
} else {
referenceTab = this.tabGroup.find(referenceTab);
}
var that = this, inserted = that._create(tab), referenceContent = that.element.find('[id=\'' + referenceTab.attr('aria-controls') + '\']');
each(inserted.tabs, function (idx) {
var contents = inserted.contents[idx];
var fromIndex = inserted.newTabsCreated ? that._contentUrls.length - (inserted.tabs.length - idx) : $(contents).index() - 1;
referenceTab.after(this);
referenceContent.after(contents);
that._moveUrlItem(fromIndex, $(this).index());
that.angular('compile', function () {
return { elements: [contents] };
});
});
updateFirstLast(that.tabGroup);
that._updateContentElements(inserted.newTabsCreated);
that.resize(true);
return that;
},
remove: function (elements) {
var that = this;
var type = typeof elements;
var contents;
if (type === 'string') {
elements = that.tabGroup.find(elements);
} else if (type === 'number') {
elements = that.tabGroup.children().eq(elements);
}
contents = elements.map(function () {
var idx = $(this).index();
var content = that.contentElement(idx);
kendo.destroy(content);
that._removeUrlItem(idx);
return content;
});
elements.remove();
contents.empty();
contents.remove();
that._updateContentElements();
that.resize(true);
return that;
},
_create: function (tab) {
var that = this, tabs, contents, content, newTabsCreated = false;
tab = tab instanceof kendo.data.ObservableArray ? tab.toJSON() : tab;
if ($.isPlainObject(tab) || $.isArray(tab)) {
tab = $.isArray(tab) ? tab : [tab];
newTabsCreated = true;
tabs = map(tab, function (value, idx) {
that._appendUrlItem(tab[idx].contentUrl || null);
return $(TabStrip.renderItem({
group: that.tabGroup,
item: extend(value, { index: idx })
}));
});
contents = map(tab, function (value, idx) {
if (typeof value.content == 'string' || value.contentUrl) {
return $(TabStrip.renderContent({ item: extend(value, { index: idx }) }));
}
});
} else {
if (typeof tab == 'string' && tab[0] != '<') {
tabs = that.element.find(tab);
} else {
tabs = $(tab);
}
contents = $();
tabs.each(function () {
if (/k-tabstrip-items/.test(this.parentNode.className)) {
var element = that.element.find('[id=\'' + this.getAttribute('aria-controls') + '\']');
content = element;
} else {
content = $('
');
}
contents = contents.add(content);
});
updateTabClasses(tabs);
}
return {
tabs: tabs,
contents: contents,
newTabsCreated: newTabsCreated
};
},
_toggleDisabled: function (element, enable) {
element = this.tabGroup.find(element);
element.each(function () {
$(this).toggleClass(DEFAULTSTATE, enable).toggleClass(DISABLEDSTATE, !enable).attr('aria-disabled', !enable);
});
},
_updateClasses: function () {
var that = this, tabs, activeItem, activeTab;
that.wrapper.addClass('k-widget k-header k-tabstrip');
that.tabGroup = that.wrapper.children('ul').addClass('k-tabstrip-items k-reset');
if (!that.tabGroup[0]) {
that.tabGroup = $('
').appendTo(that.wrapper);
}
tabs = that.tabGroup.find('li').addClass('k-item');
if (tabs.length) {
activeItem = tabs.filter('.' + ACTIVESTATE).index();
activeTab = activeItem >= 0 ? activeItem : undefined;
that.tabGroup.contents().filter(function () {
return this.nodeType == 3 && !trim(this.nodeValue);
}).remove();
}
if (activeItem >= 0) {
tabs.eq(activeItem).addClass(TABONTOP);
}
that.contentElements = that.wrapper.children('div');
that.contentElements.addClass(CONTENT).eq(activeTab).addClass(ACTIVESTATE).css({ display: 'block' });
if (tabs.length) {
updateTabClasses(tabs);
updateFirstLast(that.tabGroup);
that._updateContentElements(true);
}
},
_elementId: function (element, idx) {
var elementId = element.attr('id');
var wrapperId = this.element.attr('id');
if (!elementId || elementId.indexOf(wrapperId + '-') > -1) {
var tabStripID = (wrapperId || kendo.guid()) + '-';
return tabStripID + (idx + 1);
}
return elementId;
},
_updateContentElements: function (isInitialUpdate) {
var that = this, contentUrls = that._contentUrls, items = that.tabGroup.children('.k-item'), contentElements = that.wrapper.children('div'), _elementId = that._elementId.bind(that);
if (contentElements.length && items.length > contentElements.length) {
contentElements.each(function (idx) {
var id = _elementId($(this), idx);
var item = items.filter('[aria-controls=' + (this.id || 0) + ']')[0];
if (!item && isInitialUpdate) {
item = items[idx];
}
if (item) {
item.setAttribute('aria-controls', id);
}
this.setAttribute('id', id);
});
} else {
items.each(function (idx) {
var currentContent = contentElements.eq(idx);
var id = _elementId(currentContent, idx);
this.setAttribute('aria-controls', id);
if (!currentContent.length && contentUrls[idx]) {
$('
').appendTo(that.wrapper).attr('id', id);
} else {
currentContent.attr('id', id);
if (!$(this).children('.k-loading')[0] && !contentUrls[idx]) {
$('
').prependTo(this);
}
}
currentContent.attr('role', 'tabpanel');
currentContent.filter(':not(.' + ACTIVESTATE + ')').attr('aria-hidden', true).attr('aria-expanded', false);
currentContent.filter('.' + ACTIVESTATE).attr('aria-expanded', true);
});
}
that.contentElements = that.contentAnimators = that.wrapper.children('div');
that.tabsHeight = outerHeight(that.tabGroup) + parseInt(that.wrapper.css('border-top-width'), 10) + parseInt(that.wrapper.css('border-bottom-width'), 10);
if (kendo.kineticScrollNeeded && kendo.mobile.ui.Scroller) {
kendo.touchScroller(that.contentElements);
that.contentElements = that.contentElements.children('.km-scroll-container');
}
},
_wrapper: function () {
var that = this;
if (that.element.is('ul')) {
that.wrapper = that.element.wrapAll('
').parent();
} else {
that.wrapper = that.element;
}
that.scrollWrap = that.wrapper.parent('.k-tabstrip-wrapper');
if (!that.scrollWrap[0]) {
that.scrollWrap = that.wrapper.wrapAll('
').parent();
}
},
_tabPosition: function () {
var that = this, tabPosition = that.options.tabPosition;
that.wrapper.addClass('k-floatwrap k-tabstrip-' + tabPosition);
if (tabPosition == 'bottom') {
that.tabGroup.appendTo(that.wrapper);
}
that.resize(true);
},
_setContentElementsDimensions: function () {
var that = this, tabPosition = that.options.tabPosition;
if (tabPosition == 'left' || tabPosition == 'right') {
var contentDivs = that.wrapper.children('.k-content'), activeDiv = contentDivs.filter(':visible'), marginStyleProperty = 'margin-' + tabPosition, tabGroup = that.tabGroup, margin = outerWidth(tabGroup);
var minHeight = Math.ceil(tabGroup.height()) - parseInt(activeDiv.css('padding-top'), 10) - parseInt(activeDiv.css('padding-bottom'), 10) - parseInt(activeDiv.css('border-top-width'), 10) - parseInt(activeDiv.css('border-bottom-width'), 10);
setTimeout(function () {
contentDivs.css(marginStyleProperty, margin).css('min-height', minHeight);
});
}
},
_resize: function () {
this._setContentElementsDimensions();
this._scrollable();
},
_sizeScrollWrap: function (element) {
if (element.is(':visible')) {
var tabPosition = this.options.tabPosition;
var h = Math.floor(outerHeight(element, true)) + (tabPosition === 'left' || tabPosition === 'right' ? 2 : this.tabsHeight);
this.scrollWrap.css('height', h).css('height');
}
},
_toggleHover: function (e) {
$(e.currentTarget).toggleClass(HOVERSTATE, e.type == MOUSEENTER);
},
_click: function (item) {
var that = this, link = item.find('.' + LINK), href = link.attr(HREF), collapse = that.options.collapsible, index = item.index(), contentHolder = that.contentHolder(index), prevent, isAnchor, neighbours = item.parent().children(), oldFocusedTab = neighbours.filter('.' + FOCUSEDSTATE);
if (item.closest('.k-widget')[0] != that.wrapper[0]) {
return;
}
if (item.is('.' + DISABLEDSTATE + (!collapse ? ',.' + ACTIVESTATE : ''))) {
oldFocusedTab.removeClass(FOCUSEDSTATE);
that._focused = item;
item.addClass(FOCUSEDSTATE);
that._current(item);
if (that._scrollableModeActive) {
that._scrollTabsToItem(item);
}
return true;
}
isAnchor = link.data(CONTENTURL) || that._contentUrls[index] || href && (href.charAt(href.length - 1) == '#' || href.indexOf('#' + that.element[0].id + '-') != -1);
prevent = !href || isAnchor;
if (that.tabGroup.children('[data-animating]').length) {
return prevent;
}
if (that.trigger(SELECT, {
item: item[0],
contentElement: contentHolder[0]
})) {
return true;
}
if (prevent === false) {
return;
}
if (collapse && item.is('.' + ACTIVESTATE)) {
that.deactivateTab(item);
return true;
}
if (that.activateTab(item)) {
prevent = true;
}
return prevent;
},
_scrollable: function () {
var that = this, options = that.options, wrapperOffsetWidth, tabGroupScrollWidth, scrollPrevButton, scrollNextButton;
if (that._scrollableAllowed()) {
that.wrapper.addClass('k-tabstrip-scrollable');
wrapperOffsetWidth = that.wrapper[0].offsetWidth;
tabGroupScrollWidth = that.tabGroup[0].scrollWidth;
if (tabGroupScrollWidth > wrapperOffsetWidth && !that._scrollableModeActive) {
that._nowScrollingTabs = false;
that._isRtl = kendo.support.isRtl(that.element);
var mouseDown = kendo.support.mobileOS ? 'touchstart' : 'mousedown';
var mouseUp = kendo.support.mobileOS ? 'touchend' : 'mouseup';
var browser = kendo.support.browser;
var isRtlScrollDirection = that._isRtl && !browser.msie && !browser.edge;
that.wrapper.append(scrollButtonHtml('prev', 'k-i-arrow-60-left') + scrollButtonHtml('next', 'k-i-arrow-60-right'));
scrollPrevButton = that._scrollPrevButton = that.wrapper.children('.k-tabstrip-prev');
scrollNextButton = that._scrollNextButton = that.wrapper.children('.k-tabstrip-next');
that.tabGroup.css({
marginLeft: outerWidth(scrollPrevButton) + 9,
marginRight: outerWidth(scrollNextButton) + 12
});
scrollPrevButton.on(mouseDown + NS, function () {
that._nowScrollingTabs = true;
that._scrollTabsByDelta(options.scrollable.distance * (isRtlScrollDirection ? 1 : -1));
});
scrollNextButton.on(mouseDown + NS, function () {
that._nowScrollingTabs = true;
that._scrollTabsByDelta(options.scrollable.distance * (isRtlScrollDirection ? -1 : 1));
});
scrollPrevButton.add(scrollNextButton).on(mouseUp + NS, function () {
that._nowScrollingTabs = false;
});
that._scrollableModeActive = true;
that._toggleScrollButtons();
} else if (that._scrollableModeActive && tabGroupScrollWidth <= wrapperOffsetWidth) {
that._scrollableModeActive = false;
that.wrapper.removeClass('k-tabstrip-scrollable');
that._scrollPrevButton.off().remove();
that._scrollNextButton.off().remove();
that.tabGroup.css({
marginLeft: '',
marginRight: ''
});
} else if (!that._scrollableModeActive) {
that.wrapper.removeClass('k-tabstrip-scrollable');
} else {
that._toggleScrollButtons();
}
}
},
_scrollableAllowed: function () {
var options = this.options;
if (options.scrollable && !options.scrollable.distance) {
options.scrollable = { distance: DEFAULTDISTANCE };
}
return options.scrollable && !isNaN(options.scrollable.distance) && (options.tabPosition == 'top' || options.tabPosition == 'bottom');
},
_scrollTabsToItem: function (item) {
var that = this, tabGroup = that.tabGroup, currentScrollOffset = tabGroup.scrollLeft(), itemWidth = outerWidth(item), itemOffset = that._isRtl ? item.position().left : item.position().left - tabGroup.children().first().position().left, tabGroupWidth = tabGroup[0].offsetWidth, tabGroupPadding = Math.ceil(parseFloat(tabGroup.css('padding-left'))), itemPosition;
if (that._isRtl) {
if (itemOffset < 0) {
itemPosition = currentScrollOffset + itemOffset - (tabGroupWidth - currentScrollOffset) - tabGroupPadding;
} else if (itemOffset + itemWidth > tabGroupWidth) {
itemPosition = currentScrollOffset + itemOffset - itemWidth + tabGroupPadding * 2;
}
} else {
if (currentScrollOffset + tabGroupWidth < itemOffset + itemWidth) {
itemPosition = itemOffset + itemWidth - tabGroupWidth + tabGroupPadding * 2;
} else if (currentScrollOffset > itemOffset) {
itemPosition = itemOffset - tabGroupPadding;
}
}
tabGroup.finish().animate({ 'scrollLeft': itemPosition }, 'fast', 'linear', function () {
that._toggleScrollButtons();
});
},
_scrollTabsByDelta: function (delta) {
var that = this;
var tabGroup = that.tabGroup;
var scrLeft = tabGroup.scrollLeft();
tabGroup.finish().animate({ 'scrollLeft': scrLeft + delta }, 'fast', 'linear', function () {
if (that._nowScrollingTabs && !jQuery.fx.off) {
that._scrollTabsByDelta(delta);
} else {
that._toggleScrollButtons();
}
});
},
_toggleScrollButtons: function () {
var that = this, ul = that.tabGroup, scrollLeft = kendo.scrollLeft(ul);
that._scrollPrevButton.toggle(scrollLeft !== 0);
that._scrollNextButton.toggle(scrollLeft < ul[0].scrollWidth - ul[0].offsetWidth - 1);
},
deactivateTab: function (item) {
var that = this, animationSettings = that.options.animation, animation = animationSettings.open, close = extend({}, animationSettings.close), hasCloseAnimation = close && 'effects' in close;
item = that.tabGroup.find(item);
close = extend(hasCloseAnimation ? close : extend({ reverse: true }, animation), { hide: true });
if (kendo.size(animation.effects)) {
item.kendoAddClass(DEFAULTSTATE, { duration: animation.duration });
item.kendoRemoveClass(ACTIVESTATE, { duration: animation.duration });
} else {
item.addClass(DEFAULTSTATE);
item.removeClass(ACTIVESTATE);
}
item.removeAttr('aria-selected');
that.contentAnimators.filter('.' + ACTIVESTATE).kendoStop(true, true).kendoAnimate(close).removeClass(ACTIVESTATE).attr('aria-hidden', true);
},
activateTab: function (item) {
if (this.tabGroup.children('[data-animating]').length) {
return;
}
item = this.tabGroup.find(item);
var that = this, animationSettings = that.options.animation, animation = animationSettings.open, close = extend({}, animationSettings.close), hasCloseAnimation = close && 'effects' in close, neighbours = item.parent().children(), oldTab = neighbours.filter('.' + ACTIVESTATE), itemIndex = neighbours.index(item), isAnimationEnabled = animation && 'duration' in animation && 'effects' in animation;
close = extend(hasCloseAnimation ? close : extend({ reverse: true }, animation), { hide: true });
if (kendo.size(animation.effects)) {
oldTab.kendoRemoveClass(ACTIVESTATE, { duration: close.duration });
item.kendoRemoveClass(HOVERSTATE, { duration: close.duration });
} else {
oldTab.removeClass(ACTIVESTATE);
item.removeClass(HOVERSTATE);
}
var contentAnimators = that.contentAnimators;
if (that.inRequest) {
that.xhr.abort();
that.inRequest = false;
}
if (contentAnimators.length === 0) {
that.tabGroup.find('.' + TABONTOP).removeClass(TABONTOP);
item.addClass(TABONTOP).css('z-index');
item.addClass(ACTIVESTATE);
that._current(item);
that.trigger('change');
if (that._scrollableModeActive) {
that._scrollTabsToItem(item);
}
return false;
}
var visibleContents = contentAnimators.filter('.' + ACTIVESTATE), contentHolder = that.contentHolder(itemIndex), contentElement = contentHolder.closest('.k-content');
that.tabsHeight = outerHeight(that.tabGroup) + parseInt(that.wrapper.css('border-top-width'), 10) + parseInt(that.wrapper.css('border-bottom-width'), 10);
that._sizeScrollWrap(visibleContents);
if (contentHolder.length === 0) {
visibleContents.removeClass(ACTIVESTATE).attr('aria-hidden', true).kendoStop(true, true).kendoAnimate(close);
return false;
}
item.attr('data-animating', true);
var isAjaxContent = (item.children('.' + LINK).data(CONTENTURL) || that._contentUrls[itemIndex] || false) && contentHolder.is(EMPTY), showContentElement = function () {
oldTab.removeAttr('aria-selected');
item.attr('aria-selected', true);
that._current(item);
that._sizeScrollWrap(contentElement);
contentElement.addClass(ACTIVESTATE).removeAttr('aria-hidden').kendoStop(true, true).attr('aria-expanded', true).kendoAnimate(extend({
init: function () {
that.trigger(SHOW, {
item: item[0],
contentElement: contentHolder[0]
});
kendo.resize(contentHolder);
}
}, animation, {
complete: function () {
item.removeAttr('data-animating');
that.trigger(ACTIVATE, {
item: item[0],
contentElement: contentHolder[0]
});
kendo.resize(contentHolder);
that.scrollWrap.css('height', '').css('height');
if (isAnimationEnabled && (kendo.support.browser.msie || kendo.support.browser.edge)) {
contentHolder.finish().animate({ opacity: 0.9 }, 'fast', 'linear', function () {
contentHolder.finish().animate({ opacity: 1 }, 'fast', 'linear');
});
}
}
}));
}, showContent = function () {
if (!isAjaxContent) {
showContentElement();
that.trigger('change');
} else {
item.removeAttr('data-animating');
that.ajaxRequest(item, contentHolder, function () {
item.attr('data-animating', true);
showContentElement();
that.trigger('change');
});
}
if (that._scrollableModeActive) {
that._scrollTabsToItem(item);
}
};
visibleContents.removeClass(ACTIVESTATE);
that.tabGroup.find('.' + TABONTOP).removeClass(TABONTOP);
item.addClass(TABONTOP).css('z-index');
if (kendo.size(animation.effects)) {
oldTab.kendoAddClass(DEFAULTSTATE, { duration: animation.duration });
item.kendoAddClass(ACTIVESTATE, { duration: animation.duration });
} else {
oldTab.addClass(DEFAULTSTATE);
item.addClass(ACTIVESTATE);
}
visibleContents.attr('aria-hidden', true);
visibleContents.attr('aria-expanded', false);
if (visibleContents.length) {
visibleContents.kendoStop(true, true).kendoAnimate(extend({ complete: showContent }, close));
} else {
showContent();
}
return true;
},
contentElement: function (itemIndex) {
if (isNaN(itemIndex - 0)) {
return undefined;
}
var contentElements = this.contentElements && this.contentElements[0] && !kendo.kineticScrollNeeded ? this.contentElements : this.contentAnimators;
var id = $(this.tabGroup.children()[itemIndex]).attr('aria-controls');
if (contentElements) {
for (var i = 0, len = contentElements.length; i < len; i++) {
if (contentElements.eq(i).closest('.k-content')[0].id == id) {
return contentElements[i];
}
}
}
return undefined;
},
contentHolder: function (itemIndex) {
var contentElement = $(this.contentElement(itemIndex)), scrollContainer = contentElement.children('.km-scroll-container');
return kendo.support.touch && scrollContainer[0] ? scrollContainer : contentElement;
},
ajaxRequest: function (element, content, complete, url) {
element = this.tabGroup.find(element);
var that = this, xhr = $.ajaxSettings.xhr, link = element.find('.' + LINK), data = {}, halfWidth = element.width() / 2, fakeProgress = false, statusIcon = element.find('.k-loading').removeClass('k-complete');
if (!statusIcon[0]) {
statusIcon = $('
').prependTo(element);
}
var endState = halfWidth * 2 - statusIcon.width();
var oldProgressAnimation = function () {
statusIcon.animate({ marginLeft: (parseInt(statusIcon.css('marginLeft'), 10) || 0) < halfWidth ? endState : 0 }, 500, oldProgressAnimation);
};
if (kendo.support.browser.msie && kendo.support.browser.version < 10) {
setTimeout(oldProgressAnimation, 40);
}
url = url || link.data(CONTENTURL) || that._contentUrls[element.index()] || link.attr(HREF);
that.inRequest = true;
var ajaxOptions = {
type: 'GET',
cache: false,
url: url,
dataType: 'html',
data: data,
xhr: function () {
var current = this, request = xhr(), event = current.progressUpload ? 'progressUpload' : current.progress ? 'progress' : false;
if (request) {
$.each([
request,
request.upload
], function () {
if (this.addEventListener) {
this.addEventListener('progress', function (evt) {
if (event) {
current[event](evt);
}
}, false);
}
});
}
current.noProgress = !(window.XMLHttpRequest && 'upload' in new XMLHttpRequest());
return request;
},
progress: function (evt) {
if (evt.lengthComputable) {
var percent = parseInt(evt.loaded / evt.total * 100, 10) + '%';
statusIcon.stop(true).addClass('k-progress').css({
'width': percent,
'marginLeft': 0
});
}
},
error: function (xhr, status) {
if (that.trigger('error', {
xhr: xhr,
status: status
})) {
this.complete();
}
},
stopProgress: function () {
clearInterval(fakeProgress);
statusIcon.stop(true).addClass('k-progress')[0].style.cssText = '';
},
complete: function (xhr) {
that.inRequest = false;
if (this.noProgress) {
setTimeout(this.stopProgress, 500);
} else {
this.stopProgress();
}
if (xhr.statusText == 'abort') {
statusIcon.remove();
}
},
success: function (data) {
statusIcon.addClass('k-complete');
try {
var current = this, loaded = 10;
if (current.noProgress) {
statusIcon.width(loaded + '%');
fakeProgress = setInterval(function () {
current.progress({
lengthComputable: true,
loaded: Math.min(loaded, 100),
total: 100
});
loaded += 10;
}, 40);
}
that.angular('cleanup', function () {
return { elements: content.get() };
});
kendo.destroy(content);
content.html(data);
} catch (e) {
var console = window.console;
if (console && console.error) {
console.error(e.name + ': ' + e.message + ' in ' + url);
}
this.error(this.xhr, 'error');
}
if (complete) {
complete.call(that, content);
}
that.angular('compile', function () {
return { elements: content.get() };
});
that.trigger(CONTENTLOAD, {
item: element[0],
contentElement: content[0]
});
}
};
if (typeof url === 'object') {
ajaxOptions = $.extend(true, {}, ajaxOptions, url);
if (isFunction(ajaxOptions.url)) {
ajaxOptions.url = ajaxOptions.url();
}
}
that.xhr = $.ajax(ajaxOptions);
}
});
extend(TabStrip, {
renderItem: function (options) {
options = extend({
tabStrip: {},
group: {}
}, options);
var empty = templates.empty, item = options.item;
return templates.item(extend(options, {
image: item.imageUrl ? templates.image : empty,
sprite: item.spriteCssClass ? templates.sprite : empty,
itemWrapper: templates.itemWrapper
}, rendering));
},
renderContent: function (options) {
return templates.content(extend(options, rendering));
}
});
kendo.ui.plugin(TabStrip);
}(window.kendo.jQuery));
return window.kendo;
}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {
(a3 || a2)();
}));
(function (f, define) {
define('editor/table-wizard/table-wizard-dialog', [
'editor/table-wizard/table-wizard-command',
'kendo.tabstrip'
], f);
}(function () {
(function ($, undefined) {
var kendo = window.kendo, numericTextBoxSettings = {
format: '0',
min: 0
}, units = [
'px',
'em'
], borderStyles = [
'solid',
'dotted',
'dashed',
'double',
'groove',
'ridge',
'inset',
'outset',
'initial',
'inherit',
'none',
'hidden'
];
var tableAlignmentDropDownSettings = {
dataSource: [
{
className: 'k-icon k-i-table-align-middle-left',
value: 'left'
},
{
className: 'k-icon k-i-table-align-middle-center',
value: 'center'
},
{
className: 'k-icon k-i-table-align-middle-right',
value: 'right'
},
{
className: 'k-icon k-i-align-remove',
value: ''
}
],
dataTextField: 'className',
dataValueField: 'value',
template: '',
valueTemplate: ''
};
var cellAlignmentDropDownSettings = {
dataSource: [
{
className: 'k-icon k-i-table-align-top-left',
value: 'left top'
},
{
className: 'k-icon k-i-table-align-top-center',
value: 'center top'
},
{
className: 'k-icon k-i-table-align-top-right',
value: 'right top'
},
{
className: 'k-icon k-i-table-align-middle-left',
value: 'left middle'
},
{
className: 'k-icon k-i-table-align-middle-center',
value: 'center middle'
},
{
className: 'k-icon k-i-table-align-middle-right',
value: 'right middle'
},
{
className: 'k-icon k-i-table-align-bottom-left',
value: 'left bottom'
},
{
className: 'k-icon k-i-table-align-bottom-center',
value: 'center bottom'
},
{
className: 'k-icon k-i-table-align-bottom-right',
value: 'right bottom'
},
{
className: 'k-icon k-i-align-remove',
value: ''
}
],
dataTextField: 'className',
dataValueField: 'value',
template: '',
valueTemplate: ''
};
var accessibilityAlignmentDropDownSettings = {
dataSource: [
{
className: 'k-icon k-i-table-align-top-left',
value: 'left top'
},
{
className: 'k-icon k-i-table-align-top-center',
value: 'center top'
},
{
className: 'k-icon k-i-table-align-top-right',
value: 'right top'
},
{
className: 'k-icon k-i-table-align-bottom-left',
value: 'left bottom'
},
{
className: 'k-icon k-i-table-align-bottom-center',
value: 'center bottom'
},
{
className: 'k-icon k-i-table-align-bottom-right',
value: 'right bottom'
},
{
className: 'k-icon k-i-align-remove',
value: ''
}
],
dataTextField: 'className',
dataValueField: 'value',
template: '',
valueTemplate: ''
};
var dialogTemplate = '';
var TableWizardDialog = kendo.Class.extend({
init: function (options) {
this.options = options;
},
open: function () {
var that = this, options = that.options, dialogOptions = options.dialogOptions, tableData = options.table, dialog, messages = options.messages, isIE = kendo.support.browser.msie;
function close(e) {
e.preventDefault();
that.destroy();
dialog.destroy();
}
function okHandler(e) {
that.collectDialogValues(tableData);
close(e);
if (that.change) {
that.change();
}
options.closeCallback(tableData);
}
function closeHandler(e) {
close(e);
options.closeCallback();
}
dialogOptions.close = closeHandler;
dialogOptions.title = messages.tableWizard;
dialogOptions.visible = options.visible;
dialog = $(that._dialogTemplate(messages)).appendTo(document.body).kendoWindow(dialogOptions).closest('.k-window').toggleClass('k-rtl', options.isRtl).end().find('.k-dialog-ok').click(okHandler).end().find('.k-dialog-close').click(closeHandler).end().data('kendoWindow');
var element = dialog.element;
that._initTabStripComponent(element);
that._initTableViewComponents(element, tableData);
that._initCellViewComponents(element, tableData);
that._initAccessibilityViewComponents(element, tableData);
dialog.center();
dialog.open();
if (isIE) {
var dialogHeight = element.closest('.k-window').height();
element.css('max-height', dialogHeight);
}
},
_initTabStripComponent: function (element) {
var components = this.components = {};
components.tabStrip = element.find('#k-table-wizard-tabs').kendoTabStrip({ animation: false }).data('kendoTabStrip');
},
collectDialogValues: function () {
var that = this;
var data = that.options.table;
that._collectTableViewValues(data);
that._collectCellViewValues(data);
that._collectAccessibilityViewValues(data);
},
_collectTableViewValues: function (tableData) {
var tableView = this.components.tableView;
var tableProperties = tableData.tableProperties;
tableProperties.width = tableView.width.value();
tableProperties.widthUnit = tableView.widthUnit.value();
tableProperties.height = tableView.height.value();
tableProperties.columns = tableView.columns.value();
tableProperties.rows = tableView.rows.value();
tableProperties.heightUnit = tableView.heightUnit.value();
tableProperties.cellSpacing = tableView.cellSpacing.value();
tableProperties.cellPadding = tableView.cellPadding.value();
tableProperties.alignment = tableView.alignment.value();
tableProperties.bgColor = tableView.bgColor.value();
tableProperties.className = tableView.className.value;
tableProperties.id = tableView.id.value;
tableProperties.borderWidth = tableView.borderWidth.value();
tableProperties.borderColor = tableView.borderColor.value();
tableProperties.borderStyle = tableView.borderStyle.value();
tableProperties.collapseBorders = tableView.collapseBorders.checked;
},
_collectCellViewValues: function (table) {
var cellData = table.cellProperties = {};
var cellView = this.components.cellView;
cellData.selectAllCells = cellView.selectAllCells.checked;
cellData.width = cellView.width.value();
cellData.widthUnit = cellView.widthUnit.value();
cellData.height = cellView.height.value();
cellData.heightUnit = cellView.heightUnit.value();
cellData.cellMargin = cellView.cellMargin.value();
cellData.cellPadding = cellView.cellPadding.value();
cellData.alignment = cellView.alignment.value();
cellData.bgColor = cellView.bgColor.value();
cellData.className = cellView.className.value;
cellData.id = cellView.id.value;
cellData.borderWidth = cellView.borderWidth.value();
cellData.borderColor = cellView.borderColor.value();
cellData.borderStyle = cellView.borderStyle.value();
cellData.wrapText = cellView.wrapText.checked;
if (!cellData.width) {
cellData.selectAllCells = true;
cellData.width = 100 / table.tableProperties.columns;
cellData.widthUnit = '%';
}
},
_collectAccessibilityViewValues: function (table) {
var tableProperties = table.tableProperties;
var accessibilityView = this.components.accessibilityView;
tableProperties.captionContent = accessibilityView.captionContent.value;
tableProperties.captionAlignment = accessibilityView.captionAlignment.value();
tableProperties.summary = accessibilityView.summary.value;
tableProperties.cellsWithHeaders = accessibilityView.cellsWithHeaders.checked;
},
_addUnit: function (units, value) {
if (value && $.inArray(value, units) == -1) {
units.push(value);
}
},
_initTableViewComponents: function (element, table) {
var components = this.components;
var tableView = components.tableView = {};
var tableProperties = table.tableProperties = table.tableProperties || {};
tableProperties.borderStyle = tableProperties.borderStyle || '';
this._addUnit(units, tableProperties.widthUnit);
this._addUnit(units, tableProperties.heightUnit);
this._initNumericTextbox(element.find('#k-editor-table-width'), 'width', tableProperties, tableView);
this._initNumericTextbox(element.find('#k-editor-table-height'), 'height', tableProperties, tableView);
this._initNumericTextbox(element.find('#k-editor-table-columns'), 'columns', tableProperties, tableView, {
min: 1,
value: 4
});
this._initNumericTextbox(element.find('#k-editor-table-rows'), 'rows', tableProperties, tableView, {
min: 1,
value: 4
});
this._initDropDownList(element.find('#k-editor-table-width-type'), 'widthUnit', tableProperties, tableView, units);
this._initDropDownList(element.find('#k-editor-table-height-type'), 'heightUnit', tableProperties, tableView, units);
this._initNumericTextbox(element.find('#k-editor-table-cell-spacing'), 'cellSpacing', tableProperties, tableView);
this._initNumericTextbox(element.find('#k-editor-table-cell-padding'), 'cellPadding', tableProperties, tableView);
this._initTableAlignmentDropDown(element.find('#k-editor-table-alignment'), tableProperties);
this._initColorPicker(element.find('#k-editor-table-bg'), 'bgColor', tableProperties, tableView);
this._initInput(element.find('#k-editor-css-class'), 'className', tableProperties, tableView);
this._initInput(element.find('#k-editor-id'), 'id', tableProperties, tableView);
this._initNumericTextbox(element.find('#k-editor-border-width'), 'borderWidth', tableProperties, tableView);
this._initColorPicker(element.find('#k-editor-border-color'), 'borderColor', tableProperties, tableView);
this._initDropDownList(element.find('#k-editor-border-style'), 'borderStyle', tableProperties, tableView, borderStyles);
this._initCheckbox(element.find('#k-editor-collapse-borders'), 'collapseBorders', tableProperties, tableView);
},
_initCellViewComponents: function (element, table) {
var components = this.components;
var cellView = components.cellView = {};
table.selectedCells = table.selectedCells = table.selectedCells || [];
var cellProperties = table.selectedCells[0] || {
borderStyle: '',
wrapText: true
};
this._addUnit(units, cellProperties.widthUnit);
this._addUnit(units, cellProperties.heightUnit);
this._initCheckbox(element.find('#k-editor-selectAllCells'), 'selectAllCells', table.tableProperties, cellView);
this._initNumericTextbox(element.find('#k-editor-cell-width'), 'width', cellProperties, cellView);
this._initNumericTextbox(element.find('#k-editor-cell-height'), 'height', cellProperties, cellView);
this._initDropDownList(element.find('#k-editor-cell-width-type'), 'widthUnit', cellProperties, cellView, units);
this._initDropDownList(element.find('#k-editor-cell-height-type'), 'heightUnit', cellProperties, cellView, units);
this._initNumericTextbox(element.find('#k-editor-table-cell-margin'), 'cellMargin', cellProperties, cellView);
this._initNumericTextbox(element.find('#k-editor-table-cells-padding'), 'cellPadding', cellProperties, cellView);
this._initCellAlignmentDropDown(element.find('#k-editor-cell-alignment'), cellProperties);
this._initColorPicker(element.find('#k-editor-cell-bg'), 'bgColor', cellProperties, cellView);
this._initInput(element.find('#k-editor-cell-css-class'), 'className', cellProperties, cellView);
this._initInput(element.find('#k-editor-cell-id'), 'id', cellProperties, cellView);
this._initNumericTextbox(element.find('#k-editor-cell-border-width'), 'borderWidth', cellProperties, cellView);
this._initColorPicker(element.find('#k-editor-cell-border-color'), 'borderColor', cellProperties, cellView);
this._initDropDownList(element.find('#k-editor-cell-border-style'), 'borderStyle', cellProperties, cellView, borderStyles);
this._initCheckbox(element.find('#k-editor-wrap-text'), 'wrapText', cellProperties, cellView);
},
_initAccessibilityViewComponents: function (element, table) {
var components = this.components;
var accessibilityView = components.accessibilityView = {};
var tableProperties = table.tableProperties;
this._initInput(element.find('#k-editor-table-caption'), 'captionContent', tableProperties, accessibilityView);
this._initAccessibilityAlignmentDropDown(element.find('#k-editor-accessibility-alignment'), tableProperties);
this._initInput(element.find('#k-editor-accessibility-summary'), 'summary', tableProperties, accessibilityView);
this._initCheckbox(element.find('#k-editor-cells-headers'), 'cellsWithHeaders', tableProperties, accessibilityView);
},
_initNumericTextbox: function (element, property, data, storage, settings) {
var component = storage[property] = element.kendoNumericTextBox(settings ? $.extend({}, numericTextBoxSettings, settings) : numericTextBoxSettings).data('kendoNumericTextBox');
if (property in data) {
component.value(parseInt(data[property], 10));
}
},
_initDropDownList: function (element, property, data, storage, dataSource) {
var component = storage[property] = element.kendoDropDownList({ dataSource: dataSource }).data('kendoDropDownList');
this._setComponentValue(component, data, property);
},
_initTableAlignmentDropDown: function (element, data) {
var messages = this.options.messages;
var tableView = this.components.tableView;
var dataSource = tableAlignmentDropDownSettings.dataSource;
dataSource[0].tooltip = messages.alignLeft;
dataSource[1].tooltip = messages.alignCenter;
dataSource[2].tooltip = messages.alignRight;
dataSource[3].tooltip = messages.alignRemove;
this._initAlignmentDropDown(element, tableAlignmentDropDownSettings, 'alignment', data, tableView);
},
_initCellAlignmentDropDown: function (element, data) {
var messages = this.options.messages;
var cellView = this.components.cellView;
var dataSource = cellAlignmentDropDownSettings.dataSource;
dataSource[0].tooltip = messages.alignLeftTop;
dataSource[1].tooltip = messages.alignCenterTop;
dataSource[2].tooltip = messages.alignRightTop;
dataSource[3].tooltip = messages.alignLeftMiddle;
dataSource[4].tooltip = messages.alignCenterMiddle;
dataSource[5].tooltip = messages.alignRightMiddle;
dataSource[6].tooltip = messages.alignLeftBottom;
dataSource[7].tooltip = messages.alignCenterBottom;
dataSource[8].tooltip = messages.alignRightBottom;
dataSource[9].tooltip = messages.alignRemove;
this._initAlignmentDropDown(element, cellAlignmentDropDownSettings, 'alignment', data, cellView);
},
_initAccessibilityAlignmentDropDown: function (element, data) {
var messages = this.options.messages;
var accessibilityView = this.components.accessibilityView;
var dataSource = accessibilityAlignmentDropDownSettings.dataSource;
dataSource[0].tooltip = messages.alignLeftTop;
dataSource[1].tooltip = messages.alignCenterTop;
dataSource[2].tooltip = messages.alignRightTop;
dataSource[3].tooltip = messages.alignLeftBottom;
dataSource[4].tooltip = messages.alignCenterBottom;
dataSource[5].tooltip = messages.alignRightBottom;
dataSource[6].tooltip = messages.alignRemove;
this._initAlignmentDropDown(element, accessibilityAlignmentDropDownSettings, 'captionAlignment', data, accessibilityView);
},
_initAlignmentDropDown: function (element, settings, name, data, storage) {
var component = storage[name] = element.kendoDropDownList(settings).data('kendoDropDownList');
component.list.addClass('k-align').css('width', '110px');
this._setComponentValue(component, data, name);
},
_setComponentValue: function (component, data, property) {
if (property in data) {
component.value(data[property]);
}
},
_initColorPicker: function (element, property, data, storage) {
var component = storage[property] = element.kendoColorPicker({
buttons: false,
clearButton: true
}).data('kendoColorPicker');
if (data[property]) {
component.value(data[property]);
}
},
_initInput: function (element, property, data, storage) {
var component = storage[property] = element.get(0);
if (property in data) {
component.value = data[property];
}
},
_initCheckbox: function (element, property, data, storage) {
var component = storage[property] = element.get(0);
if (property in data) {
component.checked = data[property];
}
},
destroy: function () {
this._destroyComponents(this.components.tableView);
this._destroyComponents(this.components.cellView);
this._destroyComponents(this.components.accessibilityView);
this._destroyComponents(this.components);
delete this.components;
},
_destroyComponents: function (components) {
for (var widget in components) {
if (components[widget].destroy) {
components[widget].destroy();
}
delete components[widget];
}
},
_dialogTemplate: function (messages) {
return kendo.template(dialogTemplate)({ messages: messages });
}
});
kendo.ui.editor.TableWizardDialog = TableWizardDialog;
}(window.kendo.jQuery));
}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {
(a3 || a2)();
}));
(function (f, define) {
define('kendo.editor', [
'kendo.combobox',
'kendo.dropdownlist',
'kendo.resizable',
'kendo.window',
'kendo.colorpicker',
'kendo.imagebrowser',
'kendo.numerictextbox',
'util/undoredostack',
'editor/main',
'editor/dom',
'editor/serializer',
'editor/range',
'editor/command',
'editor/components',
'editor/toolbar',
'editor/immutables',
'editor/plugins/viewhtml',
'editor/plugins/link',
'editor/plugins/lists',
'editor/plugins/formatting',
'editor/plugins/image',
'editor/plugins/import',
'editor/plugins/insert',
'editor/plugins/export',
'editor/plugins/indent',
'editor/plugins/linebreak',
'editor/plugins/format',
'editor/plugins/inlineformat',
'editor/plugins/formatblock',
'editor/plugins/file',
'editor/plugins/tables',
'editor/plugins/clipboard',
'editor/plugins/keyboard',
'editor/plugins/exportpdf',
'editor/plugins/print',
'editor/resizing/column-resizing',
'editor/resizing/row-resizing',
'editor/resizing/table-resizing',
'editor/resizing/table-resize-handle',
'editor/table-wizard/table-wizard-command',
'editor/table-wizard/table-wizard-dialog'
], f);
}(function () {
var __meta__ = {
id: 'editor',
name: 'Editor',
category: 'web',
description: 'Rich text editor component',
depends: [
'combobox',
'dropdownlist',
'window',
'colorpicker'
],
features: [
{
id: 'editor-imagebrowser',
name: 'Image Browser',
description: 'Support for uploading and inserting images',
depends: ['imagebrowser']
},
{
id: 'editor-resizable',
name: 'Resize handle',
description: 'Support for resizing the content area via a resize handle',
depends: ['resizable']
},
{
id: 'editor-tablewizard',
name: 'Table wizard dialog',
description: 'Support for table properties configuration',
depends: [
'tabstrip',
'button',
'numerictextbox'
]
},
{
id: 'editor-pdf-export',
name: 'PDF export',
description: 'Export Editor content as PDF',
depends: [
'pdf',
'drawing'
]
}
]
};
return window.kendo;
}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {
(a3 || a2)();
}));
(function (f, define) {
define('kendo.maskedtextbox', ['kendo.core'], f);
}(function () {
var __meta__ = {
id: 'maskedtextbox',
name: 'MaskedTextBox',
category: 'web',
description: 'The MaskedTextBox widget allows to specify a mask type on an input field.',
depends: ['core']
};
(function ($, undefined) {
var global = window;
var min = global.Math.min;
var kendo = global.kendo;
var caret = kendo.caret;
var keys = kendo.keys;
var ui = kendo.ui;
var Widget = ui.Widget;
var NS = '.kendoMaskedTextBox';
var proxy = $.proxy;
var setTimeout = window.setTimeout;
var STATEDISABLED = 'k-state-disabled';
var STATEINVALID = 'k-state-invalid';
var DISABLED = 'disabled';
var READONLY = 'readonly';
var CHANGE = 'change';
var MOUSEUP = 'mouseup';
var DROP = 'drop';
var KEYDOWN = 'keydown';
var PASTE = 'paste';
var INPUT = 'input';
function ns(name) {
return name + NS;
}
var INPUT_EVENT_NAME = ns(kendo.support.propertyChangeEvent ? 'propertychange' : INPUT);
function stringDiffStart(str1, str2) {
var i = 0;
while (i < str2.length) {
if (str1[i] !== str2[i]) {
break;
}
i++;
}
return i;
}
var MaskedTextBox = Widget.extend({
init: function (element, options) {
var that = this;
var DOMElement;
Widget.fn.init.call(that, element, options);
that._rules = $.extend({}, that.rules, that.options.rules);
element = that.element;
DOMElement = element[0];
that._wrapper();
that._tokenize();
that._form();
that.element.addClass('k-textbox').attr('autocomplete', 'off').on('focus' + NS, function () {
var value = DOMElement.value;
if (!value) {
DOMElement.value = that._old = that._emptyMask;
} else {
that._togglePrompt(true);
}
that._oldValue = value;
that._timeoutId = setTimeout(function () {
caret(element, 0, value ? that._maskLength : 0);
});
}).on('focusout' + NS, function () {
var value = element.val();
clearTimeout(that._timeoutId);
DOMElement.value = that._old = '';
if (value !== that._emptyMask) {
DOMElement.value = that._old = value;
}
that._change();
that._togglePrompt();
});
var disabled = element.is('[disabled]') || $(that.element).parents('fieldset').is(':disabled');
if (disabled) {
that.enable(false);
} else {
that.readonly(element.is('[readonly]'));
}
that.value(that.options.value || element.val());
that._validationIcon = $('').insertAfter(element);
kendo.notify(that);
},
options: {
name: 'MaskedTextBox',
clearPromptChar: false,
unmaskOnPost: false,
promptChar: '_',
culture: '',
rules: {},
value: '',
mask: ''
},
events: [CHANGE],
rules: {
'0': /\d/,
'9': /\d|\s/,
'#': /\d|\s|\+|\-/,
'L': /[a-zA-Z]/,
'?': /[a-zA-Z]|\s/,
'&': /\S/,
'C': /./,
'A': /[a-zA-Z0-9]/,
'a': /[a-zA-Z0-9]|\s/
},
setOptions: function (options) {
var that = this;
Widget.fn.setOptions.call(that, options);
that._rules = $.extend({}, that.rules, that.options.rules);
that._tokenize();
this._unbindInput();
this._bindInput();
that.value(that.element.val());
},
destroy: function () {
var that = this;
that.element.off(NS);
if (that._formElement) {
that._formElement.off('reset', that._resetHandler);
that._formElement.off('submit', that._submitHandler);
}
Widget.fn.destroy.call(that);
},
raw: function () {
var unmasked = this._unmask(this.element.val(), 0);
return unmasked.replace(new RegExp(escapeRegExp(this.options.promptChar), 'g'), '');
},
value: function (value) {
var element = this.element;
var emptyMask = this._emptyMask;
if (value === undefined) {
return this.element.val();
}
if (value === null) {
value = '';
}
if (!emptyMask) {
this._oldValue = value;
element.val(value);
return;
}
value = this._unmask(value + '');
element.val(value ? emptyMask : '');
this._mask(0, this._maskLength, value);
this._unmaskedValue = null;
value = element.val();
this._oldValue = value;
if (kendo._activeElement() !== element) {
if (value === emptyMask) {
element.val('');
} else {
this._togglePrompt();
}
}
},
_togglePrompt: function (show) {
var DOMElement = this.element[0];
var value = DOMElement.value;
if (this.options.clearPromptChar) {
if (!show) {
value = value.replace(new RegExp(escapeRegExp(this.options.promptChar), 'g'), ' ');
} else {
value = this._oldValue;
}
DOMElement.value = this._old = value;
}
},
readonly: function (readonly) {
this._editable({
readonly: readonly === undefined ? true : readonly,
disable: false
});
},
enable: function (enable) {
this._editable({
readonly: false,
disable: !(enable = enable === undefined ? true : enable)
});
},
_bindInput: function () {
var that = this;
if (that._maskLength) {
if (that.options.$angular) {
that.element.off(INPUT);
}
that.element.on(ns(KEYDOWN), proxy(that._keydown, that)).on(ns(DROP), proxy(that._drop, that)).on(ns(CHANGE), proxy(that._trackChange, that)).on(INPUT_EVENT_NAME, proxy(that._inputHandler, that));
if (kendo.support.browser.msie) {
var version = kendo.support.browser.version;
if (version > 8 && version < 11) {
var events = [
ns(MOUSEUP),
ns(DROP),
ns(KEYDOWN),
ns(PASTE)
].join(' ');
that.element.on(events, proxy(that._legacyIEInputHandler, that));
}
}
}
},
_unbindInput: function () {
var events = [
INPUT_EVENT_NAME,
ns(KEYDOWN),
ns(MOUSEUP),
ns(DROP),
ns(PASTE)
].join(' ');
this.element.off(events);
},
_editable: function (options) {
var that = this;
var element = that.element;
var wrapper = that.wrapper;
var disable = options.disable;
var readonly = options.readonly;
that._unbindInput();
if (!readonly && !disable) {
element.removeAttr(DISABLED).removeAttr(READONLY);
wrapper.removeClass(STATEDISABLED);
that._bindInput();
} else {
element.attr(DISABLED, disable).attr(READONLY, readonly);
wrapper.toggleClass(STATEDISABLED, disable);
}
},
_change: function () {
var that = this;
var value = that.value();
if (value !== that._oldValue) {
that._oldValue = value;
that.trigger(CHANGE);
that.element.trigger(CHANGE);
} else if (value === '' && that.__changing) {
that.element.trigger(CHANGE);
}
},
inputChange: function (backward) {
var that = this;
var old = that._old;
var element = that.element[0];
var value = element.value;
var selection = caret(element);
var cursor = selection[1];
var lengthDiff = value.length - old.length;
var mobile = kendo.support.mobileOS;
if (that.__dropping && lengthDiff < 0) {
return;
}
if (lengthDiff === -1 && mobile.android && mobile.browser === 'chrome') {
backward = true;
}
var contentStart = min(cursor, stringDiffStart(value, old));
var content = value.substring(contentStart, cursor);
element.value = value.substring(0, contentStart) + that._emptyMask.substring(contentStart);
var caretPos = that._mask(contentStart, cursor, content);
var endContent = that._trimStartPromptChars(value.substring(cursor), min(lengthDiff, caretPos - contentStart));
var unmasked = that._unmask(endContent, old.length - endContent.length);
that._mask(caretPos, caretPos, unmasked);
if (backward) {
caretPos = that._findCaretPosBackwards(contentStart);
}
caret(element, caretPos);
that.__dropping = false;
},
_trimStartPromptChars: function (content, count) {
var promptChar = this.options.promptChar;
while (count-- > 0 && content.indexOf(promptChar) === 0) {
content = content.substring(1);
}
return content;
},
_findCaretPosBackwards: function (pos) {
var caretStart = this._find(pos, true);
if (caretStart < pos) {
caretStart += 1;
}
return caretStart;
},
_inputHandler: function () {
if (kendo._activeElement() !== this.element[0]) {
return;
}
this.inputChange(this.__backward);
},
_legacyIEInputHandler: function (e) {
var that = this;
var input = that.element[0];
var value = input.value;
var type = e.type;
that.__pasting = type === 'paste';
setTimeout(function () {
if (type === 'mouseup' && that.__pasting) {
return;
}
if (input.value && input.value !== value) {
that.inputChange(that.__backward);
}
});
},
_trackChange: function () {
var that = this;
that.__changing = true;
setTimeout(function () {
that.__changing = false;
});
},
_form: function () {
var that = this;
var element = that.element;
var formId = element.attr('form');
var form = formId ? $('#' + formId) : element.closest('form');
if (form[0]) {
that._resetHandler = function () {
setTimeout(function () {
that.value(element[0].value);
});
};
that._submitHandler = function () {
that.element[0].value = that._old = that.raw();
};
if (that.options.unmaskOnPost) {
form.on('submit', that._submitHandler);
}
that._formElement = form.on('reset', that._resetHandler);
}
},
_keydown: function (e) {
var key = e.keyCode;
this.__backward = key === keys.BACKSPACE;
if (key === keys.ENTER) {
this._change();
}
},
_drop: function () {
this.__dropping = true;
},
_find: function (idx, backward) {
var value = this.element.val() || this._emptyMask;
var step = 1;
if (backward === true) {
step = -1;
}
while (idx > -1 || idx <= this._maskLength) {
if (value.charAt(idx) !== this.tokens[idx]) {
return idx;
}
idx += step;
}
return -1;
},
_mask: function (start, end, value, backward) {
var element = this.element[0];
var current = element.value || this._emptyMask;
var empty = this.options.promptChar;
var valueLength;
var chrIdx = 0;
var unmasked;
var chr;
var idx;
start = this._find(start, backward);
if (start > end) {
end = start;
}
unmasked = this._unmask(current.substring(end), end);
value = this._unmask(value, start);
valueLength = value.length;
if (value) {
unmasked = unmasked.replace(new RegExp('^_{0,' + valueLength + '}'), '');
}
value += unmasked;
current = current.split('');
chr = value.charAt(chrIdx);
while (start < this._maskLength) {
current[start] = chr || empty;
chr = value.charAt(++chrIdx);
if (idx === undefined && chrIdx > valueLength) {
idx = start;
}
start = this._find(start + 1);
}
element.value = this._old = current.join('');
if (kendo._activeElement() === element) {
if (idx === undefined) {
idx = this._maskLength;
}
caret(element, idx);
}
return idx;
},
_unmask: function (value, idx) {
if (!value) {
return '';
}
if (this._unmaskedValue === value) {
return this._unmaskedValue;
}
value = (value + '').split('');
var chr;
var token;
var chrIdx = 0;
var tokenIdx = idx || 0;
var empty = this.options.promptChar;
var valueLength = value.length;
var tokensLength = this.tokens.length;
var result = '';
while (tokenIdx < tokensLength) {
chr = value[chrIdx];
token = this.tokens[tokenIdx];
if (chr === token || chr === empty) {
result += chr === empty ? empty : '';
chrIdx += 1;
tokenIdx += 1;
} else if (typeof token !== 'string') {
if (token && token.test && token.test(chr) || $.isFunction(token) && token(chr)) {
result += chr;
tokenIdx += 1;
} else {
if (valueLength === 1) {
this._blinkInvalidState();
}
}
chrIdx += 1;
} else {
tokenIdx += 1;
}
if (chrIdx >= valueLength) {
break;
}
}
this._unmaskedValue = result;
return result;
},
_wrapper: function () {
var that = this;
var element = that.element;
var DOMElement = element[0];
var wrapper = element.wrap('').parent();
wrapper[0].style.cssText = DOMElement.style.cssText;
DOMElement.style.width = '100%';
that.wrapper = wrapper.addClass(DOMElement.className);
},
_blinkInvalidState: function () {
var that = this;
that.wrapper.addClass(STATEINVALID);
clearTimeout(that._invalidStateTimeout);
that._invalidStateTimeout = setTimeout(proxy(that._removeInvalidState, that), 100);
},
_removeInvalidState: function () {
var that = this;
that.wrapper.removeClass(STATEINVALID);
that._invalidStateTimeout = null;
},
_tokenize: function () {
var tokens = [];
var tokenIdx = 0;
var mask = this.options.mask || '';
var maskChars = mask.split('');
var length = maskChars.length;
var idx = 0;
var chr;
var rule;
var emptyMask = '';
var promptChar = this.options.promptChar;
var numberFormat = kendo.getCulture(this.options.culture).numberFormat;
var rules = this._rules;
for (; idx < length; idx++) {
chr = maskChars[idx];
rule = rules[chr];
if (rule) {
tokens[tokenIdx] = rule;
emptyMask += promptChar;
tokenIdx += 1;
} else {
if (chr === '.' || chr === ',') {
chr = numberFormat[chr];
} else if (chr === '$') {
chr = numberFormat.currency.symbol;
} else if (chr === '\\') {
idx += 1;
chr = maskChars[idx];
}
chr = chr.split('');
for (var i = 0, l = chr.length; i < l; i++) {
tokens[tokenIdx] = chr[i];
emptyMask += chr[i];
tokenIdx += 1;
}
}
}
this.tokens = tokens;
this._emptyMask = emptyMask;
this._maskLength = emptyMask.length;
}
});
function escapeRegExp(text) {
return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
}
ui.plugin(MaskedTextBox);
}(window.kendo.jQuery));
return window.kendo;
}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {
(a3 || a2)();
}));
(function (f, define) {
define('kendo.toolbar', [
'kendo.core',
'kendo.userevents',
'kendo.popup'
], f);
}(function () {
var __meta__ = {
id: 'toolbar',
name: 'ToolBar',
category: 'web',
description: 'The ToolBar widget displays one or more command buttons divided into groups.',
depends: ['core']
};
(function ($, undefined) {
var kendo = window.kendo, Class = kendo.Class, Widget = kendo.ui.Widget, proxy = $.proxy, isFunction = kendo.isFunction, keys = kendo.keys, outerWidth = kendo._outerWidth, TOOLBAR = 'k-toolbar', BUTTON = 'k-button', OVERFLOW_BUTTON = 'k-overflow-button', TOGGLE_BUTTON = 'k-toggle-button', BUTTON_GROUP = 'k-button-group', SPLIT_BUTTON = 'k-split-button', SEPARATOR = 'k-separator', SPACER_CLASS = 'k-spacer', SPACER = 'spacer', POPUP = 'k-popup', RESIZABLE_TOOLBAR = 'k-toolbar-resizable', STATE_ACTIVE = 'k-state-active', STATE_DISABLED = 'k-state-disabled', STATE_HIDDEN = 'k-state-hidden', GROUP_START = 'k-group-start', GROUP_END = 'k-group-end', PRIMARY = 'k-primary', ICON = 'k-icon', ICON_PREFIX = 'k-i-', BUTTON_ICON = 'k-button-icon', BUTTON_ICON_TEXT = 'k-button-icontext', LIST_CONTAINER = 'k-list-container k-split-container', SPLIT_BUTTON_ARROW = 'k-split-button-arrow', OVERFLOW_ANCHOR = 'k-overflow-anchor', OVERFLOW_CONTAINER = 'k-overflow-container', FIRST_TOOLBAR_VISIBLE = 'k-toolbar-first-visible', LAST_TOOLBAR_VISIBLE = 'k-toolbar-last-visible', CLICK = 'click', TOGGLE = 'toggle', OPEN = 'open', CLOSE = 'close', OVERFLOW_OPEN = 'overflowOpen', OVERFLOW_CLOSE = 'overflowClose', OVERFLOW_NEVER = 'never', OVERFLOW_AUTO = 'auto', OVERFLOW_ALWAYS = 'always', OVERFLOW_HIDDEN = 'k-overflow-hidden', OPTION_LIST_SUFFIX = '_optionlist', KENDO_UID_ATTR = kendo.attr('uid');
kendo.toolbar = {};
var components = {
overflowAnchor: '',
overflowContainer: ''
};
kendo.toolbar.registerComponent = function (name, toolbar, overflow) {
components[name] = {
toolbar: toolbar,
overflow: overflow
};
};
var Item = kendo.Class.extend({
addOverflowAttr: function () {
this.element.attr(kendo.attr('overflow'), this.options.overflow || OVERFLOW_AUTO);
},
addUidAttr: function () {
this.element.attr(KENDO_UID_ATTR, this.options.uid);
},
addIdAttr: function () {
if (this.options.id) {
this.element.attr('id', this.options.id);
}
},
addOverflowIdAttr: function () {
if (this.options.id) {
this.element.attr('id', this.options.id + '_overflow');
}
},
attributes: function () {
if (this.options.attributes) {
this.element.attr(this.options.attributes);
}
},
show: function () {
this.element.removeClass(STATE_HIDDEN).show();
this.options.hidden = false;
},
hide: function () {
this.element.addClass(STATE_HIDDEN).hide();
if (this.overflow && this.overflowHidden) {
this.overflowHidden();
}
this.options.hidden = true;
},
remove: function () {
this.element.remove();
},
enable: function (isEnabled) {
if (isEnabled === undefined) {
isEnabled = true;
}
this.element.toggleClass(STATE_DISABLED, !isEnabled);
this.options.enable = isEnabled;
},
twin: function () {
var uid = this.element.attr(KENDO_UID_ATTR);
if (this.overflow && this.options.splitContainerId) {
return $('#' + this.options.splitContainerId).find('[' + KENDO_UID_ATTR + '=\'' + uid + '\']').data(this.options.type);
} else if (this.overflow) {
return this.toolbar.element.find('[' + KENDO_UID_ATTR + '=\'' + uid + '\']').data(this.options.type);
} else if (this.toolbar.options.resizable) {
return this.toolbar.popup.element.find('[' + KENDO_UID_ATTR + '=\'' + uid + '\']').data(this.options.type);
}
}
});
kendo.toolbar.Item = Item;
var Button = Item.extend({
init: function (options, toolbar) {
var element = options.useButtonTag ? $('') : $('');
this.element = element;
this.options = options;
this.toolbar = toolbar;
this.attributes();
if (options.primary) {
element.addClass(PRIMARY);
}
if (options.togglable) {
element.addClass(TOGGLE_BUTTON);
this.toggle(options.selected);
}
if (options.url !== undefined && !options.useButtonTag) {
element.attr('href', options.url);
if (options.mobile) {
element.attr(kendo.attr('role'), 'button');
}
}
if (options.group) {
element.attr(kendo.attr('group'), options.group);
this.group = this.toolbar.addToGroup(this, options.group);
}
if (!options.togglable && options.click && isFunction(options.click)) {
this.clickHandler = options.click;
}
if (options.togglable && options.toggle && isFunction(options.toggle)) {
this.toggleHandler = options.toggle;
}
},
toggle: function (state, propagate) {
state = !!state;
if (this.group && state) {
this.group.select(this);
} else if (!this.group) {
this.select(state);
}
if (propagate && this.twin()) {
this.twin().toggle(state);
}
},
getParentGroup: function () {
if (this.options.isChild) {
return this.element.closest('.' + BUTTON_GROUP).data('buttonGroup');
}
},
_addGraphics: function () {
var element = this.element, icon = this.options.icon, spriteCssClass = this.options.spriteCssClass, imageUrl = this.options.imageUrl, isEmpty, span, img;
if (spriteCssClass || imageUrl || icon) {
isEmpty = true;
element.contents().filter(function () {
return !$(this).hasClass('k-sprite') && !$(this).hasClass(ICON) && !$(this).hasClass('k-image');
}).each(function (idx, el) {
if (el.nodeType == 1 || el.nodeType == 3 && $.trim(el.nodeValue).length > 0) {
isEmpty = false;
}
});
if (isEmpty) {
element.addClass(BUTTON_ICON);
} else {
element.addClass(BUTTON_ICON_TEXT);
}
}
if (icon) {
span = element.children('span.' + ICON).first();
if (!span[0]) {
span = $('').prependTo(element);
}
span.addClass(ICON_PREFIX + icon);
} else if (spriteCssClass) {
span = element.children('span.k-sprite').first();
if (!span[0]) {
span = $('').prependTo(element);
}
span.addClass(spriteCssClass);
} else if (imageUrl) {
img = element.children('img.k-image').first();
if (!img[0]) {
img = $('![icon]()
').prependTo(element);
}
img.attr('src', imageUrl);
}
}
});
kendo.toolbar.Button = Button;
var ToolBarButton = Button.extend({
init: function (options, toolbar) {
Button.fn.init.call(this, options, toolbar);
var element = this.element;
element.addClass(BUTTON);
this.addIdAttr();
if (options.align) {
element.addClass('k-align-' + options.align);
}
if (options.showText != 'overflow' && options.text) {
if (options.mobile) {
element.html('' + options.text + '');
} else {
element.html(options.text);
}
}
options.hasIcon = options.showIcon != 'overflow' && (options.icon || options.spriteCssClass || options.imageUrl);
if (options.hasIcon) {
this._addGraphics();
}
this.addUidAttr();
this.addOverflowAttr();
this.enable(options.enable);
if (options.hidden) {
this.hide();
}
this.element.data({
type: 'button',
button: this
});
},
select: function (selected) {
if (selected === undefined) {
selected = false;
}
this.element.toggleClass(STATE_ACTIVE, selected);
this.options.selected = selected;
}
});
kendo.toolbar.ToolBarButton = ToolBarButton;
var OverflowButton = Button.extend({
init: function (options, toolbar) {
this.overflow = true;
Button.fn.init.call(this, $.extend({}, options), toolbar);
var element = this.element;
if (options.showText != 'toolbar' && options.text) {
if (options.mobile) {
element.html('' + options.text + '');
} else {
element.html('' + options.text + '');
}
}
options.hasIcon = options.showIcon != 'toolbar' && (options.icon || options.spriteCssClass || options.imageUrl);
if (options.hasIcon) {
this._addGraphics();
}
if (!options.isChild) {
this._wrap();
}
this.addOverflowIdAttr();
this.attributes();
this.addUidAttr();
this.addOverflowAttr();
this.enable(options.enable);
element.addClass(OVERFLOW_BUTTON + ' ' + BUTTON);
if (options.hidden) {
this.hide();
}
if (options.togglable) {
this.toggle(options.selected);
}
this.element.data({
type: 'button',
button: this
});
},
_wrap: function () {
this.element = this.element.wrap('').parent();
},
overflowHidden: function () {
this.element.addClass(OVERFLOW_HIDDEN);
},
select: function (selected) {
if (selected === undefined) {
selected = false;
}
if (this.options.isChild) {
this.element.toggleClass(STATE_ACTIVE, selected);
} else {
this.element.find('.k-button').toggleClass(STATE_ACTIVE, selected);
}
this.options.selected = selected;
}
});
kendo.toolbar.OverflowButton = OverflowButton;
kendo.toolbar.registerComponent('button', ToolBarButton, OverflowButton);
var ButtonGroup = Item.extend({
createButtons: function (buttonConstructor) {
var options = this.options;
var items = options.buttons || [];
var item;
for (var i = 0; i < items.length; i++) {
if (!items[i].uid) {
items[i].uid = kendo.guid();
}
item = new buttonConstructor($.extend({
mobile: options.mobile,
isChild: true,
type: 'button'
}, items[i]), this.toolbar);
item.element.appendTo(this.element);
}
},
refresh: function () {
this.element.children().filter(':not(\'.' + STATE_HIDDEN + '\'):first').addClass(GROUP_START);
this.element.children().filter(':not(\'.' + STATE_HIDDEN + '\'):last').addClass(GROUP_END);
}
});
kendo.toolbar.ButtonGroup = ButtonGroup;
var ToolBarButtonGroup = ButtonGroup.extend({
init: function (options, toolbar) {
var element = this.element = $('');
this.options = options;
this.toolbar = toolbar;
this.addIdAttr();
if (options.align) {
element.addClass('k-align-' + options.align);
}
this.createButtons(ToolBarButton);
this.attributes();
this.addUidAttr();
this.addOverflowAttr();
this.refresh();
element.addClass(BUTTON_GROUP);
this.element.data({
type: 'buttonGroup',
buttonGroup: this
});
}
});
kendo.toolbar.ToolBarButtonGroup = ToolBarButtonGroup;
var OverflowButtonGroup = ButtonGroup.extend({
init: function (options, toolbar) {
var element = this.element = $('');
this.options = options;
this.toolbar = toolbar;
this.overflow = true;
this.addOverflowIdAttr();
this.createButtons(OverflowButton);
this.attributes();
this.addUidAttr();
this.addOverflowAttr();
this.refresh();
element.addClass((options.mobile ? '' : BUTTON_GROUP) + ' k-overflow-group');
this.element.data({
type: 'buttonGroup',
buttonGroup: this
});
},
overflowHidden: function () {
this.element.addClass(OVERFLOW_HIDDEN);
}
});
kendo.toolbar.OverflowButtonGroup = OverflowButtonGroup;
kendo.toolbar.registerComponent('buttonGroup', ToolBarButtonGroup, OverflowButtonGroup);
var ToolBarSplitButton = Item.extend({
init: function (options, toolbar) {
var element = this.element = $('');
this.options = options;
this.toolbar = toolbar;
this.mainButton = new ToolBarButton($.extend({}, options, { hidden: false }), toolbar);
this.arrowButton = $('');
this.popupElement = $('');
this.mainButton.element.removeAttr('href tabindex').appendTo(element);
this.arrowButton.appendTo(element);
this.popupElement.appendTo(element);
if (options.align) {
element.addClass('k-align-' + options.align);
}
if (!options.id) {
options.id = options.uid;
}
element.attr('id', options.id + '_wrapper');
this.addOverflowAttr();
this.addUidAttr();
this.createMenuButtons();
this.createPopup();
this._navigatable();
this.mainButton.main = true;
this.enable(options.enable);
if (options.hidden) {
this.hide();
}
element.data({
type: 'splitButton',
splitButton: this,
kendoPopup: this.popup
});
},
_navigatable: function () {
var that = this;
that.popupElement.on('keydown', '.' + BUTTON, function (e) {
var li = $(e.target).parent();
e.preventDefault();
if (e.keyCode === keys.ESC || e.keyCode === keys.TAB || e.altKey && e.keyCode === keys.UP) {
that.toggle();
that.focus();
} else if (e.keyCode === keys.DOWN) {
findFocusableSibling(li, 'next').focus();
} else if (e.keyCode === keys.UP) {
findFocusableSibling(li, 'prev').focus();
} else if (e.keyCode === keys.SPACEBAR || e.keyCode === keys.ENTER) {
that.toolbar.userEvents.trigger('tap', { target: $(e.target) });
} else if (e.keyCode === keys.HOME) {
li.parent().find(':kendoFocusable').first().focus();
} else if (e.keyCode === keys.END) {
li.parent().find(':kendoFocusable').last().focus();
}
});
},
createMenuButtons: function () {
var options = this.options;
var items = options.menuButtons;
var item;
for (var i = 0; i < items.length; i++) {
item = new ToolBarButton($.extend({
mobile: options.mobile,
type: 'button',
click: options.click
}, items[i]), this.toolbar);
item.element.wrap('').parent().appendTo(this.popupElement);
}
},
createPopup: function () {
var that = this;
var options = this.options;
var element = this.element;
this.popupElement.attr('id', options.id + OPTION_LIST_SUFFIX).attr(KENDO_UID_ATTR, options.rootUid);
if (options.mobile) {
this.popupElement = actionSheetWrap(this.popupElement);
}
this.popup = this.popupElement.kendoPopup({
appendTo: options.mobile ? $(options.mobile).children('.km-pane') : null,
anchor: element,
isRtl: this.toolbar._isRtl,
copyAnchorStyles: false,
animation: options.animation,
open: function (e) {
var isDefaultPrevented = that.toolbar.trigger(OPEN, { target: element });
if (isDefaultPrevented) {
e.preventDefault();
return;
}
that.adjustPopupWidth(e.sender);
},
activate: function () {
this.element.find(':kendoFocusable').first().focus();
},
close: function (e) {
var isDefaultPrevented = that.toolbar.trigger(CLOSE, { target: element });
if (isDefaultPrevented) {
e.preventDefault();
}
element.focus();
}
}).data('kendoPopup');
this.popup.element.on(CLICK, 'a.k-button', preventClick);
},
adjustPopupWidth: function (popup) {
var anchor = popup.options.anchor, computedWidth = outerWidth(anchor), width;
kendo.wrap(popup.element).addClass('k-split-wrapper');
if (popup.element.css('box-sizing') !== 'border-box') {
width = computedWidth - (outerWidth(popup.element) - popup.element.width());
} else {
width = computedWidth;
}
popup.element.css({
fontFamily: anchor.css('font-family'),
'min-width': width
});
},
remove: function () {
this.popup.element.off(CLICK, 'a.k-button');
this.popup.destroy();
this.element.remove();
},
toggle: function () {
if (this.options.enable || this.popup.visible()) {
this.popup.toggle();
}
},
enable: function (isEnabled) {
if (isEnabled === undefined) {
isEnabled = true;
}
this.mainButton.enable(isEnabled);
this.element.toggleClass(STATE_DISABLED, !isEnabled);
this.options.enable = isEnabled;
},
focus: function () {
this.element.focus();
},
hide: function () {
if (this.popup) {
this.popup.close();
}
this.element.addClass(STATE_HIDDEN).hide();
this.options.hidden = true;
},
show: function () {
this.element.removeClass(STATE_HIDDEN).hide();
this.options.hidden = false;
}
});
kendo.toolbar.ToolBarSplitButton = ToolBarSplitButton;
var OverflowSplitButton = Item.extend({
init: function (options, toolbar) {
var element = this.element = $(''), items = options.menuButtons, item, splitContainerId;
this.options = options;
this.toolbar = toolbar;
this.overflow = true;
splitContainerId = (options.id || options.uid) + OPTION_LIST_SUFFIX;
this.mainButton = new OverflowButton($.extend({}, options));
this.mainButton.element.appendTo(element);
for (var i = 0; i < items.length; i++) {
item = new OverflowButton($.extend({
mobile: options.mobile,
type: 'button',
splitContainerId: splitContainerId
}, items[i]), this.toolbar);
item.element.appendTo(element);
}
this.addUidAttr();
this.addOverflowAttr();
this.mainButton.main = true;
element.data({
type: 'splitButton',
splitButton: this
});
},
overflowHidden: function () {
this.element.addClass(OVERFLOW_HIDDEN);
}
});
kendo.toolbar.OverflowSplitButton = OverflowSplitButton;
kendo.toolbar.registerComponent('splitButton', ToolBarSplitButton, OverflowSplitButton);
var ToolBarSeparator = Item.extend({
init: function (options, toolbar) {
var element = this.element = $('
');
this.element = element;
this.options = options;
this.toolbar = toolbar;
this.attributes();
this.addIdAttr();
this.addUidAttr();
this.addOverflowAttr();
element.addClass(SEPARATOR);
element.data({
type: 'separator',
separator: this
});
}
});
var OverflowSeparator = Item.extend({
init: function (options, toolbar) {
var element = this.element = $(' ');
this.element = element;
this.options = options;
this.toolbar = toolbar;
this.overflow = true;
this.attributes();
this.addUidAttr();
this.addOverflowIdAttr();
element.addClass(SEPARATOR);
element.data({
type: 'separator',
separator: this
});
},
overflowHidden: function () {
this.element.addClass(OVERFLOW_HIDDEN);
}
});
kendo.toolbar.registerComponent('separator', ToolBarSeparator, OverflowSeparator);
var ToolBarSpacer = Item.extend({
init: function (options, toolbar) {
var element = this.element = $('
');
this.element = element;
this.options = options;
this.toolbar = toolbar;
element.addClass(SPACER_CLASS);
element.data({ type: SPACER });
}
});
kendo.toolbar.registerComponent(SPACER, ToolBarSpacer);
var TemplateItem = Item.extend({
init: function (template, options, toolbar) {
var element = isFunction(template) ? template(options) : template;
if (!(element instanceof jQuery)) {
element = $('').html(element);
} else {
element = element.wrap('').parent();
}
this.element = element;
this.options = options;
this.options.type = 'template';
this.toolbar = toolbar;
this.attributes();
this.addUidAttr();
this.addIdAttr();
this.addOverflowAttr();
element.data({
type: 'template',
template: this
});
}
});
kendo.toolbar.TemplateItem = TemplateItem;
var OverflowTemplateItem = Item.extend({
init: function (template, options, toolbar) {
var element = isFunction(template) ? $(template(options)) : $(template);
if (!(element instanceof jQuery)) {
element = $('').html(element);
} else {
element = element.wrap('').parent();
}
this.element = element;
this.options = options;
this.options.type = 'template';
this.toolbar = toolbar;
this.overflow = true;
this.attributes();
this.addUidAttr();
this.addOverflowIdAttr();
this.addOverflowAttr();
element.data({
type: 'template',
template: this
});
},
overflowHidden: function () {
this.element.addClass(OVERFLOW_HIDDEN);
}
});
kendo.toolbar.OverflowTemplateItem = OverflowTemplateItem;
function toggleActive(e) {
if (!e.target.is('.k-toggle-button')) {
e.target.toggleClass(STATE_ACTIVE, e.type == 'press');
}
}
function actionSheetWrap(element) {
element = $(element);
return element.hasClass('km-actionsheet') ? element.closest('.km-popup-wrapper') : element.addClass('km-widget km-actionsheet').wrap('').parent().wrap('').parent();
}
function preventClick(e) {
if ($(e.target).closest('a.k-button').length) {
e.preventDefault();
}
}
function findFocusableSibling(element, dir) {
var getSibling = dir === 'next' ? $.fn.next : $.fn.prev;
var getter = dir === 'next' ? $.fn.first : $.fn.last;
var candidate = getSibling.call(element);
if (!candidate.length && element.is('.' + OVERFLOW_ANCHOR)) {
return element;
}
if (candidate.is(':kendoFocusable') || !candidate.length) {
return candidate;
}
if (candidate.find(':kendoFocusable').length) {
return getter.call(candidate.find(':kendoFocusable'));
}
return findFocusableSibling(candidate, dir);
}
var Group = Class.extend({
init: function (name) {
this.name = name;
this.buttons = [];
},
add: function (button) {
this.buttons[this.buttons.length] = button;
},
remove: function (button) {
var index = $.inArray(button, this.buttons);
this.buttons.splice(index, 1);
},
select: function (button) {
var tmp;
for (var i = 0; i < this.buttons.length; i++) {
tmp = this.buttons[i];
tmp.select(false);
}
button.select(true);
if (button.twin()) {
button.twin().select(true);
}
}
});
var ToolBar = Widget.extend({
init: function (element, options) {
var that = this;
Widget.fn.init.call(that, element, options);
options = that.options;
element = that.wrapper = that.element;
element.addClass(TOOLBAR + ' k-widget');
this.uid = kendo.guid();
this._isRtl = kendo.support.isRtl(element);
this._groups = {};
element.attr(KENDO_UID_ATTR, this.uid);
that.isMobile = typeof options.mobile === 'boolean' ? options.mobile : that.element.closest('.km-root')[0];
that.animation = that.isMobile ? { open: { effects: 'fade' } } : {};
if (that.isMobile) {
element.addClass('km-widget');
ICON = 'km-icon';
ICON_PREFIX = 'km-';
BUTTON = 'km-button';
BUTTON_GROUP = 'km-buttongroup';
STATE_ACTIVE = 'km-state-active';
STATE_DISABLED = 'km-state-disabled';
}
if (options.resizable) {
that._renderOverflow();
element.addClass(RESIZABLE_TOOLBAR);
that.overflowUserEvents = new kendo.UserEvents(that.element, {
threshold: 5,
allowSelection: true,
filter: '.' + OVERFLOW_ANCHOR,
tap: proxy(that._toggleOverflow, that)
});
that._resizeHandler = kendo.onResize(function () {
that.resize();
});
} else {
that.popup = { element: $([]) };
}
if (options.items && options.items.length) {
for (var i = 0; i < options.items.length; i++) {
that.add(options.items[i]);
}
if (options.resizable) {
that._shrink(that.element.innerWidth());
}
}
that.userEvents = new kendo.UserEvents(document, {
threshold: 5,
allowSelection: true,
filter: '[' + KENDO_UID_ATTR + '=' + this.uid + '] a.' + BUTTON + ', ' + '[' + KENDO_UID_ATTR + '=' + this.uid + '] .' + OVERFLOW_BUTTON,
tap: proxy(that._buttonClick, that),
press: toggleActive,
release: toggleActive
});
that.element.on(CLICK, 'a.k-button', preventClick);
that._navigatable();
if (options.resizable) {
that.popup.element.on(CLICK, +'a.k-button', preventClick);
}
if (options.resizable) {
this._toggleOverflowAnchor();
}
kendo.notify(that);
},
events: [
CLICK,
TOGGLE,
OPEN,
CLOSE,
OVERFLOW_OPEN,
OVERFLOW_CLOSE
],
options: {
name: 'ToolBar',
items: [],
resizable: true,
mobile: null
},
addToGroup: function (button, groupName) {
var group;
if (!this._groups[groupName]) {
group = this._groups[groupName] = new Group();
} else {
group = this._groups[groupName];
}
group.add(button);
return group;
},
destroy: function () {
var that = this;
that.element.find('.' + SPLIT_BUTTON).each(function (idx, element) {
$(element).data('kendoPopup').destroy();
});
that.element.off(CLICK, 'a.k-button');
that.userEvents.destroy();
if (that.options.resizable) {
kendo.unbindResize(that._resizeHandler);
that.overflowUserEvents.destroy();
that.popup.element.off(CLICK, 'a.k-button');
that.popup.destroy();
}
Widget.fn.destroy.call(that);
},
add: function (options) {
var component = components[options.type], template = options.template, tool, that = this, itemClasses = that.isMobile ? '' : 'k-item k-state-default', overflowTemplate = options.overflowTemplate, overflowTool;
$.extend(options, {
uid: kendo.guid(),
animation: that.animation,
mobile: that.isMobile,
rootUid: that.uid
});
if (options.menuButtons) {
for (var i = 0; i < options.menuButtons.length; i++) {
$.extend(options.menuButtons[i], { uid: kendo.guid() });
}
}
if (template && !overflowTemplate || options.type === SPACER) {
options.overflow = OVERFLOW_NEVER;
} else if (!options.overflow) {
options.overflow = OVERFLOW_AUTO;
}
if (options.overflow !== OVERFLOW_NEVER && that.options.resizable) {
if (overflowTemplate) {
overflowTool = new OverflowTemplateItem(overflowTemplate, options, that);
} else if (component) {
overflowTool = new component.overflow(options, that);
overflowTool.element.addClass(itemClasses);
}
if (overflowTool) {
if (options.overflow === OVERFLOW_AUTO) {
overflowTool.overflowHidden();
}
overflowTool.element.appendTo(that.popup.container);
that.angular('compile', function () {
return { elements: overflowTool.element.get() };
});
}
}
if (options.overflow !== OVERFLOW_ALWAYS) {
if (template) {
tool = new TemplateItem(template, options, that);
} else if (component) {
tool = new component.toolbar(options, that);
}
if (tool) {
tool.element.appendTo(that.element);
that.angular('compile', function () {
return { elements: tool.element.get() };
});
}
}
},
_getItem: function (candidate) {
var element, toolbarItem, overflowItem, isResizable = this.options.resizable, type;
element = this.element.find(candidate);
if (!element.length) {
element = $('.k-split-container[data-uid=' + this.uid + ']').find(candidate);
}
type = element.length ? element.data('type') : '';
toolbarItem = element.data(type);
if (toolbarItem) {
if (toolbarItem.main) {
element = element.parent('.' + SPLIT_BUTTON);
type = 'splitButton';
toolbarItem = element.data(type);
}
if (isResizable) {
overflowItem = toolbarItem.twin();
}
} else if (isResizable) {
element = this.popup.element.find(candidate);
type = element.length ? element.data('type') : '';
overflowItem = element.data(type);
if (overflowItem && overflowItem.main) {
element = element.parent('.' + SPLIT_BUTTON);
type = 'splitButton';
overflowItem = element.data(type);
}
}
return {
type: type,
toolbar: toolbarItem,
overflow: overflowItem
};
},
remove: function (candidate) {
var item = this._getItem(candidate);
if (item.toolbar) {
item.toolbar.remove();
}
if (item.overflow) {
item.overflow.remove();
}
this.resize(true);
},
hide: function (candidate) {
var item = this._getItem(candidate);
var buttonGroupInstance;
if (item.toolbar) {
if (item.toolbar.options.type === 'button' && item.toolbar.options.isChild) {
buttonGroupInstance = item.toolbar.getParentGroup();
item.toolbar.hide();
if (buttonGroupInstance) {
buttonGroupInstance.refresh();
}
} else if (!item.toolbar.options.hidden) {
item.toolbar.hide();
}
}
if (item.overflow) {
if (item.overflow.options.type === 'button' && item.overflow.options.isChild) {
buttonGroupInstance = item.overflow.getParentGroup();
item.overflow.hide();
if (buttonGroupInstance) {
buttonGroupInstance.refresh();
}
} else if (!item.overflow.options.hidden) {
item.overflow.hide();
}
}
this.resize(true);
},
show: function (candidate) {
var item = this._getItem(candidate);
if (item.toolbar) {
if (item.toolbar.options.type === 'button' && item.toolbar.options.isChild) {
item.toolbar.show();
item.toolbar.getParentGroup().refresh();
} else if (item.toolbar.options.hidden) {
item.toolbar.show();
}
}
if (item.overflow) {
if (item.overflow.options.type === 'button' && item.overflow.options.isChild) {
item.toolbar.show();
item.overflow.getParentGroup().refresh();
} else if (item.overflow.options.hidden) {
item.overflow.show();
}
}
this.resize(true);
},
enable: function (element, enable) {
var item = this._getItem(element);
if (typeof enable == 'undefined') {
enable = true;
}
if (item.toolbar) {
item.toolbar.enable(enable);
}
if (item.overflow) {
item.overflow.enable(enable);
}
},
getSelectedFromGroup: function (groupName) {
return this.element.find('.' + TOGGLE_BUTTON + '[data-group=\'' + groupName + '\']').filter('.' + STATE_ACTIVE);
},
toggle: function (button, checked) {
var element = $(button), item = element.data('button');
if (item.options.togglable) {
if (checked === undefined) {
checked = true;
}
item.toggle(checked, true);
}
},
_renderOverflow: function () {
var that = this, overflowContainer = components.overflowContainer, isRtl = that._isRtl, horizontalDirection = isRtl ? 'left' : 'right';
that.overflowAnchor = $(components.overflowAnchor).addClass(BUTTON);
that.element.append(that.overflowAnchor);
if (that.isMobile) {
that.overflowAnchor.append('');
overflowContainer = actionSheetWrap(overflowContainer);
} else {
that.overflowAnchor.append('');
}
that.popup = new kendo.ui.Popup(overflowContainer, {
origin: 'bottom ' + horizontalDirection,
position: 'top ' + horizontalDirection,
anchor: that.overflowAnchor,
isRtl: isRtl,
animation: that.animation,
appendTo: that.isMobile ? $(that.isMobile).children('.km-pane') : null,
copyAnchorStyles: false,
open: function (e) {
var wrapper = kendo.wrap(that.popup.element).addClass('k-overflow-wrapper');
if (!that.isMobile) {
wrapper.css('margin-left', (isRtl ? -1 : 1) * ((outerWidth(wrapper) - wrapper.width()) / 2 + 1));
} else {
that.popup.container.css('max-height', parseFloat($('.km-content:visible').innerHeight()) - 15 + 'px');
}
if (that.trigger(OVERFLOW_OPEN)) {
e.preventDefault();
}
},
activate: function () {
this.element.find(':kendoFocusable').first().focus();
},
close: function (e) {
if (that.trigger(OVERFLOW_CLOSE)) {
e.preventDefault();
}
this.element.focus();
}
});
that.popup.element.on('keydown', '.' + BUTTON, function (e) {
var target = $(e.target), li = target.parent(), isComplexTool = li.is('.' + BUTTON_GROUP) || li.is('.' + SPLIT_BUTTON), element;
e.preventDefault();
if (e.keyCode === keys.ESC || e.keyCode === keys.TAB || e.altKey && e.keyCode === keys.UP) {
that._toggleOverflow();
that.overflowAnchor.focus();
} else if (e.keyCode === keys.DOWN) {
element = !isComplexTool || isComplexTool && target.is(':last-child') ? li : target;
findFocusableSibling(element, 'next').focus();
} else if (e.keyCode === keys.UP) {
element = !isComplexTool || isComplexTool && target.is(':first-child') ? li : target;
findFocusableSibling(element, 'prev').focus();
} else if (e.keyCode === keys.SPACEBAR || e.keyCode === keys.ENTER) {
that.userEvents.trigger('tap', { target: $(e.target) });
that.overflowAnchor.focus();
} else if (e.keyCode === keys.HOME) {
li.parent().find(':kendoFocusable').first().focus();
} else if (e.keyCode === keys.END) {
li.parent().find(':kendoFocusable').last().focus();
}
});
if (that.isMobile) {
that.popup.container = that.popup.element.find('.' + OVERFLOW_CONTAINER);
} else {
that.popup.container = that.popup.element;
}
that.popup.container.attr(KENDO_UID_ATTR, this.uid);
},
_toggleOverflowAnchor: function () {
var hasVisibleChildren = false;
var paddingEnd = this._isRtl ? 'padding-left' : 'padding-right';
if (this.options.mobile) {
hasVisibleChildren = this.popup.element.find('.' + OVERFLOW_CONTAINER).children(':not(.' + OVERFLOW_HIDDEN + ', .' + POPUP + ')').length > 0;
} else {
hasVisibleChildren = this.popup.element.children(':not(.' + OVERFLOW_HIDDEN + ', .' + POPUP + ')').length > 0;
}
if (hasVisibleChildren) {
this.overflowAnchor.css({
visibility: 'visible',
width: ''
});
this.wrapper.css(paddingEnd, this.overflowAnchor.outerWidth(true));
} else {
this.overflowAnchor.css({
visibility: 'hidden',
width: '1px'
});
this.wrapper.css(paddingEnd, '');
}
},
_buttonClick: function (e) {
var that = this, popup, target, item, splitContainer, isSplitButtonArrow = e.target.closest('.' + SPLIT_BUTTON_ARROW).length, handler, eventData, urlTarget;
e.preventDefault();
if (isSplitButtonArrow) {
that._toggle(e);
return;
}
target = $(e.target).closest('.' + BUTTON, that.element);
if (target.hasClass(OVERFLOW_ANCHOR)) {
return;
}
item = target.data('button');
if (!item && that.popup) {
target = $(e.target).closest('.' + OVERFLOW_BUTTON, that.popup.container);
item = target.parent('li').data('button');
}
if (!item || !item.options.enable) {
return;
}
if (item.options.togglable) {
handler = isFunction(item.toggleHandler) ? item.toggleHandler : null;
item.toggle(!item.options.selected, true);
eventData = {
target: target,
group: item.options.group,
checked: item.options.selected,
id: item.options.id,
item: item
};
if (handler) {
handler.call(that, eventData);
}
that.trigger(TOGGLE, eventData);
} else {
handler = isFunction(item.clickHandler) ? item.clickHandler : null;
eventData = {
sender: that,
target: target,
id: item.options.id,
item: item
};
if (handler) {
handler.call(that, eventData);
}
that.trigger(CLICK, eventData);
}
if (item.options.url) {
if (item.options.attributes && item.options.attributes.target) {
urlTarget = item.options.attributes.target;
}
window.open(item.options.url, urlTarget || '_self');
}
if (target.hasClass(OVERFLOW_BUTTON)) {
that.popup.close();
}
splitContainer = target.closest('.k-split-container');
if (splitContainer[0]) {
popup = splitContainer.data('kendoPopup');
(popup ? popup : splitContainer.parents('.km-popup-wrapper').data('kendoPopup')).close();
}
},
_navigatable: function () {
var that = this;
that.element.attr('tabindex', 0).on('focusin', function (ev) {
var target = $(ev.target);
var element = $(this).find(':kendoFocusable:first');
if (!target.is('.' + TOOLBAR) || element.length === 0) {
return;
}
if (element.is('.' + OVERFLOW_ANCHOR)) {
element = findFocusableSibling(element, 'next');
}
if (element.length) {
element[0].focus();
}
}).on('keydown', proxy(that._keydown, that));
},
_keydown: function (e) {
var target = $(e.target), keyCode = e.keyCode, items = this.element.children(':not(.k-separator):visible'), direction = this._isRtl ? -1 : 1;
if (keyCode === keys.TAB) {
var element = target.parentsUntil(this.element).last(), lastHasFocus = false, firstHasFocus = false, isOnlyOverflowAnchor = false;
if (!items.not('.' + OVERFLOW_ANCHOR).length) {
isOnlyOverflowAnchor = true;
}
if (!element.length) {
element = target;
}
if (element.is('.' + OVERFLOW_ANCHOR) && !isOnlyOverflowAnchor) {
var lastItemNotOverflowAnchor = items.last();
if (e.shiftKey) {
e.preventDefault();
}
if (lastItemNotOverflowAnchor.is(':kendoFocusable')) {
items.last().focus();
} else {
items.last().find(':kendoFocusable').last().focus();
}
}
if (!e.shiftKey && items.index(element) === items.length - 1) {
if (element.is('.' + BUTTON_GROUP)) {
lastHasFocus = target.is(':last-child');
} else {
lastHasFocus = true;
}
}
var isFirstTool = items.index(element) === items.not('.k-overflow-anchor').first().index();
if (e.shiftKey && isFirstTool) {
if (element.is('.' + BUTTON_GROUP)) {
firstHasFocus = target.is(':first-child');
} else {
firstHasFocus = true;
}
}
if (lastHasFocus && this.overflowAnchor && this.overflowAnchor.css('visibility') !== 'hidden' && !isOnlyOverflowAnchor) {
e.preventDefault();
this.overflowAnchor.focus();
}
if (firstHasFocus || isOnlyOverflowAnchor && e.shiftKey) {
e.preventDefault();
var prevFocusable = this._getPrevFocusable(this.wrapper);
if (prevFocusable) {
prevFocusable.focus();
}
}
this._preventNextFocus = false;
}
if (e.altKey && keyCode === keys.DOWN) {
var splitButton = $(document.activeElement).data('splitButton');
var isOverflowAnchor = $(document.activeElement).is('.' + OVERFLOW_ANCHOR);
if (splitButton) {
splitButton.toggle();
} else if (isOverflowAnchor) {
this._toggleOverflow();
}
return;
}
if ((keyCode === keys.SPACEBAR || keyCode === keys.ENTER) && !target.is('input, checkbox')) {
if (keyCode === keys.SPACEBAR) {
e.preventDefault();
}
if (target.is('.' + SPLIT_BUTTON)) {
target = target.children().first();
this.userEvents.trigger('tap', { target: target });
} else if (keyCode === keys.SPACEBAR) {
this.userEvents.trigger('tap', { target: target });
}
return;
}
if (keyCode === keys.HOME) {
if (target.is('.k-dropdown') || target.is('input')) {
return;
}
if (this.overflowAnchor) {
items.eq(1).focus();
} else {
items.first().focus();
}
e.preventDefault();
} else if (keyCode === keys.END) {
if (target.is('.k-dropdown') || target.is('input')) {
return;
}
if (this.overflowAnchor && $(this.overflowAnchor).css('visibility') != 'hidden') {
this.overflowAnchor.focus();
} else {
items.last().focus();
}
e.preventDefault();
} else if (keyCode === keys.RIGHT && !this._preventNextFocus && !target.is('input, select, .k-dropdown, .k-colorpicker') && this._getNextElement(e.target, 1 * direction)) {
this._getNextElement(e.target, 1 * direction).focus();
e.preventDefault();
} else if (keyCode === keys.LEFT && !this._preventNextFocus && !target.is('input, select, .k-dropdown, .k-colorpicker') && this._getNextElement(e.target, -1 * direction)) {
this._getNextElement(e.target, -1 * direction).focus();
e.preventDefault();
}
},
_getNextElement: function (item, direction) {
var items = this.element.children(':not(.k-separator):visible');
var itemIndex = items.index(item) === -1 ? items.index(item.parentElement) : items.index(item);
var startIndex = this.overflowAnchor ? 1 : 0;
var directionNumber = direction;
var searchIndex = direction === 1 ? items.length - 1 : startIndex;
var index = direction === 1 ? startIndex : items.length - 1;
var focusableItem = items[itemIndex + direction];
this._preventNextFocus = false;
if ($(item).closest('.' + BUTTON_GROUP).length && !$(item).is(direction === 1 ? ':last-child' : ':first-child')) {
return $(item).closest('.' + BUTTON_GROUP).children()[$(item).closest('.' + BUTTON_GROUP).children().index(item) + direction];
}
if (this.overflowAnchor && item === this.overflowAnchor[0] && direction === -1) {
focusableItem = items[items.length - 1];
}
if (itemIndex === searchIndex) {
focusableItem = !this.overflowAnchor || this.overflowAnchor && $(this.overflowAnchor).css('visibility') === 'hidden' ? items[index] : this.overflowAnchor;
}
while (!$(focusableItem).is(':kendoFocusable')) {
if (direction === -1 && $(focusableItem).closest('.' + BUTTON_GROUP).length) {
focusableItem = $(focusableItem).children(':not(label, div)').last();
} else {
focusableItem = $(focusableItem).children(':not(label, div)').first();
}
if (!focusableItem.length) {
directionNumber = directionNumber + direction;
focusableItem = items[itemIndex + directionNumber];
if (!focusableItem) {
return this.overflowAnchor;
}
}
this._preventNextFocus = $(focusableItem).closest('.' + BUTTON_GROUP).length ? false : true;
}
return focusableItem;
},
_getPrevFocusable: function (element) {
if (element.is('html')) {
return element;
}
var elementToFocus, prevElement, prevElements = element.prevAll();
prevElements.each(function () {
prevElement = $(this);
if (prevElement.is(':kendoFocusable')) {
elementToFocus = prevElement;
return false;
} else if (prevElement.find(':kendoFocusable').length > 0) {
elementToFocus = prevElement.find(':kendoFocusable').last();
return false;
}
});
if (elementToFocus) {
return elementToFocus;
} else {
return this._getPrevFocusable(element.parent());
}
},
_toggle: function (e) {
var splitButton = $(e.target).closest('.' + SPLIT_BUTTON).data('splitButton');
e.preventDefault();
if (!splitButton.options.enable) {
return;
}
splitButton.toggle();
},
_toggleOverflow: function () {
this.popup.toggle();
},
_resize: function (e) {
var containerWidth = e.width;
if (!this.options.resizable) {
return;
}
this.popup.close();
this._shrink(containerWidth);
this._stretch(containerWidth);
this._markVisibles();
this._toggleOverflowAnchor();
},
_childrenWidth: function () {
var childrenWidth = 0;
this.element.children(':visible:not(.' + STATE_HIDDEN + ', .' + SPACER_CLASS + ')').each(function () {
childrenWidth += outerWidth($(this), true);
});
return Math.ceil(childrenWidth);
},
_shrink: function (containerWidth) {
var commandElement, visibleCommands;
if (containerWidth < this._childrenWidth()) {
visibleCommands = this.element.children(':visible:not([data-overflow=\'never\'], .' + OVERFLOW_ANCHOR + ')');
for (var i = visibleCommands.length - 1; i >= 0; i--) {
commandElement = visibleCommands.eq(i);
if (containerWidth > this._childrenWidth()) {
break;
} else {
this._hideItem(commandElement);
}
}
}
},
_stretch: function (containerWidth) {
var commandElement, hiddenCommands;
if (containerWidth > this._childrenWidth()) {
hiddenCommands = this.element.children(':hidden:not(\'.' + STATE_HIDDEN + '\')');
for (var i = 0; i < hiddenCommands.length; i++) {
commandElement = hiddenCommands.eq(i);
if (containerWidth < this._childrenWidth() || !this._showItem(commandElement, containerWidth)) {
break;
}
}
}
},
_hideItem: function (item) {
item.hide();
if (this.popup) {
this.popup.container.find('>li[data-uid=\'' + item.data('uid') + '\']').removeClass(OVERFLOW_HIDDEN);
}
},
_showItem: function (item, containerWidth) {
if (item.length && containerWidth > this._childrenWidth() + outerWidth(item, true)) {
item.show();
if (this.popup) {
this.popup.container.find('>li[data-uid=\'' + item.data('uid') + '\']').addClass(OVERFLOW_HIDDEN);
}
return true;
}
return false;
},
_markVisibles: function () {
var overflowItems = this.popup.container.children(), toolbarItems = this.element.children(':not(.k-overflow-anchor)'), visibleOverflowItems = overflowItems.filter(':not(.k-overflow-hidden)'), visibleToolbarItems = toolbarItems.filter(':visible');
overflowItems.add(toolbarItems).removeClass(FIRST_TOOLBAR_VISIBLE + ' ' + LAST_TOOLBAR_VISIBLE);
visibleOverflowItems.first().add(visibleToolbarItems.first()).addClass(FIRST_TOOLBAR_VISIBLE);
visibleOverflowItems.last().add(visibleToolbarItems.last()).addClass(LAST_TOOLBAR_VISIBLE);
}
});
kendo.ui.plugin(ToolBar);
}(window.kendo.jQuery));
return window.kendo;
}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {
(a3 || a2)();
}));
(function (f, define) {
define('kendo.mediaplayer', [
'kendo.slider',
'kendo.toolbar',
'kendo.dropdownlist',
'kendo.tooltip'
], f);
}(function () {
var __meta__ = {
id: 'mediaplayer',
name: 'MediaPlayer',
category: 'web',
description: '',
depends: [
'slider',
'toolbar',
'dropdownlist',
'tooltip'
]
};
(function ($, undefined) {
var kendo = window.kendo, END = 'end', PAUSE = 'pause', PLAY = 'play', READY = 'ready', TIMECHANGE = 'timeChange', VOLUMECHANGE = 'volumeChange', FULLSCREEN_ENTER = 'k-i-full-screen', FULLSCREEN_EXIT = 'k-i-full-screen-exit', MUTE = 'k-i-volume-off', LOW_VOLUME = 'k-i-volume-down', HIGH_VOLUME = 'k-i-volume-up', VIDEO_QUALITY = 'k-mediaplayer-quality', STATE_PLAY = 'k-i-play', STATE_PAUSE = 'k-i-pause', TITLEBAR = 'k-mediaplayer-titlebar', TITLE = 'k-title', TOOLBARWRAP = 'k-mediaplayer-toolbar-wrap', TOOLBAR = 'k-mediaplayer-toolbar', SLIDER = 'k-mediaplayer-seekbar', VOLUME_SLIDER = 'k-mediaplayer-volume', MEDIA = 'k-mediaplayer-media', OVERLAY = 'k-mediaplayer-overlay', YTPLAYER = 'k-mediaplayer-yt', DOT = '.', ui = kendo.ui, ns = '.kendoMediaPlayer', baseTime = new Date(1970, 0, 1), timeZoneSec = baseTime.getTimezoneOffset() * 60, Widget = kendo.ui.Widget, isArray = $.isArray, timeFormats = {
shortTime: 'mm:ss',
longTime: 'HH:mm:ss'
}, template = kendo.template, proxy = $.proxy, keys = kendo.keys, templates = {
htmlPlayer: '',
titleBar: template('Video Title
'),
toolBar: '',
youtubePlayer: '
',
toolBarTime: '00:00:00 / 00:00:00',
slider: '',
volumeSlider: '',
qualityDropDown: '',
toolTip: '#= kendo.toString(new Date(value), \'HH:mm:ss\') #'
};
var MediaPlayer = Widget.extend({
init: function (element, options) {
this.wrapper = $(element);
Widget.fn.init.call(this, element, options);
this.wrapper.addClass('k-mediaplayer k-widget');
options = this.options;
this._currentIndex = 0;
this._createTitlebar();
this._createToolbar();
this._createDropDown();
this._createSlider();
this._createVolumeSlider();
this._timers = {};
this._aria();
this._navigatable();
if (options.fullScreen) {
this.fullScreen(true);
}
if (options.media) {
this.media(this.options.media);
}
kendo.notify(this);
},
events: [
END,
PAUSE,
PLAY,
READY,
TIMECHANGE,
VOLUMECHANGE
],
options: {
name: 'MediaPlayer',
autoPlay: false,
autoRepeat: false,
volume: 100,
fullScreen: false,
mute: false,
navigatable: false,
forwardSeek: true,
media: null,
messages: {
'pause': 'Pause',
'play': 'Play',
'mute': 'Mute',
'unmute': 'Unmute',
'quality': 'Quality',
'fullscreen': 'Full Screen'
}
},
_msToTime: function (ms) {
var time = new Date(baseTime.getTime());
time.setSeconds(ms);
return time;
},
_timeToSec: function (time) {
var curTime = new Date(time).getTime();
return curTime / 1000;
},
_createTitlebar: function () {
this._titleBar = this.wrapper.find(DOT + TITLEBAR);
if (this._titleBar.length === 0) {
this.wrapper.append(templates.titleBar);
this._titleBar = this.wrapper.find(DOT + TITLEBAR);
}
},
_createSlider: function () {
var sliderElement = this.wrapper.find(DOT + SLIDER);
if (!this._slider) {
this._sliderDragChangeHandler = proxy(this._sliderDragChange, this);
this._sliderDraggingHandler = proxy(this._sliderDragging, this);
sliderElement = this.wrapper.find(DOT + SLIDER);
this._slider = new ui.Slider(sliderElement[0], {
smallStep: 1000,
tickPlacement: 'none',
showButtons: false,
change: this._sliderDragChangeHandler,
slide: this._sliderDraggingHandler,
tooltip: { template: templates.toolTip },
dragHandleTitle: ''
});
}
},
_createVolumeSlider: function () {
var volumeSliderElement = this.wrapper.find(DOT + VOLUME_SLIDER);
if (!this._volumeSlider) {
this._volumeDraggingHandler = proxy(this._volumeDragging, this);
this._volumeChangeHandler = proxy(this._volumeChange, this);
volumeSliderElement.width(87);
this._volumeSlider = new ui.Slider(volumeSliderElement[0], {
smallStep: 1,
min: 0,
max: 100,
value: this.options.volume,
slide: this._volumeDraggingHandler,
change: this._volumeChangeHandler,
tickPlacement: 'none',
showButtons: false,
tooltip: { enabled: false },
dragHandleTitle: ''
});
}
},
_resetTime: function () {
if (this._youTubeVideo) {
this._ytmedia.seekTo(0, true);
} else {
this._media.currentTime = 0;
}
this._mediaTimeUpdate();
$.grep(this._toolBar.options.items, function (e) {
return !!e.template;
}).template = templates.toolBarTime;
},
_currentUrl: function () {
var media = this.media();
return isArray(media.source) ? media.source[this._currentIndex].url : media.source;
},
_isYouTubeUrl: function () {
return !!this._currentUrl().match('youtube.com/|youtu.be/');
},
_setPlayerUrl: function () {
var oldPlayer = this._youTubeVideo;
this.stop();
this._youTubeVideo = this._isYouTubeUrl();
if (oldPlayer !== this._youTubeVideo) {
this.wrapper.find(DOT + YTPLAYER).toggle();
this.wrapper.find(DOT + MEDIA).toggle();
}
var initialized = this._media || this._ytmedia;
this._initializePlayer();
if (initialized) {
this.mute(this.mute());
this.volume(this.volume());
}
if (!this._youTubeVideo) {
this._videoOverlay.show();
this.wrapper.find(DOT + MEDIA + ' > source').remove();
this.wrapper.find(DOT + MEDIA).attr('src', this._currentUrl());
if (this.options.autoPlay) {
this.play();
}
} else if (this._ytmedia) {
if (this._videoOverlay) {
this._videoOverlay.hide();
}
if (this.options.autoPlay) {
this._ytmedia.loadVideoById(this._getMediaId());
this._playStateToggle(true);
} else {
this._ytmedia.cueVideoById(this._getMediaId());
this._playStateToggle(true);
}
}
},
_createToolbar: function () {
var toolBarElement = this.wrapper.find(DOT + TOOLBAR);
if (toolBarElement.length === 0) {
this._toolbarClickHandler = proxy(this._toolbarClick, this);
this.wrapper.append(templates.toolBar);
toolBarElement = this.wrapper.find(DOT + TOOLBAR);
toolBarElement.width(this.wrapper.find(DOT + MEDIA).width());
this._toolBar = new ui.ToolBar(toolBarElement, {
click: this._toolbarClickHandler,
resizable: false,
items: [
{
type: 'button',
attributes: { 'class': 'k-play-button' },
icon: 'play'
},
{
template: templates.toolBarTime,
attributes: { 'class': 'k-mediaplayer-currenttime-wrap' }
},
{
type: 'separator',
attributes: { 'class': 'k-toolbar-spacer' }
},
{
type: 'button',
attributes: { 'class': 'k-volume-button' },
icon: 'volume-up'
},
{
template: templates.volumeSlider,
attributes: { 'class': 'k-mediaplayer-volume-wrap' }
},
{
template: templates.qualityDropDown,
attributes: { 'class': 'k-mediaplayer-quality-wrap' }
},
{
type: 'button',
attributes: { 'class': 'k-fullscreen-button' },
icon: 'full-screen'
}
]
});
this._toolBar.wrapper.off('keydown');
toolBarElement.before(templates.slider);
this._volumeButton = toolBarElement.find('.k-volume-button');
this._fullscreenButton = toolBarElement.find('.k-fullscreen-button');
this._volumeButton.attr('title', this.options.mute ? this.options.messages.unmute : this.options.messages.mute);
this._volumeButton.attr('aria-label', this.options.mute ? this.options.messages.unmute : this.options.messages.mute);
this._fullscreenButton.attr('title', this.options.messages.fullscreen);
this._fullscreenButton.attr('aria-label', this.options.messages.fullscreen);
toolBarElement.width('auto');
this._currentTimeElement = toolBarElement.find('.k-mediaplayer-currenttime');
this._durationElement = toolBarElement.find('.k-mediaplayer-duration');
this._playButton = toolBarElement.find('.k-play-button');
this._playButtonSpan = this._playButton.find('.k-i-play');
if (this.options.autoPlay) {
this._playStateToggle(true);
}
$([
this._volumeButton[0],
toolBarElement.find('.k-mediaplayer-volume-wrap')[0],
toolBarElement.find('.k-mediaplayer-quality-wrap')[0],
this._fullscreenButton[0]
]).wrapAll('');
toolBarElement.find('.k-button').addClass('k-bare');
}
},
_createDropDown: function () {
var dropDownElement = this.wrapper.find(DOT + VIDEO_QUALITY);
var media = this.media();
if (typeof dropDownElement.data('kendoDropDownList') === 'undefined') {
this._dropDownSelectHandler = proxy(this._dropDownSelect, this);
this._dropDown = new ui.DropDownList(dropDownElement, {
dataTextField: 'quality',
dataValueField: 'url',
popup: {
position: 'bottom',
origin: 'top',
appendTo: this.wrapper
},
animation: {
open: {
effects: 'slideIn:up',
duration: 1
}
},
select: this._dropDownSelectHandler
});
if (media && isArray(media.source)) {
this._dropDown.setDataSource(media.source);
this._dropDown.select(0);
}
this._dropDown.wrapper.addClass('k-button k-bare');
this._dropDown.wrapper.attr('title', this.options.messages.quality).hide();
this._dropDown.wrapper.find('span.k-i-arrow-60-down').removeClass('k-i-arrow-60-down').addClass('k-icon k-i-hd');
this._dropDown.list.addClass('k-quality-list');
}
},
_dropDownSelect: function (e) {
if (this._currentIndex !== e.item.index()) {
this._currentIndex = e.item.index();
this._setPlayerUrl();
}
},
_toolbarClick: function (e) {
var target = $(e.target).children().first();
var isPaused = target.hasClass(STATE_PLAY);
if (!this.media()) {
return;
}
if (target.hasClass(STATE_PLAY) || target.hasClass(STATE_PAUSE)) {
if (isPaused) {
this.play();
} else {
this.pause();
}
}
if (target.hasClass(FULLSCREEN_ENTER) || target.hasClass(FULLSCREEN_EXIT)) {
if (this._isInFullScreen) {
target.removeClass(FULLSCREEN_EXIT).addClass(FULLSCREEN_ENTER);
this.fullScreen(false);
} else {
target.removeClass(FULLSCREEN_ENTER).addClass(FULLSCREEN_EXIT);
this.fullScreen(true);
}
}
if (target.hasClass(MUTE) || target.hasClass(LOW_VOLUME) || target.hasClass(HIGH_VOLUME)) {
var muted = this.mute();
this.mute(!muted);
}
},
_sliderDragging: function () {
if (!this.media()) {
return;
}
this._isDragging = true;
},
_sliderDragChange: function (e) {
var that = this;
var slider = e.sender;
var tzOffset = timeZoneSec * 1000;
if (!this.media()) {
return;
}
that._sliderChangeFired = true;
that._isDragging = false;
if (!this.options.forwardSeek && slider.value() > this._seekBarLastPosition) {
setTimeout(function () {
slider.value(that._seekBarLastPosition);
}, 1);
} else if (this._youTubeVideo) {
that._ytmedia.seekTo(that._timeToSec(e.value - tzOffset));
} else {
that._media.currentTime = that._timeToSec(e.value - tzOffset);
}
that.trigger(TIMECHANGE);
that._preventPlay = true;
},
_changeVolumeButtonImage: function (volume) {
var volumeButton = this._volumeButton;
var volumeElement = volumeButton.find('span');
var cssClass = volumeElement.attr('class');
cssClass = cssClass.substring(0, cssClass.lastIndexOf(' '));
if (volume === 0) {
volumeElement.attr('class', cssClass + ' ' + MUTE);
volumeButton.attr('title', this.options.messages.unmute);
volumeButton.attr('aria-label', this.options.messages.unmute);
} else if (volume > 0 && volume < 51) {
volumeElement.attr('class', cssClass + ' ' + LOW_VOLUME);
volumeButton.attr('title', this.options.messages.mute);
volumeButton.attr('aria-label', this.options.messages.mute);
} else {
volumeElement.attr('class', cssClass + ' ' + HIGH_VOLUME);
volumeButton.attr('title', this.options.messages.mute);
volumeButton.attr('aria-label', this.options.messages.mute);
}
},
_volumeDragging: function (e) {
if (!this.media()) {
return;
}
this.volume(e.value);
this._changeVolumeButtonImage(e.value);
this.trigger(VOLUMECHANGE);
},
_volumeChange: function (e) {
if (!this.media()) {
return;
}
this.volume(e.value);
this._changeVolumeButtonImage(e.value);
this.trigger(VOLUMECHANGE);
},
_mediaTimeUpdate: function () {
var currentTime = this._youTubeVideo ? this._ytmedia.getCurrentTime() : this._media.currentTime;
currentTime = currentTime ? currentTime : 0;
var timeInMs = this._msToTime(currentTime);
this._currentTimeElement.text(kendo.toString(timeInMs, this._timeFormat));
if (!this._isDragging) {
this._seekBarLastPosition = (currentTime + timeZoneSec) * 1000;
this._slider.value(this._seekBarLastPosition);
}
return this.isPlaying();
},
_playStateToggle: function (play) {
if (typeof play === 'undefined') {
play = this._playButtonSpan.is(DOT + STATE_PLAY);
}
if (play) {
this._playButtonSpan.removeClass(STATE_PLAY).addClass(STATE_PAUSE);
this._playButton.attr('title', this.options.messages.pause);
this._playButton.attr('aria-label', this.options.messages.pause);
} else {
this._playButtonSpan.removeClass(STATE_PAUSE).addClass(STATE_PLAY);
this._playButton.attr('title', this.options.messages.play);
this._playButton.attr('aria-label', this.options.messages.play);
}
},
_mediaEnded: function () {
this._playStateToggle(false);
this._currentTimeElement.text(kendo.toString(this._msToTime(0), this._timeFormat));
this._slider.value((0 + timeZoneSec) * 1000);
this.trigger(END);
},
_mediaPlay: function () {
this.trigger(PLAY);
},
_mediaReady: function () {
this.trigger(READY);
},
_mediaDurationChange: function () {
var durationTime = this._msToTime(this._youTubeVideo ? this._ytmedia.getDuration() : this._media.duration);
this._timeFormat = durationTime.getHours() === 0 ? timeFormats.shortTime : timeFormats.longTime;
this._durationElement.text(kendo.toString(durationTime, this._timeFormat));
this._slider.setOptions({
min: baseTime.getTime(),
max: durationTime.getTime()
});
if (!this._isFirstRun) {
this._resetTime();
this._isFirstRun = true;
}
},
_createYoutubePlayer: function () {
this._mediaTimeUpdateHandler = proxy(this._mediaTimeUpdate, this);
this._mediaDurationChangeHandler = proxy(this._mediaDurationChange, this);
this.wrapper.prepend(templates.youtubePlayer);
this._ytPlayer = this.wrapper.find(DOT + YTPLAYER)[0];
$(this._ytPlayer).css({
width: this.wrapper.width(),
height: this.wrapper.height()
});
if (!window.YT || !window.YT.Player) {
if (!window.onYouTubeIframeAPIReadyRegister) {
window.onYouTubeIframeAPIReadyRegister = [];
$.getScript('https://www.youtube.com/iframe_api');
window.onYouTubeIframeAPIReady = function () {
if (window.onYouTubeIframeAPIReadyRegister) {
for (var i = 0; i < window.onYouTubeIframeAPIReadyRegister.length; i++) {
window.onYouTubeIframeAPIReadyRegister[i]._youtubeApiReady();
}
}
window.onYouTubeIframeAPIReadyRegister.length = 0;
window.onYouTubeIframeAPIReadyRegister = undefined;
};
}
window.onYouTubeIframeAPIReadyRegister[window.onYouTubeIframeAPIReadyRegister.length] = this;
} else {
this._configurePlayer();
}
},
_poll: function (name, callback, interval, context) {
var that = this;
if (that._timers[name] !== null) {
clearTimeout(that._timers[name]);
}
that._timers[name] = setTimeout(function (context) {
return function callLater() {
if (callback.call(context)) {
that._timers[name] = setTimeout(callLater, interval);
}
};
}(context), interval);
return that._timers[name];
},
_youtubeApiReady: function () {
this._configurePlayer();
},
_configurePlayer: function () {
var vars = {
'autoplay': +this.options.autoPlay,
'wmode': 'transparent',
'controls': 0,
'rel': 0,
'showinfo': 0
};
this._onYouTubePlayerReady = proxy(this._onYouTubePlayerReady, this);
window.onYouTubePlayerReady = this._onYouTubePlayerReady;
this._onPlayerStateChangeHandler = proxy(this._onPlayerStateChange, this);
window.onPlayerStateChange = this._onPlayerStateChange;
var player = new window.YT.Player(this.wrapper.find(DOT + YTPLAYER)[0], {
height: this.wrapper.height(),
width: this.wrapper.width(),
videoId: this._getMediaId(),
playerVars: vars,
events: {
'onReady': this._onYouTubePlayerReady,
'onStateChange': this._onPlayerStateChangeHandler
}
});
},
_onYouTubePlayerReady: function (event) {
this._ytmedia = event.target;
this._ytmedia.getIframe().style.width = '100%';
this._ytmedia.getIframe().style.height = '100%';
this._youTubeVideo = true;
this._mediaDurationChangeHandler();
if (this.options.autoPlay) {
this._playStateToggle(true);
this._ytmedia.loadVideoById(this._getMediaId());
} else {
this._ytmedia.cueVideoById(this._getMediaId());
}
if (this.options.mute) {
this.mute(true);
}
this.trigger(READY);
},
_updateTitle: function () {
this.titlebar().text(this.media().title || this.media().source);
},
_onPlayerStateChange: function (event) {
if (event.data === 0) {
this._slider.value(0);
this._paused = false;
this._playStateToggle(true);
this.trigger(END);
if (this.options.autoRepeat) {
this.play();
}
} else if (event.data === 1) {
this._mediaDurationChange();
this._ytmedia.setVolume(this.volume());
if (this._sliderChangeFired) {
this._sliderChangeFired = false;
} else {
this._uiDisplay(false);
}
this.trigger(PLAY);
this._playStateToggle(true);
this._poll('progress', this._mediaTimeUpdate, 500, this);
this._paused = false;
} else if (event.data === 2) {
if (!this._paused) {
this._uiDisplay(true);
this._playStateToggle(false);
this.trigger(PAUSE);
this._paused = true;
}
}
},
_getMediaId: function () {
var result = this._currentUrl();
var regExp = /^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\?))\??v?=?([^#\&\?]*).*/;
var match = result.match(regExp);
if (match && match[7].length === 11) {
result = match[7];
}
return result;
},
_mouseClick: function () {
if (this.isPaused()) {
this.play();
} else {
this.pause();
}
},
_initializePlayer: function () {
if (!this._mouseMoveHandler) {
this._mouseMoveHandler = proxy(this._mouseMove, this);
this._mouseInHandler = proxy(this._mouseIn, this);
this._mouseOutHandler = proxy(this._mouseOut, this);
$(this.wrapper).on('mouseenter' + ns, this._mouseInHandler).on('mouseleave' + ns, this._mouseOutHandler).on('mousemove' + ns, this._mouseMoveHandler);
}
if (!this._ytmedia && this._youTubeVideo) {
this._createYoutubePlayer();
} else if (!this._media && !this._youTubeVideo) {
this._createHtmlPlayer();
}
},
_createHtmlPlayer: function () {
if (!this._videoOverlay) {
this._mouseClickHanlder = proxy(this._mouseClick, this);
this.wrapper.append('');
this._videoOverlay = this.wrapper.find('.k-mediaplayer-overlay').on('click' + ns, this._mouseClickHanlder);
}
this._mediaTimeUpdateHandler = proxy(this._mediaTimeUpdate, this);
this._mediaDurationChangeHandler = proxy(this._mediaDurationChange, this);
this._mediaEndedHandler = proxy(this._mediaEnded, this);
this._mediaCanPlayHandler = proxy(this._mediaReady, this);
this._mediaPlayHandler = proxy(this._mediaPlay, this);
this._videoOverlay.after(templates.htmlPlayer);
this._media = this.wrapper.find(DOT + MEDIA)[0];
$(this._media).css({
width: '100%',
height: '100%'
});
if (this.options.mute) {
this.mute(true);
}
this._media.ontimeupdate = this._mediaTimeUpdateHandler;
this._media.ondurationchange = this._mediaDurationChangeHandler;
this._media.oncanplay = this._mediaCanPlayHandler;
this._media.onplay = this._mediaPlayHandler;
this._media.onended = this._mediaEndedHandler;
this._media.loop = this.options.autoRepeat;
},
_mouseIn: function () {
this._uiDisplay(true);
},
_mouseOut: function () {
this._poll('mouseIdle', this._mouseIdle, 3000, this);
},
_mouseIdle: function () {
this._uiDisplay(false);
return false;
},
_mouseMove: function () {
if (!(this._titleBar.is(':animated') || this._toolBar.element.is(':animated') || this._slider.wrapper.is(':animated'))) {
this._uiDisplay(true);
}
this._poll('mouseIdle', this._mouseIdle, 3000, this);
},
_uiDisplay: function (state) {
var animationSpeed = 'slow';
var uiElements = this._titleBar.add(this._toolBar.element.parent());
if (state) {
uiElements.fadeIn(animationSpeed);
} else {
uiElements.fadeOut(animationSpeed);
if (this.options.navigatable) {
this.wrapper.focus();
}
}
},
setOptions: function (options) {
Widget.fn.setOptions.call(this, options);
},
destroy: function () {
Widget.fn.destroy.call(this);
if (!this.isPaused()) {
this.pause();
}
this.element.off(ns);
this.element.find(DOT + OVERLAY).off(ns);
this._timers = null;
this._mouseMoveHandler = null;
this._mouseOutHandler = null;
this._mouseInHandler = null;
this._mouseClickHanlder = null;
this._keyDownHandler = null;
this._fullscreenHandler = null;
this._toolbarClickHandler = null;
this._sliderDragChangeHandler = null;
this._sliderDraggingHandler = null;
this._volumeDraggingHandler = null;
this._volumeChangeHandler = null;
this._youtubeApiReadyHandler = null;
this._onYouTubePlayerReady = null;
this._onPlayerStateChangeHandler = null;
this._dropDownSelectHandler = null;
if (this._youTubeVideo) {
this._ytmedia.destroy();
} else {
this._media.ontimeupdate = this._mediaTimeUpdateHandler = null;
this._media.ondurationchange = this._mediaDurationChangeHandler = null;
this._media.oncanplay = this._mediaCanPlayHandler = null;
this._media.onplay = this._mediaPlayHandler = null;
this._media.onended = this._mediaEndedHandler = null;
this._media.src = '';
this._media.remove();
}
this._mouseMoveTimer = null;
clearTimeout(this._mouseMoveTimer);
kendo.destroy(this.element);
},
seek: function (ms) {
if (typeof ms === 'undefined') {
return 1000 * this._youTubeVideo ? this._ytmedia.getCurrentTime() : this._media ? this._media.currentTime : 0;
}
var seconds = ms / 1000;
if (this._youTubeVideo) {
if (seconds + 3 >= this._ytmedia.getDuration() | 0) {
this._ytmedia.seekTo(this._ytmedia.getDuration() - 3 | 0, true);
} else {
this._ytmedia.seekTo(seconds, true);
}
} else {
this._media.currentTime = seconds;
}
return this;
},
play: function () {
if (this._youTubeVideo) {
this._ytmedia.playVideo();
} else {
if (kendo.support.mobileOS) {
this._uiDisplay(false);
}
this._media.play();
}
this._paused = false;
this._playStateToggle(true);
return this;
},
stop: function () {
if (this._youTubeVideo && this._ytmedia) {
this._ytmedia.stopVideo();
} else if (this._media && !this._youTubeVideo) {
if (kendo.support.mobileOS) {
this._uiDisplay(true);
}
this._media.pause();
this._media.currentTime = 0;
}
this._paused = true;
this._playStateToggle(false);
return this;
},
pause: function () {
if (this._youTubeVideo) {
this._ytmedia.pauseVideo();
} else {
if (kendo.support.mobileOS) {
this._uiDisplay(true);
}
this._media.pause();
}
this._paused = true;
this._playStateToggle(false);
this.trigger(PAUSE);
return this;
},
toolbar: function () {
return this._toolBar;
},
dropdown: function () {
return this._dropDown;
},
titlebar: function () {
return this._titleBar;
},
fullScreen: function (enterFullScreen) {
if (typeof enterFullScreen === 'undefined') {
return this._isInFullScreen || false;
}
var element = this.element.get(0);
if (enterFullScreen) {
this.element.addClass('k-mediaplayer-fullscreen');
if (element.requestFullscreen) {
element.requestFullscreen();
} else if (element.webkitRequestFullscreen) {
element.webkitRequestFullscreen();
} else if (element.mozRequestFullScreen) {
element.mozRequestFullScreen();
} else if (element.msRequestFullscreen) {
element.msRequestFullscreen();
}
this._isInFullScreen = true;
} else {
if (document.cancelFullscreen) {
document.cancelFullscreen();
} else if (document.webkitCancelFullScreen) {
document.webkitCancelFullScreen();
} else if (document.mozCancelFullScreen) {
document.mozCancelFullScreen();
} else if (document.msCancelFullscreen) {
document.msCancelFullscreen();
} else if (document.exitFullscreen) {
document.exitFullscreen();
} else if (document.msExitFullscreen) {
document.msExitFullscreen();
}
this.element.removeClass('k-mediaplayer-fullscreen');
this._isInFullScreen = false;
}
this._slider.resize();
},
volume: function (value) {
if (typeof value === 'undefined') {
return typeof this._volume !== 'undefined' ? this._volume : this._volume = this.options.volume;
}
this._volume = value;
this.mute(value <= 0);
if (this._youTubeVideo) {
this._ytmedia.setVolume(this._volume);
} else {
this._media.volume = this._volume / 100;
}
this._volumeSlider.value(value);
},
mute: function (muted) {
var currentState = this._youTubeVideo ? this._ytmedia && this._ytmedia.isMuted() : this._media && this._media.muted;
if (typeof muted === 'undefined' || muted === currentState) {
return currentState;
}
if (this._youTubeVideo) {
if (muted) {
this._ytmedia.mute();
} else {
this._ytmedia.unMute();
}
} else {
this._media.muted = muted;
}
if (muted) {
this._volumeSlider.value(0);
} else {
this._volumeSlider.value(this._media && this._media.volume * 100 || this._ytmedia && this._ytmedia.getVolume());
}
this.trigger(VOLUMECHANGE);
this._changeVolumeButtonImage(this._volumeSlider.value());
},
isEnded: function () {
if (this._youTubeVideo) {
return this._ytmedia.getPlayerState() === 0;
} else {
return this._media.ended;
}
},
media: function (value) {
var dropdown = this.dropdown();
if (typeof value === 'undefined') {
return typeof this._mediaData !== 'undefined' ? this._mediaData : this._mediaData = this.options.media;
}
if (isArray(value.source)) {
dropdown.setDataSource(value.source);
dropdown.wrapper.show();
} else {
dropdown.wrapper.hide();
}
this._mediaData = value;
this._updateTitle();
this._setPlayerUrl();
},
isPaused: function () {
return this._paused;
},
isPlaying: function () {
return !this.isEnded() && !this._paused;
},
_aria: function () {
this.wrapper.attr('role', 'region');
},
_navigatable: function () {
this._fullscreenHandler = proxy(this._fullscreen, this);
$(document).on('webkitfullscreenchange mozfullscreenchange fullscreenchange' + ns, this._fullscreenHandler);
if (this.options.navigatable) {
this.wrapper.attr('tabIndex', 0);
this._keyDownHandler = proxy(this._keyDown, this);
this.wrapper.on('keydown' + ns, this._keyDownHandler);
}
},
_fullscreen: function () {
var isFullScreen = document.fullScreen || document.mozFullScreen || document.webkitIsFullScreen;
this._uiDisplay(true);
this._slider.resize();
if (!isFullScreen) {
this.wrapper.find('span[class*="k-i-fullscreen"]').removeClass(FULLSCREEN_EXIT).addClass(FULLSCREEN_ENTER);
this.fullScreen(false);
}
},
_keyDown: function (e) {
e.preventDefault();
var fsButton = this.wrapper.find('span[class*="k-i-fullscreen"]');
if (e.keyCode === keys.SPACEBAR) {
if (this.isPlaying()) {
this.pause();
} else {
this.play();
}
} else if (e.keyCode === keys.ENTER && !this._isInFullScreen) {
fsButton.removeClass(FULLSCREEN_ENTER).addClass(FULLSCREEN_EXIT);
this.fullScreen(true);
} else if (e.keyCode === 77) {
var muted = this.mute();
this.mute(!muted);
} else if (e.keyCode === keys.ESC && this._isInFullScreen) {
fsButton.removeClass(FULLSCREEN_EXIT).addClass(FULLSCREEN_ENTER);
this.fullScreen(false);
}
},
_error: function () {
},
_progress: function () {
}
});
ui.plugin(MediaPlayer);
}(window.kendo.jQuery));
return window.kendo;
}, typeof define === 'function' && define.amd ? define : function (a1, a2, a3) {
(a3 || a2)();
}));
(function (f, define) {
define('kendo.pivotgrid', [
'kendo.dom',
'kendo.data'
], f);
}(function () {
var __meta__ = {
id: 'pivotgrid',
name: 'PivotGrid',
category: 'web',
description: 'The PivotGrid widget is a data summarization tool.',
depends: [
'dom',
'data',
'data.xml',
'sortable'
],
features: [
{
id: 'pivotgrid-configurator',
name: 'Configurator',
description: 'The PivotConfigurator widget allows the user to select data slices displayed in PivotGrid',
depends: ['pivot.configurator']
},
{
id: 'pivotgrid-filtering',
name: 'Filtering',
description: 'Support for filtering',
depends: ['pivot.fieldmenu']
},
{
id: 'pivotgrid-excel-export',
name: 'Excel export',
description: 'Export pivot grid data as Excel spreadsheet',
depends: ['ooxml']
},
{
id: 'pivotgrid-pdf-export',
name: 'PDF export',
description: 'Export pivot grid data as PDF',
depends: [
'pdf',
'drawing'
]
},
{
id: 'mobile-scroller',
name: 'Mobile scroller',
description: 'Support for kinetic scrolling in mobile device',
depends: ['mobile.scroller']
}
]
};
(function ($, undefined) {
var kendo = window.kendo, ui = kendo.ui, Class = kendo.Class, Widget = ui.Widget, DataSource = kendo.data.DataSource, outerWidth = kendo._outerWidth, outerHeight = kendo._outerHeight, toString = {}.toString, identity = function (o) {
return o;
}, map = $.map, extend = $.extend, isFunction = kendo.isFunction, CHANGE = 'change', ERROR = 'error', MEASURES = 'Measures', PROGRESS = 'progress', STATERESET = 'stateReset', AUTO = 'auto', DIV = '', NS = '.kendoPivotGrid', ROW_TOTAL_KEY = '__row_total__', DATABINDING = 'dataBinding', DATABOUND = 'dataBound', EXPANDMEMBER = 'expandMember', COLLAPSEMEMBER = 'collapseMember', STATE_EXPANDED = 'k-i-collapse', STATE_COLLAPSED = 'k-i-expand', HEADER_TEMPLATE = '#: data.member.caption || data.member.name #', KPISTATUS_TEMPLATE = '', KPITREND_TEMPLATE = '', DATACELL_TEMPLATE = '#= data.dataItem ? kendo.htmlEncode(data.dataItem.fmtValue || data.dataItem.value) || " " : " " #', LAYOUT_TABLE = '' + '' + '| ' + '' + ' | ' + '' + '' + ' | ' + '
' + '
';
var AXIS_ROWS = 'rows';
var AXIS_COLUMNS = 'columns';
function normalizeMeasures(measure) {
var descriptor = typeof measure === 'string' ? [{ name: measure }] : measure;
var descriptors = toString.call(descriptor) === '[object Array]' ? descriptor : descriptor !== undefined ? [descriptor] : [];
return map(descriptors, function (d) {
if (typeof d === 'string') {
return { name: d };
}
return {
name: d.name,
type: d.type
};
});
}
function normalizeMembers(member) {
var descriptor = typeof member === 'string' ? [{
name: [member],
expand: false
}] : member;
var descriptors = toString.call(descriptor) === '[object Array]' ? descriptor : descriptor !== undefined ? [descriptor] : [];
return map(descriptors, function (d) {
if (typeof d === 'string') {
return {
name: [d],
expand: false
};
}
return {
name: toString.call(d.name) === '[object Array]' ? d.name.slice() : [d.name],
expand: d.expand
};
});
}
function normalizeName(name) {
if (name.indexOf(' ') !== -1) {
name = '["' + name + '"]';
}
return name;
}
function accumulateMembers(accumulator, rootTuple, tuple, level) {
var idx, length;
var children;
var member;
if (!tuple) {
tuple = rootTuple;
}
if (!level) {
level = 0;
}
member = tuple.members[level];
if (!member || member.measure) {
return;
}
children = member.children;
length = children.length;
if (tuple === rootTuple) {
accumulator[kendo.stringify([member.name])] = !!length;
} else if (length) {
accumulator[kendo.stringify(buildPath(tuple, level))] = true;
}
if (length) {
for (idx = 0; idx < length; idx++) {
accumulateMembers(accumulator, rootTuple, children[idx], level);
}
}
accumulateMembers(accumulator, rootTuple, tuple, level + 1);
}
function descriptorsForAxes(tuples) {
var result = {};
if (tuples.length) {
accumulateMembers(result, tuples[0]);
}
var descriptors = [];
for (var k in result) {
descriptors.push({
name: $.parseJSON(k),
expand: result[k]
});
}
return descriptors;
}
function addMissingPathMembers(members, axis) {
var tuples = axis.tuples || [];
var firstTuple = tuples[0];
if (firstTuple && members.length < firstTuple.members.length) {
var tupleMembers = firstTuple.members;
for (var idx = 0; idx < tupleMembers.length; idx++) {
if (tupleMembers[idx].measure) {
continue;
}
var found = false;
for (var j = 0; j < members.length; j++) {
if (getName(members[j]).indexOf(tupleMembers[idx].hierarchy) === 0) {
found = true;
break;
}
}
if (!found) {
members.push({
name: [tupleMembers[idx].name],
expand: false
});
}
}
}
}
function tupleToDescriptors(tuple) {
var result = [];
var members = tuple.members;
for (var idx = 0; idx < members.length; idx++) {
if (members[idx].measure) {
continue;
}
result.push({
name: [members[idx].name],
expand: members[idx].children.length > 0
});
}
return result;
}
function descriptorsForMembers(axis, members, measures) {
axis = axis || {};
addMissingPathMembers(members, axis);
if (measures.length > 1) {
members.push({
name: MEASURES,
measure: true,
children: normalizeMembers(measures)
});
}
var tupletoSearch = { members: members };
if (axis.tuples) {
var result = findExistingTuple(axis.tuples, tupletoSearch);
if (result.tuple) {
members = tupleToDescriptors(result.tuple);
}
}
return members;
}
function createAggregateGetter(m) {
var measureGetter = kendo.getter(m.field, true);
return function (aggregatorContext, state) {
return m.aggregate(measureGetter(aggregatorContext.dataItem), state, aggregatorContext);
};
}
function isNumber(val) {
return typeof val === 'number' && !isNaN(val);
}
function isDate(val) {
return val && val.getTime;
}
var functions = {
sum: function (value, state) {
var accumulator = state.accumulator;
if (!isNumber(accumulator)) {
accumulator = value;
} else if (isNumber(value)) {
accumulator += value;
}
return accumulator;
},
count: function (value, state) {
return (state.accumulator || 0) + 1;
},
average: {
aggregate: function (value, state) {
var accumulator = state.accumulator;
if (state.count === undefined) {
state.count = 0;
}
if (!isNumber(accumulator)) {
accumulator = value;
} else if (isNumber(value)) {
accumulator += value;
}
if (isNumber(value)) {
state.count++;
}
return accumulator;
},
result: function (state) {
var accumulator = state.accumulator;
if (isNumber(accumulator)) {
accumulator = accumulator / state.count;
}
return accumulator;
}
},
max: function (value, state) {
var accumulator = state.accumulator;
if (!isNumber(accumulator) && !isDate(accumulator)) {
accumulator = value;
}
if (accumulator < value && (isNumber(value) || isDate(value))) {
accumulator = value;
}
return accumulator;
},
min: function (value, state) {
var accumulator = state.accumulator;
if (!isNumber(accumulator) && !isDate(accumulator)) {
accumulator = value;
}
if (accumulator > value && (isNumber(value) || isDate(value))) {
accumulator = value;
}
return accumulator;
}
};
var PivotCubeBuilder = Class.extend({
init: function (options) {
this.options = extend({}, this.options, options);
this.dimensions = this._normalizeDescriptors('field', this.options.dimensions);
this.measures = this._normalizeDescriptors('name', this.options.measures);
},
_normalizeDescriptors: function (keyField, descriptors) {
descriptors = descriptors || {};
var fields = {};
var field;
if (toString.call(descriptors) === '[object Array]') {
for (var idx = 0, length = descriptors.length; idx < length; idx++) {
field = descriptors[idx];
if (typeof field === 'string') {
fields[field] = {};
} else if (field[keyField]) {
fields[field[keyField]] = field;
}
}
descriptors = fields;
}
return descriptors;
},
_rootTuples: function (rootNames, measureAggregators) {
var aggregatorsLength = measureAggregators.length || 1;
var dimensionsSchema = this.dimensions || [];
var root, name, parts;
var measureIdx = 0;
var idx;
var rootNamesLength = rootNames.length;
var result = [];
var keys = [];
if (rootNamesLength || measureAggregators.length) {
for (measureIdx = 0; measureIdx < aggregatorsLength; measureIdx++) {
root = { members: [] };
for (idx = 0; idx < rootNamesLength; idx++) {
name = rootNames[idx];
parts = name.split('&');
root.members[root.members.length] = {
children: [],
caption: (dimensionsSchema[name] || {}).caption || 'All',
name: name,
levelName: name,
levelNum: '0',
hasChildren: true,
parentName: parts.length > 1 ? parts[0] : undefined,
hierarchy: name
};
}
if (aggregatorsLength > 1) {
root.members[root.members.length] = {
children: [],
caption: measureAggregators[measureIdx].caption,
name: measureAggregators[measureIdx].descriptor.name,
levelName: 'MEASURES',
levelNum: '0',
hasChildren: false,
parentName: undefined,
hierarchy: 'MEASURES'
};
}
result[result.length] = root;
}
keys.push(ROW_TOTAL_KEY);
}
return {
keys: keys,
tuples: result
};
},
_expandedTuples: function (map, expanded, measureAggregators) {
var aggregatorsLength = measureAggregators.length || 1;
var dimensionsSchema = this.dimensions || [];
var measureIdx;
var tuple;
var key;
var mapItem;
var current;
var currentKeys;
var accumulator = [];
var accumulatorKeys = [];
var memberInfo;
var expandedNames;
var parts;
var name;
var idx;
for (key in map) {
mapItem = map[key];
memberInfo = this._findExpandedMember(expanded, mapItem.uniquePath);
current = accumulator[memberInfo.index] || [];
currentKeys = accumulatorKeys[memberInfo.index] || [];
expandedNames = memberInfo.member.names;
for (measureIdx = 0; measureIdx < aggregatorsLength; measureIdx++) {
tuple = { members: [] };
for (idx = 0; idx < expandedNames.length; idx++) {
if (idx === memberInfo.member.expandedIdx) {
tuple.members[tuple.members.length] = {
children: [],
caption: mapItem.value,
name: mapItem.name,
hasChildren: false,
levelNum: 1,
levelName: mapItem.parentName + mapItem.name,
parentName: mapItem.parentName,
hierarchy: mapItem.parentName + mapItem.name
};
if (measureIdx === 0) {
currentKeys.push(buildPath(tuple, idx).join(''));
}
} else {
name = expandedNames[idx];
parts = name.split('&');
tuple.members[tuple.members.length] = {
children: [],
caption: (dimensionsSchema[name] || {}).caption || 'All',
name: name,
levelName: name,
levelNum: '0',
hasChildren: true,
parentName: parts.length > 1 ? parts[0] : undefined,
hierarchy: name
};
}
}
if (aggregatorsLength > 1) {
tuple.members[tuple.members.length] = {
children: [],
caption: measureAggregators[measureIdx].caption,
name: measureAggregators[measureIdx].descriptor.name,
levelName: 'MEASURES',
levelNum: '0',
hasChildren: true,
parentName: undefined,
hierarchy: 'MEASURES'
};
}
current[current.length] = tuple;
}
accumulator[memberInfo.index] = current;
accumulatorKeys[memberInfo.index] = currentKeys;
}
return {
keys: accumulatorKeys,
tuples: accumulator
};
},
_findExpandedMember: function (members, parentName) {
for (var idx = 0; idx < members.length; idx++) {
if (members[idx].uniquePath === parentName) {
return {
member: members[idx],
index: idx
};
}
}
},
_asTuples: function (map, descriptor, measureAggregators) {
measureAggregators = measureAggregators || [];
var rootInfo = this._rootTuples(descriptor.root, measureAggregators);
var expandedInfo = this._expandedTuples(map, descriptor.expanded, measureAggregators);
return {
keys: [].concat.apply(rootInfo.keys, expandedInfo.keys),
tuples: [].concat.apply(rootInfo.tuples, expandedInfo.tuples)
};
},
_measuresInfo: function (measures, rowAxis) {
var idx = 0;
var length = measures && measures.length;
var aggregateNames = [];
var resultFuncs = {};
var formats = {};
var descriptors = this.measures || {};
var measure;
var name;
for (; idx < length; idx++) {
name = measures[idx].descriptor.name;
measure = descriptors[name] || {};
aggregateNames.push(name);
if (measure.result) {
resultFuncs[name] = measure.result;
}
if (measure.format) {
formats[name] = measure.format;
}
}
return {
names: aggregateNames,
formats: formats,
resultFuncs: resultFuncs,
rowAxis: rowAxis
};
},
_toDataArray: function (map, measuresInfo, rowKeys, columnKeys) {
var result = [];
var aggregates;
var name, i, j, k, n;
var row, column, columnKey;
var rowMeasureNamesLength = 1;
var rowMeasureNames = [];
var columnMeasureNames;
var rowLength = rowKeys.length || 1;
var columnLength = columnKeys.length || 1;
if (measuresInfo.rowAxis) {
rowMeasureNames = measuresInfo.names;
rowMeasureNamesLength = rowMeasureNames.length;
} else {
columnMeasureNames = measuresInfo.names;
}
for (i = 0; i < rowLength; i++) {
row = map[rowKeys[i] || ROW_TOTAL_KEY];
for (n = 0; n < rowMeasureNamesLength; n++) {
if (measuresInfo.rowAxis) {
columnMeasureNames = [rowMeasureNames[n]];
}
for (j = 0; j < columnLength; j++) {
columnKey = columnKeys[j] || ROW_TOTAL_KEY;
column = row.items[columnKey];
if (columnKey === ROW_TOTAL_KEY) {
aggregates = row.aggregates;
} else {
aggregates = column ? column.aggregates : {};
}
for (k = 0; k < columnMeasureNames.length; k++) {
name = columnMeasureNames[k];
this._addData(result, aggregates[name], measuresInfo.formats[name], measuresInfo.resultFuncs[name]);
}
}
}
}
return result;
},
_addData: function (result, value, format, resultFunc) {
var fmtValue = '';
var ordinal;
if (value) {
value = resultFunc ? resultFunc(value) : value.accumulator;
fmtValue = format ? kendo.format(format, value) : value;
}
ordinal = result.length;
result[ordinal] = {
ordinal: ordinal,
value: value || '',
fmtValue: fmtValue
};
},
_matchDescriptors: function (dataItem, descriptor, getters) {
var parts;
var parentField;
var expectedValue;
var names = descriptor.names;
var idx = descriptor.expandedIdx;
var value;
while (idx > 0) {
parts = names[--idx].split('&');
if (parts.length > 1) {
parentField = parts[0];
expectedValue = parts[1];
value = getters[parentField](dataItem);
value = value !== undefined && value !== null ? value.toString() : value;
if (value != expectedValue) {
return false;
}
}
}
return true;
},
_calculateAggregate: function (measureAggregators, aggregatorContext, totalItem) {
var result = {};
var state;
var name;
for (var measureIdx = 0; measureIdx < measureAggregators.length; measureIdx++) {
name = measureAggregators[measureIdx].descriptor.name;
state = totalItem.aggregates[name] || {};
state.accumulator = measureAggregators[measureIdx].aggregator(aggregatorContext, state);
result[name] = state;
}
return result;
},
_processColumns: function (measureAggregators, descriptors, getters, columns, aggregatorContext, rowTotal, state, updateColumn) {
var value;
var descriptor;
var column;
var totalItem;
var key, name, parentName, path;
var dataItem = aggregatorContext.dataItem;
var idx = 0;
for (; idx < descriptors.length; idx++) {
descriptor = descriptors[idx];
if (!this._matchDescriptors(dataItem, descriptor, getters)) {
continue;
}
path = descriptor.names.slice(0, descriptor.expandedIdx).join('');
name = descriptor.names[descriptor.expandedIdx];
value = getters[name](dataItem);
value = value !== undefined && value !== null ? value.toString() : value;
parentName = name;
name = name + '&' + value;
key = path + name;
column = columns[key] || {
index: state.columnIndex,
parentName: parentName,
name: name,
uniquePath: path + parentName,
value: value
};
totalItem = rowTotal.items[key] || { aggregates: {} };
rowTotal.items[key] = {
index: column.index,
aggregates: this._calculateAggregate(measureAggregators, aggregatorContext, totalItem)
};
if (updateColumn) {
if (!columns[key]) {
state.columnIndex++;
}
columns[key] = column;
}
}
},
_measureAggregators: function (options) {
var measureDescriptors = options.measures || [];
var measures = this.measures || {};
var aggregators = [];
var descriptor, measure, idx, length;
var defaultAggregate, aggregate;
if (measureDescriptors.length) {
for (idx = 0, length = measureDescriptors.length; idx < length; idx++) {
descriptor = measureDescriptors[idx];
measure = measures[descriptor.name];
defaultAggregate = null;
if (measure) {
aggregate = measure.aggregate;
if (typeof aggregate === 'string') {
defaultAggregate = functions[aggregate.toLowerCase()];
if (!defaultAggregate) {
throw new Error('There is no such aggregate function');
}
measure.aggregate = defaultAggregate.aggregate || defaultAggregate;
measure.result = defaultAggregate.result;
}
aggregators.push({
descriptor: descriptor,
caption: measure.caption,
result: measure.result,
aggregator: createAggregateGetter(measure)
});
}
}
} else {
aggregators.push({
descriptor: { name: 'default' },
caption: 'default',
aggregator: function () {
return 1;
}
});
}
return aggregators;
},
_buildGetters: function (names) {
var result = {};
var parts;
var name;
for (var idx = 0; idx < names.length; idx++) {
name = names[idx];
parts = name.split('&');
if (parts.length > 1) {
result[parts[0]] = kendo.getter(parts[0], true);
} else {
result[name] = kendo.getter(normalizeName(name), true);
}
}
return result;
},
_parseDescriptors: function (descriptors) {
var parsedDescriptors = parseDescriptors(descriptors);
var rootNames = getRootNames(parsedDescriptors.root);
var expanded = parsedDescriptors.expanded;
var result = [];
for (var idx = 0; idx < expanded.length; idx++) {
result.push(mapNames(expanded[idx].name, rootNames));
}
return {
root: rootNames,
expanded: result
};
},
_filter: function (data, filter) {
if (!filter) {
return data;
}
var expr;
var idx = 0;
var filters = filter.filters;
for (; idx < filters.length; idx++) {
expr = filters[idx];
if (expr.operator === 'in') {
filters[idx] = this._normalizeFilter(expr);
}
}
return new kendo.data.Query(data).filter(filter).data;
},
_normalizeFilter: function (filter) {
var value = filter.value.split(',');
var result = [];
if (!value.length) {
return value;
}
for (var idx = 0; idx < value.length; idx++) {
result.push({
field: filter.field,
operator: 'eq',
value: value[idx]
});
}
return {
logic: 'or',
filters: result
};
},
process: function (data, options) {
data = data || [];
options = options || {};
data = this._filter(data, options.filter);
var measures = options.measures || [];
var measuresRowAxis = options.measuresAxis === 'rows';
var columnDescriptors = options.columns || [];
var rowDescriptors = options.rows || [];
if (!columnDescriptors.length && rowDescriptors.length && (!measures.length || measures.length && measuresRowAxis)) {
columnDescriptors = rowDescriptors;
rowDescriptors = [];
measuresRowAxis = false;
}
if (!columnDescriptors.length && !rowDescriptors.length) {
measuresRowAxis = false;
}
if (!columnDescriptors.length && measures.length) {
columnDescriptors = normalizeMembers(options.measures);
}
columnDescriptors = this._parseDescriptors(columnDescriptors);
rowDescriptors = this._parseDescriptors(rowDescriptors);
var aggregatedData = {};
var columns = {};
var rows = {};
var rowValue;
var state = { columnIndex: 0 };
var measureAggregators = this._measureAggregators(options);
var columnGetters = this._buildGetters(columnDescriptors.root);
var rowGetters = this._buildGetters(rowDescriptors.root);
var processed = false;
var expandedColumns = columnDescriptors.expanded;
var expandedRows = rowDescriptors.expanded;
var dataItem;
var aggregatorContext;
var hasExpandedRows = expandedRows.length !== 0;
var rowIdx, rowDescriptor, rowName, rowTotal;
var key, path, parentName, value;
var columnsInfo, rowsInfo;
var length = data.length;
var idx = 0;
if (columnDescriptors.root.length || rowDescriptors.root.length) {
processed = true;
for (idx = 0; idx < length; idx++) {
dataItem = data[idx];
aggregatorContext = {
dataItem: dataItem,
index: idx
};
rowTotal = aggregatedData[ROW_TOTAL_KEY] || {
items: {},
aggregates: {}
};
this._processColumns(measureAggregators, expandedColumns, columnGetters, columns, aggregatorContext, rowTotal, state, !hasExpandedRows);
rowTotal.aggregates = this._calculateAggregate(measureAggregators, aggregatorContext, rowTotal);
aggregatedData[ROW_TOTAL_KEY] = rowTotal;
for (rowIdx = 0; rowIdx < expandedRows.length; rowIdx++) {
rowDescriptor = expandedRows[rowIdx];
if (!this._matchDescriptors(dataItem, rowDescriptor, rowGetters)) {
this._processColumns(measureAggregators, expandedColumns, columnGetters, columns, aggregatorContext, {
items: {},
aggregates: {}
}, state, true);
continue;
}
path = rowDescriptor.names.slice(0, rowDescriptor.expandedIdx).join('');
rowName = rowDescriptor.names[rowDescriptor.expandedIdx];
parentName = rowName;
rowValue = rowGetters[rowName](dataItem);
rowValue = rowValue !== undefined ? rowValue.toString() : rowValue;
rowName = rowName + '&' + rowValue;
key = path + rowName;
rows[key] = {
uniquePath: path + parentName,
parentName: parentName,
name: rowName,
value: rowValue
};
value = aggregatedData[key] || {
items: {},
aggregates: {}
};
this._processColumns(measureAggregators, expandedColumns, columnGetters, columns, aggregatorContext, value, state, true);
value.aggregates = this._calculateAggregate(measureAggregators, aggregatorContext, value);
aggregatedData[key] = value;
}
}
}
if (processed && length) {
if (measureAggregators.length > 1 && (!options.columns || !options.columns.length)) {
columnDescriptors = {
root: [],
expanded: []
};
}
columnsInfo = this._asTuples(columns, columnDescriptors, measuresRowAxis ? [] : measureAggregators);
rowsInfo = this._asTuples(rows, rowDescriptors, measuresRowAxis ? measureAggregators : []);
columns = columnsInfo.tuples;
rows = rowsInfo.tuples;
aggregatedData = this._toDataArray(aggregatedData, this._measuresInfo(measureAggregators, measuresRowAxis), rowsInfo.keys, columnsInfo.keys);
} else {
aggregatedData = columns = rows = [];
}
return {
axes: {
columns: { tuples: columns },
rows: { tuples: rows }
},
data: aggregatedData
};
}
});
var PivotTransport = Class.extend({
init: function (options, transport) {
this.transport = transport;
this.options = transport.options || {};
if (!this.transport.discover) {
if (isFunction(options.discover)) {
this.discover = options.discover;
}
}
},
read: function (options) {
return this.transport.read(options);
},
update: function (options) {
return this.transport.update(options);
},
create: function (options) {
return this.transport.create(options);
},
destroy: function (options) {
return this.transport.destroy(options);
},
discover: function (options) {
if (this.transport.discover) {
return this.transport.discover(options);
}
options.success({});
},
catalog: function (val) {
var options = this.options || {};
if (val === undefined) {
return (options.connection || {}).catalog;
}
var connection = options.connection || {};
connection.catalog = val;
this.options.connection = connection;
$.extend(this.transport.options, { connection: connection });
},
cube: function (val) {
var options = this.options || {};
if (val === undefined) {
return (options.connection || {}).cube;
}
var connection = options.connection || {};
connection.cube = val;
this.options.connection = connection;
extend(true, this.transport.options, { connection: connection });
}
});
var PivotDataSource = DataSource.extend({
init: function (options) {
var cube = ((options || {}).schema || {}).cube;
var measuresAxis = 'columns';
var measures;
var schema = {
axes: identity,
cubes: identity,
catalogs: identity,
measures: identity,
dimensions: identity,
hierarchies: identity,
levels: identity,
members: identity
};
if (cube) {
schema = $.extend(schema, this._cubeSchema(cube));
this.cubeBuilder = new PivotCubeBuilder(cube);
}
DataSource.fn.init.call(this, extend(true, {}, { schema: schema }, options));
this.transport = new PivotTransport(this.options.transport || {}, this.transport);
this._columns = normalizeMembers(this.options.columns);
this._rows = normalizeMembers(this.options.rows);
measures = this.options.measures || [];
if (toString.call(measures) === '[object Object]') {
measuresAxis = measures.axis || 'columns';
measures = measures.values || [];
}
this._measures = normalizeMeasures(measures);
this._measuresAxis = measuresAxis;
this._skipNormalize = 0;
this._axes = {};
},
_cubeSchema: function (cube) {
return {
dimensions: function () {
var result = [];
var dimensions = cube.dimensions;
for (var key in dimensions) {
result.push({
name: key,
caption: dimensions[key].caption || key,
uniqueName: key,
defaultHierarchy: key,
type: 1
});
}
if (cube.measures) {
result.push({
name: MEASURES,
caption: MEASURES,
uniqueName: MEASURES,
type: 2
});
}
return result;
},
hierarchies: function () {
return [];
},
measures: function () {
var result = [];
var measures = cube.measures;
for (var key in measures) {
result.push({
name: key,
caption: key,
uniqueName: key,
aggregator: key
});
}
return result;
},
members: $.proxy(function (response, restrictions) {
var name = restrictions.levelUniqueName || restrictions.memberUniqueName;
var schemaData = this.options.schema.data;
var dataGetter = isFunction(schemaData) ? schemaData : kendo.getter(schemaData, true);
var data = this.options.data && dataGetter(this.options.data) || this._rawData || [];
var result = [];
var getter;
var value;
var idx = 0;
var distinct = {};
if (name) {
name = name.split('.')[0];
}
if (!restrictions.treeOp) {
result.push({
caption: cube.dimensions[name].caption || name,
childrenCardinality: '1',
dimensionUniqueName: name,
hierarchyUniqueName: name,
levelUniqueName: name,
name: name,
uniqueName: name
});
return result;
}
getter = kendo.getter(normalizeName(name), true);
for (; idx < data.length; idx++) {
value = getter(data[idx]);
if ((value || value === 0) && !distinct[value]) {
distinct[value] = true;
result.push({
caption: value,
childrenCardinality: '0',
dimensionUniqueName: name,
hierarchyUniqueName: name,
levelUniqueName: name,
name: value,
uniqueName: value
});
}
}
return result;
}, this)
};
},
options: {
serverSorting: true,
serverPaging: true,
serverFiltering: true,
serverGrouping: true,
serverAggregates: true
},
catalog: function (val) {
if (val === undefined) {
return this.transport.catalog();
}
this.transport.catalog(val);
this._mergeState({});
this._axes = {};
this.data([]);
},
cube: function (val) {
if (val === undefined) {
return this.transport.cube();
}
this.transport.cube(val);
this._axes = {};
this._mergeState({});
this.data([]);
},
axes: function () {
return this._axes;
},
columns: function (val) {
if (val === undefined) {
return this._columns;
}
this._skipNormalize += 1;
this._clearAxesData = true;
this._columns = normalizeMembers(val);
this.query({
columns: val,
rows: this.rowsAxisDescriptors(),
measures: this.measures(),
sort: this.sort(),
filter: this.filter()
});
},
rows: function (val) {
if (val === undefined) {
return this._rows;
}
this._skipNormalize += 1;
this._clearAxesData = true;
this._rows = normalizeMembers(val);
this.query({
columns: this.columnsAxisDescriptors(),
rows: val,
measures: this.measures(),
sort: this.sort(),
filter: this.filter()
});
},
measures: function (val) {
if (val === undefined) {
return this._measures;
}
this._skipNormalize += 1;
this._clearAxesData = true;
this.query({
columns: this.columnsAxisDescriptors(),
rows: this.rowsAxisDescriptors(),
measures: normalizeMeasures(val),
sort: this.sort(),
filter: this.filter()
});
},
measuresAxis: function () {
return this._measuresAxis || 'columns';
},
_expandPath: function (path, axis) {
var origin = axis === 'columns' ? 'columns' : 'rows';
var other = axis === 'columns' ? 'rows' : 'columns';
var members = normalizeMembers(path);
var memberToExpand = getName(members[members.length - 1]);
this._lastExpanded = origin;
members = descriptorsForMembers(this.axes()[origin], members, this.measures());
for (var idx = 0; idx < members.length; idx++) {
var memberName = getName(members[idx]);
if (memberName === memberToExpand) {
if (members[idx].expand) {
return;
}
members[idx].expand = true;
} else {
members[idx].expand = false;
}
}
var descriptors = {};
descriptors[origin] = members;
descriptors[other] = this._descriptorsForAxis(other);
this._query(descriptors);
},
_descriptorsForAxis: function (axis) {
var axes = this.axes();
var descriptors = this[axis]() || [];
if (axes && axes[axis] && axes[axis].tuples && axes[axis].tuples[0]) {
descriptors = descriptorsForAxes(axes[axis].tuples || []);
}
return descriptors;
},
columnsAxisDescriptors: function () {
return this._descriptorsForAxis('columns');
},
rowsAxisDescriptors: function () {
return this._descriptorsForAxis('rows');
},
_process: function (data, e) {
this._view = data;
e = e || {};
e.items = e.items || this._view;
this.trigger(CHANGE, e);
},
_query: function (options) {
var that = this;
if (!options) {
this._skipNormalize += 1;
this._clearAxesData = true;
}
return that.query(extend({}, {
page: that.page(),
pageSize: that.pageSize(),
sort: that.sort(),
filter: that.filter(),
group: that.group(),
aggregate: that.aggregate(),
columns: this.columnsAxisDescriptors(),
rows: this.rowsAxisDescriptors(),
measures: this.measures()
}, options));
},
query: function (options) {
var state = this._mergeState(options);
if (this._data.length && this.cubeBuilder) {
this._params(state);
this._updateLocalData(this._pristineData);
return $.Deferred().resolve().promise();
}
return this.read(state);
},
_mergeState: function (options) {
options = DataSource.fn._mergeState.call(this, options);
if (options !== undefined) {
this._measures = normalizeMeasures(options.measures);
if (options.columns) {
options.columns = normalizeMembers(options.columns);
} else if (!options.columns) {
this._columns = [];
}
if (options.rows) {
options.rows = normalizeMembers(options.rows);
} else if (!options.rows) {
this._rows = [];
}
}
return options;
},
filter: function (val) {
if (val === undefined) {
return this._filter;
}
this._skipNormalize += 1;
this._clearAxesData = true;
this._query({
filter: val,
page: 1
});
},
expandColumn: function (path) {
this._expandPath(path, 'columns');
},
expandRow: function (path) {
this._expandPath(path, 'rows');
},
success: function (data) {
var originalData;
if (this.cubeBuilder) {
originalData = (this.reader.data(data) || []).slice(0);
}
DataSource.fn.success.call(this, data);
if (originalData) {
this._pristineData = originalData;
}
},
_processResult: function (data, axes) {
if (this.cubeBuilder) {
var processedData = this.cubeBuilder.process(data, this._requestData);
data = processedData.data;
axes = processedData.axes;
}
var columnIndexes, rowIndexes;
var tuples, resultAxis, measures, axisToSkip;
var columnDescriptors = this.columns();
var rowDescriptors = this.rows();
var hasColumnTuples = axes.columns && axes.columns.tuples;
if (!columnDescriptors.length && rowDescriptors.length && hasColumnTuples && (this._rowMeasures().length || !this.measures().length)) {
axes = {
columns: {},
rows: axes.columns
};
}
if (!columnDescriptors.length && !rowDescriptors.length && this.measuresAxis() === 'rows' && hasColumnTuples) {
axes = {
columns: {},
rows: axes.columns
};
}
this._axes = {
columns: normalizeAxis(this._axes.columns),
rows: normalizeAxis(this._axes.rows)
};
axes = {
columns: normalizeAxis(axes.columns),
rows: normalizeAxis(axes.rows)
};
columnIndexes = this._normalizeTuples(axes.columns.tuples, this._axes.columns.tuples, columnDescriptors, this._columnMeasures());
rowIndexes = this._normalizeTuples(axes.rows.tuples, this._axes.rows.tuples, rowDescriptors, this._rowMeasures());
if (this._skipNormalize > 0) {
this._skipNormalize -= 1;
}
if (!this.cubeBuilder) {
data = this._normalizeData({
columnsLength: axes.columns.tuples.length,
rowsLength: axes.rows.tuples.length,
columnIndexes: columnIndexes,
rowIndexes: rowIndexes,
data: data
});
}
if (this._lastExpanded == 'rows') {
tuples = axes.columns.tuples;
measures = this._columnMeasures();
resultAxis = validateAxis(axes.columns, this._axes.columns, measures);
if (resultAxis) {
axisToSkip = 'columns';
axes.columns = resultAxis;
adjustDataByColumn(tuples, resultAxis.tuples, axes.rows.tuples.length, measures, data);
if (!this.cubeBuilder) {
data = this._normalizeData({
columnsLength: membersCount(axes.columns.tuples, measures),
rowsLength: axes.rows.tuples.length,
data: data
});
}
}
} else if (this._lastExpanded == 'columns') {
tuples = axes.rows.tuples;
measures = this._rowMeasures();
resultAxis = validateAxis(axes.rows, this._axes.rows, measures);
if (resultAxis) {
axisToSkip = 'rows';
axes.rows = resultAxis;
adjustDataByRow(tuples, resultAxis.tuples, axes.columns.tuples.length, measures, data);
if (!this.cubeBuilder) {
data = this._normalizeData({
columnsLength: membersCount(axes.rows.tuples, measures),
rowsLength: axes.columns.tuples.length,
data: data
});
}
}
}
this._lastExpanded = null;
var result = this._mergeAxes(axes, data, axisToSkip);
this._axes = result.axes;
return result.data;
},
_readData: function (data) {
var axes = this.reader.axes(data);
var newData = this.reader.data(data);
if (this.cubeBuilder) {
this._rawData = newData;
}
return this._processResult(newData, axes);
},
_createTuple: function (tuple, measure, buildRoot) {
var members = tuple.members;
var length = members.length;
var root = { members: [] };
var levelName, levelNum;
var name, parentName;
var hasChildren;
var hierarchy;
var caption;
var member;
var idx = 0;
if (measure) {
length -= 1;
}
for (; idx < length; idx++) {
member = members[idx];
levelNum = Number(member.levelNum);
name = member.name;
parentName = member.parentName;
caption = member.caption || name;
hasChildren = member.hasChildren;
hierarchy = member.hierarchy;
levelName = member.levelName;
if (buildRoot) {
caption = 'All';
if (levelNum === 0) {
parentName = member.name;
} else {
levelNum -= 1;
}
hasChildren = true;
name = hierarchy = levelName = parentName;
}
root.members.push({
name: name,
children: [],
caption: caption,
levelName: levelName,
levelNum: levelNum.toString(),
hasChildren: hasChildren,
hierarchy: hierarchy,
parentName: !buildRoot ? parentName : ''
});
}
if (measure) {
root.members.push({
name: measure.name,
children: []
});
}
return root;
},
_hasRoot: function (target, source, descriptors) {
if (source.length) {
return findExistingTuple(source, target).tuple;
}
var members = target.members;
var member;
var descriptor;
var isRoot = true;
var levelNum;
for (var idx = 0, length = members.length; idx < length; idx++) {
member = members[idx];
levelNum = Number(member.levelNum) || 0;
descriptor = descriptors[idx];
if (!(levelNum === 0 || descriptor && member.name === getName(descriptor))) {
isRoot = false;
break;
}
}
return isRoot;
},
_mergeAxes: function (sourceAxes, data, axisToSkip) {
var columnMeasures = this._columnMeasures();
var rowMeasures = this._rowMeasures();
var axes = this.axes();
var startIndex, tuples;
var oldRowsLength = membersCount(axes.rows.tuples, rowMeasures);
var newRowsLength = sourceAxes.rows.tuples.length;
var oldColumnsLength = membersCount(axes.columns.tuples, columnMeasures);
var newColumnsLength = sourceAxes.columns.tuples.length;
if (axisToSkip == 'columns') {
newColumnsLength = oldColumnsLength;
tuples = sourceAxes.columns.tuples;
} else {
tuples = parseSource(sourceAxes.columns.tuples, columnMeasures);
data = prepareDataOnColumns(tuples, data);
}
var mergedColumns = mergeTuples(axes.columns.tuples, tuples, columnMeasures);
if (axisToSkip == 'rows') {
newRowsLength = membersCount(sourceAxes.rows.tuples, rowMeasures);
tuples = sourceAxes.rows.tuples;
} else {
tuples = parseSource(sourceAxes.rows.tuples, rowMeasures);
data = prepareDataOnRows(tuples, data);
}
var mergedRows = mergeTuples(axes.rows.tuples, tuples, rowMeasures);
axes.columns.tuples = mergedColumns.tuples;
axes.rows.tuples = mergedRows.tuples;
if (oldColumnsLength !== membersCount(axes.columns.tuples, columnMeasures)) {
startIndex = mergedColumns.index + findDataIndex(mergedColumns.parsedRoot, mergedColumns.memberIndex, columnMeasures);
var offset = oldColumnsLength + newColumnsLength;
data = this._mergeColumnData(data, startIndex, newRowsLength, newColumnsLength, offset);
} else if (oldRowsLength !== membersCount(axes.rows.tuples, rowMeasures)) {
startIndex = mergedRows.index + findDataIndex(mergedRows.parsedRoot, mergedRows.memberIndex, rowMeasures);
data = this._mergeRowData(data, startIndex, newRowsLength, newColumnsLength);
}
if (axes.columns.tuples.length === 0 && axes.rows.tuples.length === 0) {
data = [];
}
return {
axes: axes,
data: data
};
},
_mergeColumnData: function (newData, columnIndex, rowsLength, columnsLength, offset) {
var data = this.data().toJSON();
var rowIndex, index, drop = 0, toAdd;
var columnMeasures = Math.max(this._columnMeasures().length, 1);
rowsLength = Math.max(rowsLength, 1);
if (data.length > 0) {
drop = columnMeasures;
offset -= columnMeasures;
}
for (rowIndex = 0; rowIndex < rowsLength; rowIndex++) {
index = columnIndex + rowIndex * offset;
toAdd = newData.splice(0, columnsLength);
toAdd.splice(0, drop);
[].splice.apply(data, [
index,
0
].concat(toAdd));
}
return data;
},
_mergeRowData: function (newData, rowIndex, rowsLength, columnsLength) {
var data = this.data().toJSON();
var idx, dataIndex, toAdd;
var rowMeasures = Math.max(this._rowMeasures().length, 1);
columnsLength = Math.max(columnsLength, 1);
if (data.length > 0) {
rowsLength -= rowMeasures;
newData.splice(0, columnsLength * rowMeasures);
}
for (idx = 0; idx < rowsLength; idx++) {
toAdd = newData.splice(0, columnsLength);
dataIndex = rowIndex * columnsLength + idx * columnsLength;
[].splice.apply(data, [
dataIndex,
0
].concat(toAdd));
}
return data;
},
_columnMeasures: function () {
var measures = this.measures();
var columnMeasures = [];
if (this.measuresAxis() === 'columns') {
if (this.columns().length === 0) {
columnMeasures = measures;
} else if (measures.length > 1) {
columnMeasures = measures;
}
}
return columnMeasures;
},
_rowMeasures: function () {
var measures = this.measures();
var rowMeasures = [];
if (this.measuresAxis() === 'rows') {
if (this.rows().length === 0) {
rowMeasures = measures;
} else if (measures.length > 1) {
rowMeasures = measures;
}
}
return rowMeasures;
},
_updateLocalData: function (data, state) {
if (this.cubeBuilder) {
if (state) {
this._requestData = state;
}
data = this._processResult(data);
}
this._data = this._observe(data);
this._ranges = [];
this._addRange(this._data);
this._total = this._data.length;
this._pristineTotal = this._total;
this._process(this._data);
},
data: function (value) {
var that = this;
if (value !== undefined) {
this._pristineData = value.slice(0);
this._updateLocalData(value, {
columns: this.columns(),
rows: this.rows(),
measures: this.measures()
});
} else {
return that._data;
}
},
_normalizeTuples: function (tuples, source, descriptors, measures) {
var length = measures.length || 1;
var idx = 0;
var roots = [];
var indexes = {};
var measureIdx = 0;
var tuple, memberIdx, last;
if (!tuples.length) {
return;
}
if (this._skipNormalize <= 0 && !this._hasRoot(tuples[0], source, descriptors)) {
this._skipNormalize = 0;
for (; idx < length; idx++) {
roots.push(this._createTuple(tuples[0], measures[idx], true));
indexes[idx] = idx;
}
tuples.splice.apply(tuples, [
0,
tuples.length
].concat(roots).concat(tuples));
idx = length;
}
if (measures.length) {
last = tuple = tuples[idx];
memberIdx = tuple.members.length - 1;
while (tuple) {
if (measureIdx >= length) {
measureIdx = 0;
}
if (tuple.members[memberIdx].name !== measures[measureIdx].name) {
tuples.splice(idx, 0, this._createTuple(tuple, measures[measureIdx]));
indexes[idx] = idx;
}
idx += 1;
measureIdx += 1;
tuple = tuples[idx];
if (length > measureIdx && (!tuple || tupleName(last, memberIdx - 1) !== tupleName(tuple, memberIdx - 1))) {
for (; measureIdx < length; measureIdx++) {
tuples.splice(idx, 0, this._createTuple(last, measures[measureIdx]));
indexes[idx] = idx;
idx += 1;
}
tuple = tuples[idx];
}
last = tuple;
}
}
return indexes;
},
_addMissingDataItems: function (result, metadata) {
while (metadata.rowIndexes[parseInt(result.length / metadata.columnsLength, 10)] !== undefined) {
for (var idx = 0; idx < metadata.columnsLength; idx++) {
result = addEmptyDataItem(result);
}
}
while (metadata.columnIndexes[result.length % metadata.columnsLength] !== undefined) {
result = addEmptyDataItem(result);
}
return result;
},
_normalizeOrdinals: function (result, dataItem, metadata) {
var lastOrdinal = metadata.lastOrdinal;
if (!dataItem) {
return addEmptyDataItem(result);
}
if (dataItem.ordinal - lastOrdinal > 1) {
lastOrdinal += 1;
while (lastOrdinal < dataItem.ordinal && result.length < metadata.length) {
result = this._addMissingDataItems(addEmptyDataItem(result), metadata);
lastOrdinal += 1;
}
}
dataItem.ordinal = result.length;
result[result.length] = dataItem;
return result;
},
_normalizeData: function (options) {
var data = options.data;
var dataIdx = 0;
var dataItem;
var result = [];
var lastOrdinal;
var length;
options.lastOrdinal = 0;
options.columnIndexes = options.columnIndexes || {};
options.rowIndexes = options.rowIndexes || {};
options.columnsLength = options.columnsLength || 1;
options.rowsLength = options.rowsLength || 1;
options.length = options.columnsLength * options.rowsLength;
length = options.length;
if (data.length === length) {
return data;
}
while (result.length < length) {
dataItem = data[dataIdx++];
if (dataItem) {
lastOrdinal = dataItem.ordinal;
}
result = this._normalizeOrdinals(this._addMissingDataItems(result, options), dataItem, options);
options.lastOrdinal = lastOrdinal;
}
return result;
},
discover: function (options, converter) {
var that = this, transport = that.transport;
return $.Deferred(function (deferred) {
transport.discover(extend({
success: function (response) {
response = that.reader.parse(response);
if (that._handleCustomErrors(response)) {
return;
}
if (converter) {
response = converter(response);
}
deferred.resolve(response);
},
error: function (response, status, error) {
deferred.reject(response);
that.error(response, status, error);
}
}, options));
}).promise().done(function () {
that.trigger('schemaChange');
});
},
schemaMeasures: function () {
var that = this;
return that.discover({
data: {
command: 'schemaMeasures',
restrictions: {
catalogName: that.transport.catalog(),
cubeName: that.transport.cube()
}
}
}, function (response) {
return that.reader.measures(response);
});
},
schemaKPIs: function () {
var that = this;
return that.discover({
data: {
command: 'schemaKPIs',
restrictions: {
catalogName: that.transport.catalog(),
cubeName: that.transport.cube()
}
}
}, function (response) {
return that.reader.kpis(response);
});
},
schemaDimensions: function () {
var that = this;
return that.discover({
data: {
command: 'schemaDimensions',
restrictions: {
catalogName: that.transport.catalog(),
cubeName: that.transport.cube()
}
}
}, function (response) {
return that.reader.dimensions(response);
});
},
schemaHierarchies: function (dimensionName) {
var that = this;
return that.discover({
data: {
command: 'schemaHierarchies',
restrictions: {
catalogName: that.transport.catalog(),
cubeName: that.transport.cube(),
dimensionUniqueName: dimensionName
}
}
}, function (response) {
return that.reader.hierarchies(response);
});
},
schemaLevels: function (hierarchyName) {
var that = this;
return that.discover({
data: {
command: 'schemaLevels',
restrictions: {
catalogName: that.transport.catalog(),
cubeName: that.transport.cube(),
hierarchyUniqueName: hierarchyName
}
}
}, function (response) {
return that.reader.levels(response);
});
},
schemaCubes: function () {
var that = this;
return that.discover({
data: {
command: 'schemaCubes',
restrictions: { catalogName: that.transport.catalog() }
}
}, function (response) {
return that.reader.cubes(response);
});
},
schemaCatalogs: function () {
var that = this;
return that.discover({ data: { command: 'schemaCatalogs' } }, function (response) {
return that.reader.catalogs(response);
});
},
schemaMembers: function (restrictions) {
var that = this;
var success = function (restrictions) {
return function (response) {
return that.reader.members(response, restrictions);
};
}(restrictions);
return that.discover({
data: {
command: 'schemaMembers',
restrictions: extend({
catalogName: that.transport.catalog(),
cubeName: that.transport.cube()
}, restrictions)
}
}, success);
},
_params: function (data) {
if (this._clearAxesData) {
this._axes = {};
this._data = this._observe([]);
this._clearAxesData = false;
this.trigger(STATERESET);
}
var options = DataSource.fn._params.call(this, data);
options = extend({
measures: this.measures(),
measuresAxis: this.measuresAxis(),
columns: this.columns(),
rows: this.rows()
}, options);
if (this.cubeBuilder) {
this._requestData = options;
}
return options;
}
});
function addEmptyDataItem(result) {
result[result.length] = {
value: '',
fmtValue: '',
ordinal: result.length
};
return result;
}
function validateAxis(newAxis, axis, measures) {
if (newAxis.tuples.length < membersCount(axis.tuples, measures)) {
return axis;
}
return;
}
function adjustDataByColumn(sourceTuples, targetTuples, rowsLength, measures, data) {
var columnIdx, rowIdx, dataIdx;
var columnsLength = sourceTuples.length;
var targetColumnsLength = membersCount(targetTuples, measures);
var measuresLength = measures.length || 1;
for (rowIdx = 0; rowIdx < rowsLength; rowIdx++) {
for (columnIdx = 0; columnIdx < columnsLength; columnIdx++) {
dataIdx = tupleIndex(sourceTuples[columnIdx], targetTuples) * measuresLength;
dataIdx += columnIdx % measuresLength;
data[rowIdx * columnsLength + columnIdx].ordinal = rowIdx * targetColumnsLength + dataIdx;
}
}
}
function adjustDataByRow(sourceTuples, targetTuples, columnsLength, measures, data) {
var columnIdx, rowIdx, dataIdx;
var rowsLength = sourceTuples.length;
var measuresLength = measures.length || 1;
for (rowIdx = 0; rowIdx < rowsLength; rowIdx++) {
dataIdx = tupleIndex(sourceTuples[rowIdx], targetTuples);
dataIdx *= measuresLength;
dataIdx += rowIdx % measuresLength;
for (columnIdx = 0; columnIdx < columnsLength; columnIdx++) {
data[rowIdx * columnsLength + columnIdx].ordinal = dataIdx * columnsLength + columnIdx;
}
}
}
function tupleIndex(tuple, collection) {
return findExistingTuple(collection, tuple).index;
}
function membersCount(tuples, measures) {
if (!tuples.length) {
return 0;
}
var queue = tuples.slice();
var current = queue.shift();
var result = 1;
while (current) {
if (current.members) {
[].push.apply(queue, current.members);
} else if (current.children) {
if (!current.measure) {
result += current.children.length;
}
[].push.apply(queue, current.children);
}
current = queue.shift();
}
if (measures.length) {
result = result * measures.length;
}
return result;
}
function normalizeAxis(axis) {
if (!axis) {
axis = { tuples: [] };
}
if (!axis.tuples) {
axis.tuples = [];
}
return axis;
}
function findDataIndex(tuple, memberIndex, measures) {
if (!tuple) {
return 0;
}
var measuresLength = Math.max(measures.length, 1);
var tuples = tuple.members.slice(0, memberIndex);
var current = tuples.shift();
var counter = measuresLength;
while (current) {
if (current.name === MEASURES) {
counter += measuresLength - 1;
} else if (current.children) {
[].push.apply(tuples, current.children);
} else {
counter++;
[].push.apply(tuples, current.members);
}
current = tuples.shift();
}
return counter;
}
function mergeTuples(target, source, measures) {
if (!source[0]) {
return {
parsedRoot: null,
tuples: target,
memberIndex: 0,
index: 0
};
}
var result = findExistingTuple(target, source[0]);
if (!result.tuple) {
return {
parsedRoot: null,
tuples: source,
memberIndex: 0,
index: 0
};
}
var targetMembers = result.tuple.members;
var sourceMembers = source[0].members;
var memberIndex = -1;
if (targetMembers.length !== sourceMembers.length) {
return {
parsedRoot: null,
tuples: source,
memberIndex: 0,
index: 0
};
}
for (var idx = 0, length = targetMembers.length; idx < length; idx++) {
if (!targetMembers[idx].measure && sourceMembers[idx].children[0]) {
if (memberIndex == -1 && sourceMembers[idx].children.length) {
memberIndex = idx;
}
targetMembers[idx].children = sourceMembers[idx].children;
}
}
measures = Math.max(measures.length, 1);
return {
parsedRoot: result.tuple,
index: result.index * measures,
memberIndex: memberIndex,
tuples: target
};
}
function equalTuples(first, second) {
var equal = true;
var idx, length;
first = first.members;
second = second.members;
for (idx = 0, length = first.length; idx < length; idx++) {
if (first[idx].measure || second[idx].measure) {
continue;
}
equal = equal && getName(first[idx]) === getName(second[idx]);
}
return equal;
}
function findExistingTuple(tuples, toFind) {
var idx, length, tuple, found, counter = 0;
var memberIndex, membersLength, member;
for (idx = 0, length = tuples.length; idx < length; idx++) {
tuple = tuples[idx];
if (equalTuples(tuple, toFind)) {
return {
tuple: tuple,
index: counter
};
}
counter++;
for (memberIndex = 0, membersLength = tuple.members.length; memberIndex < membersLength; memberIndex++) {
member = tuple.members[memberIndex];
if (member.measure) {
continue;
}
found = findExistingTuple(member.children, toFind);
counter += found.index;
if (found.tuple) {
return {
tuple: found.tuple,
index: counter
};
}
}
}
return { index: counter };
}
function addMembers(members, map) {
var member, i, len, path = '';
for (i = 0, len = members.length; i < len; i++) {
member = members[i];
path += member.name;
if (!map[path]) {
map[path] = member;
}
}
}
function findParentMember(tuple, map) {
var members = tuple.members;
var i, len, member, path = '';
var parentPath = '';
var parentMember;
for (i = 0, len = members.length; i < len; i++) {
member = members[i];
if (parentMember) {
if (map[path + member.name]) {
path += member.name;
parentMember = map[path];
continue;
} else if (map[path + member.parentName]) {
return map[path + member.parentName];
} else if (map[parentPath + member.parentName]) {
return map[parentPath + member.parentName];
} else {
return map[parentPath];
}
}
path += member.name;
parentMember = map[member.parentName];
if (!parentMember) {
parentMember = map[path];
if (!parentMember) {
return null;
}
}
if (parentMember) {
parentPath += parentMember.name;
}
}
return parentMember;
}
function measurePosition(tuple, measures) {
if (measures.length === 0) {
return -1;
}
var measure = measures[0];
var members = tuple.members;
for (var idx = 0, len = members.length; idx < len; idx++) {
if (members[idx].name == measure.name) {
return idx;
}
}
}
function normalizeTupleMeasures(tuple, index) {
if (index < 0) {
return;
}
var member = {
name: MEASURES,
measure: true,
children: [$.extend({
members: [],
dataIndex: tuple.dataIndex
}, tuple.members[index])]
};
tuple.members.splice(index, 1, member);
tuple.dataIndex = undefined;
}
function parseSource(tuples, measures) {
if (tuples.length < 1) {
return [];
}
var result = [];
var map = {};
var measureIndex = measurePosition(tuples[0], measures);
for (var i = 0; i < tuples.length; i++) {
var tuple = tuples[i];
tuple.dataIndex = i;
normalizeTupleMeasures(tuple, measureIndex);
var parentMember = findParentMember(tuple, map);
if (parentMember) {
if (measureIndex < 0 || !parentMember.measure) {
parentMember.children.push(tuple);
} else {
parentMember.children.push(tuple.members[measureIndex].children[0]);
}
} else {
result.push(tuple);
}
addMembers(tuple.members, map);
}
return result;
}
function prepareDataOnRows(tuples, data) {
if (!tuples || !tuples.length) {
return data;
}
var result = [];
var indices = buildDataIndices(tuples);
var rowsLength = indices.length;
var columnsLength = Math.max(data.length / rowsLength, 1);
var rowIndex, columnIndex, targetIndex, sourceIndex;
var calcIndex;
for (rowIndex = 0; rowIndex < rowsLength; rowIndex++) {
targetIndex = columnsLength * rowIndex;
sourceIndex = columnsLength * indices[rowIndex];
for (columnIndex = 0; columnIndex < columnsLength; columnIndex++) {
calcIndex = parseInt(sourceIndex + columnIndex, 10);
result[parseInt(targetIndex + columnIndex, 10)] = data[calcIndex] || {
value: '',
fmtValue: '',
ordinal: calcIndex
};
}
}
return result;
}
function prepareDataOnColumns(tuples, data) {
if (!tuples || !tuples.length) {
return data;
}
var result = [];
var indices = buildDataIndices(tuples);
var columnsLength = indices.length;
var rowsLength = Math.max(data.length / columnsLength, 1);
var columnIndex, rowIndex, dataIndex, calcIndex;
for (rowIndex = 0; rowIndex < rowsLength; rowIndex++) {
dataIndex = columnsLength * rowIndex;
for (columnIndex = 0; columnIndex < columnsLength; columnIndex++) {
calcIndex = indices[columnIndex] + dataIndex;
result[dataIndex + columnIndex] = data[calcIndex] || {
value: '',
fmtValue: '',
ordinal: calcIndex
};
}
}
return result;
}
function buildDataIndices(tuples) {
tuples = tuples.slice();
var result = [];
var tuple = tuples.shift();
var idx, length, spliceIndex, children, member;
while (tuple) {
if (tuple.dataIndex !== undefined) {
result.push(tuple.dataIndex);
}
spliceIndex = 0;
for (idx = 0, length = tuple.members.length; idx < length; idx++) {
member = tuple.members[idx];
children = member.children;
if (member.measure) {
[].splice.apply(tuples, [
0,
0
].concat(children));
} else {
[].splice.apply(tuples, [
spliceIndex,
0
].concat(children));
}
spliceIndex += children.length;
}
tuple = tuples.shift();
}
return result;
}
PivotDataSource.create = function (options) {
options = options && options.push ? { data: options } : options;
var dataSource = options || {}, data = dataSource.data;
dataSource.data = data;
if (!(dataSource instanceof PivotDataSource) && dataSource instanceof kendo.data.DataSource) {
throw new Error('Incorrect DataSource type. Only PivotDataSource instances are supported');
}
return dataSource instanceof PivotDataSource ? dataSource : new PivotDataSource(dataSource);
};
function baseHierarchyPath(memberName) {
var parts = memberName.split('.');
if (parts.length > 2) {
return parts[0] + '.' + parts[1];
}
return memberName;
}
function expandMemberDescriptor(names, sort) {
var idx = names.length - 1;
var name = names[idx];
var sortDescriptor;
sortDescriptor = sortDescriptorForMember(sort, name);
if (sortDescriptor && sortDescriptor.dir) {
name = 'ORDER(' + name + '.Children,' + sortDescriptor.field + '.CurrentMember.MEMBER_CAPTION,' + sortDescriptor.dir + ')';
} else {
name += '.Children';
}
names[idx] = name;
return names;
}
function sortDescriptorForMember(sort, member) {
for (var idx = 0, length = sort.length; idx < length; idx++) {
if (member.indexOf(sort[idx].field) === 0) {
return sort[idx];
}
}
return null;
}
function crossJoin(names) {
var result = 'CROSSJOIN({';
var r;
if (names.length > 2) {
r = names.pop();
result += crossJoin(names);
} else {
result += names.shift();
r = names.pop();
}
result += '},{';
result += r;
result += '})';
return result;
}
function crossJoinCommand(members, measures) {
var tmp = members.slice(0);
if (measures.length > 1) {
tmp.push('{' + measureNames(measures).join(',') + '}');
}
return crossJoin(tmp);
}
function measureNames(measures) {
var idx = 0;
var length = measures.length;
var result = [];
var measure;
for (; idx < length; idx++) {
measure = measures[idx];
result.push(measure.name !== undefined ? measure.name : measure);
}
return result;
}
function getName(name) {
name = name.name || name;
if (toString.call(name) === '[object Array]') {
name = name[name.length - 1];
}
return name;
}
function getRootNames(members) {
var length = members.length;
var names = [];
var idx = 0;
for (; idx < length; idx++) {
names.push(members[idx].name[0]);
}
return names;
}
function mapNames(names, rootNames) {
var name;
var rootName;
var j;
var idx = 0;
var length = names.length;
var rootLength = rootNames.length;
rootNames = rootNames.slice(0);
for (; idx < length; idx++) {
name = names[idx];
for (j = 0; j < rootLength; j++) {
rootName = baseHierarchyPath(rootNames[j]);
if (name.indexOf(rootName) !== -1) {
rootNames[j] = name;
break;
}
}
}
return {
names: rootNames,
expandedIdx: j,
uniquePath: rootNames.slice(0, j + 1).join('')
};
}
function parseDescriptors(members) {
var expanded = [];
var child = [];
var root = [];
var member;
var j, l;
var idx = 0;
var length = members.length;
var name;
var hierarchyName;
var found;
for (; idx < length; idx++) {
member = members[idx];
name = member.name;
found = false;
if (toString.call(name) !== '[object Array]') {
member.name = name = [name];
}
if (name.length > 1) {
child.push(member);
} else {
hierarchyName = baseHierarchyPath(name[0]);
for (j = 0, l = root.length; j < l; j++) {
if (root[j].name[0].indexOf(hierarchyName) === 0) {
found = true;
break;
}
}
if (!found) {
root.push(member);
}
if (member.expand) {
expanded.push(member);
}
}
}
expanded = expanded.concat(child);
return {
root: root,
expanded: expanded
};
}
function serializeMembers(members, measures, sort) {
var command = '';
members = members || [];
var expanded = parseDescriptors(members);
var root = expanded.root;
var rootNames = getRootNames(root);
var crossJoinCommands = [];
expanded = expanded.expanded;
var length = expanded.length;
var idx = 0;
var memberName;
var names = [];
if (rootNames.length > 1 || measures.length > 1) {
crossJoinCommands.push(crossJoinCommand(rootNames, measures));
for (; idx < length; idx++) {
memberName = expandMemberDescriptor(expanded[idx].name, sort);
names = mapNames(memberName, rootNames).names;
crossJoinCommands.push(crossJoinCommand(names, measures));
}
command += crossJoinCommands.join(',');
} else {
for (; idx < length; idx++) {
memberName = expandMemberDescriptor(expanded[idx].name, sort);
names.push(memberName[0]);
}
command += rootNames.concat(names).join(',');
}
return command;
}
var filterFunctionFormats = {
contains: ', InStr({0}.CurrentMember.MEMBER_CAPTION,"{1}") > 0',
doesnotcontain: ', InStr({0}.CurrentMember.MEMBER_CAPTION,"{1}")',
startswith: ', Left({0}.CurrentMember.MEMBER_CAPTION,Len("{1}"))="{1}"',
endswith: ', Right({0}.CurrentMember.MEMBER_CAPTION,Len("{1}"))="{1}"',
eq: ', {0}.CurrentMember.MEMBER_CAPTION = "{1}"',
neq: ', {0}.CurrentMember.MEMBER_CAPTION = "{1}"'
};
function serializeExpression(expression) {
var command = '';
var value = expression.value;
var field = expression.field;
var operator = expression.operator;
if (operator == 'in') {
command += '{';
command += value;
command += '}';
} else {
command += operator == 'neq' || operator == 'doesnotcontain' ? '-' : '';
command += 'Filter(';
command += field + '.MEMBERS';
command += kendo.format(filterFunctionFormats[operator], field, value);
command += ')';
}
return command;
}
function serializeFilters(filter, cube) {
var command = '', current;
var filters = filter.filters;
var length = filters.length;
var idx;
for (idx = length - 1; idx >= 0; idx--) {
current = 'SELECT (';
current += serializeExpression(filters[idx]);
current += ') ON 0';
if (idx == length - 1) {
current += ' FROM [' + cube + ']';
command = current;
} else {
command = current + ' FROM ( ' + command + ' )';
}
}
return command;
}
function serializeOptions(parentTagName, options, capitalize) {
var result = '';
if (options) {
result += '<' + parentTagName + '>';
var value;
for (var key in options) {
value = options[key];
if (capitalize) {
key = key.replace(/([A-Z]+(?=$|[A-Z][a-z])|[A-Z]?[a-z]+)/g, '$1_').toUpperCase().replace(/_$/, '');
}
result += '<' + key + '>' + value + '';
}
result += '';
} else {
result += '<' + parentTagName + '/>';
}
return result;
}
var xmlaDiscoverCommands = {
schemaCubes: 'MDSCHEMA_CUBES',
schemaCatalogs: 'DBSCHEMA_CATALOGS',
schemaMeasures: 'MDSCHEMA_MEASURES',
schemaDimensions: 'MDSCHEMA_DIMENSIONS',
schemaHierarchies: 'MDSCHEMA_HIERARCHIES',
schemaLevels: 'MDSCHEMA_LEVELS',
schemaMembers: 'MDSCHEMA_MEMBERS',
schemaKPIs: 'MDSCHEMA_KPIS'
};
var convertersMap = {
read: function (options) {
var command = '';
command += 'SELECT NON EMPTY {';
var columns = options.columns || [];
var rows = options.rows || [];
var measures = options.measures || [];
var measuresRowAxis = options.measuresAxis === 'rows';
var sort = options.sort || [];
if (!columns.length && rows.length && (!measures.length || measures.length && measuresRowAxis)) {
columns = rows;
rows = [];
measuresRowAxis = false;
}
if (!columns.length && !rows.length) {
measuresRowAxis = false;
}
if (columns.length) {
command += serializeMembers(columns, !measuresRowAxis ? measures : [], sort);
} else if (measures.length && !measuresRowAxis) {
command += measureNames(measures).join(',');
}
command += '} DIMENSION PROPERTIES CHILDREN_CARDINALITY, PARENT_UNIQUE_NAME ON COLUMNS';
if (rows.length || measuresRowAxis && measures.length > 1) {
command += ', NON EMPTY {';
if (rows.length) {
command += serializeMembers(rows, measuresRowAxis ? measures : [], sort);
} else {
command += measureNames(measures).join(',');
}
command += '} DIMENSION PROPERTIES CHILDREN_CARDINALITY, PARENT_UNIQUE_NAME ON ROWS';
}
if (options.filter) {
command += ' FROM ';
command += '(';
command += serializeFilters(options.filter, options.connection.cube);
command += ')';
} else {
command += ' FROM [' + options.connection.cube + ']';
}
if (measures.length == 1 && columns.length) {
command += ' WHERE (' + measureNames(measures).join(',') + ')';
}
command += '' + options.connection.catalog + 'Multidimensional';
return command.replace(/\&/g, '&');
},
discover: function (options) {
options = options || {};
var command = '';
command += '' + (xmlaDiscoverCommands[options.command] || options.command) + '';
command += '' + serializeOptions('RestrictionList', options.restrictions, true) + '';
if (options.connection && options.connection.catalog) {
options.properties = $.extend({}, { Catalog: options.connection.catalog }, options.properties);
}
command += '' + serializeOptions('PropertyList', options.properties) + '';
command += '';
return command;
}
};
var XmlaTransport = kendo.data.RemoteTransport.extend({
init: function (options) {
var originalOptions = options;
options = this.options = extend(true, {}, this.options, options);
kendo.data.RemoteTransport.call(this, options);
if (isFunction(originalOptions.discover)) {
this.discover = originalOptions.discover;
} else if (typeof originalOptions.discover === 'string') {
this.options.discover = { url: originalOptions.discover };
} else if (!originalOptions.discover) {
this.options.discover = this.options.read;
}
},
setup: function (options, type) {
options.data = options.data || {};
$.extend(true, options.data, { connection: this.options.connection });
return kendo.data.RemoteTransport.fn.setup.call(this, options, type);
},
options: {
read: {
dataType: 'text',
contentType: 'text/xml',
type: 'POST'
},
discover: {
dataType: 'text',
contentType: 'text/xml',
type: 'POST'
},
parameterMap: function (options, type) {
return convertersMap[type](options, type);
}
},
discover: function (options) {
return $.ajax(this.setup(options, 'discover'));
}
});
function asArray(object) {
if (object == null) {
return [];
}
var type = toString.call(object);
if (type !== '[object Array]') {
return [object];
}
return object;
}
function translateAxis(axis) {
var result = { tuples: [] };
var tuples = asArray(kendo.getter('Tuples.Tuple', true)(axis));
var captionGetter = kendo.getter('Caption[\'#text\']');
var unameGetter = kendo.getter('UName[\'#text\']');
var levelNameGetter = kendo.getter('LName[\'#text\']');
var levelNumGetter = kendo.getter('LNum[\'#text\']');
var childrenGetter = kendo.getter('CHILDREN_CARDINALITY[\'#text\']', true);
var hierarchyGetter = kendo.getter('[\'@Hierarchy\']');
var parentNameGetter = kendo.getter('PARENT_UNIQUE_NAME[\'#text\']', true);
for (var idx = 0; idx < tuples.length; idx++) {
var members = [];
var member = asArray(tuples[idx].Member);
for (var memberIdx = 0; memberIdx < member.length; memberIdx++) {
members.push({
children: [],
caption: captionGetter(member[memberIdx]),
name: unameGetter(member[memberIdx]),
levelName: levelNameGetter(member[memberIdx]),
levelNum: levelNumGetter(member[memberIdx]),
hasChildren: parseInt(childrenGetter(member[memberIdx]), 10) > 0,
parentName: parentNameGetter(member[memberIdx]),
hierarchy: hierarchyGetter(member[memberIdx])
});
}
result.tuples.push({ members: members });
}
return result;
}
var schemaDataReaderMap = {
cubes: {
name: kendo.getter('CUBE_NAME[\'#text\']', true),
caption: kendo.getter('CUBE_CAPTION[\'#text\']', true),
description: kendo.getter('DESCRIPTION[\'#text\']', true),
type: kendo.getter('CUBE_TYPE[\'#text\']', true)
},
catalogs: {
name: kendo.getter('CATALOG_NAME[\'#text\']', true),
description: kendo.getter('DESCRIPTION[\'#text\']', true)
},
measures: {
name: kendo.getter('MEASURE_NAME[\'#text\']', true),
caption: kendo.getter('MEASURE_CAPTION[\'#text\']', true),
uniqueName: kendo.getter('MEASURE_UNIQUE_NAME[\'#text\']', true),
description: kendo.getter('DESCRIPTION[\'#text\']', true),
aggregator: kendo.getter('MEASURE_AGGREGATOR[\'#text\']', true),
groupName: kendo.getter('MEASUREGROUP_NAME[\'#text\']', true),
displayFolder: kendo.getter('MEASURE_DISPLAY_FOLDER[\'#text\']', true),
defaultFormat: kendo.getter('DEFAULT_FORMAT_STRING[\'#text\']', true)
},
kpis: {
name: kendo.getter('KPI_NAME[\'#text\']', true),
caption: kendo.getter('KPI_CAPTION[\'#text\']', true),
value: kendo.getter('KPI_VALUE[\'#text\']', true),
goal: kendo.getter('KPI_GOAL[\'#text\']', true),
status: kendo.getter('KPI_STATUS[\'#text\']', true),
trend: kendo.getter('KPI_TREND[\'#text\']', true),
statusGraphic: kendo.getter('KPI_STATUS_GRAPHIC[\'#text\']', true),
trendGraphic: kendo.getter('KPI_TREND_GRAPHIC[\'#text\']', true),
description: kendo.getter('KPI_DESCRIPTION[\'#text\']', true),
groupName: kendo.getter('MEASUREGROUP_NAME[\'#text\']', true)
},
dimensions: {
name: kendo.getter('DIMENSION_NAME[\'#text\']', true),
caption: kendo.getter('DIMENSION_CAPTION[\'#text\']', true),
description: kendo.getter('DESCRIPTION[\'#text\']', true),
uniqueName: kendo.getter('DIMENSION_UNIQUE_NAME[\'#text\']', true),
defaultHierarchy: kendo.getter('DEFAULT_HIERARCHY[\'#text\']', true),
type: kendo.getter('DIMENSION_TYPE[\'#text\']', true)
},
hierarchies: {
name: kendo.getter('HIERARCHY_NAME[\'#text\']', true),
caption: kendo.getter('HIERARCHY_CAPTION[\'#text\']', true),
description: kendo.getter('DESCRIPTION[\'#text\']', true),
uniqueName: kendo.getter('HIERARCHY_UNIQUE_NAME[\'#text\']', true),
dimensionUniqueName: kendo.getter('DIMENSION_UNIQUE_NAME[\'#text\']', true),
displayFolder: kendo.getter('HIERARCHY_DISPLAY_FOLDER[\'#text\']', true),
origin: kendo.getter('HIERARCHY_ORIGIN[\'#text\']', true),
defaultMember: kendo.getter('DEFAULT_MEMBER[\'#text\']', true)
},
levels: {
name: kendo.getter('LEVEL_NAME[\'#text\']', true),
caption: kendo.getter('LEVEL_CAPTION[\'#text\']', true),
description: kendo.getter('DESCRIPTION[\'#text\']', true),
uniqueName: kendo.getter('LEVEL_UNIQUE_NAME[\'#text\']', true),
dimensionUniqueName: kendo.getter('DIMENSION_UNIQUE_NAME[\'#text\']', true),
displayFolder: kendo.getter('LEVEL_DISPLAY_FOLDER[\'#text\']', true),
orderingProperty: kendo.getter('LEVEL_ORDERING_PROPERTY[\'#text\']', true),
origin: kendo.getter('LEVEL_ORIGIN[\'#text\']', true),
hierarchyUniqueName: kendo.getter('HIERARCHY_UNIQUE_NAME[\'#text\']', true)
},
members: {
name: kendo.getter('MEMBER_NAME[\'#text\']', true),
caption: kendo.getter('MEMBER_CAPTION[\'#text\']', true),
uniqueName: kendo.getter('MEMBER_UNIQUE_NAME[\'#text\']', true),
dimensionUniqueName: kendo.getter('DIMENSION_UNIQUE_NAME[\'#text\']', true),
hierarchyUniqueName: kendo.getter('HIERARCHY_UNIQUE_NAME[\'#text\']', true),
levelUniqueName: kendo.getter('LEVEL_UNIQUE_NAME[\'#text\']', true),
childrenCardinality: kendo.getter('CHILDREN_CARDINALITY[\'#text\']', true)
}
};
var xmlaReaderMethods = [
'axes',
'catalogs',
'cubes',
'dimensions',
'hierarchies',
'levels',
'measures'
];
var XmlaDataReader = kendo.data.XmlDataReader.extend({
init: function (options) {
kendo.data.XmlDataReader.call(this, options);
this._extend(options);
},
_extend: function (options) {
var idx = 0;
var length = xmlaReaderMethods.length;
var methodName;
var option;
for (; idx < length; idx++) {
methodName = xmlaReaderMethods[idx];
option = options[methodName];
if (option && option !== identity) {
this[methodName] = option;
}
}
},
parse: function (xml) {
var result = kendo.data.XmlDataReader.fn.parse(xml.replace(/<(\/?)(\w|-)+:/g, '<$1'));
return kendo.getter('[\'Envelope\'][\'Body\']', true)(result);
},
errors: function (root) {
var fault = kendo.getter('[\'Fault\']', true)(root);
if (fault) {
return [{
faultstring: kendo.getter('faultstring[\'#text\']', true)(fault),
faultcode: kendo.getter('faultcode[\'#text\']', true)(fault)
}];
}
return null;
},
axes: function (root) {
root = kendo.getter('ExecuteResponse["return"].root', true)(root);
var axes = asArray(kendo.getter('Axes.Axis', true)(root));
var axis;
var result = {
columns: {},
rows: {}
};
for (var idx = 0; idx < axes.length; idx++) {
axis = axes[idx];
if (axis['@name'].toLowerCase() !== 'sliceraxis') {
if (!result.columns.tuples) {
result.columns = translateAxis(axis);
} else {
result.rows = translateAxis(axis);
}
}
}
return result;
},
data: function (root) {
root = kendo.getter('ExecuteResponse["return"].root', true)(root);
var cells = asArray(kendo.getter('CellData.Cell', true)(root));
var result = [];
var ordinalGetter = kendo.getter('[\'@CellOrdinal\']');
var valueGetter = kendo.getter('Value[\'#text\']');
var fmtValueGetter = kendo.getter('FmtValue[\'#text\']');
for (var idx = 0; idx < cells.length; idx++) {
result.push({
value: valueGetter(cells[idx]),
fmtValue: fmtValueGetter(cells[idx]),
ordinal: parseInt(ordinalGetter(cells[idx]), 10)
});
}
return result;
},
_mapSchema: function (root, getters) {
root = kendo.getter('DiscoverResponse["return"].root', true)(root);
var rows = asArray(kendo.getter('row', true)(root));
var result = [];
for (var idx = 0; idx < rows.length; idx++) {
var obj = {};
for (var key in getters) {
obj[key] = getters[key](rows[idx]);
}
result.push(obj);
}
return result;
},
measures: function (root) {
return this._mapSchema(root, schemaDataReaderMap.measures);
},
kpis: function (root) {
return this._mapSchema(root, schemaDataReaderMap.kpis);
},
hierarchies: function (root) {
return this._mapSchema(root, schemaDataReaderMap.hierarchies);
},
levels: function (root) {
return this._mapSchema(root, schemaDataReaderMap.levels);
},
dimensions: function (root) {
return this._mapSchema(root, schemaDataReaderMap.dimensions);
},
cubes: function (root) {
return this._mapSchema(root, schemaDataReaderMap.cubes);
},
catalogs: function (root) {
return this._mapSchema(root, schemaDataReaderMap.catalogs);
},
members: function (root) {
return this._mapSchema(root, schemaDataReaderMap.members);
}
});
extend(true, kendo.data, {
PivotDataSource: PivotDataSource,
XmlaTransport: XmlaTransport,
XmlaDataReader: XmlaDataReader,
PivotCubeBuilder: PivotCubeBuilder,
transports: { xmla: XmlaTransport },
readers: { xmla: XmlaDataReader }
});
var sortExpr = function (expressions, name) {
if (!expressions) {
return null;
}
for (var idx = 0, length = expressions.length; idx < length; idx++) {
if (expressions[idx].field === name) {
return expressions[idx];
}
}
return null;
};
var removeExpr = function (expressions, name) {
var result = [];
for (var idx = 0, length = expressions.length; idx < length; idx++) {
if (expressions[idx].field !== name) {
result.push(expressions[idx]);
}
}
return result;
};
kendo.ui.PivotSettingTarget = Widget.extend({
init: function (element, options) {
var that = this;
Widget.fn.init.call(that, element, options);
that.element.addClass('k-pivot-setting');
that.dataSource = kendo.data.PivotDataSource.create(options.dataSource);
that._refreshHandler = $.proxy(that.refresh, that);
that.dataSource.first(CHANGE, that._refreshHandler);
if (!options.template) {
that.options.template = '${data.name || data}' + (that.options.enabled ? '
' : '') + '
${data}
',
setting: 'columns',
enabled: true,
messages: { empty: 'Drop Fields Here' }
},
setDataSource: function (dataSource) {
this.dataSource.unbind(CHANGE, this._refreshHandler);
this.dataSource = this.options.dataSource = dataSource;
if (this.fieldMenu) {
this.fieldMenu.setDataSource(dataSource);
}
dataSource.first(CHANGE, this._refreshHandler);
this.refresh();
},
_sortable: function () {
var that = this;
if (that.options.enabled) {
this.sortable = this.element.kendoSortable({
connectWith: this.options.connectWith,
hint: that.options.hint,
cursor: 'move',
start: function (e) {
e.item.focus().blur();
},
change: function (e) {
var name = e.item.attr(kendo.attr('name'));
if (e.action == 'receive') {
that.add(name);
} else if (e.action == 'remove') {
that.remove(name);
} else if (e.action == 'sort') {
that.move(name, e.newIndex);
}
}
}).data('kendoSortable');
}
},
_indexOf: function (name, items) {
var idx, length, index = -1;
for (idx = 0, length = items.length; idx < length; idx++) {
if (getName(items[idx]) === name) {
index = idx;
break;
}
}
return index;
},
_isKPI: function (data) {
return data.type === 'kpi' || data.measure;
},
validate: function (data) {
var isMeasure = data.type == 2 || 'aggregator' in data || this._isKPI(data);
if (isMeasure) {
return this.options.setting === 'measures';
}
if (this.options.setting === 'measures') {
return isMeasure;
}
var items = this.dataSource[this.options.setting]();
var name = data.defaultHierarchy || data.uniqueName;
if (this._indexOf(name, items) > -1) {
return false;
}
items = this.dataSource[this.options.setting === 'columns' ? 'rows' : 'columns']();
if (this._indexOf(name, items) > -1) {
return false;
}
return true;
},
add: function (name) {
var items = this.dataSource[this.options.setting]();
var i, l;
name = $.isArray(name) ? name.slice(0) : [name];
for (i = 0, l = name.length; i < l; i++) {
if (this._indexOf(name[i], items) !== -1) {
name.splice(i, 1);
i -= 1;
l -= 1;
}
}
if (name.length) {
items = items.concat(name);
this.dataSource[this.options.setting](items);
}
},
move: function (name, index) {
var items = this.dataSource[this.options.setting]();
var idx = this._indexOf(name, items);
if (idx > -1) {
name = items.splice(idx, 1)[0];
items.splice(index, 0, name);
this.dataSource[this.options.setting](items);
}
},
remove: function (name) {
var items = this.dataSource[this.options.setting]();
var idx = this._indexOf(name, items);
var sortExpressions = this.dataSource.sort();
var filter = this.dataSource.filter();
if (idx > -1) {
if (filter) {
filter.filters = removeExpr(filter.filters, name);
this.dataSource._filter.filters = filter.filters;
if (!filter.filters.length) {
this.dataSource._filter = null;
}
}
if (sortExpressions) {
sortExpressions = removeExpr(sortExpressions, name);
this.dataSource._sort = sortExpressions;
}
items.splice(idx, 1);
this.dataSource[this.options.setting](items);
}
},
sort: function (expr) {
var sortable = this.options.sortable;
var allowUnsort = sortable === true || sortable.allowUnsort;
var skipExpr = allowUnsort && expr.dir === 'asc';
var expressions = this.dataSource.sort() || [];
var result = removeExpr(expressions, expr.field);
if (skipExpr && expressions.length !== result.length) {
expr = null;
}
if (expr) {
result.push(expr);
}
this.dataSource.sort(result);
},
refresh: function () {
var html = '';
var items = this.dataSource[this.options.setting]();
var length = items.length;
var idx = 0;
var item;
if (length) {
for (; idx < length; idx++) {
item = items[idx];
item = item.name === undefined ? { name: item } : item;
html += this.template(extend({ sortIcon: this._sortIcon(item.name) }, item));
}
} else {
html = this.emptyTemplate(this.options.messages.empty);
}
this.element.html(html);
},
destroy: function () {
Widget.fn.destroy.call(this);
this.dataSource.unbind(CHANGE, this._refreshHandler);
this.element.off(NS);
if (this.sortable) {
this.sortable.destroy();
}
if (this.fieldMenu) {
this.fieldMenu.destroy();
}
this.element = null;
this._refreshHandler = null;
},
_sortIcon: function (name) {
var expressions = this.dataSource.sort();
var expr = sortExpr(expressions, getName(name));
var icon = '';
if (expr) {
icon = 'k-i-sort-' + expr.dir;
}
return icon;
}
});
var PivotGrid = Widget.extend({
init: function (element, options) {
var that = this;
var columnBuilder;
var rowBuilder;
Widget.fn.init.call(that, element, options);
that._dataSource();
that._bindConfigurator();
that._wrapper();
that._createLayout();
that._columnBuilder = columnBuilder = new ColumnBuilder();
that._rowBuilder = rowBuilder = new RowBuilder();
that._contentBuilder = new ContentBuilder();
that._templates();
that.columnsHeader.add(that.rowsHeader).on('click', 'span.k-icon', function () {
var button = $(this);
var builder = columnBuilder;
var action = 'expandColumn';
var eventName;
var path = button.attr(kendo.attr('path'));
var eventArgs = {
axis: 'columns',
path: $.parseJSON(path)
};
if (button.parent().is('td')) {
builder = rowBuilder;
action = 'expandRow';
eventArgs.axis = 'rows';
}
var expanded = button.hasClass(STATE_EXPANDED);
var metadata = builder.metadata[path];
var request = metadata.expanded === undefined;
eventName = expanded ? COLLAPSEMEMBER : EXPANDMEMBER;
eventArgs.childrenLoaded = metadata.maxChildren > metadata.children;
if (that.trigger(eventName, eventArgs)) {
return;
}
builder.metadata[path].expanded = !expanded;
button.toggleClass(STATE_EXPANDED, !expanded).toggleClass(STATE_COLLAPSED, expanded);
if (!expanded && request) {
that.dataSource[action](eventArgs.path);
} else {
that.refresh();
}
});
that._scrollable();
if (that.options.autoBind) {
that.dataSource.fetch();
}
kendo.notify(that);
},
events: [
DATABINDING,
DATABOUND,
EXPANDMEMBER,
COLLAPSEMEMBER
],
options: {
name: 'PivotGrid',
autoBind: true,
reorderable: true,
filterable: false,
sortable: false,
height: null,
columnWidth: 100,
configurator: '',
columnHeaderTemplate: null,
rowHeaderTemplate: null,
dataCellTemplate: null,
kpiStatusTemplate: null,
kpiTrendTemplate: null,
messages: {
measureFields: 'Drop Data Fields Here',
columnFields: 'Drop Column Fields Here',
rowFields: 'Drop Rows Fields Here'
}
},
_templates: function () {
var columnTemplate = this.options.columnHeaderTemplate;
var rowTemplate = this.options.rowHeaderTemplate;
var dataTemplate = this.options.dataCellTemplate;
var kpiStatusTemplate = this.options.kpiStatusTemplate;
var kpiTrendTemplate = this.options.kpiTrendTemplate;
this._columnBuilder.template = kendo.template(columnTemplate || HEADER_TEMPLATE, { useWithBlock: !!columnTemplate });
this._contentBuilder.dataTemplate = kendo.template(dataTemplate || DATACELL_TEMPLATE, { useWithBlock: !!dataTemplate });
this._contentBuilder.kpiStatusTemplate = kendo.template(kpiStatusTemplate || KPISTATUS_TEMPLATE, { useWithBlock: !!kpiStatusTemplate });
this._contentBuilder.kpiTrendTemplate = kendo.template(kpiTrendTemplate || KPITREND_TEMPLATE, { useWithBlock: !!kpiTrendTemplate });
this._rowBuilder.template = kendo.template(rowTemplate || HEADER_TEMPLATE, { useWithBlock: !!rowTemplate });
},
_bindConfigurator: function () {
var configurator = this.options.configurator;
if (configurator) {
$(configurator).kendoPivotConfigurator('setDataSource', this.dataSource);
}
},
cellInfoByElement: function (element) {
element = $(element);
return this.cellInfo(element.index(), element.parent('tr').index());
},
cellInfo: function (columnIndex, rowIndex) {
var contentBuilder = this._contentBuilder;
var columnInfo = contentBuilder.columnIndexes[columnIndex || 0];
var rowInfo = contentBuilder.rowIndexes[rowIndex || 0];
var dataIndex;
if (!columnInfo || !rowInfo) {
return null;
}
dataIndex = rowInfo.index * contentBuilder.rowLength + columnInfo.index;
return {
columnTuple: columnInfo.tuple,
rowTuple: rowInfo.tuple,
measure: columnInfo.measure || rowInfo.measure,
dataItem: this.dataSource.view()[dataIndex]
};
},
setDataSource: function (dataSource) {
this.options.dataSource = dataSource;
this._dataSource();
if (this.measuresTarget) {
this.measuresTarget.setDataSource(dataSource);
}
if (this.rowsTarget) {
this.rowsTarget.setDataSource(dataSource);
}
if (this.columnsTarget) {
this.columnsTarget.setDataSource(dataSource);
}
this._bindConfigurator();
if (this.options.autoBind) {
dataSource.fetch();
}
},
setOptions: function (options) {
Widget.fn.setOptions.call(this, options);
this._templates();
},
destroy: function () {
Widget.fn.destroy.call(this);
clearTimeout(this._headerReflowTimeout);
},
_dataSource: function () {
var that = this;
var dataSource = that.options.dataSource;
dataSource = $.isArray(dataSource) ? { data: dataSource } : dataSource;
if (that.dataSource && this._refreshHandler) {
that.dataSource.unbind(CHANGE, that._refreshHandler).unbind(STATERESET, that._stateResetHandler).unbind(PROGRESS, that._progressHandler).unbind(ERROR, that._errorHandler);
} else {
that._refreshHandler = $.proxy(that.refresh, that);
that._progressHandler = $.proxy(that._requestStart, that);
that._stateResetHandler = $.proxy(that._stateReset, that);
that._errorHandler = $.proxy(that._error, that);
}
that.dataSource = kendo.data.PivotDataSource.create(dataSource).bind(CHANGE, that._refreshHandler).bind(PROGRESS, that._progressHandler).bind(STATERESET, that._stateResetHandler).bind(ERROR, that._errorHandler);
},
_error: function () {
this._progress(false);
},
_requestStart: function () {
this._progress(true);
},
_stateReset: function () {
this._columnBuilder.reset();
this._rowBuilder.reset();
},
_wrapper: function () {
var height = this.options.height;
this.wrapper = this.element.addClass('k-widget k-pivot');
if (height) {
this.wrapper.css('height', height);
}
},
_measureFields: function () {
this.measureFields = $(DIV).addClass('k-pivot-toolbar k-header k-settings-measures');
this.measuresTarget = this._createSettingTarget(this.measureFields, {
setting: 'measures',
messages: { empty: this.options.messages.measureFields }
});
},
_createSettingTarget: function (element, options) {
var template = '${data.name}';
var sortable = options.sortable;
var icons = '';
if (sortable) {
icons += '#if (data.sortIcon) {#';
icons += '';
icons += '#}#';
}
if (options.filterable || sortable) {
icons += '';
}
if (this.options.reorderable) {
icons += '';
}
if (icons) {
template += '' + icons + '';
}
template += '';
return new kendo.ui.PivotSettingTarget(element, $.extend({
template: template,
emptyTemplate: '${data}',
enabled: this.options.reorderable,
dataSource: this.dataSource
}, options));
},
_initSettingTargets: function () {
this.columnsTarget = this._createSettingTarget(this.columnFields, {
connectWith: this.rowFields,
setting: 'columns',
filterable: this.options.filterable,
sortable: this.options.sortable,
messages: {
empty: this.options.messages.columnFields,
fieldMenu: this.options.messages.fieldMenu
}
});
this.rowsTarget = this._createSettingTarget(this.rowFields, {
connectWith: this.columnFields,
setting: 'rows',
filterable: this.options.filterable,
sortable: this.options.sortable,
messages: {
empty: this.options.messages.rowFields,
fieldMenu: this.options.messages.fieldMenu
}
});
},
_createLayout: function () {
var that = this;
var layoutTable = $(LAYOUT_TABLE);
var leftContainer = layoutTable.find('.k-pivot-rowheaders');
var rightContainer = layoutTable.find('.k-pivot-table');
var gridWrapper = $(DIV).addClass('k-grid k-widget');
that._measureFields();
that.columnFields = $(DIV).addClass('k-pivot-toolbar k-header k-settings-columns');
that.rowFields = $(DIV).addClass('k-pivot-toolbar k-header k-settings-rows');
that.columnsHeader = $('').wrap('');
that.columnsHeader.parent().css('padding-right', kendo.support.scrollbar());
that.rowsHeader = $('');
that.content = $('');
leftContainer.append(that.measureFields);
leftContainer.append(that.rowFields);
leftContainer.append(that.rowsHeader);
gridWrapper.append(that.columnsHeader.parent());
gridWrapper.append(that.content);
rightContainer.append(that.columnFields);
rightContainer.append(gridWrapper);
that.wrapper.append(layoutTable);
that.columnsHeaderTree = new kendo.dom.Tree(that.columnsHeader[0]);
that.rowsHeaderTree = new kendo.dom.Tree(that.rowsHeader[0]);
that.contentTree = new kendo.dom.Tree(that.content[0]);
that._initSettingTargets();
},
_progress: function (toggle) {
kendo.ui.progress(this.wrapper, toggle);
},
_resize: function () {
if (this.content[0].firstChild) {
this._setSectionsWidth();
this._setSectionsHeight();
this._setContentWidth();
this._setContentHeight();
this._columnHeaderReflow();
}
},
_columnHeaderReflow: function () {
var columnTable = this.columnsHeader.children('table');
if (!kendo.support.browser.mozilla) {
return;
}
clearTimeout(this._headerReflowTimeout);
columnTable.css('table-layout', 'auto');
this._headerReflowTimeout = setTimeout(function () {
columnTable.css('table-layout', '');
});
},
_setSectionsWidth: function () {
var rowsHeader = this.rowsHeader;
var leftColumn = rowsHeader.parent('.k-pivot-rowheaders').width(AUTO);
var width;
width = Math.max(outerWidth(this.measureFields), outerWidth(this.rowFields));
width = Math.max(rowsHeader.children('table').width(), width);
leftColumn.width(width);
},
_setSectionsHeight: function () {
var measureFieldsHeight = this.measureFields.height(AUTO).height();
var columnFieldsHeight = this.columnFields.height(AUTO).height();
var rowFieldsHeight = this.rowFields.height(AUTO).innerHeight();
var columnsHeight = this.columnsHeader.height(AUTO).innerHeight();
var padding = rowFieldsHeight - this.rowFields.height();
var firstRowHeight = columnFieldsHeight > measureFieldsHeight ? columnFieldsHeight : measureFieldsHeight;
var secondRowHeight = columnsHeight > rowFieldsHeight ? columnsHeight : rowFieldsHeight;
this.measureFields.height(firstRowHeight);
this.columnFields.height(firstRowHeight);
this.rowFields.height(secondRowHeight - padding);
this.columnsHeader.height(secondRowHeight);
},
_setContentWidth: function () {
var contentTable = this.content.find('table');
var columnTable = this.columnsHeader.children('table');
var rowLength = contentTable.children('colgroup').children().length;
var calculatedWidth = rowLength * this.options.columnWidth;
var minWidth = Math.ceil(calculatedWidth / this.content.width() * 100);
if (minWidth < 100) {
minWidth = 100;
}
contentTable.add(columnTable).css('width', minWidth + '%');
this._resetColspan(columnTable);
},
_setContentHeight: function () {
var that = this;
var content = that.content;
var rowsHeader = that.rowsHeader;
var innerHeight = that.wrapper.innerHeight();
var scrollbar = kendo.support.scrollbar();
var skipScrollbar = content[0].offsetHeight === content[0].clientHeight;
var height = that.options.height;
if (that.wrapper.is(':visible')) {
if (!innerHeight || !height) {
if (skipScrollbar) {
scrollbar = 0;
}
content.height('auto');
rowsHeader.height(content.height() - scrollbar);
return;
}
innerHeight -= outerHeight(that.columnFields);
innerHeight -= outerHeight(that.columnsHeader.parent());
if (innerHeight <= scrollbar * 2) {
innerHeight = scrollbar * 2 + 1;
if (!skipScrollbar) {
innerHeight += scrollbar;
}
}
content.height(innerHeight);
if (skipScrollbar) {
scrollbar = 0;
}
rowsHeader.height(innerHeight - scrollbar);
}
},
_resetColspan: function (columnTable) {
var that = this;
var cell = columnTable.children('tbody').children(':first').children(':first');
if (that._colspan === undefined) {
that._colspan = cell.attr('colspan');
}
cell.attr('colspan', 1);
clearTimeout(that._layoutTimeout);
that._layoutTimeout = setTimeout(function () {
cell.attr('colspan', that._colspan);
that._colspan = undefined;
});
},
_axisMeasures: function (axis) {
var result = [];
var dataSource = this.dataSource;
var measures = dataSource.measures();
var hasMeasure = measures.length > 1 || measures[0] && measures[0].type;
if (dataSource.measuresAxis() === axis) {
if (dataSource[axis]().length === 0 || hasMeasure) {
result = measures;
}
}
return result;
},
items: function () {
return [];
},
refresh: function () {
var that = this;
var dataSource = that.dataSource;
var axes = dataSource.axes();
var columns = (axes.columns || {}).tuples || [];
var rows = (axes.rows || {}).tuples || [];
var columnBuilder = that._columnBuilder;
var rowBuilder = that._rowBuilder;
var columnAxis = {};
var rowAxis = {};
if (that.trigger(DATABINDING, { action: 'rebind' })) {
return;
}
columnBuilder.measures = that._axisMeasures(AXIS_COLUMNS);
rowBuilder.measures = that._axisMeasures(AXIS_ROWS);
that.columnsHeaderTree.render(columnBuilder.build(columns));
that.rowsHeaderTree.render(rowBuilder.build(rows));
columnAxis = {
indexes: columnBuilder._indexes,
measures: columnBuilder.measures,
metadata: columnBuilder.metadata
};
rowAxis = {
indexes: rowBuilder._indexes,
measures: rowBuilder.measures,
metadata: rowBuilder.metadata
};
that.contentTree.render(that._contentBuilder.build(dataSource.view(), columnAxis, rowAxis));
that._resize();
if (that.touchScroller) {
that.touchScroller.contentResized();
} else {
var touchScroller = kendo.touchScroller(that.content);
if (touchScroller && touchScroller.movable) {
that.touchScroller = touchScroller;
touchScroller.movable.bind('change', function (e) {
that.columnsHeader.scrollLeft(-e.sender.x);
that.rowsHeader.scrollTop(-e.sender.y);
});
}
}
that._progress(false);
that.trigger(DATABOUND);
},
_scrollable: function () {
var that = this;
var columnsHeader = that.columnsHeader;
var rowsHeader = that.rowsHeader;
that.content.scroll(function () {
columnsHeader.scrollLeft(this.scrollLeft);
rowsHeader.scrollTop(this.scrollTop);
});
rowsHeader.bind('DOMMouseScroll' + NS + ' mousewheel' + NS, $.proxy(that._wheelScroll, that));
},
_wheelScroll: function (e) {
if (e.ctrlKey) {
return;
}
var delta = kendo.wheelDeltaY(e);
var scrollTop = this.content.scrollTop();
if (delta) {
e.preventDefault();
$(e.currentTarget).one('wheel' + NS, false);
this.rowsHeader.scrollTop(scrollTop + -delta);
this.content.scrollTop(scrollTop + -delta);
}
}
});
var element = kendo.dom.element;
var htmlNode = kendo.dom.html;
var createMetadata = function (levelNum, memberIdx) {
return {
maxChildren: 0,
children: 0,
maxMembers: 0,
members: 0,
measures: 1,
levelNum: levelNum,
parentMember: memberIdx !== 0
};
};
var buildPath = function (tuple, index) {
var path = [];
var idx = 0;
for (; idx <= index; idx++) {
path.push(tuple.members[idx].name);
}
return path;
};
var tupleName = function (tuple, index) {
var name = '';
var idx = 0;
for (; idx <= index; idx++) {
name += tuple.members[idx].name;
}
return name;
};
var ColumnBuilder = Class.extend({
init: function () {
this.measures = 1;
this.metadata = {};
},
build: function (tuples) {
var tbody = this._tbody(tuples);
var colgroup = this._colGroup();
return [element('table', null, [
colgroup,
tbody
])];
},
reset: function () {
this.metadata = {};
},
_colGroup: function () {
var length = this._rowLength();
var children = [];
var idx = 0;
for (; idx < length; idx++) {
children.push(element('col', null));
}
return element('colgroup', null, children);
},
_tbody: function (tuples) {
var root = tuples[0];
this.map = {};
this.rows = [];
this.rootTuple = root;
this._indexes = [];
if (root) {
this._buildRows(root, 0);
this._normalize();
} else {
this.rows.push(element('tr', null, [element('th', null, [htmlNode(' ')])]));
}
return element('tbody', null, this.rows);
},
_normalize: function () {
var rows = this.rows;
var rowsLength = rows.length;
var rowIdx = 0;
var row;
var cellsLength;
var cellIdx;
var cells;
var cell;
for (; rowIdx < rowsLength; rowIdx++) {
row = rows[rowIdx];
if (row.rowSpan === 1) {
continue;
}
cells = row.children;
cellIdx = 0;
cellsLength = cells.length;
for (; cellIdx < cellsLength; cellIdx++) {
cell = cells[cellIdx];
if (cell.tupleAll) {
cell.attr.rowSpan = row.rowSpan;
}
}
}
},
_rowIndex: function (row) {
var rows = this.rows;
var length = rows.length;
var idx = 0;
for (; idx < length; idx++) {
if (rows[idx] === row) {
break;
}
}
return idx;
},
_rowLength: function () {
var cells = this.rows[0] ? this.rows[0].children : [];
var length = cells.length;
var rowLength = 0;
var idx = 0;
if (length) {
for (; idx < length; idx++) {
rowLength += cells[idx].attr.colSpan || 1;
}
}
if (!rowLength) {
rowLength = this.measures;
}
return rowLength;
},
_row: function (tuple, memberIdx, parentMember) {
var rootName = this.rootTuple.members[memberIdx].name;
var levelNum = tuple.members[memberIdx].levelNum;
var rowKey = rootName + levelNum;
var map = this.map;
var parentRow;
var children;
var row = map[rowKey];
if (!row) {
row = element('tr', null, []);
row.parentMember = parentMember;
row.collapsed = 0;
row.colSpan = 0;
row.rowSpan = 1;
map[rowKey] = row;
parentRow = map[rootName + (Number(levelNum) - 1)];
if (parentRow) {
children = parentRow.children;
if (children[1] && children[1].attr.className.indexOf('k-alt') === -1) {
row.notFirst = true;
} else {
row.notFirst = parentRow.notFirst;
}
}
this.rows.splice(this._rowIndex(parentRow) + 1, 0, row);
} else {
row.notFirst = false;
if (!row.parentMember || row.parentMember !== parentMember) {
row.parentMember = parentMember;
row.collapsed = 0;
row.colSpan = 0;
}
}
return row;
},
_measures: function (measures, tuple, className) {
var map = this.map;
var row = map.measureRow;
var measure;
if (!row) {
row = element('tr', null, []);
map.measureRow = row;
this.rows.push(row);
}
for (var idx = 0, length = measures.length; idx < length; idx++) {
measure = measures[idx];
row.children.push(this._cell(className || '', [this._content(measure, tuple)], measure));
}
return length;
},
_content: function (member, tuple) {
return htmlNode(this.template({
member: member,
tuple: tuple
}));
},
_cell: function (className, children, member) {
var cell = element('th', { className: 'k-header' + className }, children);
cell.value = member.caption || member.name;
return cell;
},
_buildRows: function (tuple, memberIdx, parentMember) {
var members = tuple.members;
var member = members[memberIdx];
var nextMember = members[memberIdx + 1];
var row, childRow, children, childrenLength;
var cell, allCell, cellAttr;
var cellChildren = [];
var path;
var idx = 0;
var metadata;
var colSpan;
var collapsed = 0;
var memberCollapsed = 0;
if (member.measure) {
this._measures(member.children, tuple);
return;
}
path = kendo.stringify(buildPath(tuple, memberIdx));
row = this._row(tuple, memberIdx, parentMember);
children = member.children;
childrenLength = children.length;
metadata = this.metadata[path];
if (!metadata) {
this.metadata[path] = metadata = createMetadata(Number(member.levelNum), memberIdx);
metadata.rootLevelNum = Number(this.rootTuple.members[memberIdx].levelNum);
}
this._indexes.push({
path: path,
tuple: tuple
});
if (member.hasChildren) {
if (metadata.expanded === false) {
collapsed = metadata.maxChildren;
row.collapsed += collapsed;
metadata.children = 0;
childrenLength = 0;
}
cellAttr = { className: 'k-icon ' + (childrenLength ? STATE_EXPANDED : STATE_COLLAPSED) };
cellAttr[kendo.attr('path')] = path;
cellChildren.push(element('span', cellAttr));
}
cellChildren.push(this._content(member, tuple));
cell = this._cell(row.notFirst ? ' k-first' : '', cellChildren, member);
row.children.push(cell);
row.colSpan += 1;
if (childrenLength) {
allCell = this._cell(' k-alt', [this._content(member, tuple)], member);
row.children.push(allCell);
for (; idx < childrenLength; idx++) {
childRow = this._buildRows(children[idx], memberIdx, member);
}
colSpan = childRow.colSpan;
collapsed = childRow.collapsed;
cell.attr.colSpan = colSpan;
metadata.children = colSpan;
metadata.members = 1;
row.colSpan += colSpan;
row.collapsed += collapsed;
row.rowSpan = childRow.rowSpan + 1;
if (nextMember) {
if (nextMember.measure) {
colSpan = this._measures(nextMember.children, tuple, ' k-alt');
} else {
childRow = this._buildRows(tuple, memberIdx + 1);
colSpan = childRow.colSpan;
row.collapsed += childRow.collapsed;
memberCollapsed = childRow.collapsed;
}
allCell.attr.colSpan = colSpan;
colSpan -= 1;
metadata.members += colSpan;
row.colSpan += colSpan;
}
} else if (nextMember) {
if (nextMember.measure) {
colSpan = this._measures(nextMember.children, tuple);
} else {
childRow = this._buildRows(tuple, memberIdx + 1);
colSpan = childRow.colSpan;
row.collapsed += childRow.collapsed;
memberCollapsed = childRow.collapsed;
}
metadata.members = colSpan;
if (colSpan > 1) {
cell.attr.colSpan = colSpan;
row.colSpan += colSpan - 1;
}
}
if (metadata.maxMembers < metadata.members + memberCollapsed) {
metadata.maxMembers = metadata.members + memberCollapsed;
}
children = metadata.children + collapsed;
if (metadata.maxChildren < children) {
metadata.maxChildren = children;
}
(allCell || cell).tupleAll = true;
return row;
}
});
var RowBuilder = Class.extend({
init: function () {
this.metadata = {};
},
build: function (tuples) {
var tbody = this._tbody(tuples);
var colgroup = this._colGroup();
return [element('table', null, [
colgroup,
tbody
])];
},
reset: function () {
this.metadata = {};
},
_rowLength: function () {
var children = this.rows[0].children;
var length = 0;
var idx = 0;
var cell = children[idx];
while (cell) {
length += cell.attr.colSpan || 1;
cell = children[++idx];
}
return length;
},
_colGroup: function () {
var length = this._rowLength();
var children = [];
var idx = 0;
for (; idx < length; idx++) {
children.push(element('col', null));
}
return element('colgroup', null, children);
},
_tbody: function (tuples) {
var root = tuples[0];
this.rootTuple = root;
this.rows = [];
this.map = {};
this._indexes = [];
if (root) {
this._buildRows(root, 0);
this._normalize();
} else {
this.rows.push(element('tr', null, [element('td', null, [htmlNode(' ')])]));
}
return element('tbody', null, this.rows);
},
_normalize: function () {
var rows = this.rows;
var rowsLength = rows.length;
var rowIdx = 0;
var members = this.rootTuple.members;
var firstMemberName = members[0].name;
var membersLength = members.length;
var memberIdx = 0;
var row;
var cell;
var maxcolSpan;
var map = this.map;
var allRow;
for (; rowIdx < rowsLength; rowIdx++) {
row = rows[rowIdx];
for (memberIdx = 0; memberIdx < membersLength; memberIdx++) {
maxcolSpan = this[members[memberIdx].name];
cell = row.colSpan['dim' + memberIdx];
if (cell && cell.colSpan < maxcolSpan) {
cell.attr.colSpan = maxcolSpan - cell.colSpan + 1;
}
}
}
row = map[firstMemberName];
allRow = map[firstMemberName + 'all'];
if (row) {
row.children[0].attr.className = 'k-first';
}
if (allRow) {
allRow.children[0].attr.className += ' k-first';
}
},
_row: function (children) {
var row = element('tr', null, children);
row.rowSpan = 1;
row.colSpan = {};
this.rows.push(row);
return row;
},
_content: function (member, tuple) {
return htmlNode(this.template({
member: member,
tuple: tuple
}));
},
_cell: function (className, children, member) {
var cell = element('td', { className: className }, children);
cell.value = member.caption || member.name;
return cell;
},
_buildRows: function (tuple, memberIdx) {
var map = this.map;
var path;
var members = tuple.members;
var member = members[memberIdx];
var nextMember = members[memberIdx + 1];
var children = member.children;
var childrenLength = children.length;
var levelNum = Number(member.levelNum);
var rootName = this.rootTuple.members[memberIdx].name;
var tuplePath = buildPath(tuple, memberIdx - 1).join('');
var rootLevelNum = Number(this.rootTuple.members[memberIdx].levelNum);
var parentName = tuplePath + (rootLevelNum === levelNum ? '' : member.parentName || '');
var row = map[parentName + 'all'] || map[parentName];
var colSpan = levelNum + 1;
var cell, allCell;
var childRow, allRow;
var metadata;
var className;
var cellChildren = [];
var expandIconAttr;
var idx;
if (!row || row.hasChild) {
row = this._row();
} else {
row.hasChild = true;
}
if (member.measure) {
className = row.allCell ? 'k-grid-footer' : '';
row.children.push(this._cell(className, [this._content(children[0], tuple)], children[0]));
row.rowSpan = childrenLength;
for (idx = 1; idx < childrenLength; idx++) {
this._row([this._cell(className, [this._content(children[idx], tuple)], children[idx])]);
}
return row;
}
map[tuplePath + member.name] = row;
path = kendo.stringify(buildPath(tuple, memberIdx));
metadata = this.metadata[path];
if (!metadata) {
this.metadata[path] = metadata = createMetadata(levelNum, memberIdx);
metadata.rootLevelNum = rootLevelNum;
}
this._indexes.push({
path: path,
tuple: tuple
});
if (member.hasChildren) {
if (metadata.expanded === false) {
childrenLength = 0;
metadata.children = 0;
}
expandIconAttr = { className: 'k-icon ' + (childrenLength ? STATE_EXPANDED : STATE_COLLAPSED) };
expandIconAttr[kendo.attr('path')] = path;
cellChildren.push(element('span', expandIconAttr));
}
cellChildren.push(this._content(member, tuple));
className = row.allCell && !childrenLength ? 'k-grid-footer' : '';
cell = this._cell(className, cellChildren, member);
cell.colSpan = colSpan;
row.children.push(cell);
row.colSpan['dim' + memberIdx] = cell;
if (!this[rootName] || this[rootName] < colSpan) {
this[rootName] = colSpan;
}
if (childrenLength) {
row.allCell = false;
row.hasChild = false;
for (idx = 0; idx < childrenLength; idx++) {
childRow = this._buildRows(children[idx], memberIdx);
if (row !== childRow) {
row.rowSpan += childRow.rowSpan;
}
}
if (row.rowSpan > 1) {
cell.attr.rowSpan = row.rowSpan;
}
metadata.children = row.rowSpan;
allCell = this._cell('k-grid-footer', [this._content(member, tuple)], member);
allCell.colSpan = colSpan;
allRow = this._row([allCell]);
allRow.colSpan['dim' + memberIdx] = allCell;
allRow.allCell = true;
map[tuplePath + member.name + 'all'] = allRow;
if (nextMember) {
childRow = this._buildRows(tuple, memberIdx + 1);
allCell.attr.rowSpan = childRow.rowSpan;
}
row.rowSpan += allRow.rowSpan;
metadata.members = allRow.rowSpan;
} else if (nextMember) {
row.hasChild = false;
this._buildRows(tuple, memberIdx + 1);
(allCell || cell).attr.rowSpan = row.rowSpan;
metadata.members = row.rowSpan;
}
if (metadata.maxChildren < metadata.children) {
metadata.maxChildren = metadata.children;
}
if (metadata.maxMembers < metadata.members) {
metadata.maxMembers = metadata.members;
}
return row;
}
});
var ContentBuilder = Class.extend({
init: function () {
this.columnAxis = {};
this.rowAxis = {};
},
build: function (data, columnAxis, rowAxis) {
var index = columnAxis.indexes[0];
var metadata = columnAxis.metadata[index ? index.path : undefined];
this.columnAxis = columnAxis;
this.rowAxis = rowAxis;
this.data = data;
this.rowLength = metadata ? metadata.maxChildren + metadata.maxMembers : columnAxis.measures.length || 1;
if (!this.rowLength) {
this.rowLength = 1;
}
var tbody = this._tbody();
var colgroup = this._colGroup();
return [element('table', null, [
colgroup,
tbody
])];
},
_colGroup: function () {
var length = this.columnAxis.measures.length || 1;
var children = [];
var idx = 0;
if (this.rows[0]) {
length = this.rows[0].children.length;
}
for (; idx < length; idx++) {
children.push(element('col', null));
}
return element('colgroup', null, children);
},
_tbody: function () {
this.rows = [];
if (this.data[0]) {
this.columnIndexes = this._indexes(this.columnAxis, this.rowLength);
this.rowIndexes = this._indexes(this.rowAxis, Math.ceil(this.data.length / this.rowLength));
this._buildRows();
} else {
this.rows.push(element('tr', null, [element('td', null, [htmlNode(' ')])]));
}
return element('tbody', null, this.rows);
},
_indexes: function (axisInfo, total) {
var result = [];
var axisInfoMember;
var indexes = axisInfo.indexes;
var metadata = axisInfo.metadata;
var measures = axisInfo.measures;
var measuresLength = measures.length || 1;
var current;
var dataIdx = 0;
var firstEmpty = 0;
var idx = 0;
var length = indexes.length;
var measureIdx;
var index;
var children;
var skipChildren;
if (!length) {
for (measureIdx = 0; measureIdx < measuresLength; measureIdx++) {
result[measureIdx] = {
index: measureIdx,
measure: measures[measureIdx],
tuple: null
};
}
return result;
}
for (; idx < length; idx++) {
axisInfoMember = indexes[idx];
current = metadata[axisInfoMember.path];
children = current.children + current.members;
skipChildren = 0;
if (children) {
children -= measuresLength;
}
if (current.expanded === false && current.children !== current.maxChildren) {
skipChildren = current.maxChildren;
}
if (current.parentMember && current.levelNum === current.rootLevelNum) {
children = -1;
}
if (children > -1) {
for (measureIdx = 0; measureIdx < measuresLength; measureIdx++) {
index = children + measureIdx;
if (!current.children) {
index += firstEmpty;
}
result[children + firstEmpty + measureIdx] = {
children: children,
index: dataIdx,
measure: measures[measureIdx],
tuple: axisInfoMember.tuple
};
dataIdx += 1;
}
while (result[firstEmpty] !== undefined) {
firstEmpty += 1;
}
}
if (firstEmpty === total) {
break;
}
dataIdx += skipChildren;
}
return result;
},
_buildRows: function () {
var rowIndexes = this.rowIndexes;
var length = rowIndexes.length;
var idx = 0;
for (; idx < length; idx++) {
var rowIndex = rowIndexes[idx];
if (rowIndex) {
this.rows.push(this._buildRow(rowIndex));
}
}
},
_buildRow: function (rowInfo) {
var startIdx = rowInfo.index * this.rowLength;
var columnIndexes = this.columnIndexes;
var length = columnIndexes.length;
var columnInfo;
var cells = [];
var idx = 0;
var templateInfo;
var cell, cellContent;
var attr, dataItem, measure;
for (; idx < length; idx++) {
columnInfo = columnIndexes[idx];
if (columnInfo === undefined) {
continue;
}
attr = {};
if (columnInfo.children) {
attr.className = 'k-alt';
}
cellContent = '';
dataItem = this.data[startIdx + columnInfo.index];
measure = columnInfo.measure || rowInfo.measure;
templateInfo = {
columnTuple: columnInfo.tuple,
rowTuple: rowInfo.tuple,
measure: measure,
dataItem: dataItem
};
if (dataItem.value !== '' && measure && measure.type) {
if (measure.type === 'status') {
cellContent = this.kpiStatusTemplate(templateInfo);
} else if (measure.type === 'trend') {
cellContent = this.kpiTrendTemplate(templateInfo);
}
}
if (!cellContent) {
cellContent = this.dataTemplate(templateInfo);
}
cell = element('td', attr, [htmlNode(cellContent)]);
cell.value = dataItem.value;
cells.push(cell);
}
attr = {};
if (rowInfo.children) {
attr.className = 'k-grid-footer';
}
return element('tr', attr, cells);
}
});
ui.plugin(PivotGrid);
kendo.PivotExcelExporter = kendo.Class.extend({
init: function (options) {
this.options = options;
this.widget = options.widget;
this.dataSource = this.widget.dataSource;
},
_columns: function () {
var columnHeaderTable = this.widget.columnsHeaderTree.children[0];
var rowHeaderTable = this.widget.rowsHeaderTree.children[0];
var columnHeaderLength = columnHeaderTable.children[0].children.length;
var rowHeaderLength = rowHeaderTable.children[0].children.length;
var width = this.widget.options.columnWidth;
var result = [];
var idx;
if (rowHeaderLength && this.dataSource.data()[0]) {
for (idx = 0; idx < rowHeaderLength; idx++) {
result.push({ autoWidth: true });
}
}
for (idx = 0; idx < columnHeaderLength; idx++) {
result.push({
autoWidth: false,
width: width
});
}
return result;
},
_cells: function (rows, type, callback) {
var result = [];
var i = 0;
var length = rows.length;
var cellsLength;
var row, cells;
var j, cell;
for (; i < length; i++) {
row = [];
cells = rows[i].children;
cellsLength = cells.length;
for (j = 0; j < cellsLength; j++) {
cell = cells[j];
row.push({
background: '#7a7a7a',
color: '#fff',
value: cell.value,
colSpan: cell.attr.colSpan || 1,
rowSpan: cell.attr.rowSpan || 1
});
}
if (callback) {
callback(row, i);
}
result.push({
cells: row,
type: type
});
}
return result;
},
_rows: function () {
var columnHeaderTable = this.widget.columnsHeaderTree.children[0];
var rowHeaderTable = this.widget.rowsHeaderTree.children[0];
var columnHeaderLength = columnHeaderTable.children[0].children.length;
var rowHeaderLength = rowHeaderTable.children[0].children.length;
var columnHeaderRows = columnHeaderTable.children[1].children;
var rowHeaderRows = rowHeaderTable.children[1].children;
var contentRows = this.widget.contentTree.children[0].children[1].children;
var columnRows = this._cells(columnHeaderRows, 'header');
if (rowHeaderLength) {
columnRows[0].cells.splice(0, 0, {
background: '#7a7a7a',
color: '#fff',
value: '',
colSpan: rowHeaderLength,
rowSpan: columnHeaderRows.length
});
}
var dataCallback = function (row, index) {
var j = 0;
var cell, value;
var cells = contentRows[index].children;
for (; j < columnHeaderLength; j++) {
cell = cells[j];
value = Number(cell.value);
if (isNaN(value)) {
value = cell.value;
}
row.push({
background: '#dfdfdf',
color: '#333',
value: value,
colSpan: 1,
rowSpan: 1
});
}
};
var rowRows = this._cells(rowHeaderRows, 'data', dataCallback);
return columnRows.concat(rowRows);
},
_freezePane: function () {
var columnHeaderTable = this.widget.columnsHeaderTree.children[0];
var rowHeaderTable = this.widget.rowsHeaderTree.children[0];
var rowHeaderLength = rowHeaderTable.children[0].children.length;
var columnHeaderRows = columnHeaderTable.children[1].children;
return {
colSplit: rowHeaderLength,
rowSplit: columnHeaderRows.length
};
},
workbook: function () {
var promise;
if (this.dataSource.view()[0]) {
promise = $.Deferred();
promise.resolve();
} else {
promise = this.dataSource.fetch();
}
return promise.then($.proxy(function () {
return {
sheets: [{
columns: this._columns(),
rows: this._rows(),
freezePane: this._freezePane(),
filter: null
}]
};
}, this));
}
});
var PivotExcelMixin = {
extend: function (proto) {
proto.events.push('excelExport');
proto.options.excel = $.extend(proto.options.excel, this.options);
proto.saveAsExcel = this.saveAsExcel;
},
options: {
proxyURL: '',
filterable: false,
fileName: 'Export.xlsx'
},
saveAsExcel: function () {
var excel = this.options.excel || {};
var exporter = new kendo.PivotExcelExporter({ widget: this });
exporter.workbook().then($.proxy(function (book) {
if (!this.trigger('excelExport', { workbook: book })) {
var workbook = new kendo.ooxml.Workbook(book);
workbook.toDataURLAsync().then(function (dataURI) {
kendo.saveAs({
dataURI: dataURI,
fileName: book.fileName || excel.fileName,
proxyURL: excel.proxyURL,
forceProxy: excel.forceProxy
});
});
}
}, this));
}
};
kendo.PivotExcelMixin = PivotExcelMixin;
if (kendo.ooxml && kendo.ooxml.Workbook) {
PivotExcelMixin.extend(PivotGrid.prototype);
}
if (kendo.PDFMixin) {
kendo.PDFMixin.extend(PivotGrid.prototype);
PivotGrid.fn._drawPDF = function () {
return this._drawPDFShadow({ width: this.wrapper.width() }, { avoidLinks: this.options.pdf.avoidLinks });
};
}
}(window.kendo.jQuery));
return window.kendo;
}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {
(a3 || a2)();
}));
(function (f, define) {
define('kendo.pivot.fieldmenu', [
'kendo.pivotgrid',
'kendo.menu',
'kendo.window',
'kendo.treeview',
'kendo.dropdownlist'
], f);
}(function () {
var __meta__ = {
id: 'pivot.fieldmenu',
name: 'PivotFieldMenu',
category: 'web',
description: 'The PivotFieldMenu widget allows the user to filter on fields displayed in PivotGrid',
depends: [
'menu',
'window',
'treeview',
'dropdownlist'
],
advanced: true
};
(function ($, undefined) {
var kendo = window.kendo;
var ui = kendo.ui;
var MENU = 'kendoContextMenu';
var proxy = $.proxy;
var NS = '.kendoPivotFieldMenu';
var Widget = ui.Widget;
var FILTER_ITEM = 'k-filter-item';
var ARIA_LABEL = 'aria-label';
var PivotFieldMenu = Widget.extend({
init: function (element, options) {
Widget.fn.init.call(this, element, options);
this._dataSource();
this._layout();
kendo.notify(this);
},
events: [],
options: {
name: 'PivotFieldMenu',
filter: null,
filterable: true,
sortable: true,
messages: {
info: 'Show items with value that:',
sortAscending: 'Sort Ascending',
sortDescending: 'Sort Descending',
filterFields: 'Fields Filter',
filter: 'Filter',
include: 'Include Fields...',
title: 'Fields to include',
clear: 'Clear',
ok: 'OK',
cancel: 'Cancel',
operators: {
contains: 'Contains',
doesnotcontain: 'Does not contain',
startswith: 'Starts with',
endswith: 'Ends with',
eq: 'Is equal to',
neq: 'Is not equal to'
}
}
},
_layout: function () {
var options = this.options;
this.wrapper = $(kendo.template(MENUTEMPLATE)({
ns: kendo.ns,
filterable: options.filterable,
sortable: options.sortable,
messages: options.messages
}));
this.menu = this.wrapper[MENU]({
filter: options.filter,
target: this.element,
orientation: 'vertical',
showOn: 'click',
closeOnClick: false,
open: proxy(this._menuOpen, this),
select: proxy(this._select, this),
copyAnchorStyles: false
}).data(MENU);
this._createWindow();
if (options.filterable) {
this._initFilterForm();
}
},
_initFilterForm: function () {
var filterForm = this.menu.element.find('.' + FILTER_ITEM);
var filterProxy = proxy(this._filter, this);
this._filterOperator = new kendo.ui.DropDownList(filterForm.find('select'));
this._filterValue = filterForm.find('.k-textbox');
this._updateFilterAriaLabel();
filterForm.on('submit' + NS, filterProxy).on('click' + NS, '.k-button-filter', filterProxy).on('click' + NS, '.k-button-clear', proxy(this._reset, this));
},
_setFilterForm: function (expression) {
var filterOperator = this._filterOperator;
var operator = '';
var value = '';
if (expression) {
operator = expression.operator;
value = expression.value;
}
filterOperator.value(operator);
if (!filterOperator.value()) {
filterOperator.select(0);
}
this._filterValue.val(value);
},
_clearFilters: function (member) {
var filter = this.dataSource.filter() || {};
var expressions;
var idx = 0;
var length;
filter.filters = filter.filters || [];
expressions = findFilters(filter, member);
for (length = expressions.length; idx < length; idx++) {
filter.filters.splice(filter.filters.indexOf(expressions[idx]), 1);
}
return filter;
},
_convert: function (value) {
var schema = this.dataSource.options.schema;
var field = ((schema.model || {}).fields || {})[this.currentMember];
if (field) {
if (field.type === 'number') {
value = parseFloat(value);
} else if (field.type === 'boolean') {
value = Boolean($.parseJSON(value));
}
}
return value;
},
_filter: function (e) {
var that = this;
var value = that._convert(that._filterValue.val());
e.preventDefault();
if (value === '') {
that.menu.close();
return;
}
var expression = {
field: that.currentMember,
operator: that._filterOperator.value(),
value: value
};
var filter = that._clearFilters(that.currentMember);
filter.filters.push(expression);
that.dataSource.filter(filter);
that.menu.close();
},
_updateFilterAriaLabel: function () {
var filterForm = this.menu.element.find('.' + FILTER_ITEM);
var selectedOperator = this._filterOperator.value();
var selectedOperatorName = this.options.messages.operators[selectedOperator];
filterForm.find('select').attr(ARIA_LABEL, selectedOperatorName);
},
_reset: function (e) {
var that = this;
var filter = that._clearFilters(that.currentMember);
e.preventDefault();
if (!filter.filters[0]) {
filter = {};
}
that.dataSource.filter(filter);
that._setFilterForm(null);
that.menu.close();
},
_sort: function (dir) {
var field = this.currentMember;
var expressions = this.dataSource.sort() || [];
expressions = removeExpr(expressions, field);
expressions.push({
field: field,
dir: dir
});
this.dataSource.sort(expressions);
this.menu.close();
},
setDataSource: function (dataSource) {
this.options.dataSource = dataSource;
this._dataSource();
},
_dataSource: function () {
this.dataSource = kendo.data.PivotDataSource.create(this.options.dataSource);
},
_createWindow: function () {
var messages = this.options.messages;
this.includeWindow = $(kendo.template(WINDOWTEMPLATE)({ messages: messages })).on('click' + NS, '.k-button-ok', proxy(this._applyIncludes, this)).on('click' + NS, '.k-button-cancel', proxy(this._closeWindow, this));
this.includeWindow = new ui.Window(this.includeWindow, {
title: messages.title,
visible: false,
resizable: false,
open: proxy(this._windowOpen, this)
});
},
_applyIncludes: function (e) {
var checkedNodes = [];
var resultExpression;
var view = this.treeView.dataSource.view();
var rootChecked = view[0].checked;
var filter = this.dataSource.filter();
var existingExpression = findFilters(filter, this.currentMember, 'in')[0];
checkedNodeIds(view, checkedNodes);
if (existingExpression) {
if (rootChecked) {
filter.filters.splice(filter.filters.indexOf(existingExpression), 1);
if (!filter.filters.length) {
filter = {};
}
} else {
existingExpression.value = checkedNodes.join(',');
}
resultExpression = filter;
}
if (checkedNodes.length) {
if (!resultExpression && !rootChecked) {
resultExpression = {
field: this.currentMember,
operator: 'in',
value: checkedNodes.join(',')
};
if (filter) {
filter.filters.push(resultExpression);
resultExpression = filter;
}
}
}
if (resultExpression) {
this.dataSource.filter(resultExpression);
}
this._closeWindow(e);
},
_closeWindow: function (e) {
e.preventDefault();
this.includeWindow.close();
},
_treeViewDataSource: function () {
var that = this;
return kendo.data.HierarchicalDataSource.create({
schema: {
model: {
id: 'uniqueName',
hasChildren: function (item) {
return parseInt(item.childrenCardinality, 10) > 0;
}
}
},
transport: {
read: function (options) {
var restrictions = {};
var node = that.treeView.dataSource.get(options.data.uniqueName);
var name = options.data.uniqueName;
if (!name) {
restrictions.levelUniqueName = that.currentMember + '.[(ALL)]';
} else {
restrictions.memberUniqueName = node.uniqueName.replace(/\&/g, '&');
restrictions.treeOp = 1;
}
that.dataSource.schemaMembers(restrictions).done(function (data) {
checkNodes(that.dataSource.filter(), that.currentMember, data);
options.success(data);
}).fail(options.error);
}
}
});
},
_createTreeView: function (element) {
var that = this;
that.treeView = new ui.TreeView(element, {
autoBind: false,
dataSource: that._treeViewDataSource(),
dataTextField: 'caption',
template: '#: data.item.caption || data.item.name #',
checkboxes: { checkChildren: true },
dataBound: function () {
ui.progress(that.includeWindow.element, false);
}
});
},
_menuOpen: function (e) {
if (!e.event) {
return;
}
var attr = kendo.attr('name');
this.currentMember = $(e.event.target).closest('[' + attr + ']').attr(attr);
if (this.options.filterable) {
this._setFilterForm(findFilters(this.dataSource.filter(), this.currentMember)[0]);
}
},
_select: function (e) {
var item = $(e.item);
$('.k-pivot-filter-window').not(this.includeWindow.element).kendoWindow('close');
if (item.hasClass('k-include-item')) {
this.includeWindow.center().open();
} else if (item.hasClass('k-sort-asc')) {
this._sort('asc');
} else if (item.hasClass('k-sort-desc')) {
this._sort('desc');
} else if (item.hasClass(FILTER_ITEM)) {
this._updateFilterAriaLabel();
}
},
_windowOpen: function () {
if (!this.treeView) {
this._createTreeView(this.includeWindow.element.find('.k-treeview'));
}
ui.progress(this.includeWindow.element, true);
this.treeView.dataSource.read();
},
destroy: function () {
Widget.fn.destroy.call(this);
if (this.menu) {
this.menu.destroy();
this.menu = null;
}
if (this.treeView) {
this.treeView.destroy();
this.treeView = null;
}
if (this.includeWindow) {
this.includeWindow.destroy();
this.includeWindow = null;
}
this.wrapper = null;
this.element = null;
}
});
function removeExpr(expressions, name) {
var result = [];
for (var idx = 0, length = expressions.length; idx < length; idx++) {
if (expressions[idx].field !== name) {
result.push(expressions[idx]);
}
}
return result;
}
function findFilters(filter, member, operator) {
if (!filter) {
return [];
}
filter = filter.filters;
var idx = 0;
var result = [];
var length = filter.length;
var filterOperator;
for (; idx < length; idx++) {
filterOperator = filter[idx].operator;
if ((!operator && filterOperator !== 'in' || filterOperator === operator) && filter[idx].field === member) {
result.push(filter[idx]);
}
}
return result;
}
function checkNodes(filter, member, nodes) {
var values, idx = 0, length = nodes.length;
filter = findFilters(filter, member, 'in')[0];
if (!filter) {
for (; idx < length; idx++) {
nodes[idx].checked = true;
}
} else {
values = filter.value.split(',');
for (; idx < length; idx++) {
nodes[idx].checked = $.inArray(nodes[idx].uniqueName, values) >= 0;
}
}
}
function checkedNodeIds(nodes, checkedNodes) {
var idx, length = nodes.length;
for (idx = 0; idx < length; idx++) {
if (nodes[idx].checked && nodes[idx].level() !== 0) {
checkedNodes.push(nodes[idx].uniqueName);
}
if (nodes[idx].hasChildren) {
checkedNodeIds(nodes[idx].children.view(), checkedNodes);
}
}
}
var LABELMENUTEMPLATE = '' + '' + '
';
var MENUTEMPLATE = '';
var WINDOWTEMPLATE = '