| 0,0 → 1,7440 |
|---|
| /* |
| * File: jquery.dataTables.js |
| * Version: 1.8.2+jquery1.9fix+parseJSONfix2+bindfix |
| * Description: Paginate, search and sort HTML tables |
| * Author: Allan Jardine (www.sprymedia.co.uk) |
| * Created: 28/3/2008 |
| * Language: Javascript |
| * License: GPL v2 or BSD 3 point style |
| * Project: Mtaala |
| * Contact: allan.jardine@sprymedia.co.uk |
| * |
| * Copyright 2008-2011 Allan Jardine, 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. See the license files for details. |
| * |
| * For details please refer to: http://www.datatables.net |
| */ |
| |
| /* |
| * When considering jsLint, we need to allow eval() as it it is used for reading cookies |
| */ |
| /*jslint evil: true, undef: true, browser: true */ |
| /*globals $, jQuery,_fnExternApiFunc,_fnInitialise,_fnInitComplete,_fnLanguageProcess,_fnAddColumn,_fnColumnOptions,_fnAddData,_fnCreateTr,_fnGatherData,_fnBuildHead,_fnDrawHead,_fnDraw,_fnReDraw,_fnAjaxUpdate,_fnAjaxParameters,_fnAjaxUpdateDraw,_fnServerParams,_fnAddOptionsHtml,_fnFeatureHtmlTable,_fnScrollDraw,_fnAdjustColumnSizing,_fnFeatureHtmlFilter,_fnFilterComplete,_fnFilterCustom,_fnFilterColumn,_fnFilter,_fnBuildSearchArray,_fnBuildSearchRow,_fnFilterCreateSearch,_fnDataToSearch,_fnSort,_fnSortAttachListener,_fnSortingClasses,_fnFeatureHtmlPaginate,_fnPageChange,_fnFeatureHtmlInfo,_fnUpdateInfo,_fnFeatureHtmlLength,_fnFeatureHtmlProcessing,_fnProcessingDisplay,_fnVisibleToColumnIndex,_fnColumnIndexToVisible,_fnNodeToDataIndex,_fnVisbleColumns,_fnCalculateEnd,_fnConvertToWidth,_fnCalculateColumnWidths,_fnScrollingWidthAdjust,_fnGetWidestNode,_fnGetMaxLenString,_fnStringToCss,_fnArrayCmp,_fnDetectType,_fnSettingsFromNode,_fnGetDataMaster,_fnGetTrNodes,_fnGetTdNodes,_fnEscapeRegex,_fnDeleteIndex,_fnReOrderIndex,_fnColumnOrdering,_fnLog,_fnClearTable,_fnSaveState,_fnLoadState,_fnCreateCookie,_fnReadCookie,_fnDetectHeader,_fnGetUniqueThs,_fnScrollBarWidth,_fnApplyToChildren,_fnMap,_fnGetRowData,_fnGetCellData,_fnSetCellData,_fnGetObjectDataFn,_fnSetObjectDataFn*/ |
| |
| (function($, window, document) { |
| /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
| * Section - DataTables variables |
| * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ |
| |
| /* |
| * Variable: dataTableSettings |
| * Purpose: Store the settings for each dataTables instance |
| * Scope: jQuery.fn |
| */ |
| $.fn.dataTableSettings = []; |
| var _aoSettings = $.fn.dataTableSettings; /* Short reference for fast internal lookup */ |
| |
| /* |
| * Variable: dataTableExt |
| * Purpose: Container for customisable parts of DataTables |
| * Scope: jQuery.fn |
| */ |
| $.fn.dataTableExt = {}; |
| var _oExt = $.fn.dataTableExt; |
| |
| |
| /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
| * Section - DataTables extensible objects |
| * |
| * The _oExt object is used to provide an area where user defined plugins can be |
| * added to DataTables. The following properties of the object are used: |
| * oApi - Plug-in API functions |
| * aTypes - Auto-detection of types |
| * oSort - Sorting functions used by DataTables (based on the type) |
| * oPagination - Pagination functions for different input styles |
| * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ |
| |
| /* |
| * Variable: sVersion |
| * Purpose: Version string for plug-ins to check compatibility |
| * Scope: jQuery.fn.dataTableExt |
| * Notes: Allowed format is a.b.c.d.e where: |
| * a:int, b:int, c:int, d:string(dev|beta), e:int. d and e are optional |
| */ |
| _oExt.sVersion = "1.8.2"; |
| |
| /* |
| * Variable: sErrMode |
| * Purpose: How should DataTables report an error. Can take the value 'alert' or 'throw' |
| * Scope: jQuery.fn.dataTableExt |
| */ |
| _oExt.sErrMode = "alert"; |
| |
| /* |
| * Variable: iApiIndex |
| * Purpose: Index for what 'this' index API functions should use |
| * Scope: jQuery.fn.dataTableExt |
| */ |
| _oExt.iApiIndex = 0; |
| |
| /* |
| * Variable: oApi |
| * Purpose: Container for plugin API functions |
| * Scope: jQuery.fn.dataTableExt |
| */ |
| _oExt.oApi = { }; |
| |
| /* |
| * Variable: aFiltering |
| * Purpose: Container for plugin filtering functions |
| * Scope: jQuery.fn.dataTableExt |
| */ |
| _oExt.afnFiltering = [ ]; |
| |
| /* |
| * Variable: aoFeatures |
| * Purpose: Container for plugin function functions |
| * Scope: jQuery.fn.dataTableExt |
| * Notes: Array of objects with the following parameters: |
| * fnInit: Function for initialisation of Feature. Takes oSettings and returns node |
| * cFeature: Character that will be matched in sDom - case sensitive |
| * sFeature: Feature name - just for completeness :-) |
| */ |
| _oExt.aoFeatures = [ ]; |
| |
| /* |
| * Variable: ofnSearch |
| * Purpose: Container for custom filtering functions |
| * Scope: jQuery.fn.dataTableExt |
| * Notes: This is an object (the name should match the type) for custom filtering function, |
| * which can be used for live DOM checking or formatted text filtering |
| */ |
| _oExt.ofnSearch = { }; |
| |
| /* |
| * Variable: afnSortData |
| * Purpose: Container for custom sorting data source functions |
| * Scope: jQuery.fn.dataTableExt |
| * Notes: Array (associative) of functions which is run prior to a column of this |
| * 'SortDataType' being sorted upon. |
| * Function input parameters: |
| * object:oSettings- DataTables settings object |
| * int:iColumn - Target column number |
| * Return value: Array of data which exactly matched the full data set size for the column to |
| * be sorted upon |
| */ |
| _oExt.afnSortData = [ ]; |
| |
| /* |
| * Variable: oStdClasses |
| * Purpose: Storage for the various classes that DataTables uses |
| * Scope: jQuery.fn.dataTableExt |
| */ |
| _oExt.oStdClasses = { |
| /* Two buttons buttons */ |
| "sPagePrevEnabled": "paginate_enabled_previous", |
| "sPagePrevDisabled": "paginate_disabled_previous", |
| "sPageNextEnabled": "paginate_enabled_next", |
| "sPageNextDisabled": "paginate_disabled_next", |
| "sPageJUINext": "", |
| "sPageJUIPrev": "", |
| |
| /* Full numbers paging buttons */ |
| "sPageButton": "paginate_button", |
| "sPageButtonActive": "paginate_active", |
| "sPageButtonStaticDisabled": "paginate_button paginate_button_disabled", |
| "sPageFirst": "first", |
| "sPagePrevious": "previous", |
| "sPageNext": "next", |
| "sPageLast": "last", |
| |
| /* Striping classes */ |
| "sStripeOdd": "odd", |
| "sStripeEven": "even", |
| |
| /* Empty row */ |
| "sRowEmpty": "dataTables_empty", |
| |
| /* Features */ |
| "sWrapper": "dataTables_wrapper", |
| "sFilter": "dataTables_filter", |
| "sInfo": "dataTables_info", |
| "sPaging": "dataTables_paginate paging_", /* Note that the type is postfixed */ |
| "sLength": "dataTables_length", |
| "sProcessing": "dataTables_processing", |
| |
| /* Sorting */ |
| "sSortAsc": "sorting_asc", |
| "sSortDesc": "sorting_desc", |
| "sSortable": "sorting", /* Sortable in both directions */ |
| "sSortableAsc": "sorting_asc_disabled", |
| "sSortableDesc": "sorting_desc_disabled", |
| "sSortableNone": "sorting_disabled", |
| "sSortColumn": "sorting_", /* Note that an int is postfixed for the sorting order */ |
| "sSortJUIAsc": "", |
| "sSortJUIDesc": "", |
| "sSortJUI": "", |
| "sSortJUIAscAllowed": "", |
| "sSortJUIDescAllowed": "", |
| "sSortJUIWrapper": "", |
| "sSortIcon": "", |
| |
| /* Scrolling */ |
| "sScrollWrapper": "dataTables_scroll", |
| "sScrollHead": "dataTables_scrollHead", |
| "sScrollHeadInner": "dataTables_scrollHeadInner", |
| "sScrollBody": "dataTables_scrollBody", |
| "sScrollFoot": "dataTables_scrollFoot", |
| "sScrollFootInner": "dataTables_scrollFootInner", |
| |
| /* Misc */ |
| "sFooterTH": "" |
| }; |
| |
| /* |
| * Variable: oJUIClasses |
| * Purpose: Storage for the various classes that DataTables uses - jQuery UI suitable |
| * Scope: jQuery.fn.dataTableExt |
| */ |
| _oExt.oJUIClasses = { |
| /* Two buttons buttons */ |
| "sPagePrevEnabled": "fg-button ui-button ui-state-default ui-corner-left", |
| "sPagePrevDisabled": "fg-button ui-button ui-state-default ui-corner-left ui-state-disabled", |
| "sPageNextEnabled": "fg-button ui-button ui-state-default ui-corner-right", |
| "sPageNextDisabled": "fg-button ui-button ui-state-default ui-corner-right ui-state-disabled", |
| "sPageJUINext": "ui-icon ui-icon-circle-arrow-e", |
| "sPageJUIPrev": "ui-icon ui-icon-circle-arrow-w", |
| |
| /* Full numbers paging buttons */ |
| "sPageButton": "fg-button ui-button ui-state-default", |
| "sPageButtonActive": "fg-button ui-button ui-state-default ui-state-disabled", |
| "sPageButtonStaticDisabled": "fg-button ui-button ui-state-default ui-state-disabled", |
| "sPageFirst": "first ui-corner-tl ui-corner-bl", |
| "sPagePrevious": "previous", |
| "sPageNext": "next", |
| "sPageLast": "last ui-corner-tr ui-corner-br", |
| |
| /* Striping classes */ |
| "sStripeOdd": "odd", |
| "sStripeEven": "even", |
| |
| /* Empty row */ |
| "sRowEmpty": "dataTables_empty", |
| |
| /* Features */ |
| "sWrapper": "dataTables_wrapper", |
| "sFilter": "dataTables_filter", |
| "sInfo": "dataTables_info", |
| "sPaging": "dataTables_paginate fg-buttonset ui-buttonset fg-buttonset-multi "+ |
| "ui-buttonset-multi paging_", /* Note that the type is postfixed */ |
| "sLength": "dataTables_length", |
| "sProcessing": "dataTables_processing", |
| |
| /* Sorting */ |
| "sSortAsc": "ui-state-default", |
| "sSortDesc": "ui-state-default", |
| "sSortable": "ui-state-default", |
| "sSortableAsc": "ui-state-default", |
| "sSortableDesc": "ui-state-default", |
| "sSortableNone": "ui-state-default", |
| "sSortColumn": "sorting_", /* Note that an int is postfixed for the sorting order */ |
| "sSortJUIAsc": "css_right ui-icon ui-icon-triangle-1-n", |
| "sSortJUIDesc": "css_right ui-icon ui-icon-triangle-1-s", |
| "sSortJUI": "css_right ui-icon ui-icon-carat-2-n-s", |
| "sSortJUIAscAllowed": "css_right ui-icon ui-icon-carat-1-n", |
| "sSortJUIDescAllowed": "css_right ui-icon ui-icon-carat-1-s", |
| "sSortJUIWrapper": "DataTables_sort_wrapper", |
| "sSortIcon": "DataTables_sort_icon", |
| |
| /* Scrolling */ |
| "sScrollWrapper": "dataTables_scroll", |
| "sScrollHead": "dataTables_scrollHead ui-state-default", |
| "sScrollHeadInner": "dataTables_scrollHeadInner", |
| "sScrollBody": "dataTables_scrollBody", |
| "sScrollFoot": "dataTables_scrollFoot ui-state-default", |
| "sScrollFootInner": "dataTables_scrollFootInner", |
| |
| /* Misc */ |
| "sFooterTH": "ui-state-default" |
| }; |
| |
| /* |
| * Variable: oPagination |
| * Purpose: Container for the various type of pagination that dataTables supports |
| * Scope: jQuery.fn.dataTableExt |
| */ |
| _oExt.oPagination = { |
| /* |
| * Variable: two_button |
| * Purpose: Standard two button (forward/back) pagination |
| * Scope: jQuery.fn.dataTableExt.oPagination |
| */ |
| "two_button": { |
| /* |
| * Function: oPagination.two_button.fnInit |
| * Purpose: Initialise dom elements required for pagination with forward/back buttons only |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| * node:nPaging - the DIV which contains this pagination control |
| * function:fnCallbackDraw - draw function which must be called on update |
| */ |
| "fnInit": function ( oSettings, nPaging, fnCallbackDraw ) |
| { |
| var nPrevious, nNext, nPreviousInner, nNextInner; |
| |
| /* Store the next and previous elements in the oSettings object as they can be very |
| * usful for automation - particularly testing |
| */ |
| if ( !oSettings.bJUI ) |
| { |
| nPrevious = document.createElement( 'div' ); |
| nNext = document.createElement( 'div' ); |
| } |
| else |
| { |
| nPrevious = document.createElement( 'a' ); |
| nNext = document.createElement( 'a' ); |
| |
| nNextInner = document.createElement('span'); |
| nNextInner.className = oSettings.oClasses.sPageJUINext; |
| nNext.appendChild( nNextInner ); |
| |
| nPreviousInner = document.createElement('span'); |
| nPreviousInner.className = oSettings.oClasses.sPageJUIPrev; |
| nPrevious.appendChild( nPreviousInner ); |
| } |
| |
| nPrevious.className = oSettings.oClasses.sPagePrevDisabled; |
| nNext.className = oSettings.oClasses.sPageNextDisabled; |
| |
| nPrevious.title = oSettings.oLanguage.oPaginate.sPrevious; |
| nNext.title = oSettings.oLanguage.oPaginate.sNext; |
| |
| nPaging.appendChild( nPrevious ); |
| nPaging.appendChild( nNext ); |
| |
| $(nPrevious).on( 'click.DT', function() { |
| if ( oSettings.oApi._fnPageChange( oSettings, "previous" ) ) |
| { |
| /* Only draw when the page has actually changed */ |
| fnCallbackDraw( oSettings ); |
| } |
| } ); |
| |
| $(nNext).on( 'click.DT', function() { |
| if ( oSettings.oApi._fnPageChange( oSettings, "next" ) ) |
| { |
| fnCallbackDraw( oSettings ); |
| } |
| } ); |
| |
| /* Take the brutal approach to cancelling text selection */ |
| $(nPrevious).on( 'selectstart.DT', function () { return false; } ); |
| $(nNext).on( 'selectstart.DT', function () { return false; } ); |
| |
| /* ID the first elements only */ |
| if ( oSettings.sTableId !== '' && typeof oSettings.aanFeatures.p == "undefined" ) |
| { |
| nPaging.setAttribute( 'id', oSettings.sTableId+'_paginate' ); |
| nPrevious.setAttribute( 'id', oSettings.sTableId+'_previous' ); |
| nNext.setAttribute( 'id', oSettings.sTableId+'_next' ); |
| } |
| }, |
| |
| /* |
| * Function: oPagination.two_button.fnUpdate |
| * Purpose: Update the two button pagination at the end of the draw |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| * function:fnCallbackDraw - draw function to call on page change |
| */ |
| "fnUpdate": function ( oSettings, fnCallbackDraw ) |
| { |
| if ( !oSettings.aanFeatures.p ) |
| { |
| return; |
| } |
| |
| /* Loop over each instance of the pager */ |
| var an = oSettings.aanFeatures.p; |
| for ( var i=0, iLen=an.length ; i<iLen ; i++ ) |
| { |
| if ( an[i].childNodes.length !== 0 ) |
| { |
| an[i].childNodes[0].className = |
| ( oSettings._iDisplayStart === 0 ) ? |
| oSettings.oClasses.sPagePrevDisabled : oSettings.oClasses.sPagePrevEnabled; |
| |
| an[i].childNodes[1].className = |
| ( oSettings.fnDisplayEnd() == oSettings.fnRecordsDisplay() ) ? |
| oSettings.oClasses.sPageNextDisabled : oSettings.oClasses.sPageNextEnabled; |
| } |
| } |
| } |
| }, |
| |
| |
| /* |
| * Variable: iFullNumbersShowPages |
| * Purpose: Change the number of pages which can be seen |
| * Scope: jQuery.fn.dataTableExt.oPagination |
| */ |
| "iFullNumbersShowPages": 5, |
| |
| /* |
| * Variable: full_numbers |
| * Purpose: Full numbers pagination |
| * Scope: jQuery.fn.dataTableExt.oPagination |
| */ |
| "full_numbers": { |
| /* |
| * Function: oPagination.full_numbers.fnInit |
| * Purpose: Initialise dom elements required for pagination with a list of the pages |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| * node:nPaging - the DIV which contains this pagination control |
| * function:fnCallbackDraw - draw function which must be called on update |
| */ |
| "fnInit": function ( oSettings, nPaging, fnCallbackDraw ) |
| { |
| var nFirst = document.createElement( 'span' ); |
| var nPrevious = document.createElement( 'span' ); |
| var nList = document.createElement( 'span' ); |
| var nNext = document.createElement( 'span' ); |
| var nLast = document.createElement( 'span' ); |
| |
| nFirst.innerHTML = oSettings.oLanguage.oPaginate.sFirst; |
| nPrevious.innerHTML = oSettings.oLanguage.oPaginate.sPrevious; |
| nNext.innerHTML = oSettings.oLanguage.oPaginate.sNext; |
| nLast.innerHTML = oSettings.oLanguage.oPaginate.sLast; |
| |
| var oClasses = oSettings.oClasses; |
| nFirst.className = oClasses.sPageButton+" "+oClasses.sPageFirst; |
| nPrevious.className = oClasses.sPageButton+" "+oClasses.sPagePrevious; |
| nNext.className= oClasses.sPageButton+" "+oClasses.sPageNext; |
| nLast.className = oClasses.sPageButton+" "+oClasses.sPageLast; |
| |
| nPaging.appendChild( nFirst ); |
| nPaging.appendChild( nPrevious ); |
| nPaging.appendChild( nList ); |
| nPaging.appendChild( nNext ); |
| nPaging.appendChild( nLast ); |
| |
| $(nFirst).on( 'click.DT', function () { |
| if ( oSettings.oApi._fnPageChange( oSettings, "first" ) ) |
| { |
| fnCallbackDraw( oSettings ); |
| } |
| } ); |
| |
| $(nPrevious).on( 'click.DT', function() { |
| if ( oSettings.oApi._fnPageChange( oSettings, "previous" ) ) |
| { |
| fnCallbackDraw( oSettings ); |
| } |
| } ); |
| |
| $(nNext).on( 'click.DT', function() { |
| if ( oSettings.oApi._fnPageChange( oSettings, "next" ) ) |
| { |
| fnCallbackDraw( oSettings ); |
| } |
| } ); |
| |
| $(nLast).on( 'click.DT', function() { |
| if ( oSettings.oApi._fnPageChange( oSettings, "last" ) ) |
| { |
| fnCallbackDraw( oSettings ); |
| } |
| } ); |
| |
| /* Take the brutal approach to cancelling text selection */ |
| $('span', nPaging) |
| .on( 'mousedown.DT', function () { return false; } ) |
| .on( 'selectstart.DT', function () { return false; } ); |
| |
| /* ID the first elements only */ |
| if ( oSettings.sTableId !== '' && typeof oSettings.aanFeatures.p == "undefined" ) |
| { |
| nPaging.setAttribute( 'id', oSettings.sTableId+'_paginate' ); |
| nFirst.setAttribute( 'id', oSettings.sTableId+'_first' ); |
| nPrevious.setAttribute( 'id', oSettings.sTableId+'_previous' ); |
| nNext.setAttribute( 'id', oSettings.sTableId+'_next' ); |
| nLast.setAttribute( 'id', oSettings.sTableId+'_last' ); |
| } |
| }, |
| |
| /* |
| * Function: oPagination.full_numbers.fnUpdate |
| * Purpose: Update the list of page buttons shows |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| * function:fnCallbackDraw - draw function to call on page change |
| */ |
| "fnUpdate": function ( oSettings, fnCallbackDraw ) |
| { |
| if ( !oSettings.aanFeatures.p ) |
| { |
| return; |
| } |
| |
| var iPageCount = _oExt.oPagination.iFullNumbersShowPages; |
| var iPageCountHalf = Math.floor(iPageCount / 2); |
| var iPages = Math.ceil((oSettings.fnRecordsDisplay()) / oSettings._iDisplayLength); |
| var iCurrentPage = Math.ceil(oSettings._iDisplayStart / oSettings._iDisplayLength) + 1; |
| var sList = ""; |
| var iStartButton, iEndButton, i, iLen; |
| var oClasses = oSettings.oClasses; |
| |
| /* Pages calculation */ |
| if (iPages < iPageCount) |
| { |
| iStartButton = 1; |
| iEndButton = iPages; |
| } |
| else |
| { |
| if (iCurrentPage <= iPageCountHalf) |
| { |
| iStartButton = 1; |
| iEndButton = iPageCount; |
| } |
| else |
| { |
| if (iCurrentPage >= (iPages - iPageCountHalf)) |
| { |
| iStartButton = iPages - iPageCount + 1; |
| iEndButton = iPages; |
| } |
| else |
| { |
| iStartButton = iCurrentPage - Math.ceil(iPageCount / 2) + 1; |
| iEndButton = iStartButton + iPageCount - 1; |
| } |
| } |
| } |
| |
| /* Build the dynamic list */ |
| for ( i=iStartButton ; i<=iEndButton ; i++ ) |
| { |
| if ( iCurrentPage != i ) |
| { |
| sList += '<span class="'+oClasses.sPageButton+'">'+i+'</span>'; |
| } |
| else |
| { |
| sList += '<span class="'+oClasses.sPageButtonActive+'">'+i+'</span>'; |
| } |
| } |
| |
| /* Loop over each instance of the pager */ |
| var an = oSettings.aanFeatures.p; |
| var anButtons, anStatic, nPaginateList; |
| var fnClick = function(e) { |
| /* Use the information in the element to jump to the required page */ |
| var iTarget = (this.innerHTML * 1) - 1; |
| oSettings._iDisplayStart = iTarget * oSettings._iDisplayLength; |
| fnCallbackDraw( oSettings ); |
| e.preventDefault(); |
| }; |
| var fnFalse = function () { return false; }; |
| |
| for ( i=0, iLen=an.length ; i<iLen ; i++ ) |
| { |
| if ( an[i].childNodes.length === 0 ) |
| { |
| continue; |
| } |
| |
| /* Build up the dynamic list forst - html and listeners */ |
| var qjPaginateList = $('span:eq(2)', an[i]); |
| qjPaginateList.html( sList ); |
| $('span', qjPaginateList).on( 'click.DT', fnClick ).on( 'mousedown.DT', fnFalse ) |
| .on( 'selectstart.DT', fnFalse ); |
| |
| /* Update the 'premanent botton's classes */ |
| anButtons = an[i].getElementsByTagName('span'); |
| anStatic = [ |
| anButtons[0], anButtons[1], |
| anButtons[anButtons.length-2], anButtons[anButtons.length-1] |
| ]; |
| $(anStatic).removeClass( oClasses.sPageButton+" "+oClasses.sPageButtonActive+" "+oClasses.sPageButtonStaticDisabled ); |
| if ( iCurrentPage == 1 ) |
| { |
| anStatic[0].className += " "+oClasses.sPageButtonStaticDisabled; |
| anStatic[1].className += " "+oClasses.sPageButtonStaticDisabled; |
| } |
| else |
| { |
| anStatic[0].className += " "+oClasses.sPageButton; |
| anStatic[1].className += " "+oClasses.sPageButton; |
| } |
| |
| if ( iPages === 0 || iCurrentPage == iPages || oSettings._iDisplayLength == -1 ) |
| { |
| anStatic[2].className += " "+oClasses.sPageButtonStaticDisabled; |
| anStatic[3].className += " "+oClasses.sPageButtonStaticDisabled; |
| } |
| else |
| { |
| anStatic[2].className += " "+oClasses.sPageButton; |
| anStatic[3].className += " "+oClasses.sPageButton; |
| } |
| } |
| } |
| } |
| }; |
| |
| /* |
| * Variable: oSort |
| * Purpose: Wrapper for the sorting functions that can be used in DataTables |
| * Scope: jQuery.fn.dataTableExt |
| * Notes: The functions provided in this object are basically standard javascript sort |
| * functions - they expect two inputs which they then compare and then return a priority |
| * result. For each sort method added, two functions need to be defined, an ascending sort and |
| * a descending sort. |
| */ |
| _oExt.oSort = { |
| /* |
| * text sorting |
| */ |
| "string-asc": function ( a, b ) |
| { |
| if ( typeof a != 'string' ) { a = ''; } |
| if ( typeof b != 'string' ) { b = ''; } |
| var x = a.toLowerCase(); |
| var y = b.toLowerCase(); |
| return ((x < y) ? -1 : ((x > y) ? 1 : 0)); |
| }, |
| |
| "string-desc": function ( a, b ) |
| { |
| if ( typeof a != 'string' ) { a = ''; } |
| if ( typeof b != 'string' ) { b = ''; } |
| var x = a.toLowerCase(); |
| var y = b.toLowerCase(); |
| return ((x < y) ? 1 : ((x > y) ? -1 : 0)); |
| }, |
| |
| |
| /* |
| * html sorting (ignore html tags) |
| */ |
| "html-asc": function ( a, b ) |
| { |
| var x = a.replace( /<.*?>/g, "" ).toLowerCase(); |
| var y = b.replace( /<.*?>/g, "" ).toLowerCase(); |
| return ((x < y) ? -1 : ((x > y) ? 1 : 0)); |
| }, |
| |
| "html-desc": function ( a, b ) |
| { |
| var x = a.replace( /<.*?>/g, "" ).toLowerCase(); |
| var y = b.replace( /<.*?>/g, "" ).toLowerCase(); |
| return ((x < y) ? 1 : ((x > y) ? -1 : 0)); |
| }, |
| |
| |
| /* |
| * date sorting |
| */ |
| "date-asc": function ( a, b ) |
| { |
| var x = Date.parse( a ); |
| var y = Date.parse( b ); |
| |
| if ( isNaN(x) || x==="" ) |
| { |
| x = Date.parse( "01/01/1970 00:00:00" ); |
| } |
| if ( isNaN(y) || y==="" ) |
| { |
| y = Date.parse( "01/01/1970 00:00:00" ); |
| } |
| |
| return x - y; |
| }, |
| |
| "date-desc": function ( a, b ) |
| { |
| var x = Date.parse( a ); |
| var y = Date.parse( b ); |
| |
| if ( isNaN(x) || x==="" ) |
| { |
| x = Date.parse( "01/01/1970 00:00:00" ); |
| } |
| if ( isNaN(y) || y==="" ) |
| { |
| y = Date.parse( "01/01/1970 00:00:00" ); |
| } |
| |
| return y - x; |
| }, |
| |
| |
| /* |
| * numerical sorting |
| */ |
| "numeric-asc": function ( a, b ) |
| { |
| var x = (a=="-" || a==="") ? 0 : a*1; |
| var y = (b=="-" || b==="") ? 0 : b*1; |
| return x - y; |
| }, |
| |
| "numeric-desc": function ( a, b ) |
| { |
| var x = (a=="-" || a==="") ? 0 : a*1; |
| var y = (b=="-" || b==="") ? 0 : b*1; |
| return y - x; |
| } |
| }; |
| |
| |
| /* |
| * Variable: aTypes |
| * Purpose: Container for the various type of type detection that dataTables supports |
| * Scope: jQuery.fn.dataTableExt |
| * Notes: The functions in this array are expected to parse a string to see if it is a data |
| * type that it recognises. If so then the function should return the name of the type (a |
| * corresponding sort function should be defined!), if the type is not recognised then the |
| * function should return null such that the parser and move on to check the next type. |
| * Note that ordering is important in this array - the functions are processed linearly, |
| * starting at index 0. |
| * Note that the input for these functions is always a string! It cannot be any other data |
| * type |
| */ |
| _oExt.aTypes = [ |
| /* |
| * Function: - |
| * Purpose: Check to see if a string is numeric |
| * Returns: string:'numeric' or null |
| * Inputs: mixed:sText - string to check |
| */ |
| function ( sData ) |
| { |
| /* Allow zero length strings as a number */ |
| if ( typeof sData == 'number' ) |
| { |
| return 'numeric'; |
| } |
| else if ( typeof sData != 'string' ) |
| { |
| return null; |
| } |
| |
| var sValidFirstChars = "0123456789-"; |
| var sValidChars = "0123456789."; |
| var Char; |
| var bDecimal = false; |
| |
| /* Check for a valid first char (no period and allow negatives) */ |
| Char = sData.charAt(0); |
| if (sValidFirstChars.indexOf(Char) == -1) |
| { |
| return null; |
| } |
| |
| /* Check all the other characters are valid */ |
| for ( var i=1 ; i<sData.length ; i++ ) |
| { |
| Char = sData.charAt(i); |
| if (sValidChars.indexOf(Char) == -1) |
| { |
| return null; |
| } |
| |
| /* Only allowed one decimal place... */ |
| if ( Char == "." ) |
| { |
| if ( bDecimal ) |
| { |
| return null; |
| } |
| bDecimal = true; |
| } |
| } |
| |
| return 'numeric'; |
| }, |
| |
| /* |
| * Function: - |
| * Purpose: Check to see if a string is actually a formatted date |
| * Returns: string:'date' or null |
| * Inputs: string:sText - string to check |
| */ |
| function ( sData ) |
| { |
| var iParse = Date.parse(sData); |
| if ( (iParse !== null && !isNaN(iParse)) || (typeof sData == 'string' && sData.length === 0) ) |
| { |
| return 'date'; |
| } |
| return null; |
| }, |
| |
| /* |
| * Function: - |
| * Purpose: Check to see if a string should be treated as an HTML string |
| * Returns: string:'html' or null |
| * Inputs: string:sText - string to check |
| */ |
| function ( sData ) |
| { |
| if ( typeof sData == 'string' && sData.indexOf('<') != -1 && sData.indexOf('>') != -1 ) |
| { |
| return 'html'; |
| } |
| return null; |
| } |
| ]; |
| |
| /* |
| * Function: fnVersionCheck |
| * Purpose: Check a version string against this version of DataTables. Useful for plug-ins |
| * Returns: bool:true -this version of DataTables is greater or equal to the required version |
| * false -this version of DataTales is not suitable |
| * Inputs: string:sVersion - the version to check against. May be in the following formats: |
| * "a", "a.b" or "a.b.c" |
| * Notes: This function will only check the first three parts of a version string. It is |
| * assumed that beta and dev versions will meet the requirements. This might change in future |
| */ |
| _oExt.fnVersionCheck = function( sVersion ) |
| { |
| /* This is cheap, but very effective */ |
| var fnZPad = function (Zpad, count) |
| { |
| while(Zpad.length < count) { |
| Zpad += '0'; |
| } |
| return Zpad; |
| }; |
| var aThis = _oExt.sVersion.split('.'); |
| var aThat = sVersion.split('.'); |
| var sThis = '', sThat = ''; |
| |
| for ( var i=0, iLen=aThat.length ; i<iLen ; i++ ) |
| { |
| sThis += fnZPad( aThis[i], 3 ); |
| sThat += fnZPad( aThat[i], 3 ); |
| } |
| |
| return parseInt(sThis, 10) >= parseInt(sThat, 10); |
| }; |
| |
| /* |
| * Variable: _oExternConfig |
| * Purpose: Store information for DataTables to access globally about other instances |
| * Scope: jQuery.fn.dataTableExt |
| */ |
| _oExt._oExternConfig = { |
| /* int:iNextUnique - next unique number for an instance */ |
| "iNextUnique": 0 |
| }; |
| |
| |
| /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
| * Section - DataTables prototype |
| * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ |
| |
| /* |
| * Function: dataTable |
| * Purpose: DataTables information |
| * Returns: - |
| * Inputs: object:oInit - initialisation options for the table |
| */ |
| $.fn.dataTable = function( oInit ) |
| { |
| /* |
| * Function: classSettings |
| * Purpose: Settings container function for all 'class' properties which are required |
| * by dataTables |
| * Returns: - |
| * Inputs: - |
| */ |
| function classSettings () |
| { |
| this.fnRecordsTotal = function () |
| { |
| if ( this.oFeatures.bServerSide ) { |
| return parseInt(this._iRecordsTotal, 10); |
| } else { |
| return this.aiDisplayMaster.length; |
| } |
| }; |
| |
| this.fnRecordsDisplay = function () |
| { |
| if ( this.oFeatures.bServerSide ) { |
| return parseInt(this._iRecordsDisplay, 10); |
| } else { |
| return this.aiDisplay.length; |
| } |
| }; |
| |
| this.fnDisplayEnd = function () |
| { |
| if ( this.oFeatures.bServerSide ) { |
| if ( this.oFeatures.bPaginate === false || this._iDisplayLength == -1 ) { |
| return this._iDisplayStart+this.aiDisplay.length; |
| } else { |
| return Math.min( this._iDisplayStart+this._iDisplayLength, |
| this._iRecordsDisplay ); |
| } |
| } else { |
| return this._iDisplayEnd; |
| } |
| }; |
| |
| /* |
| * Variable: oInstance |
| * Purpose: The DataTables object for this table |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.oInstance = null; |
| |
| /* |
| * Variable: sInstance |
| * Purpose: Unique idendifier for each instance of the DataTables object |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.sInstance = null; |
| |
| /* |
| * Variable: oFeatures |
| * Purpose: Indicate the enablement of key dataTable features |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.oFeatures = { |
| "bPaginate": true, |
| "bLengthChange": true, |
| "bFilter": true, |
| "bSort": true, |
| "bInfo": true, |
| "bAutoWidth": true, |
| "bProcessing": false, |
| "bSortClasses": true, |
| "bStateSave": false, |
| "bServerSide": false, |
| "bDeferRender": false |
| }; |
| |
| /* |
| * Variable: oScroll |
| * Purpose: Container for scrolling options |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.oScroll = { |
| "sX": "", |
| "sXInner": "", |
| "sY": "", |
| "bCollapse": false, |
| "bInfinite": false, |
| "iLoadGap": 100, |
| "iBarWidth": 0, |
| "bAutoCss": true |
| }; |
| |
| /* |
| * Variable: aanFeatures |
| * Purpose: Array referencing the nodes which are used for the features |
| * Scope: jQuery.dataTable.classSettings |
| * Notes: The parameters of this object match what is allowed by sDom - i.e. |
| * 'l' - Length changing |
| * 'f' - Filtering input |
| * 't' - The table! |
| * 'i' - Information |
| * 'p' - Pagination |
| * 'r' - pRocessing |
| */ |
| this.aanFeatures = []; |
| |
| /* |
| * Variable: oLanguage |
| * Purpose: Store the language strings used by dataTables |
| * Scope: jQuery.dataTable.classSettings |
| * Notes: The words in the format _VAR_ are variables which are dynamically replaced |
| * by javascript |
| */ |
| this.oLanguage = { |
| "sProcessing": "Processing...", |
| "sLengthMenu": "Show _MENU_ entries", |
| "sZeroRecords": "No matching records found", |
| "sEmptyTable": "No data available in table", |
| "sLoadingRecords": "Loading...", |
| "sInfo": "Showing _START_ to _END_ of _TOTAL_ entries", |
| "sInfoEmpty": "Showing 0 to 0 of 0 entries", |
| "sInfoFiltered": "(filtered from _MAX_ total entries)", |
| "sInfoPostFix": "", |
| "sInfoThousands": ",", |
| "sSearch": "Search:", |
| "sUrl": "", |
| "oPaginate": { |
| "sFirst": "First", |
| "sPrevious": "Previous", |
| "sNext": "Next", |
| "sLast": "Last" |
| }, |
| "fnInfoCallback": null |
| }; |
| |
| /* |
| * Variable: aoData |
| * Purpose: Store data information |
| * Scope: jQuery.dataTable.classSettings |
| * Notes: This is an array of objects with the following parameters: |
| * int: _iId - internal id for tracking |
| * array: _aData - internal data - used for sorting / filtering etc |
| * node: nTr - display node |
| * array node: _anHidden - hidden TD nodes |
| * string: _sRowStripe |
| */ |
| this.aoData = []; |
| |
| /* |
| * Variable: aiDisplay |
| * Purpose: Array of indexes which are in the current display (after filtering etc) |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.aiDisplay = []; |
| |
| /* |
| * Variable: aiDisplayMaster |
| * Purpose: Array of indexes for display - no filtering |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.aiDisplayMaster = []; |
| |
| /* |
| * Variable: aoColumns |
| * Purpose: Store information about each column that is in use |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.aoColumns = []; |
| |
| /* |
| * Variable: aoHeader |
| * Purpose: Store information about the table's header |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.aoHeader = []; |
| |
| /* |
| * Variable: aoFooter |
| * Purpose: Store information about the table's footer |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.aoFooter = []; |
| |
| /* |
| * Variable: iNextId |
| * Purpose: Store the next unique id to be used for a new row |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.iNextId = 0; |
| |
| /* |
| * Variable: asDataSearch |
| * Purpose: Search data array for regular expression searching |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.asDataSearch = []; |
| |
| /* |
| * Variable: oPreviousSearch |
| * Purpose: Store the previous search incase we want to force a re-search |
| * or compare the old search to a new one |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.oPreviousSearch = { |
| "sSearch": "", |
| "bRegex": false, |
| "bSmart": true |
| }; |
| |
| /* |
| * Variable: aoPreSearchCols |
| * Purpose: Store the previous search for each column |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.aoPreSearchCols = []; |
| |
| /* |
| * Variable: aaSorting |
| * Purpose: Sorting information |
| * Scope: jQuery.dataTable.classSettings |
| * Notes: Index 0 - column number |
| * Index 1 - current sorting direction |
| * Index 2 - index of asSorting for this column |
| */ |
| this.aaSorting = [ [0, 'asc', 0] ]; |
| |
| /* |
| * Variable: aaSortingFixed |
| * Purpose: Sorting information that is always applied |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.aaSortingFixed = null; |
| |
| /* |
| * Variable: asStripeClasses |
| * Purpose: Classes to use for the striping of a table |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.asStripeClasses = []; |
| |
| /* |
| * Variable: asDestroyStripes |
| * Purpose: If restoring a table - we should restore its striping classes as well |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.asDestroyStripes = []; |
| |
| /* |
| * Variable: sDestroyWidth |
| * Purpose: If restoring a table - we should restore its width |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.sDestroyWidth = 0; |
| |
| /* |
| * Variable: fnRowCallback |
| * Purpose: Call this function every time a row is inserted (draw) |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.fnRowCallback = null; |
| |
| /* |
| * Variable: fnHeaderCallback |
| * Purpose: Callback function for the header on each draw |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.fnHeaderCallback = null; |
| |
| /* |
| * Variable: fnFooterCallback |
| * Purpose: Callback function for the footer on each draw |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.fnFooterCallback = null; |
| |
| /* |
| * Variable: aoDrawCallback |
| * Purpose: Array of callback functions for draw callback functions |
| * Scope: jQuery.dataTable.classSettings |
| * Notes: Each array element is an object with the following parameters: |
| * function:fn - function to call |
| * string:sName - name callback (feature). useful for arranging array |
| */ |
| this.aoDrawCallback = []; |
| |
| /* |
| * Variable: fnPreDrawCallback |
| * Purpose: Callback function for just before the table is redrawn. A return of false |
| * will be used to cancel the draw. |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.fnPreDrawCallback = null; |
| |
| /* |
| * Variable: fnInitComplete |
| * Purpose: Callback function for when the table has been initialised |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.fnInitComplete = null; |
| |
| /* |
| * Variable: sTableId |
| * Purpose: Cache the table ID for quick access |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.sTableId = ""; |
| |
| /* |
| * Variable: nTable |
| * Purpose: Cache the table node for quick access |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.nTable = null; |
| |
| /* |
| * Variable: nTHead |
| * Purpose: Permanent ref to the thead element |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.nTHead = null; |
| |
| /* |
| * Variable: nTFoot |
| * Purpose: Permanent ref to the tfoot element - if it exists |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.nTFoot = null; |
| |
| /* |
| * Variable: nTBody |
| * Purpose: Permanent ref to the tbody element |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.nTBody = null; |
| |
| /* |
| * Variable: nTableWrapper |
| * Purpose: Cache the wrapper node (contains all DataTables controlled elements) |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.nTableWrapper = null; |
| |
| /* |
| * Variable: bDeferLoading |
| * Purpose: Indicate if when using server-side processing the loading of data |
| * should be deferred until the second draw |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.bDeferLoading = false; |
| |
| /* |
| * Variable: bInitialised |
| * Purpose: Indicate if all required information has been read in |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.bInitialised = false; |
| |
| /* |
| * Variable: aoOpenRows |
| * Purpose: Information about open rows |
| * Scope: jQuery.dataTable.classSettings |
| * Notes: Has the parameters 'nTr' and 'nParent' |
| */ |
| this.aoOpenRows = []; |
| |
| /* |
| * Variable: sDom |
| * Purpose: Dictate the positioning that the created elements will take |
| * Scope: jQuery.dataTable.classSettings |
| * Notes: |
| * The following options are allowed: |
| * 'l' - Length changing |
| * 'f' - Filtering input |
| * 't' - The table! |
| * 'i' - Information |
| * 'p' - Pagination |
| * 'r' - pRocessing |
| * The following constants are allowed: |
| * 'H' - jQueryUI theme "header" classes |
| * 'F' - jQueryUI theme "footer" classes |
| * The following syntax is expected: |
| * '<' and '>' - div elements |
| * '<"class" and '>' - div with a class |
| * Examples: |
| * '<"wrapper"flipt>', '<lf<t>ip>' |
| */ |
| this.sDom = 'lfrtip'; |
| |
| /* |
| * Variable: sPaginationType |
| * Purpose: Note which type of sorting should be used |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.sPaginationType = "two_button"; |
| |
| /* |
| * Variable: iCookieDuration |
| * Purpose: The cookie duration (for bStateSave) in seconds - default 2 hours |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.iCookieDuration = 60 * 60 * 2; |
| |
| /* |
| * Variable: sCookiePrefix |
| * Purpose: The cookie name prefix |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.sCookiePrefix = "SpryMedia_DataTables_"; |
| |
| /* |
| * Variable: fnCookieCallback |
| * Purpose: Callback function for cookie creation |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.fnCookieCallback = null; |
| |
| /* |
| * Variable: aoStateSave |
| * Purpose: Array of callback functions for state saving |
| * Scope: jQuery.dataTable.classSettings |
| * Notes: Each array element is an object with the following parameters: |
| * function:fn - function to call. Takes two parameters, oSettings and the JSON string to |
| * save that has been thus far created. Returns a JSON string to be inserted into a |
| * json object (i.e. '"param": [ 0, 1, 2]') |
| * string:sName - name of callback |
| */ |
| this.aoStateSave = []; |
| |
| /* |
| * Variable: aoStateLoad |
| * Purpose: Array of callback functions for state loading |
| * Scope: jQuery.dataTable.classSettings |
| * Notes: Each array element is an object with the following parameters: |
| * function:fn - function to call. Takes two parameters, oSettings and the object stored. |
| * May return false to cancel state loading. |
| * string:sName - name of callback |
| */ |
| this.aoStateLoad = []; |
| |
| /* |
| * Variable: oLoadedState |
| * Purpose: State that was loaded from the cookie. Useful for back reference |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.oLoadedState = null; |
| |
| /* |
| * Variable: sAjaxSource |
| * Purpose: Source url for AJAX data for the table |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.sAjaxSource = null; |
| |
| /* |
| * Variable: sAjaxDataProp |
| * Purpose: Property from a given object from which to read the table data from. This can |
| * be an empty string (when not server-side processing), in which case it is |
| * assumed an an array is given directly. |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.sAjaxDataProp = 'aaData'; |
| |
| /* |
| * Variable: bAjaxDataGet |
| * Purpose: Note if draw should be blocked while getting data |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.bAjaxDataGet = true; |
| |
| /* |
| * Variable: jqXHR |
| * Purpose: The last jQuery XHR object that was used for server-side data gathering. |
| * This can be used for working with the XHR information in one of the callbacks |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.jqXHR = null; |
| |
| /* |
| * Variable: fnServerData |
| * Purpose: Function to get the server-side data - can be overruled by the developer |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.fnServerData = function ( url, data, callback, settings ) { |
| settings.jqXHR = $.ajax( { |
| "url": url, |
| "data": data, |
| "success": function (json) { |
| $(settings.oInstance).trigger('xhr', settings); |
| callback( json ); |
| }, |
| "dataType": "json", |
| "cache": false, |
| "error": function (xhr, error, thrown) { |
| if ( error == "parsererror" ) { |
| alert( "DataTables warning: JSON data from server could not be parsed. "+ |
| "This is caused by a JSON formatting error." ); |
| } |
| } |
| } ); |
| }; |
| |
| /* |
| * Variable: aoServerParams |
| * Purpose: Functions which are called prior to sending an Ajax request so extra parameters |
| * can easily be sent to the server |
| * Scope: jQuery.dataTable.classSettings |
| * Notes: Each array element is an object with the following parameters: |
| * function:fn - function to call |
| * string:sName - name callback - useful for knowing where it came from (plugin etc) |
| */ |
| this.aoServerParams = []; |
| |
| /* |
| * Variable: fnFormatNumber |
| * Purpose: Format numbers for display |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.fnFormatNumber = function ( iIn ) |
| { |
| if ( iIn < 1000 ) |
| { |
| /* A small optimisation for what is likely to be the vast majority of use cases */ |
| return iIn; |
| } |
| else |
| { |
| var s=(iIn+""), a=s.split(""), out="", iLen=s.length; |
| |
| for ( var i=0 ; i<iLen ; i++ ) |
| { |
| if ( i%3 === 0 && i !== 0 ) |
| { |
| out = this.oLanguage.sInfoThousands+out; |
| } |
| out = a[iLen-i-1]+out; |
| } |
| } |
| return out; |
| }; |
| |
| /* |
| * Variable: aLengthMenu |
| * Purpose: List of options that can be used for the user selectable length menu |
| * Scope: jQuery.dataTable.classSettings |
| * Note: This varaible can take for form of a 1D array, in which case the value and the |
| * displayed value in the menu are the same, or a 2D array in which case the value comes |
| * from the first array, and the displayed value to the end user comes from the second |
| * array. 2D example: [ [ 10, 25, 50, 100, -1 ], [ 10, 25, 50, 100, 'All' ] ]; |
| */ |
| this.aLengthMenu = [ 10, 25, 50, 100 ]; |
| |
| /* |
| * Variable: iDraw |
| * Purpose: Counter for the draws that the table does. Also used as a tracker for |
| * server-side processing |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.iDraw = 0; |
| |
| /* |
| * Variable: bDrawing |
| * Purpose: Indicate if a redraw is being done - useful for Ajax |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.bDrawing = 0; |
| |
| /* |
| * Variable: iDrawError |
| * Purpose: Last draw error |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.iDrawError = -1; |
| |
| /* |
| * Variable: _iDisplayLength, _iDisplayStart, _iDisplayEnd |
| * Purpose: Display length variables |
| * Scope: jQuery.dataTable.classSettings |
| * Notes: These variable must NOT be used externally to get the data length. Rather, use |
| * the fnRecordsTotal() (etc) functions. |
| */ |
| this._iDisplayLength = 10; |
| this._iDisplayStart = 0; |
| this._iDisplayEnd = 10; |
| |
| /* |
| * Variable: _iRecordsTotal, _iRecordsDisplay |
| * Purpose: Display length variables used for server side processing |
| * Scope: jQuery.dataTable.classSettings |
| * Notes: These variable must NOT be used externally to get the data length. Rather, use |
| * the fnRecordsTotal() (etc) functions. |
| */ |
| this._iRecordsTotal = 0; |
| this._iRecordsDisplay = 0; |
| |
| /* |
| * Variable: bJUI |
| * Purpose: Should we add the markup needed for jQuery UI theming? |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.bJUI = false; |
| |
| /* |
| * Variable: oClasses |
| * Purpose: Should we add the markup needed for jQuery UI theming? |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.oClasses = _oExt.oStdClasses; |
| |
| /* |
| * Variable: bFiltered and bSorted |
| * Purpose: Flags to allow callback functions to see what actions have been performed |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.bFiltered = false; |
| this.bSorted = false; |
| |
| /* |
| * Variable: bSortCellsTop |
| * Purpose: Indicate that if multiple rows are in the header and there is more than one |
| * unique cell per column, if the top one (true) or bottom one (false) should |
| * be used for sorting / title by DataTables |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.bSortCellsTop = false; |
| |
| /* |
| * Variable: oInit |
| * Purpose: Initialisation object that is used for the table |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.oInit = null; |
| |
| /* |
| * Variable: aoDestroyCallback |
| * Purpose: Destroy callback functions |
| * Scope: jQuery.dataTable.classSettings |
| */ |
| this.aoDestroyCallback = []; |
| } |
| |
| /* |
| * Variable: oApi |
| * Purpose: Container for publicly exposed 'private' functions |
| * Scope: jQuery.dataTable |
| */ |
| this.oApi = {}; |
| |
| |
| /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
| * Section - API functions |
| * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ |
| |
| /* |
| * Function: fnDraw |
| * Purpose: Redraw the table |
| * Returns: - |
| * Inputs: bool:bComplete - Refilter and resort (if enabled) the table before the draw. |
| * Optional: default - true |
| */ |
| this.fnDraw = function( bComplete ) |
| { |
| var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] ); |
| if ( typeof bComplete != 'undefined' && bComplete === false ) |
| { |
| _fnCalculateEnd( oSettings ); |
| _fnDraw( oSettings ); |
| } |
| else |
| { |
| _fnReDraw( oSettings ); |
| } |
| }; |
| |
| /* |
| * Function: fnFilter |
| * Purpose: Filter the input based on data |
| * Returns: - |
| * Inputs: string:sInput - string to filter the table on |
| * int:iColumn - optional - column to limit filtering to |
| * bool:bRegex - optional - treat as regular expression or not - default false |
| * bool:bSmart - optional - perform smart filtering or not - default true |
| * bool:bShowGlobal - optional - show the input global filter in it's input box(es) |
| * - default true |
| */ |
| this.fnFilter = function( sInput, iColumn, bRegex, bSmart, bShowGlobal ) |
| { |
| var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] ); |
| |
| if ( !oSettings.oFeatures.bFilter ) |
| { |
| return; |
| } |
| |
| if ( typeof bRegex == 'undefined' ) |
| { |
| bRegex = false; |
| } |
| |
| if ( typeof bSmart == 'undefined' ) |
| { |
| bSmart = true; |
| } |
| |
| if ( typeof bShowGlobal == 'undefined' ) |
| { |
| bShowGlobal = true; |
| } |
| |
| if ( typeof iColumn == "undefined" || iColumn === null ) |
| { |
| /* Global filter */ |
| _fnFilterComplete( oSettings, { |
| "sSearch":sInput, |
| "bRegex": bRegex, |
| "bSmart": bSmart |
| }, 1 ); |
| |
| if ( bShowGlobal && typeof oSettings.aanFeatures.f != 'undefined' ) |
| { |
| var n = oSettings.aanFeatures.f; |
| for ( var i=0, iLen=n.length ; i<iLen ; i++ ) |
| { |
| $('input', n[i]).val( sInput ); |
| } |
| } |
| } |
| else |
| { |
| /* Single column filter */ |
| oSettings.aoPreSearchCols[ iColumn ].sSearch = sInput; |
| oSettings.aoPreSearchCols[ iColumn ].bRegex = bRegex; |
| oSettings.aoPreSearchCols[ iColumn ].bSmart = bSmart; |
| _fnFilterComplete( oSettings, oSettings.oPreviousSearch, 1 ); |
| } |
| }; |
| |
| /* |
| * Function: fnSettings |
| * Purpose: Get the settings for a particular table for extern. manipulation |
| * Returns: - |
| * Inputs: - |
| */ |
| this.fnSettings = function( nNode ) |
| { |
| return _fnSettingsFromNode( this[_oExt.iApiIndex] ); |
| }; |
| |
| /* |
| * Function: fnVersionCheck |
| * Notes: The function is the same as the 'static' function provided in the ext variable |
| */ |
| this.fnVersionCheck = _oExt.fnVersionCheck; |
| |
| /* |
| * Function: fnSort |
| * Purpose: Sort the table by a particular row |
| * Returns: - |
| * Inputs: int:iCol - the data index to sort on. Note that this will |
| * not match the 'display index' if you have hidden data entries |
| */ |
| this.fnSort = function( aaSort ) |
| { |
| var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] ); |
| oSettings.aaSorting = aaSort; |
| _fnSort( oSettings ); |
| }; |
| |
| /* |
| * Function: fnSortListener |
| * Purpose: Attach a sort listener to an element for a given column |
| * Returns: - |
| * Inputs: node:nNode - the element to attach the sort listener to |
| * int:iColumn - the column that a click on this node will sort on |
| * function:fnCallback - callback function when sort is run - optional |
| */ |
| this.fnSortListener = function( nNode, iColumn, fnCallback ) |
| { |
| _fnSortAttachListener( _fnSettingsFromNode( this[_oExt.iApiIndex] ), nNode, iColumn, |
| fnCallback ); |
| }; |
| |
| /* |
| * Function: fnAddData |
| * Purpose: Add new row(s) into the table |
| * Returns: array int: array of indexes (aoData) which have been added (zero length on error) |
| * Inputs: array:mData - the data to be added. The length must match |
| * the original data from the DOM |
| * or |
| * array array:mData - 2D array of data to be added |
| * bool:bRedraw - redraw the table or not - default true |
| * Notes: Warning - the refilter here will cause the table to redraw |
| * starting at zero |
| * Notes: Thanks to Yekimov Denis for contributing the basis for this function! |
| */ |
| this.fnAddData = function( mData, bRedraw ) |
| { |
| if ( mData.length === 0 ) |
| { |
| return []; |
| } |
| |
| var aiReturn = []; |
| var iTest; |
| |
| /* Find settings from table node */ |
| var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] ); |
| |
| /* Check if we want to add multiple rows or not */ |
| if ( typeof mData[0] == "object" ) |
| { |
| for ( var i=0 ; i<mData.length ; i++ ) |
| { |
| iTest = _fnAddData( oSettings, mData[i] ); |
| if ( iTest == -1 ) |
| { |
| return aiReturn; |
| } |
| aiReturn.push( iTest ); |
| } |
| } |
| else |
| { |
| iTest = _fnAddData( oSettings, mData ); |
| if ( iTest == -1 ) |
| { |
| return aiReturn; |
| } |
| aiReturn.push( iTest ); |
| } |
| |
| oSettings.aiDisplay = oSettings.aiDisplayMaster.slice(); |
| |
| if ( typeof bRedraw == 'undefined' || bRedraw ) |
| { |
| _fnReDraw( oSettings ); |
| } |
| return aiReturn; |
| }; |
| |
| /* |
| * Function: fnDeleteRow |
| * Purpose: Remove a row for the table |
| * Returns: array:aReturn - the row that was deleted |
| * Inputs: mixed:mTarget - |
| * int: - index of aoData to be deleted, or |
| * node(TR): - TR element you want to delete |
| * function:fnCallBack - callback function - default null |
| * bool:bRedraw - redraw the table or not - default true |
| */ |
| this.fnDeleteRow = function( mTarget, fnCallBack, bRedraw ) |
| { |
| /* Find settings from table node */ |
| var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] ); |
| var i, iAODataIndex; |
| |
| iAODataIndex = (typeof mTarget == 'object') ? |
| _fnNodeToDataIndex(oSettings, mTarget) : mTarget; |
| |
| /* Return the data array from this row */ |
| var oData = oSettings.aoData.splice( iAODataIndex, 1 ); |
| |
| /* Remove the target row from the search array */ |
| var iDisplayIndex = $.inArray( iAODataIndex, oSettings.aiDisplay ); |
| oSettings.asDataSearch.splice( iDisplayIndex, 1 ); |
| |
| /* Delete from the display arrays */ |
| _fnDeleteIndex( oSettings.aiDisplayMaster, iAODataIndex ); |
| _fnDeleteIndex( oSettings.aiDisplay, iAODataIndex ); |
| |
| /* If there is a user callback function - call it */ |
| if ( typeof fnCallBack == "function" ) |
| { |
| fnCallBack.call( this, oSettings, oData ); |
| } |
| |
| /* Check for an 'overflow' they case for dislaying the table */ |
| if ( oSettings._iDisplayStart >= oSettings.aiDisplay.length ) |
| { |
| oSettings._iDisplayStart -= oSettings._iDisplayLength; |
| if ( oSettings._iDisplayStart < 0 ) |
| { |
| oSettings._iDisplayStart = 0; |
| } |
| } |
| |
| if ( typeof bRedraw == 'undefined' || bRedraw ) |
| { |
| _fnCalculateEnd( oSettings ); |
| _fnDraw( oSettings ); |
| } |
| |
| return oData; |
| }; |
| |
| /* |
| * Function: fnClearTable |
| * Purpose: Quickly and simply clear a table |
| * Returns: - |
| * Inputs: bool:bRedraw - redraw the table or not - default true |
| * Notes: Thanks to Yekimov Denis for contributing the basis for this function! |
| */ |
| this.fnClearTable = function( bRedraw ) |
| { |
| /* Find settings from table node */ |
| var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] ); |
| _fnClearTable( oSettings ); |
| |
| if ( typeof bRedraw == 'undefined' || bRedraw ) |
| { |
| _fnDraw( oSettings ); |
| } |
| }; |
| |
| /* |
| * Function: fnOpen |
| * Purpose: Open a display row (append a row after the row in question) |
| * Returns: node:nNewRow - the row opened |
| * Inputs: node:nTr - the table row to 'open' |
| * string|node|jQuery:mHtml - the HTML to put into the row |
| * string:sClass - class to give the new TD cell |
| */ |
| this.fnOpen = function( nTr, mHtml, sClass ) |
| { |
| /* Find settings from table node */ |
| var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] ); |
| |
| /* the old open one if there is one */ |
| this.fnClose( nTr ); |
| |
| var nNewRow = document.createElement("tr"); |
| var nNewCell = document.createElement("td"); |
| nNewRow.appendChild( nNewCell ); |
| nNewCell.className = sClass; |
| nNewCell.colSpan = _fnVisbleColumns( oSettings ); |
| |
| if( typeof mHtml.jquery != 'undefined' || typeof mHtml == "object" ) |
| { |
| nNewCell.appendChild( mHtml ); |
| } |
| else |
| { |
| nNewCell.innerHTML = mHtml; |
| } |
| |
| /* If the nTr isn't on the page at the moment - then we don't insert at the moment */ |
| var nTrs = $('tr', oSettings.nTBody); |
| if ( $.inArray(nTr, nTrs) != -1 ) |
| { |
| $(nNewRow).insertAfter(nTr); |
| } |
| |
| oSettings.aoOpenRows.push( { |
| "nTr": nNewRow, |
| "nParent": nTr |
| } ); |
| |
| return nNewRow; |
| }; |
| |
| /* |
| * Function: fnClose |
| * Purpose: Close a display row |
| * Returns: int: 0 (success) or 1 (failed) |
| * Inputs: node:nTr - the table row to 'close' |
| */ |
| this.fnClose = function( nTr ) |
| { |
| /* Find settings from table node */ |
| var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] ); |
| |
| for ( var i=0 ; i<oSettings.aoOpenRows.length ; i++ ) |
| { |
| if ( oSettings.aoOpenRows[i].nParent == nTr ) |
| { |
| var nTrParent = oSettings.aoOpenRows[i].nTr.parentNode; |
| if ( nTrParent ) |
| { |
| /* Remove it if it is currently on display */ |
| nTrParent.removeChild( oSettings.aoOpenRows[i].nTr ); |
| } |
| oSettings.aoOpenRows.splice( i, 1 ); |
| return 0; |
| } |
| } |
| return 1; |
| }; |
| |
| /* |
| * Function: fnGetData |
| * Purpose: Return an array with the data which is used to make up the table |
| * Returns: array array string: 2d data array ([row][column]) or array string: 1d data array |
| * or string if both row and column are given |
| * Inputs: mixed:mRow - optional - if not present, then the full 2D array for the table |
| * if given then: |
| * int: - return data object for aoData entry of this index |
| * node(TR): - return data object for this TR element |
| * int:iCol - optional - the column that you want the data of. This will take into |
| * account mDataProp and return the value DataTables uses for this column |
| */ |
| this.fnGetData = function( mRow, iCol ) |
| { |
| var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] ); |
| |
| if ( typeof mRow != 'undefined' ) |
| { |
| var iRow = (typeof mRow == 'object') ? |
| _fnNodeToDataIndex(oSettings, mRow) : mRow; |
| |
| if ( typeof iCol != 'undefined' ) |
| { |
| return _fnGetCellData( oSettings, iRow, iCol, '' ); |
| } |
| return (typeof oSettings.aoData[iRow] != 'undefined') ? |
| oSettings.aoData[iRow]._aData : null; |
| } |
| return _fnGetDataMaster( oSettings ); |
| }; |
| |
| /* |
| * Function: fnGetNodes |
| * Purpose: Return an array with the TR nodes used for drawing the table |
| * Returns: array node: TR elements |
| * or |
| * node (if iRow specified) |
| * Inputs: int:iRow - optional - if present then the array returned will be the node for |
| * the row with the index 'iRow' |
| */ |
| this.fnGetNodes = function( iRow ) |
| { |
| var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] ); |
| |
| if ( typeof iRow != 'undefined' ) |
| { |
| return (typeof oSettings.aoData[iRow] != 'undefined') ? oSettings.aoData[iRow].nTr : null; |
| } |
| return _fnGetTrNodes( oSettings ); |
| }; |
| |
| /* |
| * Function: fnGetPosition |
| * Purpose: Get the array indexes of a particular cell from it's DOM element |
| * Returns: int: - row index, or array[ int, int, int ]: - row index, column index (visible) |
| * and column index including hidden columns |
| * Inputs: node:nNode - this can either be a TR, TD or TH in the table's body, the return is |
| * dependent on this input |
| */ |
| this.fnGetPosition = function( nNode ) |
| { |
| var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] ); |
| var sNodeName = nNode.nodeName.toUpperCase(); |
| |
| if ( sNodeName == "TR" ) |
| { |
| return _fnNodeToDataIndex(oSettings, nNode); |
| } |
| else if ( sNodeName == "TD" || sNodeName == "TH" ) |
| { |
| var iDataIndex = _fnNodeToDataIndex(oSettings, nNode.parentNode); |
| var anCells = _fnGetTdNodes( oSettings, iDataIndex ); |
| |
| for ( var i=0 ; i<oSettings.aoColumns.length ; i++ ) |
| { |
| if ( anCells[i] == nNode ) |
| { |
| return [ iDataIndex, _fnColumnIndexToVisible(oSettings, i ), i ]; |
| } |
| } |
| } |
| return null; |
| }; |
| |
| /* |
| * Function: fnUpdate |
| * Purpose: Update a table cell or row - this method will accept either a single value to |
| * update the cell with, an array of values with one element for each column or |
| * an object in the same format as the original data source. The function is |
| * self-referencing in order to make the multi column updates easier. |
| * Returns: int: 0 okay, 1 error |
| * Inputs: object | array string | string:mData - data to update the cell/row with |
| * mixed:mRow - |
| * int: - index of aoData to be updated, or |
| * node(TR): - TR element you want to update |
| * int:iColumn - the column to update - optional (not used of mData is an array or object) |
| * bool:bRedraw - redraw the table or not - default true |
| * bool:bAction - perform predraw actions or not (you will want this as 'true' if |
| * you have bRedraw as true) - default true |
| */ |
| this.fnUpdate = function( mData, mRow, iColumn, bRedraw, bAction ) |
| { |
| var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] ); |
| var iVisibleColumn, i, iLen, sDisplay; |
| var iRow = (typeof mRow == 'object') ? |
| _fnNodeToDataIndex(oSettings, mRow) : mRow; |
| |
| if ( $.isArray(mData) && typeof mData == 'object' ) |
| { |
| /* Array update - update the whole row */ |
| oSettings.aoData[iRow]._aData = mData.slice(); |
| |
| for ( i=0 ; i<oSettings.aoColumns.length ; i++ ) |
| { |
| this.fnUpdate( _fnGetCellData( oSettings, iRow, i ), iRow, i, false, false ); |
| } |
| } |
| else if ( mData !== null && typeof mData == 'object' ) |
| { |
| /* Object update - update the whole row - assume the developer gets the object right */ |
| oSettings.aoData[iRow]._aData = $.extend( true, {}, mData ); |
| |
| for ( i=0 ; i<oSettings.aoColumns.length ; i++ ) |
| { |
| this.fnUpdate( _fnGetCellData( oSettings, iRow, i ), iRow, i, false, false ); |
| } |
| } |
| else |
| { |
| /* Individual cell update */ |
| sDisplay = mData; |
| _fnSetCellData( oSettings, iRow, iColumn, sDisplay ); |
| |
| if ( oSettings.aoColumns[iColumn].fnRender !== null ) |
| { |
| sDisplay = oSettings.aoColumns[iColumn].fnRender( { |
| "iDataRow": iRow, |
| "iDataColumn": iColumn, |
| "aData": oSettings.aoData[iRow]._aData, |
| "oSettings": oSettings |
| } ); |
| |
| if ( oSettings.aoColumns[iColumn].bUseRendered ) |
| { |
| _fnSetCellData( oSettings, iRow, iColumn, sDisplay ); |
| } |
| } |
| |
| if ( oSettings.aoData[iRow].nTr !== null ) |
| { |
| /* Do the actual HTML update */ |
| _fnGetTdNodes( oSettings, iRow )[iColumn].innerHTML = sDisplay; |
| } |
| } |
| |
| /* Modify the search index for this row (strictly this is likely not needed, since fnReDraw |
| * will rebuild the search array - however, the redraw might be disabled by the user) |
| */ |
| var iDisplayIndex = $.inArray( iRow, oSettings.aiDisplay ); |
| oSettings.asDataSearch[iDisplayIndex] = _fnBuildSearchRow( oSettings, |
| _fnGetRowData( oSettings, iRow, 'filter' ) ); |
| |
| /* Perform pre-draw actions */ |
| if ( typeof bAction == 'undefined' || bAction ) |
| { |
| _fnAdjustColumnSizing( oSettings ); |
| } |
| |
| /* Redraw the table */ |
| if ( typeof bRedraw == 'undefined' || bRedraw ) |
| { |
| _fnReDraw( oSettings ); |
| } |
| return 0; |
| }; |
| |
| |
| /* |
| * Function: fnShowColoumn |
| * Purpose: Show a particular column |
| * Returns: - |
| * Inputs: int:iCol - the column whose display should be changed |
| * bool:bShow - show (true) or hide (false) the column |
| * bool:bRedraw - redraw the table or not - default true |
| */ |
| this.fnSetColumnVis = function ( iCol, bShow, bRedraw ) |
| { |
| var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] ); |
| var i, iLen; |
| var iColumns = oSettings.aoColumns.length; |
| var nTd, nCell, anTrs, jqChildren, bAppend, iBefore; |
| |
| /* No point in doing anything if we are requesting what is already true */ |
| if ( oSettings.aoColumns[iCol].bVisible == bShow ) |
| { |
| return; |
| } |
| |
| /* Show the column */ |
| if ( bShow ) |
| { |
| var iInsert = 0; |
| for ( i=0 ; i<iCol ; i++ ) |
| { |
| if ( oSettings.aoColumns[i].bVisible ) |
| { |
| iInsert++; |
| } |
| } |
| |
| /* Need to decide if we should use appendChild or insertBefore */ |
| bAppend = (iInsert >= _fnVisbleColumns( oSettings )); |
| |
| /* Which coloumn should we be inserting before? */ |
| if ( !bAppend ) |
| { |
| for ( i=iCol ; i<iColumns ; i++ ) |
| { |
| if ( oSettings.aoColumns[i].bVisible ) |
| { |
| iBefore = i; |
| break; |
| } |
| } |
| } |
| |
| for ( i=0, iLen=oSettings.aoData.length ; i<iLen ; i++ ) |
| { |
| if ( oSettings.aoData[i].nTr !== null ) |
| { |
| if ( bAppend ) |
| { |
| oSettings.aoData[i].nTr.appendChild( |
| oSettings.aoData[i]._anHidden[iCol] |
| ); |
| } |
| else |
| { |
| oSettings.aoData[i].nTr.insertBefore( |
| oSettings.aoData[i]._anHidden[iCol], |
| _fnGetTdNodes( oSettings, i )[iBefore] ); |
| } |
| } |
| } |
| } |
| else |
| { |
| /* Remove a column from display */ |
| for ( i=0, iLen=oSettings.aoData.length ; i<iLen ; i++ ) |
| { |
| if ( oSettings.aoData[i].nTr !== null ) |
| { |
| nTd = _fnGetTdNodes( oSettings, i )[iCol]; |
| oSettings.aoData[i]._anHidden[iCol] = nTd; |
| nTd.parentNode.removeChild( nTd ); |
| } |
| } |
| } |
| |
| /* Clear to set the visible flag */ |
| oSettings.aoColumns[iCol].bVisible = bShow; |
| |
| /* Redraw the header and footer based on the new column visibility */ |
| _fnDrawHead( oSettings, oSettings.aoHeader ); |
| if ( oSettings.nTFoot ) |
| { |
| _fnDrawHead( oSettings, oSettings.aoFooter ); |
| } |
| |
| /* If there are any 'open' rows, then we need to alter the colspan for this col change */ |
| for ( i=0, iLen=oSettings.aoOpenRows.length ; i<iLen ; i++ ) |
| { |
| oSettings.aoOpenRows[i].nTr.colSpan = _fnVisbleColumns( oSettings ); |
| } |
| |
| /* Do a redraw incase anything depending on the table columns needs it |
| * (built-in: scrolling) |
| */ |
| if ( typeof bRedraw == 'undefined' || bRedraw ) |
| { |
| _fnAdjustColumnSizing( oSettings ); |
| _fnDraw( oSettings ); |
| } |
| |
| _fnSaveState( oSettings ); |
| }; |
| |
| /* |
| * Function: fnPageChange |
| * Purpose: Change the pagination |
| * Returns: - |
| * Inputs: string:sAction - paging action to take: "first", "previous", "next" or "last" |
| * bool:bRedraw - redraw the table or not - optional - default true |
| */ |
| this.fnPageChange = function ( sAction, bRedraw ) |
| { |
| var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] ); |
| _fnPageChange( oSettings, sAction ); |
| _fnCalculateEnd( oSettings ); |
| |
| if ( typeof bRedraw == 'undefined' || bRedraw ) |
| { |
| _fnDraw( oSettings ); |
| } |
| }; |
| |
| /* |
| * Function: fnDestroy |
| * Purpose: Destructor for the DataTable |
| * Returns: - |
| * Inputs: - |
| */ |
| this.fnDestroy = function ( ) |
| { |
| var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] ); |
| var nOrig = oSettings.nTableWrapper.parentNode; |
| var nBody = oSettings.nTBody; |
| var i, iLen; |
| |
| /* Flag to note that the table is currently being destoryed - no action should be taken */ |
| oSettings.bDestroying = true; |
| |
| /* Restore hidden columns */ |
| for ( i=0, iLen=oSettings.aoDestroyCallback.length ; i<iLen ; i++ ) { |
| oSettings.aoDestroyCallback[i].fn(); |
| } |
| |
| /* Restore hidden columns */ |
| for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ ) |
| { |
| if ( oSettings.aoColumns[i].bVisible === false ) |
| { |
| this.fnSetColumnVis( i, true ); |
| } |
| } |
| |
| /* Blitz all DT events */ |
| $(oSettings.nTableWrapper).find('*').andSelf().off('.DT'); |
| |
| /* If there is an 'empty' indicator row, remove it */ |
| $('tbody>tr>td.'+oSettings.oClasses.sRowEmpty, oSettings.nTable).parent().remove(); |
| |
| /* When scrolling we had to break the table up - restore it */ |
| if ( oSettings.nTable != oSettings.nTHead.parentNode ) |
| { |
| $(oSettings.nTable).children('thead').remove(); |
| oSettings.nTable.appendChild( oSettings.nTHead ); |
| } |
| |
| if ( oSettings.nTFoot && oSettings.nTable != oSettings.nTFoot.parentNode ) |
| { |
| $(oSettings.nTable).children('tfoot').remove(); |
| oSettings.nTable.appendChild( oSettings.nTFoot ); |
| } |
| |
| /* Remove the DataTables generated nodes, events and classes */ |
| oSettings.nTable.parentNode.removeChild( oSettings.nTable ); |
| $(oSettings.nTableWrapper).remove(); |
| |
| oSettings.aaSorting = []; |
| oSettings.aaSortingFixed = []; |
| _fnSortingClasses( oSettings ); |
| |
| $(_fnGetTrNodes( oSettings )).removeClass( oSettings.asStripeClasses.join(' ') ); |
| |
| if ( !oSettings.bJUI ) |
| { |
| $('th', oSettings.nTHead).removeClass( [ _oExt.oStdClasses.sSortable, |
| _oExt.oStdClasses.sSortableAsc, |
| _oExt.oStdClasses.sSortableDesc, |
| _oExt.oStdClasses.sSortableNone ].join(' ') |
| ); |
| } |
| else |
| { |
| $('th', oSettings.nTHead).removeClass( [ _oExt.oStdClasses.sSortable, |
| _oExt.oJUIClasses.sSortableAsc, |
| _oExt.oJUIClasses.sSortableDesc, |
| _oExt.oJUIClasses.sSortableNone ].join(' ') |
| ); |
| $('th span.'+_oExt.oJUIClasses.sSortIcon, oSettings.nTHead).remove(); |
| |
| $('th', oSettings.nTHead).each( function () { |
| var jqWrapper = $('div.'+_oExt.oJUIClasses.sSortJUIWrapper, this); |
| var kids = jqWrapper.contents(); |
| $(this).append( kids ); |
| jqWrapper.remove(); |
| } ); |
| } |
| |
| /* Add the TR elements back into the table in their original order */ |
| if ( oSettings.nTableReinsertBefore ) |
| { |
| nOrig.insertBefore( oSettings.nTable, oSettings.nTableReinsertBefore ); |
| } |
| else |
| { |
| nOrig.appendChild( oSettings.nTable ); |
| } |
| |
| for ( i=0, iLen=oSettings.aoData.length ; i<iLen ; i++ ) |
| { |
| if ( oSettings.aoData[i].nTr !== null ) |
| { |
| nBody.appendChild( oSettings.aoData[i].nTr ); |
| } |
| } |
| |
| /* Restore the width of the original table */ |
| if ( oSettings.oFeatures.bAutoWidth === true ) |
| { |
| oSettings.nTable.style.width = _fnStringToCss(oSettings.sDestroyWidth); |
| } |
| |
| /* If the were originally odd/even type classes - then we add them back here. Note |
| * this is not fool proof (for example if not all rows as odd/even classes - but |
| * it's a good effort without getting carried away |
| */ |
| $(nBody).children('tr:even').addClass( oSettings.asDestroyStripes[0] ); |
| $(nBody).children('tr:odd').addClass( oSettings.asDestroyStripes[1] ); |
| |
| /* Remove the settings object from the settings array */ |
| for ( i=0, iLen=_aoSettings.length ; i<iLen ; i++ ) |
| { |
| if ( _aoSettings[i] == oSettings ) |
| { |
| _aoSettings.splice( i, 1 ); |
| } |
| } |
| |
| /* End it all */ |
| oSettings = null; |
| }; |
| |
| /* |
| * Function: fnAdjustColumnSizing |
| * Purpose: Update table sizing based on content. This would most likely be used for scrolling |
| * and will typically need a redraw after it. |
| * Returns: - |
| * Inputs: bool:bRedraw - redraw the table or not, you will typically want to - default true |
| */ |
| this.fnAdjustColumnSizing = function ( bRedraw ) |
| { |
| var oSettings = _fnSettingsFromNode(this[_oExt.iApiIndex]); |
| _fnAdjustColumnSizing( oSettings ); |
| |
| if ( typeof bRedraw == 'undefined' || bRedraw ) |
| { |
| this.fnDraw( false ); |
| } |
| else if ( oSettings.oScroll.sX !== "" || oSettings.oScroll.sY !== "" ) |
| { |
| /* If not redrawing, but scrolling, we want to apply the new column sizes anyway */ |
| this.oApi._fnScrollDraw(oSettings); |
| } |
| }; |
| |
| /* |
| * Plugin API functions |
| * |
| * This call will add the functions which are defined in _oExt.oApi to the |
| * DataTables object, providing a rather nice way to allow plug-in API functions. Note that |
| * this is done here, so that API function can actually override the built in API functions if |
| * required for a particular purpose. |
| */ |
| |
| /* |
| * Function: _fnExternApiFunc |
| * Purpose: Create a wrapper function for exporting an internal func to an external API func |
| * Returns: function: - wrapped function |
| * Inputs: string:sFunc - API function name |
| */ |
| function _fnExternApiFunc (sFunc) |
| { |
| return function() { |
| var aArgs = [_fnSettingsFromNode(this[_oExt.iApiIndex])].concat( |
| Array.prototype.slice.call(arguments) ); |
| return _oExt.oApi[sFunc].apply( this, aArgs ); |
| }; |
| } |
| |
| for ( var sFunc in _oExt.oApi ) |
| { |
| if ( sFunc ) |
| { |
| /* |
| * Function: anon |
| * Purpose: Wrap the plug-in API functions in order to provide the settings as 1st arg |
| * and execute in this scope |
| * Returns: - |
| * Inputs: - |
| */ |
| this[sFunc] = _fnExternApiFunc(sFunc); |
| } |
| } |
| |
| |
| |
| /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
| * Section - Local functions |
| * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ |
| |
| /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
| * Section - Initialisation |
| */ |
| |
| /* |
| * Function: _fnInitialise |
| * Purpose: Draw the table for the first time, adding all required features |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| */ |
| function _fnInitialise ( oSettings ) |
| { |
| var i, iLen, iAjaxStart=oSettings.iInitDisplayStart; |
| |
| /* Ensure that the table data is fully initialised */ |
| if ( oSettings.bInitialised === false ) |
| { |
| setTimeout( function(){ _fnInitialise( oSettings ); }, 200 ); |
| return; |
| } |
| |
| /* Show the display HTML options */ |
| _fnAddOptionsHtml( oSettings ); |
| |
| /* Build and draw the header / footer for the table */ |
| _fnBuildHead( oSettings ); |
| _fnDrawHead( oSettings, oSettings.aoHeader ); |
| if ( oSettings.nTFoot ) |
| { |
| _fnDrawHead( oSettings, oSettings.aoFooter ); |
| } |
| |
| /* Okay to show that something is going on now */ |
| _fnProcessingDisplay( oSettings, true ); |
| |
| /* Calculate sizes for columns */ |
| if ( oSettings.oFeatures.bAutoWidth ) |
| { |
| _fnCalculateColumnWidths( oSettings ); |
| } |
| |
| for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ ) |
| { |
| if ( oSettings.aoColumns[i].sWidth !== null ) |
| { |
| oSettings.aoColumns[i].nTh.style.width = _fnStringToCss( oSettings.aoColumns[i].sWidth ); |
| } |
| } |
| |
| /* If there is default sorting required - let's do it. The sort function will do the |
| * drawing for us. Otherwise we draw the table regardless of the Ajax source - this allows |
| * the table to look initialised for Ajax sourcing data (show 'loading' message possibly) |
| */ |
| if ( oSettings.oFeatures.bSort ) |
| { |
| _fnSort( oSettings ); |
| } |
| else if ( oSettings.oFeatures.bFilter ) |
| { |
| _fnFilterComplete( oSettings, oSettings.oPreviousSearch ); |
| } |
| else |
| { |
| oSettings.aiDisplay = oSettings.aiDisplayMaster.slice(); |
| _fnCalculateEnd( oSettings ); |
| _fnDraw( oSettings ); |
| } |
| |
| /* if there is an ajax source load the data */ |
| if ( oSettings.sAjaxSource !== null && !oSettings.oFeatures.bServerSide ) |
| { |
| var aoData = []; |
| _fnServerParams( oSettings, aoData ); |
| oSettings.fnServerData.call( oSettings.oInstance, oSettings.sAjaxSource, aoData, function(json) { |
| var aData = json; |
| if ( oSettings.sAjaxDataProp !== "" ) |
| { |
| var fnDataSrc = _fnGetObjectDataFn( oSettings.sAjaxDataProp ); |
| aData = fnDataSrc( json ); |
| } |
| |
| /* Got the data - add it to the table */ |
| for ( i=0 ; i<aData.length ; i++ ) |
| { |
| _fnAddData( oSettings, aData[i] ); |
| } |
| |
| /* Reset the init display for cookie saving. We've already done a filter, and |
| * therefore cleared it before. So we need to make it appear 'fresh' |
| */ |
| oSettings.iInitDisplayStart = iAjaxStart; |
| |
| if ( oSettings.oFeatures.bSort ) |
| { |
| _fnSort( oSettings ); |
| } |
| else |
| { |
| oSettings.aiDisplay = oSettings.aiDisplayMaster.slice(); |
| _fnCalculateEnd( oSettings ); |
| _fnDraw( oSettings ); |
| } |
| |
| _fnProcessingDisplay( oSettings, false ); |
| _fnInitComplete( oSettings, json ); |
| }, oSettings ); |
| return; |
| } |
| |
| /* Server-side processing initialisation complete is done at the end of _fnDraw */ |
| if ( !oSettings.oFeatures.bServerSide ) |
| { |
| _fnProcessingDisplay( oSettings, false ); |
| _fnInitComplete( oSettings ); |
| } |
| } |
| |
| /* |
| * Function: _fnInitComplete |
| * Purpose: Draw the table for the first time, adding all required features |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| */ |
| function _fnInitComplete ( oSettings, json ) |
| { |
| oSettings._bInitComplete = true; |
| if ( typeof oSettings.fnInitComplete == 'function' ) |
| { |
| if ( typeof json != 'undefined' ) |
| { |
| oSettings.fnInitComplete.call( oSettings.oInstance, oSettings, json ); |
| } |
| else |
| { |
| oSettings.fnInitComplete.call( oSettings.oInstance, oSettings ); |
| } |
| } |
| } |
| |
| /* |
| * Function: _fnLanguageProcess |
| * Purpose: Copy language variables from remote object to a local one |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| * object:oLanguage - Language information |
| * bool:bInit - init once complete |
| */ |
| function _fnLanguageProcess( oSettings, oLanguage, bInit ) |
| { |
| oSettings.oLanguage = $.extend( true, oSettings.oLanguage, oLanguage ); |
| |
| /* Backwards compatibility - if there is no sEmptyTable given, then use the same as |
| * sZeroRecords - assuming that is given. |
| */ |
| if ( typeof oLanguage.sEmptyTable == 'undefined' && |
| typeof oLanguage.sZeroRecords != 'undefined' ) |
| { |
| _fnMap( oSettings.oLanguage, oLanguage, 'sZeroRecords', 'sEmptyTable' ); |
| } |
| |
| /* Likewise with loading records */ |
| if ( typeof oLanguage.sLoadingRecords == 'undefined' && |
| typeof oLanguage.sZeroRecords != 'undefined' ) |
| { |
| _fnMap( oSettings.oLanguage, oLanguage, 'sZeroRecords', 'sLoadingRecords' ); |
| } |
| |
| if ( bInit ) |
| { |
| _fnInitialise( oSettings ); |
| } |
| } |
| |
| /* |
| * Function: _fnAddColumn |
| * Purpose: Add a column to the list used for the table with default values |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| * node:nTh - the th element for this column |
| */ |
| function _fnAddColumn( oSettings, nTh ) |
| { |
| var iCol = oSettings.aoColumns.length; |
| var oCol = { |
| "sType": null, |
| "_bAutoType": true, |
| "bVisible": true, |
| "bSearchable": true, |
| "bSortable": true, |
| "asSorting": [ 'asc', 'desc' ], |
| "sSortingClass": oSettings.oClasses.sSortable, |
| "sSortingClassJUI": oSettings.oClasses.sSortJUI, |
| "sTitle": nTh ? nTh.innerHTML : '', |
| "sName": '', |
| "sWidth": null, |
| "sWidthOrig": null, |
| "sClass": null, |
| "fnRender": null, |
| "bUseRendered": true, |
| "iDataSort": iCol, |
| "mDataProp": iCol, |
| "fnGetData": null, |
| "fnSetData": null, |
| "sSortDataType": 'std', |
| "sDefaultContent": null, |
| "sContentPadding": "", |
| "nTh": nTh ? nTh : document.createElement('th'), |
| "nTf": null |
| }; |
| oSettings.aoColumns.push( oCol ); |
| |
| /* Add a column specific filter */ |
| if ( typeof oSettings.aoPreSearchCols[ iCol ] == 'undefined' || |
| oSettings.aoPreSearchCols[ iCol ] === null ) |
| { |
| oSettings.aoPreSearchCols[ iCol ] = { |
| "sSearch": "", |
| "bRegex": false, |
| "bSmart": true |
| }; |
| } |
| else |
| { |
| /* Don't require that the user must specify bRegex and / or bSmart */ |
| if ( typeof oSettings.aoPreSearchCols[ iCol ].bRegex == 'undefined' ) |
| { |
| oSettings.aoPreSearchCols[ iCol ].bRegex = true; |
| } |
| |
| if ( typeof oSettings.aoPreSearchCols[ iCol ].bSmart == 'undefined' ) |
| { |
| oSettings.aoPreSearchCols[ iCol ].bSmart = true; |
| } |
| } |
| |
| /* Use the column options function to initialise classes etc */ |
| _fnColumnOptions( oSettings, iCol, null ); |
| } |
| |
| /* |
| * Function: _fnColumnOptions |
| * Purpose: Apply options for a column |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| * int:iCol - column index to consider |
| * object:oOptions - object with sType, bVisible and bSearchable |
| */ |
| function _fnColumnOptions( oSettings, iCol, oOptions ) |
| { |
| var oCol = oSettings.aoColumns[ iCol ]; |
| |
| /* User specified column options */ |
| if ( typeof oOptions != 'undefined' && oOptions !== null ) |
| { |
| if ( typeof oOptions.sType != 'undefined' ) |
| { |
| oCol.sType = oOptions.sType; |
| oCol._bAutoType = false; |
| } |
| |
| _fnMap( oCol, oOptions, "bVisible" ); |
| _fnMap( oCol, oOptions, "bSearchable" ); |
| _fnMap( oCol, oOptions, "bSortable" ); |
| _fnMap( oCol, oOptions, "sTitle" ); |
| _fnMap( oCol, oOptions, "sName" ); |
| _fnMap( oCol, oOptions, "sWidth" ); |
| _fnMap( oCol, oOptions, "sWidth", "sWidthOrig" ); |
| _fnMap( oCol, oOptions, "sClass" ); |
| _fnMap( oCol, oOptions, "fnRender" ); |
| _fnMap( oCol, oOptions, "bUseRendered" ); |
| _fnMap( oCol, oOptions, "iDataSort" ); |
| _fnMap( oCol, oOptions, "mDataProp" ); |
| _fnMap( oCol, oOptions, "asSorting" ); |
| _fnMap( oCol, oOptions, "sSortDataType" ); |
| _fnMap( oCol, oOptions, "sDefaultContent" ); |
| _fnMap( oCol, oOptions, "sContentPadding" ); |
| } |
| |
| /* Cache the data get and set functions for speed */ |
| oCol.fnGetData = _fnGetObjectDataFn( oCol.mDataProp ); |
| oCol.fnSetData = _fnSetObjectDataFn( oCol.mDataProp ); |
| |
| /* Feature sorting overrides column specific when off */ |
| if ( !oSettings.oFeatures.bSort ) |
| { |
| oCol.bSortable = false; |
| } |
| |
| /* Check that the class assignment is correct for sorting */ |
| if ( !oCol.bSortable || |
| ($.inArray('asc', oCol.asSorting) == -1 && $.inArray('desc', oCol.asSorting) == -1) ) |
| { |
| oCol.sSortingClass = oSettings.oClasses.sSortableNone; |
| oCol.sSortingClassJUI = ""; |
| } |
| else if ( oCol.bSortable || |
| ($.inArray('asc', oCol.asSorting) == -1 && $.inArray('desc', oCol.asSorting) == -1) ) |
| { |
| oCol.sSortingClass = oSettings.oClasses.sSortable; |
| oCol.sSortingClassJUI = oSettings.oClasses.sSortJUI; |
| } |
| else if ( $.inArray('asc', oCol.asSorting) != -1 && $.inArray('desc', oCol.asSorting) == -1 ) |
| { |
| oCol.sSortingClass = oSettings.oClasses.sSortableAsc; |
| oCol.sSortingClassJUI = oSettings.oClasses.sSortJUIAscAllowed; |
| } |
| else if ( $.inArray('asc', oCol.asSorting) == -1 && $.inArray('desc', oCol.asSorting) != -1 ) |
| { |
| oCol.sSortingClass = oSettings.oClasses.sSortableDesc; |
| oCol.sSortingClassJUI = oSettings.oClasses.sSortJUIDescAllowed; |
| } |
| } |
| |
| /* |
| * Function: _fnAddData |
| * Purpose: Add a data array to the table, creating DOM node etc |
| * Returns: int: - >=0 if successful (index of new aoData entry), -1 if failed |
| * Inputs: object:oSettings - dataTables settings object |
| * array:aData - data array to be added |
| * Notes: There are two basic methods for DataTables to get data to display - a JS array |
| * (which is dealt with by this function), and the DOM, which has it's own optimised |
| * function (_fnGatherData). Be careful to make the same changes here as there and vice-versa |
| */ |
| function _fnAddData ( oSettings, aDataSupplied ) |
| { |
| var oCol; |
| |
| /* Take an independent copy of the data source so we can bash it about as we wish */ |
| var aDataIn = ($.isArray(aDataSupplied)) ? |
| aDataSupplied.slice() : |
| $.extend( true, {}, aDataSupplied ); |
| |
| /* Create the object for storing information about this new row */ |
| var iRow = oSettings.aoData.length; |
| var oData = { |
| "nTr": null, |
| "_iId": oSettings.iNextId++, |
| "_aData": aDataIn, |
| "_anHidden": [], |
| "_sRowStripe": "" |
| }; |
| oSettings.aoData.push( oData ); |
| |
| /* Create the cells */ |
| var nTd, sThisType; |
| for ( var i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ ) |
| { |
| oCol = oSettings.aoColumns[i]; |
| |
| /* Use rendered data for filtering/sorting */ |
| if ( typeof oCol.fnRender == 'function' && oCol.bUseRendered && oCol.mDataProp !== null ) |
| { |
| _fnSetCellData( oSettings, iRow, i, oCol.fnRender( { |
| "iDataRow": iRow, |
| "iDataColumn": i, |
| "aData": oData._aData, |
| "oSettings": oSettings |
| } ) ); |
| } |
| |
| /* See if we should auto-detect the column type */ |
| if ( oCol._bAutoType && oCol.sType != 'string' ) |
| { |
| /* Attempt to auto detect the type - same as _fnGatherData() */ |
| var sVarType = _fnGetCellData( oSettings, iRow, i, 'type' ); |
| if ( sVarType !== null && sVarType !== '' ) |
| { |
| sThisType = _fnDetectType( sVarType ); |
| if ( oCol.sType === null ) |
| { |
| oCol.sType = sThisType; |
| } |
| else if ( oCol.sType != sThisType && oCol.sType != "html" ) |
| { |
| /* String is always the 'fallback' option */ |
| oCol.sType = 'string'; |
| } |
| } |
| } |
| } |
| |
| /* Add to the display array */ |
| oSettings.aiDisplayMaster.push( iRow ); |
| |
| /* Create the DOM imformation */ |
| if ( !oSettings.oFeatures.bDeferRender ) |
| { |
| _fnCreateTr( oSettings, iRow ); |
| } |
| |
| return iRow; |
| } |
| |
| /* |
| * Function: _fnCreateTr |
| * Purpose: Create a new TR element (and it's TD children) for a row |
| * Returns: void |
| * Inputs: object:oSettings - dataTables settings object |
| * int:iRow - Row to consider |
| */ |
| function _fnCreateTr ( oSettings, iRow ) |
| { |
| var oData = oSettings.aoData[iRow]; |
| var nTd; |
| |
| if ( oData.nTr === null ) |
| { |
| oData.nTr = document.createElement('tr'); |
| |
| /* Special parameters can be given by the data source to be used on the row */ |
| if ( typeof oData._aData.DT_RowId != 'undefined' ) |
| { |
| oData.nTr.setAttribute( 'id', oData._aData.DT_RowId ); |
| } |
| |
| if ( typeof oData._aData.DT_RowClass != 'undefined' ) |
| { |
| $(oData.nTr).addClass( oData._aData.DT_RowClass ); |
| } |
| |
| /* Process each column */ |
| for ( var i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ ) |
| { |
| var oCol = oSettings.aoColumns[i]; |
| nTd = document.createElement('td'); |
| |
| /* Render if needed - if bUseRendered is true then we already have the rendered |
| * value in the data source - so can just use that |
| */ |
| if ( typeof oCol.fnRender == 'function' && (!oCol.bUseRendered || oCol.mDataProp === null) ) |
| { |
| nTd.innerHTML = oCol.fnRender( { |
| "iDataRow": iRow, |
| "iDataColumn": i, |
| "aData": oData._aData, |
| "oSettings": oSettings |
| } ); |
| } |
| else |
| { |
| nTd.innerHTML = _fnGetCellData( oSettings, iRow, i, 'display' ); |
| } |
| |
| /* Add user defined class */ |
| if ( oCol.sClass !== null ) |
| { |
| nTd.className = oCol.sClass; |
| } |
| |
| if ( oCol.bVisible ) |
| { |
| oData.nTr.appendChild( nTd ); |
| oData._anHidden[i] = null; |
| } |
| else |
| { |
| oData._anHidden[i] = nTd; |
| } |
| } |
| } |
| } |
| |
| /* |
| * Function: _fnGatherData |
| * Purpose: Read in the data from the target table from the DOM |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| * Notes: This is a optimised version of _fnAddData (more or less) for reading information |
| * from the DOM. The basic actions must be identical in the two functions. |
| */ |
| function _fnGatherData( oSettings ) |
| { |
| var iLoop, i, iLen, j, jLen, jInner, |
| nTds, nTrs, nTd, aLocalData, iThisIndex, |
| iRow, iRows, iColumn, iColumns, sNodeName; |
| |
| /* |
| * Process by row first |
| * Add the data object for the whole table - storing the tr node. Note - no point in getting |
| * DOM based data if we are going to go and replace it with Ajax source data. |
| */ |
| if ( oSettings.bDeferLoading || oSettings.sAjaxSource === null ) |
| { |
| nTrs = oSettings.nTBody.childNodes; |
| for ( i=0, iLen=nTrs.length ; i<iLen ; i++ ) |
| { |
| if ( nTrs[i].nodeName.toUpperCase() == "TR" ) |
| { |
| iThisIndex = oSettings.aoData.length; |
| oSettings.aoData.push( { |
| "nTr": nTrs[i], |
| "_iId": oSettings.iNextId++, |
| "_aData": [], |
| "_anHidden": [], |
| "_sRowStripe": '' |
| } ); |
| |
| oSettings.aiDisplayMaster.push( iThisIndex ); |
| nTds = nTrs[i].childNodes; |
| jInner = 0; |
| |
| for ( j=0, jLen=nTds.length ; j<jLen ; j++ ) |
| { |
| sNodeName = nTds[j].nodeName.toUpperCase(); |
| if ( sNodeName == "TD" || sNodeName == "TH" ) |
| { |
| _fnSetCellData( oSettings, iThisIndex, jInner, $.trim(nTds[j].innerHTML) ); |
| jInner++; |
| } |
| } |
| } |
| } |
| } |
| |
| /* Gather in the TD elements of the Table - note that this is basically the same as |
| * fnGetTdNodes, but that function takes account of hidden columns, which we haven't yet |
| * setup! |
| */ |
| nTrs = _fnGetTrNodes( oSettings ); |
| nTds = []; |
| for ( i=0, iLen=nTrs.length ; i<iLen ; i++ ) |
| { |
| for ( j=0, jLen=nTrs[i].childNodes.length ; j<jLen ; j++ ) |
| { |
| nTd = nTrs[i].childNodes[j]; |
| sNodeName = nTd.nodeName.toUpperCase(); |
| if ( sNodeName == "TD" || sNodeName == "TH" ) |
| { |
| nTds.push( nTd ); |
| } |
| } |
| } |
| |
| /* Sanity check */ |
| if ( nTds.length != nTrs.length * oSettings.aoColumns.length ) |
| { |
| _fnLog( oSettings, 1, "Unexpected number of TD elements. Expected "+ |
| (nTrs.length * oSettings.aoColumns.length)+" and got "+nTds.length+". DataTables does "+ |
| "not support rowspan / colspan in the table body, and there must be one cell for each "+ |
| "row/column combination." ); |
| } |
| |
| /* Now process by column */ |
| for ( iColumn=0, iColumns=oSettings.aoColumns.length ; iColumn<iColumns ; iColumn++ ) |
| { |
| /* Get the title of the column - unless there is a user set one */ |
| if ( oSettings.aoColumns[iColumn].sTitle === null ) |
| { |
| oSettings.aoColumns[iColumn].sTitle = oSettings.aoColumns[iColumn].nTh.innerHTML; |
| } |
| |
| var |
| bAutoType = oSettings.aoColumns[iColumn]._bAutoType, |
| bRender = typeof oSettings.aoColumns[iColumn].fnRender == 'function', |
| bClass = oSettings.aoColumns[iColumn].sClass !== null, |
| bVisible = oSettings.aoColumns[iColumn].bVisible, |
| nCell, sThisType, sRendered, sValType; |
| |
| /* A single loop to rule them all (and be more efficient) */ |
| if ( bAutoType || bRender || bClass || !bVisible ) |
| { |
| for ( iRow=0, iRows=oSettings.aoData.length ; iRow<iRows ; iRow++ ) |
| { |
| nCell = nTds[ (iRow*iColumns) + iColumn ]; |
| |
| /* Type detection */ |
| if ( bAutoType && oSettings.aoColumns[iColumn].sType != 'string' ) |
| { |
| sValType = _fnGetCellData( oSettings, iRow, iColumn, 'type' ); |
| if ( sValType !== '' ) |
| { |
| sThisType = _fnDetectType( sValType ); |
| if ( oSettings.aoColumns[iColumn].sType === null ) |
| { |
| oSettings.aoColumns[iColumn].sType = sThisType; |
| } |
| else if ( oSettings.aoColumns[iColumn].sType != sThisType && |
| oSettings.aoColumns[iColumn].sType != "html" ) |
| { |
| /* String is always the 'fallback' option */ |
| oSettings.aoColumns[iColumn].sType = 'string'; |
| } |
| } |
| } |
| |
| /* Rendering */ |
| if ( bRender ) |
| { |
| sRendered = oSettings.aoColumns[iColumn].fnRender( { |
| "iDataRow": iRow, |
| "iDataColumn": iColumn, |
| "aData": oSettings.aoData[iRow]._aData, |
| "oSettings": oSettings |
| } ); |
| nCell.innerHTML = sRendered; |
| if ( oSettings.aoColumns[iColumn].bUseRendered ) |
| { |
| /* Use the rendered data for filtering/sorting */ |
| _fnSetCellData( oSettings, iRow, iColumn, sRendered ); |
| } |
| } |
| |
| /* Classes */ |
| if ( bClass ) |
| { |
| nCell.className += ' '+oSettings.aoColumns[iColumn].sClass; |
| } |
| |
| /* Column visability */ |
| if ( !bVisible ) |
| { |
| oSettings.aoData[iRow]._anHidden[iColumn] = nCell; |
| nCell.parentNode.removeChild( nCell ); |
| } |
| else |
| { |
| oSettings.aoData[iRow]._anHidden[iColumn] = null; |
| } |
| } |
| } |
| } |
| } |
| |
| /* |
| * Function: _fnBuildHead |
| * Purpose: Create the HTML header for the table |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| */ |
| function _fnBuildHead( oSettings ) |
| { |
| var i, nTh, iLen, j, jLen; |
| var anTr = oSettings.nTHead.getElementsByTagName('tr'); |
| var iThs = oSettings.nTHead.getElementsByTagName('th').length; |
| var iCorrector = 0; |
| var jqChildren; |
| |
| /* If there is a header in place - then use it - otherwise it's going to get nuked... */ |
| if ( iThs !== 0 ) |
| { |
| /* We've got a thead from the DOM, so remove hidden columns and apply width to vis cols */ |
| for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ ) |
| { |
| nTh = oSettings.aoColumns[i].nTh; |
| |
| if ( oSettings.aoColumns[i].sClass !== null ) |
| { |
| $(nTh).addClass( oSettings.aoColumns[i].sClass ); |
| } |
| |
| /* Set the title of the column if it is user defined (not what was auto detected) */ |
| if ( oSettings.aoColumns[i].sTitle != nTh.innerHTML ) |
| { |
| nTh.innerHTML = oSettings.aoColumns[i].sTitle; |
| } |
| } |
| } |
| else |
| { |
| /* We don't have a header in the DOM - so we are going to have to create one */ |
| var nTr = document.createElement( "tr" ); |
| |
| for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ ) |
| { |
| nTh = oSettings.aoColumns[i].nTh; |
| nTh.innerHTML = oSettings.aoColumns[i].sTitle; |
| |
| if ( oSettings.aoColumns[i].sClass !== null ) |
| { |
| $(nTh).addClass( oSettings.aoColumns[i].sClass ); |
| } |
| |
| nTr.appendChild( nTh ); |
| } |
| $(oSettings.nTHead).html( '' )[0].appendChild( nTr ); |
| _fnDetectHeader( oSettings.aoHeader, oSettings.nTHead ); |
| } |
| |
| /* Add the extra markup needed by jQuery UI's themes */ |
| if ( oSettings.bJUI ) |
| { |
| for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ ) |
| { |
| nTh = oSettings.aoColumns[i].nTh; |
| |
| var nDiv = document.createElement('div'); |
| nDiv.className = oSettings.oClasses.sSortJUIWrapper; |
| $(nTh).contents().appendTo(nDiv); |
| |
| var nSpan = document.createElement('span'); |
| nSpan.className = oSettings.oClasses.sSortIcon; |
| nDiv.appendChild( nSpan ); |
| nTh.appendChild( nDiv ); |
| } |
| } |
| |
| /* Add sort listener */ |
| var fnNoSelect = function (e) { |
| this.onselectstart = function() { return false; }; |
| return false; |
| }; |
| |
| if ( oSettings.oFeatures.bSort ) |
| { |
| for ( i=0 ; i<oSettings.aoColumns.length ; i++ ) |
| { |
| if ( oSettings.aoColumns[i].bSortable !== false ) |
| { |
| _fnSortAttachListener( oSettings, oSettings.aoColumns[i].nTh, i ); |
| |
| /* Take the brutal approach to cancelling text selection in header */ |
| $(oSettings.aoColumns[i].nTh).on( 'mousedown.DT', fnNoSelect ); |
| } |
| else |
| { |
| $(oSettings.aoColumns[i].nTh).addClass( oSettings.oClasses.sSortableNone ); |
| } |
| } |
| } |
| |
| /* Deal with the footer - add classes if required */ |
| if ( oSettings.oClasses.sFooterTH !== "" ) |
| { |
| $(oSettings.nTFoot).children('tr').children('th').addClass( oSettings.oClasses.sFooterTH ); |
| } |
| |
| /* Cache the footer elements */ |
| if ( oSettings.nTFoot !== null ) |
| { |
| var anCells = _fnGetUniqueThs( oSettings, null, oSettings.aoFooter ); |
| for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ ) |
| { |
| if ( typeof anCells[i] != 'undefined' ) |
| { |
| oSettings.aoColumns[i].nTf = anCells[i]; |
| } |
| } |
| } |
| } |
| |
| |
| /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
| * Section - Drawing functions |
| */ |
| |
| /* |
| * Function: _fnDrawHead |
| * Purpose: Draw the header (or footer) element based on the column visibility states. The |
| * methodology here is to use the layout array from _fnDetectHeader, modified for |
| * the instantaneous column visibility, to construct the new layout. The grid is |
| * traversed over cell at a time in a rows x columns grid fashion, although each |
| * cell insert can cover multiple elements in the grid - which is tracks using the |
| * aApplied array. Cell inserts in the grid will only occur where there isn't |
| * already a cell in that position. |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| * array objects:aoSource - Layout array from _fnDetectHeader |
| * boolean:bIncludeHidden - If true then include the hidden columns in the calc, |
| * - optional: default false |
| */ |
| function _fnDrawHead( oSettings, aoSource, bIncludeHidden ) |
| { |
| var i, iLen, j, jLen, k, kLen; |
| var aoLocal = []; |
| var aApplied = []; |
| var iColumns = oSettings.aoColumns.length; |
| var iRowspan, iColspan; |
| |
| if ( typeof bIncludeHidden == 'undefined' ) |
| { |
| bIncludeHidden = false; |
| } |
| |
| /* Make a copy of the master layout array, but without the visible columns in it */ |
| for ( i=0, iLen=aoSource.length ; i<iLen ; i++ ) |
| { |
| aoLocal[i] = aoSource[i].slice(); |
| aoLocal[i].nTr = aoSource[i].nTr; |
| |
| /* Remove any columns which are currently hidden */ |
| for ( j=iColumns-1 ; j>=0 ; j-- ) |
| { |
| if ( !oSettings.aoColumns[j].bVisible && !bIncludeHidden ) |
| { |
| aoLocal[i].splice( j, 1 ); |
| } |
| } |
| |
| /* Prep the applied array - it needs an element for each row */ |
| aApplied.push( [] ); |
| } |
| |
| for ( i=0, iLen=aoLocal.length ; i<iLen ; i++ ) |
| { |
| /* All cells are going to be replaced, so empty out the row */ |
| if ( aoLocal[i].nTr ) |
| { |
| for ( k=0, kLen=aoLocal[i].nTr.childNodes.length ; k<kLen ; k++ ) |
| { |
| aoLocal[i].nTr.removeChild( aoLocal[i].nTr.childNodes[0] ); |
| } |
| } |
| |
| for ( j=0, jLen=aoLocal[i].length ; j<jLen ; j++ ) |
| { |
| iRowspan = 1; |
| iColspan = 1; |
| |
| /* Check to see if there is already a cell (row/colspan) covering our target |
| * insert point. If there is, then there is nothing to do. |
| */ |
| if ( typeof aApplied[i][j] == 'undefined' ) |
| { |
| aoLocal[i].nTr.appendChild( aoLocal[i][j].cell ); |
| aApplied[i][j] = 1; |
| |
| /* Expand the cell to cover as many rows as needed */ |
| while ( typeof aoLocal[i+iRowspan] != 'undefined' && |
| aoLocal[i][j].cell == aoLocal[i+iRowspan][j].cell ) |
| { |
| aApplied[i+iRowspan][j] = 1; |
| iRowspan++; |
| } |
| |
| /* Expand the cell to cover as many columns as needed */ |
| while ( typeof aoLocal[i][j+iColspan] != 'undefined' && |
| aoLocal[i][j].cell == aoLocal[i][j+iColspan].cell ) |
| { |
| /* Must update the applied array over the rows for the columns */ |
| for ( k=0 ; k<iRowspan ; k++ ) |
| { |
| aApplied[i+k][j+iColspan] = 1; |
| } |
| iColspan++; |
| } |
| |
| /* Do the actual expansion in the DOM */ |
| aoLocal[i][j].cell.rowSpan = iRowspan; |
| aoLocal[i][j].cell.colSpan = iColspan; |
| } |
| } |
| } |
| } |
| |
| /* |
| * Function: _fnDraw |
| * Purpose: Insert the required TR nodes into the table for display |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| */ |
| function _fnDraw( oSettings ) |
| { |
| var i, iLen; |
| var anRows = []; |
| var iRowCount = 0; |
| var bRowError = false; |
| var iStripes = oSettings.asStripeClasses.length; |
| var iOpenRows = oSettings.aoOpenRows.length; |
| |
| /* Provide a pre-callback function which can be used to cancel the draw is false is returned */ |
| if ( oSettings.fnPreDrawCallback !== null && |
| oSettings.fnPreDrawCallback.call( oSettings.oInstance, oSettings ) === false ) |
| { |
| return; |
| } |
| |
| oSettings.bDrawing = true; |
| |
| /* Check and see if we have an initial draw position from state saving */ |
| if ( typeof oSettings.iInitDisplayStart != 'undefined' && oSettings.iInitDisplayStart != -1 ) |
| { |
| if ( oSettings.oFeatures.bServerSide ) |
| { |
| oSettings._iDisplayStart = oSettings.iInitDisplayStart; |
| } |
| else |
| { |
| oSettings._iDisplayStart = (oSettings.iInitDisplayStart >= oSettings.fnRecordsDisplay()) ? |
| 0 : oSettings.iInitDisplayStart; |
| } |
| oSettings.iInitDisplayStart = -1; |
| _fnCalculateEnd( oSettings ); |
| } |
| |
| /* Server-side processing draw intercept */ |
| if ( oSettings.bDeferLoading ) |
| { |
| oSettings.bDeferLoading = false; |
| oSettings.iDraw++; |
| } |
| else if ( !oSettings.oFeatures.bServerSide ) |
| { |
| oSettings.iDraw++; |
| } |
| else if ( !oSettings.bDestroying && !_fnAjaxUpdate( oSettings ) ) |
| { |
| return; |
| } |
| |
| if ( oSettings.aiDisplay.length !== 0 ) |
| { |
| var iStart = oSettings._iDisplayStart; |
| var iEnd = oSettings._iDisplayEnd; |
| |
| if ( oSettings.oFeatures.bServerSide ) |
| { |
| iStart = 0; |
| iEnd = oSettings.aoData.length; |
| } |
| |
| for ( var j=iStart ; j<iEnd ; j++ ) |
| { |
| var aoData = oSettings.aoData[ oSettings.aiDisplay[j] ]; |
| if ( aoData.nTr === null ) |
| { |
| _fnCreateTr( oSettings, oSettings.aiDisplay[j] ); |
| } |
| |
| var nRow = aoData.nTr; |
| |
| /* Remove the old striping classes and then add the new one */ |
| if ( iStripes !== 0 ) |
| { |
| var sStripe = oSettings.asStripeClasses[ iRowCount % iStripes ]; |
| if ( aoData._sRowStripe != sStripe ) |
| { |
| $(nRow).removeClass( aoData._sRowStripe ).addClass( sStripe ); |
| aoData._sRowStripe = sStripe; |
| } |
| } |
| |
| /* Custom row callback function - might want to manipule the row */ |
| if ( typeof oSettings.fnRowCallback == "function" ) |
| { |
| nRow = oSettings.fnRowCallback.call( oSettings.oInstance, nRow, |
| oSettings.aoData[ oSettings.aiDisplay[j] ]._aData, iRowCount, j ); |
| if ( !nRow && !bRowError ) |
| { |
| _fnLog( oSettings, 0, "A node was not returned by fnRowCallback" ); |
| bRowError = true; |
| } |
| } |
| |
| anRows.push( nRow ); |
| iRowCount++; |
| |
| /* If there is an open row - and it is attached to this parent - attach it on redraw */ |
| if ( iOpenRows !== 0 ) |
| { |
| for ( var k=0 ; k<iOpenRows ; k++ ) |
| { |
| if ( nRow == oSettings.aoOpenRows[k].nParent ) |
| { |
| anRows.push( oSettings.aoOpenRows[k].nTr ); |
| } |
| } |
| } |
| } |
| } |
| else |
| { |
| /* Table is empty - create a row with an empty message in it */ |
| anRows[ 0 ] = document.createElement( 'tr' ); |
| |
| if ( typeof oSettings.asStripeClasses[0] != 'undefined' ) |
| { |
| anRows[ 0 ].className = oSettings.asStripeClasses[0]; |
| } |
| |
| var sZero = oSettings.oLanguage.sZeroRecords.replace( |
| '_MAX_', oSettings.fnFormatNumber(oSettings.fnRecordsTotal()) ); |
| if ( oSettings.iDraw == 1 && oSettings.sAjaxSource !== null && !oSettings.oFeatures.bServerSide ) |
| { |
| sZero = oSettings.oLanguage.sLoadingRecords; |
| } |
| else if ( typeof oSettings.oLanguage.sEmptyTable != 'undefined' && |
| oSettings.fnRecordsTotal() === 0 ) |
| { |
| sZero = oSettings.oLanguage.sEmptyTable; |
| } |
| |
| var nTd = document.createElement( 'td' ); |
| nTd.setAttribute( 'valign', "top" ); |
| nTd.colSpan = _fnVisbleColumns( oSettings ); |
| nTd.className = oSettings.oClasses.sRowEmpty; |
| nTd.innerHTML = sZero; |
| |
| anRows[ iRowCount ].appendChild( nTd ); |
| } |
| |
| /* Callback the header and footer custom funcation if there is one */ |
| if ( typeof oSettings.fnHeaderCallback == 'function' ) |
| { |
| oSettings.fnHeaderCallback.call( oSettings.oInstance, $(oSettings.nTHead).children('tr')[0], |
| _fnGetDataMaster( oSettings ), oSettings._iDisplayStart, oSettings.fnDisplayEnd(), |
| oSettings.aiDisplay ); |
| } |
| |
| if ( typeof oSettings.fnFooterCallback == 'function' ) |
| { |
| oSettings.fnFooterCallback.call( oSettings.oInstance, $(oSettings.nTFoot).children('tr')[0], |
| _fnGetDataMaster( oSettings ), oSettings._iDisplayStart, oSettings.fnDisplayEnd(), |
| oSettings.aiDisplay ); |
| } |
| |
| /* |
| * Need to remove any old row from the display - note we can't just empty the tbody using |
| * $().html('') since this will unbind the jQuery event handlers (even although the node |
| * still exists!) - equally we can't use innerHTML, since IE throws an exception. |
| */ |
| var |
| nAddFrag = document.createDocumentFragment(), |
| nRemoveFrag = document.createDocumentFragment(), |
| nBodyPar, nTrs; |
| |
| if ( oSettings.nTBody ) |
| { |
| nBodyPar = oSettings.nTBody.parentNode; |
| nRemoveFrag.appendChild( oSettings.nTBody ); |
| |
| /* When doing infinite scrolling, only remove child rows when sorting, filtering or start |
| * up. When not infinite scroll, always do it. |
| */ |
| if ( !oSettings.oScroll.bInfinite || !oSettings._bInitComplete || |
| oSettings.bSorted || oSettings.bFiltered ) |
| { |
| nTrs = oSettings.nTBody.childNodes; |
| for ( i=nTrs.length-1 ; i>=0 ; i-- ) |
| { |
| nTrs[i].parentNode.removeChild( nTrs[i] ); |
| } |
| } |
| |
| /* Put the draw table into the dom */ |
| for ( i=0, iLen=anRows.length ; i<iLen ; i++ ) |
| { |
| nAddFrag.appendChild( anRows[i] ); |
| } |
| |
| oSettings.nTBody.appendChild( nAddFrag ); |
| if ( nBodyPar !== null ) |
| { |
| nBodyPar.appendChild( oSettings.nTBody ); |
| } |
| } |
| |
| /* Call all required callback functions for the end of a draw */ |
| for ( i=oSettings.aoDrawCallback.length-1 ; i>=0 ; i-- ) |
| { |
| oSettings.aoDrawCallback[i].fn.call( oSettings.oInstance, oSettings ); |
| } |
| $(oSettings.oInstance).trigger('draw', oSettings); |
| |
| /* Draw is complete, sorting and filtering must be as well */ |
| oSettings.bSorted = false; |
| oSettings.bFiltered = false; |
| oSettings.bDrawing = false; |
| |
| if ( oSettings.oFeatures.bServerSide ) |
| { |
| _fnProcessingDisplay( oSettings, false ); |
| if ( typeof oSettings._bInitComplete == 'undefined' ) |
| { |
| _fnInitComplete( oSettings ); |
| } |
| } |
| } |
| |
| /* |
| * Function: _fnReDraw |
| * Purpose: Redraw the table - taking account of the various features which are enabled |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| */ |
| function _fnReDraw( oSettings ) |
| { |
| if ( oSettings.oFeatures.bSort ) |
| { |
| /* Sorting will refilter and draw for us */ |
| _fnSort( oSettings, oSettings.oPreviousSearch ); |
| } |
| else if ( oSettings.oFeatures.bFilter ) |
| { |
| /* Filtering will redraw for us */ |
| _fnFilterComplete( oSettings, oSettings.oPreviousSearch ); |
| } |
| else |
| { |
| _fnCalculateEnd( oSettings ); |
| _fnDraw( oSettings ); |
| } |
| } |
| |
| /* |
| * Function: _fnAjaxUpdate |
| * Purpose: Update the table using an Ajax call |
| * Returns: bool: block the table drawing or not |
| * Inputs: object:oSettings - dataTables settings object |
| */ |
| function _fnAjaxUpdate( oSettings ) |
| { |
| if ( oSettings.bAjaxDataGet ) |
| { |
| oSettings.iDraw++; |
| _fnProcessingDisplay( oSettings, true ); |
| var iColumns = oSettings.aoColumns.length; |
| var aoData = _fnAjaxParameters( oSettings ); |
| _fnServerParams( oSettings, aoData ); |
| |
| oSettings.fnServerData.call( oSettings.oInstance, oSettings.sAjaxSource, aoData, |
| function(json) { |
| _fnAjaxUpdateDraw( oSettings, json ); |
| }, oSettings ); |
| return false; |
| } |
| else |
| { |
| return true; |
| } |
| } |
| |
| /* |
| * Function: _fnAjaxParameters |
| * Purpose: Build up the parameters in an object needed for a server-side processing request |
| * Returns: bool: block the table drawing or not |
| * Inputs: object:oSettings - dataTables settings object |
| */ |
| function _fnAjaxParameters( oSettings ) |
| { |
| var iColumns = oSettings.aoColumns.length; |
| var aoData = [], mDataProp; |
| var i; |
| |
| aoData.push( { "name": "sEcho", "value": oSettings.iDraw } ); |
| aoData.push( { "name": "iColumns", "value": iColumns } ); |
| aoData.push( { "name": "sColumns", "value": _fnColumnOrdering(oSettings) } ); |
| aoData.push( { "name": "iDisplayStart", "value": oSettings._iDisplayStart } ); |
| aoData.push( { "name": "iDisplayLength", "value": oSettings.oFeatures.bPaginate !== false ? |
| oSettings._iDisplayLength : -1 } ); |
| |
| for ( i=0 ; i<iColumns ; i++ ) |
| { |
| mDataProp = oSettings.aoColumns[i].mDataProp; |
| aoData.push( { "name": "mDataProp_"+i, "value": typeof(mDataProp)=="function" ? 'function' : mDataProp } ); |
| } |
| |
| /* Filtering */ |
| if ( oSettings.oFeatures.bFilter !== false ) |
| { |
| aoData.push( { "name": "sSearch", "value": oSettings.oPreviousSearch.sSearch } ); |
| aoData.push( { "name": "bRegex", "value": oSettings.oPreviousSearch.bRegex } ); |
| for ( i=0 ; i<iColumns ; i++ ) |
| { |
| aoData.push( { "name": "sSearch_"+i, "value": oSettings.aoPreSearchCols[i].sSearch } ); |
| aoData.push( { "name": "bRegex_"+i, "value": oSettings.aoPreSearchCols[i].bRegex } ); |
| aoData.push( { "name": "bSearchable_"+i, "value": oSettings.aoColumns[i].bSearchable } ); |
| } |
| } |
| |
| /* Sorting */ |
| if ( oSettings.oFeatures.bSort !== false ) |
| { |
| var iFixed = oSettings.aaSortingFixed !== null ? oSettings.aaSortingFixed.length : 0; |
| var iUser = oSettings.aaSorting.length; |
| aoData.push( { "name": "iSortingCols", "value": iFixed+iUser } ); |
| for ( i=0 ; i<iFixed ; i++ ) |
| { |
| aoData.push( { "name": "iSortCol_"+i, "value": oSettings.aaSortingFixed[i][0] } ); |
| aoData.push( { "name": "sSortDir_"+i, "value": oSettings.aaSortingFixed[i][1] } ); |
| } |
| |
| for ( i=0 ; i<iUser ; i++ ) |
| { |
| aoData.push( { "name": "iSortCol_"+(i+iFixed), "value": oSettings.aaSorting[i][0] } ); |
| aoData.push( { "name": "sSortDir_"+(i+iFixed), "value": oSettings.aaSorting[i][1] } ); |
| } |
| |
| for ( i=0 ; i<iColumns ; i++ ) |
| { |
| aoData.push( { "name": "bSortable_"+i, "value": oSettings.aoColumns[i].bSortable } ); |
| } |
| } |
| |
| return aoData; |
| } |
| |
| /* |
| * Function: _fnServerParams |
| * Purpose: Add Ajax parameters from plugins |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| * array objects:aoData - name/value pairs to send to the server |
| */ |
| function _fnServerParams( oSettings, aoData ) |
| { |
| for ( var i=0, iLen=oSettings.aoServerParams.length ; i<iLen ; i++ ) |
| { |
| oSettings.aoServerParams[i].fn.call( oSettings.oInstance, aoData ); |
| } |
| } |
| |
| /* |
| * Function: _fnAjaxUpdateDraw |
| * Purpose: Data the data from the server (nuking the old) and redraw the table |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| * object:json - json data return from the server. |
| * The following must be defined: |
| * iTotalRecords, iTotalDisplayRecords, aaData |
| * The following may be defined: |
| * sColumns |
| */ |
| function _fnAjaxUpdateDraw ( oSettings, json ) |
| { |
| if ( typeof json.sEcho != 'undefined' ) |
| { |
| /* Protect against old returns over-writing a new one. Possible when you get |
| * very fast interaction, and later queires are completed much faster |
| */ |
| if ( json.sEcho*1 < oSettings.iDraw ) |
| { |
| return; |
| } |
| else |
| { |
| oSettings.iDraw = json.sEcho * 1; |
| } |
| } |
| |
| if ( !oSettings.oScroll.bInfinite || |
| (oSettings.oScroll.bInfinite && (oSettings.bSorted || oSettings.bFiltered)) ) |
| { |
| _fnClearTable( oSettings ); |
| } |
| oSettings._iRecordsTotal = json.iTotalRecords; |
| oSettings._iRecordsDisplay = json.iTotalDisplayRecords; |
| |
| /* Determine if reordering is required */ |
| var sOrdering = _fnColumnOrdering(oSettings); |
| var bReOrder = (typeof json.sColumns != 'undefined' && sOrdering !== "" && json.sColumns != sOrdering ); |
| if ( bReOrder ) |
| { |
| var aiIndex = _fnReOrderIndex( oSettings, json.sColumns ); |
| } |
| |
| var fnDataSrc = _fnGetObjectDataFn( oSettings.sAjaxDataProp ); |
| var aData = fnDataSrc( json ); |
| |
| for ( var i=0, iLen=aData.length ; i<iLen ; i++ ) |
| { |
| if ( bReOrder ) |
| { |
| /* If we need to re-order, then create a new array with the correct order and add it */ |
| var aDataSorted = []; |
| for ( var j=0, jLen=oSettings.aoColumns.length ; j<jLen ; j++ ) |
| { |
| aDataSorted.push( aData[i][ aiIndex[j] ] ); |
| } |
| _fnAddData( oSettings, aDataSorted ); |
| } |
| else |
| { |
| /* No re-order required, sever got it "right" - just straight add */ |
| _fnAddData( oSettings, aData[i] ); |
| } |
| } |
| oSettings.aiDisplay = oSettings.aiDisplayMaster.slice(); |
| |
| oSettings.bAjaxDataGet = false; |
| _fnDraw( oSettings ); |
| oSettings.bAjaxDataGet = true; |
| _fnProcessingDisplay( oSettings, false ); |
| } |
| |
| |
| /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
| * Section - Options (features) HTML |
| */ |
| |
| /* |
| * Function: _fnAddOptionsHtml |
| * Purpose: Add the options to the page HTML for the table |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| */ |
| function _fnAddOptionsHtml ( oSettings ) |
| { |
| /* |
| * Create a temporary, empty, div which we can later on replace with what we have generated |
| * we do it this way to rendering the 'options' html offline - speed :-) |
| */ |
| var nHolding = document.createElement( 'div' ); |
| oSettings.nTable.parentNode.insertBefore( nHolding, oSettings.nTable ); |
| |
| /* |
| * All DataTables are wrapped in a div |
| */ |
| oSettings.nTableWrapper = document.createElement( 'div' ); |
| oSettings.nTableWrapper.className = oSettings.oClasses.sWrapper; |
| if ( oSettings.sTableId !== '' ) |
| { |
| oSettings.nTableWrapper.setAttribute( 'id', oSettings.sTableId+'_wrapper' ); |
| } |
| |
| oSettings.nTableReinsertBefore = oSettings.nTable.nextSibling; |
| |
| /* Track where we want to insert the option */ |
| var nInsertNode = oSettings.nTableWrapper; |
| |
| /* Loop over the user set positioning and place the elements as needed */ |
| var aDom = oSettings.sDom.split(''); |
| var nTmp, iPushFeature, cOption, nNewNode, cNext, sAttr, j; |
| for ( var i=0 ; i<aDom.length ; i++ ) |
| { |
| iPushFeature = 0; |
| cOption = aDom[i]; |
| |
| if ( cOption == '<' ) |
| { |
| /* New container div */ |
| nNewNode = document.createElement( 'div' ); |
| |
| /* Check to see if we should append an id and/or a class name to the container */ |
| cNext = aDom[i+1]; |
| if ( cNext == "'" || cNext == '"' ) |
| { |
| sAttr = ""; |
| j = 2; |
| while ( aDom[i+j] != cNext ) |
| { |
| sAttr += aDom[i+j]; |
| j++; |
| } |
| |
| /* Replace jQuery UI constants */ |
| if ( sAttr == "H" ) |
| { |
| sAttr = "fg-toolbar ui-toolbar ui-widget-header ui-corner-tl ui-corner-tr ui-helper-clearfix"; |
| } |
| else if ( sAttr == "F" ) |
| { |
| sAttr = "fg-toolbar ui-toolbar ui-widget-header ui-corner-bl ui-corner-br ui-helper-clearfix"; |
| } |
| |
| /* The attribute can be in the format of "#id.class", "#id" or "class" This logic |
| * breaks the string into parts and applies them as needed |
| */ |
| if ( sAttr.indexOf('.') != -1 ) |
| { |
| var aSplit = sAttr.split('.'); |
| nNewNode.setAttribute('id', aSplit[0].substr(1, aSplit[0].length-1) ); |
| nNewNode.className = aSplit[1]; |
| } |
| else if ( sAttr.charAt(0) == "#" ) |
| { |
| nNewNode.setAttribute('id', sAttr.substr(1, sAttr.length-1) ); |
| } |
| else |
| { |
| nNewNode.className = sAttr; |
| } |
| |
| i += j; /* Move along the position array */ |
| } |
| |
| nInsertNode.appendChild( nNewNode ); |
| nInsertNode = nNewNode; |
| } |
| else if ( cOption == '>' ) |
| { |
| /* End container div */ |
| nInsertNode = nInsertNode.parentNode; |
| } |
| else if ( cOption == 'l' && oSettings.oFeatures.bPaginate && oSettings.oFeatures.bLengthChange ) |
| { |
| /* Length */ |
| nTmp = _fnFeatureHtmlLength( oSettings ); |
| iPushFeature = 1; |
| } |
| else if ( cOption == 'f' && oSettings.oFeatures.bFilter ) |
| { |
| /* Filter */ |
| nTmp = _fnFeatureHtmlFilter( oSettings ); |
| iPushFeature = 1; |
| } |
| else if ( cOption == 'r' && oSettings.oFeatures.bProcessing ) |
| { |
| /* pRocessing */ |
| nTmp = _fnFeatureHtmlProcessing( oSettings ); |
| iPushFeature = 1; |
| } |
| else if ( cOption == 't' ) |
| { |
| /* Table */ |
| nTmp = _fnFeatureHtmlTable( oSettings ); |
| iPushFeature = 1; |
| } |
| else if ( cOption == 'i' && oSettings.oFeatures.bInfo ) |
| { |
| /* Info */ |
| nTmp = _fnFeatureHtmlInfo( oSettings ); |
| iPushFeature = 1; |
| } |
| else if ( cOption == 'p' && oSettings.oFeatures.bPaginate ) |
| { |
| /* Pagination */ |
| nTmp = _fnFeatureHtmlPaginate( oSettings ); |
| iPushFeature = 1; |
| } |
| else if ( _oExt.aoFeatures.length !== 0 ) |
| { |
| /* Plug-in features */ |
| var aoFeatures = _oExt.aoFeatures; |
| for ( var k=0, kLen=aoFeatures.length ; k<kLen ; k++ ) |
| { |
| if ( cOption == aoFeatures[k].cFeature ) |
| { |
| nTmp = aoFeatures[k].fnInit( oSettings ); |
| if ( nTmp ) |
| { |
| iPushFeature = 1; |
| } |
| break; |
| } |
| } |
| } |
| |
| /* Add to the 2D features array */ |
| if ( iPushFeature == 1 && nTmp !== null ) |
| { |
| if ( typeof oSettings.aanFeatures[cOption] != 'object' ) |
| { |
| oSettings.aanFeatures[cOption] = []; |
| } |
| oSettings.aanFeatures[cOption].push( nTmp ); |
| nInsertNode.appendChild( nTmp ); |
| } |
| } |
| |
| /* Built our DOM structure - replace the holding div with what we want */ |
| nHolding.parentNode.replaceChild( oSettings.nTableWrapper, nHolding ); |
| } |
| |
| |
| /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
| * Section - Feature: Filtering |
| */ |
| |
| /* |
| * Function: _fnFeatureHtmlTable |
| * Purpose: Add any control elements for the table - specifically scrolling |
| * Returns: node: - Node to add to the DOM |
| * Inputs: object:oSettings - dataTables settings object |
| */ |
| function _fnFeatureHtmlTable ( oSettings ) |
| { |
| /* Chack if scrolling is enabled or not - if not then leave the DOM unaltered */ |
| if ( oSettings.oScroll.sX === "" && oSettings.oScroll.sY === "" ) |
| { |
| return oSettings.nTable; |
| } |
| |
| /* |
| * The HTML structure that we want to generate in this function is: |
| * div - nScroller |
| * div - nScrollHead |
| * div - nScrollHeadInner |
| * table - nScrollHeadTable |
| * thead - nThead |
| * div - nScrollBody |
| * table - oSettings.nTable |
| * thead - nTheadSize |
| * tbody - nTbody |
| * div - nScrollFoot |
| * div - nScrollFootInner |
| * table - nScrollFootTable |
| * tfoot - nTfoot |
| */ |
| var |
| nScroller = document.createElement('div'), |
| nScrollHead = document.createElement('div'), |
| nScrollHeadInner = document.createElement('div'), |
| nScrollBody = document.createElement('div'), |
| nScrollFoot = document.createElement('div'), |
| nScrollFootInner = document.createElement('div'), |
| nScrollHeadTable = oSettings.nTable.cloneNode(false), |
| nScrollFootTable = oSettings.nTable.cloneNode(false), |
| nThead = oSettings.nTable.getElementsByTagName('thead')[0], |
| nTfoot = oSettings.nTable.getElementsByTagName('tfoot').length === 0 ? null : |
| oSettings.nTable.getElementsByTagName('tfoot')[0], |
| oClasses = (typeof oInit.bJQueryUI != 'undefined' && oInit.bJQueryUI) ? |
| _oExt.oJUIClasses : _oExt.oStdClasses; |
| |
| nScrollHead.appendChild( nScrollHeadInner ); |
| nScrollFoot.appendChild( nScrollFootInner ); |
| nScrollBody.appendChild( oSettings.nTable ); |
| nScroller.appendChild( nScrollHead ); |
| nScroller.appendChild( nScrollBody ); |
| nScrollHeadInner.appendChild( nScrollHeadTable ); |
| nScrollHeadTable.appendChild( nThead ); |
| if ( nTfoot !== null ) |
| { |
| nScroller.appendChild( nScrollFoot ); |
| nScrollFootInner.appendChild( nScrollFootTable ); |
| nScrollFootTable.appendChild( nTfoot ); |
| } |
| |
| nScroller.className = oClasses.sScrollWrapper; |
| nScrollHead.className = oClasses.sScrollHead; |
| nScrollHeadInner.className = oClasses.sScrollHeadInner; |
| nScrollBody.className = oClasses.sScrollBody; |
| nScrollFoot.className = oClasses.sScrollFoot; |
| nScrollFootInner.className = oClasses.sScrollFootInner; |
| |
| if ( oSettings.oScroll.bAutoCss ) |
| { |
| nScrollHead.style.overflow = "hidden"; |
| nScrollHead.style.position = "relative"; |
| nScrollFoot.style.overflow = "hidden"; |
| nScrollBody.style.overflow = "auto"; |
| } |
| |
| nScrollHead.style.border = "0"; |
| nScrollHead.style.width = "100%"; |
| nScrollFoot.style.border = "0"; |
| nScrollHeadInner.style.width = "150%"; /* will be overwritten */ |
| |
| /* Modify attributes to respect the clones */ |
| nScrollHeadTable.removeAttribute('id'); |
| nScrollHeadTable.style.marginLeft = "0"; |
| oSettings.nTable.style.marginLeft = "0"; |
| if ( nTfoot !== null ) |
| { |
| nScrollFootTable.removeAttribute('id'); |
| nScrollFootTable.style.marginLeft = "0"; |
| } |
| |
| /* Move any caption elements from the body to the header */ |
| var nCaptions = $(oSettings.nTable).children('caption'); |
| for ( var i=0, iLen=nCaptions.length ; i<iLen ; i++ ) |
| { |
| nScrollHeadTable.appendChild( nCaptions[i] ); |
| } |
| |
| /* |
| * Sizing |
| */ |
| /* When xscrolling add the width and a scroller to move the header with the body */ |
| if ( oSettings.oScroll.sX !== "" ) |
| { |
| nScrollHead.style.width = _fnStringToCss( oSettings.oScroll.sX ); |
| nScrollBody.style.width = _fnStringToCss( oSettings.oScroll.sX ); |
| |
| if ( nTfoot !== null ) |
| { |
| nScrollFoot.style.width = _fnStringToCss( oSettings.oScroll.sX ); |
| } |
| |
| /* When the body is scrolled, then we also want to scroll the headers */ |
| $(nScrollBody).scroll( function (e) { |
| nScrollHead.scrollLeft = this.scrollLeft; |
| |
| if ( nTfoot !== null ) |
| { |
| nScrollFoot.scrollLeft = this.scrollLeft; |
| } |
| } ); |
| } |
| |
| /* When yscrolling, add the height */ |
| if ( oSettings.oScroll.sY !== "" ) |
| { |
| nScrollBody.style.height = _fnStringToCss( oSettings.oScroll.sY ); |
| } |
| |
| /* Redraw - align columns across the tables */ |
| oSettings.aoDrawCallback.push( { |
| "fn": _fnScrollDraw, |
| "sName": "scrolling" |
| } ); |
| |
| /* Infinite scrolling event handlers */ |
| if ( oSettings.oScroll.bInfinite ) |
| { |
| $(nScrollBody).scroll( function() { |
| /* Use a blocker to stop scrolling from loading more data while other data is still loading */ |
| if ( !oSettings.bDrawing ) |
| { |
| /* Check if we should load the next data set */ |
| if ( $(this).scrollTop() + $(this).height() > |
| $(oSettings.nTable).height() - oSettings.oScroll.iLoadGap ) |
| { |
| /* Only do the redraw if we have to - we might be at the end of the data */ |
| if ( oSettings.fnDisplayEnd() < oSettings.fnRecordsDisplay() ) |
| { |
| _fnPageChange( oSettings, 'next' ); |
| _fnCalculateEnd( oSettings ); |
| _fnDraw( oSettings ); |
| } |
| } |
| } |
| } ); |
| } |
| |
| oSettings.nScrollHead = nScrollHead; |
| oSettings.nScrollFoot = nScrollFoot; |
| |
| return nScroller; |
| } |
| |
| /* |
| * Function: _fnScrollDraw |
| * Purpose: Update the various tables for resizing |
| * Returns: node: - Node to add to the DOM |
| * Inputs: object:o - dataTables settings object |
| * Notes: It's a bit of a pig this function, but basically the idea to: |
| * 1. Re-create the table inside the scrolling div |
| * 2. Take live measurements from the DOM |
| * 3. Apply the measurements |
| * 4. Clean up |
| */ |
| function _fnScrollDraw ( o ) |
| { |
| var |
| nScrollHeadInner = o.nScrollHead.getElementsByTagName('div')[0], |
| nScrollHeadTable = nScrollHeadInner.getElementsByTagName('table')[0], |
| nScrollBody = o.nTable.parentNode, |
| i, iLen, j, jLen, anHeadToSize, anHeadSizers, anFootSizers, anFootToSize, oStyle, iVis, |
| iWidth, aApplied=[], iSanityWidth, |
| nScrollFootInner = (o.nTFoot !== null) ? o.nScrollFoot.getElementsByTagName('div')[0] : null, |
| nScrollFootTable = (o.nTFoot !== null) ? nScrollFootInner.getElementsByTagName('table')[0] : null, |
| ie67 = (navigator.userAgent.match(/MSIE ([2-7]\.)/) !== null); |
| |
| /* |
| * 1. Re-create the table inside the scrolling div |
| */ |
| |
| /* Remove the old minimised thead and tfoot elements in the inner table */ |
| var nTheadSize = o.nTable.getElementsByTagName('thead'); |
| if ( nTheadSize.length > 0 ) |
| { |
| o.nTable.removeChild( nTheadSize[0] ); |
| } |
| |
| if ( o.nTFoot !== null ) |
| { |
| /* Remove the old minimised footer element in the cloned header */ |
| var nTfootSize = o.nTable.getElementsByTagName('tfoot'); |
| if ( nTfootSize.length > 0 ) |
| { |
| o.nTable.removeChild( nTfootSize[0] ); |
| } |
| } |
| |
| /* Clone the current header and footer elements and then place it into the inner table */ |
| nTheadSize = o.nTHead.cloneNode(true); |
| o.nTable.insertBefore( nTheadSize, o.nTable.childNodes[0] ); |
| |
| if ( o.nTFoot !== null ) |
| { |
| nTfootSize = o.nTFoot.cloneNode(true); |
| o.nTable.insertBefore( nTfootSize, o.nTable.childNodes[1] ); |
| } |
| |
| /* |
| * 2. Take live measurements from the DOM - do not alter the DOM itself! |
| */ |
| |
| /* Remove old sizing and apply the calculated column widths |
| * Get the unique column headers in the newly created (cloned) header. We want to apply the |
| * calclated sizes to this header |
| */ |
| if ( o.oScroll.sX === "" ) |
| { |
| nScrollBody.style.width = '100%'; |
| nScrollHeadInner.parentNode.style.width = '100%'; |
| } |
| |
| var nThs = _fnGetUniqueThs( o, nTheadSize ); |
| for ( i=0, iLen=nThs.length ; i<iLen ; i++ ) |
| { |
| iVis = _fnVisibleToColumnIndex( o, i ); |
| nThs[i].style.width = o.aoColumns[iVis].sWidth; |
| } |
| |
| if ( o.nTFoot !== null ) |
| { |
| _fnApplyToChildren( function(n) { |
| n.style.width = ""; |
| }, nTfootSize.getElementsByTagName('tr') ); |
| } |
| |
| /* Size the table as a whole */ |
| iSanityWidth = $(o.nTable).outerWidth(); |
| if ( o.oScroll.sX === "" ) |
| { |
| /* No x scrolling */ |
| o.nTable.style.width = "100%"; |
| |
| /* I know this is rubbish - but IE7 will make the width of the table when 100% include |
| * the scrollbar - which is shouldn't. When there is a scrollbar we need to take this |
| * into account. |
| */ |
| if ( ie67 && (nScrollBody.scrollHeight > |
| nScrollBody.offsetHeight || $(nScrollBody).css('overflow-y') == "scroll") ) |
| { |
| o.nTable.style.width = _fnStringToCss( $(o.nTable).outerWidth()-o.oScroll.iBarWidth ); |
| } |
| } |
| else |
| { |
| if ( o.oScroll.sXInner !== "" ) |
| { |
| /* x scroll inner has been given - use it */ |
| o.nTable.style.width = _fnStringToCss(o.oScroll.sXInner); |
| } |
| else if ( iSanityWidth == $(nScrollBody).width() && |
| $(nScrollBody).height() < $(o.nTable).height() ) |
| { |
| /* There is y-scrolling - try to take account of the y scroll bar */ |
| o.nTable.style.width = _fnStringToCss( iSanityWidth-o.oScroll.iBarWidth ); |
| if ( $(o.nTable).outerWidth() > iSanityWidth-o.oScroll.iBarWidth ) |
| { |
| /* Not possible to take account of it */ |
| o.nTable.style.width = _fnStringToCss( iSanityWidth ); |
| } |
| } |
| else |
| { |
| /* All else fails */ |
| o.nTable.style.width = _fnStringToCss( iSanityWidth ); |
| } |
| } |
| |
| /* Recalculate the sanity width - now that we've applied the required width, before it was |
| * a temporary variable. This is required because the column width calculation is done |
| * before this table DOM is created. |
| */ |
| iSanityWidth = $(o.nTable).outerWidth(); |
| |
| /* We want the hidden header to have zero height, so remove padding and borders. Then |
| * set the width based on the real headers |
| */ |
| anHeadToSize = o.nTHead.getElementsByTagName('tr'); |
| anHeadSizers = nTheadSize.getElementsByTagName('tr'); |
| |
| _fnApplyToChildren( function(nSizer, nToSize) { |
| oStyle = nSizer.style; |
| oStyle.paddingTop = "0"; |
| oStyle.paddingBottom = "0"; |
| oStyle.borderTopWidth = "0"; |
| oStyle.borderBottomWidth = "0"; |
| oStyle.height = 0; |
| |
| iWidth = $(nSizer).width(); |
| nToSize.style.width = _fnStringToCss( iWidth ); |
| aApplied.push( iWidth ); |
| }, anHeadSizers, anHeadToSize ); |
| $(anHeadSizers).height(0); |
| |
| if ( o.nTFoot !== null ) |
| { |
| /* Clone the current footer and then place it into the body table as a "hidden header" */ |
| anFootSizers = nTfootSize.getElementsByTagName('tr'); |
| anFootToSize = o.nTFoot.getElementsByTagName('tr'); |
| |
| _fnApplyToChildren( function(nSizer, nToSize) { |
| oStyle = nSizer.style; |
| oStyle.paddingTop = "0"; |
| oStyle.paddingBottom = "0"; |
| oStyle.borderTopWidth = "0"; |
| oStyle.borderBottomWidth = "0"; |
| oStyle.height = 0; |
| |
| iWidth = $(nSizer).width(); |
| nToSize.style.width = _fnStringToCss( iWidth ); |
| aApplied.push( iWidth ); |
| }, anFootSizers, anFootToSize ); |
| $(anFootSizers).height(0); |
| } |
| |
| /* |
| * 3. Apply the measurements |
| */ |
| |
| /* "Hide" the header and footer that we used for the sizing. We want to also fix their width |
| * to what they currently are |
| */ |
| _fnApplyToChildren( function(nSizer) { |
| nSizer.innerHTML = ""; |
| nSizer.style.width = _fnStringToCss( aApplied.shift() ); |
| }, anHeadSizers ); |
| |
| if ( o.nTFoot !== null ) |
| { |
| _fnApplyToChildren( function(nSizer) { |
| nSizer.innerHTML = ""; |
| nSizer.style.width = _fnStringToCss( aApplied.shift() ); |
| }, anFootSizers ); |
| } |
| |
| /* Sanity check that the table is of a sensible width. If not then we are going to get |
| * misalignment - try to prevent this by not allowing the table to shrink below its min width |
| */ |
| if ( $(o.nTable).outerWidth() < iSanityWidth ) |
| { |
| /* The min width depends upon if we have a vertical scrollbar visible or not */ |
| var iCorrection = ((nScrollBody.scrollHeight > nScrollBody.offsetHeight || |
| $(nScrollBody).css('overflow-y') == "scroll")) ? |
| iSanityWidth+o.oScroll.iBarWidth : iSanityWidth; |
| |
| /* IE6/7 are a law unto themselves... */ |
| if ( ie67 && (nScrollBody.scrollHeight > |
| nScrollBody.offsetHeight || $(nScrollBody).css('overflow-y') == "scroll") ) |
| { |
| o.nTable.style.width = _fnStringToCss( iCorrection-o.oScroll.iBarWidth ); |
| } |
| |
| /* Apply the calculated minimum width to the table wrappers */ |
| nScrollBody.style.width = _fnStringToCss( iCorrection ); |
| nScrollHeadInner.parentNode.style.width = _fnStringToCss( iCorrection ); |
| |
| if ( o.nTFoot !== null ) |
| { |
| nScrollFootInner.parentNode.style.width = _fnStringToCss( iCorrection ); |
| } |
| |
| /* And give the user a warning that we've stopped the table getting too small */ |
| if ( o.oScroll.sX === "" ) |
| { |
| _fnLog( o, 1, "The table cannot fit into the current element which will cause column"+ |
| " misalignment. The table has been drawn at its minimum possible width." ); |
| } |
| else if ( o.oScroll.sXInner !== "" ) |
| { |
| _fnLog( o, 1, "The table cannot fit into the current element which will cause column"+ |
| " misalignment. Increase the sScrollXInner value or remove it to allow automatic"+ |
| " calculation" ); |
| } |
| } |
| else |
| { |
| nScrollBody.style.width = _fnStringToCss( '100%' ); |
| nScrollHeadInner.parentNode.style.width = _fnStringToCss( '100%' ); |
| |
| if ( o.nTFoot !== null ) |
| { |
| nScrollFootInner.parentNode.style.width = _fnStringToCss( '100%' ); |
| } |
| } |
| |
| |
| /* |
| * 4. Clean up |
| */ |
| |
| if ( o.oScroll.sY === "" ) |
| { |
| /* IE7< puts a vertical scrollbar in place (when it shouldn't be) due to subtracting |
| * the scrollbar height from the visible display, rather than adding it on. We need to |
| * set the height in order to sort this. Don't want to do it in any other browsers. |
| */ |
| if ( ie67 ) |
| { |
| nScrollBody.style.height = _fnStringToCss( o.nTable.offsetHeight+o.oScroll.iBarWidth ); |
| } |
| } |
| |
| if ( o.oScroll.sY !== "" && o.oScroll.bCollapse ) |
| { |
| nScrollBody.style.height = _fnStringToCss( o.oScroll.sY ); |
| |
| var iExtra = (o.oScroll.sX !== "" && o.nTable.offsetWidth > nScrollBody.offsetWidth) ? |
| o.oScroll.iBarWidth : 0; |
| if ( o.nTable.offsetHeight < nScrollBody.offsetHeight ) |
| { |
| nScrollBody.style.height = _fnStringToCss( $(o.nTable).height()+iExtra ); |
| } |
| } |
| |
| /* Finally set the width's of the header and footer tables */ |
| var iOuterWidth = $(o.nTable).outerWidth(); |
| nScrollHeadTable.style.width = _fnStringToCss( iOuterWidth ); |
| nScrollHeadInner.style.width = _fnStringToCss( iOuterWidth+o.oScroll.iBarWidth ); |
| |
| if ( o.nTFoot !== null ) |
| { |
| nScrollFootInner.style.width = _fnStringToCss( o.nTable.offsetWidth+o.oScroll.iBarWidth ); |
| nScrollFootTable.style.width = _fnStringToCss( o.nTable.offsetWidth ); |
| } |
| |
| /* If sorting or filtering has occured, jump the scrolling back to the top */ |
| if ( o.bSorted || o.bFiltered ) |
| { |
| nScrollBody.scrollTop = 0; |
| } |
| } |
| |
| /* |
| * Function: _fnAdjustColumnSizing |
| * Purpose: Adjust the table column widths for new data |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| * Notes: You would probably want to do a redraw after calling this function! |
| */ |
| function _fnAdjustColumnSizing ( oSettings ) |
| { |
| /* Not interested in doing column width calculation if autowidth is disabled */ |
| if ( oSettings.oFeatures.bAutoWidth === false ) |
| { |
| return false; |
| } |
| |
| _fnCalculateColumnWidths( oSettings ); |
| for ( var i=0 , iLen=oSettings.aoColumns.length ; i<iLen ; i++ ) |
| { |
| oSettings.aoColumns[i].nTh.style.width = oSettings.aoColumns[i].sWidth; |
| } |
| } |
| |
| |
| /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
| * Section - Feature: Filtering |
| */ |
| |
| /* |
| * Function: _fnFeatureHtmlFilter |
| * Purpose: Generate the node required for filtering text |
| * Returns: node |
| * Inputs: object:oSettings - dataTables settings object |
| */ |
| function _fnFeatureHtmlFilter ( oSettings ) |
| { |
| var sSearchStr = oSettings.oLanguage.sSearch; |
| sSearchStr = (sSearchStr.indexOf('_INPUT_') !== -1) ? |
| sSearchStr.replace('_INPUT_', '<input type="text" />') : |
| sSearchStr==="" ? '<input type="text" />' : sSearchStr+' <input type="text" />'; |
| |
| var nFilter = document.createElement( 'div' ); |
| nFilter.className = oSettings.oClasses.sFilter; |
| nFilter.innerHTML = '<label>'+sSearchStr+'</label>'; |
| if ( oSettings.sTableId !== '' && typeof oSettings.aanFeatures.f == "undefined" ) |
| { |
| nFilter.setAttribute( 'id', oSettings.sTableId+'_filter' ); |
| } |
| |
| var jqFilter = $("input", nFilter); |
| jqFilter.val( oSettings.oPreviousSearch.sSearch.replace('"','"') ); |
| jqFilter.on( 'keyup.DT', function(e) { |
| /* Update all other filter input elements for the new display */ |
| var n = oSettings.aanFeatures.f; |
| for ( var i=0, iLen=n.length ; i<iLen ; i++ ) |
| { |
| if ( n[i] != $(this).parents('div.dataTables_filter')[0] ) |
| { |
| $('input', n[i]).val( this.value ); |
| } |
| } |
| |
| /* Now do the filter */ |
| if ( this.value != oSettings.oPreviousSearch.sSearch ) |
| { |
| _fnFilterComplete( oSettings, { |
| "sSearch": this.value, |
| "bRegex": oSettings.oPreviousSearch.bRegex, |
| "bSmart": oSettings.oPreviousSearch.bSmart |
| } ); |
| } |
| } ); |
| |
| jqFilter.on( 'keypress.DT', function(e) { |
| /* Prevent default */ |
| if ( e.keyCode == 13 ) |
| { |
| return false; |
| } |
| } ); |
| |
| return nFilter; |
| } |
| |
| /* |
| * Function: _fnFilterComplete |
| * Purpose: Filter the table using both the global filter and column based filtering |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| * object:oSearch: search information |
| * int:iForce - optional - force a research of the master array (1) or not (undefined or 0) |
| */ |
| function _fnFilterComplete ( oSettings, oInput, iForce ) |
| { |
| /* Filter on everything */ |
| _fnFilter( oSettings, oInput.sSearch, iForce, oInput.bRegex, oInput.bSmart ); |
| |
| /* Now do the individual column filter */ |
| for ( var i=0 ; i<oSettings.aoPreSearchCols.length ; i++ ) |
| { |
| _fnFilterColumn( oSettings, oSettings.aoPreSearchCols[i].sSearch, i, |
| oSettings.aoPreSearchCols[i].bRegex, oSettings.aoPreSearchCols[i].bSmart ); |
| } |
| |
| /* Custom filtering */ |
| if ( _oExt.afnFiltering.length !== 0 ) |
| { |
| _fnFilterCustom( oSettings ); |
| } |
| |
| /* Tell the draw function we have been filtering */ |
| oSettings.bFiltered = true; |
| $(oSettings.oInstance).trigger('filter', oSettings); |
| |
| /* Redraw the table */ |
| oSettings._iDisplayStart = 0; |
| _fnCalculateEnd( oSettings ); |
| _fnDraw( oSettings ); |
| |
| /* Rebuild search array 'offline' */ |
| _fnBuildSearchArray( oSettings, 0 ); |
| } |
| |
| /* |
| * Function: _fnFilterCustom |
| * Purpose: Apply custom filtering functions |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| */ |
| function _fnFilterCustom( oSettings ) |
| { |
| var afnFilters = _oExt.afnFiltering; |
| for ( var i=0, iLen=afnFilters.length ; i<iLen ; i++ ) |
| { |
| var iCorrector = 0; |
| for ( var j=0, jLen=oSettings.aiDisplay.length ; j<jLen ; j++ ) |
| { |
| var iDisIndex = oSettings.aiDisplay[j-iCorrector]; |
| |
| /* Check if we should use this row based on the filtering function */ |
| if ( !afnFilters[i]( oSettings, _fnGetRowData( oSettings, iDisIndex, 'filter' ), iDisIndex ) ) |
| { |
| oSettings.aiDisplay.splice( j-iCorrector, 1 ); |
| iCorrector++; |
| } |
| } |
| } |
| } |
| |
| /* |
| * Function: _fnFilterColumn |
| * Purpose: Filter the table on a per-column basis |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| * string:sInput - string to filter on |
| * int:iColumn - column to filter |
| * bool:bRegex - treat search string as a regular expression or not |
| * bool:bSmart - use smart filtering or not |
| */ |
| function _fnFilterColumn ( oSettings, sInput, iColumn, bRegex, bSmart ) |
| { |
| if ( sInput === "" ) |
| { |
| return; |
| } |
| |
| var iIndexCorrector = 0; |
| var rpSearch = _fnFilterCreateSearch( sInput, bRegex, bSmart ); |
| |
| for ( var i=oSettings.aiDisplay.length-1 ; i>=0 ; i-- ) |
| { |
| var sData = _fnDataToSearch( _fnGetCellData( oSettings, oSettings.aiDisplay[i], iColumn, 'filter' ), |
| oSettings.aoColumns[iColumn].sType ); |
| if ( ! rpSearch.test( sData ) ) |
| { |
| oSettings.aiDisplay.splice( i, 1 ); |
| iIndexCorrector++; |
| } |
| } |
| } |
| |
| /* |
| * Function: _fnFilter |
| * Purpose: Filter the data table based on user input and draw the table |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| * string:sInput - string to filter on |
| * int:iForce - optional - force a research of the master array (1) or not (undefined or 0) |
| * bool:bRegex - treat as a regular expression or not |
| * bool:bSmart - perform smart filtering or not |
| */ |
| function _fnFilter( oSettings, sInput, iForce, bRegex, bSmart ) |
| { |
| var i; |
| var rpSearch = _fnFilterCreateSearch( sInput, bRegex, bSmart ); |
| |
| /* Check if we are forcing or not - optional parameter */ |
| if ( typeof iForce == 'undefined' || iForce === null ) |
| { |
| iForce = 0; |
| } |
| |
| /* Need to take account of custom filtering functions - always filter */ |
| if ( _oExt.afnFiltering.length !== 0 ) |
| { |
| iForce = 1; |
| } |
| |
| /* |
| * If the input is blank - we want the full data set |
| */ |
| if ( sInput.length <= 0 ) |
| { |
| oSettings.aiDisplay.splice( 0, oSettings.aiDisplay.length); |
| oSettings.aiDisplay = oSettings.aiDisplayMaster.slice(); |
| } |
| else |
| { |
| /* |
| * We are starting a new search or the new search string is smaller |
| * then the old one (i.e. delete). Search from the master array |
| */ |
| if ( oSettings.aiDisplay.length == oSettings.aiDisplayMaster.length || |
| oSettings.oPreviousSearch.sSearch.length > sInput.length || iForce == 1 || |
| sInput.indexOf(oSettings.oPreviousSearch.sSearch) !== 0 ) |
| { |
| /* Nuke the old display array - we are going to rebuild it */ |
| oSettings.aiDisplay.splice( 0, oSettings.aiDisplay.length); |
| |
| /* Force a rebuild of the search array */ |
| _fnBuildSearchArray( oSettings, 1 ); |
| |
| /* Search through all records to populate the search array |
| * The the oSettings.aiDisplayMaster and asDataSearch arrays have 1 to 1 |
| * mapping |
| */ |
| for ( i=0 ; i<oSettings.aiDisplayMaster.length ; i++ ) |
| { |
| if ( rpSearch.test(oSettings.asDataSearch[i]) ) |
| { |
| oSettings.aiDisplay.push( oSettings.aiDisplayMaster[i] ); |
| } |
| } |
| } |
| else |
| { |
| /* Using old search array - refine it - do it this way for speed |
| * Don't have to search the whole master array again |
| */ |
| var iIndexCorrector = 0; |
| |
| /* Search the current results */ |
| for ( i=0 ; i<oSettings.asDataSearch.length ; i++ ) |
| { |
| if ( ! rpSearch.test(oSettings.asDataSearch[i]) ) |
| { |
| oSettings.aiDisplay.splice( i-iIndexCorrector, 1 ); |
| iIndexCorrector++; |
| } |
| } |
| } |
| } |
| oSettings.oPreviousSearch.sSearch = sInput; |
| oSettings.oPreviousSearch.bRegex = bRegex; |
| oSettings.oPreviousSearch.bSmart = bSmart; |
| } |
| |
| /* |
| * Function: _fnBuildSearchArray |
| * Purpose: Create an array which can be quickly search through |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| * int:iMaster - use the master data array - optional |
| */ |
| function _fnBuildSearchArray ( oSettings, iMaster ) |
| { |
| if ( !oSettings.oFeatures.bServerSide ) |
| { |
| /* Clear out the old data */ |
| oSettings.asDataSearch.splice( 0, oSettings.asDataSearch.length ); |
| |
| var aArray = (typeof iMaster != 'undefined' && iMaster == 1) ? |
| oSettings.aiDisplayMaster : oSettings.aiDisplay; |
| |
| for ( var i=0, iLen=aArray.length ; i<iLen ; i++ ) |
| { |
| oSettings.asDataSearch[i] = _fnBuildSearchRow( oSettings, |
| _fnGetRowData( oSettings, aArray[i], 'filter' ) ); |
| } |
| } |
| } |
| |
| /* |
| * Function: _fnBuildSearchRow |
| * Purpose: Create a searchable string from a single data row |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| * array:aData - Row data array to use for the data to search |
| */ |
| function _fnBuildSearchRow( oSettings, aData ) |
| { |
| var sSearch = ''; |
| if ( typeof oSettings.__nTmpFilter == 'undefined' ) { |
| oSettings.__nTmpFilter = document.createElement('div'); |
| } |
| var nTmp = oSettings.__nTmpFilter; |
| |
| for ( var j=0, jLen=oSettings.aoColumns.length ; j<jLen ; j++ ) |
| { |
| if ( oSettings.aoColumns[j].bSearchable ) |
| { |
| var sData = aData[j]; |
| sSearch += _fnDataToSearch( sData, oSettings.aoColumns[j].sType )+' '; |
| } |
| } |
| |
| /* If it looks like there is an HTML entity in the string, attempt to decode it */ |
| if ( sSearch.indexOf('&') !== -1 ) |
| { |
| nTmp.innerHTML = sSearch; |
| sSearch = nTmp.textContent ? nTmp.textContent : nTmp.innerText; |
| |
| /* IE and Opera appear to put an newline where there is a <br> tag - remove it */ |
| sSearch = sSearch.replace(/\n/g," ").replace(/\r/g,""); |
| } |
| |
| return sSearch; |
| } |
| |
| /* |
| * Function: _fnFilterCreateSearch |
| * Purpose: Build a regular expression object suitable for searching a table |
| * Returns: RegExp: - constructed object |
| * Inputs: string:sSearch - string to search for |
| * bool:bRegex - treat as a regular expression or not |
| * bool:bSmart - perform smart filtering or not |
| */ |
| function _fnFilterCreateSearch( sSearch, bRegex, bSmart ) |
| { |
| var asSearch, sRegExpString; |
| |
| if ( bSmart ) |
| { |
| /* Generate the regular expression to use. Something along the lines of: |
| * ^(?=.*?\bone\b)(?=.*?\btwo\b)(?=.*?\bthree\b).*$ |
| */ |
| asSearch = bRegex ? sSearch.split( ' ' ) : _fnEscapeRegex( sSearch ).split( ' ' ); |
| sRegExpString = '^(?=.*?'+asSearch.join( ')(?=.*?' )+').*$'; |
| return new RegExp( sRegExpString, "i" ); |
| } |
| else |
| { |
| sSearch = bRegex ? sSearch : _fnEscapeRegex( sSearch ); |
| return new RegExp( sSearch, "i" ); |
| } |
| } |
| |
| /* |
| * Function: _fnDataToSearch |
| * Purpose: Convert raw data into something that the user can search on |
| * Returns: string: - search string |
| * Inputs: string:sData - data to be modified |
| * string:sType - data type |
| */ |
| function _fnDataToSearch ( sData, sType ) |
| { |
| if ( typeof _oExt.ofnSearch[sType] == "function" ) |
| { |
| return _oExt.ofnSearch[sType]( sData ); |
| } |
| else if ( sType == "html" ) |
| { |
| return sData.replace(/\n/g," ").replace( /<.*?>/g, "" ); |
| } |
| else if ( typeof sData == "string" ) |
| { |
| return sData.replace(/\n/g," "); |
| } |
| else if ( sData === null ) |
| { |
| return ''; |
| } |
| return sData; |
| } |
| |
| |
| /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
| * Section - Feature: Sorting |
| */ |
| |
| /* |
| * Function: _fnSort |
| * Purpose: Change the order of the table |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| * bool:bApplyClasses - optional - should we apply classes or not |
| * Notes: We always sort the master array and then apply a filter again |
| * if it is needed. This probably isn't optimal - but atm I can't think |
| * of any other way which is (each has disadvantages). we want to sort aiDisplayMaster - |
| * but according to aoData[]._aData |
| */ |
| function _fnSort ( oSettings, bApplyClasses ) |
| { |
| var |
| iDataSort, iDataType, |
| i, iLen, j, jLen, |
| aaSort = [], |
| aiOrig = [], |
| oSort = _oExt.oSort, |
| aoData = oSettings.aoData, |
| aoColumns = oSettings.aoColumns; |
| |
| /* No sorting required if server-side or no sorting array */ |
| if ( !oSettings.oFeatures.bServerSide && |
| (oSettings.aaSorting.length !== 0 || oSettings.aaSortingFixed !== null) ) |
| { |
| if ( oSettings.aaSortingFixed !== null ) |
| { |
| aaSort = oSettings.aaSortingFixed.concat( oSettings.aaSorting ); |
| } |
| else |
| { |
| aaSort = oSettings.aaSorting.slice(); |
| } |
| |
| /* If there is a sorting data type, and a fuction belonging to it, then we need to |
| * get the data from the developer's function and apply it for this column |
| */ |
| for ( i=0 ; i<aaSort.length ; i++ ) |
| { |
| var iColumn = aaSort[i][0]; |
| var iVisColumn = _fnColumnIndexToVisible( oSettings, iColumn ); |
| var sDataType = oSettings.aoColumns[ iColumn ].sSortDataType; |
| if ( typeof _oExt.afnSortData[sDataType] != 'undefined' ) |
| { |
| var aData = _oExt.afnSortData[sDataType]( oSettings, iColumn, iVisColumn ); |
| for ( j=0, jLen=aoData.length ; j<jLen ; j++ ) |
| { |
| _fnSetCellData( oSettings, j, iColumn, aData[j] ); |
| } |
| } |
| } |
| |
| /* Create a value - key array of the current row positions such that we can use their |
| * current position during the sort, if values match, in order to perform stable sorting |
| */ |
| for ( i=0, iLen=oSettings.aiDisplayMaster.length ; i<iLen ; i++ ) |
| { |
| aiOrig[ oSettings.aiDisplayMaster[i] ] = i; |
| } |
| |
| /* Do the sort - here we want multi-column sorting based on a given data source (column) |
| * and sorting function (from oSort) in a certain direction. It's reasonably complex to |
| * follow on it's own, but this is what we want (example two column sorting): |
| * fnLocalSorting = function(a,b){ |
| * var iTest; |
| * iTest = oSort['string-asc']('data11', 'data12'); |
| * if (iTest !== 0) |
| * return iTest; |
| * iTest = oSort['numeric-desc']('data21', 'data22'); |
| * if (iTest !== 0) |
| * return iTest; |
| * return oSort['numeric-asc']( aiOrig[a], aiOrig[b] ); |
| * } |
| * Basically we have a test for each sorting column, if the data in that column is equal, |
| * test the next column. If all columns match, then we use a numeric sort on the row |
| * positions in the original data array to provide a stable sort. |
| */ |
| var iSortLen = aaSort.length; |
| oSettings.aiDisplayMaster.sort( function ( a, b ) { |
| var iTest, iDataSort, sDataType; |
| for ( i=0 ; i<iSortLen ; i++ ) |
| { |
| iDataSort = aoColumns[ aaSort[i][0] ].iDataSort; |
| sDataType = aoColumns[ iDataSort ].sType; |
| iTest = oSort[ (sDataType?sDataType:'string')+"-"+aaSort[i][1] ]( |
| _fnGetCellData( oSettings, a, iDataSort, 'sort' ), |
| _fnGetCellData( oSettings, b, iDataSort, 'sort' ) |
| ); |
| |
| if ( iTest !== 0 ) |
| { |
| return iTest; |
| } |
| } |
| |
| return oSort['numeric-asc']( aiOrig[a], aiOrig[b] ); |
| } ); |
| } |
| |
| /* Alter the sorting classes to take account of the changes */ |
| if ( (typeof bApplyClasses == 'undefined' || bApplyClasses) && !oSettings.oFeatures.bDeferRender ) |
| { |
| _fnSortingClasses( oSettings ); |
| } |
| |
| /* Tell the draw function that we have sorted the data */ |
| oSettings.bSorted = true; |
| $(oSettings.oInstance).trigger('sort', oSettings); |
| |
| /* Copy the master data into the draw array and re-draw */ |
| if ( oSettings.oFeatures.bFilter ) |
| { |
| /* _fnFilter() will redraw the table for us */ |
| _fnFilterComplete( oSettings, oSettings.oPreviousSearch, 1 ); |
| } |
| else |
| { |
| oSettings.aiDisplay = oSettings.aiDisplayMaster.slice(); |
| oSettings._iDisplayStart = 0; /* reset display back to page 0 */ |
| _fnCalculateEnd( oSettings ); |
| _fnDraw( oSettings ); |
| } |
| } |
| |
| /* |
| * Function: _fnSortAttachListener |
| * Purpose: Attach a sort handler (click) to a node |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| * node:nNode - node to attach the handler to |
| * int:iDataIndex - column sorting index |
| * function:fnCallback - callback function - optional |
| */ |
| function _fnSortAttachListener ( oSettings, nNode, iDataIndex, fnCallback ) |
| { |
| $(nNode).on( 'click.DT', function (e) { |
| /* If the column is not sortable - don't to anything */ |
| if ( oSettings.aoColumns[iDataIndex].bSortable === false ) |
| { |
| return; |
| } |
| |
| /* |
| * This is a little bit odd I admit... I declare a temporary function inside the scope of |
| * _fnBuildHead and the click handler in order that the code presented here can be used |
| * twice - once for when bProcessing is enabled, and another time for when it is |
| * disabled, as we need to perform slightly different actions. |
| * Basically the issue here is that the Javascript engine in modern browsers don't |
| * appear to allow the rendering engine to update the display while it is still excuting |
| * it's thread (well - it does but only after long intervals). This means that the |
| * 'processing' display doesn't appear for a table sort. To break the js thread up a bit |
| * I force an execution break by using setTimeout - but this breaks the expected |
| * thread continuation for the end-developer's point of view (their code would execute |
| * too early), so we on;y do it when we absolutely have to. |
| */ |
| var fnInnerSorting = function () { |
| var iColumn, iNextSort; |
| |
| /* If the shift key is pressed then we are multipe column sorting */ |
| if ( e.shiftKey ) |
| { |
| /* Are we already doing some kind of sort on this column? */ |
| var bFound = false; |
| for ( var i=0 ; i<oSettings.aaSorting.length ; i++ ) |
| { |
| if ( oSettings.aaSorting[i][0] == iDataIndex ) |
| { |
| bFound = true; |
| iColumn = oSettings.aaSorting[i][0]; |
| iNextSort = oSettings.aaSorting[i][2]+1; |
| |
| if ( typeof oSettings.aoColumns[iColumn].asSorting[iNextSort] == 'undefined' ) |
| { |
| /* Reached the end of the sorting options, remove from multi-col sort */ |
| oSettings.aaSorting.splice( i, 1 ); |
| } |
| else |
| { |
| /* Move onto next sorting direction */ |
| oSettings.aaSorting[i][1] = oSettings.aoColumns[iColumn].asSorting[iNextSort]; |
| oSettings.aaSorting[i][2] = iNextSort; |
| } |
| break; |
| } |
| } |
| |
| /* No sort yet - add it in */ |
| if ( bFound === false ) |
| { |
| oSettings.aaSorting.push( [ iDataIndex, |
| oSettings.aoColumns[iDataIndex].asSorting[0], 0 ] ); |
| } |
| } |
| else |
| { |
| /* If no shift key then single column sort */ |
| if ( oSettings.aaSorting.length == 1 && oSettings.aaSorting[0][0] == iDataIndex ) |
| { |
| iColumn = oSettings.aaSorting[0][0]; |
| iNextSort = oSettings.aaSorting[0][2]+1; |
| if ( typeof oSettings.aoColumns[iColumn].asSorting[iNextSort] == 'undefined' ) |
| { |
| iNextSort = 0; |
| } |
| oSettings.aaSorting[0][1] = oSettings.aoColumns[iColumn].asSorting[iNextSort]; |
| oSettings.aaSorting[0][2] = iNextSort; |
| } |
| else |
| { |
| oSettings.aaSorting.splice( 0, oSettings.aaSorting.length ); |
| oSettings.aaSorting.push( [ iDataIndex, |
| oSettings.aoColumns[iDataIndex].asSorting[0], 0 ] ); |
| } |
| } |
| |
| /* Run the sort */ |
| _fnSort( oSettings ); |
| }; /* /fnInnerSorting */ |
| |
| if ( !oSettings.oFeatures.bProcessing ) |
| { |
| fnInnerSorting(); |
| } |
| else |
| { |
| _fnProcessingDisplay( oSettings, true ); |
| setTimeout( function() { |
| fnInnerSorting(); |
| if ( !oSettings.oFeatures.bServerSide ) |
| { |
| _fnProcessingDisplay( oSettings, false ); |
| } |
| }, 0 ); |
| } |
| |
| /* Call the user specified callback function - used for async user interaction */ |
| if ( typeof fnCallback == 'function' ) |
| { |
| fnCallback( oSettings ); |
| } |
| } ); |
| } |
| |
| /* |
| * Function: _fnSortingClasses |
| * Purpose: Set the sortting classes on the header |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| * Notes: It is safe to call this function when bSort and bSortClasses are false |
| */ |
| function _fnSortingClasses( oSettings ) |
| { |
| var i, iLen, j, jLen, iFound; |
| var aaSort, sClass; |
| var iColumns = oSettings.aoColumns.length; |
| var oClasses = oSettings.oClasses; |
| |
| for ( i=0 ; i<iColumns ; i++ ) |
| { |
| if ( oSettings.aoColumns[i].bSortable ) |
| { |
| $(oSettings.aoColumns[i].nTh).removeClass( oClasses.sSortAsc +" "+ oClasses.sSortDesc + |
| " "+ oSettings.aoColumns[i].sSortingClass ); |
| } |
| } |
| |
| if ( oSettings.aaSortingFixed !== null ) |
| { |
| aaSort = oSettings.aaSortingFixed.concat( oSettings.aaSorting ); |
| } |
| else |
| { |
| aaSort = oSettings.aaSorting.slice(); |
| } |
| |
| /* Apply the required classes to the header */ |
| for ( i=0 ; i<oSettings.aoColumns.length ; i++ ) |
| { |
| if ( oSettings.aoColumns[i].bSortable ) |
| { |
| sClass = oSettings.aoColumns[i].sSortingClass; |
| iFound = -1; |
| for ( j=0 ; j<aaSort.length ; j++ ) |
| { |
| if ( aaSort[j][0] == i ) |
| { |
| sClass = ( aaSort[j][1] == "asc" ) ? |
| oClasses.sSortAsc : oClasses.sSortDesc; |
| iFound = j; |
| break; |
| } |
| } |
| $(oSettings.aoColumns[i].nTh).addClass( sClass ); |
| |
| if ( oSettings.bJUI ) |
| { |
| /* jQuery UI uses extra markup */ |
| var jqSpan = $("span", oSettings.aoColumns[i].nTh); |
| jqSpan.removeClass(oClasses.sSortJUIAsc +" "+ oClasses.sSortJUIDesc +" "+ |
| oClasses.sSortJUI +" "+ oClasses.sSortJUIAscAllowed +" "+ oClasses.sSortJUIDescAllowed ); |
| |
| var sSpanClass; |
| if ( iFound == -1 ) |
| { |
| sSpanClass = oSettings.aoColumns[i].sSortingClassJUI; |
| } |
| else if ( aaSort[iFound][1] == "asc" ) |
| { |
| sSpanClass = oClasses.sSortJUIAsc; |
| } |
| else |
| { |
| sSpanClass = oClasses.sSortJUIDesc; |
| } |
| |
| jqSpan.addClass( sSpanClass ); |
| } |
| } |
| else |
| { |
| /* No sorting on this column, so add the base class. This will have been assigned by |
| * _fnAddColumn |
| */ |
| $(oSettings.aoColumns[i].nTh).addClass( oSettings.aoColumns[i].sSortingClass ); |
| } |
| } |
| |
| /* |
| * Apply the required classes to the table body |
| * Note that this is given as a feature switch since it can significantly slow down a sort |
| * on large data sets (adding and removing of classes is always slow at the best of times..) |
| * Further to this, note that this code is admitadly fairly ugly. It could be made a lot |
| * simpiler using jQuery selectors and add/removeClass, but that is significantly slower |
| * (on the order of 5 times slower) - hence the direct DOM manipulation here. |
| * Note that for defered drawing we do use jQuery - the reason being that taking the first |
| * row found to see if the whole column needs processed can miss classes since the first |
| * column might be new. |
| */ |
| sClass = oClasses.sSortColumn; |
| |
| if ( oSettings.oFeatures.bSort && oSettings.oFeatures.bSortClasses ) |
| { |
| var nTds = _fnGetTdNodes( oSettings ); |
| |
| /* Remove the old classes */ |
| if ( oSettings.oFeatures.bDeferRender ) |
| { |
| $(nTds).removeClass(sClass+'1 '+sClass+'2 '+sClass+'3'); |
| } |
| else if ( nTds.length >= iColumns ) |
| { |
| for ( i=0 ; i<iColumns ; i++ ) |
| { |
| if ( nTds[i].className.indexOf(sClass+"1") != -1 ) |
| { |
| for ( j=0, jLen=(nTds.length/iColumns) ; j<jLen ; j++ ) |
| { |
| nTds[(iColumns*j)+i].className = |
| $.trim( nTds[(iColumns*j)+i].className.replace( sClass+"1", "" ) ); |
| } |
| } |
| else if ( nTds[i].className.indexOf(sClass+"2") != -1 ) |
| { |
| for ( j=0, jLen=(nTds.length/iColumns) ; j<jLen ; j++ ) |
| { |
| nTds[(iColumns*j)+i].className = |
| $.trim( nTds[(iColumns*j)+i].className.replace( sClass+"2", "" ) ); |
| } |
| } |
| else if ( nTds[i].className.indexOf(sClass+"3") != -1 ) |
| { |
| for ( j=0, jLen=(nTds.length/iColumns) ; j<jLen ; j++ ) |
| { |
| nTds[(iColumns*j)+i].className = |
| $.trim( nTds[(iColumns*j)+i].className.replace( " "+sClass+"3", "" ) ); |
| } |
| } |
| } |
| } |
| |
| /* Add the new classes to the table */ |
| var iClass = 1, iTargetCol; |
| for ( i=0 ; i<aaSort.length ; i++ ) |
| { |
| iTargetCol = parseInt( aaSort[i][0], 10 ); |
| for ( j=0, jLen=(nTds.length/iColumns) ; j<jLen ; j++ ) |
| { |
| nTds[(iColumns*j)+iTargetCol].className += " "+sClass+iClass; |
| } |
| |
| if ( iClass < 3 ) |
| { |
| iClass++; |
| } |
| } |
| } |
| } |
| |
| |
| /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
| * Section - Feature: Pagination. Note that most of the paging logic is done in |
| * _oExt.oPagination |
| */ |
| |
| /* |
| * Function: _fnFeatureHtmlPaginate |
| * Purpose: Generate the node required for default pagination |
| * Returns: node |
| * Inputs: object:oSettings - dataTables settings object |
| */ |
| function _fnFeatureHtmlPaginate ( oSettings ) |
| { |
| if ( oSettings.oScroll.bInfinite ) |
| { |
| return null; |
| } |
| |
| var nPaginate = document.createElement( 'div' ); |
| nPaginate.className = oSettings.oClasses.sPaging+oSettings.sPaginationType; |
| |
| _oExt.oPagination[ oSettings.sPaginationType ].fnInit( oSettings, nPaginate, |
| function( oSettings ) { |
| _fnCalculateEnd( oSettings ); |
| _fnDraw( oSettings ); |
| } |
| ); |
| |
| /* Add a draw callback for the pagination on first instance, to update the paging display */ |
| if ( typeof oSettings.aanFeatures.p == "undefined" ) |
| { |
| oSettings.aoDrawCallback.push( { |
| "fn": function( oSettings ) { |
| _oExt.oPagination[ oSettings.sPaginationType ].fnUpdate( oSettings, function( oSettings ) { |
| _fnCalculateEnd( oSettings ); |
| _fnDraw( oSettings ); |
| } ); |
| }, |
| "sName": "pagination" |
| } ); |
| } |
| return nPaginate; |
| } |
| |
| /* |
| * Function: _fnPageChange |
| * Purpose: Alter the display settings to change the page |
| * Returns: bool:true - page has changed, false - no change (no effect) eg 'first' on page 1 |
| * Inputs: object:oSettings - dataTables settings object |
| * string:sAction - paging action to take: "first", "previous", "next" or "last" |
| */ |
| function _fnPageChange ( oSettings, sAction ) |
| { |
| var iOldStart = oSettings._iDisplayStart; |
| |
| if ( sAction == "first" ) |
| { |
| oSettings._iDisplayStart = 0; |
| } |
| else if ( sAction == "previous" ) |
| { |
| oSettings._iDisplayStart = oSettings._iDisplayLength>=0 ? |
| oSettings._iDisplayStart - oSettings._iDisplayLength : |
| 0; |
| |
| /* Correct for underrun */ |
| if ( oSettings._iDisplayStart < 0 ) |
| { |
| oSettings._iDisplayStart = 0; |
| } |
| } |
| else if ( sAction == "next" ) |
| { |
| if ( oSettings._iDisplayLength >= 0 ) |
| { |
| /* Make sure we are not over running the display array */ |
| if ( oSettings._iDisplayStart + oSettings._iDisplayLength < oSettings.fnRecordsDisplay() ) |
| { |
| oSettings._iDisplayStart += oSettings._iDisplayLength; |
| } |
| } |
| else |
| { |
| oSettings._iDisplayStart = 0; |
| } |
| } |
| else if ( sAction == "last" ) |
| { |
| if ( oSettings._iDisplayLength >= 0 ) |
| { |
| var iPages = parseInt( (oSettings.fnRecordsDisplay()-1) / oSettings._iDisplayLength, 10 ) + 1; |
| oSettings._iDisplayStart = (iPages-1) * oSettings._iDisplayLength; |
| } |
| else |
| { |
| oSettings._iDisplayStart = 0; |
| } |
| } |
| else |
| { |
| _fnLog( oSettings, 0, "Unknown paging action: "+sAction ); |
| } |
| $(oSettings.oInstance).trigger('page', oSettings); |
| |
| return iOldStart != oSettings._iDisplayStart; |
| } |
| |
| |
| /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
| * Section - Feature: HTML info |
| */ |
| |
| /* |
| * Function: _fnFeatureHtmlInfo |
| * Purpose: Generate the node required for the info display |
| * Returns: node |
| * Inputs: object:oSettings - dataTables settings object |
| */ |
| function _fnFeatureHtmlInfo ( oSettings ) |
| { |
| var nInfo = document.createElement( 'div' ); |
| nInfo.className = oSettings.oClasses.sInfo; |
| |
| /* Actions that are to be taken once only for this feature */ |
| if ( typeof oSettings.aanFeatures.i == "undefined" ) |
| { |
| /* Add draw callback */ |
| oSettings.aoDrawCallback.push( { |
| "fn": _fnUpdateInfo, |
| "sName": "information" |
| } ); |
| |
| /* Add id */ |
| if ( oSettings.sTableId !== '' ) |
| { |
| nInfo.setAttribute( 'id', oSettings.sTableId+'_info' ); |
| } |
| } |
| |
| return nInfo; |
| } |
| |
| /* |
| * Function: _fnUpdateInfo |
| * Purpose: Update the information elements in the display |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| */ |
| function _fnUpdateInfo ( oSettings ) |
| { |
| /* Show information about the table */ |
| if ( !oSettings.oFeatures.bInfo || oSettings.aanFeatures.i.length === 0 ) |
| { |
| return; |
| } |
| |
| var |
| iStart = oSettings._iDisplayStart+1, iEnd = oSettings.fnDisplayEnd(), |
| iMax = oSettings.fnRecordsTotal(), iTotal = oSettings.fnRecordsDisplay(), |
| sStart = oSettings.fnFormatNumber( iStart ), sEnd = oSettings.fnFormatNumber( iEnd ), |
| sMax = oSettings.fnFormatNumber( iMax ), sTotal = oSettings.fnFormatNumber( iTotal ), |
| sOut; |
| |
| /* When infinite scrolling, we are always starting at 1. _iDisplayStart is used only |
| * internally |
| */ |
| if ( oSettings.oScroll.bInfinite ) |
| { |
| sStart = oSettings.fnFormatNumber( 1 ); |
| } |
| |
| if ( oSettings.fnRecordsDisplay() === 0 && |
| oSettings.fnRecordsDisplay() == oSettings.fnRecordsTotal() ) |
| { |
| /* Empty record set */ |
| sOut = oSettings.oLanguage.sInfoEmpty+ oSettings.oLanguage.sInfoPostFix; |
| } |
| else if ( oSettings.fnRecordsDisplay() === 0 ) |
| { |
| /* Rmpty record set after filtering */ |
| sOut = oSettings.oLanguage.sInfoEmpty +' '+ |
| oSettings.oLanguage.sInfoFiltered.replace('_MAX_', sMax)+ |
| oSettings.oLanguage.sInfoPostFix; |
| } |
| else if ( oSettings.fnRecordsDisplay() == oSettings.fnRecordsTotal() ) |
| { |
| /* Normal record set */ |
| sOut = oSettings.oLanguage.sInfo. |
| replace('_START_', sStart). |
| replace('_END_', sEnd). |
| replace('_TOTAL_', sTotal)+ |
| oSettings.oLanguage.sInfoPostFix; |
| } |
| else |
| { |
| /* Record set after filtering */ |
| sOut = oSettings.oLanguage.sInfo. |
| replace('_START_', sStart). |
| replace('_END_', sEnd). |
| replace('_TOTAL_', sTotal) +' '+ |
| oSettings.oLanguage.sInfoFiltered.replace('_MAX_', |
| oSettings.fnFormatNumber(oSettings.fnRecordsTotal()))+ |
| oSettings.oLanguage.sInfoPostFix; |
| } |
| |
| if ( oSettings.oLanguage.fnInfoCallback !== null ) |
| { |
| sOut = oSettings.oLanguage.fnInfoCallback( oSettings, iStart, iEnd, iMax, iTotal, sOut ); |
| } |
| |
| var n = oSettings.aanFeatures.i; |
| for ( var i=0, iLen=n.length ; i<iLen ; i++ ) |
| { |
| $(n[i]).html( sOut ); |
| } |
| } |
| |
| |
| /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
| * Section - Feature: Length change |
| */ |
| |
| /* |
| * Function: _fnFeatureHtmlLength |
| * Purpose: Generate the node required for user display length changing |
| * Returns: node |
| * Inputs: object:oSettings - dataTables settings object |
| */ |
| function _fnFeatureHtmlLength ( oSettings ) |
| { |
| if ( oSettings.oScroll.bInfinite ) |
| { |
| return null; |
| } |
| |
| /* This can be overruled by not using the _MENU_ var/macro in the language variable */ |
| var sName = (oSettings.sTableId === "") ? "" : 'name="'+oSettings.sTableId+'_length"'; |
| var sStdMenu = '<select size="1" '+sName+'>'; |
| var i, iLen; |
| |
| if ( oSettings.aLengthMenu.length == 2 && typeof oSettings.aLengthMenu[0] == 'object' && |
| typeof oSettings.aLengthMenu[1] == 'object' ) |
| { |
| for ( i=0, iLen=oSettings.aLengthMenu[0].length ; i<iLen ; i++ ) |
| { |
| sStdMenu += '<option value="'+oSettings.aLengthMenu[0][i]+'">'+ |
| oSettings.aLengthMenu[1][i]+'</option>'; |
| } |
| } |
| else |
| { |
| for ( i=0, iLen=oSettings.aLengthMenu.length ; i<iLen ; i++ ) |
| { |
| sStdMenu += '<option value="'+oSettings.aLengthMenu[i]+'">'+ |
| oSettings.aLengthMenu[i]+'</option>'; |
| } |
| } |
| sStdMenu += '</select>'; |
| |
| var nLength = document.createElement( 'div' ); |
| if ( oSettings.sTableId !== '' && typeof oSettings.aanFeatures.l == "undefined" ) |
| { |
| nLength.setAttribute( 'id', oSettings.sTableId+'_length' ); |
| } |
| nLength.className = oSettings.oClasses.sLength; |
| nLength.innerHTML = '<label>'+oSettings.oLanguage.sLengthMenu.replace( '_MENU_', sStdMenu )+'</label>'; |
| |
| /* |
| * Set the length to the current display length - thanks to Andrea Pavlovic for this fix, |
| * and Stefan Skopnik for fixing the fix! |
| */ |
| $('select option[value="'+oSettings._iDisplayLength+'"]',nLength).attr("selected",true); |
| |
| $('select', nLength).on( 'change.DT', function(e) { |
| var iVal = $(this).val(); |
| |
| /* Update all other length options for the new display */ |
| var n = oSettings.aanFeatures.l; |
| for ( i=0, iLen=n.length ; i<iLen ; i++ ) |
| { |
| if ( n[i] != this.parentNode ) |
| { |
| $('select', n[i]).val( iVal ); |
| } |
| } |
| |
| /* Redraw the table */ |
| oSettings._iDisplayLength = parseInt(iVal, 10); |
| _fnCalculateEnd( oSettings ); |
| |
| /* If we have space to show extra rows (backing up from the end point - then do so */ |
| if ( oSettings.fnDisplayEnd() == oSettings.fnRecordsDisplay() ) |
| { |
| oSettings._iDisplayStart = oSettings.fnDisplayEnd() - oSettings._iDisplayLength; |
| if ( oSettings._iDisplayStart < 0 ) |
| { |
| oSettings._iDisplayStart = 0; |
| } |
| } |
| |
| if ( oSettings._iDisplayLength == -1 ) |
| { |
| oSettings._iDisplayStart = 0; |
| } |
| |
| _fnDraw( oSettings ); |
| } ); |
| |
| return nLength; |
| } |
| |
| |
| /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
| * Section - Feature: Processing incidator |
| */ |
| |
| /* |
| * Function: _fnFeatureHtmlProcessing |
| * Purpose: Generate the node required for the processing node |
| * Returns: node |
| * Inputs: object:oSettings - dataTables settings object |
| */ |
| function _fnFeatureHtmlProcessing ( oSettings ) |
| { |
| var nProcessing = document.createElement( 'div' ); |
| |
| if ( oSettings.sTableId !== '' && typeof oSettings.aanFeatures.r == "undefined" ) |
| { |
| nProcessing.setAttribute( 'id', oSettings.sTableId+'_processing' ); |
| } |
| nProcessing.innerHTML = oSettings.oLanguage.sProcessing; |
| nProcessing.className = oSettings.oClasses.sProcessing; |
| oSettings.nTable.parentNode.insertBefore( nProcessing, oSettings.nTable ); |
| |
| return nProcessing; |
| } |
| |
| /* |
| * Function: _fnProcessingDisplay |
| * Purpose: Display or hide the processing indicator |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| * bool: |
| * true - show the processing indicator |
| * false - don't show |
| */ |
| function _fnProcessingDisplay ( oSettings, bShow ) |
| { |
| if ( oSettings.oFeatures.bProcessing ) |
| { |
| var an = oSettings.aanFeatures.r; |
| for ( var i=0, iLen=an.length ; i<iLen ; i++ ) |
| { |
| an[i].style.visibility = bShow ? "visible" : "hidden"; |
| } |
| } |
| } |
| |
| |
| /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
| * Section - Support functions |
| */ |
| |
| /* |
| * Function: _fnVisibleToColumnIndex |
| * Purpose: Covert the index of a visible column to the index in the data array (take account |
| * of hidden columns) |
| * Returns: int:i - the data index |
| * Inputs: object:oSettings - dataTables settings object |
| */ |
| function _fnVisibleToColumnIndex( oSettings, iMatch ) |
| { |
| var iColumn = -1; |
| |
| for ( var i=0 ; i<oSettings.aoColumns.length ; i++ ) |
| { |
| if ( oSettings.aoColumns[i].bVisible === true ) |
| { |
| iColumn++; |
| } |
| |
| if ( iColumn == iMatch ) |
| { |
| return i; |
| } |
| } |
| |
| return null; |
| } |
| |
| /* |
| * Function: _fnColumnIndexToVisible |
| * Purpose: Covert the index of an index in the data array and convert it to the visible |
| * column index (take account of hidden columns) |
| * Returns: int:i - the data index |
| * Inputs: object:oSettings - dataTables settings object |
| */ |
| function _fnColumnIndexToVisible( oSettings, iMatch ) |
| { |
| var iVisible = -1; |
| for ( var i=0 ; i<oSettings.aoColumns.length ; i++ ) |
| { |
| if ( oSettings.aoColumns[i].bVisible === true ) |
| { |
| iVisible++; |
| } |
| |
| if ( i == iMatch ) |
| { |
| return oSettings.aoColumns[i].bVisible === true ? iVisible : null; |
| } |
| } |
| |
| return null; |
| } |
| |
| |
| /* |
| * Function: _fnNodeToDataIndex |
| * Purpose: Take a TR element and convert it to an index in aoData |
| * Returns: int:i - index if found, null if not |
| * Inputs: object:s - dataTables settings object |
| * node:n - the TR element to find |
| */ |
| function _fnNodeToDataIndex( s, n ) |
| { |
| var i, iLen; |
| |
| /* Optimisation - see if the nodes which are currently visible match, since that is |
| * the most likely node to be asked for (a selector or event for example) |
| */ |
| for ( i=s._iDisplayStart, iLen=s._iDisplayEnd ; i<iLen ; i++ ) |
| { |
| if ( s.aoData[ s.aiDisplay[i] ].nTr == n ) |
| { |
| return s.aiDisplay[i]; |
| } |
| } |
| |
| /* Otherwise we are in for a slog through the whole data cache */ |
| for ( i=0, iLen=s.aoData.length ; i<iLen ; i++ ) |
| { |
| if ( s.aoData[i].nTr == n ) |
| { |
| return i; |
| } |
| } |
| return null; |
| } |
| |
| /* |
| * Function: _fnVisbleColumns |
| * Purpose: Get the number of visible columns |
| * Returns: int:i - the number of visible columns |
| * Inputs: object:oS - dataTables settings object |
| */ |
| function _fnVisbleColumns( oS ) |
| { |
| var iVis = 0; |
| for ( var i=0 ; i<oS.aoColumns.length ; i++ ) |
| { |
| if ( oS.aoColumns[i].bVisible === true ) |
| { |
| iVis++; |
| } |
| } |
| return iVis; |
| } |
| |
| /* |
| * Function: _fnCalculateEnd |
| * Purpose: Rcalculate the end point based on the start point |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| */ |
| function _fnCalculateEnd( oSettings ) |
| { |
| if ( oSettings.oFeatures.bPaginate === false ) |
| { |
| oSettings._iDisplayEnd = oSettings.aiDisplay.length; |
| } |
| else |
| { |
| /* Set the end point of the display - based on how many elements there are |
| * still to display |
| */ |
| if ( oSettings._iDisplayStart + oSettings._iDisplayLength > oSettings.aiDisplay.length || |
| oSettings._iDisplayLength == -1 ) |
| { |
| oSettings._iDisplayEnd = oSettings.aiDisplay.length; |
| } |
| else |
| { |
| oSettings._iDisplayEnd = oSettings._iDisplayStart + oSettings._iDisplayLength; |
| } |
| } |
| } |
| |
| /* |
| * Function: _fnConvertToWidth |
| * Purpose: Convert a CSS unit width to pixels (e.g. 2em) |
| * Returns: int:iWidth - width in pixels |
| * Inputs: string:sWidth - width to be converted |
| * node:nParent - parent to get the with for (required for |
| * relative widths) - optional |
| */ |
| function _fnConvertToWidth ( sWidth, nParent ) |
| { |
| if ( !sWidth || sWidth === null || sWidth === '' ) |
| { |
| return 0; |
| } |
| |
| if ( typeof nParent == "undefined" ) |
| { |
| nParent = document.getElementsByTagName('body')[0]; |
| } |
| |
| var iWidth; |
| var nTmp = document.createElement( "div" ); |
| nTmp.style.width = _fnStringToCss( sWidth ); |
| |
| nParent.appendChild( nTmp ); |
| iWidth = nTmp.offsetWidth; |
| nParent.removeChild( nTmp ); |
| |
| return ( iWidth ); |
| } |
| |
| /* |
| * Function: _fnCalculateColumnWidths |
| * Purpose: Calculate the width of columns for the table |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| */ |
| function _fnCalculateColumnWidths ( oSettings ) |
| { |
| var iTableWidth = oSettings.nTable.offsetWidth; |
| var iUserInputs = 0; |
| var iTmpWidth; |
| var iVisibleColumns = 0; |
| var iColums = oSettings.aoColumns.length; |
| var i, iIndex, iCorrector, iWidth; |
| var oHeaders = $('th', oSettings.nTHead); |
| |
| /* Convert any user input sizes into pixel sizes */ |
| for ( i=0 ; i<iColums ; i++ ) |
| { |
| if ( oSettings.aoColumns[i].bVisible ) |
| { |
| iVisibleColumns++; |
| |
| if ( oSettings.aoColumns[i].sWidth !== null ) |
| { |
| iTmpWidth = _fnConvertToWidth( oSettings.aoColumns[i].sWidthOrig, |
| oSettings.nTable.parentNode ); |
| if ( iTmpWidth !== null ) |
| { |
| oSettings.aoColumns[i].sWidth = _fnStringToCss( iTmpWidth ); |
| } |
| |
| iUserInputs++; |
| } |
| } |
| } |
| |
| /* If the number of columns in the DOM equals the number that we have to process in |
| * DataTables, then we can use the offsets that are created by the web-browser. No custom |
| * sizes can be set in order for this to happen, nor scrolling used |
| */ |
| if ( iColums == oHeaders.length && iUserInputs === 0 && iVisibleColumns == iColums && |
| oSettings.oScroll.sX === "" && oSettings.oScroll.sY === "" ) |
| { |
| for ( i=0 ; i<oSettings.aoColumns.length ; i++ ) |
| { |
| iTmpWidth = $(oHeaders[i]).width(); |
| if ( iTmpWidth !== null ) |
| { |
| oSettings.aoColumns[i].sWidth = _fnStringToCss( iTmpWidth ); |
| } |
| } |
| } |
| else |
| { |
| /* Otherwise we are going to have to do some calculations to get the width of each column. |
| * Construct a 1 row table with the widest node in the data, and any user defined widths, |
| * then insert it into the DOM and allow the browser to do all the hard work of |
| * calculating table widths. |
| */ |
| var |
| nCalcTmp = oSettings.nTable.cloneNode( false ), |
| nTheadClone = oSettings.nTHead.cloneNode(true), |
| nBody = document.createElement( 'tbody' ), |
| nTr = document.createElement( 'tr' ), |
| nDivSizing; |
| |
| nCalcTmp.removeAttribute( "id" ); |
| nCalcTmp.appendChild( nTheadClone ); |
| if ( oSettings.nTFoot !== null ) |
| { |
| nCalcTmp.appendChild( oSettings.nTFoot.cloneNode(true) ); |
| _fnApplyToChildren( function(n) { |
| n.style.width = ""; |
| }, nCalcTmp.getElementsByTagName('tr') ); |
| } |
| |
| nCalcTmp.appendChild( nBody ); |
| nBody.appendChild( nTr ); |
| |
| /* Remove any sizing that was previously applied by the styles */ |
| var jqColSizing = $('thead th', nCalcTmp); |
| if ( jqColSizing.length === 0 ) |
| { |
| jqColSizing = $('tbody tr:eq(0)>td', nCalcTmp); |
| } |
| |
| /* Apply custom sizing to the cloned header */ |
| var nThs = _fnGetUniqueThs( oSettings, nTheadClone ); |
| iCorrector = 0; |
| for ( i=0 ; i<iColums ; i++ ) |
| { |
| var oColumn = oSettings.aoColumns[i]; |
| if ( oColumn.bVisible && oColumn.sWidthOrig !== null && oColumn.sWidthOrig !== "" ) |
| { |
| nThs[i-iCorrector].style.width = _fnStringToCss( oColumn.sWidthOrig ); |
| } |
| else if ( oColumn.bVisible ) |
| { |
| nThs[i-iCorrector].style.width = ""; |
| } |
| else |
| { |
| iCorrector++; |
| } |
| } |
| |
| /* Find the biggest td for each column and put it into the table */ |
| for ( i=0 ; i<iColums ; i++ ) |
| { |
| if ( oSettings.aoColumns[i].bVisible ) |
| { |
| var nTd = _fnGetWidestNode( oSettings, i ); |
| if ( nTd !== null ) |
| { |
| nTd = nTd.cloneNode(true); |
| if ( oSettings.aoColumns[i].sContentPadding !== "" ) |
| { |
| nTd.innerHTML += oSettings.aoColumns[i].sContentPadding; |
| } |
| nTr.appendChild( nTd ); |
| } |
| } |
| } |
| |
| /* Build the table and 'display' it */ |
| var nWrapper = oSettings.nTable.parentNode; |
| nWrapper.appendChild( nCalcTmp ); |
| |
| /* When scrolling (X or Y) we want to set the width of the table as appropriate. However, |
| * when not scrolling leave the table width as it is. This results in slightly different, |
| * but I think correct behaviour |
| */ |
| if ( oSettings.oScroll.sX !== "" && oSettings.oScroll.sXInner !== "" ) |
| { |
| nCalcTmp.style.width = _fnStringToCss(oSettings.oScroll.sXInner); |
| } |
| else if ( oSettings.oScroll.sX !== "" ) |
| { |
| nCalcTmp.style.width = ""; |
| if ( $(nCalcTmp).width() < nWrapper.offsetWidth ) |
| { |
| nCalcTmp.style.width = _fnStringToCss( nWrapper.offsetWidth ); |
| } |
| } |
| else if ( oSettings.oScroll.sY !== "" ) |
| { |
| nCalcTmp.style.width = _fnStringToCss( nWrapper.offsetWidth ); |
| } |
| nCalcTmp.style.visibility = "hidden"; |
| |
| /* Scrolling considerations */ |
| _fnScrollingWidthAdjust( oSettings, nCalcTmp ); |
| |
| /* Read the width's calculated by the browser and store them for use by the caller. We |
| * first of all try to use the elements in the body, but it is possible that there are |
| * no elements there, under which circumstances we use the header elements |
| */ |
| var oNodes = $("tbody tr:eq(0)", nCalcTmp).children(); |
| if ( oNodes.length === 0 ) |
| { |
| oNodes = _fnGetUniqueThs( oSettings, $('thead', nCalcTmp)[0] ); |
| } |
| |
| /* Browsers need a bit of a hand when a width is assigned to any columns when |
| * x-scrolling as they tend to collapse the table to the min-width, even if |
| * we sent the column widths. So we need to keep track of what the table width |
| * should be by summing the user given values, and the automatic values |
| */ |
| if ( oSettings.oScroll.sX !== "" ) |
| { |
| var iTotal = 0; |
| iCorrector = 0; |
| for ( i=0 ; i<oSettings.aoColumns.length ; i++ ) |
| { |
| if ( oSettings.aoColumns[i].bVisible ) |
| { |
| if ( oSettings.aoColumns[i].sWidthOrig === null ) |
| { |
| iTotal += $(oNodes[iCorrector]).outerWidth(); |
| } |
| else |
| { |
| iTotal += parseInt(oSettings.aoColumns[i].sWidth.replace('px',''), 10) + |
| ($(oNodes[iCorrector]).outerWidth() - $(oNodes[iCorrector]).width()); |
| } |
| iCorrector++; |
| } |
| } |
| |
| nCalcTmp.style.width = _fnStringToCss( iTotal ); |
| oSettings.nTable.style.width = _fnStringToCss( iTotal ); |
| } |
| |
| iCorrector = 0; |
| for ( i=0 ; i<oSettings.aoColumns.length ; i++ ) |
| { |
| if ( oSettings.aoColumns[i].bVisible ) |
| { |
| iWidth = $(oNodes[iCorrector]).width(); |
| if ( iWidth !== null && iWidth > 0 ) |
| { |
| oSettings.aoColumns[i].sWidth = _fnStringToCss( iWidth ); |
| } |
| iCorrector++; |
| } |
| } |
| |
| oSettings.nTable.style.width = _fnStringToCss( $(nCalcTmp).outerWidth() ); |
| nCalcTmp.parentNode.removeChild( nCalcTmp ); |
| } |
| } |
| |
| /* |
| * Function: _fnScrollingWidthAdjust |
| * Purpose: Adjust a table's width to take account of scrolling |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| * node:n - table node |
| */ |
| function _fnScrollingWidthAdjust ( oSettings, n ) |
| { |
| if ( oSettings.oScroll.sX === "" && oSettings.oScroll.sY !== "" ) |
| { |
| /* When y-scrolling only, we want to remove the width of the scroll bar so the table |
| * + scroll bar will fit into the area avaialble. |
| */ |
| var iOrigWidth = $(n).width(); |
| n.style.width = _fnStringToCss( $(n).outerWidth()-oSettings.oScroll.iBarWidth ); |
| } |
| else if ( oSettings.oScroll.sX !== "" ) |
| { |
| /* When x-scrolling both ways, fix the table at it's current size, without adjusting */ |
| n.style.width = _fnStringToCss( $(n).outerWidth() ); |
| } |
| } |
| |
| /* |
| * Function: _fnGetWidestNode |
| * Purpose: Get the widest node |
| * Returns: string: - max strlens for each column |
| * Inputs: object:oSettings - dataTables settings object |
| * int:iCol - column of interest |
| */ |
| function _fnGetWidestNode( oSettings, iCol ) |
| { |
| var iMaxIndex = _fnGetMaxLenString( oSettings, iCol ); |
| if ( iMaxIndex < 0 ) |
| { |
| return null; |
| } |
| |
| if ( oSettings.aoData[iMaxIndex].nTr === null ) |
| { |
| var n = document.createElement('td'); |
| n.innerHTML = _fnGetCellData( oSettings, iMaxIndex, iCol, '' ); |
| return n; |
| } |
| return _fnGetTdNodes(oSettings, iMaxIndex)[iCol]; |
| } |
| |
| /* |
| * Function: _fnGetMaxLenString |
| * Purpose: Get the maximum strlen for each data column |
| * Returns: string: - max strlens for each column |
| * Inputs: object:oSettings - dataTables settings object |
| * int:iCol - column of interest |
| */ |
| function _fnGetMaxLenString( oSettings, iCol ) |
| { |
| var iMax = -1; |
| var iMaxIndex = -1; |
| |
| for ( var i=0 ; i<oSettings.aoData.length ; i++ ) |
| { |
| var s = _fnGetCellData( oSettings, i, iCol, 'display' )+""; |
| s = s.replace( /<.*?>/g, "" ); |
| if ( s.length > iMax ) |
| { |
| iMax = s.length; |
| iMaxIndex = i; |
| } |
| } |
| |
| return iMaxIndex; |
| } |
| |
| /* |
| * Function: _fnStringToCss |
| * Purpose: Append a CSS unit (only if required) to a string |
| * Returns: 0 if match, 1 if length is different, 2 if no match |
| * Inputs: array:aArray1 - first array |
| * array:aArray2 - second array |
| */ |
| function _fnStringToCss( s ) |
| { |
| if ( s === null ) |
| { |
| return "0px"; |
| } |
| |
| if ( typeof s == 'number' ) |
| { |
| if ( s < 0 ) |
| { |
| return "0px"; |
| } |
| return s+"px"; |
| } |
| |
| /* Check if the last character is not 0-9 */ |
| var c = s.charCodeAt( s.length-1 ); |
| if (c < 0x30 || c > 0x39) |
| { |
| return s; |
| } |
| return s+"px"; |
| } |
| |
| /* |
| * Function: _fnArrayCmp |
| * Purpose: Compare two arrays |
| * Returns: 0 if match, 1 if length is different, 2 if no match |
| * Inputs: array:aArray1 - first array |
| * array:aArray2 - second array |
| */ |
| function _fnArrayCmp( aArray1, aArray2 ) |
| { |
| if ( aArray1.length != aArray2.length ) |
| { |
| return 1; |
| } |
| |
| for ( var i=0 ; i<aArray1.length ; i++ ) |
| { |
| if ( aArray1[i] != aArray2[i] ) |
| { |
| return 2; |
| } |
| } |
| |
| return 0; |
| } |
| |
| /* |
| * Function: _fnDetectType |
| * Purpose: Get the sort type based on an input string |
| * Returns: string: - type (defaults to 'string' if no type can be detected) |
| * Inputs: string:sData - data we wish to know the type of |
| * Notes: This function makes use of the DataTables plugin objct _oExt |
| * (.aTypes) such that new types can easily be added. |
| */ |
| function _fnDetectType( sData ) |
| { |
| var aTypes = _oExt.aTypes; |
| var iLen = aTypes.length; |
| |
| for ( var i=0 ; i<iLen ; i++ ) |
| { |
| var sType = aTypes[i]( sData ); |
| if ( sType !== null ) |
| { |
| return sType; |
| } |
| } |
| |
| return 'string'; |
| } |
| |
| /* |
| * Function: _fnSettingsFromNode |
| * Purpose: Return the settings object for a particular table |
| * Returns: object: Settings object - or null if not found |
| * Inputs: node:nTable - table we are using as a dataTable |
| */ |
| function _fnSettingsFromNode ( nTable ) |
| { |
| for ( var i=0 ; i<_aoSettings.length ; i++ ) |
| { |
| if ( _aoSettings[i].nTable == nTable ) |
| { |
| return _aoSettings[i]; |
| } |
| } |
| |
| return null; |
| } |
| |
| /* |
| * Function: _fnGetDataMaster |
| * Purpose: Return an array with the full table data |
| * Returns: array array:aData - Master data array |
| * Inputs: object:oSettings - dataTables settings object |
| */ |
| function _fnGetDataMaster ( oSettings ) |
| { |
| var aData = []; |
| var iLen = oSettings.aoData.length; |
| for ( var i=0 ; i<iLen; i++ ) |
| { |
| aData.push( oSettings.aoData[i]._aData ); |
| } |
| return aData; |
| } |
| |
| /* |
| * Function: _fnGetTrNodes |
| * Purpose: Return an array with the TR nodes for the table |
| * Returns: array: - TR array |
| * Inputs: object:oSettings - dataTables settings object |
| */ |
| function _fnGetTrNodes ( oSettings ) |
| { |
| var aNodes = []; |
| for ( var i=0, iLen=oSettings.aoData.length ; i<iLen ; i++ ) |
| { |
| if ( oSettings.aoData[i].nTr !== null ) |
| { |
| aNodes.push( oSettings.aoData[i].nTr ); |
| } |
| } |
| return aNodes; |
| } |
| |
| /* |
| * Function: _fnGetTdNodes |
| * Purpose: Return an flat array with all TD nodes for the table, or row |
| * Returns: array: - TD array |
| * Inputs: object:oSettings - dataTables settings object |
| * int:iIndividualRow - aoData index to get the nodes for - optional if not |
| * given then the return array will contain all nodes for the table |
| */ |
| function _fnGetTdNodes ( oSettings, iIndividualRow ) |
| { |
| var anReturn = []; |
| var iCorrector; |
| var anTds; |
| var iRow, iRows=oSettings.aoData.length, |
| iColumn, iColumns, oData, sNodeName, iStart=0, iEnd=iRows; |
| |
| /* Allow the collection to be limited to just one row */ |
| if ( typeof iIndividualRow != 'undefined' ) |
| { |
| iStart = iIndividualRow; |
| iEnd = iIndividualRow+1; |
| } |
| |
| for ( iRow=iStart ; iRow<iEnd ; iRow++ ) |
| { |
| oData = oSettings.aoData[iRow]; |
| if ( oData.nTr !== null ) |
| { |
| /* get the TD child nodes - taking into account text etc nodes */ |
| anTds = []; |
| for ( iColumn=0, iColumns=oData.nTr.childNodes.length ; iColumn<iColumns ; iColumn++ ) |
| { |
| sNodeName = oData.nTr.childNodes[iColumn].nodeName.toLowerCase(); |
| if ( sNodeName == 'td' || sNodeName == 'th' ) |
| { |
| anTds.push( oData.nTr.childNodes[iColumn] ); |
| } |
| } |
| |
| iCorrector = 0; |
| for ( iColumn=0, iColumns=oSettings.aoColumns.length ; iColumn<iColumns ; iColumn++ ) |
| { |
| if ( oSettings.aoColumns[iColumn].bVisible ) |
| { |
| anReturn.push( anTds[iColumn-iCorrector] ); |
| } |
| else |
| { |
| anReturn.push( oData._anHidden[iColumn] ); |
| iCorrector++; |
| } |
| } |
| } |
| } |
| |
| return anReturn; |
| } |
| |
| /* |
| * Function: _fnEscapeRegex |
| * Purpose: scape a string stuch that it can be used in a regular expression |
| * Returns: string: - escaped string |
| * Inputs: string:sVal - string to escape |
| */ |
| function _fnEscapeRegex ( sVal ) |
| { |
| var acEscape = [ '/', '.', '*', '+', '?', '|', '(', ')', '[', ']', '{', '}', '\\', '$', '^' ]; |
| var reReplace = new RegExp( '(\\' + acEscape.join('|\\') + ')', 'g' ); |
| return sVal.replace(reReplace, '\\$1'); |
| } |
| |
| /* |
| * Function: _fnDeleteIndex |
| * Purpose: Take an array of integers (index array) and remove a target integer (value - not |
| * the key!) |
| * Returns: - |
| * Inputs: a:array int - Index array to target |
| * int:iTarget - value to find |
| */ |
| function _fnDeleteIndex( a, iTarget ) |
| { |
| var iTargetIndex = -1; |
| |
| for ( var i=0, iLen=a.length ; i<iLen ; i++ ) |
| { |
| if ( a[i] == iTarget ) |
| { |
| iTargetIndex = i; |
| } |
| else if ( a[i] > iTarget ) |
| { |
| a[i]--; |
| } |
| } |
| |
| if ( iTargetIndex != -1 ) |
| { |
| a.splice( iTargetIndex, 1 ); |
| } |
| } |
| |
| /* |
| * Function: _fnReOrderIndex |
| * Purpose: Figure out how to reorder a display list |
| * Returns: array int:aiReturn - index list for reordering |
| * Inputs: object:oSettings - dataTables settings object |
| */ |
| function _fnReOrderIndex ( oSettings, sColumns ) |
| { |
| var aColumns = sColumns.split(','); |
| var aiReturn = []; |
| |
| for ( var i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ ) |
| { |
| for ( var j=0 ; j<iLen ; j++ ) |
| { |
| if ( oSettings.aoColumns[i].sName == aColumns[j] ) |
| { |
| aiReturn.push( j ); |
| break; |
| } |
| } |
| } |
| |
| return aiReturn; |
| } |
| |
| /* |
| * Function: _fnColumnOrdering |
| * Purpose: Get the column ordering that DataTables expects |
| * Returns: string: - comma separated list of names |
| * Inputs: object:oSettings - dataTables settings object |
| */ |
| function _fnColumnOrdering ( oSettings ) |
| { |
| var sNames = ''; |
| for ( var i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ ) |
| { |
| sNames += oSettings.aoColumns[i].sName+','; |
| } |
| if ( sNames.length == iLen ) |
| { |
| return ""; |
| } |
| return sNames.slice(0, -1); |
| } |
| |
| /* |
| * Function: _fnLog |
| * Purpose: Log an error message |
| * Returns: - |
| * Inputs: int:iLevel - log error messages, or display them to the user |
| * string:sMesg - error message |
| */ |
| function _fnLog( oSettings, iLevel, sMesg ) |
| { |
| var sAlert = oSettings.sTableId === "" ? |
| "DataTables warning: " +sMesg : |
| "DataTables warning (table id = '"+oSettings.sTableId+"'): " +sMesg; |
| |
| if ( iLevel === 0 ) |
| { |
| if ( _oExt.sErrMode == 'alert' ) |
| { |
| alert( sAlert ); |
| } |
| else |
| { |
| throw sAlert; |
| } |
| return; |
| } |
| else if ( typeof console != 'undefined' && typeof console.log != 'undefined' ) |
| { |
| console.log( sAlert ); |
| } |
| } |
| |
| /* |
| * Function: _fnClearTable |
| * Purpose: Nuke the table |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| */ |
| function _fnClearTable( oSettings ) |
| { |
| oSettings.aoData.splice( 0, oSettings.aoData.length ); |
| oSettings.aiDisplayMaster.splice( 0, oSettings.aiDisplayMaster.length ); |
| oSettings.aiDisplay.splice( 0, oSettings.aiDisplay.length ); |
| _fnCalculateEnd( oSettings ); |
| } |
| |
| /* |
| * Function: _fnSaveState |
| * Purpose: Save the state of a table in a cookie such that the page can be reloaded |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| */ |
| function _fnSaveState ( oSettings ) |
| { |
| if ( !oSettings.oFeatures.bStateSave || typeof oSettings.bDestroying != 'undefined' ) |
| { |
| return; |
| } |
| |
| /* Store the interesting variables */ |
| var i, iLen, sTmp; |
| var sValue = "{"; |
| sValue += '"iCreate":'+ new Date().getTime()+','; |
| sValue += '"iStart":'+ (oSettings.oScroll.bInfinite ? 0 : oSettings._iDisplayStart)+','; |
| sValue += '"iEnd":'+ (oSettings.oScroll.bInfinite ? oSettings._iDisplayLength : oSettings._iDisplayEnd)+','; |
| sValue += '"iLength":'+ oSettings._iDisplayLength+','; |
| sValue += '"sFilter":"'+ encodeURIComponent(oSettings.oPreviousSearch.sSearch)+'",'; |
| sValue += '"sFilterEsc":'+ !oSettings.oPreviousSearch.bRegex+','; |
| |
| sValue += '"aaSorting":[ '; |
| for ( i=0 ; i<oSettings.aaSorting.length ; i++ ) |
| { |
| sValue += '['+oSettings.aaSorting[i][0]+',"'+oSettings.aaSorting[i][1]+'"],'; |
| } |
| sValue = sValue.substring(0, sValue.length-1); |
| sValue += "],"; |
| |
| sValue += '"aaSearchCols":[ '; |
| for ( i=0 ; i<oSettings.aoPreSearchCols.length ; i++ ) |
| { |
| sValue += '["'+encodeURIComponent(oSettings.aoPreSearchCols[i].sSearch)+ |
| '",'+!oSettings.aoPreSearchCols[i].bRegex+'],'; |
| } |
| sValue = sValue.substring(0, sValue.length-1); |
| sValue += "],"; |
| |
| sValue += '"abVisCols":[ '; |
| for ( i=0 ; i<oSettings.aoColumns.length ; i++ ) |
| { |
| sValue += oSettings.aoColumns[i].bVisible+","; |
| } |
| sValue = sValue.substring(0, sValue.length-1); |
| sValue += "]"; |
| |
| /* Save state from any plug-ins */ |
| for ( i=0, iLen=oSettings.aoStateSave.length ; i<iLen ; i++ ) |
| { |
| sTmp = oSettings.aoStateSave[i].fn( oSettings, sValue ); |
| if ( sTmp !== "" ) |
| { |
| sValue = sTmp; |
| } |
| } |
| |
| sValue += "}"; |
| |
| _fnCreateCookie( oSettings.sCookiePrefix+oSettings.sInstance, sValue, |
| oSettings.iCookieDuration, oSettings.sCookiePrefix, oSettings.fnCookieCallback ); |
| } |
| |
| /* |
| * Function: _fnLoadState |
| * Purpose: Attempt to load a saved table state from a cookie |
| * Returns: - |
| * Inputs: object:oSettings - dataTables settings object |
| * object:oInit - DataTables init object so we can override settings |
| */ |
| function _fnLoadState ( oSettings, oInit ) |
| { |
| if ( !oSettings.oFeatures.bStateSave ) |
| { |
| return; |
| } |
| |
| var oData, i, iLen; |
| var sData = _fnReadCookie( oSettings.sCookiePrefix+oSettings.sInstance ); |
| if ( sData !== null && sData !== '' ) |
| { |
| /* Try/catch the JSON eval - if it is bad then we ignore it - note that 1.7.0 and before |
| * incorrectly used single quotes for some strings - hence the replace below |
| */ |
| try |
| { |
| oData = (typeof JSON.parse == 'function') ? |
| JSON.parse( sData.replace(/'/g, '"') ) : $.parseJSON( sData.replace(/'/g, '"') ); |
| } |
| catch( e ) |
| { |
| return; |
| } |
| |
| /* Allow custom and plug-in manipulation functions to alter the data set which was |
| * saved, and also reject any saved state by returning false |
| */ |
| for ( i=0, iLen=oSettings.aoStateLoad.length ; i<iLen ; i++ ) |
| { |
| if ( !oSettings.aoStateLoad[i].fn( oSettings, oData ) ) |
| { |
| return; |
| } |
| } |
| |
| /* Store the saved state so it might be accessed at any time (particualrly a plug-in */ |
| oSettings.oLoadedState = $.extend( true, {}, oData ); |
| |
| /* Restore key features */ |
| oSettings._iDisplayStart = oData.iStart; |
| oSettings.iInitDisplayStart = oData.iStart; |
| oSettings._iDisplayEnd = oData.iEnd; |
| oSettings._iDisplayLength = oData.iLength; |
| oSettings.oPreviousSearch.sSearch = decodeURIComponent(oData.sFilter); |
| oSettings.aaSorting = oData.aaSorting.slice(); |
| oSettings.saved_aaSorting = oData.aaSorting.slice(); |
| |
| /* |
| * Search filtering - global reference added in 1.4.1 |
| * Note that we use a 'not' for the value of the regular expression indicator to maintain |
| * compatibility with pre 1.7 versions, where this was basically inverted. Added in 1.7.0 |
| */ |
| if ( typeof oData.sFilterEsc != 'undefined' ) |
| { |
| oSettings.oPreviousSearch.bRegex = !oData.sFilterEsc; |
| } |
| |
| /* Column filtering - added in 1.5.0 beta 6 */ |
| if ( typeof oData.aaSearchCols != 'undefined' ) |
| { |
| for ( i=0 ; i<oData.aaSearchCols.length ; i++ ) |
| { |
| oSettings.aoPreSearchCols[i] = { |
| "sSearch": decodeURIComponent(oData.aaSearchCols[i][0]), |
| "bRegex": !oData.aaSearchCols[i][1] |
| }; |
| } |
| } |
| |
| /* Column visibility state - added in 1.5.0 beta 10 */ |
| if ( typeof oData.abVisCols != 'undefined' ) |
| { |
| /* Pass back visibiliy settings to the init handler, but to do not here override |
| * the init object that the user might have passed in |
| */ |
| oInit.saved_aoColumns = []; |
| for ( i=0 ; i<oData.abVisCols.length ; i++ ) |
| { |
| oInit.saved_aoColumns[i] = {}; |
| oInit.saved_aoColumns[i].bVisible = oData.abVisCols[i]; |
| } |
| } |
| } |
| } |
| |
| /* |
| * Function: _fnCreateCookie |
| * Purpose: Create a new cookie with a value to store the state of a table |
| * Returns: - |
| * Inputs: string:sName - name of the cookie to create |
| * string:sValue - the value the cookie should take |
| * int:iSecs - duration of the cookie |
| * string:sBaseName - sName is made up of the base + file name - this is the base |
| * function:fnCallback - User definable function to modify the cookie |
| */ |
| function _fnCreateCookie ( sName, sValue, iSecs, sBaseName, fnCallback ) |
| { |
| var date = new Date(); |
| date.setTime( date.getTime()+(iSecs*1000) ); |
| |
| /* |
| * Shocking but true - it would appear IE has major issues with having the path not having |
| * a trailing slash on it. We need the cookie to be available based on the path, so we |
| * have to append the file name to the cookie name. Appalling. Thanks to vex for adding the |
| * patch to use at least some of the path |
| */ |
| var aParts = window.location.pathname.split('/'); |
| var sNameFile = sName + '_' + aParts.pop().replace(/[\/:]/g,"").toLowerCase(); |
| var sFullCookie, oData; |
| |
| if ( fnCallback !== null ) |
| { |
| oData = (typeof JSON.parse == 'function') ? |
| JSON.parse( sValue ) : $.parseJSON( sValue ); |
| sFullCookie = fnCallback( sNameFile, oData, date.toGMTString(), |
| aParts.join('/')+"/" ); |
| } |
| else |
| { |
| sFullCookie = sNameFile + "=" + encodeURIComponent(sValue) + |
| "; expires=" + date.toGMTString() +"; path=" + aParts.join('/')+"/"; |
| } |
| |
| /* Are we going to go over the cookie limit of 4KiB? If so, try to delete a cookies |
| * belonging to DataTables. This is FAR from bullet proof |
| */ |
| var sOldName="", iOldTime=9999999999999; |
| var iLength = _fnReadCookie( sNameFile )!==null ? document.cookie.length : |
| sFullCookie.length + document.cookie.length; |
| |
| if ( iLength+10 > 4096 ) /* Magic 10 for padding */ |
| { |
| var aCookies =document.cookie.split(';'); |
| for ( var i=0, iLen=aCookies.length ; i<iLen ; i++ ) |
| { |
| if ( aCookies[i].indexOf( sBaseName ) != -1 ) |
| { |
| /* It's a DataTables cookie, so eval it and check the time stamp */ |
| var aSplitCookie = aCookies[i].split('='); |
| try { oData = eval( '('+decodeURIComponent(aSplitCookie[1])+')' ); } |
| catch( e ) { continue; } |
| |
| if ( typeof oData.iCreate != 'undefined' && oData.iCreate < iOldTime ) |
| { |
| sOldName = aSplitCookie[0]; |
| iOldTime = oData.iCreate; |
| } |
| } |
| } |
| |
| if ( sOldName !== "" ) |
| { |
| document.cookie = sOldName+"=; expires=Thu, 01-Jan-1970 00:00:01 GMT; path="+ |
| aParts.join('/') + "/"; |
| } |
| } |
| |
| document.cookie = sFullCookie; |
| } |
| |
| /* |
| * Function: _fnReadCookie |
| * Purpose: Read an old cookie to get a cookie with an old table state |
| * Returns: string: - contents of the cookie - or null if no cookie with that name found |
| * Inputs: string:sName - name of the cookie to read |
| */ |
| function _fnReadCookie ( sName ) |
| { |
| var |
| aParts = window.location.pathname.split('/'), |
| sNameEQ = sName + '_' + aParts[aParts.length-1].replace(/[\/:]/g,"").toLowerCase() + '=', |
| sCookieContents = document.cookie.split(';'); |
| |
| for( var i=0 ; i<sCookieContents.length ; i++ ) |
| { |
| var c = sCookieContents[i]; |
| |
| while (c.charAt(0)==' ') |
| { |
| c = c.substring(1,c.length); |
| } |
| |
| if (c.indexOf(sNameEQ) === 0) |
| { |
| return decodeURIComponent( c.substring(sNameEQ.length,c.length) ); |
| } |
| } |
| return null; |
| } |
| |
| /* |
| * Function: _fnDetectHeader |
| * Purpose: Use the DOM source to create up an array of header cells. The idea here is to |
| * create a layout grid (array) of rows x columns, which contains a reference |
| * to the cell that that point in the grid (regardless of col/rowspan), such that |
| * any column / row could be removed and the new grid constructed |
| * Returns: void |
| * Outputs: array object:aLayout - Array to store the calculated layout in |
| * Inputs: node:nThead - The header/footer element for the table |
| */ |
| function _fnDetectHeader ( aLayout, nThead ) |
| { |
| var nTrs = $(nThead).children('tr'); |
| var nCell; |
| var i, j, k, l, iLen, jLen, iColShifted; |
| var fnShiftCol = function ( a, i, j ) { |
| while ( typeof a[i][j] != 'undefined' ) { |
| j++; |
| } |
| return j; |
| }; |
| |
| aLayout.splice( 0, aLayout.length ); |
| |
| /* We know how many rows there are in the layout - so prep it */ |
| for ( i=0, iLen=nTrs.length ; i<iLen ; i++ ) |
| { |
| aLayout.push( [] ); |
| } |
| |
| /* Calculate a layout array */ |
| for ( i=0, iLen=nTrs.length ; i<iLen ; i++ ) |
| { |
| var iColumn = 0; |
| |
| /* For every cell in the row... */ |
| for ( j=0, jLen=nTrs[i].childNodes.length ; j<jLen ; j++ ) |
| { |
| nCell = nTrs[i].childNodes[j]; |
| |
| if ( nCell.nodeName.toUpperCase() == "TD" || |
| nCell.nodeName.toUpperCase() == "TH" ) |
| { |
| /* Get the col and rowspan attributes from the DOM and sanitise them */ |
| var iColspan = nCell.getAttribute('colspan') * 1; |
| var iRowspan = nCell.getAttribute('rowspan') * 1; |
| iColspan = (!iColspan || iColspan===0 || iColspan===1) ? 1 : iColspan; |
| iRowspan = (!iRowspan || iRowspan===0 || iRowspan===1) ? 1 : iRowspan; |
| |
| /* There might be colspan cells already in this row, so shift our target |
| * accordingly |
| */ |
| iColShifted = fnShiftCol( aLayout, i, iColumn ); |
| |
| /* If there is col / rowspan, copy the information into the layout grid */ |
| for ( l=0 ; l<iColspan ; l++ ) |
| { |
| for ( k=0 ; k<iRowspan ; k++ ) |
| { |
| aLayout[i+k][iColShifted+l] = { |
| "cell": nCell, |
| "unique": iColspan == 1 ? true : false |
| }; |
| aLayout[i+k].nTr = nTrs[i]; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| /* |
| * Function: _fnGetUniqueThs |
| * Purpose: Get an array of unique th elements, one for each column |
| * Returns: array node:aReturn - list of unique ths |
| * Inputs: object:oSettings - dataTables settings object |
| * node:nHeader - automatically detect the layout from this node - optional |
| * array object:aLayout - thead/tfoot layout from _fnDetectHeader - optional |
| */ |
| function _fnGetUniqueThs ( oSettings, nHeader, aLayout ) |
| { |
| var aReturn = []; |
| if ( typeof aLayout == 'undefined' ) |
| { |
| aLayout = oSettings.aoHeader; |
| if ( typeof nHeader != 'undefined' ) |
| { |
| aLayout = []; |
| _fnDetectHeader( aLayout, nHeader ); |
| } |
| } |
| |
| for ( var i=0, iLen=aLayout.length ; i<iLen ; i++ ) |
| { |
| for ( var j=0, jLen=aLayout[i].length ; j<jLen ; j++ ) |
| { |
| if ( aLayout[i][j].unique && |
| (typeof aReturn[j] == 'undefined' || !oSettings.bSortCellsTop) ) |
| { |
| aReturn[j] = aLayout[i][j].cell; |
| } |
| } |
| } |
| |
| return aReturn; |
| } |
| |
| /* |
| * Function: _fnScrollBarWidth |
| * Purpose: Get the width of a scroll bar in this browser being used |
| * Returns: int: - width in pixels |
| * Inputs: - |
| * Notes: All credit for this function belongs to Alexandre Gomes. Thanks for sharing! |
| * http://www.alexandre-gomes.com/?p=115 |
| */ |
| function _fnScrollBarWidth () |
| { |
| var inner = document.createElement('p'); |
| var style = inner.style; |
| style.width = "100%"; |
| style.height = "200px"; |
| style.padding = "0px"; |
| |
| var outer = document.createElement('div'); |
| style = outer.style; |
| style.position = "absolute"; |
| style.top = "0px"; |
| style.left = "0px"; |
| style.visibility = "hidden"; |
| style.width = "200px"; |
| style.height = "150px"; |
| style.padding = "0px"; |
| style.overflow = "hidden"; |
| outer.appendChild(inner); |
| |
| document.body.appendChild(outer); |
| var w1 = inner.offsetWidth; |
| outer.style.overflow = 'scroll'; |
| var w2 = inner.offsetWidth; |
| if ( w1 == w2 ) |
| { |
| w2 = outer.clientWidth; |
| } |
| |
| document.body.removeChild(outer); |
| return (w1 - w2); |
| } |
| |
| /* |
| * Function: _fnApplyToChildren |
| * Purpose: Apply a given function to the display child nodes of an element array (typically |
| * TD children of TR rows |
| * Returns: - (done by reference) |
| * Inputs: function:fn - Method to apply to the objects |
| * array nodes:an1 - List of elements to look through for display children |
| * array nodes:an2 - Another list (identical structure to the first) - optional |
| */ |
| function _fnApplyToChildren( fn, an1, an2 ) |
| { |
| for ( var i=0, iLen=an1.length ; i<iLen ; i++ ) |
| { |
| for ( var j=0, jLen=an1[i].childNodes.length ; j<jLen ; j++ ) |
| { |
| if ( an1[i].childNodes[j].nodeType == 1 ) |
| { |
| if ( typeof an2 != 'undefined' ) |
| { |
| fn( an1[i].childNodes[j], an2[i].childNodes[j] ); |
| } |
| else |
| { |
| fn( an1[i].childNodes[j] ); |
| } |
| } |
| } |
| } |
| } |
| |
| /* |
| * Function: _fnMap |
| * Purpose: See if a property is defined on one object, if so assign it to the other object |
| * Returns: - (done by reference) |
| * Inputs: object:oRet - target object |
| * object:oSrc - source object |
| * string:sName - property |
| * string:sMappedName - name to map too - optional, sName used if not given |
| */ |
| function _fnMap( oRet, oSrc, sName, sMappedName ) |
| { |
| if ( typeof sMappedName == 'undefined' ) |
| { |
| sMappedName = sName; |
| } |
| if ( typeof oSrc[sName] != 'undefined' ) |
| { |
| oRet[sMappedName] = oSrc[sName]; |
| } |
| } |
| |
| /* |
| * Function: _fnGetRowData |
| * Purpose: Get an array of data for a given row from the internal data cache |
| * Returns: array: - Data array |
| * Inputs: object:oSettings - dataTables settings object |
| * int:iRow - aoData row id |
| * string:sSpecific - data get type ('type' 'filter' 'sort') |
| */ |
| function _fnGetRowData( oSettings, iRow, sSpecific ) |
| { |
| var out = []; |
| for ( var i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ ) |
| { |
| out.push( _fnGetCellData( oSettings, iRow, i, sSpecific ) ); |
| } |
| return out; |
| } |
| |
| /* |
| * Function: _fnGetCellData |
| * Purpose: Get the data for a given cell from the internal cache, taking into account data mapping |
| * Returns: *: - Cell data |
| * Inputs: object:oSettings - dataTables settings object |
| * int:iRow - aoData row id |
| * int:iCol - Column index |
| * string:sSpecific - data get type ('display', 'type' 'filter' 'sort') |
| */ |
| function _fnGetCellData( oSettings, iRow, iCol, sSpecific ) |
| { |
| var sData; |
| var oCol = oSettings.aoColumns[iCol]; |
| var oData = oSettings.aoData[iRow]._aData; |
| |
| if ( (sData=oCol.fnGetData( oData )) === undefined ) |
| { |
| if ( oSettings.iDrawError != oSettings.iDraw && oCol.sDefaultContent === null ) |
| { |
| _fnLog( oSettings, 0, "Requested unknown parameter '"+oCol.mDataProp+ |
| "' from the data source for row "+iRow ); |
| oSettings.iDrawError = oSettings.iDraw; |
| } |
| return oCol.sDefaultContent; |
| } |
| |
| /* When the data source is null, we can use default column data */ |
| if ( sData === null && oCol.sDefaultContent !== null ) |
| { |
| sData = oCol.sDefaultContent; |
| } |
| else if ( typeof sData == 'function' ) |
| { |
| /* If the data source is a function, then we run it and use the return */ |
| return sData(); |
| } |
| |
| if ( sSpecific == 'display' && sData === null ) |
| { |
| return ''; |
| } |
| return sData; |
| } |
| |
| /* |
| * Function: _fnSetCellData |
| * Purpose: Set the value for a specific cell, into the internal data cache |
| * Returns: *: - Cell data |
| * Inputs: object:oSettings - dataTables settings object |
| * int:iRow - aoData row id |
| * int:iCol - Column index |
| * *:val - Value to set |
| */ |
| function _fnSetCellData( oSettings, iRow, iCol, val ) |
| { |
| var oCol = oSettings.aoColumns[iCol]; |
| var oData = oSettings.aoData[iRow]._aData; |
| |
| oCol.fnSetData( oData, val ); |
| } |
| |
| /* |
| * Function: _fnGetObjectDataFn |
| * Purpose: Return a function that can be used to get data from a source object, taking |
| * into account the ability to use nested objects as a source |
| * Returns: function: - Data get function |
| * Inputs: string|int|function:mSource - The data source for the object |
| */ |
| function _fnGetObjectDataFn( mSource ) |
| { |
| if ( mSource === null ) |
| { |
| /* Give an empty string for rendering / sorting etc */ |
| return function (data) { |
| return null; |
| }; |
| } |
| else if ( typeof mSource == 'function' ) |
| { |
| return function (data) { |
| return mSource( data ); |
| }; |
| } |
| else if ( typeof mSource == 'string' && mSource.indexOf('.') != -1 ) |
| { |
| /* If there is a . in the source string then the data source is in a nested object |
| * we provide two 'quick' functions for the look up to speed up the most common |
| * operation, and a generalised one for when it is needed |
| */ |
| var a = mSource.split('.'); |
| if ( a.length == 2 ) |
| { |
| return function (data) { |
| return data[ a[0] ][ a[1] ]; |
| }; |
| } |
| else if ( a.length == 3 ) |
| { |
| return function (data) { |
| return data[ a[0] ][ a[1] ][ a[2] ]; |
| }; |
| } |
| else |
| { |
| return function (data) { |
| for ( var i=0, iLen=a.length ; i<iLen ; i++ ) |
| { |
| data = data[ a[i] ]; |
| } |
| return data; |
| }; |
| } |
| } |
| else |
| { |
| /* Array or flat object mapping */ |
| return function (data) { |
| return data[mSource]; |
| }; |
| } |
| } |
| |
| /* |
| * Function: _fnSetObjectDataFn |
| * Purpose: Return a function that can be used to set data from a source object, taking |
| * into account the ability to use nested objects as a source |
| * Returns: function: - Data set function |
| * Inputs: string|int|function:mSource - The data source for the object |
| */ |
| function _fnSetObjectDataFn( mSource ) |
| { |
| if ( mSource === null ) |
| { |
| /* Nothing to do when the data source is null */ |
| return function (data, val) {}; |
| } |
| else if ( typeof mSource == 'function' ) |
| { |
| return function (data, val) { |
| return mSource( data, val ); |
| }; |
| } |
| else if ( typeof mSource == 'string' && mSource.indexOf('.') != -1 ) |
| { |
| /* Like the get, we need to get data from a nested object. Again two fast lookup |
| * functions are provided, and a generalised one. |
| */ |
| var a = mSource.split('.'); |
| if ( a.length == 2 ) |
| { |
| return function (data, val) { |
| data[ a[0] ][ a[1] ] = val; |
| }; |
| } |
| else if ( a.length == 3 ) |
| { |
| return function (data, val) { |
| data[ a[0] ][ a[1] ][ a[2] ] = val; |
| }; |
| } |
| else |
| { |
| return function (data, val) { |
| for ( var i=0, iLen=a.length-1 ; i<iLen ; i++ ) |
| { |
| data = data[ a[i] ]; |
| } |
| data[ a[a.length-1] ] = val; |
| }; |
| } |
| } |
| else |
| { |
| /* Array or flat object mapping */ |
| return function (data, val) { |
| data[mSource] = val; |
| }; |
| } |
| } |
| |
| |
| /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
| * Section - API |
| * I'm not happy with this solution... - To be fixed in 2.0 |
| */ |
| this.oApi._fnExternApiFunc = _fnExternApiFunc; |
| this.oApi._fnInitialise = _fnInitialise; |
| this.oApi._fnInitComplete = _fnInitComplete; |
| this.oApi._fnLanguageProcess = _fnLanguageProcess; |
| this.oApi._fnAddColumn = _fnAddColumn; |
| this.oApi._fnColumnOptions = _fnColumnOptions; |
| this.oApi._fnAddData = _fnAddData; |
| this.oApi._fnCreateTr = _fnCreateTr; |
| this.oApi._fnGatherData = _fnGatherData; |
| this.oApi._fnBuildHead = _fnBuildHead; |
| this.oApi._fnDrawHead = _fnDrawHead; |
| this.oApi._fnDraw = _fnDraw; |
| this.oApi._fnReDraw = _fnReDraw; |
| this.oApi._fnAjaxUpdate = _fnAjaxUpdate; |
| this.oApi._fnAjaxParameters = _fnAjaxParameters; |
| this.oApi._fnAjaxUpdateDraw = _fnAjaxUpdateDraw; |
| this.oApi._fnServerParams = _fnServerParams; |
| this.oApi._fnAddOptionsHtml = _fnAddOptionsHtml; |
| this.oApi._fnFeatureHtmlTable = _fnFeatureHtmlTable; |
| this.oApi._fnScrollDraw = _fnScrollDraw; |
| this.oApi._fnAdjustColumnSizing = _fnAdjustColumnSizing; |
| this.oApi._fnFeatureHtmlFilter = _fnFeatureHtmlFilter; |
| this.oApi._fnFilterComplete = _fnFilterComplete; |
| this.oApi._fnFilterCustom = _fnFilterCustom; |
| this.oApi._fnFilterColumn = _fnFilterColumn; |
| this.oApi._fnFilter = _fnFilter; |
| this.oApi._fnBuildSearchArray = _fnBuildSearchArray; |
| this.oApi._fnBuildSearchRow = _fnBuildSearchRow; |
| this.oApi._fnFilterCreateSearch = _fnFilterCreateSearch; |
| this.oApi._fnDataToSearch = _fnDataToSearch; |
| this.oApi._fnSort = _fnSort; |
| this.oApi._fnSortAttachListener = _fnSortAttachListener; |
| this.oApi._fnSortingClasses = _fnSortingClasses; |
| this.oApi._fnFeatureHtmlPaginate = _fnFeatureHtmlPaginate; |
| this.oApi._fnPageChange = _fnPageChange; |
| this.oApi._fnFeatureHtmlInfo = _fnFeatureHtmlInfo; |
| this.oApi._fnUpdateInfo = _fnUpdateInfo; |
| this.oApi._fnFeatureHtmlLength = _fnFeatureHtmlLength; |
| this.oApi._fnFeatureHtmlProcessing = _fnFeatureHtmlProcessing; |
| this.oApi._fnProcessingDisplay = _fnProcessingDisplay; |
| this.oApi._fnVisibleToColumnIndex = _fnVisibleToColumnIndex; |
| this.oApi._fnColumnIndexToVisible = _fnColumnIndexToVisible; |
| this.oApi._fnNodeToDataIndex = _fnNodeToDataIndex; |
| this.oApi._fnVisbleColumns = _fnVisbleColumns; |
| this.oApi._fnCalculateEnd = _fnCalculateEnd; |
| this.oApi._fnConvertToWidth = _fnConvertToWidth; |
| this.oApi._fnCalculateColumnWidths = _fnCalculateColumnWidths; |
| this.oApi._fnScrollingWidthAdjust = _fnScrollingWidthAdjust; |
| this.oApi._fnGetWidestNode = _fnGetWidestNode; |
| this.oApi._fnGetMaxLenString = _fnGetMaxLenString; |
| this.oApi._fnStringToCss = _fnStringToCss; |
| this.oApi._fnArrayCmp = _fnArrayCmp; |
| this.oApi._fnDetectType = _fnDetectType; |
| this.oApi._fnSettingsFromNode = _fnSettingsFromNode; |
| this.oApi._fnGetDataMaster = _fnGetDataMaster; |
| this.oApi._fnGetTrNodes = _fnGetTrNodes; |
| this.oApi._fnGetTdNodes = _fnGetTdNodes; |
| this.oApi._fnEscapeRegex = _fnEscapeRegex; |
| this.oApi._fnDeleteIndex = _fnDeleteIndex; |
| this.oApi._fnReOrderIndex = _fnReOrderIndex; |
| this.oApi._fnColumnOrdering = _fnColumnOrdering; |
| this.oApi._fnLog = _fnLog; |
| this.oApi._fnClearTable = _fnClearTable; |
| this.oApi._fnSaveState = _fnSaveState; |
| this.oApi._fnLoadState = _fnLoadState; |
| this.oApi._fnCreateCookie = _fnCreateCookie; |
| this.oApi._fnReadCookie = _fnReadCookie; |
| this.oApi._fnDetectHeader = _fnDetectHeader; |
| this.oApi._fnGetUniqueThs = _fnGetUniqueThs; |
| this.oApi._fnScrollBarWidth = _fnScrollBarWidth; |
| this.oApi._fnApplyToChildren = _fnApplyToChildren; |
| this.oApi._fnMap = _fnMap; |
| this.oApi._fnGetRowData = _fnGetRowData; |
| this.oApi._fnGetCellData = _fnGetCellData; |
| this.oApi._fnSetCellData = _fnSetCellData; |
| this.oApi._fnGetObjectDataFn = _fnGetObjectDataFn; |
| this.oApi._fnSetObjectDataFn = _fnSetObjectDataFn; |
| |
| |
| /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
| * Section - Constructor |
| */ |
| |
| /* Want to be able to reference "this" inside the this.each function */ |
| var _that = this; |
| return this.each(function() |
| { |
| var i=0, iLen, j, jLen, k, kLen; |
| |
| /* Check to see if we are re-initialising a table */ |
| for ( i=0, iLen=_aoSettings.length ; i<iLen ; i++ ) |
| { |
| /* Base check on table node */ |
| if ( _aoSettings[i].nTable == this ) |
| { |
| if ( typeof oInit == 'undefined' || |
| ( typeof oInit.bRetrieve != 'undefined' && oInit.bRetrieve === true ) ) |
| { |
| return _aoSettings[i].oInstance; |
| } |
| else if ( typeof oInit.bDestroy != 'undefined' && oInit.bDestroy === true ) |
| { |
| _aoSettings[i].oInstance.fnDestroy(); |
| break; |
| } |
| else |
| { |
| _fnLog( _aoSettings[i], 0, "Cannot reinitialise DataTable.\n\n"+ |
| "To retrieve the DataTables object for this table, please pass either no arguments "+ |
| "to the dataTable() function, or set bRetrieve to true. Alternatively, to destory "+ |
| "the old table and create a new one, set bDestroy to true (note that a lot of "+ |
| "changes to the configuration can be made through the API which is usually much "+ |
| "faster)." ); |
| return; |
| } |
| } |
| |
| /* If the element we are initialising has the same ID as a table which was previously |
| * initialised, but the table nodes don't match (from before) then we destory the old |
| * instance by simply deleting it. This is under the assumption that the table has been |
| * destroyed by other methods. Anyone using non-id selectors will need to do this manually |
| */ |
| if ( _aoSettings[i].sTableId !== "" && _aoSettings[i].sTableId == this.getAttribute('id') ) |
| { |
| _aoSettings.splice( i, 1 ); |
| break; |
| } |
| } |
| |
| /* Make a complete and independent copy of the settings object */ |
| var oSettings = new classSettings(); |
| _aoSettings.push( oSettings ); |
| |
| var bInitHandedOff = false; |
| var bUsePassedData = false; |
| |
| /* Set the id */ |
| var sId = this.getAttribute( 'id' ); |
| if ( sId !== null ) |
| { |
| oSettings.sTableId = sId; |
| oSettings.sInstance = sId; |
| } |
| else |
| { |
| oSettings.sInstance = _oExt._oExternConfig.iNextUnique ++; |
| } |
| |
| /* Sanity check */ |
| if ( this.nodeName.toLowerCase() != 'table' ) |
| { |
| _fnLog( oSettings, 0, "Attempted to initialise DataTables on a node which is not a "+ |
| "table: "+this.nodeName ); |
| return; |
| } |
| |
| /* Set the table node */ |
| oSettings.nTable = this; |
| |
| /* Keep a reference to the 'this' instance for the table. Note that if this table is being |
| * created with others, we retrieve a unique instance to ease API access. |
| */ |
| oSettings.oInstance = _that.length == 1 ? _that : $(this).dataTable(); |
| |
| /* Bind the API functions to the settings, so we can perform actions whenever oSettings is |
| * available |
| */ |
| oSettings.oApi = _that.oApi; |
| |
| /* State the table's width for if a destroy is called at a later time */ |
| oSettings.sDestroyWidth = $(this).width(); |
| |
| /* Store the features that we have available */ |
| if ( typeof oInit != 'undefined' && oInit !== null ) |
| { |
| oSettings.oInit = oInit; |
| _fnMap( oSettings.oFeatures, oInit, "bPaginate" ); |
| _fnMap( oSettings.oFeatures, oInit, "bLengthChange" ); |
| _fnMap( oSettings.oFeatures, oInit, "bFilter" ); |
| _fnMap( oSettings.oFeatures, oInit, "bSort" ); |
| _fnMap( oSettings.oFeatures, oInit, "bInfo" ); |
| _fnMap( oSettings.oFeatures, oInit, "bProcessing" ); |
| _fnMap( oSettings.oFeatures, oInit, "bAutoWidth" ); |
| _fnMap( oSettings.oFeatures, oInit, "bSortClasses" ); |
| _fnMap( oSettings.oFeatures, oInit, "bServerSide" ); |
| _fnMap( oSettings.oFeatures, oInit, "bDeferRender" ); |
| _fnMap( oSettings.oScroll, oInit, "sScrollX", "sX" ); |
| _fnMap( oSettings.oScroll, oInit, "sScrollXInner", "sXInner" ); |
| _fnMap( oSettings.oScroll, oInit, "sScrollY", "sY" ); |
| _fnMap( oSettings.oScroll, oInit, "bScrollCollapse", "bCollapse" ); |
| _fnMap( oSettings.oScroll, oInit, "bScrollInfinite", "bInfinite" ); |
| _fnMap( oSettings.oScroll, oInit, "iScrollLoadGap", "iLoadGap" ); |
| _fnMap( oSettings.oScroll, oInit, "bScrollAutoCss", "bAutoCss" ); |
| _fnMap( oSettings, oInit, "asStripClasses", "asStripeClasses" ); // legacy |
| _fnMap( oSettings, oInit, "asStripeClasses" ); |
| _fnMap( oSettings, oInit, "fnPreDrawCallback" ); |
| _fnMap( oSettings, oInit, "fnRowCallback" ); |
| _fnMap( oSettings, oInit, "fnHeaderCallback" ); |
| _fnMap( oSettings, oInit, "fnFooterCallback" ); |
| _fnMap( oSettings, oInit, "fnCookieCallback" ); |
| _fnMap( oSettings, oInit, "fnInitComplete" ); |
| _fnMap( oSettings, oInit, "fnServerData" ); |
| _fnMap( oSettings, oInit, "fnFormatNumber" ); |
| _fnMap( oSettings, oInit, "aaSorting" ); |
| _fnMap( oSettings, oInit, "aaSortingFixed" ); |
| _fnMap( oSettings, oInit, "aLengthMenu" ); |
| _fnMap( oSettings, oInit, "sPaginationType" ); |
| _fnMap( oSettings, oInit, "sAjaxSource" ); |
| _fnMap( oSettings, oInit, "sAjaxDataProp" ); |
| _fnMap( oSettings, oInit, "iCookieDuration" ); |
| _fnMap( oSettings, oInit, "sCookiePrefix" ); |
| _fnMap( oSettings, oInit, "sDom" ); |
| _fnMap( oSettings, oInit, "bSortCellsTop" ); |
| _fnMap( oSettings, oInit, "oSearch", "oPreviousSearch" ); |
| _fnMap( oSettings, oInit, "aoSearchCols", "aoPreSearchCols" ); |
| _fnMap( oSettings, oInit, "iDisplayLength", "_iDisplayLength" ); |
| _fnMap( oSettings, oInit, "bJQueryUI", "bJUI" ); |
| _fnMap( oSettings.oLanguage, oInit, "fnInfoCallback" ); |
| |
| /* Callback functions which are array driven */ |
| if ( typeof oInit.fnDrawCallback == 'function' ) |
| { |
| oSettings.aoDrawCallback.push( { |
| "fn": oInit.fnDrawCallback, |
| "sName": "user" |
| } ); |
| } |
| |
| /* Ajax additional variables are array driven */ |
| if ( typeof oInit.fnServerParams == 'function' ) |
| { |
| oSettings.aoServerParams.push( { |
| "fn": oInit.fnServerParams, |
| "sName": "user" |
| } ); |
| } |
| |
| if ( typeof oInit.fnStateSaveCallback == 'function' ) |
| { |
| oSettings.aoStateSave.push( { |
| "fn": oInit.fnStateSaveCallback, |
| "sName": "user" |
| } ); |
| } |
| |
| if ( typeof oInit.fnStateLoadCallback == 'function' ) |
| { |
| oSettings.aoStateLoad.push( { |
| "fn": oInit.fnStateLoadCallback, |
| "sName": "user" |
| } ); |
| } |
| |
| if ( oSettings.oFeatures.bServerSide && oSettings.oFeatures.bSort && |
| oSettings.oFeatures.bSortClasses ) |
| { |
| /* Enable sort classes for server-side processing. Safe to do it here, since server-side |
| * processing must be enabled by the developer |
| */ |
| oSettings.aoDrawCallback.push( { |
| "fn": _fnSortingClasses, |
| "sName": "server_side_sort_classes" |
| } ); |
| } |
| else if ( oSettings.oFeatures.bDeferRender ) |
| { |
| oSettings.aoDrawCallback.push( { |
| "fn": _fnSortingClasses, |
| "sName": "defer_sort_classes" |
| } ); |
| } |
| |
| if ( typeof oInit.bJQueryUI != 'undefined' && oInit.bJQueryUI ) |
| { |
| /* Use the JUI classes object for display. You could clone the oStdClasses object if |
| * you want to have multiple tables with multiple independent classes |
| */ |
| oSettings.oClasses = _oExt.oJUIClasses; |
| |
| if ( typeof oInit.sDom == 'undefined' ) |
| { |
| /* Set the DOM to use a layout suitable for jQuery UI's theming */ |
| oSettings.sDom = '<"H"lfr>t<"F"ip>'; |
| } |
| } |
| |
| /* Calculate the scroll bar width and cache it for use later on */ |
| if ( oSettings.oScroll.sX !== "" || oSettings.oScroll.sY !== "" ) |
| { |
| oSettings.oScroll.iBarWidth = _fnScrollBarWidth(); |
| } |
| |
| if ( typeof oInit.iDisplayStart != 'undefined' && |
| typeof oSettings.iInitDisplayStart == 'undefined' ) |
| { |
| /* Display start point, taking into account the save saving */ |
| oSettings.iInitDisplayStart = oInit.iDisplayStart; |
| oSettings._iDisplayStart = oInit.iDisplayStart; |
| } |
| |
| /* Must be done after everything which can be overridden by a cookie! */ |
| if ( typeof oInit.bStateSave != 'undefined' ) |
| { |
| oSettings.oFeatures.bStateSave = oInit.bStateSave; |
| _fnLoadState( oSettings, oInit ); |
| oSettings.aoDrawCallback.push( { |
| "fn": _fnSaveState, |
| "sName": "state_save" |
| } ); |
| } |
| |
| if ( typeof oInit.iDeferLoading != 'undefined' ) |
| { |
| oSettings.bDeferLoading = true; |
| oSettings._iRecordsTotal = oInit.iDeferLoading; |
| oSettings._iRecordsDisplay = oInit.iDeferLoading; |
| } |
| |
| if ( typeof oInit.aaData != 'undefined' ) |
| { |
| bUsePassedData = true; |
| } |
| |
| /* Backwards compatability */ |
| /* aoColumns / aoData - remove at some point... */ |
| if ( typeof oInit != 'undefined' && typeof oInit.aoData != 'undefined' ) |
| { |
| oInit.aoColumns = oInit.aoData; |
| } |
| |
| /* Language definitions */ |
| if ( typeof oInit.oLanguage != 'undefined' ) |
| { |
| if ( typeof oInit.oLanguage.sUrl != 'undefined' && oInit.oLanguage.sUrl !== "" ) |
| { |
| /* Get the language definitions from a file */ |
| oSettings.oLanguage.sUrl = oInit.oLanguage.sUrl; |
| $.getJSON( oSettings.oLanguage.sUrl, null, function( json ) { |
| _fnLanguageProcess( oSettings, json, true ); } ); |
| bInitHandedOff = true; |
| } |
| else |
| { |
| _fnLanguageProcess( oSettings, oInit.oLanguage, false ); |
| } |
| } |
| /* Warning: The _fnLanguageProcess function is async to the remainder of this function due |
| * to the XHR. We use _bInitialised in _fnLanguageProcess() to check this the processing |
| * below is complete. The reason for spliting it like this is optimisation - we can fire |
| * off the XHR (if needed) and then continue processing the data. |
| */ |
| } |
| else |
| { |
| /* Create a dummy object for quick manipulation later on. */ |
| oInit = {}; |
| } |
| |
| /* |
| * Stripes |
| * Add the stripe classes now that we know which classes to apply - unless overruled |
| */ |
| if ( typeof oInit.asStripClasses == 'undefined' && |
| typeof oInit.asStripeClasses == 'undefined' ) |
| { |
| oSettings.asStripeClasses.push( oSettings.oClasses.sStripeOdd ); |
| oSettings.asStripeClasses.push( oSettings.oClasses.sStripeEven ); |
| } |
| |
| /* Remove row stripe classes if they are already on the table row */ |
| var bStripeRemove = false; |
| var anRows = $(this).children('tbody').children('tr'); |
| for ( i=0, iLen=oSettings.asStripeClasses.length ; i<iLen ; i++ ) |
| { |
| if ( anRows.filter(":lt(2)").hasClass( oSettings.asStripeClasses[i]) ) |
| { |
| bStripeRemove = true; |
| break; |
| } |
| } |
| |
| if ( bStripeRemove ) |
| { |
| /* Store the classes which we are about to remove so they can be readded on destory */ |
| oSettings.asDestroyStripes = [ '', '' ]; |
| if ( $(anRows[0]).hasClass(oSettings.oClasses.sStripeOdd) ) |
| { |
| oSettings.asDestroyStripes[0] += oSettings.oClasses.sStripeOdd+" "; |
| } |
| if ( $(anRows[0]).hasClass(oSettings.oClasses.sStripeEven) ) |
| { |
| oSettings.asDestroyStripes[0] += oSettings.oClasses.sStripeEven; |
| } |
| if ( $(anRows[1]).hasClass(oSettings.oClasses.sStripeOdd) ) |
| { |
| oSettings.asDestroyStripes[1] += oSettings.oClasses.sStripeOdd+" "; |
| } |
| if ( $(anRows[1]).hasClass(oSettings.oClasses.sStripeEven) ) |
| { |
| oSettings.asDestroyStripes[1] += oSettings.oClasses.sStripeEven; |
| } |
| |
| anRows.removeClass( oSettings.asStripeClasses.join(' ') ); |
| } |
| |
| /* |
| * Columns |
| * See if we should load columns automatically or use defined ones |
| */ |
| var anThs = []; |
| var aoColumnsInit; |
| var nThead = this.getElementsByTagName('thead'); |
| if ( nThead.length !== 0 ) |
| { |
| _fnDetectHeader( oSettings.aoHeader, nThead[0] ); |
| anThs = _fnGetUniqueThs( oSettings ); |
| } |
| |
| /* If not given a column array, generate one with nulls */ |
| if ( typeof oInit.aoColumns == 'undefined' ) |
| { |
| aoColumnsInit = []; |
| for ( i=0, iLen=anThs.length ; i<iLen ; i++ ) |
| { |
| aoColumnsInit.push( null ); |
| } |
| } |
| else |
| { |
| aoColumnsInit = oInit.aoColumns; |
| } |
| |
| /* Add the columns */ |
| for ( i=0, iLen=aoColumnsInit.length ; i<iLen ; i++ ) |
| { |
| /* Check if we have column visibilty state to restore */ |
| if ( typeof oInit.saved_aoColumns != 'undefined' && oInit.saved_aoColumns.length == iLen ) |
| { |
| if ( aoColumnsInit[i] === null ) |
| { |
| aoColumnsInit[i] = {}; |
| } |
| aoColumnsInit[i].bVisible = oInit.saved_aoColumns[i].bVisible; |
| } |
| |
| _fnAddColumn( oSettings, anThs ? anThs[i] : null ); |
| } |
| |
| /* Add options from column definations */ |
| if ( typeof oInit.aoColumnDefs != 'undefined' ) |
| { |
| /* Loop over the column defs array - loop in reverse so first instace has priority */ |
| for ( i=oInit.aoColumnDefs.length-1 ; i>=0 ; i-- ) |
| { |
| /* Each column def can target multiple columns, as it is an array */ |
| var aTargets = oInit.aoColumnDefs[i].aTargets; |
| if ( !$.isArray( aTargets ) ) |
| { |
| _fnLog( oSettings, 1, 'aTargets must be an array of targets, not a '+(typeof aTargets) ); |
| } |
| for ( j=0, jLen=aTargets.length ; j<jLen ; j++ ) |
| { |
| if ( typeof aTargets[j] == 'number' && aTargets[j] >= 0 ) |
| { |
| /* 0+ integer, left to right column counting. We add columns which are unknown |
| * automatically. Is this the right behaviour for this? We should at least |
| * log it in future. We cannot do this for the negative or class targets, only here. |
| */ |
| while( oSettings.aoColumns.length <= aTargets[j] ) |
| { |
| _fnAddColumn( oSettings ); |
| } |
| _fnColumnOptions( oSettings, aTargets[j], oInit.aoColumnDefs[i] ); |
| } |
| else if ( typeof aTargets[j] == 'number' && aTargets[j] < 0 ) |
| { |
| /* Negative integer, right to left column counting */ |
| _fnColumnOptions( oSettings, oSettings.aoColumns.length+aTargets[j], |
| oInit.aoColumnDefs[i] ); |
| } |
| else if ( typeof aTargets[j] == 'string' ) |
| { |
| /* Class name matching on TH element */ |
| for ( k=0, kLen=oSettings.aoColumns.length ; k<kLen ; k++ ) |
| { |
| if ( aTargets[j] == "_all" || |
| $(oSettings.aoColumns[k].nTh).hasClass( aTargets[j] ) ) |
| { |
| _fnColumnOptions( oSettings, k, oInit.aoColumnDefs[i] ); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| /* Add options from column array - after the defs array so this has priority */ |
| if ( typeof aoColumnsInit != 'undefined' ) |
| { |
| for ( i=0, iLen=aoColumnsInit.length ; i<iLen ; i++ ) |
| { |
| _fnColumnOptions( oSettings, i, aoColumnsInit[i] ); |
| } |
| } |
| |
| /* |
| * Sorting |
| * Check the aaSorting array |
| */ |
| for ( i=0, iLen=oSettings.aaSorting.length ; i<iLen ; i++ ) |
| { |
| if ( oSettings.aaSorting[i][0] >= oSettings.aoColumns.length ) |
| { |
| oSettings.aaSorting[i][0] = 0; |
| } |
| var oColumn = oSettings.aoColumns[ oSettings.aaSorting[i][0] ]; |
| |
| /* Add a default sorting index */ |
| if ( typeof oSettings.aaSorting[i][2] == 'undefined' ) |
| { |
| oSettings.aaSorting[i][2] = 0; |
| } |
| |
| /* If aaSorting is not defined, then we use the first indicator in asSorting */ |
| if ( typeof oInit.aaSorting == "undefined" && |
| typeof oSettings.saved_aaSorting == "undefined" ) |
| { |
| oSettings.aaSorting[i][1] = oColumn.asSorting[0]; |
| } |
| |
| /* Set the current sorting index based on aoColumns.asSorting */ |
| for ( j=0, jLen=oColumn.asSorting.length ; j<jLen ; j++ ) |
| { |
| if ( oSettings.aaSorting[i][1] == oColumn.asSorting[j] ) |
| { |
| oSettings.aaSorting[i][2] = j; |
| break; |
| } |
| } |
| } |
| |
| /* Do a first pass on the sorting classes (allows any size changes to be taken into |
| * account, and also will apply sorting disabled classes if disabled |
| */ |
| _fnSortingClasses( oSettings ); |
| |
| /* |
| * Final init |
| * Cache the header, body and footer as required, creating them if needed |
| */ |
| var thead = $(this).children('thead'); |
| if ( thead.length === 0 ) |
| { |
| thead = [ document.createElement( 'thead' ) ]; |
| this.appendChild( thead[0] ); |
| } |
| oSettings.nTHead = thead[0]; |
| |
| var tbody = $(this).children('tbody'); |
| if ( tbody.length === 0 ) |
| { |
| tbody = [ document.createElement( 'tbody' ) ]; |
| this.appendChild( tbody[0] ); |
| } |
| oSettings.nTBody = tbody[0]; |
| |
| var tfoot = $(this).children('tfoot'); |
| if ( tfoot.length > 0 ) |
| { |
| oSettings.nTFoot = tfoot[0]; |
| _fnDetectHeader( oSettings.aoFooter, oSettings.nTFoot ); |
| } |
| |
| /* Check if there is data passing into the constructor */ |
| if ( bUsePassedData ) |
| { |
| for ( i=0 ; i<oInit.aaData.length ; i++ ) |
| { |
| _fnAddData( oSettings, oInit.aaData[ i ] ); |
| } |
| } |
| else |
| { |
| /* Grab the data from the page */ |
| _fnGatherData( oSettings ); |
| } |
| |
| /* Copy the data index array */ |
| oSettings.aiDisplay = oSettings.aiDisplayMaster.slice(); |
| |
| /* Initialisation complete - table can be drawn */ |
| oSettings.bInitialised = true; |
| |
| /* Check if we need to initialise the table (it might not have been handed off to the |
| * language processor) |
| */ |
| if ( bInitHandedOff === false ) |
| { |
| _fnInitialise( oSettings ); |
| } |
| }); |
| }; |
| })(jQuery, window, document); |