{"version":3,"sources":["kendo.pivotgrid.js"],"names":["f","define","$","undefined","normalizeMeasures","measure","descriptor","name","descriptors","toString","call","map","d","type","normalizeMembers","member","expand","slice","normalizeName","indexOf","accumulateMembers","accumulator","rootTuple","tuple","level","idx","length","children","members","kendo","stringify","buildPath","descriptorsForAxes","tuples","k","result","push","parseJSON","addMissingPathMembers","axis","tupleMembers","found","j","firstTuple","getName","hierarchy","tupleToDescriptors","descriptorsForMembers","measures","tupletoSearch","MEASURES","findExistingTuple","createAggregateGetter","m","measureGetter","getter","field","aggregatorContext","state","aggregate","dataItem","isNumber","val","isNaN","isDate","getTime","flatColumns","columns","concat","sortItemsTree","items","sortFunction","i","parentName","sort","fillSortTree","currentItem","isEmptyObject","childrenMap","extend","addEmptyDataItem","value","fmtValue","ordinal","validateAxis","newAxis","membersCount","adjustDataByColumn","sourceTuples","targetTuples","rowsLength","data","columnIdx","rowIdx","dataIdx","columnsLength","targetColumnsLength","measuresLength","tupleIndex","adjustDataByRow","collection","index","queue","current","shift","apply","normalizeAxis","findDataIndex","memberIndex","counter","Math","max","mergeTuples","target","source","targetMembers","sourceMembers","parsedRoot","equalTuples","first","second","equal","toFind","membersLength","addMembers","len","path","findParentMember","parentMember","parentPath","measurePosition","normalizeTupleMeasures","dataIndex","splice","parseSource","measureIndex","prepareDataOnRows","indices","rowIndex","columnIndex","targetIndex","sourceIndex","calcIndex","buildDataIndices","parseInt","prepareDataOnColumns","spliceIndex","baseHierarchyPath","memberName","parts","split","expandMemberDescriptor","names","sortDescriptor","sortDescriptorForMember","dir","crossJoin","r","pop","crossJoinCommand","tmp","measureNames","join","getRootNames","mapNames","rootNames","rootName","rootLength","expandedIdx","uniquePath","parseDescriptors","l","hierarchyName","expanded","child","root","serializeMembers","crossJoinCommands","command","serializeExpression","expression","operator","format","filterFunctionFormats","serializeFilters","filter","cube","filters","serializeOptions","parentTagName","options","capitalize","key","replace","toUpperCase","asArray","object","translateAxis","memberIdx","captionGetter","unameGetter","levelNameGetter","levelNumGetter","childrenGetter","hierarchyGetter","parentNameGetter","Member","caption","levelName","levelNum","hasChildren","xmlaDiscoverCommands","convertersMap","XmlaTransport","schemaDataReaderMap","xmlaReaderMethods","XmlaDataReader","sortExpr","removeExpr","PivotGrid","element","htmlNode","createMetadata","tupleName","ColumnBuilder","RowBuilder","ContentBuilder","PivotExcelMixin","window","ui","Class","Comparer","Widget","DataSource","outerWidth","_outerWidth","outerHeight","_outerHeight","identity","o","isFunction","CHANGE","ERROR","PROGRESS","STATERESET","AUTO","DIV","NS","ROW_TOTAL_KEY","DATABINDING","DATABOUND","EXPANDMEMBER","COLLAPSEMEMBER","STATE_EXPANDED","STATE_COLLAPSED","HEADER_TEMPLATE","KPISTATUS_TEMPLATE","KPITREND_TEMPLATE","DATACELL_TEMPLATE","LAYOUT_TABLE","AXIS_ROWS","AXIS_COLUMNS","functions","sum","count","average","min","PivotCubeBuilder","init","this","dimensions","_normalizeDescriptors","keyField","fields","_rootTuples","measureAggregators","aggregatorsLength","dimensionsSchema","measureIdx","rootNamesLength","keys","_sortMap","sortDescriptors","mapItem","sortedMaps","sortTree","flattenTree","directParentName","create","_expandedTuples","currentKeys","memberInfo","expandedNames","accumulatorKeys","_findExpandedMember","_asTuples","rootInfo","expandedInfo","_measuresInfo","rowAxis","aggregateNames","resultFuncs","formats","_toDataArray","measuresInfo","rowKeys","columnKeys","aggregates","n","row","column","columnKey","columnMeasureNames","rowMeasureNamesLength","rowMeasureNames","rowLength","columnLength","_addData","resultFunc","_matchDescriptors","getters","parentField","expectedValue","_calculateAggregate","totalItem","aggregator","_processColumns","rowTotal","updateColumn","_measureAggregators","defaultAggregate","measureDescriptors","aggregators","toLowerCase","Error","_buildGetters","_parseDescriptors","parsedDescriptors","_filter","expr","_normalizeFilter","Query","logic","process","measuresRowAxis","columnDescriptors","rowDescriptors","aggregatedData","rows","rowValue","columnGetters","rowGetters","processed","expandedColumns","expandedRows","hasExpandedRows","rowDescriptor","rowName","columnsInfo","rowsInfo","measuresAxis","axes","PivotTransport","transport","discover","read","update","destroy","success","catalog","connection","PivotDataSource","schema","cubes","catalogs","hierarchies","levels","_cubeSchema","cubeBuilder","fn","_columns","_rows","values","_measures","_measuresAxis","_skipNormalize","_axes","uniqueName","defaultHierarchy","proxy","response","restrictions","levelUniqueName","memberUniqueName","schemaData","dataGetter","_rawData","distinct","treeOp","childrenCardinality","dimensionUniqueName","hierarchyUniqueName","serverSorting","serverPaging","serverFiltering","serverGrouping","serverAggregates","_mergeState","_clearAxesData","query","rowsAxisDescriptors","columnsAxisDescriptors","_expandPath","origin","other","memberToExpand","_lastExpanded","_descriptorsForAxis","_query","_process","e","_view","trigger","that","page","pageSize","group","_data","_params","_updateLocalData","_pristineData","Deferred","resolve","promise","expandColumn","expandRow","originalData","reader","_processResult","processedData","columnIndexes","rowIndexes","resultAxis","axisToSkip","hasColumnTuples","_requestData","_rowMeasures","_normalizeTuples","_columnMeasures","_normalizeData","_mergeAxes","_readData","newData","_createTuple","buildRoot","_hasRoot","isRoot","sourceAxes","startIndex","mergedColumns","mergedRows","offset","columnMeasures","rowMeasures","oldRowsLength","newRowsLength","oldColumnsLength","newColumnsLength","_mergeColumnData","_mergeRowData","toAdd","toJSON","drop","_observe","_ranges","_addRange","_total","_pristineTotal","last","roots","indexes","_addMissingDataItems","metadata","_normalizeOrdinals","lastOrdinal","converter","deferred","parse","_handleCustomErrors","error","status","reject","done","schemaMeasures","catalogName","cubeName","schemaKPIs","kpis","schemaDimensions","schemaHierarchies","dimensionName","schemaLevels","schemaCubes","schemaCatalogs","schemaMembers","dataSource","contains","doesnotcontain","startswith","endswith","eq","neq","properties","Catalog","RemoteTransport","originalOptions","url","setup","dataType","contentType","parameterMap","ajax","description","groupName","displayFolder","defaultFormat","goal","trend","statusGraphic","trendGraphic","defaultMember","orderingProperty","XmlDataReader","_extend","methodName","option","xml","errors","fault","faultstring","faultcode","cells","ordinalGetter","valueGetter","fmtValueGetter","_mapSchema","obj","transports","xmla","readers","expressions","PivotSettingTarget","addClass","_refreshHandler","refresh","template","ns","enabled","emptyTemplate","_sortable","on","closest","attr","hasClass","remove","sortable","currentTarget","find","filterable","fieldMenu","PivotFieldMenu","messages","setting","empty","setDataSource","unbind","kendoSortable","connectWith","hint","cursor","start","item","focus","blur","change","action","add","move","newIndex","_indexOf","_isKPI","validate","isMeasure","isArray","sortExpressions","_sort","allowUnsort","skipExpr","html","sortIcon","_sortIcon","off","icon","columnBuilder","rowBuilder","_dataSource","_bindConfigurator","_wrapper","_createLayout","_columnBuilder","_rowBuilder","_contentBuilder","_templates","columnsHeader","rowsHeader","eventName","request","button","builder","eventArgs","parent","is","childrenLoaded","maxChildren","toggleClass","_scrollable","autoBind","fetch","notify","events","reorderable","height","columnWidth","configurator","columnHeaderTemplate","rowHeaderTemplate","dataCellTemplate","kpiStatusTemplate","kpiTrendTemplate","measureFields","columnFields","rowFields","columnTemplate","rowTemplate","dataTemplate","useWithBlock","kendoPivotConfigurator","cellInfoByElement","cellInfo","contentBuilder","columnInfo","rowInfo","columnTuple","rowTuple","view","measuresTarget","rowsTarget","columnsTarget","setOptions","clearTimeout","_headerReflowTimeout","_stateResetHandler","_progressHandler","_errorHandler","_requestStart","_stateReset","_error","bind","_progress","reset","wrapper","css","_measureFields","_createSettingTarget","icons","_initSettingTargets","layoutTable","leftContainer","rightContainer","gridWrapper","wrap","support","scrollbar","content","append","columnsHeaderTree","dom","Tree","rowsHeaderTree","contentTree","toggle","progress","_resize","firstChild","_setSectionsWidth","_setSectionsHeight","_setContentWidth","_setContentHeight","_columnHeaderReflow","columnTable","browser","mozilla","setTimeout","leftColumn","width","measureFieldsHeight","columnFieldsHeight","rowFieldsHeight","innerHeight","columnsHeight","padding","firstRowHeight","secondRowHeight","contentTable","calculatedWidth","minWidth","ceil","_resetColspan","skipScrollbar","offsetHeight","clientHeight","cell","_colspan","_layoutTimeout","_axisMeasures","hasMeasure","touchScroller","columnAxis","render","build","_indexes","contentResized","movable","scrollLeft","sender","x","scrollTop","y","scroll","_wheelScroll","delta","ctrlKey","wheelDeltaY","preventDefault","one","maxMembers","tbody","_tbody","colgroup","_colGroup","_rowLength","_buildRows","_normalize","cellsLength","cellIdx","rowSpan","tupleAll","_rowIndex","colSpan","_row","parentRow","rowKey","notFirst","collapsed","className","measureRow","_cell","_content","childRow","childrenLength","allCell","cellAttr","nextMember","cellChildren","memberCollapsed","rootLevelNum","maxcolSpan","allRow","firstMemberName","expandIconAttr","tuplePath","hasChild","axisInfo","total","axisInfoMember","skipChildren","firstEmpty","_buildRow","templateInfo","cellContent","startIdx","plugin","PivotExcelExporter","widget","columnHeaderTable","rowHeaderTable","columnHeaderLength","rowHeaderLength","autoWidth","_cells","callback","background","color","dataCallback","rowRows","columnHeaderRows","rowHeaderRows","contentRows","columnRows","_freezePane","colSplit","rowSplit","workbook","then","sheets","freezePane","proto","excel","saveAsExcel","proxyURL","fileName","exporter","book","ooxml","Workbook","toDataURLAsync","dataURI","saveAs","forceProxy","prototype","PDFMixin","_drawPDF","_drawPDFShadow","avoidLinks","pdf","jQuery","amd","a1","a2","a3"],"mappings":"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","file":"kendo.pivotgrid.min.js","sourcesContent":["/*!\n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n\n*/\n(function (f, define) {\n    define('kendo.pivotgrid', [\n        'kendo.dom',\n        'kendo.data'\n    ], f);\n}(function () {\n    var __meta__ = {\n        id: 'pivotgrid',\n        name: 'PivotGrid',\n        category: 'web',\n        description: 'The PivotGrid widget is a data summarization tool.',\n        depends: [\n            'dom',\n            'data',\n            'data.xml',\n            'sortable'\n        ],\n        features: [\n            {\n                id: 'pivotgrid-configurator',\n                name: 'Configurator',\n                description: 'The PivotConfigurator widget allows the user to select data slices displayed in PivotGrid',\n                depends: ['pivot.configurator']\n            },\n            {\n                id: 'pivotgrid-filtering',\n                name: 'Filtering',\n                description: 'Support for filtering',\n                depends: ['pivot.fieldmenu']\n            },\n            {\n                id: 'pivotgrid-excel-export',\n                name: 'Excel export',\n                description: 'Export pivot grid data as Excel spreadsheet',\n                depends: ['ooxml']\n            },\n            {\n                id: 'pivotgrid-pdf-export',\n                name: 'PDF export',\n                description: 'Export pivot grid data as PDF',\n                depends: [\n                    'pdf',\n                    'drawing'\n                ]\n            },\n            {\n                id: 'mobile-scroller',\n                name: 'Mobile scroller',\n                description: 'Support for kinetic scrolling in mobile device',\n                depends: ['mobile.scroller']\n            }\n        ]\n    };\n    (function ($, undefined) {\n        var kendo = window.kendo, ui = kendo.ui, Class = kendo.Class, Comparer = kendo.data.Comparer, Widget = ui.Widget, DataSource = kendo.data.DataSource, outerWidth = kendo._outerWidth, outerHeight = kendo._outerHeight, toString = {}.toString, identity = function (o) {\n                return o;\n            }, map = $.map, extend = $.extend, isFunction = kendo.isFunction, CHANGE = 'change', ERROR = 'error', MEASURES = 'Measures', PROGRESS = 'progress', STATERESET = 'stateReset', AUTO = 'auto', DIV = '<div></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 = '<span>#: data.member.caption || data.member.name #</span>', KPISTATUS_TEMPLATE = '<span class=\"k-icon k-i-kpi-status-#=data.dataItem.value > 0 ? \"open\" : data.dataItem.value < 0 ? \"deny\" : \"hold\"#\" title=\"#:data.dataItem.value#\"></span>', KPITREND_TEMPLATE = '<span class=\"k-icon k-i-kpi-trend-#=data.dataItem.value > 0 ? \"increase\" : data.dataItem.value < 0 ? \"decrease\" : \"equal\"#\" title=\"#:data.dataItem.value#\"></span>', DATACELL_TEMPLATE = '#= data.dataItem ? kendo.htmlEncode(data.dataItem.fmtValue || data.dataItem.value) || \"&nbsp;\" : \"&nbsp;\" #', LAYOUT_TABLE = '<table class=\"k-pivot-layout\">' + '<tr>' + '<td>' + '<div class=\"k-pivot-rowheaders\"></div>' + '</td>' + '<td>' + '<div class=\"k-pivot-table k-state-default\"></div>' + '</td>' + '</tr>' + '</table>';\n        var AXIS_ROWS = 'rows';\n        var AXIS_COLUMNS = 'columns';\n        function normalizeMeasures(measure) {\n            var descriptor = typeof measure === 'string' ? [{ name: measure }] : measure;\n            var descriptors = toString.call(descriptor) === '[object Array]' ? descriptor : descriptor !== undefined ? [descriptor] : [];\n            return map(descriptors, function (d) {\n                if (typeof d === 'string') {\n                    return { name: d };\n                }\n                return {\n                    name: d.name,\n                    type: d.type\n                };\n            });\n        }\n        function normalizeMembers(member) {\n            var descriptor = typeof member === 'string' ? [{\n                    name: [member],\n                    expand: false\n                }] : member;\n            var descriptors = toString.call(descriptor) === '[object Array]' ? descriptor : descriptor !== undefined ? [descriptor] : [];\n            return map(descriptors, function (d) {\n                if (typeof d === 'string') {\n                    return {\n                        name: [d],\n                        expand: false\n                    };\n                }\n                return {\n                    name: toString.call(d.name) === '[object Array]' ? d.name.slice() : [d.name],\n                    expand: d.expand\n                };\n            });\n        }\n        function normalizeName(name) {\n            if (name.indexOf(' ') !== -1) {\n                name = '[\"' + name + '\"]';\n            }\n            return name;\n        }\n        function accumulateMembers(accumulator, rootTuple, tuple, level) {\n            var idx, length;\n            var children;\n            var member;\n            if (!tuple) {\n                tuple = rootTuple;\n            }\n            if (!level) {\n                level = 0;\n            }\n            member = tuple.members[level];\n            if (!member || member.measure) {\n                return;\n            }\n            children = member.children;\n            length = children.length;\n            if (tuple === rootTuple) {\n                accumulator[kendo.stringify([member.name])] = !!length;\n            } else if (length) {\n                accumulator[kendo.stringify(buildPath(tuple, level))] = true;\n            }\n            if (length) {\n                for (idx = 0; idx < length; idx++) {\n                    accumulateMembers(accumulator, rootTuple, children[idx], level);\n                }\n            }\n            accumulateMembers(accumulator, rootTuple, tuple, level + 1);\n        }\n        function descriptorsForAxes(tuples) {\n            var result = {};\n            if (tuples.length) {\n                accumulateMembers(result, tuples[0]);\n            }\n            var descriptors = [];\n            for (var k in result) {\n                descriptors.push({\n                    name: $.parseJSON(k),\n                    expand: result[k]\n                });\n            }\n            return descriptors;\n        }\n        function addMissingPathMembers(members, axis) {\n            var tuples = axis.tuples || [];\n            var firstTuple = tuples[0];\n            if (firstTuple && members.length < firstTuple.members.length) {\n                var tupleMembers = firstTuple.members;\n                for (var idx = 0; idx < tupleMembers.length; idx++) {\n                    if (tupleMembers[idx].measure) {\n                        continue;\n                    }\n                    var found = false;\n                    for (var j = 0; j < members.length; j++) {\n                        if (getName(members[j]).indexOf(tupleMembers[idx].hierarchy) === 0) {\n                            found = true;\n                            break;\n                        }\n                    }\n                    if (!found) {\n                        members.push({\n                            name: [tupleMembers[idx].name],\n                            expand: false\n                        });\n                    }\n                }\n            }\n        }\n        function tupleToDescriptors(tuple) {\n            var result = [];\n            var members = tuple.members;\n            for (var idx = 0; idx < members.length; idx++) {\n                if (members[idx].measure) {\n                    continue;\n                }\n                result.push({\n                    name: [members[idx].name],\n                    expand: members[idx].children.length > 0\n                });\n            }\n            return result;\n        }\n        function descriptorsForMembers(axis, members, measures) {\n            axis = axis || {};\n            addMissingPathMembers(members, axis);\n            if (measures.length > 1) {\n                members.push({\n                    name: MEASURES,\n                    measure: true,\n                    children: normalizeMembers(measures)\n                });\n            }\n            var tupletoSearch = { members: members };\n            if (axis.tuples) {\n                var result = findExistingTuple(axis.tuples, tupletoSearch);\n                if (result.tuple) {\n                    members = tupleToDescriptors(result.tuple);\n                }\n            }\n            return members;\n        }\n        function createAggregateGetter(m) {\n            var measureGetter = kendo.getter(m.field, true);\n            return function (aggregatorContext, state) {\n                return m.aggregate(measureGetter(aggregatorContext.dataItem), state, aggregatorContext);\n            };\n        }\n        function isNumber(val) {\n            return typeof val === 'number' && !isNaN(val);\n        }\n        function isDate(val) {\n            return val && val.getTime;\n        }\n        var functions = {\n            sum: function (value, state) {\n                var accumulator = state.accumulator;\n                if (!isNumber(accumulator)) {\n                    accumulator = value;\n                } else if (isNumber(value)) {\n                    accumulator += value;\n                }\n                return accumulator;\n            },\n            count: function (value, state) {\n                return (state.accumulator || 0) + 1;\n            },\n            average: {\n                aggregate: function (value, state) {\n                    var accumulator = state.accumulator;\n                    if (state.count === undefined) {\n                        state.count = 0;\n                    }\n                    if (!isNumber(accumulator)) {\n                        accumulator = value;\n                    } else if (isNumber(value)) {\n                        accumulator += value;\n                    }\n                    if (isNumber(value)) {\n                        state.count++;\n                    }\n                    return accumulator;\n                },\n                result: function (state) {\n                    var accumulator = state.accumulator;\n                    if (isNumber(accumulator)) {\n                        accumulator = accumulator / state.count;\n                    }\n                    return accumulator;\n                }\n            },\n            max: function (value, state) {\n                var accumulator = state.accumulator;\n                if (!isNumber(accumulator) && !isDate(accumulator)) {\n                    accumulator = value;\n                }\n                if (accumulator < value && (isNumber(value) || isDate(value))) {\n                    accumulator = value;\n                }\n                return accumulator;\n            },\n            min: function (value, state) {\n                var accumulator = state.accumulator;\n                if (!isNumber(accumulator) && !isDate(accumulator)) {\n                    accumulator = value;\n                }\n                if (accumulator > value && (isNumber(value) || isDate(value))) {\n                    accumulator = value;\n                }\n                return accumulator;\n            }\n        };\n        var PivotCubeBuilder = Class.extend({\n            init: function (options) {\n                this.options = extend({}, this.options, options);\n                this.dimensions = this._normalizeDescriptors('field', this.options.dimensions);\n                this.measures = this._normalizeDescriptors('name', this.options.measures);\n            },\n            _normalizeDescriptors: function (keyField, descriptors) {\n                descriptors = descriptors || {};\n                var fields = {};\n                var field;\n                if (toString.call(descriptors) === '[object Array]') {\n                    for (var idx = 0, length = descriptors.length; idx < length; idx++) {\n                        field = descriptors[idx];\n                        if (typeof field === 'string') {\n                            fields[field] = {};\n                        } else if (field[keyField]) {\n                            fields[field[keyField]] = field;\n                        }\n                    }\n                    descriptors = fields;\n                }\n                return descriptors;\n            },\n            _rootTuples: function (rootNames, measureAggregators) {\n                var aggregatorsLength = measureAggregators.length || 1;\n                var dimensionsSchema = this.dimensions || [];\n                var root, name, parts;\n                var measureIdx = 0;\n                var idx;\n                var rootNamesLength = rootNames.length;\n                var result = [];\n                var keys = [];\n                if (rootNamesLength || measureAggregators.length) {\n                    for (measureIdx = 0; measureIdx < aggregatorsLength; measureIdx++) {\n                        root = { members: [] };\n                        for (idx = 0; idx < rootNamesLength; idx++) {\n                            name = rootNames[idx];\n                            parts = name.split('&');\n                            root.members[root.members.length] = {\n                                children: [],\n                                caption: (dimensionsSchema[name] || {}).caption || 'All',\n                                name: name,\n                                levelName: name,\n                                levelNum: '0',\n                                hasChildren: true,\n                                parentName: parts.length > 1 ? parts[0] : undefined,\n                                hierarchy: name\n                            };\n                        }\n                        if (aggregatorsLength > 1) {\n                            root.members[root.members.length] = {\n                                children: [],\n                                caption: measureAggregators[measureIdx].caption,\n                                name: measureAggregators[measureIdx].descriptor.name,\n                                levelName: 'MEASURES',\n                                levelNum: '0',\n                                hasChildren: false,\n                                parentName: undefined,\n                                hierarchy: 'MEASURES'\n                            };\n                        }\n                        result[result.length] = root;\n                    }\n                    keys.push(ROW_TOTAL_KEY);\n                }\n                return {\n                    keys: keys,\n                    tuples: result\n                };\n            },\n            _sortMap: function (map, sortDescriptors) {\n                var sortedMaps = [];\n                var sortTree = [];\n                var flattenTree = [];\n                var mapItem;\n                var key;\n                for (key in map) {\n                    if (!map[key].directParentName) {\n                        sortTree.push($.extend({}, {\n                            name: key,\n                            parentName: map[key].parentName\n                        }));\n                    }\n                }\n                if (!sortTree.length) {\n                    for (key in map) {\n                        sortTree.push($.extend({}, {\n                            name: key,\n                            parentName: map[key].parentName\n                        }));\n                    }\n                }\n                fillSortTree(sortTree, map);\n                for (var i = 0; i < sortDescriptors.length; i++) {\n                    sortItemsTree(sortDescriptors[i].field.split('.').pop(), sortTree, Comparer.create({\n                        field: 'name',\n                        dir: sortDescriptors[i].dir\n                    }));\n                }\n                flattenTree = flatColumns(sortTree);\n                for (var j = 0; j < flattenTree.length; j++) {\n                    mapItem = map[flattenTree[j].name];\n                    mapItem.index = j;\n                    sortedMaps[j] = mapItem;\n                }\n                return sortedMaps;\n            },\n            _expandedTuples: function (map, expanded, measureAggregators, sortDescriptors) {\n                var aggregatorsLength = measureAggregators.length || 1;\n                var dimensionsSchema = this.dimensions || [];\n                var measureIdx;\n                var tuple;\n                var key;\n                var mapItem;\n                var current;\n                var currentKeys;\n                var accumulator = [];\n                var accumulatorKeys = [];\n                var memberInfo;\n                var expandedNames;\n                var parts;\n                var name;\n                var idx;\n                if (sortDescriptors && sortDescriptors.length && !$.isEmptyObject(map)) {\n                    map = this._sortMap(map, sortDescriptors);\n                }\n                for (key in map) {\n                    mapItem = map[key];\n                    memberInfo = this._findExpandedMember(expanded, mapItem.uniquePath);\n                    current = accumulator[memberInfo.index] || [];\n                    currentKeys = accumulatorKeys[memberInfo.index] || [];\n                    expandedNames = memberInfo.member.names;\n                    for (measureIdx = 0; measureIdx < aggregatorsLength; measureIdx++) {\n                        tuple = { members: [] };\n                        for (idx = 0; idx < expandedNames.length; idx++) {\n                            if (idx === memberInfo.member.expandedIdx) {\n                                tuple.members[tuple.members.length] = {\n                                    children: [],\n                                    caption: mapItem.value,\n                                    name: mapItem.name,\n                                    hasChildren: false,\n                                    levelNum: 1,\n                                    levelName: mapItem.parentName + mapItem.name,\n                                    parentName: mapItem.parentName,\n                                    hierarchy: mapItem.parentName + mapItem.name\n                                };\n                                if (measureIdx === 0) {\n                                    currentKeys.push(buildPath(tuple, idx).join(''));\n                                }\n                            } else {\n                                name = expandedNames[idx];\n                                parts = name.split('&');\n                                tuple.members[tuple.members.length] = {\n                                    children: [],\n                                    caption: (dimensionsSchema[name] || {}).caption || 'All',\n                                    name: name,\n                                    levelName: name,\n                                    levelNum: '0',\n                                    hasChildren: true,\n                                    parentName: parts.length > 1 ? parts[0] : undefined,\n                                    hierarchy: name\n                                };\n                            }\n                        }\n                        if (aggregatorsLength > 1) {\n                            tuple.members[tuple.members.length] = {\n                                children: [],\n                                caption: measureAggregators[measureIdx].caption,\n                                name: measureAggregators[measureIdx].descriptor.name,\n                                levelName: 'MEASURES',\n                                levelNum: '0',\n                                hasChildren: true,\n                                parentName: undefined,\n                                hierarchy: 'MEASURES'\n                            };\n                        }\n                        current[current.length] = tuple;\n                    }\n                    accumulator[memberInfo.index] = current;\n                    accumulatorKeys[memberInfo.index] = currentKeys;\n                }\n                return {\n                    keys: accumulatorKeys,\n                    tuples: accumulator\n                };\n            },\n            _findExpandedMember: function (members, parentName) {\n                for (var idx = 0; idx < members.length; idx++) {\n                    if (members[idx].uniquePath === parentName) {\n                        return {\n                            member: members[idx],\n                            index: idx\n                        };\n                    }\n                }\n            },\n            _asTuples: function (map, descriptor, measureAggregators, sortDescriptors) {\n                measureAggregators = measureAggregators || [];\n                var rootInfo = this._rootTuples(descriptor.root, measureAggregators);\n                var expandedInfo = this._expandedTuples(map, descriptor.expanded, measureAggregators, sortDescriptors);\n                return {\n                    keys: [].concat.apply(rootInfo.keys, expandedInfo.keys),\n                    tuples: [].concat.apply(rootInfo.tuples, expandedInfo.tuples)\n                };\n            },\n            _measuresInfo: function (measures, rowAxis) {\n                var idx = 0;\n                var length = measures && measures.length;\n                var aggregateNames = [];\n                var resultFuncs = {};\n                var formats = {};\n                var descriptors = this.measures || {};\n                var measure;\n                var name;\n                for (; idx < length; idx++) {\n                    name = measures[idx].descriptor.name;\n                    measure = descriptors[name] || {};\n                    aggregateNames.push(name);\n                    if (measure.result) {\n                        resultFuncs[name] = measure.result;\n                    }\n                    if (measure.format) {\n                        formats[name] = measure.format;\n                    }\n                }\n                return {\n                    names: aggregateNames,\n                    formats: formats,\n                    resultFuncs: resultFuncs,\n                    rowAxis: rowAxis\n                };\n            },\n            _toDataArray: function (map, measuresInfo, rowKeys, columnKeys) {\n                var result = [];\n                var aggregates;\n                var name, i, j, k, n;\n                var row, column, columnKey;\n                var rowMeasureNamesLength = 1;\n                var rowMeasureNames = [];\n                var columnMeasureNames;\n                var rowLength = rowKeys.length || 1;\n                var columnLength = columnKeys.length || 1;\n                if (measuresInfo.rowAxis) {\n                    rowMeasureNames = measuresInfo.names;\n                    rowMeasureNamesLength = rowMeasureNames.length;\n                } else {\n                    columnMeasureNames = measuresInfo.names;\n                }\n                for (i = 0; i < rowLength; i++) {\n                    row = map[rowKeys[i] || ROW_TOTAL_KEY];\n                    for (n = 0; n < rowMeasureNamesLength; n++) {\n                        if (measuresInfo.rowAxis) {\n                            columnMeasureNames = [rowMeasureNames[n]];\n                        }\n                        for (j = 0; j < columnLength; j++) {\n                            columnKey = columnKeys[j] || ROW_TOTAL_KEY;\n                            column = row.items[columnKey];\n                            if (columnKey === ROW_TOTAL_KEY) {\n                                aggregates = row.aggregates;\n                            } else {\n                                aggregates = column ? column.aggregates : {};\n                            }\n                            for (k = 0; k < columnMeasureNames.length; k++) {\n                                name = columnMeasureNames[k];\n                                this._addData(result, aggregates[name], measuresInfo.formats[name], measuresInfo.resultFuncs[name]);\n                            }\n                        }\n                    }\n                }\n                return result;\n            },\n            _addData: function (result, value, format, resultFunc) {\n                var fmtValue = '';\n                var ordinal;\n                if (value) {\n                    value = resultFunc ? resultFunc(value) : value.accumulator;\n                    fmtValue = format ? kendo.format(format, value) : value;\n                }\n                ordinal = result.length;\n                result[ordinal] = {\n                    ordinal: ordinal,\n                    value: value || '',\n                    fmtValue: fmtValue\n                };\n            },\n            _matchDescriptors: function (dataItem, descriptor, getters) {\n                var parts;\n                var parentField;\n                var expectedValue;\n                var names = descriptor.names;\n                var idx = descriptor.expandedIdx;\n                var value;\n                while (idx > 0) {\n                    parts = names[--idx].split('&');\n                    if (parts.length > 1) {\n                        parentField = parts[0];\n                        expectedValue = parts[1];\n                        value = getters[parentField](dataItem);\n                        value = value !== undefined && value !== null ? value.toString() : value;\n                        if (value != expectedValue) {\n                            return false;\n                        }\n                    }\n                }\n                return true;\n            },\n            _calculateAggregate: function (measureAggregators, aggregatorContext, totalItem) {\n                var result = {};\n                var state;\n                var name;\n                for (var measureIdx = 0; measureIdx < measureAggregators.length; measureIdx++) {\n                    name = measureAggregators[measureIdx].descriptor.name;\n                    state = totalItem.aggregates[name] || {};\n                    state.accumulator = measureAggregators[measureIdx].aggregator(aggregatorContext, state);\n                    result[name] = state;\n                }\n                return result;\n            },\n            _processColumns: function (measureAggregators, descriptors, getters, columns, aggregatorContext, rowTotal, state, updateColumn) {\n                var value;\n                var descriptor;\n                var column;\n                var totalItem;\n                var key, name, parentName, path;\n                var dataItem = aggregatorContext.dataItem;\n                var idx = 0;\n                for (; idx < descriptors.length; idx++) {\n                    descriptor = descriptors[idx];\n                    if (!this._matchDescriptors(dataItem, descriptor, getters)) {\n                        continue;\n                    }\n                    path = descriptor.names.slice(0, descriptor.expandedIdx).join('');\n                    name = descriptor.names[descriptor.expandedIdx];\n                    value = getters[name](dataItem);\n                    value = value !== undefined && value !== null ? value.toString() : value;\n                    parentName = name;\n                    name = name + '&' + value;\n                    key = path + name;\n                    column = columns[key] || {\n                        index: state.columnIndex,\n                        parentName: parentName,\n                        name: name,\n                        directParentName: path.indexOf('&') !== -1 ? path : '',\n                        uniquePath: path + parentName,\n                        childrenMap: {},\n                        value: value\n                    };\n                    if (path && columns[path] && !columns[path].childrenMap[path + parentName + '&' + value]) {\n                        columns[path].childrenMap[path + parentName + '&' + value] = true;\n                    }\n                    totalItem = rowTotal.items[key] || { aggregates: {} };\n                    rowTotal.items[key] = {\n                        index: column.index,\n                        aggregates: this._calculateAggregate(measureAggregators, aggregatorContext, totalItem)\n                    };\n                    if (updateColumn) {\n                        if (!columns[key]) {\n                            state.columnIndex++;\n                        }\n                        columns[key] = column;\n                    }\n                }\n            },\n            _measureAggregators: function (options) {\n                var measureDescriptors = options.measures || [];\n                var measures = this.measures || {};\n                var aggregators = [];\n                var descriptor, measure, idx, length;\n                var defaultAggregate, aggregate;\n                if (measureDescriptors.length) {\n                    for (idx = 0, length = measureDescriptors.length; idx < length; idx++) {\n                        descriptor = measureDescriptors[idx];\n                        measure = measures[descriptor.name];\n                        defaultAggregate = null;\n                        if (measure) {\n                            aggregate = measure.aggregate;\n                            if (typeof aggregate === 'string') {\n                                defaultAggregate = functions[aggregate.toLowerCase()];\n                                if (!defaultAggregate) {\n                                    throw new Error('There is no such aggregate function');\n                                }\n                                measure.aggregate = defaultAggregate.aggregate || defaultAggregate;\n                                measure.result = defaultAggregate.result;\n                            }\n                            aggregators.push({\n                                descriptor: descriptor,\n                                caption: measure.caption,\n                                result: measure.result,\n                                aggregator: createAggregateGetter(measure)\n                            });\n                        }\n                    }\n                } else {\n                    aggregators.push({\n                        descriptor: { name: 'default' },\n                        caption: 'default',\n                        aggregator: function () {\n                            return 1;\n                        }\n                    });\n                }\n                return aggregators;\n            },\n            _buildGetters: function (names) {\n                var result = {};\n                var parts;\n                var name;\n                for (var idx = 0; idx < names.length; idx++) {\n                    name = names[idx];\n                    parts = name.split('&');\n                    if (parts.length > 1) {\n                        result[parts[0]] = kendo.getter(parts[0], true);\n                    } else {\n                        result[name] = kendo.getter(normalizeName(name), true);\n                    }\n                }\n                return result;\n            },\n            _parseDescriptors: function (descriptors) {\n                var parsedDescriptors = parseDescriptors(descriptors);\n                var rootNames = getRootNames(parsedDescriptors.root);\n                var expanded = parsedDescriptors.expanded;\n                var result = [];\n                for (var idx = 0; idx < expanded.length; idx++) {\n                    result.push(mapNames(expanded[idx].name, rootNames));\n                }\n                return {\n                    root: rootNames,\n                    expanded: result\n                };\n            },\n            _filter: function (data, filter) {\n                if (!filter) {\n                    return data;\n                }\n                var expr;\n                var idx = 0;\n                var filters = filter.filters;\n                for (; idx < filters.length; idx++) {\n                    expr = filters[idx];\n                    if (expr.operator === 'in') {\n                        filters[idx] = this._normalizeFilter(expr);\n                    }\n                }\n                return new kendo.data.Query(data).filter(filter).data;\n            },\n            _normalizeFilter: function (filter) {\n                var value = filter.value.split(',');\n                var result = [];\n                if (!value.length) {\n                    return value;\n                }\n                for (var idx = 0; idx < value.length; idx++) {\n                    result.push({\n                        field: filter.field,\n                        operator: 'eq',\n                        value: value[idx]\n                    });\n                }\n                return {\n                    logic: 'or',\n                    filters: result\n                };\n            },\n            process: function (data, options) {\n                data = data || [];\n                options = options || {};\n                data = this._filter(data, options.filter);\n                var measures = options.measures || [];\n                var measuresRowAxis = options.measuresAxis === 'rows';\n                var columnDescriptors = options.columns || [];\n                var rowDescriptors = options.rows || [];\n                if (!columnDescriptors.length && rowDescriptors.length && (!measures.length || measures.length && measuresRowAxis)) {\n                    columnDescriptors = rowDescriptors;\n                    rowDescriptors = [];\n                    measuresRowAxis = false;\n                }\n                if (!columnDescriptors.length && !rowDescriptors.length) {\n                    measuresRowAxis = false;\n                }\n                if (!columnDescriptors.length && measures.length) {\n                    columnDescriptors = normalizeMembers(options.measures);\n                }\n                columnDescriptors = this._parseDescriptors(columnDescriptors);\n                rowDescriptors = this._parseDescriptors(rowDescriptors);\n                var aggregatedData = {};\n                var columns = {};\n                var rows = {};\n                var rowValue;\n                var state = { columnIndex: 0 };\n                var measureAggregators = this._measureAggregators(options);\n                var columnGetters = this._buildGetters(columnDescriptors.root);\n                var rowGetters = this._buildGetters(rowDescriptors.root);\n                var processed = false;\n                var expandedColumns = columnDescriptors.expanded;\n                var expandedRows = rowDescriptors.expanded;\n                var dataItem;\n                var aggregatorContext;\n                var hasExpandedRows = expandedRows.length !== 0;\n                var rowIdx, rowDescriptor, rowName, rowTotal;\n                var key, path, parentName, value;\n                var columnsInfo, rowsInfo;\n                var length = data.length;\n                var idx = 0;\n                if (columnDescriptors.root.length || rowDescriptors.root.length) {\n                    processed = true;\n                    for (idx = 0; idx < length; idx++) {\n                        dataItem = data[idx];\n                        aggregatorContext = {\n                            dataItem: dataItem,\n                            index: idx\n                        };\n                        rowTotal = aggregatedData[ROW_TOTAL_KEY] || {\n                            items: {},\n                            aggregates: {}\n                        };\n                        this._processColumns(measureAggregators, expandedColumns, columnGetters, columns, aggregatorContext, rowTotal, state, !hasExpandedRows);\n                        rowTotal.aggregates = this._calculateAggregate(measureAggregators, aggregatorContext, rowTotal);\n                        aggregatedData[ROW_TOTAL_KEY] = rowTotal;\n                        for (rowIdx = 0; rowIdx < expandedRows.length; rowIdx++) {\n                            rowDescriptor = expandedRows[rowIdx];\n                            if (!this._matchDescriptors(dataItem, rowDescriptor, rowGetters)) {\n                                this._processColumns(measureAggregators, expandedColumns, columnGetters, columns, aggregatorContext, {\n                                    items: {},\n                                    aggregates: {}\n                                }, state, true);\n                                continue;\n                            }\n                            path = rowDescriptor.names.slice(0, rowDescriptor.expandedIdx).join('');\n                            rowName = rowDescriptor.names[rowDescriptor.expandedIdx];\n                            parentName = rowName;\n                            rowValue = rowGetters[rowName](dataItem);\n                            rowValue = rowValue !== undefined ? rowValue.toString() : rowValue;\n                            rowName = rowName + '&' + rowValue;\n                            key = path + rowName;\n                            rows[key] = {\n                                uniquePath: path + parentName,\n                                parentName: parentName,\n                                name: rowName,\n                                value: rowValue\n                            };\n                            value = aggregatedData[key] || {\n                                items: {},\n                                aggregates: {}\n                            };\n                            this._processColumns(measureAggregators, expandedColumns, columnGetters, columns, aggregatorContext, value, state, true);\n                            value.aggregates = this._calculateAggregate(measureAggregators, aggregatorContext, value);\n                            aggregatedData[key] = value;\n                        }\n                    }\n                }\n                if (processed && length) {\n                    if (measureAggregators.length > 1 && (!options.columns || !options.columns.length)) {\n                        columnDescriptors = {\n                            root: [],\n                            expanded: []\n                        };\n                    }\n                    columnsInfo = this._asTuples(columns, columnDescriptors, measuresRowAxis ? [] : measureAggregators, options.sort ? options.sort : []);\n                    rowsInfo = this._asTuples(rows, rowDescriptors, measuresRowAxis ? measureAggregators : [], options.sort ? options.sort : []);\n                    columns = columnsInfo.tuples;\n                    rows = rowsInfo.tuples;\n                    aggregatedData = this._toDataArray(aggregatedData, this._measuresInfo(measureAggregators, measuresRowAxis), rowsInfo.keys, columnsInfo.keys);\n                } else {\n                    aggregatedData = columns = rows = [];\n                }\n                return {\n                    axes: {\n                        columns: { tuples: columns },\n                        rows: { tuples: rows }\n                    },\n                    data: aggregatedData\n                };\n            }\n        });\n        var PivotTransport = Class.extend({\n            init: function (options, transport) {\n                this.transport = transport;\n                this.options = transport.options || {};\n                if (!this.transport.discover) {\n                    if (isFunction(options.discover)) {\n                        this.discover = options.discover;\n                    }\n                }\n            },\n            read: function (options) {\n                return this.transport.read(options);\n            },\n            update: function (options) {\n                return this.transport.update(options);\n            },\n            create: function (options) {\n                return this.transport.create(options);\n            },\n            destroy: function (options) {\n                return this.transport.destroy(options);\n            },\n            discover: function (options) {\n                if (this.transport.discover) {\n                    return this.transport.discover(options);\n                }\n                options.success({});\n            },\n            catalog: function (val) {\n                var options = this.options || {};\n                if (val === undefined) {\n                    return (options.connection || {}).catalog;\n                }\n                var connection = options.connection || {};\n                connection.catalog = val;\n                this.options.connection = connection;\n                $.extend(this.transport.options, { connection: connection });\n            },\n            cube: function (val) {\n                var options = this.options || {};\n                if (val === undefined) {\n                    return (options.connection || {}).cube;\n                }\n                var connection = options.connection || {};\n                connection.cube = val;\n                this.options.connection = connection;\n                extend(true, this.transport.options, { connection: connection });\n            }\n        });\n        var PivotDataSource = DataSource.extend({\n            init: function (options) {\n                var cube = ((options || {}).schema || {}).cube;\n                var measuresAxis = 'columns';\n                var measures;\n                var schema = {\n                    axes: identity,\n                    cubes: identity,\n                    catalogs: identity,\n                    measures: identity,\n                    dimensions: identity,\n                    hierarchies: identity,\n                    levels: identity,\n                    members: identity\n                };\n                if (cube) {\n                    schema = $.extend(schema, this._cubeSchema(cube));\n                    this.cubeBuilder = new PivotCubeBuilder(cube);\n                }\n                DataSource.fn.init.call(this, extend(true, {}, { schema: schema }, options));\n                this.transport = new PivotTransport(this.options.transport || {}, this.transport);\n                this._columns = normalizeMembers(this.options.columns);\n                this._rows = normalizeMembers(this.options.rows);\n                measures = this.options.measures || [];\n                if (toString.call(measures) === '[object Object]') {\n                    measuresAxis = measures.axis || 'columns';\n                    measures = measures.values || [];\n                }\n                this._measures = normalizeMeasures(measures);\n                this._measuresAxis = measuresAxis;\n                this._skipNormalize = 0;\n                this._axes = {};\n            },\n            _cubeSchema: function (cube) {\n                return {\n                    dimensions: function () {\n                        var result = [];\n                        var dimensions = cube.dimensions;\n                        for (var key in dimensions) {\n                            result.push({\n                                name: key,\n                                caption: dimensions[key].caption || key,\n                                uniqueName: key,\n                                defaultHierarchy: key,\n                                type: 1\n                            });\n                        }\n                        if (cube.measures) {\n                            result.push({\n                                name: MEASURES,\n                                caption: MEASURES,\n                                uniqueName: MEASURES,\n                                type: 2\n                            });\n                        }\n                        return result;\n                    },\n                    hierarchies: function () {\n                        return [];\n                    },\n                    measures: function () {\n                        var result = [];\n                        var measures = cube.measures;\n                        for (var key in measures) {\n                            result.push({\n                                name: key,\n                                caption: key,\n                                uniqueName: key,\n                                aggregator: key\n                            });\n                        }\n                        return result;\n                    },\n                    members: $.proxy(function (response, restrictions) {\n                        var name = restrictions.levelUniqueName || restrictions.memberUniqueName;\n                        var schemaData = this.options.schema.data;\n                        var dataGetter = isFunction(schemaData) ? schemaData : kendo.getter(schemaData, true);\n                        var data = this.options.data && dataGetter(this.options.data) || this._rawData || [];\n                        var result = [];\n                        var getter;\n                        var value;\n                        var idx = 0;\n                        var distinct = {};\n                        if (name) {\n                            name = name.split('.')[0];\n                        }\n                        if (!restrictions.treeOp) {\n                            result.push({\n                                caption: cube.dimensions[name].caption || name,\n                                childrenCardinality: '1',\n                                dimensionUniqueName: name,\n                                hierarchyUniqueName: name,\n                                levelUniqueName: name,\n                                name: name,\n                                uniqueName: name\n                            });\n                            return result;\n                        }\n                        getter = kendo.getter(normalizeName(name), true);\n                        for (; idx < data.length; idx++) {\n                            value = getter(data[idx]);\n                            if ((value || value === 0) && !distinct[value]) {\n                                distinct[value] = true;\n                                result.push({\n                                    caption: value,\n                                    childrenCardinality: '0',\n                                    dimensionUniqueName: name,\n                                    hierarchyUniqueName: name,\n                                    levelUniqueName: name,\n                                    name: value,\n                                    uniqueName: value\n                                });\n                            }\n                        }\n                        return result;\n                    }, this)\n                };\n            },\n            options: {\n                serverSorting: true,\n                serverPaging: true,\n                serverFiltering: true,\n                serverGrouping: true,\n                serverAggregates: true\n            },\n            catalog: function (val) {\n                if (val === undefined) {\n                    return this.transport.catalog();\n                }\n                this.transport.catalog(val);\n                this._mergeState({});\n                this._axes = {};\n                this.data([]);\n            },\n            cube: function (val) {\n                if (val === undefined) {\n                    return this.transport.cube();\n                }\n                this.transport.cube(val);\n                this._axes = {};\n                this._mergeState({});\n                this.data([]);\n            },\n            axes: function () {\n                return this._axes;\n            },\n            columns: function (val) {\n                if (val === undefined) {\n                    return this._columns;\n                }\n                this._skipNormalize += 1;\n                this._clearAxesData = true;\n                this._columns = normalizeMembers(val);\n                this.query({\n                    columns: val,\n                    rows: this.rowsAxisDescriptors(),\n                    measures: this.measures(),\n                    sort: this.sort(),\n                    filter: this.filter()\n                });\n            },\n            rows: function (val) {\n                if (val === undefined) {\n                    return this._rows;\n                }\n                this._skipNormalize += 1;\n                this._clearAxesData = true;\n                this._rows = normalizeMembers(val);\n                this.query({\n                    columns: this.columnsAxisDescriptors(),\n                    rows: val,\n                    measures: this.measures(),\n                    sort: this.sort(),\n                    filter: this.filter()\n                });\n            },\n            measures: function (val) {\n                if (val === undefined) {\n                    return this._measures;\n                }\n                this._skipNormalize += 1;\n                this._clearAxesData = true;\n                this.query({\n                    columns: this.columnsAxisDescriptors(),\n                    rows: this.rowsAxisDescriptors(),\n                    measures: normalizeMeasures(val),\n                    sort: this.sort(),\n                    filter: this.filter()\n                });\n            },\n            measuresAxis: function () {\n                return this._measuresAxis || 'columns';\n            },\n            _expandPath: function (path, axis) {\n                var origin = axis === 'columns' ? 'columns' : 'rows';\n                var other = axis === 'columns' ? 'rows' : 'columns';\n                var members = normalizeMembers(path);\n                var memberToExpand = getName(members[members.length - 1]);\n                this._lastExpanded = origin;\n                members = descriptorsForMembers(this.axes()[origin], members, this.measures());\n                for (var idx = 0; idx < members.length; idx++) {\n                    var memberName = getName(members[idx]);\n                    if (memberName === memberToExpand) {\n                        if (members[idx].expand) {\n                            return;\n                        }\n                        members[idx].expand = true;\n                    } else {\n                        members[idx].expand = false;\n                    }\n                }\n                var descriptors = {};\n                descriptors[origin] = members;\n                descriptors[other] = this._descriptorsForAxis(other);\n                this._query(descriptors);\n            },\n            _descriptorsForAxis: function (axis) {\n                var axes = this.axes();\n                var descriptors = this[axis]() || [];\n                if (axes && axes[axis] && axes[axis].tuples && axes[axis].tuples[0]) {\n                    descriptors = descriptorsForAxes(axes[axis].tuples || []);\n                }\n                return descriptors;\n            },\n            columnsAxisDescriptors: function () {\n                return this._descriptorsForAxis('columns');\n            },\n            rowsAxisDescriptors: function () {\n                return this._descriptorsForAxis('rows');\n            },\n            _process: function (data, e) {\n                this._view = data;\n                e = e || {};\n                e.items = e.items || this._view;\n                this.trigger(CHANGE, e);\n            },\n            _query: function (options) {\n                var that = this;\n                if (!options) {\n                    this._skipNormalize += 1;\n                    this._clearAxesData = true;\n                }\n                return that.query(extend({}, {\n                    page: that.page(),\n                    pageSize: that.pageSize(),\n                    sort: that.sort(),\n                    filter: that.filter(),\n                    group: that.group(),\n                    aggregate: that.aggregate(),\n                    columns: this.columnsAxisDescriptors(),\n                    rows: this.rowsAxisDescriptors(),\n                    measures: this.measures()\n                }, options));\n            },\n            query: function (options) {\n                var state = this._mergeState(options);\n                if (this._data.length && this.cubeBuilder) {\n                    this._params(state);\n                    this._updateLocalData(this._pristineData);\n                    return $.Deferred().resolve().promise();\n                }\n                return this.read(state);\n            },\n            _mergeState: function (options) {\n                options = DataSource.fn._mergeState.call(this, options);\n                if (options !== undefined) {\n                    this._measures = normalizeMeasures(options.measures);\n                    if (options.columns) {\n                        options.columns = normalizeMembers(options.columns);\n                    } else if (!options.columns) {\n                        this._columns = [];\n                    }\n                    if (options.rows) {\n                        options.rows = normalizeMembers(options.rows);\n                    } else if (!options.rows) {\n                        this._rows = [];\n                    }\n                }\n                return options;\n            },\n            filter: function (val) {\n                if (val === undefined) {\n                    return this._filter;\n                }\n                this._skipNormalize += 1;\n                this._clearAxesData = true;\n                this._query({\n                    filter: val,\n                    page: 1\n                });\n            },\n            expandColumn: function (path) {\n                this._expandPath(path, 'columns');\n            },\n            expandRow: function (path) {\n                this._expandPath(path, 'rows');\n            },\n            success: function (data) {\n                var originalData;\n                if (this.cubeBuilder) {\n                    originalData = (this.reader.data(data) || []).slice(0);\n                }\n                DataSource.fn.success.call(this, data);\n                if (originalData) {\n                    this._pristineData = originalData;\n                }\n            },\n            _processResult: function (data, axes) {\n                if (this.cubeBuilder) {\n                    var processedData = this.cubeBuilder.process(data, this._requestData);\n                    data = processedData.data;\n                    axes = processedData.axes;\n                }\n                var columnIndexes, rowIndexes;\n                var tuples, resultAxis, measures, axisToSkip;\n                var columnDescriptors = this.columns();\n                var rowDescriptors = this.rows();\n                var hasColumnTuples = axes.columns && axes.columns.tuples;\n                if (!columnDescriptors.length && rowDescriptors.length && hasColumnTuples && (this._rowMeasures().length || !this.measures().length)) {\n                    axes = {\n                        columns: {},\n                        rows: axes.columns\n                    };\n                }\n                if (!columnDescriptors.length && !rowDescriptors.length && this.measuresAxis() === 'rows' && hasColumnTuples) {\n                    axes = {\n                        columns: {},\n                        rows: axes.columns\n                    };\n                }\n                this._axes = {\n                    columns: normalizeAxis(this._axes.columns),\n                    rows: normalizeAxis(this._axes.rows)\n                };\n                axes = {\n                    columns: normalizeAxis(axes.columns),\n                    rows: normalizeAxis(axes.rows)\n                };\n                columnIndexes = this._normalizeTuples(axes.columns.tuples, this._axes.columns.tuples, columnDescriptors, this._columnMeasures());\n                rowIndexes = this._normalizeTuples(axes.rows.tuples, this._axes.rows.tuples, rowDescriptors, this._rowMeasures());\n                if (this._skipNormalize > 0) {\n                    this._skipNormalize -= 1;\n                }\n                if (!this.cubeBuilder) {\n                    data = this._normalizeData({\n                        columnsLength: axes.columns.tuples.length,\n                        rowsLength: axes.rows.tuples.length,\n                        columnIndexes: columnIndexes,\n                        rowIndexes: rowIndexes,\n                        data: data\n                    });\n                }\n                if (this._lastExpanded == 'rows') {\n                    tuples = axes.columns.tuples;\n                    measures = this._columnMeasures();\n                    resultAxis = validateAxis(axes.columns, this._axes.columns, measures);\n                    if (resultAxis) {\n                        axisToSkip = 'columns';\n                        axes.columns = resultAxis;\n                        adjustDataByColumn(tuples, resultAxis.tuples, axes.rows.tuples.length, measures, data);\n                        if (!this.cubeBuilder) {\n                            data = this._normalizeData({\n                                columnsLength: membersCount(axes.columns.tuples, measures),\n                                rowsLength: axes.rows.tuples.length,\n                                data: data\n                            });\n                        }\n                    }\n                } else if (this._lastExpanded == 'columns') {\n                    tuples = axes.rows.tuples;\n                    measures = this._rowMeasures();\n                    resultAxis = validateAxis(axes.rows, this._axes.rows, measures);\n                    if (resultAxis) {\n                        axisToSkip = 'rows';\n                        axes.rows = resultAxis;\n                        adjustDataByRow(tuples, resultAxis.tuples, axes.columns.tuples.length, measures, data);\n                        if (!this.cubeBuilder) {\n                            data = this._normalizeData({\n                                columnsLength: membersCount(axes.rows.tuples, measures),\n                                rowsLength: axes.columns.tuples.length,\n                                data: data\n                            });\n                        }\n                    }\n                }\n                this._lastExpanded = null;\n                var result = this._mergeAxes(axes, data, axisToSkip);\n                this._axes = result.axes;\n                return result.data;\n            },\n            _readData: function (data) {\n                var axes = this.reader.axes(data);\n                var newData = this.reader.data(data);\n                if (this.cubeBuilder) {\n                    this._rawData = newData;\n                }\n                return this._processResult(newData, axes);\n            },\n            _createTuple: function (tuple, measure, buildRoot) {\n                var members = tuple.members;\n                var length = members.length;\n                var root = { members: [] };\n                var levelName, levelNum;\n                var name, parentName;\n                var hasChildren;\n                var hierarchy;\n                var caption;\n                var member;\n                var idx = 0;\n                if (measure) {\n                    length -= 1;\n                }\n                for (; idx < length; idx++) {\n                    member = members[idx];\n                    levelNum = Number(member.levelNum);\n                    name = member.name;\n                    parentName = member.parentName;\n                    caption = member.caption || name;\n                    hasChildren = member.hasChildren;\n                    hierarchy = member.hierarchy;\n                    levelName = member.levelName;\n                    if (buildRoot) {\n                        caption = 'All';\n                        if (levelNum === 0) {\n                            parentName = member.name;\n                        } else {\n                            levelNum -= 1;\n                        }\n                        hasChildren = true;\n                        name = hierarchy = levelName = parentName;\n                    }\n                    root.members.push({\n                        name: name,\n                        children: [],\n                        caption: caption,\n                        levelName: levelName,\n                        levelNum: levelNum.toString(),\n                        hasChildren: hasChildren,\n                        hierarchy: hierarchy,\n                        parentName: !buildRoot ? parentName : ''\n                    });\n                }\n                if (measure) {\n                    root.members.push({\n                        name: measure.name,\n                        children: []\n                    });\n                }\n                return root;\n            },\n            _hasRoot: function (target, source, descriptors) {\n                if (source.length) {\n                    return findExistingTuple(source, target).tuple;\n                }\n                var members = target.members;\n                var member;\n                var descriptor;\n                var isRoot = true;\n                var levelNum;\n                for (var idx = 0, length = members.length; idx < length; idx++) {\n                    member = members[idx];\n                    levelNum = Number(member.levelNum) || 0;\n                    descriptor = descriptors[idx];\n                    if (!(levelNum === 0 || descriptor && member.name === getName(descriptor))) {\n                        isRoot = false;\n                        break;\n                    }\n                }\n                return isRoot;\n            },\n            _mergeAxes: function (sourceAxes, data, axisToSkip) {\n                var columnMeasures = this._columnMeasures();\n                var rowMeasures = this._rowMeasures();\n                var axes = this.axes();\n                var startIndex, tuples;\n                var oldRowsLength = membersCount(axes.rows.tuples, rowMeasures);\n                var newRowsLength = sourceAxes.rows.tuples.length;\n                var oldColumnsLength = membersCount(axes.columns.tuples, columnMeasures);\n                var newColumnsLength = sourceAxes.columns.tuples.length;\n                if (axisToSkip == 'columns') {\n                    newColumnsLength = oldColumnsLength;\n                    tuples = sourceAxes.columns.tuples;\n                } else {\n                    tuples = parseSource(sourceAxes.columns.tuples, columnMeasures);\n                    data = prepareDataOnColumns(tuples, data);\n                }\n                var mergedColumns = mergeTuples(axes.columns.tuples, tuples, columnMeasures);\n                if (axisToSkip == 'rows') {\n                    newRowsLength = membersCount(sourceAxes.rows.tuples, rowMeasures);\n                    tuples = sourceAxes.rows.tuples;\n                } else {\n                    tuples = parseSource(sourceAxes.rows.tuples, rowMeasures);\n                    data = prepareDataOnRows(tuples, data);\n                }\n                var mergedRows = mergeTuples(axes.rows.tuples, tuples, rowMeasures);\n                axes.columns.tuples = mergedColumns.tuples;\n                axes.rows.tuples = mergedRows.tuples;\n                if (oldColumnsLength !== membersCount(axes.columns.tuples, columnMeasures)) {\n                    startIndex = mergedColumns.index + findDataIndex(mergedColumns.parsedRoot, mergedColumns.memberIndex, columnMeasures);\n                    var offset = oldColumnsLength + newColumnsLength;\n                    data = this._mergeColumnData(data, startIndex, newRowsLength, newColumnsLength, offset);\n                } else if (oldRowsLength !== membersCount(axes.rows.tuples, rowMeasures)) {\n                    startIndex = mergedRows.index + findDataIndex(mergedRows.parsedRoot, mergedRows.memberIndex, rowMeasures);\n                    data = this._mergeRowData(data, startIndex, newRowsLength, newColumnsLength);\n                }\n                if (axes.columns.tuples.length === 0 && axes.rows.tuples.length === 0) {\n                    data = [];\n                }\n                return {\n                    axes: axes,\n                    data: data\n                };\n            },\n            _mergeColumnData: function (newData, columnIndex, rowsLength, columnsLength, offset) {\n                var data = this.data().toJSON();\n                var rowIndex, index, drop = 0, toAdd;\n                var columnMeasures = Math.max(this._columnMeasures().length, 1);\n                rowsLength = Math.max(rowsLength, 1);\n                if (data.length > 0) {\n                    drop = columnMeasures;\n                    offset -= columnMeasures;\n                }\n                for (rowIndex = 0; rowIndex < rowsLength; rowIndex++) {\n                    index = columnIndex + rowIndex * offset;\n                    toAdd = newData.splice(0, columnsLength);\n                    toAdd.splice(0, drop);\n                    [].splice.apply(data, [\n                        index,\n                        0\n                    ].concat(toAdd));\n                }\n                return data;\n            },\n            _mergeRowData: function (newData, rowIndex, rowsLength, columnsLength) {\n                var data = this.data().toJSON();\n                var idx, dataIndex, toAdd;\n                var rowMeasures = Math.max(this._rowMeasures().length, 1);\n                columnsLength = Math.max(columnsLength, 1);\n                if (data.length > 0) {\n                    rowsLength -= rowMeasures;\n                    newData.splice(0, columnsLength * rowMeasures);\n                }\n                for (idx = 0; idx < rowsLength; idx++) {\n                    toAdd = newData.splice(0, columnsLength);\n                    dataIndex = rowIndex * columnsLength + idx * columnsLength;\n                    [].splice.apply(data, [\n                        dataIndex,\n                        0\n                    ].concat(toAdd));\n                }\n                return data;\n            },\n            _columnMeasures: function () {\n                var measures = this.measures();\n                var columnMeasures = [];\n                if (this.measuresAxis() === 'columns') {\n                    if (this.columns().length === 0) {\n                        columnMeasures = measures;\n                    } else if (measures.length > 1) {\n                        columnMeasures = measures;\n                    }\n                }\n                return columnMeasures;\n            },\n            _rowMeasures: function () {\n                var measures = this.measures();\n                var rowMeasures = [];\n                if (this.measuresAxis() === 'rows') {\n                    if (this.rows().length === 0) {\n                        rowMeasures = measures;\n                    } else if (measures.length > 1) {\n                        rowMeasures = measures;\n                    }\n                }\n                return rowMeasures;\n            },\n            _updateLocalData: function (data, state) {\n                if (this.cubeBuilder) {\n                    if (state) {\n                        this._requestData = state;\n                    }\n                    data = this._processResult(data);\n                }\n                this._data = this._observe(data);\n                this._ranges = [];\n                this._addRange(this._data);\n                this._total = this._data.length;\n                this._pristineTotal = this._total;\n                this._process(this._data);\n            },\n            data: function (value) {\n                var that = this;\n                if (value !== undefined) {\n                    this._pristineData = value.slice(0);\n                    this._updateLocalData(value, {\n                        columns: this.columns(),\n                        rows: this.rows(),\n                        measures: this.measures()\n                    });\n                } else {\n                    return that._data;\n                }\n            },\n            _normalizeTuples: function (tuples, source, descriptors, measures) {\n                var length = measures.length || 1;\n                var idx = 0;\n                var roots = [];\n                var indexes = {};\n                var measureIdx = 0;\n                var tuple, memberIdx, last;\n                if (!tuples.length) {\n                    return;\n                }\n                if (this._skipNormalize <= 0 && !this._hasRoot(tuples[0], source, descriptors)) {\n                    this._skipNormalize = 0;\n                    for (; idx < length; idx++) {\n                        roots.push(this._createTuple(tuples[0], measures[idx], true));\n                        indexes[idx] = idx;\n                    }\n                    tuples.splice.apply(tuples, [\n                        0,\n                        tuples.length\n                    ].concat(roots).concat(tuples));\n                    idx = length;\n                }\n                if (measures.length) {\n                    last = tuple = tuples[idx];\n                    memberIdx = tuple.members.length - 1;\n                    while (tuple) {\n                        if (measureIdx >= length) {\n                            measureIdx = 0;\n                        }\n                        if (tuple.members[memberIdx].name !== measures[measureIdx].name) {\n                            tuples.splice(idx, 0, this._createTuple(tuple, measures[measureIdx]));\n                            indexes[idx] = idx;\n                        }\n                        idx += 1;\n                        measureIdx += 1;\n                        tuple = tuples[idx];\n                        if (length > measureIdx && (!tuple || tupleName(last, memberIdx - 1) !== tupleName(tuple, memberIdx - 1))) {\n                            for (; measureIdx < length; measureIdx++) {\n                                tuples.splice(idx, 0, this._createTuple(last, measures[measureIdx]));\n                                indexes[idx] = idx;\n                                idx += 1;\n                            }\n                            tuple = tuples[idx];\n                        }\n                        last = tuple;\n                    }\n                }\n                return indexes;\n            },\n            _addMissingDataItems: function (result, metadata) {\n                while (metadata.rowIndexes[parseInt(result.length / metadata.columnsLength, 10)] !== undefined) {\n                    for (var idx = 0; idx < metadata.columnsLength; idx++) {\n                        result = addEmptyDataItem(result);\n                    }\n                }\n                while (metadata.columnIndexes[result.length % metadata.columnsLength] !== undefined) {\n                    result = addEmptyDataItem(result);\n                }\n                return result;\n            },\n            _normalizeOrdinals: function (result, dataItem, metadata) {\n                var lastOrdinal = metadata.lastOrdinal;\n                if (!dataItem) {\n                    return addEmptyDataItem(result);\n                }\n                if (dataItem.ordinal - lastOrdinal > 1) {\n                    lastOrdinal += 1;\n                    while (lastOrdinal < dataItem.ordinal && result.length < metadata.length) {\n                        result = this._addMissingDataItems(addEmptyDataItem(result), metadata);\n                        lastOrdinal += 1;\n                    }\n                }\n                dataItem.ordinal = result.length;\n                result[result.length] = dataItem;\n                return result;\n            },\n            _normalizeData: function (options) {\n                var data = options.data;\n                var dataIdx = 0;\n                var dataItem;\n                var result = [];\n                var lastOrdinal;\n                var length;\n                options.lastOrdinal = 0;\n                options.columnIndexes = options.columnIndexes || {};\n                options.rowIndexes = options.rowIndexes || {};\n                options.columnsLength = options.columnsLength || 1;\n                options.rowsLength = options.rowsLength || 1;\n                options.length = options.columnsLength * options.rowsLength;\n                length = options.length;\n                if (data.length === length) {\n                    return data;\n                }\n                while (result.length < length) {\n                    dataItem = data[dataIdx++];\n                    if (dataItem) {\n                        lastOrdinal = dataItem.ordinal;\n                    }\n                    result = this._normalizeOrdinals(this._addMissingDataItems(result, options), dataItem, options);\n                    options.lastOrdinal = lastOrdinal;\n                }\n                return result;\n            },\n            discover: function (options, converter) {\n                var that = this, transport = that.transport;\n                return $.Deferred(function (deferred) {\n                    transport.discover(extend({\n                        success: function (response) {\n                            response = that.reader.parse(response);\n                            if (that._handleCustomErrors(response)) {\n                                return;\n                            }\n                            if (converter) {\n                                response = converter(response);\n                            }\n                            deferred.resolve(response);\n                        },\n                        error: function (response, status, error) {\n                            deferred.reject(response);\n                            that.error(response, status, error);\n                        }\n                    }, options));\n                }).promise().done(function () {\n                    that.trigger('schemaChange');\n                });\n            },\n            schemaMeasures: function () {\n                var that = this;\n                return that.discover({\n                    data: {\n                        command: 'schemaMeasures',\n                        restrictions: {\n                            catalogName: that.transport.catalog(),\n                            cubeName: that.transport.cube()\n                        }\n                    }\n                }, function (response) {\n                    return that.reader.measures(response);\n                });\n            },\n            schemaKPIs: function () {\n                var that = this;\n                return that.discover({\n                    data: {\n                        command: 'schemaKPIs',\n                        restrictions: {\n                            catalogName: that.transport.catalog(),\n                            cubeName: that.transport.cube()\n                        }\n                    }\n                }, function (response) {\n                    return that.reader.kpis(response);\n                });\n            },\n            schemaDimensions: function () {\n                var that = this;\n                return that.discover({\n                    data: {\n                        command: 'schemaDimensions',\n                        restrictions: {\n                            catalogName: that.transport.catalog(),\n                            cubeName: that.transport.cube()\n                        }\n                    }\n                }, function (response) {\n                    return that.reader.dimensions(response);\n                });\n            },\n            schemaHierarchies: function (dimensionName) {\n                var that = this;\n                return that.discover({\n                    data: {\n                        command: 'schemaHierarchies',\n                        restrictions: {\n                            catalogName: that.transport.catalog(),\n                            cubeName: that.transport.cube(),\n                            dimensionUniqueName: dimensionName\n                        }\n                    }\n                }, function (response) {\n                    return that.reader.hierarchies(response);\n                });\n            },\n            schemaLevels: function (hierarchyName) {\n                var that = this;\n                return that.discover({\n                    data: {\n                        command: 'schemaLevels',\n                        restrictions: {\n                            catalogName: that.transport.catalog(),\n                            cubeName: that.transport.cube(),\n                            hierarchyUniqueName: hierarchyName\n                        }\n                    }\n                }, function (response) {\n                    return that.reader.levels(response);\n                });\n            },\n            schemaCubes: function () {\n                var that = this;\n                return that.discover({\n                    data: {\n                        command: 'schemaCubes',\n                        restrictions: { catalogName: that.transport.catalog() }\n                    }\n                }, function (response) {\n                    return that.reader.cubes(response);\n                });\n            },\n            schemaCatalogs: function () {\n                var that = this;\n                return that.discover({ data: { command: 'schemaCatalogs' } }, function (response) {\n                    return that.reader.catalogs(response);\n                });\n            },\n            schemaMembers: function (restrictions) {\n                var that = this;\n                var success = function (restrictions) {\n                    return function (response) {\n                        return that.reader.members(response, restrictions);\n                    };\n                }(restrictions);\n                return that.discover({\n                    data: {\n                        command: 'schemaMembers',\n                        restrictions: extend({\n                            catalogName: that.transport.catalog(),\n                            cubeName: that.transport.cube()\n                        }, restrictions)\n                    }\n                }, success);\n            },\n            _params: function (data) {\n                if (this._clearAxesData) {\n                    this._axes = {};\n                    this._data = this._observe([]);\n                    this._clearAxesData = false;\n                    this.trigger(STATERESET);\n                }\n                var options = DataSource.fn._params.call(this, data);\n                options = extend({\n                    measures: this.measures(),\n                    measuresAxis: this.measuresAxis(),\n                    columns: this.columns(),\n                    rows: this.rows()\n                }, options);\n                if (this.cubeBuilder) {\n                    this._requestData = options;\n                }\n                return options;\n            }\n        });\n        function flatColumns(columns) {\n            var result = [];\n            for (var idx = 0; idx < columns.length; idx++) {\n                result.push(columns[idx]);\n                if (columns[idx].children) {\n                    result = result.concat(flatColumns(columns[idx].children));\n                }\n            }\n            return result;\n        }\n        function sortItemsTree(field, items, sortFunction) {\n            for (var i = 0; i < items.length; i++) {\n                if (items[i].children && items[i].children.length) {\n                    sortItemsTree(field, items[i].children, sortFunction);\n                }\n            }\n            if (items[0].parentName != field) {\n                return;\n            }\n            items = items.sort(sortFunction);\n        }\n        function fillSortTree(items, map) {\n            for (var i = 0; i < items.length; i++) {\n                var currentItem = map[items[i].name];\n                if (!$.isEmptyObject(currentItem.childrenMap)) {\n                    items[i].children = [];\n                    for (var name in currentItem.childrenMap) {\n                        items[i].children.push($.extend({}, {\n                            name: name,\n                            parentName: map[name].parentName\n                        }));\n                    }\n                    fillSortTree(items[i].children, map);\n                }\n            }\n        }\n        function addEmptyDataItem(result) {\n            result[result.length] = {\n                value: '',\n                fmtValue: '',\n                ordinal: result.length\n            };\n            return result;\n        }\n        function validateAxis(newAxis, axis, measures) {\n            if (newAxis.tuples.length < membersCount(axis.tuples, measures)) {\n                return axis;\n            }\n            return;\n        }\n        function adjustDataByColumn(sourceTuples, targetTuples, rowsLength, measures, data) {\n            var columnIdx, rowIdx, dataIdx;\n            var columnsLength = sourceTuples.length;\n            var targetColumnsLength = membersCount(targetTuples, measures);\n            var measuresLength = measures.length || 1;\n            for (rowIdx = 0; rowIdx < rowsLength; rowIdx++) {\n                for (columnIdx = 0; columnIdx < columnsLength; columnIdx++) {\n                    dataIdx = tupleIndex(sourceTuples[columnIdx], targetTuples) * measuresLength;\n                    dataIdx += columnIdx % measuresLength;\n                    data[rowIdx * columnsLength + columnIdx].ordinal = rowIdx * targetColumnsLength + dataIdx;\n                }\n            }\n        }\n        function adjustDataByRow(sourceTuples, targetTuples, columnsLength, measures, data) {\n            var columnIdx, rowIdx, dataIdx;\n            var rowsLength = sourceTuples.length;\n            var measuresLength = measures.length || 1;\n            for (rowIdx = 0; rowIdx < rowsLength; rowIdx++) {\n                dataIdx = tupleIndex(sourceTuples[rowIdx], targetTuples);\n                dataIdx *= measuresLength;\n                dataIdx += rowIdx % measuresLength;\n                for (columnIdx = 0; columnIdx < columnsLength; columnIdx++) {\n                    data[rowIdx * columnsLength + columnIdx].ordinal = dataIdx * columnsLength + columnIdx;\n                }\n            }\n        }\n        function tupleIndex(tuple, collection) {\n            return findExistingTuple(collection, tuple).index;\n        }\n        function membersCount(tuples, measures) {\n            if (!tuples.length) {\n                return 0;\n            }\n            var queue = tuples.slice();\n            var current = queue.shift();\n            var result = 1;\n            while (current) {\n                if (current.members) {\n                    [].push.apply(queue, current.members);\n                } else if (current.children) {\n                    if (!current.measure) {\n                        result += current.children.length;\n                    }\n                    [].push.apply(queue, current.children);\n                }\n                current = queue.shift();\n            }\n            if (measures.length) {\n                result = result * measures.length;\n            }\n            return result;\n        }\n        function normalizeAxis(axis) {\n            if (!axis) {\n                axis = { tuples: [] };\n            }\n            if (!axis.tuples) {\n                axis.tuples = [];\n            }\n            return axis;\n        }\n        function findDataIndex(tuple, memberIndex, measures) {\n            if (!tuple) {\n                return 0;\n            }\n            var measuresLength = Math.max(measures.length, 1);\n            var tuples = tuple.members.slice(0, memberIndex);\n            var current = tuples.shift();\n            var counter = measuresLength;\n            while (current) {\n                if (current.name === MEASURES) {\n                    counter += measuresLength - 1;\n                } else if (current.children) {\n                    [].push.apply(tuples, current.children);\n                } else {\n                    counter++;\n                    [].push.apply(tuples, current.members);\n                }\n                current = tuples.shift();\n            }\n            return counter;\n        }\n        function mergeTuples(target, source, measures) {\n            if (!source[0]) {\n                return {\n                    parsedRoot: null,\n                    tuples: target,\n                    memberIndex: 0,\n                    index: 0\n                };\n            }\n            var result = findExistingTuple(target, source[0]);\n            if (!result.tuple) {\n                return {\n                    parsedRoot: null,\n                    tuples: source,\n                    memberIndex: 0,\n                    index: 0\n                };\n            }\n            var targetMembers = result.tuple.members;\n            var sourceMembers = source[0].members;\n            var memberIndex = -1;\n            if (targetMembers.length !== sourceMembers.length) {\n                return {\n                    parsedRoot: null,\n                    tuples: source,\n                    memberIndex: 0,\n                    index: 0\n                };\n            }\n            for (var idx = 0, length = targetMembers.length; idx < length; idx++) {\n                if (!targetMembers[idx].measure && sourceMembers[idx].children[0]) {\n                    if (memberIndex == -1 && sourceMembers[idx].children.length) {\n                        memberIndex = idx;\n                    }\n                    targetMembers[idx].children = sourceMembers[idx].children;\n                }\n            }\n            measures = Math.max(measures.length, 1);\n            return {\n                parsedRoot: result.tuple,\n                index: result.index * measures,\n                memberIndex: memberIndex,\n                tuples: target\n            };\n        }\n        function equalTuples(first, second) {\n            var equal = true;\n            var idx, length;\n            first = first.members;\n            second = second.members;\n            for (idx = 0, length = first.length; idx < length; idx++) {\n                if (first[idx].measure || second[idx].measure) {\n                    continue;\n                }\n                equal = equal && getName(first[idx]) === getName(second[idx]);\n            }\n            return equal;\n        }\n        function findExistingTuple(tuples, toFind) {\n            var idx, length, tuple, found, counter = 0;\n            var memberIndex, membersLength, member;\n            for (idx = 0, length = tuples.length; idx < length; idx++) {\n                tuple = tuples[idx];\n                if (equalTuples(tuple, toFind)) {\n                    return {\n                        tuple: tuple,\n                        index: counter\n                    };\n                }\n                counter++;\n                for (memberIndex = 0, membersLength = tuple.members.length; memberIndex < membersLength; memberIndex++) {\n                    member = tuple.members[memberIndex];\n                    if (member.measure) {\n                        continue;\n                    }\n                    found = findExistingTuple(member.children, toFind);\n                    counter += found.index;\n                    if (found.tuple) {\n                        return {\n                            tuple: found.tuple,\n                            index: counter\n                        };\n                    }\n                }\n            }\n            return { index: counter };\n        }\n        function addMembers(members, map) {\n            var member, i, len, path = '';\n            for (i = 0, len = members.length; i < len; i++) {\n                member = members[i];\n                path += member.name;\n                if (!map[path]) {\n                    map[path] = member;\n                }\n            }\n        }\n        function findParentMember(tuple, map) {\n            var members = tuple.members;\n            var i, len, member, path = '';\n            var parentPath = '';\n            var parentMember;\n            for (i = 0, len = members.length; i < len; i++) {\n                member = members[i];\n                if (parentMember) {\n                    if (map[path + member.name]) {\n                        path += member.name;\n                        parentMember = map[path];\n                        continue;\n                    } else if (map[path + member.parentName]) {\n                        return map[path + member.parentName];\n                    } else if (map[parentPath + member.parentName]) {\n                        return map[parentPath + member.parentName];\n                    } else {\n                        return map[parentPath];\n                    }\n                }\n                path += member.name;\n                parentMember = map[member.parentName];\n                if (!parentMember) {\n                    parentMember = map[path];\n                    if (!parentMember) {\n                        return null;\n                    }\n                }\n                if (parentMember) {\n                    parentPath += parentMember.name;\n                }\n            }\n            return parentMember;\n        }\n        function measurePosition(tuple, measures) {\n            if (measures.length === 0) {\n                return -1;\n            }\n            var measure = measures[0];\n            var members = tuple.members;\n            for (var idx = 0, len = members.length; idx < len; idx++) {\n                if (members[idx].name == measure.name) {\n                    return idx;\n                }\n            }\n        }\n        function normalizeTupleMeasures(tuple, index) {\n            if (index < 0) {\n                return;\n            }\n            var member = {\n                name: MEASURES,\n                measure: true,\n                children: [$.extend({\n                        members: [],\n                        dataIndex: tuple.dataIndex\n                    }, tuple.members[index])]\n            };\n            tuple.members.splice(index, 1, member);\n            tuple.dataIndex = undefined;\n        }\n        function parseSource(tuples, measures) {\n            if (tuples.length < 1) {\n                return [];\n            }\n            var result = [];\n            var map = {};\n            var measureIndex = measurePosition(tuples[0], measures);\n            for (var i = 0; i < tuples.length; i++) {\n                var tuple = tuples[i];\n                tuple.dataIndex = i;\n                normalizeTupleMeasures(tuple, measureIndex);\n                var parentMember = findParentMember(tuple, map);\n                if (parentMember) {\n                    if (measureIndex < 0 || !parentMember.measure) {\n                        parentMember.children.push(tuple);\n                    } else {\n                        parentMember.children.push(tuple.members[measureIndex].children[0]);\n                    }\n                } else {\n                    result.push(tuple);\n                }\n                addMembers(tuple.members, map);\n            }\n            return result;\n        }\n        function prepareDataOnRows(tuples, data) {\n            if (!tuples || !tuples.length) {\n                return data;\n            }\n            var result = [];\n            var indices = buildDataIndices(tuples);\n            var rowsLength = indices.length;\n            var columnsLength = Math.max(data.length / rowsLength, 1);\n            var rowIndex, columnIndex, targetIndex, sourceIndex;\n            var calcIndex;\n            for (rowIndex = 0; rowIndex < rowsLength; rowIndex++) {\n                targetIndex = columnsLength * rowIndex;\n                sourceIndex = columnsLength * indices[rowIndex];\n                for (columnIndex = 0; columnIndex < columnsLength; columnIndex++) {\n                    calcIndex = parseInt(sourceIndex + columnIndex, 10);\n                    result[parseInt(targetIndex + columnIndex, 10)] = data[calcIndex] || {\n                        value: '',\n                        fmtValue: '',\n                        ordinal: calcIndex\n                    };\n                }\n            }\n            return result;\n        }\n        function prepareDataOnColumns(tuples, data) {\n            if (!tuples || !tuples.length) {\n                return data;\n            }\n            var result = [];\n            var indices = buildDataIndices(tuples);\n            var columnsLength = indices.length;\n            var rowsLength = Math.max(data.length / columnsLength, 1);\n            var columnIndex, rowIndex, dataIndex, calcIndex;\n            for (rowIndex = 0; rowIndex < rowsLength; rowIndex++) {\n                dataIndex = columnsLength * rowIndex;\n                for (columnIndex = 0; columnIndex < columnsLength; columnIndex++) {\n                    calcIndex = indices[columnIndex] + dataIndex;\n                    result[dataIndex + columnIndex] = data[calcIndex] || {\n                        value: '',\n                        fmtValue: '',\n                        ordinal: calcIndex\n                    };\n                }\n            }\n            return result;\n        }\n        function buildDataIndices(tuples) {\n            tuples = tuples.slice();\n            var result = [];\n            var tuple = tuples.shift();\n            var idx, length, spliceIndex, children, member;\n            while (tuple) {\n                if (tuple.dataIndex !== undefined) {\n                    result.push(tuple.dataIndex);\n                }\n                spliceIndex = 0;\n                for (idx = 0, length = tuple.members.length; idx < length; idx++) {\n                    member = tuple.members[idx];\n                    children = member.children;\n                    if (member.measure) {\n                        [].splice.apply(tuples, [\n                            0,\n                            0\n                        ].concat(children));\n                    } else {\n                        [].splice.apply(tuples, [\n                            spliceIndex,\n                            0\n                        ].concat(children));\n                    }\n                    spliceIndex += children.length;\n                }\n                tuple = tuples.shift();\n            }\n            return result;\n        }\n        PivotDataSource.create = function (options) {\n            options = options && options.push ? { data: options } : options;\n            var dataSource = options || {}, data = dataSource.data;\n            dataSource.data = data;\n            if (!(dataSource instanceof PivotDataSource) && dataSource instanceof kendo.data.DataSource) {\n                throw new Error('Incorrect DataSource type. Only PivotDataSource instances are supported');\n            }\n            return dataSource instanceof PivotDataSource ? dataSource : new PivotDataSource(dataSource);\n        };\n        function baseHierarchyPath(memberName) {\n            var parts = memberName.split('.');\n            if (parts.length > 2) {\n                return parts[0] + '.' + parts[1];\n            }\n            return memberName;\n        }\n        function expandMemberDescriptor(names, sort) {\n            var idx = names.length - 1;\n            var name = names[idx];\n            var sortDescriptor;\n            sortDescriptor = sortDescriptorForMember(sort, name);\n            if (sortDescriptor && sortDescriptor.dir) {\n                name = 'ORDER(' + name + '.Children,' + sortDescriptor.field + '.CurrentMember.MEMBER_CAPTION,' + sortDescriptor.dir + ')';\n            } else {\n                name += '.Children';\n            }\n            names[idx] = name;\n            return names;\n        }\n        function sortDescriptorForMember(sort, member) {\n            for (var idx = 0, length = sort.length; idx < length; idx++) {\n                if (member.indexOf(sort[idx].field) === 0) {\n                    return sort[idx];\n                }\n            }\n            return null;\n        }\n        function crossJoin(names) {\n            var result = 'CROSSJOIN({';\n            var r;\n            if (names.length > 2) {\n                r = names.pop();\n                result += crossJoin(names);\n            } else {\n                result += names.shift();\n                r = names.pop();\n            }\n            result += '},{';\n            result += r;\n            result += '})';\n            return result;\n        }\n        function crossJoinCommand(members, measures) {\n            var tmp = members.slice(0);\n            if (measures.length > 1) {\n                tmp.push('{' + measureNames(measures).join(',') + '}');\n            }\n            return crossJoin(tmp);\n        }\n        function measureNames(measures) {\n            var idx = 0;\n            var length = measures.length;\n            var result = [];\n            var measure;\n            for (; idx < length; idx++) {\n                measure = measures[idx];\n                result.push(measure.name !== undefined ? measure.name : measure);\n            }\n            return result;\n        }\n        function getName(name) {\n            name = name.name || name;\n            if (toString.call(name) === '[object Array]') {\n                name = name[name.length - 1];\n            }\n            return name;\n        }\n        function getRootNames(members) {\n            var length = members.length;\n            var names = [];\n            var idx = 0;\n            for (; idx < length; idx++) {\n                names.push(members[idx].name[0]);\n            }\n            return names;\n        }\n        function mapNames(names, rootNames) {\n            var name;\n            var rootName;\n            var j;\n            var idx = 0;\n            var length = names.length;\n            var rootLength = rootNames.length;\n            rootNames = rootNames.slice(0);\n            for (; idx < length; idx++) {\n                name = names[idx];\n                for (j = 0; j < rootLength; j++) {\n                    rootName = baseHierarchyPath(rootNames[j]);\n                    if (name.indexOf(rootName) !== -1) {\n                        rootNames[j] = name;\n                        break;\n                    }\n                }\n            }\n            return {\n                names: rootNames,\n                expandedIdx: j,\n                uniquePath: rootNames.slice(0, j + 1).join('')\n            };\n        }\n        function parseDescriptors(members) {\n            var expanded = [];\n            var child = [];\n            var root = [];\n            var member;\n            var j, l;\n            var idx = 0;\n            var length = members.length;\n            var name;\n            var hierarchyName;\n            var found;\n            for (; idx < length; idx++) {\n                member = members[idx];\n                name = member.name;\n                found = false;\n                if (toString.call(name) !== '[object Array]') {\n                    member.name = name = [name];\n                }\n                if (name.length > 1) {\n                    child.push(member);\n                } else {\n                    hierarchyName = baseHierarchyPath(name[0]);\n                    for (j = 0, l = root.length; j < l; j++) {\n                        if (root[j].name[0].indexOf(hierarchyName) === 0) {\n                            found = true;\n                            break;\n                        }\n                    }\n                    if (!found) {\n                        root.push(member);\n                    }\n                    if (member.expand) {\n                        expanded.push(member);\n                    }\n                }\n            }\n            expanded = expanded.concat(child);\n            return {\n                root: root,\n                expanded: expanded\n            };\n        }\n        function serializeMembers(members, measures, sort) {\n            var command = '';\n            members = members || [];\n            var expanded = parseDescriptors(members);\n            var root = expanded.root;\n            var rootNames = getRootNames(root);\n            var crossJoinCommands = [];\n            expanded = expanded.expanded;\n            var length = expanded.length;\n            var idx = 0;\n            var memberName;\n            var names = [];\n            if (rootNames.length > 1 || measures.length > 1) {\n                crossJoinCommands.push(crossJoinCommand(rootNames, measures));\n                for (; idx < length; idx++) {\n                    memberName = expandMemberDescriptor(expanded[idx].name, sort);\n                    names = mapNames(memberName, rootNames).names;\n                    crossJoinCommands.push(crossJoinCommand(names, measures));\n                }\n                command += crossJoinCommands.join(',');\n            } else {\n                for (; idx < length; idx++) {\n                    memberName = expandMemberDescriptor(expanded[idx].name, sort);\n                    names.push(memberName[0]);\n                }\n                command += rootNames.concat(names).join(',');\n            }\n            return command;\n        }\n        var filterFunctionFormats = {\n            contains: ', InStr({0}.CurrentMember.MEMBER_CAPTION,\"{1}\") > 0',\n            doesnotcontain: ', InStr({0}.CurrentMember.MEMBER_CAPTION,\"{1}\")',\n            startswith: ', Left({0}.CurrentMember.MEMBER_CAPTION,Len(\"{1}\"))=\"{1}\"',\n            endswith: ', Right({0}.CurrentMember.MEMBER_CAPTION,Len(\"{1}\"))=\"{1}\"',\n            eq: ', {0}.CurrentMember.MEMBER_CAPTION = \"{1}\"',\n            neq: ', {0}.CurrentMember.MEMBER_CAPTION = \"{1}\"'\n        };\n        function serializeExpression(expression) {\n            var command = '';\n            var value = expression.value;\n            var field = expression.field;\n            var operator = expression.operator;\n            if (operator == 'in') {\n                command += '{';\n                command += value;\n                command += '}';\n            } else {\n                command += operator == 'neq' || operator == 'doesnotcontain' ? '-' : '';\n                command += 'Filter(';\n                command += field + '.MEMBERS';\n                command += kendo.format(filterFunctionFormats[operator], field, value);\n                command += ')';\n            }\n            return command;\n        }\n        function serializeFilters(filter, cube) {\n            var command = '', current;\n            var filters = filter.filters;\n            var length = filters.length;\n            var idx;\n            for (idx = length - 1; idx >= 0; idx--) {\n                current = 'SELECT (';\n                current += serializeExpression(filters[idx]);\n                current += ') ON 0';\n                if (idx == length - 1) {\n                    current += ' FROM [' + cube + ']';\n                    command = current;\n                } else {\n                    command = current + ' FROM ( ' + command + ' )';\n                }\n            }\n            return command;\n        }\n        function serializeOptions(parentTagName, options, capitalize) {\n            var result = '';\n            if (options) {\n                result += '<' + parentTagName + '>';\n                var value;\n                for (var key in options) {\n                    value = options[key];\n                    if (capitalize) {\n                        key = key.replace(/([A-Z]+(?=$|[A-Z][a-z])|[A-Z]?[a-z]+)/g, '$1_').toUpperCase().replace(/_$/, '');\n                    }\n                    result += '<' + key + '>' + value + '</' + key + '>';\n                }\n                result += '</' + parentTagName + '>';\n            } else {\n                result += '<' + parentTagName + '/>';\n            }\n            return result;\n        }\n        var xmlaDiscoverCommands = {\n            schemaCubes: 'MDSCHEMA_CUBES',\n            schemaCatalogs: 'DBSCHEMA_CATALOGS',\n            schemaMeasures: 'MDSCHEMA_MEASURES',\n            schemaDimensions: 'MDSCHEMA_DIMENSIONS',\n            schemaHierarchies: 'MDSCHEMA_HIERARCHIES',\n            schemaLevels: 'MDSCHEMA_LEVELS',\n            schemaMembers: 'MDSCHEMA_MEMBERS',\n            schemaKPIs: 'MDSCHEMA_KPIS'\n        };\n        var convertersMap = {\n            read: function (options) {\n                var command = '<Envelope xmlns=\"http://schemas.xmlsoap.org/soap/envelope/\"><Header/><Body><Execute xmlns=\"urn:schemas-microsoft-com:xml-analysis\"><Command><Statement>';\n                command += 'SELECT NON EMPTY {';\n                var columns = options.columns || [];\n                var rows = options.rows || [];\n                var measures = options.measures || [];\n                var measuresRowAxis = options.measuresAxis === 'rows';\n                var sort = options.sort || [];\n                if (!columns.length && rows.length && (!measures.length || measures.length && measuresRowAxis)) {\n                    columns = rows;\n                    rows = [];\n                    measuresRowAxis = false;\n                }\n                if (!columns.length && !rows.length) {\n                    measuresRowAxis = false;\n                }\n                if (columns.length) {\n                    command += serializeMembers(columns, !measuresRowAxis ? measures : [], sort);\n                } else if (measures.length && !measuresRowAxis) {\n                    command += measureNames(measures).join(',');\n                }\n                command += '} DIMENSION PROPERTIES CHILDREN_CARDINALITY, PARENT_UNIQUE_NAME ON COLUMNS';\n                if (rows.length || measuresRowAxis && measures.length > 1) {\n                    command += ', NON EMPTY {';\n                    if (rows.length) {\n                        command += serializeMembers(rows, measuresRowAxis ? measures : [], sort);\n                    } else {\n                        command += measureNames(measures).join(',');\n                    }\n                    command += '} DIMENSION PROPERTIES CHILDREN_CARDINALITY, PARENT_UNIQUE_NAME ON ROWS';\n                }\n                if (options.filter) {\n                    command += ' FROM ';\n                    command += '(';\n                    command += serializeFilters(options.filter, options.connection.cube);\n                    command += ')';\n                } else {\n                    command += ' FROM [' + options.connection.cube + ']';\n                }\n                if (measures.length == 1 && columns.length) {\n                    command += ' WHERE (' + measureNames(measures).join(',') + ')';\n                }\n                command += '</Statement></Command><Properties><PropertyList><Catalog>' + options.connection.catalog + '</Catalog><Format>Multidimensional</Format></PropertyList></Properties></Execute></Body></Envelope>';\n                return command.replace(/\\&/g, '&amp;');\n            },\n            discover: function (options) {\n                options = options || {};\n                var command = '<Envelope xmlns=\"http://schemas.xmlsoap.org/soap/envelope/\"><Header/><Body><Discover xmlns=\"urn:schemas-microsoft-com:xml-analysis\">';\n                command += '<RequestType>' + (xmlaDiscoverCommands[options.command] || options.command) + '</RequestType>';\n                command += '<Restrictions>' + serializeOptions('RestrictionList', options.restrictions, true) + '</Restrictions>';\n                if (options.connection && options.connection.catalog) {\n                    options.properties = $.extend({}, { Catalog: options.connection.catalog }, options.properties);\n                }\n                command += '<Properties>' + serializeOptions('PropertyList', options.properties) + '</Properties>';\n                command += '</Discover></Body></Envelope>';\n                return command;\n            }\n        };\n        var XmlaTransport = kendo.data.RemoteTransport.extend({\n            init: function (options) {\n                var originalOptions = options;\n                options = this.options = extend(true, {}, this.options, options);\n                kendo.data.RemoteTransport.call(this, options);\n                if (isFunction(originalOptions.discover)) {\n                    this.discover = originalOptions.discover;\n                } else if (typeof originalOptions.discover === 'string') {\n                    this.options.discover = { url: originalOptions.discover };\n                } else if (!originalOptions.discover) {\n                    this.options.discover = this.options.read;\n                }\n            },\n            setup: function (options, type) {\n                options.data = options.data || {};\n                $.extend(true, options.data, { connection: this.options.connection });\n                return kendo.data.RemoteTransport.fn.setup.call(this, options, type);\n            },\n            options: {\n                read: {\n                    dataType: 'text',\n                    contentType: 'text/xml',\n                    type: 'POST'\n                },\n                discover: {\n                    dataType: 'text',\n                    contentType: 'text/xml',\n                    type: 'POST'\n                },\n                parameterMap: function (options, type) {\n                    return convertersMap[type](options, type);\n                }\n            },\n            discover: function (options) {\n                return $.ajax(this.setup(options, 'discover'));\n            }\n        });\n        function asArray(object) {\n            if (object == null) {\n                return [];\n            }\n            var type = toString.call(object);\n            if (type !== '[object Array]') {\n                return [object];\n            }\n            return object;\n        }\n        function translateAxis(axis) {\n            var result = { tuples: [] };\n            var tuples = asArray(kendo.getter('Tuples.Tuple', true)(axis));\n            var captionGetter = kendo.getter('Caption[\\'#text\\']');\n            var unameGetter = kendo.getter('UName[\\'#text\\']');\n            var levelNameGetter = kendo.getter('LName[\\'#text\\']');\n            var levelNumGetter = kendo.getter('LNum[\\'#text\\']');\n            var childrenGetter = kendo.getter('CHILDREN_CARDINALITY[\\'#text\\']', true);\n            var hierarchyGetter = kendo.getter('[\\'@Hierarchy\\']');\n            var parentNameGetter = kendo.getter('PARENT_UNIQUE_NAME[\\'#text\\']', true);\n            for (var idx = 0; idx < tuples.length; idx++) {\n                var members = [];\n                var member = asArray(tuples[idx].Member);\n                for (var memberIdx = 0; memberIdx < member.length; memberIdx++) {\n                    members.push({\n                        children: [],\n                        caption: captionGetter(member[memberIdx]),\n                        name: unameGetter(member[memberIdx]),\n                        levelName: levelNameGetter(member[memberIdx]),\n                        levelNum: levelNumGetter(member[memberIdx]),\n                        hasChildren: parseInt(childrenGetter(member[memberIdx]), 10) > 0,\n                        parentName: parentNameGetter(member[memberIdx]),\n                        hierarchy: hierarchyGetter(member[memberIdx])\n                    });\n                }\n                result.tuples.push({ members: members });\n            }\n            return result;\n        }\n        var schemaDataReaderMap = {\n            cubes: {\n                name: kendo.getter('CUBE_NAME[\\'#text\\']', true),\n                caption: kendo.getter('CUBE_CAPTION[\\'#text\\']', true),\n                description: kendo.getter('DESCRIPTION[\\'#text\\']', true),\n                type: kendo.getter('CUBE_TYPE[\\'#text\\']', true)\n            },\n            catalogs: {\n                name: kendo.getter('CATALOG_NAME[\\'#text\\']', true),\n                description: kendo.getter('DESCRIPTION[\\'#text\\']', true)\n            },\n            measures: {\n                name: kendo.getter('MEASURE_NAME[\\'#text\\']', true),\n                caption: kendo.getter('MEASURE_CAPTION[\\'#text\\']', true),\n                uniqueName: kendo.getter('MEASURE_UNIQUE_NAME[\\'#text\\']', true),\n                description: kendo.getter('DESCRIPTION[\\'#text\\']', true),\n                aggregator: kendo.getter('MEASURE_AGGREGATOR[\\'#text\\']', true),\n                groupName: kendo.getter('MEASUREGROUP_NAME[\\'#text\\']', true),\n                displayFolder: kendo.getter('MEASURE_DISPLAY_FOLDER[\\'#text\\']', true),\n                defaultFormat: kendo.getter('DEFAULT_FORMAT_STRING[\\'#text\\']', true)\n            },\n            kpis: {\n                name: kendo.getter('KPI_NAME[\\'#text\\']', true),\n                caption: kendo.getter('KPI_CAPTION[\\'#text\\']', true),\n                value: kendo.getter('KPI_VALUE[\\'#text\\']', true),\n                goal: kendo.getter('KPI_GOAL[\\'#text\\']', true),\n                status: kendo.getter('KPI_STATUS[\\'#text\\']', true),\n                trend: kendo.getter('KPI_TREND[\\'#text\\']', true),\n                statusGraphic: kendo.getter('KPI_STATUS_GRAPHIC[\\'#text\\']', true),\n                trendGraphic: kendo.getter('KPI_TREND_GRAPHIC[\\'#text\\']', true),\n                description: kendo.getter('KPI_DESCRIPTION[\\'#text\\']', true),\n                groupName: kendo.getter('MEASUREGROUP_NAME[\\'#text\\']', true)\n            },\n            dimensions: {\n                name: kendo.getter('DIMENSION_NAME[\\'#text\\']', true),\n                caption: kendo.getter('DIMENSION_CAPTION[\\'#text\\']', true),\n                description: kendo.getter('DESCRIPTION[\\'#text\\']', true),\n                uniqueName: kendo.getter('DIMENSION_UNIQUE_NAME[\\'#text\\']', true),\n                defaultHierarchy: kendo.getter('DEFAULT_HIERARCHY[\\'#text\\']', true),\n                type: kendo.getter('DIMENSION_TYPE[\\'#text\\']', true)\n            },\n            hierarchies: {\n                name: kendo.getter('HIERARCHY_NAME[\\'#text\\']', true),\n                caption: kendo.getter('HIERARCHY_CAPTION[\\'#text\\']', true),\n                description: kendo.getter('DESCRIPTION[\\'#text\\']', true),\n                uniqueName: kendo.getter('HIERARCHY_UNIQUE_NAME[\\'#text\\']', true),\n                dimensionUniqueName: kendo.getter('DIMENSION_UNIQUE_NAME[\\'#text\\']', true),\n                displayFolder: kendo.getter('HIERARCHY_DISPLAY_FOLDER[\\'#text\\']', true),\n                origin: kendo.getter('HIERARCHY_ORIGIN[\\'#text\\']', true),\n                defaultMember: kendo.getter('DEFAULT_MEMBER[\\'#text\\']', true)\n            },\n            levels: {\n                name: kendo.getter('LEVEL_NAME[\\'#text\\']', true),\n                caption: kendo.getter('LEVEL_CAPTION[\\'#text\\']', true),\n                description: kendo.getter('DESCRIPTION[\\'#text\\']', true),\n                uniqueName: kendo.getter('LEVEL_UNIQUE_NAME[\\'#text\\']', true),\n                dimensionUniqueName: kendo.getter('DIMENSION_UNIQUE_NAME[\\'#text\\']', true),\n                displayFolder: kendo.getter('LEVEL_DISPLAY_FOLDER[\\'#text\\']', true),\n                orderingProperty: kendo.getter('LEVEL_ORDERING_PROPERTY[\\'#text\\']', true),\n                origin: kendo.getter('LEVEL_ORIGIN[\\'#text\\']', true),\n                hierarchyUniqueName: kendo.getter('HIERARCHY_UNIQUE_NAME[\\'#text\\']', true)\n            },\n            members: {\n                name: kendo.getter('MEMBER_NAME[\\'#text\\']', true),\n                caption: kendo.getter('MEMBER_CAPTION[\\'#text\\']', true),\n                uniqueName: kendo.getter('MEMBER_UNIQUE_NAME[\\'#text\\']', true),\n                dimensionUniqueName: kendo.getter('DIMENSION_UNIQUE_NAME[\\'#text\\']', true),\n                hierarchyUniqueName: kendo.getter('HIERARCHY_UNIQUE_NAME[\\'#text\\']', true),\n                levelUniqueName: kendo.getter('LEVEL_UNIQUE_NAME[\\'#text\\']', true),\n                childrenCardinality: kendo.getter('CHILDREN_CARDINALITY[\\'#text\\']', true)\n            }\n        };\n        var xmlaReaderMethods = [\n            'axes',\n            'catalogs',\n            'cubes',\n            'dimensions',\n            'hierarchies',\n            'levels',\n            'measures'\n        ];\n        var XmlaDataReader = kendo.data.XmlDataReader.extend({\n            init: function (options) {\n                kendo.data.XmlDataReader.call(this, options);\n                this._extend(options);\n            },\n            _extend: function (options) {\n                var idx = 0;\n                var length = xmlaReaderMethods.length;\n                var methodName;\n                var option;\n                for (; idx < length; idx++) {\n                    methodName = xmlaReaderMethods[idx];\n                    option = options[methodName];\n                    if (option && option !== identity) {\n                        this[methodName] = option;\n                    }\n                }\n            },\n            parse: function (xml) {\n                var result = kendo.data.XmlDataReader.fn.parse(xml.replace(/<(\\/?)(\\w|-)+:/g, '<$1'));\n                return kendo.getter('[\\'Envelope\\'][\\'Body\\']', true)(result);\n            },\n            errors: function (root) {\n                var fault = kendo.getter('[\\'Fault\\']', true)(root);\n                if (fault) {\n                    return [{\n                            faultstring: kendo.getter('faultstring[\\'#text\\']', true)(fault),\n                            faultcode: kendo.getter('faultcode[\\'#text\\']', true)(fault)\n                        }];\n                }\n                return null;\n            },\n            axes: function (root) {\n                root = kendo.getter('ExecuteResponse[\"return\"].root', true)(root);\n                var axes = asArray(kendo.getter('Axes.Axis', true)(root));\n                var axis;\n                var result = {\n                    columns: {},\n                    rows: {}\n                };\n                for (var idx = 0; idx < axes.length; idx++) {\n                    axis = axes[idx];\n                    if (axis['@name'].toLowerCase() !== 'sliceraxis') {\n                        if (!result.columns.tuples) {\n                            result.columns = translateAxis(axis);\n                        } else {\n                            result.rows = translateAxis(axis);\n                        }\n                    }\n                }\n                return result;\n            },\n            data: function (root) {\n                root = kendo.getter('ExecuteResponse[\"return\"].root', true)(root);\n                var cells = asArray(kendo.getter('CellData.Cell', true)(root));\n                var result = [];\n                var ordinalGetter = kendo.getter('[\\'@CellOrdinal\\']');\n                var valueGetter = kendo.getter('Value[\\'#text\\']');\n                var fmtValueGetter = kendo.getter('FmtValue[\\'#text\\']');\n                for (var idx = 0; idx < cells.length; idx++) {\n                    result.push({\n                        value: valueGetter(cells[idx]),\n                        fmtValue: fmtValueGetter(cells[idx]),\n                        ordinal: parseInt(ordinalGetter(cells[idx]), 10)\n                    });\n                }\n                return result;\n            },\n            _mapSchema: function (root, getters) {\n                root = kendo.getter('DiscoverResponse[\"return\"].root', true)(root);\n                var rows = asArray(kendo.getter('row', true)(root));\n                var result = [];\n                for (var idx = 0; idx < rows.length; idx++) {\n                    var obj = {};\n                    for (var key in getters) {\n                        obj[key] = getters[key](rows[idx]);\n                    }\n                    result.push(obj);\n                }\n                return result;\n            },\n            measures: function (root) {\n                return this._mapSchema(root, schemaDataReaderMap.measures);\n            },\n            kpis: function (root) {\n                return this._mapSchema(root, schemaDataReaderMap.kpis);\n            },\n            hierarchies: function (root) {\n                return this._mapSchema(root, schemaDataReaderMap.hierarchies);\n            },\n            levels: function (root) {\n                return this._mapSchema(root, schemaDataReaderMap.levels);\n            },\n            dimensions: function (root) {\n                return this._mapSchema(root, schemaDataReaderMap.dimensions);\n            },\n            cubes: function (root) {\n                return this._mapSchema(root, schemaDataReaderMap.cubes);\n            },\n            catalogs: function (root) {\n                return this._mapSchema(root, schemaDataReaderMap.catalogs);\n            },\n            members: function (root) {\n                return this._mapSchema(root, schemaDataReaderMap.members);\n            }\n        });\n        extend(true, kendo.data, {\n            PivotDataSource: PivotDataSource,\n            XmlaTransport: XmlaTransport,\n            XmlaDataReader: XmlaDataReader,\n            PivotCubeBuilder: PivotCubeBuilder,\n            transports: { xmla: XmlaTransport },\n            readers: { xmla: XmlaDataReader }\n        });\n        var sortExpr = function (expressions, name) {\n            if (!expressions) {\n                return null;\n            }\n            for (var idx = 0, length = expressions.length; idx < length; idx++) {\n                if (expressions[idx].field === name) {\n                    return expressions[idx];\n                }\n            }\n            return null;\n        };\n        var removeExpr = function (expressions, name) {\n            var result = [];\n            for (var idx = 0, length = expressions.length; idx < length; idx++) {\n                if (expressions[idx].field !== name) {\n                    result.push(expressions[idx]);\n                }\n            }\n            return result;\n        };\n        kendo.ui.PivotSettingTarget = Widget.extend({\n            init: function (element, options) {\n                var that = this;\n                Widget.fn.init.call(that, element, options);\n                that.element.addClass('k-pivot-setting');\n                that.dataSource = kendo.data.PivotDataSource.create(options.dataSource);\n                that._refreshHandler = $.proxy(that.refresh, that);\n                that.dataSource.first(CHANGE, that._refreshHandler);\n                if (!options.template) {\n                    that.options.template = '<div data-' + kendo.ns + 'name=\"${data.name || data}\">${data.name || data}' + (that.options.enabled ? '<a class=\"k-button k-button-icon k-flat\"><span class=\"k-icon k-i-close k-setting-delete\"></span></a>' : '') + '</div>';\n                }\n                that.template = kendo.template(that.options.template);\n                that.emptyTemplate = kendo.template(that.options.emptyTemplate);\n                that._sortable();\n                that.element.on('click' + NS, '.k-button,.k-item', function (e) {\n                    var target = $(e.target);\n                    var name = target.closest('[' + kendo.attr('name') + ']').attr(kendo.attr('name'));\n                    if (!name) {\n                        return;\n                    }\n                    if (target.hasClass('k-i-close')) {\n                        that.remove(name);\n                    } else if (that.options.sortable && target[0] === e.currentTarget) {\n                        that.sort({\n                            field: name,\n                            dir: target.find('.k-i-sort-asc-sm')[0] ? 'desc' : 'asc'\n                        });\n                    }\n                });\n                if (options.filterable || options.sortable) {\n                    that.fieldMenu = new ui.PivotFieldMenu(that.element, {\n                        messages: that.options.messages.fieldMenu,\n                        filter: '.k-setting-fieldmenu',\n                        filterable: options.filterable,\n                        sortable: options.sortable,\n                        dataSource: that.dataSource\n                    });\n                }\n                that.refresh();\n            },\n            options: {\n                name: 'PivotSettingTarget',\n                template: null,\n                filterable: false,\n                sortable: false,\n                emptyTemplate: '<div class=\\'k-empty\\'>${data}</div>',\n                setting: 'columns',\n                enabled: true,\n                messages: { empty: 'Drop Fields Here' }\n            },\n            setDataSource: function (dataSource) {\n                this.dataSource.unbind(CHANGE, this._refreshHandler);\n                this.dataSource = this.options.dataSource = dataSource;\n                if (this.fieldMenu) {\n                    this.fieldMenu.setDataSource(dataSource);\n                }\n                dataSource.first(CHANGE, this._refreshHandler);\n                this.refresh();\n            },\n            _sortable: function () {\n                var that = this;\n                if (that.options.enabled) {\n                    this.sortable = this.element.kendoSortable({\n                        connectWith: this.options.connectWith,\n                        hint: that.options.hint,\n                        filter: '>*:not(.k-empty)',\n                        cursor: 'move',\n                        start: function (e) {\n                            e.item.focus().blur();\n                        },\n                        change: function (e) {\n                            var name = e.item.attr(kendo.attr('name'));\n                            if (e.action == 'receive') {\n                                that.add(name);\n                            } else if (e.action == 'remove') {\n                                that.remove(name);\n                            } else if (e.action == 'sort') {\n                                that.move(name, e.newIndex);\n                            }\n                        }\n                    }).data('kendoSortable');\n                }\n            },\n            _indexOf: function (name, items) {\n                var idx, length, index = -1;\n                for (idx = 0, length = items.length; idx < length; idx++) {\n                    if (getName(items[idx]) === name) {\n                        index = idx;\n                        break;\n                    }\n                }\n                return index;\n            },\n            _isKPI: function (data) {\n                return data.type === 'kpi' || data.measure;\n            },\n            validate: function (data) {\n                var isMeasure = data.type == 2 || 'aggregator' in data || this._isKPI(data);\n                if (isMeasure) {\n                    return this.options.setting === 'measures';\n                }\n                if (this.options.setting === 'measures') {\n                    return isMeasure;\n                }\n                var items = this.dataSource[this.options.setting]();\n                var name = data.defaultHierarchy || data.uniqueName;\n                if (this._indexOf(name, items) > -1) {\n                    return false;\n                }\n                items = this.dataSource[this.options.setting === 'columns' ? 'rows' : 'columns']();\n                if (this._indexOf(name, items) > -1) {\n                    return false;\n                }\n                return true;\n            },\n            add: function (name) {\n                var items = this.dataSource[this.options.setting]();\n                var i, l;\n                name = $.isArray(name) ? name.slice(0) : [name];\n                for (i = 0, l = name.length; i < l; i++) {\n                    if (this._indexOf(name[i], items) !== -1) {\n                        name.splice(i, 1);\n                        i -= 1;\n                        l -= 1;\n                    }\n                }\n                if (name.length) {\n                    items = items.concat(name);\n                    this.dataSource[this.options.setting](items);\n                }\n            },\n            move: function (name, index) {\n                var items = this.dataSource[this.options.setting]();\n                var idx = this._indexOf(name, items);\n                if (idx > -1) {\n                    name = items.splice(idx, 1)[0];\n                    items.splice(index, 0, name);\n                    this.dataSource[this.options.setting](items);\n                }\n            },\n            remove: function (name) {\n                var items = this.dataSource[this.options.setting]();\n                var idx = this._indexOf(name, items);\n                var sortExpressions = this.dataSource.sort();\n                var filter = this.dataSource.filter();\n                if (idx > -1) {\n                    if (filter) {\n                        filter.filters = removeExpr(filter.filters, name);\n                        this.dataSource._filter.filters = filter.filters;\n                        if (!filter.filters.length) {\n                            this.dataSource._filter = null;\n                        }\n                    }\n                    if (sortExpressions) {\n                        sortExpressions = removeExpr(sortExpressions, name);\n                        this.dataSource._sort = sortExpressions;\n                    }\n                    items.splice(idx, 1);\n                    this.dataSource[this.options.setting](items);\n                }\n            },\n            sort: function (expr) {\n                var sortable = this.options.sortable;\n                var allowUnsort = sortable === true || sortable.allowUnsort;\n                var skipExpr = allowUnsort && expr.dir === 'asc';\n                var expressions = this.dataSource.sort() || [];\n                var result = removeExpr(expressions, expr.field);\n                if (skipExpr && expressions.length !== result.length) {\n                    expr = null;\n                }\n                if (expr) {\n                    result.push(expr);\n                }\n                this.dataSource.sort(result);\n            },\n            refresh: function () {\n                var html = '';\n                var items = this.dataSource[this.options.setting]();\n                var length = items.length;\n                var idx = 0;\n                var item;\n                if (length) {\n                    for (; idx < length; idx++) {\n                        item = items[idx];\n                        item = item.name === undefined ? { name: item } : item;\n                        html += this.template(extend({ sortIcon: this._sortIcon(item.name) }, item));\n                    }\n                } else {\n                    html = this.emptyTemplate(this.options.messages.empty);\n                }\n                this.element.html(html);\n            },\n            destroy: function () {\n                Widget.fn.destroy.call(this);\n                this.dataSource.unbind(CHANGE, this._refreshHandler);\n                this.element.off(NS);\n                if (this.sortable) {\n                    this.sortable.destroy();\n                }\n                if (this.fieldMenu) {\n                    this.fieldMenu.destroy();\n                }\n                this.element = null;\n                this._refreshHandler = null;\n            },\n            _sortIcon: function (name) {\n                var expressions = this.dataSource.sort();\n                var expr = sortExpr(expressions, getName(name));\n                var icon = '';\n                if (expr) {\n                    icon = 'k-i-sort-' + expr.dir;\n                }\n                return icon;\n            }\n        });\n        var PivotGrid = Widget.extend({\n            init: function (element, options) {\n                var that = this;\n                var columnBuilder;\n                var rowBuilder;\n                Widget.fn.init.call(that, element, options);\n                that._dataSource();\n                that._bindConfigurator();\n                that._wrapper();\n                that._createLayout();\n                that._columnBuilder = columnBuilder = new ColumnBuilder();\n                that._rowBuilder = rowBuilder = new RowBuilder();\n                that._contentBuilder = new ContentBuilder();\n                that._templates();\n                that.columnsHeader.add(that.rowsHeader).on('click', 'span.k-icon', function () {\n                    var button = $(this);\n                    var builder = columnBuilder;\n                    var action = 'expandColumn';\n                    var eventName;\n                    var path = button.attr(kendo.attr('path'));\n                    var eventArgs = {\n                        axis: 'columns',\n                        path: $.parseJSON(path)\n                    };\n                    if (button.parent().is('td')) {\n                        builder = rowBuilder;\n                        action = 'expandRow';\n                        eventArgs.axis = 'rows';\n                    }\n                    var expanded = button.hasClass(STATE_EXPANDED);\n                    var metadata = builder.metadata[path];\n                    var request = metadata.expanded === undefined;\n                    eventName = expanded ? COLLAPSEMEMBER : EXPANDMEMBER;\n                    eventArgs.childrenLoaded = metadata.maxChildren > metadata.children;\n                    if (that.trigger(eventName, eventArgs)) {\n                        return;\n                    }\n                    builder.metadata[path].expanded = !expanded;\n                    button.toggleClass(STATE_EXPANDED, !expanded).toggleClass(STATE_COLLAPSED, expanded);\n                    if (!expanded && request) {\n                        that.dataSource[action](eventArgs.path);\n                    } else {\n                        that.refresh();\n                    }\n                });\n                that._scrollable();\n                if (that.options.autoBind) {\n                    that.dataSource.fetch();\n                }\n                kendo.notify(that);\n            },\n            events: [\n                DATABINDING,\n                DATABOUND,\n                EXPANDMEMBER,\n                COLLAPSEMEMBER\n            ],\n            options: {\n                name: 'PivotGrid',\n                autoBind: true,\n                reorderable: true,\n                filterable: false,\n                sortable: false,\n                height: null,\n                columnWidth: 100,\n                configurator: '',\n                columnHeaderTemplate: null,\n                rowHeaderTemplate: null,\n                dataCellTemplate: null,\n                kpiStatusTemplate: null,\n                kpiTrendTemplate: null,\n                messages: {\n                    measureFields: 'Drop Data Fields Here',\n                    columnFields: 'Drop Column Fields Here',\n                    rowFields: 'Drop Rows Fields Here'\n                }\n            },\n            _templates: function () {\n                var columnTemplate = this.options.columnHeaderTemplate;\n                var rowTemplate = this.options.rowHeaderTemplate;\n                var dataTemplate = this.options.dataCellTemplate;\n                var kpiStatusTemplate = this.options.kpiStatusTemplate;\n                var kpiTrendTemplate = this.options.kpiTrendTemplate;\n                this._columnBuilder.template = kendo.template(columnTemplate || HEADER_TEMPLATE, { useWithBlock: !!columnTemplate });\n                this._contentBuilder.dataTemplate = kendo.template(dataTemplate || DATACELL_TEMPLATE, { useWithBlock: !!dataTemplate });\n                this._contentBuilder.kpiStatusTemplate = kendo.template(kpiStatusTemplate || KPISTATUS_TEMPLATE, { useWithBlock: !!kpiStatusTemplate });\n                this._contentBuilder.kpiTrendTemplate = kendo.template(kpiTrendTemplate || KPITREND_TEMPLATE, { useWithBlock: !!kpiTrendTemplate });\n                this._rowBuilder.template = kendo.template(rowTemplate || HEADER_TEMPLATE, { useWithBlock: !!rowTemplate });\n            },\n            _bindConfigurator: function () {\n                var configurator = this.options.configurator;\n                if (configurator) {\n                    $(configurator).kendoPivotConfigurator('setDataSource', this.dataSource);\n                }\n            },\n            cellInfoByElement: function (element) {\n                element = $(element);\n                return this.cellInfo(element.index(), element.parent('tr').index());\n            },\n            cellInfo: function (columnIndex, rowIndex) {\n                var contentBuilder = this._contentBuilder;\n                var columnInfo = contentBuilder.columnIndexes[columnIndex || 0];\n                var rowInfo = contentBuilder.rowIndexes[rowIndex || 0];\n                var dataIndex;\n                if (!columnInfo || !rowInfo) {\n                    return null;\n                }\n                dataIndex = rowInfo.index * contentBuilder.rowLength + columnInfo.index;\n                return {\n                    columnTuple: columnInfo.tuple,\n                    rowTuple: rowInfo.tuple,\n                    measure: columnInfo.measure || rowInfo.measure,\n                    dataItem: this.dataSource.view()[dataIndex]\n                };\n            },\n            setDataSource: function (dataSource) {\n                this.options.dataSource = dataSource;\n                this._dataSource();\n                if (this.measuresTarget) {\n                    this.measuresTarget.setDataSource(dataSource);\n                }\n                if (this.rowsTarget) {\n                    this.rowsTarget.setDataSource(dataSource);\n                }\n                if (this.columnsTarget) {\n                    this.columnsTarget.setDataSource(dataSource);\n                }\n                this._bindConfigurator();\n                if (this.options.autoBind) {\n                    dataSource.fetch();\n                }\n            },\n            setOptions: function (options) {\n                Widget.fn.setOptions.call(this, options);\n                this._templates();\n            },\n            destroy: function () {\n                Widget.fn.destroy.call(this);\n                clearTimeout(this._headerReflowTimeout);\n            },\n            _dataSource: function () {\n                var that = this;\n                var dataSource = that.options.dataSource;\n                dataSource = $.isArray(dataSource) ? { data: dataSource } : dataSource;\n                if (that.dataSource && this._refreshHandler) {\n                    that.dataSource.unbind(CHANGE, that._refreshHandler).unbind(STATERESET, that._stateResetHandler).unbind(PROGRESS, that._progressHandler).unbind(ERROR, that._errorHandler);\n                } else {\n                    that._refreshHandler = $.proxy(that.refresh, that);\n                    that._progressHandler = $.proxy(that._requestStart, that);\n                    that._stateResetHandler = $.proxy(that._stateReset, that);\n                    that._errorHandler = $.proxy(that._error, that);\n                }\n                that.dataSource = kendo.data.PivotDataSource.create(dataSource).bind(CHANGE, that._refreshHandler).bind(PROGRESS, that._progressHandler).bind(STATERESET, that._stateResetHandler).bind(ERROR, that._errorHandler);\n            },\n            _error: function () {\n                this._progress(false);\n            },\n            _requestStart: function () {\n                this._progress(true);\n            },\n            _stateReset: function () {\n                this._columnBuilder.reset();\n                this._rowBuilder.reset();\n            },\n            _wrapper: function () {\n                var height = this.options.height;\n                this.wrapper = this.element.addClass('k-widget k-pivot');\n                if (height) {\n                    this.wrapper.css('height', height);\n                }\n            },\n            _measureFields: function () {\n                this.measureFields = $(DIV).addClass('k-pivot-toolbar k-header k-settings-measures');\n                this.measuresTarget = this._createSettingTarget(this.measureFields, {\n                    setting: 'measures',\n                    messages: { empty: this.options.messages.measureFields }\n                });\n            },\n            _createSettingTarget: function (element, options) {\n                var template = '<span tabindex=\"0\" class=\"k-button\" data-' + kendo.ns + 'name=\"${data.name}\">${data.name}';\n                var sortable = options.sortable;\n                var icons = '';\n                if (sortable) {\n                    icons += '#if (data.sortIcon) {#';\n                    icons += '<span class=\"k-icon ${data.sortIcon}-sm\"></span>';\n                    icons += '#}#';\n                }\n                if (options.filterable || sortable) {\n                    icons += '<span class=\"k-icon k-i-more-vertical k-setting-fieldmenu\"></span>';\n                }\n                if (this.options.reorderable) {\n                    icons += '<span class=\"k-icon k-i-close k-setting-delete\"></span>';\n                }\n                if (icons) {\n                    template += '<span class=\"k-field-actions\">' + icons + '</span>';\n                }\n                template += '</span>';\n                return new kendo.ui.PivotSettingTarget(element, $.extend({\n                    template: template,\n                    emptyTemplate: '<span class=\"k-empty\">${data}</span>',\n                    enabled: this.options.reorderable,\n                    dataSource: this.dataSource\n                }, options));\n            },\n            _initSettingTargets: function () {\n                this.columnsTarget = this._createSettingTarget(this.columnFields, {\n                    connectWith: this.rowFields,\n                    setting: 'columns',\n                    filterable: this.options.filterable,\n                    sortable: this.options.sortable,\n                    messages: {\n                        empty: this.options.messages.columnFields,\n                        fieldMenu: this.options.messages.fieldMenu\n                    }\n                });\n                this.rowsTarget = this._createSettingTarget(this.rowFields, {\n                    connectWith: this.columnFields,\n                    setting: 'rows',\n                    filterable: this.options.filterable,\n                    sortable: this.options.sortable,\n                    messages: {\n                        empty: this.options.messages.rowFields,\n                        fieldMenu: this.options.messages.fieldMenu\n                    }\n                });\n            },\n            _createLayout: function () {\n                var that = this;\n                var layoutTable = $(LAYOUT_TABLE);\n                var leftContainer = layoutTable.find('.k-pivot-rowheaders');\n                var rightContainer = layoutTable.find('.k-pivot-table');\n                var gridWrapper = $(DIV).addClass('k-grid k-widget');\n                that._measureFields();\n                that.columnFields = $(DIV).addClass('k-pivot-toolbar k-header k-settings-columns');\n                that.rowFields = $(DIV).addClass('k-pivot-toolbar k-header k-settings-rows');\n                that.columnsHeader = $('<div class=\"k-grid-header-wrap\" />').wrap('<div class=\"k-grid-header\" />');\n                that.columnsHeader.parent().css('padding-right', kendo.support.scrollbar());\n                that.rowsHeader = $('<div class=\"k-grid k-widget k-alt\"/>');\n                that.content = $('<div class=\"k-grid-content\" />');\n                leftContainer.append(that.measureFields);\n                leftContainer.append(that.rowFields);\n                leftContainer.append(that.rowsHeader);\n                gridWrapper.append(that.columnsHeader.parent());\n                gridWrapper.append(that.content);\n                rightContainer.append(that.columnFields);\n                rightContainer.append(gridWrapper);\n                that.wrapper.append(layoutTable);\n                that.columnsHeaderTree = new kendo.dom.Tree(that.columnsHeader[0]);\n                that.rowsHeaderTree = new kendo.dom.Tree(that.rowsHeader[0]);\n                that.contentTree = new kendo.dom.Tree(that.content[0]);\n                that._initSettingTargets();\n            },\n            _progress: function (toggle) {\n                kendo.ui.progress(this.wrapper, toggle);\n            },\n            _resize: function () {\n                if (this.content[0].firstChild) {\n                    this._setSectionsWidth();\n                    this._setSectionsHeight();\n                    this._setContentWidth();\n                    this._setContentHeight();\n                    this._columnHeaderReflow();\n                }\n            },\n            _columnHeaderReflow: function () {\n                var columnTable = this.columnsHeader.children('table');\n                if (!kendo.support.browser.mozilla) {\n                    return;\n                }\n                clearTimeout(this._headerReflowTimeout);\n                columnTable.css('table-layout', 'auto');\n                this._headerReflowTimeout = setTimeout(function () {\n                    columnTable.css('table-layout', '');\n                });\n            },\n            _setSectionsWidth: function () {\n                var rowsHeader = this.rowsHeader;\n                var leftColumn = rowsHeader.parent('.k-pivot-rowheaders').width(AUTO);\n                var width;\n                width = Math.max(outerWidth(this.measureFields), outerWidth(this.rowFields));\n                width = Math.max(rowsHeader.children('table').width(), width);\n                leftColumn.width(width);\n            },\n            _setSectionsHeight: function () {\n                var measureFieldsHeight = this.measureFields.height(AUTO).height();\n                var columnFieldsHeight = this.columnFields.height(AUTO).height();\n                var rowFieldsHeight = this.rowFields.height(AUTO).innerHeight();\n                var columnsHeight = this.columnsHeader.height(AUTO).innerHeight();\n                var padding = rowFieldsHeight - this.rowFields.height();\n                var firstRowHeight = columnFieldsHeight > measureFieldsHeight ? columnFieldsHeight : measureFieldsHeight;\n                var secondRowHeight = columnsHeight > rowFieldsHeight ? columnsHeight : rowFieldsHeight;\n                this.measureFields.height(firstRowHeight);\n                this.columnFields.height(firstRowHeight);\n                this.rowFields.height(secondRowHeight - padding);\n                this.columnsHeader.height(secondRowHeight);\n            },\n            _setContentWidth: function () {\n                var contentTable = this.content.find('table');\n                var columnTable = this.columnsHeader.children('table');\n                var rowLength = contentTable.children('colgroup').children().length;\n                var calculatedWidth = rowLength * this.options.columnWidth;\n                var minWidth = Math.ceil(calculatedWidth / this.content.width() * 100);\n                if (minWidth < 100) {\n                    minWidth = 100;\n                }\n                contentTable.add(columnTable).css('width', minWidth + '%');\n                this._resetColspan(columnTable);\n            },\n            _setContentHeight: function () {\n                var that = this;\n                var content = that.content;\n                var rowsHeader = that.rowsHeader;\n                var innerHeight = that.wrapper.innerHeight();\n                var scrollbar = kendo.support.scrollbar();\n                var skipScrollbar = content[0].offsetHeight === content[0].clientHeight;\n                var height = that.options.height;\n                if (that.wrapper.is(':visible')) {\n                    if (!innerHeight || !height) {\n                        if (skipScrollbar) {\n                            scrollbar = 0;\n                        }\n                        content.height('auto');\n                        rowsHeader.height(content.height() - scrollbar);\n                        return;\n                    }\n                    innerHeight -= outerHeight(that.columnFields);\n                    innerHeight -= outerHeight(that.columnsHeader.parent());\n                    if (innerHeight <= scrollbar * 2) {\n                        innerHeight = scrollbar * 2 + 1;\n                        if (!skipScrollbar) {\n                            innerHeight += scrollbar;\n                        }\n                    }\n                    content.height(innerHeight);\n                    if (skipScrollbar) {\n                        scrollbar = 0;\n                    }\n                    rowsHeader.height(innerHeight - scrollbar);\n                }\n            },\n            _resetColspan: function (columnTable) {\n                var that = this;\n                var cell = columnTable.children('tbody').children(':first').children(':first');\n                if (that._colspan === undefined) {\n                    that._colspan = cell.attr('colspan');\n                }\n                cell.attr('colspan', 1);\n                clearTimeout(that._layoutTimeout);\n                that._layoutTimeout = setTimeout(function () {\n                    cell.attr('colspan', that._colspan);\n                    that._colspan = undefined;\n                });\n            },\n            _axisMeasures: function (axis) {\n                var result = [];\n                var dataSource = this.dataSource;\n                var measures = dataSource.measures();\n                var hasMeasure = measures.length > 1 || measures[0] && measures[0].type;\n                if (dataSource.measuresAxis() === axis) {\n                    if (dataSource[axis]().length === 0 || hasMeasure) {\n                        result = measures;\n                    }\n                }\n                return result;\n            },\n            items: function () {\n                return [];\n            },\n            refresh: function () {\n                var that = this;\n                var dataSource = that.dataSource;\n                var axes = dataSource.axes();\n                var columns = (axes.columns || {}).tuples || [];\n                var rows = (axes.rows || {}).tuples || [];\n                var columnBuilder = that._columnBuilder;\n                var rowBuilder = that._rowBuilder;\n                var columnAxis = {};\n                var rowAxis = {};\n                if (that.trigger(DATABINDING, { action: 'rebind' })) {\n                    return;\n                }\n                columnBuilder.measures = that._axisMeasures(AXIS_COLUMNS);\n                rowBuilder.measures = that._axisMeasures(AXIS_ROWS);\n                that.columnsHeaderTree.render(columnBuilder.build(columns));\n                that.rowsHeaderTree.render(rowBuilder.build(rows));\n                columnAxis = {\n                    indexes: columnBuilder._indexes,\n                    measures: columnBuilder.measures,\n                    metadata: columnBuilder.metadata\n                };\n                rowAxis = {\n                    indexes: rowBuilder._indexes,\n                    measures: rowBuilder.measures,\n                    metadata: rowBuilder.metadata\n                };\n                that.contentTree.render(that._contentBuilder.build(dataSource.view(), columnAxis, rowAxis));\n                that._resize();\n                if (that.touchScroller) {\n                    that.touchScroller.contentResized();\n                } else {\n                    var touchScroller = kendo.touchScroller(that.content);\n                    if (touchScroller && touchScroller.movable) {\n                        that.touchScroller = touchScroller;\n                        touchScroller.movable.bind('change', function (e) {\n                            that.columnsHeader.scrollLeft(-e.sender.x);\n                            that.rowsHeader.scrollTop(-e.sender.y);\n                        });\n                    }\n                }\n                that._progress(false);\n                that.trigger(DATABOUND);\n            },\n            _scrollable: function () {\n                var that = this;\n                var columnsHeader = that.columnsHeader;\n                var rowsHeader = that.rowsHeader;\n                that.content.scroll(function () {\n                    columnsHeader.scrollLeft(this.scrollLeft);\n                    rowsHeader.scrollTop(this.scrollTop);\n                });\n                rowsHeader.bind('DOMMouseScroll' + NS + ' mousewheel' + NS, $.proxy(that._wheelScroll, that));\n            },\n            _wheelScroll: function (e) {\n                if (e.ctrlKey) {\n                    return;\n                }\n                var delta = kendo.wheelDeltaY(e);\n                var scrollTop = this.content.scrollTop();\n                if (delta) {\n                    e.preventDefault();\n                    $(e.currentTarget).one('wheel' + NS, false);\n                    this.rowsHeader.scrollTop(scrollTop + -delta);\n                    this.content.scrollTop(scrollTop + -delta);\n                }\n            }\n        });\n        var element = kendo.dom.element;\n        var htmlNode = kendo.dom.html;\n        var createMetadata = function (levelNum, memberIdx) {\n            return {\n                maxChildren: 0,\n                children: 0,\n                maxMembers: 0,\n                members: 0,\n                measures: 1,\n                levelNum: levelNum,\n                parentMember: memberIdx !== 0\n            };\n        };\n        var buildPath = function (tuple, index) {\n            var path = [];\n            var idx = 0;\n            for (; idx <= index; idx++) {\n                path.push(tuple.members[idx].name);\n            }\n            return path;\n        };\n        var tupleName = function (tuple, index) {\n            var name = '';\n            var idx = 0;\n            for (; idx <= index; idx++) {\n                name += tuple.members[idx].name;\n            }\n            return name;\n        };\n        var ColumnBuilder = Class.extend({\n            init: function () {\n                this.measures = 1;\n                this.metadata = {};\n            },\n            build: function (tuples) {\n                var tbody = this._tbody(tuples);\n                var colgroup = this._colGroup();\n                return [element('table', null, [\n                        colgroup,\n                        tbody\n                    ])];\n            },\n            reset: function () {\n                this.metadata = {};\n            },\n            _colGroup: function () {\n                var length = this._rowLength();\n                var children = [];\n                var idx = 0;\n                for (; idx < length; idx++) {\n                    children.push(element('col', null));\n                }\n                return element('colgroup', null, children);\n            },\n            _tbody: function (tuples) {\n                var root = tuples[0];\n                this.map = {};\n                this.rows = [];\n                this.rootTuple = root;\n                this._indexes = [];\n                if (root) {\n                    this._buildRows(root, 0);\n                    this._normalize();\n                } else {\n                    this.rows.push(element('tr', null, [element('th', null, [htmlNode('&nbsp;')])]));\n                }\n                return element('tbody', null, this.rows);\n            },\n            _normalize: function () {\n                var rows = this.rows;\n                var rowsLength = rows.length;\n                var rowIdx = 0;\n                var row;\n                var cellsLength;\n                var cellIdx;\n                var cells;\n                var cell;\n                for (; rowIdx < rowsLength; rowIdx++) {\n                    row = rows[rowIdx];\n                    if (row.rowSpan === 1) {\n                        continue;\n                    }\n                    cells = row.children;\n                    cellIdx = 0;\n                    cellsLength = cells.length;\n                    for (; cellIdx < cellsLength; cellIdx++) {\n                        cell = cells[cellIdx];\n                        if (cell.tupleAll) {\n                            cell.attr.rowSpan = row.rowSpan;\n                        }\n                    }\n                }\n            },\n            _rowIndex: function (row) {\n                var rows = this.rows;\n                var length = rows.length;\n                var idx = 0;\n                for (; idx < length; idx++) {\n                    if (rows[idx] === row) {\n                        break;\n                    }\n                }\n                return idx;\n            },\n            _rowLength: function () {\n                var cells = this.rows[0] ? this.rows[0].children : [];\n                var length = cells.length;\n                var rowLength = 0;\n                var idx = 0;\n                if (length) {\n                    for (; idx < length; idx++) {\n                        rowLength += cells[idx].attr.colSpan || 1;\n                    }\n                }\n                if (!rowLength) {\n                    rowLength = this.measures;\n                }\n                return rowLength;\n            },\n            _row: function (tuple, memberIdx, parentMember) {\n                var rootName = this.rootTuple.members[memberIdx].name;\n                var levelNum = tuple.members[memberIdx].levelNum;\n                var rowKey = rootName + levelNum;\n                var map = this.map;\n                var parentRow;\n                var children;\n                var row = map[rowKey];\n                if (!row) {\n                    row = element('tr', null, []);\n                    row.parentMember = parentMember;\n                    row.collapsed = 0;\n                    row.colSpan = 0;\n                    row.rowSpan = 1;\n                    map[rowKey] = row;\n                    parentRow = map[rootName + (Number(levelNum) - 1)];\n                    if (parentRow) {\n                        children = parentRow.children;\n                        if (children[1] && children[1].attr.className.indexOf('k-alt') === -1) {\n                            row.notFirst = true;\n                        } else {\n                            row.notFirst = parentRow.notFirst;\n                        }\n                    }\n                    this.rows.splice(this._rowIndex(parentRow) + 1, 0, row);\n                } else {\n                    row.notFirst = false;\n                    if (!row.parentMember || row.parentMember !== parentMember) {\n                        row.parentMember = parentMember;\n                        row.collapsed = 0;\n                        row.colSpan = 0;\n                    }\n                }\n                return row;\n            },\n            _measures: function (measures, tuple, className) {\n                var map = this.map;\n                var row = map.measureRow;\n                var measure;\n                if (!row) {\n                    row = element('tr', null, []);\n                    map.measureRow = row;\n                    this.rows.push(row);\n                }\n                for (var idx = 0, length = measures.length; idx < length; idx++) {\n                    measure = measures[idx];\n                    row.children.push(this._cell(className || '', [this._content(measure, tuple)], measure));\n                }\n                return length;\n            },\n            _content: function (member, tuple) {\n                return htmlNode(this.template({\n                    member: member,\n                    tuple: tuple\n                }));\n            },\n            _cell: function (className, children, member) {\n                var cell = element('th', { className: 'k-header' + className }, children);\n                cell.value = member.caption || member.name;\n                return cell;\n            },\n            _buildRows: function (tuple, memberIdx, parentMember) {\n                var members = tuple.members;\n                var member = members[memberIdx];\n                var nextMember = members[memberIdx + 1];\n                var row, childRow, children, childrenLength;\n                var cell, allCell, cellAttr;\n                var cellChildren = [];\n                var path;\n                var idx = 0;\n                var metadata;\n                var colSpan;\n                var collapsed = 0;\n                var memberCollapsed = 0;\n                if (member.measure) {\n                    this._measures(member.children, tuple);\n                    return;\n                }\n                path = kendo.stringify(buildPath(tuple, memberIdx));\n                row = this._row(tuple, memberIdx, parentMember);\n                children = member.children;\n                childrenLength = children.length;\n                metadata = this.metadata[path];\n                if (!metadata) {\n                    this.metadata[path] = metadata = createMetadata(Number(member.levelNum), memberIdx);\n                    metadata.rootLevelNum = Number(this.rootTuple.members[memberIdx].levelNum);\n                }\n                this._indexes.push({\n                    path: path,\n                    tuple: tuple\n                });\n                if (member.hasChildren) {\n                    if (metadata.expanded === false) {\n                        collapsed = metadata.maxChildren;\n                        row.collapsed += collapsed;\n                        metadata.children = 0;\n                        childrenLength = 0;\n                    }\n                    cellAttr = { className: 'k-icon ' + (childrenLength ? STATE_EXPANDED : STATE_COLLAPSED) };\n                    cellAttr[kendo.attr('path')] = path;\n                    cellChildren.push(element('span', cellAttr));\n                }\n                cellChildren.push(this._content(member, tuple));\n                cell = this._cell(row.notFirst ? ' k-first' : '', cellChildren, member);\n                row.children.push(cell);\n                row.colSpan += 1;\n                if (childrenLength) {\n                    allCell = this._cell(' k-alt', [this._content(member, tuple)], member);\n                    row.children.push(allCell);\n                    for (; idx < childrenLength; idx++) {\n                        childRow = this._buildRows(children[idx], memberIdx, member);\n                    }\n                    colSpan = childRow.colSpan;\n                    collapsed = childRow.collapsed;\n                    cell.attr.colSpan = colSpan;\n                    metadata.children = colSpan;\n                    metadata.members = 1;\n                    row.colSpan += colSpan;\n                    row.collapsed += collapsed;\n                    row.rowSpan = childRow.rowSpan + 1;\n                    if (nextMember) {\n                        if (nextMember.measure) {\n                            colSpan = this._measures(nextMember.children, tuple, ' k-alt');\n                        } else {\n                            childRow = this._buildRows(tuple, memberIdx + 1);\n                            colSpan = childRow.colSpan;\n                            row.collapsed += childRow.collapsed;\n                            memberCollapsed = childRow.collapsed;\n                        }\n                        allCell.attr.colSpan = colSpan;\n                        colSpan -= 1;\n                        metadata.members += colSpan;\n                        row.colSpan += colSpan;\n                    }\n                } else if (nextMember) {\n                    if (nextMember.measure) {\n                        colSpan = this._measures(nextMember.children, tuple);\n                    } else {\n                        childRow = this._buildRows(tuple, memberIdx + 1);\n                        colSpan = childRow.colSpan;\n                        row.collapsed += childRow.collapsed;\n                        memberCollapsed = childRow.collapsed;\n                    }\n                    metadata.members = colSpan;\n                    if (colSpan > 1) {\n                        cell.attr.colSpan = colSpan;\n                        row.colSpan += colSpan - 1;\n                    }\n                }\n                if (metadata.maxMembers < metadata.members + memberCollapsed) {\n                    metadata.maxMembers = metadata.members + memberCollapsed;\n                }\n                children = metadata.children + collapsed;\n                if (metadata.maxChildren < children) {\n                    metadata.maxChildren = children;\n                }\n                (allCell || cell).tupleAll = true;\n                return row;\n            }\n        });\n        var RowBuilder = Class.extend({\n            init: function () {\n                this.metadata = {};\n            },\n            build: function (tuples) {\n                var tbody = this._tbody(tuples);\n                var colgroup = this._colGroup();\n                return [element('table', null, [\n                        colgroup,\n                        tbody\n                    ])];\n            },\n            reset: function () {\n                this.metadata = {};\n            },\n            _rowLength: function () {\n                var children = this.rows[0].children;\n                var length = 0;\n                var idx = 0;\n                var cell = children[idx];\n                while (cell) {\n                    length += cell.attr.colSpan || 1;\n                    cell = children[++idx];\n                }\n                return length;\n            },\n            _colGroup: function () {\n                var length = this._rowLength();\n                var children = [];\n                var idx = 0;\n                for (; idx < length; idx++) {\n                    children.push(element('col', null));\n                }\n                return element('colgroup', null, children);\n            },\n            _tbody: function (tuples) {\n                var root = tuples[0];\n                this.rootTuple = root;\n                this.rows = [];\n                this.map = {};\n                this._indexes = [];\n                if (root) {\n                    this._buildRows(root, 0);\n                    this._normalize();\n                } else {\n                    this.rows.push(element('tr', null, [element('td', null, [htmlNode('&nbsp;')])]));\n                }\n                return element('tbody', null, this.rows);\n            },\n            _normalize: function () {\n                var rows = this.rows;\n                var rowsLength = rows.length;\n                var rowIdx = 0;\n                var members = this.rootTuple.members;\n                var firstMemberName = members[0].name;\n                var membersLength = members.length;\n                var memberIdx = 0;\n                var row;\n                var cell;\n                var maxcolSpan;\n                var map = this.map;\n                var allRow;\n                for (; rowIdx < rowsLength; rowIdx++) {\n                    row = rows[rowIdx];\n                    for (memberIdx = 0; memberIdx < membersLength; memberIdx++) {\n                        maxcolSpan = this[members[memberIdx].name];\n                        cell = row.colSpan['dim' + memberIdx];\n                        if (cell && cell.colSpan < maxcolSpan) {\n                            cell.attr.colSpan = maxcolSpan - cell.colSpan + 1;\n                        }\n                    }\n                }\n                row = map[firstMemberName];\n                allRow = map[firstMemberName + 'all'];\n                if (row) {\n                    row.children[0].attr.className = 'k-first';\n                }\n                if (allRow) {\n                    allRow.children[0].attr.className += ' k-first';\n                }\n            },\n            _row: function (children) {\n                var row = element('tr', null, children);\n                row.rowSpan = 1;\n                row.colSpan = {};\n                this.rows.push(row);\n                return row;\n            },\n            _content: function (member, tuple) {\n                return htmlNode(this.template({\n                    member: member,\n                    tuple: tuple\n                }));\n            },\n            _cell: function (className, children, member) {\n                var cell = element('td', { className: className }, children);\n                cell.value = member.caption || member.name;\n                return cell;\n            },\n            _buildRows: function (tuple, memberIdx) {\n                var map = this.map;\n                var path;\n                var members = tuple.members;\n                var member = members[memberIdx];\n                var nextMember = members[memberIdx + 1];\n                var children = member.children;\n                var childrenLength = children.length;\n                var levelNum = Number(member.levelNum);\n                var rootName = this.rootTuple.members[memberIdx].name;\n                var tuplePath = buildPath(tuple, memberIdx - 1).join('');\n                var rootLevelNum = Number(this.rootTuple.members[memberIdx].levelNum);\n                var parentName = tuplePath + (rootLevelNum === levelNum ? '' : member.parentName || '');\n                var row = map[parentName + 'all'] || map[parentName];\n                var colSpan = levelNum + 1;\n                var cell, allCell;\n                var childRow, allRow;\n                var metadata;\n                var className;\n                var cellChildren = [];\n                var expandIconAttr;\n                var idx;\n                if (!row || row.hasChild) {\n                    row = this._row();\n                } else {\n                    row.hasChild = true;\n                }\n                if (member.measure) {\n                    className = row.allCell ? 'k-grid-footer' : '';\n                    row.children.push(this._cell(className, [this._content(children[0], tuple)], children[0]));\n                    row.rowSpan = childrenLength;\n                    for (idx = 1; idx < childrenLength; idx++) {\n                        this._row([this._cell(className, [this._content(children[idx], tuple)], children[idx])]);\n                    }\n                    return row;\n                }\n                map[tuplePath + member.name] = row;\n                path = kendo.stringify(buildPath(tuple, memberIdx));\n                metadata = this.metadata[path];\n                if (!metadata) {\n                    this.metadata[path] = metadata = createMetadata(levelNum, memberIdx);\n                    metadata.rootLevelNum = rootLevelNum;\n                }\n                this._indexes.push({\n                    path: path,\n                    tuple: tuple\n                });\n                if (member.hasChildren) {\n                    if (metadata.expanded === false) {\n                        childrenLength = 0;\n                        metadata.children = 0;\n                    }\n                    expandIconAttr = { className: 'k-icon ' + (childrenLength ? STATE_EXPANDED : STATE_COLLAPSED) };\n                    expandIconAttr[kendo.attr('path')] = path;\n                    cellChildren.push(element('span', expandIconAttr));\n                }\n                cellChildren.push(this._content(member, tuple));\n                className = row.allCell && !childrenLength ? 'k-grid-footer' : '';\n                cell = this._cell(className, cellChildren, member);\n                cell.colSpan = colSpan;\n                row.children.push(cell);\n                row.colSpan['dim' + memberIdx] = cell;\n                if (!this[rootName] || this[rootName] < colSpan) {\n                    this[rootName] = colSpan;\n                }\n                if (childrenLength) {\n                    row.allCell = false;\n                    row.hasChild = false;\n                    for (idx = 0; idx < childrenLength; idx++) {\n                        childRow = this._buildRows(children[idx], memberIdx);\n                        if (row !== childRow) {\n                            row.rowSpan += childRow.rowSpan;\n                        }\n                    }\n                    if (row.rowSpan > 1) {\n                        cell.attr.rowSpan = row.rowSpan;\n                    }\n                    metadata.children = row.rowSpan;\n                    allCell = this._cell('k-grid-footer', [this._content(member, tuple)], member);\n                    allCell.colSpan = colSpan;\n                    allRow = this._row([allCell]);\n                    allRow.colSpan['dim' + memberIdx] = allCell;\n                    allRow.allCell = true;\n                    map[tuplePath + member.name + 'all'] = allRow;\n                    if (nextMember) {\n                        childRow = this._buildRows(tuple, memberIdx + 1);\n                        allCell.attr.rowSpan = childRow.rowSpan;\n                    }\n                    row.rowSpan += allRow.rowSpan;\n                    metadata.members = allRow.rowSpan;\n                } else if (nextMember) {\n                    row.hasChild = false;\n                    this._buildRows(tuple, memberIdx + 1);\n                    (allCell || cell).attr.rowSpan = row.rowSpan;\n                    metadata.members = row.rowSpan;\n                }\n                if (metadata.maxChildren < metadata.children) {\n                    metadata.maxChildren = metadata.children;\n                }\n                if (metadata.maxMembers < metadata.members) {\n                    metadata.maxMembers = metadata.members;\n                }\n                return row;\n            }\n        });\n        var ContentBuilder = Class.extend({\n            init: function () {\n                this.columnAxis = {};\n                this.rowAxis = {};\n            },\n            build: function (data, columnAxis, rowAxis) {\n                var index = columnAxis.indexes[0];\n                var metadata = columnAxis.metadata[index ? index.path : undefined];\n                this.columnAxis = columnAxis;\n                this.rowAxis = rowAxis;\n                this.data = data;\n                this.rowLength = metadata ? metadata.maxChildren + metadata.maxMembers : columnAxis.measures.length || 1;\n                if (!this.rowLength) {\n                    this.rowLength = 1;\n                }\n                var tbody = this._tbody();\n                var colgroup = this._colGroup();\n                return [element('table', null, [\n                        colgroup,\n                        tbody\n                    ])];\n            },\n            _colGroup: function () {\n                var length = this.columnAxis.measures.length || 1;\n                var children = [];\n                var idx = 0;\n                if (this.rows[0]) {\n                    length = this.rows[0].children.length;\n                }\n                for (; idx < length; idx++) {\n                    children.push(element('col', null));\n                }\n                return element('colgroup', null, children);\n            },\n            _tbody: function () {\n                this.rows = [];\n                if (this.data[0]) {\n                    this.columnIndexes = this._indexes(this.columnAxis, this.rowLength);\n                    this.rowIndexes = this._indexes(this.rowAxis, Math.ceil(this.data.length / this.rowLength));\n                    this._buildRows();\n                } else {\n                    this.rows.push(element('tr', null, [element('td', null, [htmlNode('&nbsp;')])]));\n                }\n                return element('tbody', null, this.rows);\n            },\n            _indexes: function (axisInfo, total) {\n                var result = [];\n                var axisInfoMember;\n                var indexes = axisInfo.indexes;\n                var metadata = axisInfo.metadata;\n                var measures = axisInfo.measures;\n                var measuresLength = measures.length || 1;\n                var current;\n                var dataIdx = 0;\n                var firstEmpty = 0;\n                var idx = 0;\n                var length = indexes.length;\n                var measureIdx;\n                var index;\n                var children;\n                var skipChildren;\n                if (!length) {\n                    for (measureIdx = 0; measureIdx < measuresLength; measureIdx++) {\n                        result[measureIdx] = {\n                            index: measureIdx,\n                            measure: measures[measureIdx],\n                            tuple: null\n                        };\n                    }\n                    return result;\n                }\n                for (; idx < length; idx++) {\n                    axisInfoMember = indexes[idx];\n                    current = metadata[axisInfoMember.path];\n                    children = current.children + current.members;\n                    skipChildren = 0;\n                    if (children) {\n                        children -= measuresLength;\n                    }\n                    if (current.expanded === false && current.children !== current.maxChildren) {\n                        skipChildren = current.maxChildren;\n                    }\n                    if (current.parentMember && current.levelNum === current.rootLevelNum) {\n                        children = -1;\n                    }\n                    if (children > -1) {\n                        for (measureIdx = 0; measureIdx < measuresLength; measureIdx++) {\n                            index = children + measureIdx;\n                            if (!current.children) {\n                                index += firstEmpty;\n                            }\n                            result[children + firstEmpty + measureIdx] = {\n                                children: children,\n                                index: dataIdx,\n                                measure: measures[measureIdx],\n                                tuple: axisInfoMember.tuple\n                            };\n                            dataIdx += 1;\n                        }\n                        while (result[firstEmpty] !== undefined) {\n                            firstEmpty += 1;\n                        }\n                    }\n                    if (firstEmpty === total) {\n                        break;\n                    }\n                    dataIdx += skipChildren;\n                }\n                return result;\n            },\n            _buildRows: function () {\n                var rowIndexes = this.rowIndexes;\n                var length = rowIndexes.length;\n                var idx = 0;\n                for (; idx < length; idx++) {\n                    var rowIndex = rowIndexes[idx];\n                    if (rowIndex) {\n                        this.rows.push(this._buildRow(rowIndex));\n                    }\n                }\n            },\n            _buildRow: function (rowInfo) {\n                var startIdx = rowInfo.index * this.rowLength;\n                var columnIndexes = this.columnIndexes;\n                var length = columnIndexes.length;\n                var columnInfo;\n                var cells = [];\n                var idx = 0;\n                var templateInfo;\n                var cell, cellContent;\n                var attr, dataItem, measure;\n                for (; idx < length; idx++) {\n                    columnInfo = columnIndexes[idx];\n                    if (columnInfo === undefined) {\n                        continue;\n                    }\n                    attr = {};\n                    if (columnInfo.children) {\n                        attr.className = 'k-alt';\n                    }\n                    cellContent = '';\n                    dataItem = this.data[startIdx + columnInfo.index];\n                    measure = columnInfo.measure || rowInfo.measure;\n                    templateInfo = {\n                        columnTuple: columnInfo.tuple,\n                        rowTuple: rowInfo.tuple,\n                        measure: measure,\n                        dataItem: dataItem\n                    };\n                    if (dataItem.value !== '' && measure && measure.type) {\n                        if (measure.type === 'status') {\n                            cellContent = this.kpiStatusTemplate(templateInfo);\n                        } else if (measure.type === 'trend') {\n                            cellContent = this.kpiTrendTemplate(templateInfo);\n                        }\n                    }\n                    if (!cellContent) {\n                        cellContent = this.dataTemplate(templateInfo);\n                    }\n                    cell = element('td', attr, [htmlNode(cellContent)]);\n                    cell.value = dataItem.value;\n                    cells.push(cell);\n                }\n                attr = {};\n                if (rowInfo.children) {\n                    attr.className = 'k-grid-footer';\n                }\n                return element('tr', attr, cells);\n            }\n        });\n        ui.plugin(PivotGrid);\n        kendo.PivotExcelExporter = kendo.Class.extend({\n            init: function (options) {\n                this.options = options;\n                this.widget = options.widget;\n                this.dataSource = this.widget.dataSource;\n            },\n            _columns: function () {\n                var columnHeaderTable = this.widget.columnsHeaderTree.children[0];\n                var rowHeaderTable = this.widget.rowsHeaderTree.children[0];\n                var columnHeaderLength = columnHeaderTable.children[0].children.length;\n                var rowHeaderLength = rowHeaderTable.children[0].children.length;\n                var width = this.widget.options.columnWidth;\n                var result = [];\n                var idx;\n                if (rowHeaderLength && this.dataSource.data()[0]) {\n                    for (idx = 0; idx < rowHeaderLength; idx++) {\n                        result.push({ autoWidth: true });\n                    }\n                }\n                for (idx = 0; idx < columnHeaderLength; idx++) {\n                    result.push({\n                        autoWidth: false,\n                        width: width\n                    });\n                }\n                return result;\n            },\n            _cells: function (rows, type, callback) {\n                var result = [];\n                var i = 0;\n                var length = rows.length;\n                var cellsLength;\n                var row, cells;\n                var j, cell;\n                for (; i < length; i++) {\n                    row = [];\n                    cells = rows[i].children;\n                    cellsLength = cells.length;\n                    for (j = 0; j < cellsLength; j++) {\n                        cell = cells[j];\n                        row.push({\n                            background: '#7a7a7a',\n                            color: '#fff',\n                            value: cell.value,\n                            colSpan: cell.attr.colSpan || 1,\n                            rowSpan: cell.attr.rowSpan || 1\n                        });\n                    }\n                    if (callback) {\n                        callback(row, i);\n                    }\n                    result.push({\n                        cells: row,\n                        type: type\n                    });\n                }\n                return result;\n            },\n            _rows: function () {\n                var columnHeaderTable = this.widget.columnsHeaderTree.children[0];\n                var rowHeaderTable = this.widget.rowsHeaderTree.children[0];\n                var columnHeaderLength = columnHeaderTable.children[0].children.length;\n                var rowHeaderLength = rowHeaderTable.children[0].children.length;\n                var columnHeaderRows = columnHeaderTable.children[1].children;\n                var rowHeaderRows = rowHeaderTable.children[1].children;\n                var contentRows = this.widget.contentTree.children[0].children[1].children;\n                var columnRows = this._cells(columnHeaderRows, 'header');\n                if (rowHeaderLength) {\n                    columnRows[0].cells.splice(0, 0, {\n                        background: '#7a7a7a',\n                        color: '#fff',\n                        value: '',\n                        colSpan: rowHeaderLength,\n                        rowSpan: columnHeaderRows.length\n                    });\n                }\n                var dataCallback = function (row, index) {\n                    var j = 0;\n                    var cell, value;\n                    var cells = contentRows[index].children;\n                    for (; j < columnHeaderLength; j++) {\n                        cell = cells[j];\n                        value = Number(cell.value);\n                        if (isNaN(value)) {\n                            value = cell.value;\n                        }\n                        row.push({\n                            background: '#dfdfdf',\n                            color: '#333',\n                            value: value,\n                            colSpan: 1,\n                            rowSpan: 1\n                        });\n                    }\n                };\n                var rowRows = this._cells(rowHeaderRows, 'data', dataCallback);\n                return columnRows.concat(rowRows);\n            },\n            _freezePane: function () {\n                var columnHeaderTable = this.widget.columnsHeaderTree.children[0];\n                var rowHeaderTable = this.widget.rowsHeaderTree.children[0];\n                var rowHeaderLength = rowHeaderTable.children[0].children.length;\n                var columnHeaderRows = columnHeaderTable.children[1].children;\n                return {\n                    colSplit: rowHeaderLength,\n                    rowSplit: columnHeaderRows.length\n                };\n            },\n            workbook: function () {\n                var promise;\n                if (this.dataSource.view()[0]) {\n                    promise = $.Deferred();\n                    promise.resolve();\n                } else {\n                    promise = this.dataSource.fetch();\n                }\n                return promise.then($.proxy(function () {\n                    return {\n                        sheets: [{\n                                columns: this._columns(),\n                                rows: this._rows(),\n                                freezePane: this._freezePane(),\n                                filter: null\n                            }]\n                    };\n                }, this));\n            }\n        });\n        var PivotExcelMixin = {\n            extend: function (proto) {\n                proto.events.push('excelExport');\n                proto.options.excel = $.extend(proto.options.excel, this.options);\n                proto.saveAsExcel = this.saveAsExcel;\n            },\n            options: {\n                proxyURL: '',\n                filterable: false,\n                fileName: 'Export.xlsx'\n            },\n            saveAsExcel: function () {\n                var excel = this.options.excel || {};\n                var exporter = new kendo.PivotExcelExporter({ widget: this });\n                exporter.workbook().then($.proxy(function (book) {\n                    if (!this.trigger('excelExport', { workbook: book })) {\n                        var workbook = new kendo.ooxml.Workbook(book);\n                        workbook.toDataURLAsync().then(function (dataURI) {\n                            kendo.saveAs({\n                                dataURI: dataURI,\n                                fileName: book.fileName || excel.fileName,\n                                proxyURL: excel.proxyURL,\n                                forceProxy: excel.forceProxy\n                            });\n                        });\n                    }\n                }, this));\n            }\n        };\n        kendo.PivotExcelMixin = PivotExcelMixin;\n        if (kendo.ooxml && kendo.ooxml.Workbook) {\n            PivotExcelMixin.extend(PivotGrid.prototype);\n        }\n        if (kendo.PDFMixin) {\n            kendo.PDFMixin.extend(PivotGrid.prototype);\n            PivotGrid.fn._drawPDF = function () {\n                return this._drawPDFShadow({ width: this.wrapper.width() }, { avoidLinks: this.options.pdf.avoidLinks });\n            };\n        }\n    }(window.kendo.jQuery));\n    return window.kendo;\n}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {\n    (a3 || a2)();\n}));"]}