690 lines
33 KiB
JavaScript
690 lines
33 KiB
JavaScript
/*
|
|
* File: jquery.dataTables.grouping.js
|
|
* Version: 1.2.9.
|
|
* Author: Jovan Popovic
|
|
*
|
|
* Copyright 2013 Jovan Popovic, all rights reserved.
|
|
*
|
|
* This source file is free software, under either the GPL v2 license or a
|
|
* BSD style license, as supplied with this software.
|
|
*
|
|
* This source file is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
* or FITNESS FOR A PARTICULAR PURPOSE.
|
|
* Parameters:
|
|
* @iGroupingColumnIndex Integer Index of the column that will be used for grouping - default 0
|
|
* @sGroupingColumnSortDirection Enumeration Sort direction of the group
|
|
* @iGroupingOrderByColumnIndex Integer Index of the column that will be used for ordering groups
|
|
* @sGroupingClass String Class that will be associated to the group row. Default - "group"
|
|
* @sGroupItemClass String Class that will be associated to the group row of group items. Default - "group-item"
|
|
* @bSetGroupingClassOnTR Boolean If set class will be set to the TR instead of the TD withing the grouping TR
|
|
* @bHideGroupingColumn Boolean Hide column used for grouping once results are grouped. Default - true
|
|
* @bHideGroupingOrderByColumn Boolean Hide column used for ordering groups once results are grouped. Default - true
|
|
* @sGroupBy Enumeration Type of grouping that should be applied. Values "name"(default), "letter", "year"
|
|
* @sGroupLabelPrefix String Prefix that will be added to each group cell
|
|
* @bExpandableGrouping Boolean Attach expand/collapse handlers to the grouping rows
|
|
* @bExpandSingleGroup Boolean Use accordon grouping
|
|
* @iExpandGroupOffset Integer Number of pixels to set scroll position above the currently selected group. If -1 scroll will be alligned to the table
|
|
* General settings
|
|
* @sDateFormat: "dd/MM/yyyy" String Date format used for grouping
|
|
* @sEmptyGroupLabel String Lable that will be placed as group if grouping cells are empty. Default "-"
|
|
|
|
* Parameters used in the second level grouping
|
|
* @iGroupingColumnIndex2 Integer Index of the secondary column that will be used for grouping - default 0
|
|
* @sGroupingColumnSortDirection2 Enumeration Sort direction of the secondary group
|
|
* @iGroupingOrderByColumnIndex2 Integer Index of the column that will be used for ordering secondary groups
|
|
* @sGroupingClass2 String Class that will be associated to the secondary group row. Default "subgroup"
|
|
* @sGroupItemClass2 String Class that will be associated to the secondary group row of group items. Default "subgroup-item"
|
|
* @bHideGroupingColumn2 Boolean Hide column used for secondary grouping once results are grouped. Default - true,
|
|
* @bHideGroupingOrderByColumn2 Boolean Hide column used for ordering secondary groups once results are grouped. Default - true,
|
|
* @sGroupBy2 Enumeration Type of grouping that should be applied to secondary column. Values "name"(default), "letter", "year",
|
|
* @sGroupLabelPrefix2 String Prefix that will be added to each secondary group cell
|
|
* @fnOnGrouped Function Function that is called when grouping is finished. Function has no parameters.
|
|
*/
|
|
(function ($) {
|
|
|
|
"use strict";
|
|
|
|
$.fn.rowGrouping = function (options) {
|
|
|
|
function _fnOnGrouped() {
|
|
|
|
}
|
|
|
|
function _fnOnGroupCreated(oGroup, sGroup, iLevel) {
|
|
///<summary>
|
|
///Function called when a new grouping row is created(it should be overriden in properties)
|
|
///</summary>
|
|
}
|
|
|
|
function _fnOnGroupCompleted(oGroup, sGroup, iLevel) {
|
|
///<summary>
|
|
///Function called when a new grouping row is created(it should be overriden in properties)
|
|
///</summary>
|
|
}
|
|
|
|
function _getMonthName(iMonth) {
|
|
var asMonths = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
|
|
return asMonths[iMonth - 1];
|
|
}
|
|
|
|
var defaults = {
|
|
|
|
iGroupingColumnIndex: 0,
|
|
sGroupingColumnSortDirection: "",
|
|
iGroupingOrderByColumnIndex: -1,
|
|
sGroupingClass: "group",
|
|
sGroupItemClass: "group-item",
|
|
bHideGroupingColumn: true,
|
|
bHideGroupingOrderByColumn: true,
|
|
sGroupBy: "name",
|
|
sGroupLabelPrefix: "",
|
|
fnGroupLabelFormat: function (label) { return label; },
|
|
bExpandableGrouping: false,
|
|
bExpandSingleGroup: false,
|
|
iExpandGroupOffset: 100,
|
|
asExpandedGroups: null,
|
|
|
|
sDateFormat: "dd/MM/yyyy",
|
|
sEmptyGroupLabel: "-",
|
|
bSetGroupingClassOnTR: false,
|
|
|
|
iGroupingColumnIndex2: -1,
|
|
sGroupingColumnSortDirection2: "",
|
|
iGroupingOrderByColumnIndex2: -1,
|
|
sGroupingClass2: "subgroup",
|
|
sGroupItemClass2: "subgroup-item",
|
|
bHideGroupingColumn2: true,
|
|
bHideGroupingOrderByColumn2: true,
|
|
sGroupBy2: "name",
|
|
sGroupLabelPrefix2: "",
|
|
fnGroupLabelFormat2: function (label) { return label; },
|
|
bExpandableGrouping2: false,
|
|
|
|
fnOnGrouped: _fnOnGrouped,
|
|
|
|
fnOnGroupCreated: _fnOnGroupCreated,
|
|
fnOnGroupCompleted: _fnOnGroupCompleted,
|
|
|
|
oHideEffect: null, // { method: "hide", duration: "fast", easing: "linear" },
|
|
oShowEffect: null,//{ method: "show", duration: "slow", easing: "linear" }
|
|
|
|
bUseFilteringForGrouping: false // This is still work in progress option
|
|
};
|
|
return this.each(function (index, elem) {
|
|
|
|
var oTable = $(elem).dataTable();
|
|
|
|
var aoGroups = new Array();
|
|
$(this).dataTableExt.aoGroups = aoGroups;
|
|
|
|
function fnCreateGroupRow(sGroupCleaned, sGroup, iColspan) {
|
|
var nGroup = document.createElement('tr');
|
|
var nCell = document.createElement('td');
|
|
nGroup.id = "group-id-" + oTable.attr("id") + "_" + sGroupCleaned;
|
|
|
|
var oGroup = { id: nGroup.id, key: sGroupCleaned, text: sGroup, level: 0, groupItemClass: ".group-item-" + sGroupCleaned, dataGroup: sGroupCleaned, aoSubgroups: new Array() };
|
|
|
|
|
|
|
|
if (properties.bSetGroupingClassOnTR) {
|
|
nGroup.className = properties.sGroupingClass + " " + sGroupCleaned;
|
|
} else {
|
|
nCell.className = properties.sGroupingClass + " " + sGroupCleaned;
|
|
}
|
|
|
|
nCell.colSpan = iColspan;
|
|
nCell.innerHTML = properties.sGroupLabelPrefix + properties.fnGroupLabelFormat(sGroup == "" ? properties.sEmptyGroupLabel : sGroup, oGroup );
|
|
if (properties.bExpandableGrouping) {
|
|
|
|
if (!_fnIsGroupCollapsed(sGroupCleaned)) {
|
|
nCell.className += " expanded-group";
|
|
oGroup.state = "expanded";
|
|
} else {
|
|
nCell.className += " collapsed-group";
|
|
oGroup.state = "collapsed";
|
|
}
|
|
nCell.className += " group-item-expander";
|
|
$(nCell).attr('data-group', oGroup.dataGroup); //Fix provided by mssskhalsa (Issue 5)
|
|
$(nCell).attr("data-group-level", oGroup.level);
|
|
$(nCell).click(_fnOnGroupClick);
|
|
}
|
|
nGroup.appendChild(nCell);
|
|
aoGroups[sGroupCleaned] = oGroup;
|
|
oGroup.nGroup = nGroup;
|
|
properties.fnOnGroupCreated(oGroup, sGroupCleaned, 1);
|
|
return oGroup;
|
|
}
|
|
|
|
function _fnCreateGroup2Row(sGroup2, sGroupLabel, iColspan, oParentGroup) {
|
|
|
|
var nGroup2 = document.createElement('tr');
|
|
nGroup2.id = oParentGroup.id + "_" + sGroup2;
|
|
var nCell2 = document.createElement('td');
|
|
var dataGroup = oParentGroup.dataGroup + '_' + sGroup2;
|
|
|
|
var oGroup = { id: nGroup2.id, key: sGroup2, text: sGroupLabel, level: oParentGroup.level + 1, groupItemClass: ".group-item-" + dataGroup,
|
|
dataGroup: dataGroup, aoSubgroups: new Array()
|
|
};
|
|
|
|
if (properties.bSetGroupingClassOnTR) {
|
|
nGroup2.className = properties.sGroupingClass2 + " " + sGroup2;
|
|
} else {
|
|
nCell2.className = properties.sGroupingClass2 + " " + sGroup2;
|
|
}
|
|
|
|
nCell2.colSpan = iColspan;
|
|
nCell2.innerHTML = properties.sGroupLabelPrefix2 + properties.fnGroupLabelFormat2(sGroupLabel == "" ? properties.sEmptyGroupLabel : sGroupLabel, oGroup);
|
|
|
|
if (properties.bExpandableGrouping) {
|
|
|
|
nGroup2.className += " group-item-" + oParentGroup.dataGroup;
|
|
}
|
|
|
|
|
|
if (properties.bExpandableGrouping && properties.bExpandableGrouping2) {
|
|
|
|
if (!_fnIsGroupCollapsed(oGroup.dataGroup)) {
|
|
nCell2.className += " expanded-group";
|
|
oGroup.state = "expanded";
|
|
} else {
|
|
nCell2.className += " collapsed-group";
|
|
oGroup.state = "collapsed";
|
|
}
|
|
nCell2.className += " group-item-expander";
|
|
$(nCell2).attr('data-group', oGroup.dataGroup);
|
|
$(nCell2).attr("data-group-level", oGroup.level);
|
|
$(nCell2).click(_fnOnGroupClick);
|
|
}
|
|
|
|
nGroup2.appendChild(nCell2);
|
|
|
|
oParentGroup.aoSubgroups[oGroup.dataGroup] = oGroup;
|
|
aoGroups[oGroup.dataGroup] = oGroup;
|
|
oGroup.nGroup = nGroup2;
|
|
properties.fnOnGroupCreated(oGroup, sGroup2, 2);
|
|
return oGroup;
|
|
}
|
|
|
|
function _fnIsGroupCollapsed(sGroup) {
|
|
if (aoGroups[sGroup] != null)
|
|
return (aoGroups[sGroup].state == "collapsed");
|
|
else
|
|
if (sGroup.indexOf("_") > -1)
|
|
true;
|
|
else
|
|
if(bInitialGrouping && (asExpandedGroups==null || asExpandedGroups.length == 0))
|
|
return false;// initially if asExpandedGroups is empty - no one is collapsed
|
|
else
|
|
return ($.inArray(sGroup, asExpandedGroups) == -1); //the last chance check asExpandedGroups
|
|
}
|
|
|
|
function _fnGetYear(x) {
|
|
if(x.length< (iYearIndex+iYearLength) )
|
|
return x;
|
|
else
|
|
return x.substr(iYearIndex, iYearLength);
|
|
}
|
|
function _fnGetGroupByName(x) {
|
|
return x;
|
|
}
|
|
|
|
function _fnGetGroupByLetter(x) {
|
|
return x.substr(0, 1);
|
|
}
|
|
|
|
function _fnGetGroupByYear(x) {
|
|
return _fnGetYear(x);
|
|
//return Date.parseExact(x, properties.sDateFormat).getFullYear();//slooooow
|
|
}
|
|
|
|
function _fnGetGroupByYearMonth(x) {
|
|
//var date = Date.parseExact(x, "dd/MM/yyyy");
|
|
//return date.getFullYear() + " / " + date.getMonthName();
|
|
//return x.substr(iYearIndex, iYearLength) + '/' + x.substr(iMonthIndex, iMonthLength);
|
|
return x.substr(iYearIndex, iYearLength) + ' ' + _getMonthName(x.substr(iMonthIndex, iMonthLength));
|
|
}
|
|
|
|
function _fnGetCleanedGroup(sGroup) {
|
|
|
|
if (sGroup === "") return "-";
|
|
return sGroup.toLowerCase().replace(/[^a-zA-Z0-9\u0080-\uFFFF]+/g, "-"); //fix for unicode characters (Issue 23)
|
|
//return sGroup.toLowerCase().replace(/\W+/g, "-"); //Fix provided by bmathews (Issue 7)
|
|
}
|
|
|
|
function _rowGroupingRowFilter(oSettings, aData, iDataIndex) {
|
|
///<summary>Used to expand/collapse groups with DataTables filtering</summary>
|
|
if (oSettings.nTable.id !== oTable[0].id) return true;
|
|
var sColData = aData[properties.iGroupingColumnIndex];
|
|
if (typeof sColData === "undefined")
|
|
sColData = aData[oSettings.aoColumns[properties.iGroupingColumnIndex].mDataProp];
|
|
if (_fnIsGroupCollapsed(_fnGetCleanedGroup(sColData))) {
|
|
if (oTable.fnIsOpen(oTable.fnGetNodes(iDataIndex)))
|
|
{
|
|
if (properties.fnOnRowClosed != null) {
|
|
properties.fnOnRowClosed(this); // $(this.cells[0].children[0]).attr('src', '../../Images/details.png');
|
|
}
|
|
oTable.fnClose(oTable.fnGetNodes(iDataIndex));
|
|
}
|
|
return false;
|
|
};
|
|
return true;
|
|
} //end of function _rowGroupingRowFilter
|
|
|
|
|
|
function fnExpandGroup(sGroup) {
|
|
///<summary>Expand group if expanadable grouping is used</summary>
|
|
|
|
aoGroups[sGroup].state = "expanded";
|
|
|
|
$("td[data-group^='" + sGroup + "']").removeClass("collapsed-group");
|
|
$("td[data-group^='" + sGroup + "']").addClass("expanded-group");
|
|
|
|
|
|
if(properties.bUseFilteringForGrouping)
|
|
{
|
|
oTable.fnDraw();
|
|
return;//Because rows are expanded with _rowGroupingRowFilter function
|
|
}
|
|
|
|
if (jQuery.inArray(sGroup, asExpandedGroups)==-1)
|
|
asExpandedGroups.push(sGroup);
|
|
|
|
if (properties.oHideEffect != null)
|
|
$(".group-item-" + sGroup, oTable)
|
|
[properties.oShowEffect.method](properties.oShowEffect.duration,
|
|
properties.oShowEffect.easing,
|
|
function () { });
|
|
else
|
|
$(".group-item-" + sGroup, oTable).show();
|
|
|
|
|
|
} //end of function fnExpandGroup
|
|
|
|
function fnCollapseGroup(sGroup) {
|
|
///<summary>Collapse group if expanadable grouping is used</summary>
|
|
|
|
aoGroups[sGroup].state = "collapsed";
|
|
$("td[data-group^='" + sGroup + "']").removeClass("expanded-group");
|
|
$("td[data-group^='" + sGroup + "']").addClass("collapsed-group");
|
|
|
|
if(properties.bUseFilteringForGrouping)
|
|
{
|
|
oTable.fnDraw();
|
|
return;//Because rows are expanded with _rowGroupingRowFilter function
|
|
}
|
|
//var index = $.inArray(sGroup, asExpandedGroups);
|
|
//asExpandedGroups.splice(index, 1);
|
|
|
|
$('.group-item-' + sGroup).each(function () {
|
|
//Issue 24 - Patch provided by Bob Graham
|
|
if (oTable.fnIsOpen(this)) {
|
|
if (properties.fnOnRowClosed != null) {
|
|
properties.fnOnRowClosed(this); // $(this.cells[0].children[0]).attr('src', '../../Images/details.png');
|
|
}
|
|
oTable.fnClose(this);
|
|
}
|
|
});
|
|
|
|
if (properties.oHideEffect != null)
|
|
$(".group-item-" + sGroup, oTable)
|
|
[properties.oHideEffect.method](properties.oHideEffect.duration,
|
|
properties.oHideEffect.easing,
|
|
function () { });
|
|
else
|
|
$(".group-item-" + sGroup, oTable).hide();
|
|
|
|
} //end of function fnCollapseGroup
|
|
|
|
function _fnOnGroupClick(e) {
|
|
///<summary>
|
|
///Function that is called when user click on the group cell in order to
|
|
///expand of collapse group
|
|
///</summary>
|
|
|
|
//var sGroup = $(this).attr("rel");
|
|
var sGroup = $(this).attr("data-group");
|
|
var iGroupLevel = $(this).attr("data-group-level");
|
|
|
|
var bIsExpanded = !_fnIsGroupCollapsed(sGroup);
|
|
if (properties.bExpandSingleGroup) {
|
|
if (!bIsExpanded) {
|
|
var sCurrentGroup = $("td.expanded-group").attr("data-group");
|
|
fnCollapseGroup(sCurrentGroup);
|
|
fnExpandGroup(sGroup);
|
|
|
|
if (properties.iExpandGroupOffset != -1) {
|
|
var position = $("#group-id-" + oTable.attr("id") + "_" + sGroup).offset().top - properties.iExpandGroupOffset;
|
|
window.scroll(0, position);
|
|
} else {
|
|
var position = oTable.offset().top;
|
|
window.scroll(0, position);
|
|
}
|
|
}
|
|
} else {
|
|
if (bIsExpanded) {
|
|
fnCollapseGroup(sGroup);
|
|
} else {
|
|
fnExpandGroup(sGroup);
|
|
}
|
|
}
|
|
e.preventDefault();
|
|
|
|
}; //end function _fnOnGroupClick
|
|
|
|
|
|
function _fnDrawCallBackWithGrouping (oSettings) {
|
|
|
|
if (oTable.fnSettings().oFeatures.bServerSide)
|
|
bInitialGrouping = true;
|
|
var bUseSecondaryGrouping = false;
|
|
|
|
if (properties.iGroupingColumnIndex2 != -1)
|
|
bUseSecondaryGrouping = true;
|
|
|
|
//-----Start grouping
|
|
|
|
if (oSettings.aiDisplayMaster.length == 0) { //aiDisplay
|
|
return;
|
|
}
|
|
|
|
var nTrs = $('tbody tr', oTable);
|
|
var iColspan = 0; //nTrs[0].getElementsByTagName('td').length;
|
|
for (var iColIndex = 0; iColIndex < oSettings.aoColumns.length; iColIndex++) {
|
|
if (oSettings.aoColumns[iColIndex].bVisible)
|
|
iColspan += 1;
|
|
}
|
|
var sLastGroup = null;
|
|
var sLastGroup2 = null;
|
|
if (oSettings.aiDisplay.length > 0) {
|
|
for (var i = 0; i < nTrs.length; i++) {
|
|
|
|
|
|
var iDisplayIndex = oSettings._iDisplayStart + i;
|
|
if (oTable.fnSettings().oFeatures.bServerSide)
|
|
iDisplayIndex = i;
|
|
var sGroupData = "";
|
|
var sGroup = null;
|
|
var sGroupData2 = "";
|
|
var sGroup2 = null;
|
|
|
|
//Issue 31 - Start fix provided by Fabien Taysse
|
|
// sGroupData = oSettings.aoData[oSettings.aiDisplay[iDisplayIndex]]._aData[properties.iGroupingColumnIndex];
|
|
// if (sGroupData == undefined)
|
|
// sGroupData = oSettings.aoData[oSettings.aiDisplay[iDisplayIndex]]._aData[oSettings.aoColumns[properties.iGroupingColumnIndex].mDataProp];
|
|
sGroupData = this.fnGetData(nTrs[i], properties.iGroupingColumnIndex);
|
|
//Issue 31 - End fix provided by Fabien Taysse
|
|
|
|
var sGroup = sGroupData;
|
|
if (properties.sGroupBy != "year")
|
|
sGroup = fnGetGroup(sGroupData);
|
|
|
|
if (bUseSecondaryGrouping) {
|
|
sGroupData2 = oSettings.aoData[oSettings.aiDisplay[iDisplayIndex]]._aData[properties.iGroupingColumnIndex2];
|
|
if (sGroupData2 == undefined)
|
|
sGroupData2 = oSettings.aoData[oSettings.aiDisplay[iDisplayIndex]]._aData[oSettings.aoColumns[properties.iGroupingColumnIndex2].mDataProp];
|
|
if (properties.sGroupBy2 != "year")
|
|
sGroup2 = fnGetGroup(sGroupData2);
|
|
}
|
|
|
|
|
|
if (sLastGroup == null || _fnGetCleanedGroup(sGroup) != _fnGetCleanedGroup(sLastGroup)) { // new group encountered (or first of group)
|
|
var sGroupCleaned = _fnGetCleanedGroup(sGroup);
|
|
|
|
if(sLastGroup != null)
|
|
{
|
|
properties.fnOnGroupCompleted(aoGroups[_fnGetCleanedGroup(sLastGroup)]);
|
|
}
|
|
/*
|
|
if (properties.bExpandableGrouping && bInitialGrouping) {
|
|
if (properties.bExpandSingleGroup) {
|
|
if (asExpandedGroups.length == 0)
|
|
asExpandedGroups.push(sGroupCleaned);
|
|
} else {
|
|
asExpandedGroups.push(sGroupCleaned);
|
|
}
|
|
}
|
|
*/
|
|
if(properties.bAddAllGroupsAsExpanded && jQuery.inArray(sGroupCleaned,asExpandedGroups) == -1)
|
|
asExpandedGroups.push(sGroupCleaned);
|
|
|
|
var oGroup = fnCreateGroupRow(sGroupCleaned, sGroup, iColspan);
|
|
var nGroup = oGroup.nGroup;
|
|
|
|
if(nTrs[i].parentNode!=null)
|
|
nTrs[i].parentNode.insertBefore(nGroup, nTrs[i]);
|
|
else
|
|
$(nTrs[i]).before(nGroup);
|
|
|
|
sLastGroup = sGroup;
|
|
sLastGroup2 = null; //to reset second level grouping
|
|
|
|
|
|
|
|
|
|
|
|
} // end if (sLastGroup == null || sGroup != sLastGroup)
|
|
|
|
$(nTrs[i]).attr("data-group", aoGroups[sGroupCleaned].dataGroup);
|
|
|
|
$(nTrs[i]).addClass(properties.sGroupItemClass);
|
|
$(nTrs[i]).addClass("group-item-" + sGroupCleaned);
|
|
if (properties.bExpandableGrouping) {
|
|
if (_fnIsGroupCollapsed(sGroupCleaned) && !properties.bUseFilteringForGrouping) {
|
|
$(nTrs[i]).hide();
|
|
}
|
|
}
|
|
|
|
|
|
if (bUseSecondaryGrouping) {
|
|
|
|
if (sLastGroup2 == null || _fnGetCleanedGroup(sGroup2) != _fnGetCleanedGroup(sLastGroup2)) {
|
|
var sGroup2Id = _fnGetCleanedGroup(sGroup) + '-' + _fnGetCleanedGroup(sGroup2);
|
|
var oGroup2 = _fnCreateGroup2Row(sGroup2Id, sGroup2, iColspan, aoGroups[sGroupCleaned])
|
|
var nGroup2 = oGroup2.nGroup;
|
|
nTrs[i].parentNode.insertBefore(nGroup2, nTrs[i]);
|
|
|
|
sLastGroup2 = sGroup2;
|
|
}
|
|
|
|
$(nTrs[i]).attr("data-group", oGroup2.dataGroup)
|
|
.addClass(properties.sGroupItemClass2)
|
|
.addClass("group-item-" + oGroup2.dataGroup);
|
|
} //end if (bUseSecondaryGrouping)
|
|
|
|
|
|
|
|
} // end for (var i = 0; i < nTrs.length; i++)
|
|
}; // if (oSettings.aiDisplay.length > 0)
|
|
|
|
if(sLastGroup != null)
|
|
{
|
|
properties.fnOnGroupCompleted(aoGroups[_fnGetCleanedGroup(sLastGroup)]);
|
|
}
|
|
|
|
|
|
//-----End grouping
|
|
properties.fnOnGrouped(aoGroups);
|
|
|
|
bInitialGrouping = false;
|
|
|
|
}; // end of _fnDrawCallBackWithGrouping = function (oSettings)
|
|
|
|
|
|
//var oTable = this;
|
|
var iYearIndex = 6;
|
|
var iYearLength = 4;
|
|
var asExpandedGroups = new Array();
|
|
var bInitialGrouping = true;
|
|
|
|
var properties = $.extend(defaults, options);
|
|
|
|
if (properties.iGroupingOrderByColumnIndex == -1) {
|
|
properties.bCustomColumnOrdering = false;
|
|
properties.iGroupingOrderByColumnIndex = properties.iGroupingColumnIndex;
|
|
} else {
|
|
properties.bCustomColumnOrdering = true;
|
|
}
|
|
|
|
if (properties.sGroupingColumnSortDirection == "") {
|
|
if (properties.sGroupBy == "year")
|
|
properties.sGroupingColumnSortDirection = "desc";
|
|
else
|
|
properties.sGroupingColumnSortDirection = "asc";
|
|
}
|
|
|
|
|
|
if (properties.iGroupingOrderByColumnIndex2 == -1) {
|
|
properties.bCustomColumnOrdering2 = false;
|
|
properties.iGroupingOrderByColumnIndex2 = properties.iGroupingColumnIndex2;
|
|
} else {
|
|
properties.bCustomColumnOrdering2 = true;
|
|
}
|
|
|
|
if (properties.sGroupingColumnSortDirection2 == "") {
|
|
if (properties.sGroupBy2 == "year")
|
|
properties.sGroupingColumnSortDirection2 = "desc";
|
|
else
|
|
properties.sGroupingColumnSortDirection2 = "asc";
|
|
}
|
|
|
|
|
|
|
|
iYearIndex = properties.sDateFormat.toLowerCase().indexOf('yy');
|
|
iYearLength = properties.sDateFormat.toLowerCase().lastIndexOf('y') - properties.sDateFormat.toLowerCase().indexOf('y') + 1;
|
|
|
|
var iMonthIndex = properties.sDateFormat.toLowerCase().indexOf('mm');
|
|
var iMonthLength = properties.sDateFormat.toLowerCase().lastIndexOf('m') - properties.sDateFormat.toLowerCase().indexOf('m') + 1;
|
|
|
|
var fnGetGroup = _fnGetGroupByName;
|
|
switch (properties.sGroupBy) {
|
|
case "letter": fnGetGroup = _fnGetGroupByLetter;
|
|
break;
|
|
case "year": fnGetGroup = _fnGetGroupByYear;
|
|
break;
|
|
case "month": fnGetGroup = _fnGetGroupByYearMonth;
|
|
break;
|
|
default: fnGetGroup = _fnGetGroupByName;
|
|
break;
|
|
}
|
|
|
|
|
|
if (properties.asExpandedGroups != null) {
|
|
if (properties.asExpandedGroups == "NONE") {
|
|
properties.asExpandedGroups = [];
|
|
asExpandedGroups = properties.asExpandedGroups;
|
|
bInitialGrouping = false;
|
|
} else if (properties.asExpandedGroups == "ALL") {
|
|
properties.bAddAllGroupsAsExpanded = true;
|
|
} else if (properties.asExpandedGroups.constructor == String) {
|
|
var currentGroup = properties.asExpandedGroups;
|
|
properties.asExpandedGroups = new Array();
|
|
properties.asExpandedGroups.push(_fnGetCleanedGroup(currentGroup));
|
|
asExpandedGroups = properties.asExpandedGroups;
|
|
bInitialGrouping = false;
|
|
} else if (properties.asExpandedGroups.constructor == Array) {
|
|
for (var i = 0; i < properties.asExpandedGroups.length; i++) {
|
|
asExpandedGroups.push(_fnGetCleanedGroup(properties.asExpandedGroups[i]));
|
|
if (properties.bExpandSingleGroup)
|
|
break;
|
|
}
|
|
bInitialGrouping = false;
|
|
}
|
|
}else{
|
|
properties.asExpandedGroups = new Array();
|
|
properties.bAddAllGroupsAsExpanded = true;
|
|
}
|
|
if(properties.bExpandSingleGroup){
|
|
var nTrs = $('tbody tr', oTable);
|
|
var sGroupData = oTable.fnGetData(nTrs[0], properties.iGroupingColumnIndex);
|
|
|
|
var sGroup = sGroupData;
|
|
if (properties.sGroupBy != "year")
|
|
sGroup = fnGetGroup(sGroupData);
|
|
|
|
var sGroupCleaned = _fnGetCleanedGroup(sGroup);
|
|
properties.asExpandedGroups = new Array();
|
|
properties.asExpandedGroups.push(sGroupCleaned);
|
|
|
|
}
|
|
|
|
oTable.fnSetColumnVis(properties.iGroupingColumnIndex, !properties.bHideGroupingColumn);
|
|
if (properties.bCustomColumnOrdering) {
|
|
oTable.fnSetColumnVis(properties.iGroupingOrderByColumnIndex, !properties.bHideGroupingOrderByColumn);
|
|
}
|
|
if (properties.iGroupingColumnIndex2 != -1) {
|
|
oTable.fnSetColumnVis(properties.iGroupingColumnIndex2, !properties.bHideGroupingColumn2);
|
|
}
|
|
if (properties.bCustomColumnOrdering2) {
|
|
oTable.fnSetColumnVis(properties.iGroupingOrderByColumnIndex2, !properties.bHideGroupingOrderByColumn2);
|
|
}
|
|
oTable.fnSettings().aoDrawCallback.push({
|
|
"fn": _fnDrawCallBackWithGrouping,
|
|
"sName": "fnRowGrouping"
|
|
});
|
|
|
|
var aaSortingFixed = new Array();
|
|
aaSortingFixed.push([properties.iGroupingOrderByColumnIndex, properties.sGroupingColumnSortDirection]);
|
|
if (properties.iGroupingColumnIndex2 != -1) {
|
|
aaSortingFixed.push([properties.iGroupingOrderByColumnIndex2, properties.sGroupingColumnSortDirection2]);
|
|
} // end of if (properties.iGroupingColumnIndex2 != -1)
|
|
|
|
oTable.fnSettings().aaSortingFixed = aaSortingFixed;
|
|
//Old way
|
|
//oTable.fnSettings().aaSortingFixed = [[properties.iGroupingOrderByColumnIndex, properties.sGroupingColumnSortDirection]];
|
|
|
|
switch (properties.sGroupBy) {
|
|
case "name":
|
|
break;
|
|
|
|
|
|
case "letter":
|
|
|
|
/* Create an array with the values of all the input boxes in a column */
|
|
oTable.fnSettings().aoColumns[properties.iGroupingOrderByColumnIndex].sSortDataType = "rg-letter";
|
|
$.fn.dataTableExt.afnSortData['rg-letter'] = function (oSettings, iColumn) {
|
|
var aData = [];
|
|
$('td:eq(' + iColumn + ')', oSettings.oApi._fnGetTrNodes(oSettings)).each(function () {
|
|
aData.push(_fnGetGroupByLetter(this.innerHTML));
|
|
});
|
|
return aData;
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
|
|
case "year":
|
|
/* Create an array with the values of all the input boxes in a column */
|
|
oTable.fnSettings().aoColumns[properties.iGroupingOrderByColumnIndex].sSortDataType = "rg-date";
|
|
$.fn.dataTableExt.afnSortData['rg-date'] = function (oSettings, iColumn) {
|
|
var aData = [];
|
|
var nTrs = oSettings.oApi._fnGetTrNodes(oSettings);
|
|
for(i = 0; i< nTrs.length; i++)
|
|
{
|
|
aData.push(_fnGetYear( oTable.fnGetData( nTrs[i], iColumn) ));
|
|
}
|
|
|
|
/*
|
|
$('td:eq(' + iColumn + ')', oSettings.oApi._fnGetTrNodes(oSettings)).each(function () {
|
|
aData.push(_fnGetYear(this.innerHTML));
|
|
});
|
|
*/
|
|
return aData;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
|
|
} // end of switch (properties.sGroupBy)
|
|
|
|
if(properties.bUseFilteringForGrouping)
|
|
$.fn.dataTableExt.afnFiltering.push(_rowGroupingRowFilter);
|
|
|
|
oTable.fnDraw();
|
|
|
|
|
|
|
|
});
|
|
};
|
|
})(jQuery); |