https://cgu-odisha.ac.in/wp-content/themes/cgu-child/js/cdn.datatables.net_1.13.4_js_jquery.dataTables.js

1
2 * ©2008-2023 SpryMedia Ltd - datatables.net/license
3 */
4
5/**
6 * @summary     DataTables
7 * @description Paginate, search and order HTML tables
8 * @version     1.13.4
9 * @author      SpryMedia Ltd
10 * @contact     www.datatables.net
11 * @copyright   SpryMedia Ltd.
12 *
13 * This source file is free software, available under the following license:
14 *   MIT license - http://datatables.net/license
15 *
16 * This source file is distributed in the hope that it will be useful, but
17 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
18 * or FITNESS FOR A PARTICULAR PURPOSE. See the license files for details.
19 *
20 * For details please refer to: http://www.datatables.net
21 */
22
23/*jslint evil: true, undef: true, browser: true */
24/*globals $,require,jQuery,define,_selector_run,_selector_opts,_selector_first,_selector_row_indexes,_ext,_Api,_api_register,_api_registerPlural,_re_new_lines,_re_html,_re_formatted_numeric,_re_escape_regex,_empty,_intVal,_numToDecimal,_isNumber,_isHtml,_htmlNumeric,_pluck,_pluck_order,_range,_stripHtml,_unique,_fnBuildAjax,_fnAjaxUpdate,_fnAjaxParameters,_fnAjaxUpdateDraw,_fnAjaxDataSrc,_fnAddColumn,_fnColumnOptions,_fnAdjustColumnSizing,_fnVisibleToColumnIndex,_fnColumnIndexToVisible,_fnVisbleColumns,_fnGetColumns,_fnColumnTypes,_fnApplyColumnDefs,_fnHungarianMap,_fnCamelToHungarian,_fnLanguageCompat,_fnBrowserDetect,_fnAddData,_fnAddTr,_fnNodeToDataIndex,_fnNodeToColumnIndex,_fnGetCellData,_fnSetCellData,_fnSplitObjNotation,_fnGetObjectDataFn,_fnSetObjectDataFn,_fnGetDataMaster,_fnClearTable,_fnDeleteIndex,_fnInvalidate,_fnGetRowElements,_fnCreateTr,_fnBuildHead,_fnDrawHead,_fnDraw,_fnReDraw,_fnAddOptionsHtml,_fnDetectHeader,_fnGetUniqueThs,_fnFeatureHtmlFilter,_fnFilterComplete,_fnFilterCustom,_fnFilterColumn,_fnFilter,_fnFilterCreateSearch,_fnEscapeRegex,_fnFilterData,_fnFeatureHtmlInfo,_fnUpdateInfo,_fnInfoMacros,_fnInitialise,_fnInitComplete,_fnLengthChange,_fnFeatureHtmlLength,_fnFeatureHtmlPaginate,_fnPageChange,_fnFeatureHtmlProcessing,_fnProcessingDisplay,_fnFeatureHtmlTable,_fnScrollDraw,_fnApplyToChildren,_fnCalculateColumnWidths,_fnThrottle,_fnConvertToWidth,_fnGetWidestNode,_fnGetMaxLenString,_fnStringToCss,_fnSortFlatten,_fnSort,_fnSortAria,_fnSortListener,_fnSortAttachListener,_fnSortingClasses,_fnSortData,_fnSaveState,_fnLoadState,_fnSettingsFromNode,_fnLog,_fnMap,_fnBindAction,_fnCallbackReg,_fnCallbackFire,_fnLengthOverflow,_fnRenderer,_fnDataSource,_fnRowAttributes*/
25
26(function( factory ) {
27	"use strict";
28
29	if ( typeof define === 'function' && define.amd ) {
30		// AMD
31		define( ['jquery'], function ( $ ) {
32			return factory( $, window, document );
33		} );
34	}
35	else if ( typeof exports === 'object' ) {
36		// CommonJS
37		// jQuery's factory checks for a global window - if it isn't present then it
38		// returns a factory function that expects the window object
39		var jq = require('jquery');
40
41		if (typeof window !== 'undefined') {
42			module.exports = function (root, $) {
43				if ( ! root ) {
44					// CommonJS environments without a window global must pass a
45					// root. This will give an error otherwise
46					root = window;
47				}
48
49				if ( ! $ ) {
50					$ = jq( root );
51				}
52
53				return factory( $, root, root.document );
54			};
55		}
56		else {
57			return factory( jq, window, window.document );
58		}
59	}
60	else {
61		// Browser
62		window.DataTable = factory( jQuery, window, document );
63	}
64}
65(function( $, window, document, undefined ) {
66	"use strict";
67
68	
69	var DataTable = function ( selector, options )
70	{
71		// Check if called with a window or jQuery object for DOM less applications
72		// This is for backwards compatibility
73		if (DataTable.factory(selector, options)) {
74			return DataTable;
75		}
76	
77		// When creating with `new`, create a new DataTable, returning the API instance
78		if (this instanceof DataTable) {
79			return $(selector).DataTable(options);
80		}
81		else {
82			// Argument switching
83			options = selector;
84		}
85	
86		/**
87		 * Perform a jQuery selector action on the table's TR elements (from the tbody) and
88		 * return the resulting jQuery object.
89		 *  @param {string|node|jQuery} sSelector jQuery selector or node collection to act on
90		 *  @param {object} [oOpts] Optional parameters for modifying the rows to be included
91		 *  @param {string} [oOpts.filter=none] Select TR elements that meet the current filter
92		 *    criterion ("applied") or all TR elements (i.e. no filter).
93		 *  @param {string} [oOpts.order=current] Order of the TR elements in the processed array.
94		 *    Can be either 'current', whereby the current sorting of the table is used, or
95		 *    'original' whereby the original order the data was read into the table is used.
96		 *  @param {string} [oOpts.page=all] Limit the selection to the currently displayed page
97		 *    ("current") or not ("all"). If 'current' is given, then order is assumed to be
98		 *    'current' and filter is 'applied', regardless of what they might be given as.
99		 *  @returns {object} jQuery object, filtered by the given selector.
100		 *  @dtopt API
101		 *  @deprecated Since v1.10
102		 *
103		 *  @example
104		 *    $(document).ready(function() {
105		 *      var oTable = $('#example').dataTable();
106		 *
107		 *      // Highlight every second row
108		 *      oTable.$('tr:odd').css('backgroundColor', 'blue');
109		 *    } );
110		 *
111		 *  @example
112		 *    $(document).ready(function() {
113		 *      var oTable = $('#example').dataTable();
114		 *
115		 *      // Filter to rows with 'Webkit' in them, add a background colour and then
116		 *      // remove the filter, thus highlighting the 'Webkit' rows only.
117		 *      oTable.fnFilter('Webkit');
118		 *      oTable.$('tr', {"search": "applied"}).css('backgroundColor', 'blue');
119		 *      oTable.fnFilter('');
120		 *    } );
121		 */
122		this.$ = function ( sSelector, oOpts )
123		{
124			return this.api(true).$( sSelector, oOpts );
125		};
126		
127		
128		/**
129		 * Almost identical to $ in operation, but in this case returns the data for the matched
130		 * rows - as such, the jQuery selector used should match TR row nodes or TD/TH cell nodes
131		 * rather than any descendants, so the data can be obtained for the row/cell. If matching
132		 * rows are found, the data returned is the original data array/object that was used to
133		 * create the row (or a generated array if from a DOM source).
134		 *
135		 * This method is often useful in-combination with $ where both functions are given the
136		 * same parameters and the array indexes will match identically.
137		 *  @param {string|node|jQuery} sSelector jQuery selector or node collection to act on
138		 *  @param {object} [oOpts] Optional parameters for modifying the rows to be included
139		 *  @param {string} [oOpts.filter=none] Select elements that meet the current filter
140		 *    criterion ("applied") or all elements (i.e. no filter).
141		 *  @param {string} [oOpts.order=current] Order of the data in the processed array.
142		 *    Can be either 'current', whereby the current sorting of the table is used, or
143		 *    'original' whereby the original order the data was read into the table is used.
144		 *  @param {string} [oOpts.page=all] Limit the selection to the currently displayed page
145		 *    ("current") or not ("all"). If 'current' is given, then order is assumed to be
146		 *    'current' and filter is 'applied', regardless of what they might be given as.
147		 *  @returns {array} Data for the matched elements. If any elements, as a result of the
148		 *    selector, were not TR, TD or TH elements in the DataTable, they will have a null
149		 *    entry in the array.
150		 *  @dtopt API
151		 *  @deprecated Since v1.10
152		 *
153		 *  @example
154		 *    $(document).ready(function() {
155		 *      var oTable = $('#example').dataTable();
156		 *
157		 *      // Get the data from the first row in the table
158		 *      var data = oTable._('tr:first');
159		 *
160		 *      // Do something useful with the data
161		 *      alert( "First cell is: "+data[0] );
162		 *    } );
163		 *
164		 *  @example
165		 *    $(document).ready(function() {
166		 *      var oTable = $('#example').dataTable();
167		 *
168		 *      // Filter to 'Webkit' and get all data for
169		 *      oTable.fnFilter('Webkit');
170		 *      var data = oTable._('tr', {"search": "applied"});
171		 *
172		 *      // Do something with the data
173		 *      alert( data.length+" rows matched the search" );
174		 *    } );
175		 */
176		this._ = function ( sSelector, oOpts )
177		{
178			return this.api(true).rows( sSelector, oOpts ).data();
179		};
180		
181		
182		/**
183		 * Create a DataTables Api instance, with the currently selected tables for
184		 * the Api's context.
185		 * @param {boolean} [traditional=false] Set the API instance's context to be
186		 *   only the table referred to by the `DataTable.ext.iApiIndex` option, as was
187		 *   used in the API presented by DataTables 1.9- (i.e. the traditional mode),
188		 *   or if all tables captured in the jQuery object should be used.
189		 * @return {DataTables.Api}
190		 */
191		this.api = function ( traditional )
192		{
193			return traditional ?
194				new _Api(
195					_fnSettingsFromNode( this[ _ext.iApiIndex ] )
196				) :
197				new _Api( this );
198		};
199		
200		
201		/**
202		 * Add a single new row or multiple rows of data to the table. Please note
203		 * that this is suitable for client-side processing only - if you are using
204		 * server-side processing (i.e. "bServerSide": true), then to add data, you
205		 * must add it to the data source, i.e. the server-side, through an Ajax call.
206		 *  @param {array|object} data The data to be added to the table. This can be:
207		 *    <ul>
208		 *      <li>1D array of data - add a single row with the data provided</li>
209		 *      <li>2D array of arrays - add multiple rows in a single call</li>
210		 *      <li>object - data object when using <i>mData</i></li>
211		 *      <li>array of objects - multiple data objects when using <i>mData</i></li>
212		 *    </ul>
213		 *  @param {bool} [redraw=true] redraw the table or not
214		 *  @returns {array} An array of integers, representing the list of indexes in
215		 *    <i>aoData</i> ({@link DataTable.models.oSettings}) that have been added to
216		 *    the table.
217		 *  @dtopt API
218		 *  @deprecated Since v1.10
219		 *
220		 *  @example
221		 *    // Global var for counter
222		 *    var giCount = 2;
223		 *
224		 *    $(document).ready(function() {
225		 *      $('#example').dataTable();
226		 *    } );
227		 *
228		 *    function fnClickAddRow() {
229		 *      $('#example').dataTable().fnAddData( [
230		 *        giCount+".1",
231		 *        giCount+".2",
232		 *        giCount+".3",
233		 *        giCount+".4" ]
234		 *      );
235		 *
236		 *      giCount++;
237		 *    }
238		 */
239		this.fnAddData = function( data, redraw )
240		{
241			var api = this.api( true );
242		
243			/* Check if we want to add multiple rows or not */
244			var rows = Array.isArray(data) && ( Array.isArray(data[0]) || $.isPlainObject(data[0]) ) ?
245				api.rows.add( data ) :
246				api.row.add( data );
247		
248			if ( redraw === undefined || redraw ) {
249				api.draw();
250			}
251		
252			return rows.flatten().toArray();
253		};
254		
255		
256		/**
257		 * This function will make DataTables recalculate the column sizes, based on the data
258		 * contained in the table and the sizes applied to the columns (in the DOM, CSS or
259		 * through the sWidth parameter). This can be useful when the width of the table's
260		 * parent element changes (for example a window resize).
261		 *  @param {boolean} [bRedraw=true] Redraw the table or not, you will typically want to
262		 *  @dtopt API
263		 *  @deprecated Since v1.10
264		 *
265		 *  @example
266		 *    $(document).ready(function() {
267		 *      var oTable = $('#example').dataTable( {
268		 *        "sScrollY": "200px",
269		 *        "bPaginate": false
270		 *      } );
271		 *
272		 *      $(window).on('resize', function () {
273		 *        oTable.fnAdjustColumnSizing();
274		 *      } );
275		 *    } );
276		 */
277		this.fnAdjustColumnSizing = function ( bRedraw )
278		{
279			var api = this.api( true ).columns.adjust();
280			var settings = api.settings()[0];
281			var scroll = settings.oScroll;
282		
283			if ( bRedraw === undefined || bRedraw ) {
284				api.draw( false );
285			}
286			else if ( scroll.sX !== "" || scroll.sY !== "" ) {
287				/* If not redrawing, but scrolling, we want to apply the new column sizes anyway */
288				_fnScrollDraw( settings );
289			}
290		};
291		
292		
293		/**
294		 * Quickly and simply clear a table
295		 *  @param {bool} [bRedraw=true] redraw the table or not
296		 *  @dtopt API
297		 *  @deprecated Since v1.10
298		 *
299		 *  @example
300		 *    $(document).ready(function() {
301		 *      var oTable = $('#example').dataTable();
302		 *
303		 *      // Immediately 'nuke' the current rows (perhaps waiting for an Ajax callback...)
304		 *      oTable.fnClearTable();
305		 *    } );
306		 */
307		this.fnClearTable = function( bRedraw )
308		{
309			var api = this.api( true ).clear();
310		
311			if ( bRedraw === undefined || bRedraw ) {
312				api.draw();
313			}
314		};
315		
316		
317		/**
318		 * The exact opposite of 'opening' a row, this function will close any rows which
319		 * are currently 'open'.
320		 *  @param {node} nTr the table row to 'close'
321		 *  @returns {int} 0 on success, or 1 if failed (can't find the row)
322		 *  @dtopt API
323		 *  @deprecated Since v1.10
324		 *
325		 *  @example
326		 *    $(document).ready(function() {
327		 *      var oTable;
328		 *
329		 *      // 'open' an information row when a row is clicked on
330		 *      $('#example tbody tr').click( function () {
331		 *        if ( oTable.fnIsOpen(this) ) {
332		 *          oTable.fnClose( this );
333		 *        } else {
334		 *          oTable.fnOpen( this, "Temporary row opened", "info_row" );
335		 *        }
336		 *      } );
337		 *
338		 *      oTable = $('#example').dataTable();
339		 *    } );
340		 */
341		this.fnClose = function( nTr )
342		{
343			this.api( true ).row( nTr ).child.hide();
344		};
345		
346		
347		/**
348		 * Remove a row for the table
349		 *  @param {mixed} target The index of the row from aoData to be deleted, or
350		 *    the TR element you want to delete
351		 *  @param {function|null} [callBack] Callback function
352		 *  @param {bool} [redraw=true] Redraw the table or not
353		 *  @returns {array} The row that was deleted
354		 *  @dtopt API
355		 *  @deprecated Since v1.10
356		 *
357		 *  @example
358		 *    $(document).ready(function() {
359		 *      var oTable = $('#example').dataTable();
360		 *
361		 *      // Immediately remove the first row
362		 *      oTable.fnDeleteRow( 0 );
363		 *    } );
364		 */
365		this.fnDeleteRow = function( target, callback, redraw )
366		{
367			var api = this.api( true );
368			var rows = api.rows( target );
369			var settings = rows.settings()[0];
370			var data = settings.aoData[ rows[0][0] ];
371		
372			rows.remove();
373		
374			if ( callback ) {
375				callback.call( this, settings, data );
376			}
377		
378			if ( redraw === undefined || redraw ) {
379				api.draw();
380			}
381		
382			return data;
383		};
384		
385		
386		/**
387		 * Restore the table to it's original state in the DOM by removing all of DataTables
388		 * enhancements, alterations to the DOM structure of the table and event listeners.
389		 *  @param {boolean} [remove=false] Completely remove the table from the DOM
390		 *  @dtopt API
391		 *  @deprecated Since v1.10
392		 *
393		 *  @example
394		 *    $(document).ready(function() {
395		 *      // This example is fairly pointless in reality, but shows how fnDestroy can be used
396		 *      var oTable = $('#example').dataTable();
397		 *      oTable.fnDestroy();
398		 *    } );
399		 */
400		this.fnDestroy = function ( remove )
401		{
402			this.api( true ).destroy( remove );
403		};
404		
405		
406		/**
407		 * Redraw the table
408		 *  @param {bool} [complete=true] Re-filter and resort (if enabled) the table before the draw.
409		 *  @dtopt API
410		 *  @deprecated Since v1.10
411		 *
412		 *  @example
413		 *    $(document).ready(function() {
414		 *      var oTable = $('#example').dataTable();
415		 *
416		 *      // Re-draw the table - you wouldn't want to do it here, but it's an example :-)
417		 *      oTable.fnDraw();
418		 *    } );
419		 */
420		this.fnDraw = function( complete )
421		{
422			// Note that this isn't an exact match to the old call to _fnDraw - it takes
423			// into account the new data, but can hold position.
424			this.api( true ).draw( complete );
425		};
426		
427		
428		/**
429		 * Filter the input based on data
430		 *  @param {string} sInput String to filter the table on
431		 *  @param {int|null} [iColumn] Column to limit filtering to
432		 *  @param {bool} [bRegex=false] Treat as regular expression or not
433		 *  @param {bool} [bSmart=true] Perform smart filtering or not
434		 *  @param {bool} [bShowGlobal=true] Show the input global filter in it's input box(es)
435		 *  @param {bool} [bCaseInsensitive=true] Do case-insensitive matching (true) or not (false)
436		 *  @dtopt API
437		 *  @deprecated Since v1.10
438		 *
439		 *  @example
440		 *    $(document).ready(function() {
441		 *      var oTable = $('#example').dataTable();
442		 *
443		 *      // Sometime later - filter...
444		 *      oTable.fnFilter( 'test string' );
445		 *    } );
446		 */
447		this.fnFilter = function( sInput, iColumn, bRegex, bSmart, bShowGlobal, bCaseInsensitive )
448		{
449			var api = this.api( true );
450		
451			if ( iColumn === null || iColumn === undefined ) {
452				api.search( sInput, bRegex, bSmart, bCaseInsensitive );
453			}
454			else {
455				api.column( iColumn ).search( sInput, bRegex, bSmart, bCaseInsensitive );
456			}
457		
458			api.draw();
459		};
460		
461		
462		/**
463		 * Get the data for the whole table, an individual row or an individual cell based on the
464		 * provided parameters.
465		 *  @param {int|node} [src] A TR row node, TD/TH cell node or an integer. If given as
466		 *    a TR node then the data source for the whole row will be returned. If given as a
467		 *    TD/TH cell node then iCol will be automatically calculated and the data for the
468		 *    cell returned. If given as an integer, then this is treated as the aoData internal
469		 *    data index for the row (see fnGetPosition) and the data for that row used.
470		 *  @param {int} [col] Optional column index that you want the data of.
471		 *  @returns {array|object|string} If mRow is undefined, then the data for all rows is
472		 *    returned. If mRow is defined, just data for that row, and is iCol is
473		 *    defined, only data for the designated cell is returned.
474		 *  @dtopt API
475		 *  @deprecated Since v1.10
476		 *
477		 *  @example
478		 *    // Row data
479		 *    $(document).ready(function() {
480		 *      oTable = $('#example').dataTable();
481		 *
482		 *      oTable.$('tr').click( function () {
483		 *        var data = oTable.fnGetData( this );
484		 *        // ... do something with the array / object of data for the row
485		 *      } );
486		 *    } );
487		 *
488		 *  @example
489		 *    // Individual cell data
490		 *    $(document).ready(function() {
491		 *      oTable = $('#example').dataTable();
492		 *
493		 *      oTable.$('td').click( function () {
494		 *        var sData = oTable.fnGetData( this );
495		 *        alert( 'The cell clicked on had the value of '+sData );
496		 *      } );
497		 *    } );
498		 */
499		this.fnGetData = function( src, col )
500		{
501			var api = this.api( true );
502		
503			if ( src !== undefined ) {
504				var type = src.nodeName ? src.nodeName.toLowerCase() : '';
505		
506				return col !== undefined || type == 'td' || type == 'th' ?
507					api.cell( src, col ).data() :
508					api.row( src ).data() || null;
509			}
510		
511			return api.data().toArray();
512		};
513		
514		
515		/**
516		 * Get an array of the TR nodes that are used in the table's body. Note that you will
517		 * typically want to use the '$' API method in preference to this as it is more
518		 * flexible.
519		 *  @param {int} [iRow] Optional row index for the TR element you want
520		 *  @returns {array|node} If iRow is undefined, returns an array of all TR elements
521		 *    in the table's body, or iRow is defined, just the TR element requested.
522		 *  @dtopt API
523		 *  @deprecated Since v1.10
524		 *
525		 *  @example
526		 *    $(document).ready(function() {
527		 *      var oTable = $('#example').dataTable();
528		 *
529		 *      // Get the nodes from the table
530		 *      var nNodes = oTable.fnGetNodes( );
531		 *    } );
532		 */
533		this.fnGetNodes = function( iRow )
534		{
535			var api = this.api( true );
536		
537			return iRow !== undefined ?
538				api.row( iRow ).node() :
539				api.rows().nodes().flatten().toArray();
540		};
541		
542		
543		/**
544		 * Get the array indexes of a particular cell from it's DOM element
545		 * and column index including hidden columns
546		 *  @param {node} node this can either be a TR, TD or TH in the table's body
547		 *  @returns {int} If nNode is given as a TR, then a single index is returned, or
548		 *    if given as a cell, an array of [row index, column index (visible),
549		 *    column index (all)] is given.
550		 *  @dtopt API
551		 *  @deprecated Since v1.10
552		 *
553		 *  @example
554		 *    $(document).ready(function() {
555		 *      $('#example tbody td').click( function () {
556		 *        // Get the position of the current data from the node
557		 *        var aPos = oTable.fnGetPosition( this );
558		 *
559		 *        // Get the data array for this row
560		 *        var aData = oTable.fnGetData( aPos[0] );
561		 *
562		 *        // Update the data array and return the value
563		 *        aData[ aPos[1] ] = 'clicked';
564		 *        this.innerHTML = 'clicked';
565		 *      } );
566		 *
567		 *      // Init DataTables
568		 *      oTable = $('#example').dataTable();
569		 *    } );
570		 */
571		this.fnGetPosition = function( node )
572		{
573			var api = this.api( true );
574			var nodeName = node.nodeName.toUpperCase();
575		
576			if ( nodeName == 'TR' ) {
577				return api.row( node ).index();
578			}
579			else if ( nodeName == 'TD' || nodeName == 'TH' ) {
580				var cell = api.cell( node ).index();
581		
582				return [
583					cell.row,
584					cell.columnVisible,
585					cell.column
586				];
587			}
588			return null;
589		};
590		
591		
592		/**
593		 * Check to see if a row is 'open' or not.
594		 *  @param {node} nTr the table row to check
595		 *  @returns {boolean} true if the row is currently open, false otherwise
596		 *  @dtopt API
597		 *  @deprecated Since v1.10
598		 *
599		 *  @example
600		 *    $(document).ready(function() {
601		 *      var oTable;
602		 *
603		 *      // 'open' an information row when a row is clicked on
604		 *      $('#example tbody tr').click( function () {
605		 *        if ( oTable.fnIsOpen(this) ) {
606		 *          oTable.fnClose( this );
607		 *        } else {
608		 *          oTable.fnOpen( this, "Temporary row opened", "info_row" );
609		 *        }
610		 *      } );
611		 *
612		 *      oTable = $('#example').dataTable();
613		 *    } );
614		 */
615		this.fnIsOpen = function( nTr )
616		{
617			return this.api( true ).row( nTr ).child.isShown();
618		};
619		
620		
621		/**
622		 * This function will place a new row directly after a row which is currently
623		 * on display on the page, with the HTML contents that is passed into the
624		 * function. This can be used, for example, to ask for confirmation that a
625		 * particular record should be deleted.
626		 *  @param {node} nTr The table row to 'open'
627		 *  @param {string|node|jQuery} mHtml The HTML to put into the row
628		 *  @param {string} sClass Class to give the new TD cell
629		 *  @returns {node} The row opened. Note that if the table row passed in as the
630		 *    first parameter, is not found in the table, this method will silently
631		 *    return.
632		 *  @dtopt API
633		 *  @deprecated Since v1.10
634		 *
635		 *  @example
636		 *    $(document).ready(function() {
637		 *      var oTable;
638		 *
639		 *      // 'open' an information row when a row is clicked on
640		 *      $('#example tbody tr').click( function () {
641		 *        if ( oTable.fnIsOpen(this) ) {
642		 *          oTable.fnClose( this );
643		 *        } else {
644		 *          oTable.fnOpen( this, "Temporary row opened", "info_row" );
645		 *        }
646		 *      } );
647		 *
648		 *      oTable = $('#example').dataTable();
649		 *    } );
650		 */
651		this.fnOpen = function( nTr, mHtml, sClass )
652		{
653			return this.api( true )
654				.row( nTr )
655				.child( mHtml, sClass )
656				.show()
657				.child()[0];
658		};
659		
660		
661		/**
662		 * Change the pagination - provides the internal logic for pagination in a simple API
663		 * function. With this function you can have a DataTables table go to the next,
664		 * previous, first or last pages.
665		 *  @param {string|int} mAction Paging action to take: "first", "previous", "next" or "last"
666		 *    or page number to jump to (integer), note that page 0 is the first page.
667		 *  @param {bool} [bRedraw=true] Redraw the table or not
668		 *  @dtopt API
669		 *  @deprecated Since v1.10
670		 *
671		 *  @example
672		 *    $(document).ready(function() {
673		 *      var oTable = $('#example').dataTable();
674		 *      oTable.fnPageChange( 'next' );
675		 *    } );
676		 */
677		this.fnPageChange = function ( mAction, bRedraw )
678		{
679			var api = this.api( true ).page( mAction );
680		
681			if ( bRedraw === undefined || bRedraw ) {
682				api.draw(false);
683			}
684		};
685		
686		
687		/**
688		 * Show a particular column
689		 *  @param {int} iCol The column whose display should be changed
690		 *  @param {bool} bShow Show (true) or hide (false) the column
691		 *  @param {bool} [bRedraw=true] Redraw the table or not
692		 *  @dtopt API
693		 *  @deprecated Since v1.10
694		 *
695		 *  @example
696		 *    $(document).ready(function() {
697		 *      var oTable = $('#example').dataTable();
698		 *
699		 *      // Hide the second column after initialisation
700		 *      oTable.fnSetColumnVis( 1, false );
701		 *    } );
702		 */
703		this.fnSetColumnVis = function ( iCol, bShow, bRedraw )
704		{
705			var api = this.api( true ).column( iCol ).visible( bShow );
706		
707			if ( bRedraw === undefined || bRedraw ) {
708				api.columns.adjust().draw();
709			}
710		};
711		
712		
713		/**
714		 * Get the settings for a particular table for external manipulation
715		 *  @returns {object} DataTables settings object. See
716		 *    {@link DataTable.models.oSettings}
717		 *  @dtopt API
718		 *  @deprecated Since v1.10
719		 *
720		 *  @example
721		 *    $(document).ready(function() {
722		 *      var oTable = $('#example').dataTable();
723		 *      var oSettings = oTable.fnSettings();
724		 *
725		 *      // Show an example parameter from the settings
726		 *      alert( oSettings._iDisplayStart );
727		 *    } );
728		 */
729		this.fnSettings = function()
730		{
731			return _fnSettingsFromNode( this[_ext.iApiIndex] );
732		};
733		
734		
735		/**
736		 * Sort the table by a particular column
737		 *  @param {int} iCol the data index to sort on. Note that this will not match the
738		 *    'display index' if you have hidden data entries
739		 *  @dtopt API
740		 *  @deprecated Since v1.10
741		 *
742		 *  @example
743		 *    $(document).ready(function() {
744		 *      var oTable = $('#example').dataTable();
745		 *
746		 *      // Sort immediately with columns 0 and 1
747		 *      oTable.fnSort( [ [0,'asc'], [1,'asc'] ] );
748		 *    } );
749		 */
750		this.fnSort = function( aaSort )
751		{
752			this.api( true ).order( aaSort ).draw();
753		};
754		
755		
756		/**
757		 * Attach a sort listener to an element for a given column
758		 *  @param {node} nNode the element to attach the sort listener to
759		 *  @param {int} iColumn the column that a click on this node will sort on
760		 *  @param {function} [fnCallback] callback function when sort is run
761		 *  @dtopt API
762		 *  @deprecated Since v1.10
763		 *
764		 *  @example
765		 *    $(document).ready(function() {
766		 *      var oTable = $('#example').dataTable();
767		 *
768		 *      // Sort on column 1, when 'sorter' is clicked on
769		 *      oTable.fnSortListener( document.getElementById('sorter'), 1 );
770		 *    } );
771		 */
772		this.fnSortListener = function( nNode, iColumn, fnCallback )
773		{
774			this.api( true ).order.listener( nNode, iColumn, fnCallback );
775		};
776		
777		
778		/**
779		 * Update a table cell or row - this method will accept either a single value to
780		 * update the cell with, an array of values with one element for each column or
781		 * an object in the same format as the original data source. The function is
782		 * self-referencing in order to make the multi column updates easier.
783		 *  @param {object|array|string} mData Data to update the cell/row with
784		 *  @param {node|int} mRow TR element you want to update or the aoData index
785		 *  @param {int} [iColumn] The column to update, give as null or undefined to
786		 *    update a whole row.
787		 *  @param {bool} [bRedraw=true] Redraw the table or not
788		 *  @param {bool} [bAction=true] Perform pre-draw actions or not
789		 *  @returns {int} 0 on success, 1 on error
790		 *  @dtopt API
791		 *  @deprecated Since v1.10
792		 *
793		 *  @example
794		 *    $(document).ready(function() {
795		 *      var oTable = $('#example').dataTable();
796		 *      oTable.fnUpdate( 'Example update', 0, 0 ); // Single cell
797		 *      oTable.fnUpdate( ['a', 'b', 'c', 'd', 'e'], $('tbody tr')[0] ); // Row
798		 *    } );
799		 */
800		this.fnUpdate = function( mData, mRow, iColumn, bRedraw, bAction )
801		{
802			var api = this.api( true );
803		
804			if ( iColumn === undefined || iColumn === null ) {
805				api.row( mRow ).data( mData );
806			}
807			else {
808				api.cell( mRow, iColumn ).data( mData );
809			}
810		
811			if ( bAction === undefined || bAction ) {
812				api.columns.adjust();
813			}
814		
815			if ( bRedraw === undefined || bRedraw ) {
816				api.draw();
817			}
818			return 0;
819		};
820		
821		
822		/**
823		 * Provide a common method for plug-ins to check the version of DataTables being used, in order
824		 * to ensure compatibility.
825		 *  @param {string} sVersion Version string to check for, in the format "X.Y.Z". Note that the
826		 *    formats "X" and "X.Y" are also acceptable.
827		 *  @returns {boolean} true if this version of DataTables is greater or equal to the required
828		 *    version, or false if this version of DataTales is not suitable
829		 *  @method
830		 *  @dtopt API
831		 *  @deprecated Since v1.10
832		 *
833		 *  @example
834		 *    $(document).ready(function() {
835		 *      var oTable = $('#example').dataTable();
836		 *      alert( oTable.fnVersionCheck( '1.9.0' ) );
837		 *    } );
838		 */
839		this.fnVersionCheck = _ext.fnVersionCheck;
840		
841	
842		var _that = this;
843		var emptyInit = options === undefined;
844		var len = this.length;
845	
846		if ( emptyInit ) {
847			options = {};
848		}
849	
850		this.oApi = this.internal = _ext.internal;
851	
852		// Extend with old style plug-in API methods
853		for ( var fn in DataTable.ext.internal ) {
854			if ( fn ) {
855				this[fn] = _fnExternApiFunc(fn);
856			}
857		}
858	
859		this.each(function() {
860			// For each initialisation we want to give it a clean initialisation
861			// object that can be bashed around
862			var o = {};
863			var oInit = len > 1 ? // optimisation for single table case
864				_fnExtend( o, options, true ) :
865				options;
866	
867			/*global oInit,_that,emptyInit*/
868			var i=0, iLen, j, jLen, k, kLen;
869			var sId = this.getAttribute( 'id' );
870			var bInitHandedOff = false;
871			var defaults = DataTable.defaults;
872			var $this = $(this);
873			
874			
875			/* Sanity check */
876			if ( this.nodeName.toLowerCase() != 'table' )
877			{
878				_fnLog( null, 0, 'Non-table node initialisation ('+this.nodeName+')', 2 );
879				return;
880			}
881			
882			/* Backwards compatibility for the defaults */
883			_fnCompatOpts( defaults );
884			_fnCompatCols( defaults.column );
885			
886			/* Convert the camel-case defaults to Hungarian */
887			_fnCamelToHungarian( defaults, defaults, true );
888			_fnCamelToHungarian( defaults.column, defaults.column, true );
889			
890			/* Setting up the initialisation object */
891			_fnCamelToHungarian( defaults, $.extend( oInit, $this.data() ), true );
892			
893			
894			
895			/* Check to see if we are re-initialising a table */
896			var allSettings = DataTable.settings;
897			for ( i=0, iLen=allSettings.length ; i<iLen ; i++ )
898			{
899				var s = allSettings[i];
900			
901				/* Base check on table node */
902				if (
903					s.nTable == this ||
904					(s.nTHead && s.nTHead.parentNode == this) ||
905					(s.nTFoot && s.nTFoot.parentNode == this)
906				) {
907					var bRetrieve = oInit.bRetrieve !== undefined ? oInit.bRetrieve : defaults.bRetrieve;
908					var bDestroy = oInit.bDestroy !== undefined ? oInit.bDestroy : defaults.bDestroy;
909			
910					if ( emptyInit || bRetrieve )
911					{
912						return s.oInstance;
913					}
914					else if ( bDestroy )
915					{
916						s.oInstance.fnDestroy();
917						break;
918					}
919					else
920					{
921						_fnLog( s, 0, 'Cannot reinitialise DataTable', 3 );
922						return;
923					}
924				}
925			
926				/* If the element we are initialising has the same ID as a table which was previously
927				 * initialised, but the table nodes don't match (from before) then we destroy the old
928				 * instance by simply deleting it. This is under the assumption that the table has been
929				 * destroyed by other methods. Anyone using non-id selectors will need to do this manually
930				 */
931				if ( s.sTableId == this.id )
932				{
933					allSettings.splice( i, 1 );
934					break;
935				}
936			}
937			
938			/* Ensure the table has an ID - required for accessibility */
939			if ( sId === null || sId === "" )
940			{
941				sId = "DataTables_Table_"+(DataTable.ext._unique++);
942				this.id = sId;
943			}
944			
945			/* Create the settings object for this table and set some of the default parameters */
946			var oSettings = $.extend( true, {}, DataTable.models.oSettings, {
947				"sDestroyWidth": $this[0].style.width,
948				"sInstance":     sId,
949				"sTableId":      sId
950			} );
951			oSettings.nTable = this;
952			oSettings.oApi   = _that.internal;
953			oSettings.oInit  = oInit;
954			
955			allSettings.push( oSettings );
956			
957			// Need to add the instance after the instance after the settings object has been added
958			// to the settings array, so we can self reference the table instance if more than one
959			oSettings.oInstance = (_that.length===1) ? _that : $this.dataTable();
960			
961			// Backwards compatibility, before we apply all the defaults
962			_fnCompatOpts( oInit );
963			_fnLanguageCompat( oInit.oLanguage );
964			
965			// If the length menu is given, but the init display length is not, use the length menu
966			if ( oInit.aLengthMenu && ! oInit.iDisplayLength )
967			{
968				oInit.iDisplayLength = Array.isArray( oInit.aLengthMenu[0] ) ?
969					oInit.aLengthMenu[0][0] : oInit.aLengthMenu[0];
970			}
971			
972			// Apply the defaults and init options to make a single init object will all
973			// options defined from defaults and instance options.
974			oInit = _fnExtend( $.extend( true, {}, defaults ), oInit );
975			
976			
977			// Map the initialisation options onto the settings object
978			_fnMap( oSettings.oFeatures, oInit, [
979				"bPaginate",
980				"bLengthChange",
981				"bFilter",
982				"bSort",
983				"bSortMulti",
984				"bInfo",
985				"bProcessing",
986				"bAutoWidth",
987				"bSortClasses",
988				"bServerSide",
989				"bDeferRender"
990			] );
991			_fnMap( oSettings, oInit, [
992				"asStripeClasses",
993				"ajax",
994				"fnServerData",
995				"fnFormatNumber",
996				"sServerMethod",
997				"aaSorting",
998				"aaSortingFixed",
999				"aLengthMenu",
1000				"sPaginationType",
1001				"sAjaxSource",
1002				"sAjaxDataProp",
1003				"iStateDuration",
1004				"sDom",
1005				"bSortCellsTop",
1006				"iTabIndex",
1007				"fnStateLoadCallback",
1008				"fnStateSaveCallback",
1009				"renderer",
1010				"searchDelay",
1011				"rowId",
1012				[ "iCookieDuration", "iStateDuration" ], // backwards compat
1013				[ "oSearch", "oPreviousSearch" ],
1014				[ "aoSearchCols", "aoPreSearchCols" ],
1015				[ "iDisplayLength", "_iDisplayLength" ]
1016			] );
1017			_fnMap( oSettings.oScroll, oInit, [
1018				[ "sScrollX", "sX" ],
1019				[ "sScrollXInner", "sXInner" ],
1020				[ "sScrollY", "sY" ],
1021				[ "bScrollCollapse", "bCollapse" ]
1022			] );
1023			_fnMap( oSettings.oLanguage, oInit, "fnInfoCallback" );
1024			
1025			/* Callback functions which are array driven */
1026			_fnCallbackReg( oSettings, 'aoDrawCallback',       oInit.fnDrawCallback,      'user' );
1027			_fnCallbackReg( oSettings, 'aoServerParams',       oInit.fnServerParams,      'user' );
1028			_fnCallbackReg( oSettings, 'aoStateSaveParams',    oInit.fnStateSaveParams,   'user' );
1029			_fnCallbackReg( oSettings, 'aoStateLoadParams',    oInit.fnStateLoadParams,   'user' );
1030			_fnCallbackReg( oSettings, 'aoStateLoaded',        oInit.fnStateLoaded,       'user' );
1031			_fnCallbackReg( oSettings, 'aoRowCallback',        oInit.fnRowCallback,       'user' );
1032			_fnCallbackReg( oSettings, 'aoRowCreatedCallback', oInit.fnCreatedRow,        'user' );
1033			_fnCallbackReg( oSettings, 'aoHeaderCallback',     oInit.fnHeaderCallback,    'user' );
1034			_fnCallbackReg( oSettings, 'aoFooterCallback',     oInit.fnFooterCallback,    'user' );
1035			_fnCallbackReg( oSettings, 'aoInitComplete',       oInit.fnInitComplete,      'user' );
1036			_fnCallbackReg( oSettings, 'aoPreDrawCallback',    oInit.fnPreDrawCallback,   'user' );
1037			
1038			oSettings.rowIdFn = _fnGetObjectDataFn( oInit.rowId );
1039			
1040			/* Browser support detection */
1041			_fnBrowserDetect( oSettings );
1042			
1043			var oClasses = oSettings.oClasses;
1044			
1045			$.extend( oClasses, DataTable.ext.classes, oInit.oClasses );
1046			$this.addClass( oClasses.sTable );
1047			
1048			
1049			if ( oSettings.iInitDisplayStart === undefined )
1050			{
1051				/* Display start point, taking into account the save saving */
1052				oSettings.iInitDisplayStart = oInit.iDisplayStart;
1053				oSettings._iDisplayStart = oInit.iDisplayStart;
1054			}
1055			
1056			if ( oInit.iDeferLoading !== null )
1057			{
1058				oSettings.bDeferLoading = true;
1059				var tmp = Array.isArray( oInit.iDeferLoading );
1060				oSettings._iRecordsDisplay = tmp ? oInit.iDeferLoading[0] : oInit.iDeferLoading;
1061				oSettings._iRecordsTotal = tmp ? oInit.iDeferLoading[1] : oInit.iDeferLoading;
1062			}
1063			
1064			/* Language definitions */
1065			var oLanguage = oSettings.oLanguage;
1066			$.extend( true, oLanguage, oInit.oLanguage );
1067			
1068			if ( oLanguage.sUrl )
1069			{
1070				/* Get the language definitions from a file - because this Ajax call makes the language
1071				 * get async to the remainder of this function we use bInitHandedOff to indicate that
1072				 * _fnInitialise will be fired by the returned Ajax handler, rather than the constructor
1073				 */
1074				$.ajax( {
1075					dataType: 'json',
1076					url: oLanguage.sUrl,
1077					success: function ( json ) {
1078						_fnCamelToHungarian( defaults.oLanguage, json );
1079						_fnLanguageCompat( json );
1080						$.extend( true, oLanguage, json, oSettings.oInit.oLanguage );
1081			
1082						_fnCallbackFire( oSettings, null, 'i18n', [oSettings]);
1083						_fnInitialise( oSettings );
1084					},
1085					error: function () {
1086						// Error occurred loading language file, continue on as best we can
1087						_fnInitialise( oSettings );
1088					}
1089				} );
1090				bInitHandedOff = true;
1091			}
1092			else {
1093				_fnCallbackFire( oSettings, null, 'i18n', [oSettings]);
1094			}
1095			
1096			/*
1097			 * Stripes
1098			 */
1099			if ( oInit.asStripeClasses === null )
1100			{
1101				oSettings.asStripeClasses =[
1102					oClasses.sStripeOdd,
1103					oClasses.sStripeEven
1104				];
1105			}
1106			
1107			/* Remove row stripe classes if they are already on the table row */
1108			var stripeClasses = oSettings.asStripeClasses;
1109			var rowOne = $this.children('tbody').find('tr').eq(0);
1110			if ( $.inArray( true, $.map( stripeClasses, function(el, i) {
1111				return rowOne.hasClass(el);
1112			} ) ) !== -1 ) {
1113				$('tbody tr', this).removeClass( stripeClasses.join(' ') );
1114				oSettings.asDestroyStripes = stripeClasses.slice();
1115			}
1116			
1117			/*
1118			 * Columns
1119			 * See if we should load columns automatically or use defined ones
1120			 */
1121			var anThs = [];
1122			var aoColumnsInit;
1123			var nThead = this.getElementsByTagName('thead');
1124			if ( nThead.length !== 0 )
1125			{
1126				_fnDetectHeader( oSettings.aoHeader, nThead[0] );
1127				anThs = _fnGetUniqueThs( oSettings );
1128			}
1129			
1130			/* If not given a column array, generate one with nulls */
1131			if ( oInit.aoColumns === null )
1132			{
1133				aoColumnsInit = [];
1134				for ( i=0, iLen=anThs.length ; i<iLen ; i++ )
1135				{
1136					aoColumnsInit.push( null );
1137				}
1138			}
1139			else
1140			{
1141				aoColumnsInit = oInit.aoColumns;
1142			}
1143			
1144			/* Add the columns */
1145			for ( i=0, iLen=aoColumnsInit.length ; i<iLen ; i++ )
1146			{
1147				_fnAddColumn( oSettings, anThs ? anThs[i] : null );
1148			}
1149			
1150			/* Apply the column definitions */
1151			_fnApplyColumnDefs( oSettings, oInit.aoColumnDefs, aoColumnsInit, function (iCol, oDef) {
1152				_fnColumnOptions( oSettings, iCol, oDef );
1153			} );
1154			
1155			/* HTML5 attribute detection - build an mData object automatically if the
1156			 * attributes are found
1157			 */
1158			if ( rowOne.length ) {
1159				var a = function ( cell, name ) {
1160					return cell.getAttribute( 'data-'+name ) !== null ? name : null;
1161				};
1162			
1163				$( rowOne[0] ).children('th, td').each( function (i, cell) {
1164					var col = oSettings.aoColumns[i];
1165			
1166					if (! col) {
1167						_fnLog( oSettings, 0, 'Incorrect column count', 18 );
1168					}
1169			
1170					if ( col.mData === i ) {
1171						var sort = a( cell, 'sort' ) || a( cell, 'order' );
1172						var filter = a( cell, 'filter' ) || a( cell, 'search' );
1173			
1174						if ( sort !== null || filter !== null ) {
1175							col.mData = {
1176								_:      i+'.display',
1177								sort:   sort !== null   ? i+'.@data-'+sort   : undefined,
1178								type:   sort !== null   ? i+'.@data-'+sort   : undefined,
1179								filter: filter !== null ? i+'.@data-'+filter : undefined
1180							};
1181							col._isArrayHost = true;
1182			
1183							_fnColumnOptions( oSettings, i );
1184						}
1185					}
1186				} );
1187			}
1188			
1189			var features = oSettings.oFeatures;
1190			var loadedInit = function () {
1191				/*
1192				 * Sorting
1193				 * @todo For modularisation (1.11) this needs to do into a sort start up handler
1194				 */
1195			
1196				// If aaSorting is not defined, then we use the first indicator in asSorting
1197				// in case that has been altered, so the default sort reflects that option
1198				if ( oInit.aaSorting === undefined ) {
1199					var sorting = oSettings.aaSorting;
1200					for ( i=0, iLen=sorting.length ; i<iLen ; i++ ) {
1201						sorting[i][1] = oSettings.aoColumns[ i ].asSorting[0];
1202					}
1203				}
1204			
1205				/* Do a first pass on the sorting classes (allows any size changes to be taken into
1206				 * account, and also will apply sorting disabled classes if disabled
1207				 */
1208				_fnSortingClasses( oSettings );
1209			
1210				if ( features.bSort ) {
1211					_fnCallbackReg( oSettings, 'aoDrawCallback', function () {
1212						if ( oSettings.bSorted ) {
1213							var aSort = _fnSortFlatten( oSettings );
1214							var sortedColumns = {};
1215			
1216							$.each( aSort, function (i, val) {
1217								sortedColumns[ val.src ] = val.dir;
1218							} );
1219			
1220							_fnCallbackFire( oSettings, null, 'order', [oSettings, aSort, sortedColumns] );
1221							_fnSortAria( oSettings );
1222						}
1223					} );
1224				}
1225			
1226				_fnCallbackReg( oSettings, 'aoDrawCallback', function () {
1227					if ( oSettings.bSorted || _fnDataSource( oSettings ) === 'ssp' || features.bDeferRender ) {
1228						_fnSortingClasses( oSettings );
1229					}
1230				}, 'sc' );
1231			
1232			
1233				/*
1234				 * Final init
1235				 * Cache the header, body and footer as required, creating them if needed
1236				 */
1237			
1238				// Work around for Webkit bug 83867 - store the caption-side before removing from doc
1239				var captions = $this.children('caption').each( function () {
1240					this._captionSide = $(this).css('caption-side');
1241				} );
1242			
1243				var thead = $this.children('thead');
1244				if ( thead.length === 0 ) {
1245					thead = $('<thead/>').appendTo($this);
1246				}
1247				oSettings.nTHead = thead[0];
1248			
1249				var tbody = $this.children('tbody');
1250				if ( tbody.length === 0 ) {
1251					tbody = $('<tbody/>').insertAfter(thead);
1252				}
1253				oSettings.nTBody = tbody[0];
1254			
1255				var tfoot = $this.children('tfoot');
1256				if ( tfoot.length === 0 && captions.length > 0 && (oSettings.oScroll.sX !== "" || oSettings.oScroll.sY !== "") ) {
1257					// If we are a scrolling table, and no footer has been given, then we need to create
1258					// a tfoot element for the caption element to be appended to
1259					tfoot = $('<tfoot/>').appendTo($this);
1260				}
1261			
1262				if ( tfoot.length === 0 || tfoot.children().length === 0 ) {
1263					$this.addClass( oClasses.sNoFooter );
1264				}
1265				else if ( tfoot.length > 0 ) {
1266					oSettings.nTFoot = tfoot[0];
1267					_fnDetectHeader( oSettings.aoFooter, oSettings.nTFoot );
1268				}
1269			
1270				/* Check if there is data passing into the constructor */
1271				if ( oInit.aaData ) {
1272					for ( i=0 ; i<oInit.aaData.length ; i++ ) {
1273						_fnAddData( oSettings, oInit.aaData[ i ] );
1274					}
1275				}
1276				else if ( oSettings.bDeferLoading || _fnDataSource( oSettings ) == 'dom' ) {
1277					/* Grab the data from the page - only do this when deferred loading or no Ajax
1278					 * source since there is no point in reading the DOM data if we are then going
1279					 * to replace it with Ajax data
1280					 */
1281					_fnAddTr( oSettings, $(oSettings.nTBody).children('tr') );
1282				}
1283			
1284				/* Copy the data index array */
1285				oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
1286			
1287				/* Initialisation complete - table can be drawn */
1288				oSettings.bInitialised = true;
1289			
1290				/* Check if we need to initialise the table (it might not have been handed off to the
1291				 * language processor)
1292				 */
1293				if ( bInitHandedOff === false ) {
1294					_fnInitialise( oSettings );
1295				}
1296			};
1297			
1298			/* Must be done after everything which can be overridden by the state saving! */
1299			_fnCallbackReg( oSettings, 'aoDrawCallback', _fnSaveState, 'state_save' );
1300			
1301			if ( oInit.bStateSave )
1302			{
1303				features.bStateSave = true;
1304				_fnLoadState( oSettings, oInit, loadedInit );
1305			}
1306			else {
1307				loadedInit();
1308			}
1309			
1310		} );
1311		_that = null;
1312		return this;
1313	};
1314	
1315	
1316	/*
1317	 * It is useful to have variables which are scoped locally so only the
1318	 * DataTables functions can access them and they don't leak into global space.
1319	 * At the same time these functions are often useful over multiple files in the
1320	 * core and API, so we list, or at least document, all variables which are used
1321	 * by DataTables as private variables here. This also ensures that there is no
1322	 * clashing of variable names and that they can easily referenced for reuse.
1323	 */
1324	
1325	
1326	// Defined else where
1327	//  _selector_run
1328	//  _selector_opts
1329	//  _selector_first
1330	//  _selector_row_indexes
1331	
1332	var _ext; // DataTable.ext
1333	var _Api; // DataTable.Api
1334	var _api_register; // DataTable.Api.register
1335	var _api_registerPlural; // DataTable.Api.registerPlural
1336	
1337	var _re_dic = {};
1338	var _re_new_lines = /[\r\n\u2028]/g;
1339	var _re_html = /<.*?>/g;
1340	
1341	// This is not strict ISO8601 - Date.parse() is quite lax, although
1342	// implementations differ between browsers.
1343	var _re_date = /^\d{2,4}[\.\/\-]\d{1,2}[\.\/\-]\d{1,2}([T ]{1}\d{1,2}[:\.]\d{2}([\.:]\d{2})?)?$/;
1344	
1345	// Escape regular expression special characters
1346	var _re_escape_regex = new RegExp( '(\\' + [ '/', '.', '*', '+', '?', '|', '(', ')', '[', ']', '{', '}', '\\', '$', '^', '-' ].join('|\\') + ')', 'g' );
1347	
1348	// http://en.wikipedia.org/wiki/Foreign_exchange_market
1349	// - \u20BD - Russian ruble.
1350	// - \u20a9 - South Korean Won
1351	// - \u20BA - Turkish Lira
1352	// - \u20B9 - Indian Rupee
1353	// - R - Brazil (R$) and South Africa
1354	// - fr - Swiss Franc
1355	// - kr - Swedish krona, Norwegian krone and Danish krone
1356	// - \u2009 is thin space and \u202F is narrow no-break space, both used in many
1357	// - Ƀ - Bitcoin
1358	// - Ξ - Ethereum
1359	//   standards as thousands separators.
1360	var _re_formatted_numeric = /['\u00A0,$£€¥%\u2009\u202F\u20BD\u20a9\u20BArfkɃΞ]/gi;
1361	
1362	
1363	var _empty = function ( d ) {
1364		return !d || d === true || d === '-' ? true : false;
1365	};
1366	
1367	
1368	var _intVal = function ( s ) {
1369		var integer = parseInt( s, 10 );
1370		return !isNaN(integer) && isFinite(s) ? integer : null;
1371	};
1372	
1373	// Convert from a formatted number with characters other than `.` as the
1374	// decimal place, to a Javascript number
1375	var _numToDecimal = function ( num, decimalPoint ) {
1376		// Cache created regular expressions for speed as this function is called often
1377		if ( ! _re_dic[ decimalPoint ] ) {
1378			_re_dic[ decimalPoint ] = new RegExp( _fnEscapeRegex( decimalPoint ), 'g' );
1379		}
1380		return typeof num === 'string' && decimalPoint !== '.' ?
1381			num.replace( /\./g, '' ).replace( _re_dic[ decimalPoint ], '.' ) :
1382			num;
1383	};
1384	
1385	
1386	var _isNumber = function ( d, decimalPoint, formatted ) {
1387		

1387let type = typeof d;
1388		var strType = type === 'string';
1389	
1390		if ( type === 'number' || type === 'bigint') {
1391			return true;
1392		}
1393	
1394		// If empty return immediately so there must be a number if it is a
1395		// formatted string (this stops the string "k", or "kr", etc being detected
1396		// as a formatted number for currency
1397		if ( _empty( d ) ) {
1398			return true;
1399		}
1400	
1401		if ( decimalPoint && strType ) {
1402			d = _numToDecimal( d, decimalPoint );
1403		}
1404	
1405		if ( formatted && strType ) {
1406			d = d.replace( _re_formatted_numeric, '' );
1407		}
1408	
1409		return !isNaN( parseFloat(d) ) && isFinite( d );
1410	};
1411	
1412	
1413	// A string without HTML in it can be considered to be HTML still
1414	var _isHtml = function ( d ) {
1415		return _empty( d ) || typeof d === 'string';
1416	};
1417	
1418	
1419	var _htmlNumeric = function ( d, decimalPoint, formatted ) {
1420		if ( _empty( d ) ) {
1421			return true;
1422		}
1423	
1424		var html = _isHtml( d );
1425		return ! html ?
1426			null :
1427			_isNumber( _stripHtml( d ), decimalPoint, formatted ) ?
1428				true :
1429				null;
1430	};
1431	
1432	
1433	var _pluck = function ( a, prop, prop2 ) {
1434		var out = [];
1435		var i=0, ien=a.length;
1436	
1437		// Could have the test in the loop for slightly smaller code, but speed
1438		// is essential here
1439		if ( prop2 !== undefined ) {
1440			for ( ; i<ien ; i++ ) {
1441				if ( a[i] && a[i][ prop ] ) {
1442					out.push( a[i][ prop ][ prop2 ] );
1443				}
1444			}
1445		}
1446		else {
1447			for ( ; i<ien ; i++ ) {
1448				if ( a[i] ) {
1449					out.push( a[i][ prop ] );
1450				}
1451			}
1452		}
1453	
1454		return out;
1455	};
1456	
1457	
1458	// Basically the same as _pluck, but rather than looping over `a` we use `order`
1459	// as the indexes to pick from `a`
1460	var _pluck_order = function ( a, order, prop, prop2 )
1461	{
1462		var out = [];
1463		var i=0, ien=order.length;
1464	
1465		// Could have the test in the loop for slightly smaller code, but speed
1466		// is essential here
1467		if ( prop2 !== undefined ) {
1468			for ( ; i<ien ; i++ ) {
1469				if ( a[ order[i] ][ prop ] ) {
1470					out.push( a[ order[i] ][ prop ][ prop2 ] );
1471				}
1472			}
1473		}
1474		else {
1475			for ( ; i<ien ; i++ ) {
1476				out.push( a[ order[i] ][ prop ] );
1477			}
1478		}
1479	
1480		return out;
1481	};
1482	
1483	
1484	var _range = function ( len, start )
1485	{
1486		var out = [];
1487		var end;
1488	
1489		if ( start === undefined ) {
1490			start = 0;
1491			end = len;
1492		}
1493		else {
1494			end = start;
1495			start = len;
1496		}
1497	
1498		for ( var i=start ; i<end ; i++ ) {
1499			out.push( i );
1500		}
1501	
1502		return out;
1503	};
1504	
1505	
1506	var _removeEmpty = function ( a )
1507	{
1508		var out = [];
1509	
1510		for ( var i=0, ien=a.length ; i<ien ; i++ ) {
1511			if ( a[i] ) { // careful - will remove all falsy values!
1512				out.push( a[i] );
1513			}
1514		}
1515	
1516		return out;
1517	};
1518	
1519	
1520	var _stripHtml = function ( d ) {
1521		return d.replace( _re_html, '' );

1521
1522	};
1523	
1524	
1525	/**
1526	 * Determine if all values in the array are unique. This means we can short
1527	 * cut the _unique method at the cost of a single loop. A sorted array is used
1528	 * to easily check the values.
1529	 *
1530	 * @param  {array} src Source array
1531	 * @return {boolean} true if all unique, false otherwise
1532	 * @ignore
1533	 */
1534	var _areAllUnique = function ( src ) {
1535		if ( src.length < 2 ) {
1536			return true;
1537		}
1538	
1539		var sorted = src.slice().sort();
1540		var last = sorted[0];
1541	
1542		for ( var i=1, ien=sorted.length ; i<ien ; i++ ) {
1543			if ( sorted[i] === last ) {
1544				return false;
1545			}
1546	
1547			last = sorted[i];
1548		}
1549	
1550		return true;
1551	};
1552	
1553	
1554	/**
1555	 * Find the unique elements in a source array.
1556	 *
1557	 * @param  {array} src Source array
1558	 * @return {array} Array of unique items
1559	 * @ignore
1560	 */
1561	var _unique = function ( src )
1562	{
1563		if ( _areAllUnique( src ) ) {
1564			return src.slice();
1565		}
1566	
1567		// A faster unique method is to use object keys to identify used values,
1568		// but this doesn't work with arrays or objects, which we must also
1569		// consider. See jsperf.com/compare-array-unique-versions/4 for more
1570		// information.
1571		var
1572			out = [],
1573			val,
1574			i, ien=src.length,
1575			j, k=0;
1576	
1577		again: for ( i=0 ; i<ien ; i++ ) {
1578			val = src[i];
1579	
1580			for ( j=0 ; j<k ; j++ ) {
1581				if ( out[j] === val ) {
1582					continue again;
1583				}
1584			}
1585	
1586			out.push( val );
1587			k++;
1588		}
1589	
1590		return out;
1591	};
1592	
1593	// Surprisingly this is faster than [].concat.apply
1594	// https://jsperf.com/flatten-an-array-loop-vs-reduce/2
1595	var _flatten = function (out, val) {
1596		if (Array.isArray(val)) {
1597			for (var i=0 ; i<val.length ; i++) {
1598				_flatten(out, val[i]);
1599			}
1600		}
1601		else {
1602			out.push(val);
1603		}
1604	  
1605		return out;
1606	}
1607	
1608	var _includes = function (search, start) {
1609		if (start === undefined) {
1610			start = 0;
1611		}
1612	
1613		return this.indexOf(search, start) !== -1;	
1614	};
1615	
1616	// Array.isArray polyfill.
1617	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray
1618	if (! Array.isArray) {
1619	    Array.isArray = function(arg) {
1620	        return Object.prototype.toString.call(arg) === '[object Array]';
1621	    };
1622	}
1623	
1624	if (! Array.prototype.includes) {
1625		Array.prototype.includes = _includes;
1626	}
1627	
1628	// .trim() polyfill
1629	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/trim
1630	if (!String.prototype.trim) {
1631	  String.prototype.trim = function () {
1632	    return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
1633	  };
1634	}
1635	
1636	if (! String.prototype.includes) {
1637		String.prototype.includes = _includes;
1638	}
1639	
1640	/**
1641	 * DataTables utility methods
1642	 * 
1643	 * This namespace provides helper methods that DataTables uses internally to
1644	 * create a DataTable, but which are not exclusively used only for DataTables.
1645	 * These methods can be used by extension authors to save the duplication of
1646	 * code.
1647	 *
1648	 *  @namespace
1649	 */
1650	DataTable.util = {
1651		/**
1652		 * Throttle the calls to a function. Arguments and context are maintained
1653		 * for the throttled function.
1654		 *
1655		 * @param {function} fn Function to be called
1656		 * @param {integer} freq Call frequency in mS
1657		 * @return {function} Wrapped function
1658		 */
1659		throttle: function ( fn, freq ) {
1660			var
1661				frequency = freq !== undefined ? freq : 200,
1662				last,
1663				timer;
1664	
1665			return function () {
1666				var
1667					that = this,
1668					now  = +new Date(),
1669					args = arguments;
1670	
1671				if ( last && now < last + frequency ) {
1672					clearTimeout( timer );
1673	
1674					timer = setTimeout( function () {
1675						last = undefined;
1676						fn.apply( that, args );
1677					}, frequency );
1678				}
1679				else {
1680					last = now;
1681					fn.apply( that, args );
1682				}
1683			};
1684		},
1685	
1686	
1687		/**
1688		 * Escape a string such that it can be used in a regular expression
1689		 *
1690		 *  @param {string} val string to escape
1691		 *  @returns {string} escaped string
1692		 */
1693		escapeRegex: function ( val ) {
1694			return val.replace( _re_escape_regex, '\\$1' );
1695		},
1696	
1697		/**
1698		 * Create a function that will write to a nested object or array
1699		 * @param {*} source JSON notation string
1700		 * @returns Write function
1701		 */
1702		set: function ( source ) {
1703			if ( $.isPlainObject( source ) ) {
1704				/* Unlike get, only the underscore (global) option is used for for
1705				 * setting data since we don't know the type here. This is why an object
1706				 * option is not documented for `mData` (which is read/write), but it is
1707				 * for `mRender` which is read only.
1708				 */
1709				return DataTable.util.set( source._ );
1710			}
1711			else if ( source === null ) {
1712				// Nothing to do when the data source is null
1713				return function () {};
1714			}
1715			else if ( typeof source === 'function' ) {
1716				return function (data, val, meta) {
1717					source( data, 'set', val, meta );
1718				};
1719			}
1720			else if ( typeof source === 'string' && (source.indexOf('.') !== -1 ||
1721					  source.indexOf('[') !== -1 || source.indexOf('(') !== -1) )
1722			{
1723				// Like the get, we need to get data from a nested object
1724				var setData = function (data, val, src) {
1725					var a = _fnSplitObjNotation( src ), b;
1726					var aLast = a[a.length-1];
1727					var arrayNotation, funcNotation, o, innerSrc;
1728		
1729					for ( var i=0, iLen=a.length-1 ; i<iLen ; i++ ) {
1730						// Protect against prototype pollution
1731						if (a[i] === '__proto__' || a[i] === 'constructor') {
1732							throw new Error('Cannot set prototype values');
1733						}
1734		
1735						// Check if we are dealing with an array notation request
1736						arrayNotation = a[i].match(__reArray);
1737						funcNotation = a[i].match(__reFn);
1738		
1739						if ( arrayNotation ) {
1740							a[i] = a[i].replace(__reArray, '');
1741							data[ a[i] ] = [];
1742		
1743							// Get the remainder of the nested object to set so we can recurse
1744							b = a.slice();
1745							b.splice( 0, i+1 );
1746							innerSrc = b.join('.');
1747		
1748							// Traverse each entry in the array setting the properties requested
1749							if ( Array.isArray( val ) ) {
1750								for ( var j=0, jLen=val.length ; j<jLen ; j++ ) {
1751									o = {};
1752									setData( o, val[j], innerSrc );
1753									data[ a[i] ].push( o );
1754								}
1755							}
1756							else {
1757								// We've been asked to save data to an array, but it
1758								// isn't array data to be saved. Best that can be done
1759								// is to just save the value.
1760								data[ a[i] ] = val;
1761							}
1762		
1763							// The inner call to setData has already traversed through the remainder
1764							// of the source and has set the data, thus we can exit here
1765							return;
1766						}
1767						else if ( funcNotation ) {
1768							// Function call
1769							a[i] = a[i].replace(__reFn, '');
1770							data = data[ a[i] ]( val );
1771						}
1772		
1773						// If the nested object doesn't currently exist - since we are
1774						// trying to set the value - create it
1775						if ( data[ a[i] ] === null || data[ a[i] ] === undefined ) {
1776							data[ a[i] ] = {};
1777						}
1778						data = data[ a[i] ];
1779					}
1780		
1781					// Last item in the input - i.e, the actual set
1782					if ( aLast.match(__reFn ) ) {
1783						// Function call
1784						data = data[ aLast.replace(__reFn, '') ]( val );
1785					}
1786					else {
1787						// If array notation is used, we just want to strip it and use the property name
1788						// and assign the value. If it isn't used, then we get the result we want anyway
1789						data[ aLast.replace(__reArray, '') ] = val;
1790					}
1791				};
1792		
1793				return function (data, val) { // meta is also passed in, but not used
1794					return setData( data, val, source );
1795				};
1796			}
1797			else {
1798				// Array or flat object mapping
1799				return function (data, val) { // meta is also passed in, but not used
1800					data[source] = val;
1801				};
1802			}
1803		},
1804	
1805		/**
1806		 * Create a function that will read nested objects from arrays, based on JSON notation
1807		 * @param {*} source JSON notation string
1808		 * @returns Value read
1809		 */
1810		get: function ( source ) {
1811			if ( $.isPlainObject( source ) ) {
1812				// Build an object of get functions, and wrap them in a single call
1813				var o = {};
1814				$.each( source, function (key, val) {
1815					if ( val ) {
1816						o[key] = DataTable.util.get( val );
1817					}
1818				} );
1819		
1820				return function (data, type, row, meta) {
1821					var t = o[type] || o._;
1822					return t !== undefined ?
1823						t(data, type, row, meta) :
1824						data;
1825				};
1826			}
1827			else if ( source === null ) {
1828				// Give an empty string for rendering / sorting etc
1829				return function (data) { // type, row and meta also passed, but not used
1830					return data;
1831				};
1832			}
1833			else if ( typeof source === 'function' ) {
1834				return function (data, type, row, meta) {
1835					return source( data, type, row, meta );
1836				};
1837			}
1838			else if ( typeof source === 'string' && (source.indexOf('.') !== -1 ||
1839					  source.indexOf('[') !== -1 || source.indexOf('(') !== -1) )
1840			{
1841				/* If there is a . in the source string then the data source is in a
1842				 * nested object so we loop over the data for each level to get the next
1843				 * level down. On each loop we test for undefined, and if found immediately
1844				 * return. This allows entire objects to be missing and sDefaultContent to
1845				 * be used if defined, rather than throwing an error
1846				 */
1847				var fetchData = function (data, type, src) {
1848					var arrayNotation, funcNotation, out, innerSrc;
1849		
1850					if ( src !== "" ) {
1851						var a = _fnSplitObjNotation( src );
1852		
1853						for ( var i=0, iLen=a.length ; i<iLen ; i++ ) {
1854							// Check if we are dealing with special notation
1855							arrayNotation = a[i].match(__reArray);
1856							funcNotation = a[i].match(__reFn);
1857		
1858							if ( arrayNotation ) {
1859								// Array notation
1860								a[i] = a[i].replace(__reArray, '');
1861		
1862								// Condition allows simply [] to be passed in
1863								if ( a[i] !== "" ) {
1864									data = data[ a[i] ];
1865								}
1866								out = [];
1867		
1868								// Get the remainder of the nested object to get
1869								a.splice( 0, i+1 );
1870								innerSrc = a.join('.');
1871		
1872								// Traverse each entry in the array getting the properties requested
1873								if ( Array.isArray( data ) ) {
1874									for ( var j=0, jLen=data.length ; j<jLen ; j++ ) {
1875										out.push( fetchData( data[j], type, innerSrc ) );
1876									}
1877								}
1878		
1879								// If a string is given in between the array notation indicators, that
1880								// is used to join the strings together, otherwise an array is returned
1881								var join = arrayNotation[0].substring(1, arrayNotation[0].length-1);
1882								data = (join==="") ? out : out.join(join);
1883		
1884								// The inner call to fetchData has already traversed through the remainder
1885								// of the source requested, so we exit from the loop
1886								break;
1887							}
1888							else if ( funcNotation ) {
1889								// Function call
1890								a[i] = a[i].replace(__reFn, '');
1891								data = data[ a[i] ]();
1892								continue;
1893							}
1894		
1895							if (

1895 || data[ a[i] ] === undefined ) {
1896								return undefined;
1897							}
1898	
1899							data = data[ a[i] ];
1900						}
1901					}
1902		
1903					return data;
1904				};
1905		
1906				return function (data, type) { // row and meta also passed, but not used
1907					return fetchData( data, type, source );
1908				};
1909			}
1910			else {
1911				// Array or flat object mapping
1912				return function (data, type) { // row and meta also passed, but not used
1913					return data[source];
1914				};
1915			}
1916		}
1917	};
1918	
1919	
1920	
1921	/**
1922	 * Create a mapping object that allows camel case parameters to be looked up
1923	 * for their Hungarian counterparts. The mapping is stored in a private
1924	 * parameter called `_hungarianMap` which can be accessed on the source object.
1925	 *  @param {object} o
1926	 *  @memberof DataTable#oApi
1927	 */
1928	function _fnHungarianMap ( o )
1929	{
1930		var
1931			hungarian = 'a aa ai ao as b fn i m o s ',
1932			match,
1933			newKey,
1934			map = {};
1935	
1936		$.each( o, function (key, val) {
1937			match = key.match(/^([^A-Z]+?)([A-Z])/);
1938	
1939			if ( match && hungarian.indexOf(match[1]+' ') !== -1 )
1940			{
1941				newKey = key.replace( match[0], match[2].toLowerCase() );
1942				map[ newKey ] = key;
1943	
1944				if ( match[1] === 'o' )
1945				{
1946					_fnHungarianMap( o[key] );
1947				}
1948			}
1949		} );
1950	
1951		o._hungarianMap = map;
1952	}
1953	
1954	
1955	/**
1956	 * Convert from camel case parameters to Hungarian, based on a Hungarian map
1957	 * created by _fnHungarianMap.
1958	 *  @param {object} src The model object which holds all parameters that can be
1959	 *    mapped.
1960	 *  @param {object} user The object to convert from camel case to Hungarian.
1961	 *  @param {boolean} force When set to `true`, properties which already have a
1962	 *    Hungarian value in the `user` object will be overwritten. Otherwise they
1963	 *    won't be.
1964	 *  @memberof DataTable#oApi
1965	 */
1966	function _fnCamelToHungarian ( src, user, force )
1967	{
1968		if ( ! src._hungarianMap ) {
1969			_fnHungarianMap( src );
1970		}
1971	
1972		var hungarianKey;
1973	
1974		$.each( user, function (key, val) {
1975			hungarianKey = src._hungarianMap[ key ];
1976	
1977			if ( hungarianKey !== undefined && (force || user[hungarianKey] === undefined) )
1978			{
1979				// For objects, we need to buzz down into the object to copy parameters
1980				if ( hungarianKey.charAt(0) === 'o' )
1981				{
1982					// Copy the camelCase options over to the hungarian
1983					if ( ! user[ hungarianKey ] ) {
1984						user[ hungarianKey ] = {};
1985					}
1986					$.extend( true, user[hungarianKey], user[key] );
1987	
1988					_fnCamelToHungarian( src[hungarianKey], user[hungarianKey], force );
1989				}
1990				else {
1991					user[hungarianKey] = user[ key ];
1992				}
1993			}
1994		} );
1995	}
1996	
1997	
1998	/**
1999	 * Language compatibility - when certain options are given, and others aren't, we
2000	 * need to duplicate the values over, in order to provide backwards compatibility
2001	 * with older language files.
2002	 *  @param {object} oSettings dataTables settings object
2003	 *  @memberof DataTable#oApi
2004	 */
2005	function _fnLanguageCompat( lang )
2006	{
2007		// Note the use of the Hungarian notation for the parameters in this method as
2008		// this is called after the mapping of camelCase to Hungarian
2009		var defaults = DataTable.defaults.oLanguage;
2010	
2011		// Default mapping
2012		var defaultDecimal = defaults.sDecimal;
2013		if ( defaultDecimal ) {
2014			_addNumericSort( defaultDecimal );
2015		}
2016	
2017		if ( lang ) {
2018			var zeroRecords = lang.sZeroRecords;
2019	
2020			// Backwards compatibility - if there is no sEmptyTable given, then use the same as
2021			// sZeroRecords - assuming that is given.
2022			if ( ! lang.sEmptyTable && zeroRecords &&
2023				defaults.sEmptyTable === "No data available in table" )
2024			{
2025				_fnMap( lang, lang, 'sZeroRecords', 'sEmptyTable' );
2026			}
2027	
2028			// Likewise with loading records
2029			if ( ! lang.sLoadingRecords && zeroRecords &&
2030				defaults.sLoadingRecords === "Loading..." )
2031			{
2032				_fnMap( lang, lang, 'sZeroRecords', 'sLoadingRecords' );
2033			}
2034	
2035			// Old parameter name of the thousands separator mapped onto the new
2036			if ( lang.sInfoThousands ) {
2037				lang.sThousands = lang.sInfoThousands;
2038			}
2039	
2040			var decimal = lang.sDecimal;
2041			if ( decimal && defaultDecimal !== decimal ) {
2042				_addNumericSort( decimal );
2043			}
2044		}
2045	}
2046	
2047	
2048	/**
2049	 * Map one parameter onto another
2050	 *  @param {object} o Object to map
2051	 *  @param {*} knew The new parameter name
2052	 *  @param {*} old The old parameter name
2053	 */
2054	var _fnCompatMap = function ( o, knew, old ) {
2055		if ( o[ knew ] !== undefined ) {
2056			o[ old ] = o[ knew ];
2057		}
2058	};
2059	
2060	
2061	/**
2062	 * Provide backwards compatibility for the main DT options. Note that the new
2063	 * options are mapped onto the old parameters, so this is an external interface
2064	 * change only.
2065	 *  @param {object} init Object to map
2066	 */
2067	function _fnCompatOpts ( init )
2068	{
2069		_fnCompatMap( init, 'ordering',      'bSort' );
2070		_fnCompatMap( init, 'orderMulti',    'bSortMulti' );
2071		_fnCompatMap( init, 'orderClasses',  'bSortClasses' );
2072		_fnCompatMap( init, 'orderCellsTop', 'bSortCellsTop' );
2073		_fnCompatMap( init, 'order',         'aaSorting' );
2074		_fnCompatMap( init, 'orderFixed',    'aaSortingFixed' );
2075		_fnCompatMap( init, 'paging',        'bPaginate' );
2076		_fnCompatMap( init, 'pagingType',    'sPaginationType' );
2077		_fnCompatMap( init, 'pageLength',    'iDisplayLength' );
2078		_fnCompatMap( init, 'searching',     'bFilter' );
2079	
2080		// Boolean initialisation of x-scrolling
2081		if ( typeof init.sScrollX === 'boolean' ) {
2082			init.sScrollX = init.sScrollX ? '100%' : '';
2083		}
2084		if ( typeof init.scrollX === 'boolean' ) {
2085			init.scrollX = init.scrollX ? '100%' : '';
2086		}
2087	
2088		// Column search objects are in an array, so it needs to be converted
2089		// element by element
2090		var searchCols = init.aoSearchCols;
2091	
2092		if ( searchCols ) {
2093			for ( var i=0, ien=searchCols.length ; i<ien ; i++ ) {
2094				if ( searchCols[i] ) {
2095					_fnCamelToHungarian( DataTable.models.oSearch, searchCols[i] );
2096				}
2097			}
2098		}
2099	}
2100	
2101	
2102	/**
2103	 * Provide backwards compatibility for column options. Note that the new options
2104	 * are mapped onto the old parameters, so this is an external interface change
2105	 * only.
2106	 *  @param {object} init Object to map
2107	 */
2108	function _fnCompatCols ( init )
2109	{
2110		_fnCompatMap( init, 'orderable',     'bSortable' );
2111		_fnCompatMap( init, 'orderData',     'aDataSort' );
2112		_fnCompatMap( init, 'orderSequence', 'asSorting' );
2113		_fnCompatMap( init, 'orderDataType', 'sortDataType' );
2114	
2115		// orderData can be given as an integer
2116		var dataSort = init.aDataSort;
2117		if ( typeof dataSort === 'number' && ! Array.isArray( dataSort ) ) {
2118			init.aDataSort = [ dataSort ];
2119		}
2120	}
2121	
2122	
2123	/**
2124	 * Browser feature detection for capabilities, quirks
2125	 *  @param {object} settings dataTables settings object
2126	 *  @memberof DataTable#oApi
2127	 */
2128	function _fnBrowserDetect( settings )
2129	{
2130		// We don't need to do this every time DataTables is constructed, the values
2131		// calculated are specific to the browser and OS configuration which we
2132		// don't expect to change between initialisations
2133		if ( ! DataTable.__browser ) {
2134			var browser = {};
2135			DataTable.__browser = browser;
2136	
2137			// Scrolling feature / quirks detection
2138			var n = $('<div/>')
2139				.css( {
2140					position: 'fixed',
2141					top: 0,
2142					left: $(window).scrollLeft()*-1, // allow for scrolling
2143					height: 1,
2144					width: 1,
2145					overflow: 'hidden'
2146				} )
2147				.append(
2148					$('<div/>')
2149						.css( {
2150							position: 'absolute',
2151							top: 1,
2152							left: 1,
2153							width: 100,
2154							overflow: 'scroll'
2155						} )
2156						.append(
2157							$('<div/>')
2158								.css( {
2159									width: '100%',
2160									height: 10
2161								} )
2162						)
2163				)
2164				.appendTo( 'body' );
2165	
2166			var outer = n.children();
2167			var inner = outer.children();
2168	
2169			// Numbers below, in order, are:
2170			// inner.offsetWidth, inner.clientWidth, outer.offsetWidth, outer.clientWidth
2171			//
2172			// IE6 XP:                           100 100 100  83
2173			// IE7 Vista:                        100 100 100  83
2174			// IE 8+ Windows:                     83  83 100  83
2175			// Evergreen Windows:                 83  83 100  83
2176			// Evergreen Mac with scrollbars:     85  85 100  85
2177			// Evergreen Mac without scrollbars: 100 100 100 100
2178	
2179			// Get scrollbar width
2180			browser.barWidth = outer[0].offsetWidth - outer[0].clientWidth;
2181	
2182			// IE6/7 will oversize a width 100% element inside a scrolling element, to
2183			// include the width of the scrollbar, while other browsers ensure the inner
2184			// element is contained without forcing scrolling
2185			browser.bScrollOversize = inner[0].offsetWidth === 100 && outer[0].clientWidth !== 100;
2186	
2187			// In rtl text layout, some browsers (most, but not all) will place the
2188			// scrollbar on the left, rather than the right.
2189			browser.bScrollbarLeft = Math.round( inner.offset().left ) !== 1;
2190	
2191			// IE8- don't provide height and width for getBoundingClientRect
2192			browser.bBounding = n[0].getBoundingClientRect().width ? true : false;
2193	
2194			n.remove();
2195		}
2196	
2197		$.extend( settings.oBrowser, DataTable.__browser );
2198		settings.oScroll.iBarWidth = DataTable.__browser.barWidth;
2199	}
2200	
2201	
2202	/**
2203	 * Array.prototype reduce[Right] method, used for browsers which don't support
2204	 * JS 1.6. Done this way to reduce code size, since we iterate either way
2205	 *  @param {object} settings dataTables settings object
2206	 *  @memberof DataTable#oApi
2207	 */
2208	function _fnReduce ( that, fn, init, start, end, inc )
2209	{
2210		var
2211			i = start,
2212			value,
2213			isSet = false;
2214	
2215		if ( init !== undefined ) {
2216			value = init;
2217			isSet = true;
2218		}
2219	
2220		while ( i !== end ) {
2221			if ( ! that.hasOwnProperty(i) ) {
2222				continue;
2223			}
2224	
2225			value = isSet ?
2226				fn( value, that[i], i, that ) :
2227				that[i];
2228	
2229			isSet = true;
2230			i += inc;
2231		}
2232	
2233		return value;
2234	}
2235	
2236	/**
2237	 * Add a column to the list used for the table with default values
2238	 *  @param {object} oSettings dataTables settings object
2239	 *  @param {node} nTh The th element for this column
2240	 *  @memberof DataTable#oApi
2241	 */
2242	function _fnAddColumn( oSettings, nTh )
2243	{
2244		// Add column to aoColumns array
2245		var oDefaults = DataTable.defaults.column;
2246		var iCol = oSettings.aoColumns.length;
2247		var oCol = $.extend( {}, DataTable.models.oColumn, oDefaults, {
2248			"nTh": nTh ? nTh : document.createElement('th'),
2249			"sTitle":    oDefaults.sTitle    ? oDefaults.sTitle    : nTh ? nTh.innerHTML : '',
2250			"aDataSort": oDefaults.aDataSort ? oDefaults.aDataSort : [iCol],
2251			"mData": oDefaults.mData ? oDefaults.mData : iCol,
2252			idx: iCol
2253		} );
2254		oSettings.aoColumns.push( oCol );
2255	
2256		// Add search object for column specific search. Note that the `searchCols[ iCol ]`
2257		// passed into extend can be undefined. This allows the user to give a default
2258		// with only some of the parameters defined, and also not give a default
2259		var searchCols = oSettings.aoPreSearchCols;
2260		searchCols[ iCol ] = $.extend( {}, DataTable.models.oSearch, searchCols[ iCol ] );
2261	
2262		// Use the default column options function to initialise classes etc
2263		_fnColumnOptions( oSettings, iCol, $(nTh).data() );
2264	}
2265	
2266	
2267	/**
2268	 * Apply options for a column
2269	 *  @param {object} oSettings dataTables settings object
2270	 *  @param {int} iCol column index to consider
2271	 *  @param {object} oOptions object with sType, bVisible and bSearchable etc
2272	 *  @memberof DataTable#oApi
2273	 */
2274	function _fnColumnOptions( oSettings, iCol, oOptions )
2275	{
2276		var oCol = oSettings.aoColumns[ iCol ];
2277		var oClasses = oSettings.oClasses;
2278		var th = $(oCol.nTh);
2279	
2280		// Try to get width information from the DOM. We can't get it from CSS
2281		// as we'd need to parse the CSS stylesheet. `width` option can override
2282		if ( ! oCol.sWidthOrig ) {
2283			// Width attribute
2284			oCol.sWidthOrig = th.attr('width') || null;
2285	
2286			// Style attribute
2287			var t = (th.attr('style') || '').match(/width:\s*(\d+[pxem%]+)/);
2288			if ( t ) {
2289				oCol.sWidthOrig = t[1];
2290			}
2291		}
2292	
2293		/* User specified column options */
2294		if ( oOptions !== undefined && oOptions !== null )
2295		{
2296			// Backwards compatibility
2297			_fnCompatCols( oOptions );
2298	
2299			// Map camel case parameters to their Hungarian counterparts
2300			_fnCamelToHungarian( DataTable.defaults.column, oOptions, true );
2301	
2302			/* Backwards compatibility for mDataProp */
2303			if ( oOptions.mDataProp !== undefined && !oOptions.mData )
2304			{
2305				oOptions.mData = oOptions.mDataProp;
2306			}
2307	
2308			if ( oOptions.sType )
2309			{
2310				oCol._sManualType = oOptions.sType;
2311			}
2312	
2313			// `class` is a reserved word in Javascript, so we need to provide
2314			// the ability to use a valid name for the camel case input
2315			if ( oOptions.className && ! oOptions.sClass )
2316			{
2317				oOptions.sClass = oOptions.className;
2318			}
2319			if ( oOptions.sClass ) {
2320				th.addClass( oOptions.sClass );
2321			}
2322	
2323			var origClass = oCol.sClass;
2324	
2325			$.extend( oCol, oOptions );
2326			_fnMap( oCol, oOptions, "sWidth", "sWidthOrig" );
2327	
2328			// Merge class from previously defined classes with this one, rather than just
2329			// overwriting it in the extend above
2330			if (origClass !== oCol.sClass) {
2331				oCol.sClass = origClass + ' ' + oCol.sClass;
2332			}
2333	
2334			/* iDataSort to be applied (backwards compatibility), but aDataSort will take
2335			 * priority if defined
2336			 */
2337			if ( oOptions.iDataSort !== undefined )
2338			{
2339				oCol.aDataSort = [ oOptions.iDataSort ];
2340			}
2341			_fnMap( oCol, oOptions, "aDataSort" );
2342		}
2343	
2344		/* Cache the data get and set functions for speed */
2345		var mDataSrc = oCol.mData;
2346		var mData = _fnGetObjectDataFn( mDataSrc );
2347		var mRender = oCol.mRender ? _fnGetObjectDataFn( oCol.mRender ) : null;
2348	
2349		var attrTest = function( src ) {
2350			return typeof src === 'string' && src.indexOf('@') !== -1;
2351		};
2352		oCol._bAttrSrc = $.isPlainObject( mDataSrc ) && (
2353			attrTest(mDataSrc.sort) || attrTest(mDataSrc.type) || attrTest(mDataSrc.filter)
2354		);
2355		oCol._setter = null;
2356	
2357		oCol.fnGetData = function (rowData, type, meta) {
2358			var innerData = mData( rowData, type, undefined, meta );
2359	
2360			return mRender && type ?
2361				mRender( innerData, type, rowData, meta ) :
2362				innerData;
2363		};
2364		oCol.fnSetData = function ( rowData, val, meta ) {
2365			return _fnSetObjectDataFn( mDataSrc )( rowData, val, meta );
2366		};
2367	
2368		// Indicate if DataTables should read DOM data as an object or array
2369		// Used in _fnGetRowElements
2370		if ( typeof mDataSrc !== 'number' && ! oCol._isArrayHost ) {
2371			oSettings._rowReadObject = true;
2372		}
2373	
2374		/* Feature sorting overrides column specific when off */
2375		if ( !oSettings.oFeatures.bSort )
2376		{
2377			oCol.bSortable = false;
2378			th.addClass( oClasses.sSortableNone ); // Have to add class here as order event isn't called
2379		}
2380	
2381		/* Check that the class assignment is correct for sorting */
2382		var bAsc = $.inArray('asc', oCol.asSorting) !== -1;
2383		var bDesc = $.inArray('desc', oCol.asSorting) !== -1;
2384		if ( !oCol.bSortable || (!bAsc && !bDesc) )
2385		{
2386			oCol.sSortingClass = oClasses.sSortableNone;
2387			oCol.sSortingClassJUI = "";
2388		}
2389		else if ( bAsc && !bDesc )
2390		{
2391			oCol.sSortingClass = oClasses.sSortableAsc;
2392			oCol.sSortingClassJUI = oClasses.sSortJUIAscAllowed;
2393		}
2394		else if ( !bAsc && bDesc )
2395		{
2396			oCol.sSortingClass = oClasses.sSortableDesc;
2397			oCol.sSortingClassJUI = oClasses.sSortJUIDescAllowed;
2398		}
2399		else
2400		{
2401			oCol.sSortingClass = oClasses.sSortable;
2402			oCol.sSortingClassJUI = oClasses.sSortJUI;
2403		}
2404	}
2405	
2406	
2407	/**
2408	 * Adjust the table column widths for new data. Note: you would probably want to
2409	 * do a redraw after calling this function!
2410	 *  @param {object} settings dataTables settings object
2411	 *  @memberof DataTable#oApi
2412	 */
2413	function _fnAdjustColumnSizing ( settings )
2414	{
2415		/* Not interested in doing column width calculation if auto-width is disabled */
2416		if ( settings.oFeatures.bAutoWidth !== false )
2417		{
2418			var columns = settings.aoColumns;
2419	
2420			_fnCalculateColumnWidths( settings );
2421			for ( var i=0 , iLen=columns.length ; i<iLen ; i++ )
2422			{
2423				columns[i].nTh.style.width = columns[i].sWidth;
2424			}
2425		}
2426	
2427		var scroll = settings.oScroll;
2428		if ( scroll.sY !== '' || scroll.sX !== '')
2429		{
2430			_fnScrollDraw( settings );
2431		}
2432	
2433		_fnCallbackFire( settings, null, 'column-sizing', [settings] );
2434	}
2435	
2436	
2437	/**
2438	 * Convert the index of a visible column to the index in the data array (take account
2439	 * of hidden columns)
2440	 *  @param {object} oSettings dataTables settings object
2441	 *  @param {int} iMatch Visible column index to lookup
2442	 *  @returns {int} i the data index
2443	 *  @memberof DataTable#oApi
2444	 */
2445	function _fnVisibleToColumnIndex( oSettings, iMatch )
2446	{
2447		var aiVis = _fnGetColumns( oSettings, 'bVisible' );
2448	
2449		return typeof aiVis[iMatch] === 'number' ?
2450			aiVis[iMatch] :
2451			null;
2452	}
2453	
2454	
2455	/**
2456	 * Convert the index of an index in the data array and convert it to the visible
2457	 *   column index (take account of hidden columns)
2458	 *  @param {int} iMatch Column index to lookup
2459	 *  @param {object} oSettings dataTables settings object
2460	 *  @returns {int} i the data index
2461	 *  @memberof DataTable#oApi
2462	 */
2463	function _fnColumnIndexToVisible( oSettings, iMatch )
2464	{
2465		var aiVis = _fnGetColumns( oSettings, 'bVisible' );
2466		var iPos = $.inArray( iMatch, aiVis );
2467	
2468		return iPos !== -1 ? iPos : null;
2469	}
2470	
2471	
2472	/**
2473	 * Get the number of visible columns
2474	 *  @param {object} oSettings dataTables settings object
2475	 *  @returns {int} i the number of visible columns
2476	 *  @memberof DataTable#oApi
2477	 */
2478	function _fnVisbleColumns( oSettings )
2479	{
2480		var vis = 0;
2481	
2482		// No reduce in IE8, use a loop for now
2483		$.each( oSettings.aoColumns, function ( i, col ) {
2484			if ( col.bVisible && $(col.nTh).css('display') !== 'none' ) {
2485				vis++;
2486			}
2487		} );
2488	
2489		return vis;
2490	}
2491	
2492	
2493	/**
2494	 * Get an array of column indexes that match a given property
2495	 *  @param {object} oSettings dataTables settings object
2496	 *  @param {string} sParam Parameter in aoColumns to look for - typically
2497	 *    bVisible or bSearchable
2498	 *  @returns {array} Array of indexes with matched properties
2499	 *  @memberof DataTable#oApi
2500	 */
2501	function _fnGetColumns( oSettings, sParam )
2502	{
2503		var a = [];
2504	
2505		$.map( oSettings.aoColumns, function(val, i) {
2506			if ( val[sParam] ) {
2507				a.push( i );
2508			}
2509		} );
2510	
2511		return a;
2512	}
2513	
2514	
2515	/**
2516	 * Calculate the 'type' of a column
2517	 *  @param {object} settings dataTables settings object
2518	 *  @memberof DataTable#oApi
2519	 */
2520	function _fnColumnTypes ( settings )
2521	{
2522		var columns = settings.aoColumns;
2523		var data = settings.aoData;
2524		var types = DataTable.ext.type.detect;
2525		var i, ien, j, jen, k, ken;
2526		var col, cell, detectedType, cache;
2527	
2528		// For each column, spin over the 
2529		for ( i=0, ien=columns.length ; i<ien ; i++ ) {
2530			col = columns[i];
2531			cache = [];
2532	
2533			if ( ! col.sType && col._sManualType ) {
2534				col.sType = col._sManualType;
2535			}
2536			else if ( ! col.sType ) {
2537				for ( j=0, jen=types.length ; j<jen ; j++ ) {
2538					for ( k=0, ken=data.length ; k<ken ; k++ ) {
2539						// Use a cache array so we only need to get the type data
2540						// from the formatter once (when using multiple detectors)
2541						if ( cache[k] === undefined ) {
2542							cache[k] = _fnGetCellData( settings, k, i, 'type' );
2543						}
2544	
2545						detectedType = types[j]( cache[k], settings );
2546	
2547						// If null, then this type can't apply to this column, so
2548						// rather than testing all cells, break out. There is an
2549						// exception for the last type which is `html`. We need to
2550						// scan all rows since it is possible to mix string and HTML
2551						// types
2552						if ( ! detectedType && j !== types.length-1 ) {
2553							break;
2554						}
2555	
2556						// Only a single match is needed for html type since it is
2557						// bottom of the pile and very similar to string - but it
2558						// must not be empty
2559						if ( detectedType === 'html' && ! _empty(cache[k]) ) {
2560							break;
2561						}
2562					}
2563	
2564					// Type is valid for all data points in the column - use this
2565					// type
2566					if ( detectedType ) {
2567						col.sType = detectedType;
2568						break;
2569					}
2570				}
2571	
2572				// Fall back - if no type was detected, always use string
2573				if ( ! col.sType ) {
2574					col.sType = 'string';
2575				}
2576			}
2577		}
2578	}
2579	
2580	
2581	/**
2582	 * Take the column definitions and static columns arrays and calculate how
2583	 * they relate to column indexes. The callback function will then apply the
2584	 * definition found for a column to a suitable configuration object.
2585	 *  @param {object} oSettings dataTables settings object
2586	 *  @param {array} aoColDefs The aoColumnDefs array that is to be applied
2587	 *  @param {array} aoCols The aoColumns array that defines columns individually
2588	 *  @param {function} fn Callback function - takes two parameters, the calculated
2589	 *    column index and the definition for that column.
2590	 *  @memberof DataTable#oApi
2591	 */
2592	function _fnApplyColumnDefs( oSettings, aoColDefs, aoCols, fn )
2593	{
2594		var i, iLen, j, jLen, k, kLen, def;
2595		var columns = oSettings.aoColumns;
2596	
2597		// Column definitions with aTargets
2598		if ( aoColDefs )
2599		{
2600			/* Loop over the definitions array - loop in reverse so first instance has priority */
2601			for ( i=aoColDefs.length-1 ; i>=0 ; i-- )
2602			{
2603				def = aoColDefs[i];
2604	
2605				/* Each definition can target multiple columns, as it is an array */
2606				var aTargets = def.target !== undefined
2607					? def.target
2608					: def.targets !== undefined
2609						? def.targets
2610						: def.aTargets;
2611	
2612				if ( ! Array.isArray( aTargets ) )
2613				{
2614					aTargets = [ aTargets ];
2615				}
2616	
2617				for ( j=0, jLen=aTargets.length ; j<jLen ; j++ )
2618				{
2619					if ( typeof aTargets[j] === 'number' && aTargets[j] >= 0 )
2620					{
2621						/* Add columns that we don't yet know about */
2622						while( columns.length <= aTargets[j] )
2623						{
2624							_fnAddColumn( oSettings );
2625						}
2626	
2627						/* Integer, basic index */
2628						fn( aTargets[j], def );
2629					}
2630					else if ( typeof aTargets[j] === 'number' && aTargets[j] < 0 )
2631					{
2632						/* Negative integer, right to left column counting */
2633						fn( columns.length+aTargets[j], def );
2634					}
2635					else if ( typeof aTargets[j] === 'string' )
2636					{
2637						/* Class name matching on TH element */
2638						for ( k=0, kLen=columns.length ; k<kLen ; k++ )
2639						{
2640							if ( aTargets[j] == "_all" ||
2641							     $(columns[k].nTh).hasClass( aTargets[j] ) )
2642							{
2643								fn( k, def );
2644							}
2645						}
2646					}
2647				}
2648			}
2649		}
2650	
2651		// Statically defined columns array
2652		if ( aoCols )
2653		{
2654			for ( i=0, iLen=aoCols.length ; i<iLen ; i++ )
2655			{
2656				fn( i, aoCols[i] );
2657			}
2658		}
2659	}
2660	
2661	/**
2662	 * Add a data array to the table, creating DOM node etc. This is the parallel to
2663	 * _fnGatherData, but for adding rows from a Javascript source, rather than a
2664	 * DOM source.
2665	 *  @param {object} oSettings dataTables settings object
2666	 *  @param {array} aData data array to be added
2667	 *  @param {node} [nTr] TR element to add to the table - optional. If not given,
2668	 *    DataTables will create a row automatically
2669	 *  @param {array} [anTds] Array of TD|TH elements for the row - must be given
2670	 *    if nTr is.
2671	 *  @returns {int} >=0 if successful (index of new aoData entry), -1 if failed
2672	 *  @memberof DataTable#oApi
2673	 */
2674	function _fnAddData ( oSettings, aDataIn, nTr, anTds )
2675	{
2676		/* Create the object for storing information about this new row */
2677		var iRow = oSettings.aoData.length;
2678		var oData = $.extend( true, {}, DataTable.models.oRow, {
2679			src: nTr ? 'dom' : 'data',
2680			idx: iRow
2681		} );
2682	
2683		oData._aData = aDataIn;
2684		oSettings.aoData.push( oData );
2685	
2686		/* Create the cells */
2687		var nTd, sThisType;
2688		var columns = oSettings.aoColumns;
2689	
2690		// Invalidate the column types as the new data needs to be revalidated
2691		for ( var i=0, iLen=columns.length ; i<iLen ; i++ )
2692		{
2693			columns[i].sType = null;
2694		}
2695	
2696		/* Add to the display array */
2697		oSettings.aiDisplayMaster.push( iRow );
2698	
2699		var id = oSettings.rowIdFn( aDataIn );
2700		if ( id !== undefined ) {
2701			oSettings.aIds[ id ] = oData;
2702		}
2703	
2704		/* Create the DOM information, or register it if already present */
2705		if ( nTr || ! oSettings.oFeatures.bDeferRender )
2706		{
2707			_fnCreateTr( oSettings, iRow, nTr, anTds );
2708		}
2709	
2710		return iRow;
2711	}
2712	
2713	
2714	/**
2715	 * Add one or more TR elements to the table. Generally we'd expect to
2716	 * use this for reading data from a DOM sourced table, but it could be
2717	 * used for an TR element. Note that if a TR is given, it is used (i.e.
2718	 * it is not cloned).
2719	 *  @param {object} settings dataTables settings object
2720	 *  @param {array|node|jQuery} trs The TR element(s) to add to the table
2721	 *  @returns {array} Array of indexes for the added rows
2722	 *  @memberof DataTable#oApi
2723	 */
2724	function _fnAddTr( settings, trs )
2725	{
2726		var row;
2727	
2728		// Allow an individual node to be passed in
2729		if ( ! (trs instanceof $) ) {
2730			trs = $(trs);
2731		}
2732	
2733		return trs.map( function (i, el) {
2734			row = _fnGetRowElements( settings, el );
2735			return _fnAddData( settings, row.data, el, row.cells );
2736		} );
2737	}
2738	
2739	
2740	/**
2741	 * Take a TR element and convert it to an index in aoData
2742	 *  @param {object} oSettings dataTables settings object
2743	 *  @param {node} n the TR element to find
2744	 *  @returns {int} index if the node is found, null if not
2745	 *  @memberof DataTable#oApi
2746	 */
2747	function _fnNodeToDataIndex( oSettings, n )
2748	{
2749		return (n._DT_RowIndex!==undefined) ? n._DT_RowIndex : null;
2750	}
2751	
2752	
2753	/**
2754	 * Take a TD element and convert it into a column data index (not the visible index)
2755	 *  @param {object} oSettings dataTables settings object
2756	 *  @param {int} iRow The row number the TD/TH can be found in
2757	 *  @param {node} n The TD/TH element to find
2758	 *  @returns {int} index if the node is found, -1 if not
2759	 *  @memberof DataTable#oApi
2760	 */
2761	function _fnNodeToColumnIndex( oSettings, iRow, n )
2762	{
2763		return $.inArray( n, oSettings.aoData[ iRow ].anCells );
2764	}
2765	
2766	
2767	/**
2768	 * Get the data for a given cell from the internal cache, taking into account data mapping
2769	 *  @param {object} settings dataTables settings object
2770	 *  @param {int} rowIdx aoData row id
2771	 *  @param {int} colIdx Column index
2772	 *  @param {string} type data get type ('display', 'type' 'filter|search' 'sort|order')
2773	 *  @returns {*} Cell data
2774	 *  @memberof DataTable#oApi
2775	 */
2776	function _fnGetCellData( settings, rowIdx, colIdx, type )
2777	{
2778		if (type === 'search') {
2779			type = 'filter';
2780		}
2781		else if (type === 'order') {
2782			type = 'sort';
2783		}
2784	
2785		var draw           = settings.iDraw;
2786		var col            = settings.aoColumns[colIdx];
2787		var rowData        = settings.aoData[rowIdx]._aData;
2788		var defaultContent = col.sDefaultContent;
2789		var cellData       = col.fnGetData( rowData, type, {
2790			settings: settings,
2791			row:      rowIdx,
2792			col:      colIdx
2793		} );
2794	
2795		if ( cellData === undefined ) {
2796			if ( settings.iDrawError != draw && defaultContent === null ) {
2797				_fnLog( settings, 0, "Requested unknown parameter "+
2798					(typeof col.mData=='function' ? '{function}' : "'"+col.mData+"'")+
2799					" for row "+rowIdx+", column "+colIdx, 4 );
2800				settings.iDrawError = draw;
2801			}
2802			return defaultContent;
2803		}
2804	
2805		// When the data source is null and a specific data type is requested (i.e.
2806		// not the original data), we can use default column data
2807		if ( (cellData === rowData || cellData === null) && defaultContent !== null && type !== undefined ) {
2808			cellData = defaultContent;
2809		}
2810		else if ( typeof cellData === 'function' ) {
2811			// If the data source is a function, then we run it and use the return,
2812			// executing in the scope of the data object (for instances)
2813			return cellData.call( rowData );
2814		}
2815	
2816		if ( cellData === null && type === 'display' ) {
2817			return '';
2818		}
2819	
2820		if ( type === 'filter' ) {
2821			var fomatters = DataTable.ext.type.search;
2822	
2823			if ( fomatters[ col.sType ] ) {
2824				cellData = fomatters[ col.sType ]( cellData );
2825			}
2826		}
2827	
2828		return cellData;
2829	}
2830	
2831	
2832	/**
2833	 * Set the value for a specific cell, into the internal data cache
2834	 *  @param {object} settings dataTables settings object
2835	 *  @param {int} rowIdx aoData row id
2836	 *  @param {int} colIdx Column index
2837	 *  @param {*} val Value to set
2838	 *  @memberof DataTable#oApi
2839	 */
2840	function _fnSetCellData( settings, rowIdx, colIdx, val )
2841	{
2842		var col     = settings.aoColumns[colIdx];
2843		var rowData = settings.aoData[rowIdx]._aData;
2844	
2845		col.fnSetData( rowData, val, {
2846			settings: settings,
2847			row:      rowIdx,
2848			col:      colIdx
2849		}  );
2850	}
2851	
2852	
2853	// Private variable that is used to match action syntax in the data property object
2854	var __reArray = /\[.*?\]$/;
2855	var __reFn = /\(\)$/;
2856	
2857	/**
2858	 * Split string on periods, taking into account escaped periods
2859	 * @param  {string} str String to split
2860	 * @return {array} Split string
2861	 */
2862	function _fnSplitObjNotation( str )
2863	{
2864		return $.map( str.match(/(\\.|[^\.])+/g) || [''], function ( s ) {
2865			return s.replace(/\\\./g, '.');
2866		} );
2867	}
2868	
2869	
2870	/**
2871	 * Return a function that can be used to get data from a source object, taking
2872	 * into account the ability to use nested objects as a source
2873	 *  @param {string|int|function} mSource The data source for the object
2874	 *  @returns {function} Data get function
2875	 *  @memberof DataTable#oApi
2876	 */
2877	var _fnGetObjectDataFn = DataTable.util.get;
2878	
2879	
2880	/**
2881	 * Return a function that can be used to set data from a source object, taking
2882	 * into account the ability to use nested objects as a source
2883	 *  @param {string|int|function} mSource The data source for the object
2884	 *  @returns {function} Data set function
2885	 *  @memberof DataTable#oApi
2886	 */
2887	var _fnSetObjectDataFn = DataTable.util.set;
2888	
2889	
2890	/**
2891	 * Return an array with the full table data
2892	 *  @param {object} oSettings dataTables settings object
2893	 *  @returns array {array} aData Master data array
2894	 *  @memberof DataTable#oApi
2895	 */
2896	function _fnGetDataMaster ( settings )
2897	{
2898		return _pluck( settings.aoData, '_aData' );
2899	}
2900	
2901	
2902	/**
2903	 * Nuke the table
2904	 *  @param {object} oSettings dataTables settings object
2905	 *  @memberof DataTable#oApi
2906	 */
2907	function _fnClearTable( settings )
2908	{
2909		settings.aoData.length = 0;
2910		settings.aiDisplayMaster.length = 0;
2911		settings.aiDisplay.length = 0;
2912		settings.aIds = {};
2913	}
2914	
2915	
2916	 /**
2917	 * Take an array of integers (index array) and remove a target integer (value - not
2918	 * the key!)
2919	 *  @param {array} a Index array to target
2920	 *  @param {int} iTarget value to find
2921	 *  @memberof DataTable#oApi
2922	 */
2923	function _fnDeleteIndex( a, iTarget, splice )
2924	{
2925		var iTargetIndex = -1;
2926	
2927		for ( var i=0, iLen=a.length ; i<iLen ; i++ )
2928		{
2929			if ( a[i] == iTarget )
2930			{
2931				iTargetIndex = i;
2932			}
2933			else if ( a[i] > iTarget )
2934			{
2935				a[i]--;
2936			}
2937		}
2938	
2939		if ( iTargetIndex != -1 && splice === undefined )
2940		{
2941			a.splice( iTargetIndex, 1 );
2942		}
2943	}
2944	
2945	
2946	/**
2947	 * Mark cached data as invalid such that a re-read of the data will occur when
2948	 * the cached data is next requested. Also update from the data source object.
2949	 *
2950	 * @param {object} settings DataTables settings object
2951	 * @param {int}    rowIdx   Row index to invalidate
2952	 * @param {string} [src]    Source to invalidate from: undefined, 'auto', 'dom'
2953	 *     or 'data'
2954	 * @param {int}    [colIdx] Column index to invalidate. If undefined the whole
2955	 *     row will be invalidated
2956	 * @memberof DataTable#oApi
2957	 *
2958	 * @todo For the modularisation of v1.11 this will need to become a callback, so
2959	 *   the sort and filter methods can subscribe to it. That will required
2960	 *   initialisation options for sorting, which is why it is not already baked in
2961	 */
2962	function _fnInvalidate( settings, rowIdx, src, colIdx )
2963	{
2964		var row = settings.aoData[ rowIdx ];
2965		var i, ien;
2966		var cellWrite = function ( cell, col ) {
2967			// This is very frustrating, but in IE if you just write directly
2968			// to innerHTML, and elements that are overwritten are GC'ed,
2969			// even if there is a reference to them elsewhere
2970			while ( cell.childNodes.length ) {
2971				cell.removeChild( cell.firstChild );
2972			}
2973	
2974			cell.innerHTML = _fnGetCellData( settings, rowIdx, col, 'display' );
2975		};
2976	
2977		// Are we reading last data from DOM or the data object?
2978		if ( src === 'dom' || ((! src || src === 'auto') && row.src === 'dom') ) {
2979			// Read the data from the DOM
2980			row._aData = _fnGetRowElements(
2981					settings, row, colIdx, colIdx === undefined ? undefined : row._aData
2982				)
2983				.data;
2984		}
2985		else {
2986			// Reading from data object, update the DOM
2987			var cells = row.anCells;
2988	
2989			if ( cells ) {
2990				if ( colIdx !== undefined ) {
2991					cellWrite( cells[colIdx], colIdx );
2992				}
2993				else {
2994					for ( i=0, ien=cells.length ; i<ien ; i++ ) {
2995						cellWrite( cells[i], i );
2996					}
2997				}
2998			}
2999		}
3000	
3001		// For both row and cell invalidation, the cached data for sorting and
3002		// filtering is nulled out
3003		row._aSortData = null;
3004		row._aFilterData = null;
3005	
3006		// Invalidate the type for a specific column (if given) or all columns since
3007		// the data might have changed
3008		var cols = settings.aoColumns;
3009		if ( colIdx !== undefined ) {
3010			cols[ colIdx ].sType = null;
3011		}
3012		else {
3013			for ( i=0, ien=cols.length ; i<ien ; i++ ) {
3014				cols[i].sType = null;
3015			}
3016	
3017			// Update DataTables special `DT_*` attributes for the row
3018			_fnRowAttributes( settings, row );
3019		}
3020	}
3021	
3022	
3023	/**
3024	 * Build a data source object from an HTML row, reading the contents of the
3025	 * cells that are in the row.
3026	 *
3027	 * @param {object} settings DataTables settings object
3028	 * @param {node|object} TR element from which to read data or existing row
3029	 *   object from which to re-read the data from the cells
3030	 * @param {int} [colIdx] Optional column index
3031	 * @param {array|object} [d] Data source object. If `colIdx` is given then this
3032	 *   parameter should also be given and will be used to write the data into.
3033	 *   Only the column in question will be written
3034	 * @returns {object} Object with two parameters: `data` the data read, in
3035	 *   document order, and `cells` and array of nodes (they can be useful to the
3036	 *   caller, so rather than needing a second traversal to get them, just return
3037	 *   them from here).
3038	 * @memberof DataTable#oApi
3039	 */
3040	function _fnGetRowElements( settings, row, colIdx, d )
3041	{
3042		var
3043			tds = [],
3044			td = row.firstChild,
3045			name, col, o, i=0, contents,
3046			columns = settings.aoColumns,
3047			objectRead = settings._rowReadObject;
3048	
3049		// Allow the data object to be passed in, or construct
3050		d = d !== undefined ?
3051			d :
3052			objectRead ?
3053				{} :
3054				[];
3055	
3056		var attr = function ( str, td  ) {
3057			if ( typeof str === 'string' ) {
3058				var idx = str.indexOf('@');
3059	
3060				if ( idx !== -1 ) {
3061					var attr = str.substring( idx+1 );
3062					var setter = _fnSetObjectDataFn( str );
3063					setter( d, td.getAttribute( attr ) );
3064				}
3065			}
3066		};
3067	
3068		// Read data from a cell and store into the data object
3069		var cellProcess = function ( cell ) {
3070			if ( colIdx === undefined || colIdx === i ) {
3071				col = columns[i];
3072				contents = (cell.innerHTML).trim();
3073	
3074				if ( col && col._bAttrSrc ) {
3075					var setter = _fnSetObjectDataFn( col.mData._ );
3076					setter( d, contents );
3077	
3078					attr( col.mData.sort, cell );
3079					attr( col.mData.type, cell );
3080					attr( col.mData.filter, cell );
3081				}
3082				else {
3083					// Depending on the `data` option for the columns the data can
3084					// be read to either an object or an array.
3085					if ( objectRead ) {
3086						if ( ! col._setter ) {
3087							// Cache the setter function
3088							col._setter = _fnSetObjectDataFn( col.mData );
3089						}
3090						col._setter( d, contents );
3091					}
3092					else {
3093						d[i] = contents;
3094					}
3095				}
3096			}
3097	
3098			i++;
3099		};
3100	
3101		if ( td ) {
3102			// `tr` element was passed in
3103			while ( td ) {
3104				name = td.nodeName.toUpperCase();
3105	
3106				if ( name == "TD" || name == "TH" ) {
3107					cellProcess( td );
3108					tds.push( td );
3109				}
3110	
3111				td = td.nextSibling;
3112			}
3113		}
3114		else {
3115			// Existing row object passed in
3116			tds = row.anCells;
3117	
3118			for ( var j=0, jen=tds.length ; j<jen ; j++ ) {
3119				cellProcess( tds[j] );
3120			}
3121		}
3122	
3123		// Read the ID from the DOM if present
3124		var rowNode = row.firstChild ? row : row.nTr;
3125	
3126		if ( rowNode ) {
3127			var id = rowNode.getAttribute( 'id' );
3128	
3129			if ( id ) {
3130				_fnSetObjectDataFn( settings.rowId )( d, id );
3131			}
3132		}
3133	
3134		return {
3135			data: d,
3136			cells: tds
3137		};
3138	}
3139	/**
3140	 * Create a new TR element (and it's TD children) for a row
3141	 *  @param {object} oSettings dataTables settings object
3142	 *  @param {int} iRow Row to consider
3143	 *  @param {node} [nTrIn] TR element to add to the table - optional. If not given,
3144	 *    DataTables will create a row automatically
3145	 *  @param {array} [anTds] Array of TD|TH elements for the row - must be given
3146	 *    if nTr is.
3147	 *  @memberof DataTable#oApi
3148	 */
3149	function _fnCreateTr ( oSettings, iRow, nTrIn, anTds )
3150	{
3151		var
3152			row = oSettings.aoData[iRow],
3153			rowData = row._aData,
3154			cells = [],
3155			nTr, nTd, oCol,
3156			i, iLen, create;
3157	
3158		if ( row.nTr === null )
3159		{
3160			nTr = nTrIn || document.createElement('tr');
3161	
3162			row.nTr = nTr;
3163			row.anCells = cells;
3164	
3165			/* Use a private property on the node to allow reserve mapping from the node
3166			 * to the aoData array for fast look up
3167			 */
3168			nTr._DT_RowIndex = iRow;
3169	
3170			/* Special parameters can be given by the data source to be used on the row */
3171			_fnRowAttributes( oSettings, row );
3172	
3173			/* Process each column */
3174			for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
3175			{
3176				oCol = oSettings.aoColumns[i];
3177				create = nTrIn ? false : true;
3178	
3179				nTd = create ? document.createElement( oCol.sCellType ) : anTds[i];
3180	
3181				if (! nTd) {
3182					_fnLog( oSettings, 0, 'Incorrect column count', 18 );
3183				}
3184	
3185				nTd._DT_CellIndex = {
3186					row: iRow,
3187					column: i
3188				};
3189				
3190				cells.push( nTd );
3191	
3192				// Need to create the HTML if new, or if a rendering function is defined
3193				if ( create || ((oCol.mRender || oCol.mData !== i) &&
3194					 (!$.isPlainObject(oCol.mData) || oCol.mData._ !== i+'.display')
3195				)) {
3196					nTd.innerHTML = _fnGetCellData( oSettings, iRow, i, 'display' );
3197				}
3198	
3199				/* Add user defined class */
3200				if ( oCol.sClass )
3201				{
3202					nTd.className += ' '+oCol.sClass;
3203				}
3204	
3205				// Visibility - add or remove as required
3206				if ( oCol.bVisible && ! nTrIn )
3207				{
3208					nTr.appendChild( nTd );
3209				}
3210				else if ( ! oCol.bVisible && nTrIn )
3211				{
3212					nTd.parentNode.removeChild( nTd );
3213				}
3214	
3215				if ( oCol.fnCreatedCell )
3216				{
3217					oCol.fnCreatedCell.call( oSettings.oInstance,
3218						nTd, _fnGetCellData( oSettings, iRow, i ), rowData, iRow, i
3219					);
3220				}
3221			}
3222	
3223			_fnCallbackFire( oSettings, 'aoRowCreatedCallback', null, [nTr, rowData, iRow, cells] );
3224		}
3225	}
3226	
3227	
3228	/**
3229	 * Add attributes to a row based on the special `DT_*` parameters in a data
3230	 * source object.
3231	 *  @param {object} settings DataTables settings object
3232	 *  @param {object} DataTables row object for the row to be modified
3233	 *  @memberof DataTable#oApi
3234	 */
3235	function _fnRowAttributes( settings, row )
3236	{
3237		var tr = row.nTr;
3238		var data = row._aData;
3239	
3240		if ( tr ) {
3241			var id = settings.rowIdFn( data );
3242	
3243			if ( id ) {
3244				tr.id = id;
3245			}
3246	
3247			if ( data.DT_RowClass ) {
3248				// Remove any classes added by DT_RowClass before
3249				var a = data.DT_RowClass.split(' ');
3250				row.__rowc = row.__rowc ?
3251					_unique( row.__rowc.concat( a ) ) :
3252					a;
3253	
3254				$(tr)
3255					.removeClass( row.__rowc.join(' ') )
3256					.addClass( data.DT_RowClass );
3257			}
3258	
3259			if ( data.DT_RowAttr ) {
3260				$(tr).attr( data.DT_RowAttr );
3261			}
3262	
3263			if ( data.DT_RowData ) {
3264				$(tr).data( data.DT_RowData );
3265			}
3266		}
3267	}
3268	
3269	
3270	/**
3271	 * Create the HTML header for the table
3272	 *  @param {object} oSettings dataTables settings object
3273	 *  @memberof DataTable#oApi
3274	 */
3275	function _fnBuildHead( oSettings )
3276	{
3277		var i, ien, cell, row, column;
3278		var thead = oSettings.nTHead;
3279		var tfoot = oSettings.nTFoot;
3280		var createHeader = $('th, td', thead).length === 0;
3281		var classes = oSettings.oClasses;
3282		var columns = oSettings.aoColumns;
3283	
3284		if ( createHeader ) {
3285			row = $('<tr/>').appendTo( thead );
3286		}
3287	
3288		for ( i=0, ien=columns.length ; i<ien ; i++ ) {
3289			column = columns[i];
3290			cell = $( column.nTh ).addClass( column.sClass );
3291	
3292			if ( createHeader ) {
3293				cell.appendTo( row );
3294			}
3295	
3296			// 1.11 move into sorting
3297			if ( oSettings.oFeatures.bSort ) {
3298				cell.addClass( column.sSortingClass );
3299	
3300				if ( column.bSortable !== false ) {
3301					cell
3302						.attr( 'tabindex', oSettings.iTabIndex )
3303						.attr( 'aria-controls', oSettings.sTableId );
3304	
3305					_fnSortAttachListener( oSettings, column.nTh, i );
3306				}
3307			}
3308	
3309			if ( column.sTitle != cell[0].innerHTML ) {
3310				cell.html( column.sTitle );
3311			}
3312	
3313			_fnRenderer( oSettings, 'header' )(
3314				oSettings, cell, column, classes
3315			);
3316		}
3317	
3318		if ( createHeader ) {
3319			_fnDetectHeader( oSettings.aoHeader, thead );
3320		}
3321	
3322		/* Deal with the footer - add classes if required */
3323		$(thead).children('tr').children('th, td').addClass( classes.sHeaderTH );
3324		$(tfoot).children('tr').children('th, td').addClass( classes.sFooterTH );
3325	
3326		// Cache the footer cells. Note that we only take the cells from the first
3327		// row in the footer. If there is more than one row the user wants to
3328		// interact with, they need to use the table().foot() method. Note also this
3329		// allows cells to be used for multiple columns using colspan
3330		if ( tfoot !== null ) {
3331			var cells = oSettings.aoFooter[0];
3332	
3333			for ( i=0, ien=cells.length ; i<ien ; i++ ) {
3334				column = columns[i];
3335	
3336				if (column) {
3337					column.nTf = cells[i].cell;
3338		
3339					if ( column.sClass ) {
3340						$(column.nTf).addClass( column.sClass );
3341					}
3342				}
3343				else {
3344					_fnLog( oSettings, 0, 'Incorrect column count', 18 );
3345				}
3346			}
3347		}
3348	}
3349	
3350	
3351	/**
3352	 * Draw the header (or footer) element based on the column visibility states. The
3353	 * methodology here is to use the layout array from _fnDetectHeader, modified for
3354	 * the instantaneous column visibility, to construct the new layout. The grid is
3355	 * traversed over cell at a time in a rows x columns grid fashion, although each
3356	 * cell insert can cover multiple elements in the grid - which is tracks using the
3357	 * aApplied array. Cell inserts in the grid will only occur where there isn't
3358	 * already a cell in that position.
3359	 *  @param {object} oSettings dataTables settings object
3360	 *  @param array {objects} aoSource Layout array from _fnDetectHeader
3361	 *  @param {boolean} [bIncludeHidden=false] If true then include the hidden columns in the calc,
3362	 *  @memberof DataTable#oApi
3363	 */
3364	function _fnDrawHead( oSettings, aoSource, bIncludeHidden )
3365	{
3366		var i, iLen, j, jLen, k, kLen, n, nLocalTr;
3367		var aoLocal = [];
3368		var aApplied = [];
3369		var iColumns = oSettings.aoColumns.length;
3370		var iRowspan, iColspan;
3371	
3372		if ( ! aoSource )
3373		{
3374			return;
3375		}
3376	
3377		if (  bIncludeHidden === undefined )
3378		{
3379			bIncludeHidden = false;
3380		}
3381	
3382		/* Make a copy of the master layout array, but without the visible columns in it */
3383		for ( i=0, iLen=aoSource.length ; i<iLen ; i++ )
3384		{
3385			aoLocal[i] = aoSource[i].slice();
3386			aoLocal[i].nTr = aoSource[i].nTr;
3387	
3388			/* Remove any columns which are currently hidden */
3389			for ( j=iColumns-1 ; j>=0 ; j-- )
3390			{
3391				if ( !oSettings.aoColumns[j].bVisible && !bIncludeHidden )
3392				{
3393					aoLocal[i].splice( j, 1 );
3394				}
3395			}
3396	
3397			/* Prep the applied array - it needs an element for each row */
3398			aApplied.push( [] );
3399		}
3400	
3401		for ( i=0, iLen=aoLocal.length ; i<iLen ; i++ )
3402		{
3403			nLocalTr = aoLocal[i].nTr;
3404	
3405			/* All cells are going to be replaced, so empty out the row */
3406			if ( nLocalTr )
3407			{
3408				while( (n = nLocalTr.firstChild) )
3409				{
3410					nLocalTr.removeChild( n );
3411				}
3412			}
3413	
3414			for ( j=0, jLen=aoLocal[i].length ; j<jLen ; j++ )
3415			{
3416				iRowspan = 1;
3417				iColspan = 1;
3418	
3419				/* Check to see if there is already a cell (row/colspan) covering our target
3420				 * insert point. If there is, then there is nothing to do.
3421				 */
3422				if ( aApplied[i][j] === undefined )
3423				{
3424					nLocalTr.appendChild( aoLocal[i][j].cell );
3425					aApplied[i][j] = 1;
3426	
3427					/* Expand the cell to cover as many rows as needed */
3428					while ( aoLocal[i+iRowspan] !== undefined &&
3429					        aoLocal[i][j].cell == aoLocal[i+iRowspan][j].cell )
3430					{
3431						aApplied[i+iRowspan][j] = 1;
3432						iRowspan++;
3433					}
3434	
3435					/* Expand the cell to cover as many columns as needed */
3436					while ( aoLocal[i][j+iColspan] !== undefined &&
3437					        aoLocal[i][j].cell == aoLocal[i][j+iColspan].cell )
3438					{
3439						/* Must update the applied array over the rows for the columns */
3440						for ( k=0 ; k<iRowspan ; k++ )
3441						{
3442							aApplied[i+k][j+iColspan] = 1;
3443						}
3444						iColspan++;
3445					}
3446	
3447					/* Do the actual expansion in the DOM */
3448					$(aoLocal[i][j].cell)
3449						.attr('rowspan', iRowspan)
3450						.attr('colspan', iColspan);
3451				}
3452			}
3453		}
3454	}
3455	
3456	
3457	/**
3458	 * Insert the required TR nodes into the table for display
3459	 *  @param {object} oSettings dataTables settings object
3460	 *  @param ajaxComplete true after ajax call to complete rendering
3461	 *  @memberof DataTable#oApi
3462	 */
3463	function _fnDraw( oSettings, ajaxComplete )
3464	{
3465		// Allow for state saving and a custom start position
3466		_fnStart( oSettings );
3467	
3468		/* Provide a pre-callback function which can be used to cancel the draw is false is returned */
3469		var aPreDraw = _fnCallbackFire( oSettings, 'aoPreDrawCallback', 'preDraw', [oSettings] );
3470		if ( $.inArray( false, aPreDraw ) !== -1 )
3471		{
3472			_fnProcessingDisplay( oSettings, false );
3473			return;
3474		}
3475	
3476		var anRows = [];
3477		var iRowCount = 0;
3478		var asStripeClasses = oSettings.asStripeClasses;
3479		var iStripes = asStripeClasses.length;
3480		var oLang = oSettings.oLanguage;
3481		var bServerSide = _fnDataSource( oSettings ) == 'ssp';
3482		var aiDisplay = oSettings.aiDisplay;
3483		var iDisplayStart = oSettings._iDisplayStart;
3484		var iDisplayEnd = oSettings.fnDisplayEnd();
3485	
3486		oSettings.bDrawing = true;
3487	
3488		/* Server-side processing draw intercept */
3489		if ( oSettings.bDeferLoading )
3490		{
3491			oSettings.bDeferLoading = false;
3492			oSettings.iDraw++;
3493			_fnProcessingDisplay( oSettings, false );
3494		}
3495		else if ( !bServerSide )
3496		{
3497			oSettings.iDraw++;
3498		}
3499		else if ( !oSettings.bDestroying && !ajaxComplete)
3500		{
3501			_fnAjaxUpdate( oSettings );
3502			return;
3503		}
3504	
3505		if ( aiDisplay.length !== 0 )
3506		{
3507			var iStart = bServerSide ? 0 : iDisplayStart;
3508			var iEnd = bServerSide ? oSettings.aoData.length : iDisplayEnd;
3509	
3510			for ( var j=iStart ; j<iEnd ; j++ )
3511			{
3512				var iDataIndex = aiDisplay[j];
3513				var aoData = oSettings.aoData[ iDataIndex ];
3514				if ( aoData.nTr === null )
3515				{
3516					_fnCreateTr( oSettings, iDataIndex );
3517				}
3518	
3519				var nRow = aoData.nTr;
3520	
3521				/* Remove the old striping classes and then add the new one */
3522				if ( iStripes !== 0 )
3523				{
3524					var sStripe = asStripeClasses[ iRowCount % iStripes ];
3525					if ( aoData._sRowStripe != sStripe )
3526					{
3527						$(nRow).removeClass( aoData._sRowStripe ).addClass( sStripe );
3528						aoData._sRowStripe = sStripe;
3529					}
3530				}
3531	
3532				// Row callback functions - might want to manipulate the row
3533				// iRowCount and j are not currently documented. Are they at all
3534				// useful?
3535				_fnCallbackFire( oSettings, 'aoRowCallback', null,
3536					[nRow, aoData._aData, iRowCount, j, iDataIndex] );
3537	
3538				anRows.push( nRow );
3539				iRowCount++;
3540			}
3541		}
3542		else
3543		{
3544			/* Table is empty - create a row with an empty message in it */
3545			var sZero = oLang.sZeroRecords;
3546			if ( oSettings.iDraw == 1 &&  _fnDataSource( oSettings ) == 'ajax' )
3547			{
3548				sZero = oLang.sLoadingRecords;
3549			}
3550			else if ( oLang.sEmptyTable && oSettings.fnRecordsTotal() === 0 )
3551			{
3552				sZero = oLang.sEmptyTable;
3553			}
3554	
3555			anRows[ 0 ] = $( '<tr/>', { 'class': iStripes ? asStripeClasses[0] : '' } )
3556				.append( $('<td />', {
3557					'valign':  'top',
3558					'colSpan': _fnVisbleColumns( oSettings ),
3559					'class':   oSettings.oClasses.sRowEmpty
3560				} ).html( sZero ) )[0];
3561		}
3562	
3563		/* Header and footer callbacks */
3564		_fnCallbackFire( oSettings, 'aoHeaderCallback', 'header', [ $(oSettings.nTHead).children('tr')[0],
3565			_fnGetDataMaster( oSettings ), iDisplayStart, iDisplayEnd, aiDisplay ] );
3566	
3567		_fnCallbackFire( oSettings, 'aoFooterCallback', 'footer', [ $(oSettings.nTFoot).children('tr')[0],
3568			_fnGetDataMaster( oSettings ), iDisplayStart, iDisplayEnd, aiDisplay ] );
3569	
3570		var body = $(oSettings.nTBody);
3571	
3572		body.children().detach();
3573		body.append( $(anRows) );
3574	
3575		/* Call all required callback functions for the end of a draw */
3576		_fnCallbackFire( oSettings, 'aoDrawCallback', 'draw', [oSettings] );
3577	
3578		/* Draw is complete, sorting and filtering must be as well */
3579		oSettings.bSorted = false;
3580		oSettings.bFiltered = false;
3581		oSettings.bDrawing = false;
3582	}
3583	
3584	
3585	/**
3586	 * Redraw the table - taking account of the various features which are enabled
3587	 *  @param {object} oSettings dataTables settings object
3588	 *  @param {boolean} [holdPosition] Keep the current paging position. By default
3589	 *    the paging is reset to the first page
3590	 *  @memberof DataTable#oApi
3591	 */
3592	function _fnReDraw( settings, holdPosition )
3593	{
3594		var
3595			features = settings.oFeatures,
3596			sort     = features.bSort,
3597			filter   = features.bFilter;
3598	
3599		if ( sort ) {
3600			_fnSort( settings );
3601		}
3602	
3603		if ( filter ) {
3604			_fnFilterComplete( settings, settings.oPreviousSearch );
3605		}
3606		else {
3607			// No filtering, so we want to just use the display master
3608			settings.aiDisplay = settings.aiDisplayMaster.slice();
3609		}
3610	
3611		if ( holdPosition !== true ) {
3612			settings._iDisplayStart = 0;
3613		}
3614	
3615		// Let any modules know about the draw hold position state (used by
3616		// scrolling internally)
3617		settings._drawHold = holdPosition;
3618	
3619		_fnDraw( settings );
3620	
3621		settings._drawHold = false;
3622	}
3623	
3624	
3625	/**
3626	 * Add the options to the page HTML for the table
3627	 *  @param {object} oSettings dataTables settings object
3628	 *  @memberof DataTable#oApi
3629	 */
3630	function _fnAddOptionsHtml ( oSettings )
3631	{
3632		var classes = oSettings.oClasses;
3633		var table = $(oSettings.nTable);
3634		var holding = $('<div/>').insertBefore( table ); // Holding element for speed
3635		var features = oSettings.oFeatures;
3636	
3637		// All DataTables are wrapped in a div
3638		var insert = $('<div/>', {
3639			id:      oSettings.sTableId+'_wrapper',
3640			'class': classes.sWrapper + (oSettings.nTFoot ? '' : ' '+classes.sNoFooter)
3641		} );
3642	
3643		oSettings.nHolding = holding[0];
3644		oSettings.nTableWrapper = insert[0];
3645		oSettings.nTableReinsertBefore = oSettings.nTable.nextSibling;
3646	
3647		/* Loop over the user set positioning and place the elements as needed */
3648		var aDom = oSettings.sDom.split('');
3649		var featureNode, cOption, nNewNode, cNext, sAttr, j;
3650		for ( var i=0 ; i<aDom.length ; i++ )
3651		{
3652			featureNode = null;
3653			cOption = aDom[i];
3654	
3655			if ( cOption == '<' )
3656			{
3657				/* New container div */
3658				nNewNode = $('<div/>')[0];
3659	
3660				/* Check to see if we should append an id and/or a class name to the container */
3661				cNext = aDom[i+1];
3662				if ( cNext == "'" || cNext == '"' )
3663				{
3664					sAttr = "";
3665					j = 2;
3666					while ( aDom[i+j] != cNext )
3667					{
3668						sAttr += aDom[i+j];
3669						j++;
3670					}
3671	
3672					/* Replace jQuery UI constants @todo depreciated */
3673					if ( sAttr == "H" )
3674					{
3675						sAttr = classes.sJUIHeader;
3676					}
3677					else if ( sAttr == "F" )
3678					{
3679						sAttr = classes.sJUIFooter;
3680					}
3681	
3682					/* The attribute can be in the format of "#id.class", "#id" or "class" This logic
3683					 * breaks the string into parts and applies them as needed
3684					 */
3685					if ( sAttr.indexOf('.') != -1 )
3686					{
3687						var aSplit = sAttr.split('.');
3688						nNewNode.id = aSplit[0].substr(1, aSplit[0].length-1);
3689						nNewNode.className = aSplit[1];
3690					}
3691					else if ( sAttr.charAt(0) == "#" )
3692					{
3693						nNewNode.id = sAttr.substr(1, sAttr.length-1);
3694					}
3695					else
3696					{
3697						nNewNode.className = sAttr;
3698					}
3699	
3700					i += j; /* Move along the position array */
3701				}
3702	
3703				insert.append( nNewNode );
3704				insert = $(nNewNode);
3705			}
3706			else if ( cOption == '>' )
3707			{
3708				/* End container div */
3709				insert = insert.parent();
3710			}
3711			// @todo Move options into their own plugins?
3712			else if ( cOption == 'l' && features.bPaginate && features.bLengthChange )
3713			{
3714				/* Length */
3715				featureNode = _fnFeatureHtmlLength( oSettings );
3716			}
3717			else if ( cOption == 'f' && features.bFilter )
3718			{
3719				/* Filter */
3720				featureNode = _fnFeatureHtmlFilter( oSettings );
3721			}
3722			else if ( cOption == 'r' && features.bProcessing )
3723			{
3724				/* pRocessing */
3725				featureNode = _fnFeatureHtmlProcessing( oSettings );
3726			}
3727			else if ( cOption == 't' )
3728			{
3729				/* Table */
3730				featureNode = _fnFeatureHtmlTable( oSettings );
3731			}
3732			else if ( cOption ==  'i' && features.bInfo )
3733			{
3734				/* Info */
3735				featureNode = _fnFeatureHtmlInfo( oSettings );
3736			}
3737			else if ( cOption == 'p' && features.bPaginate )
3738			{
3739				/* Pagination */
3740				featureNode = _fnFeatureHtmlPaginate( oSettings );
3741			}
3742			else if ( DataTable.ext.feature.length !== 0 )
3743			{
3744				/* Plug-in features */
3745				var aoFeatures = DataTable.ext.feature;
3746				for ( var k=0, kLen=aoFeatures.length ; k<kLen ; k++ )
3747				{
3748					if ( cOption == aoFeatures[k].cFeature )
3749					{
3750						featureNode = aoFeatures[k].fnInit( oSettings );
3751						break;
3752					}
3753				}
3754			}
3755	
3756			/* Add to the 2D features array */
3757			if ( featureNode )
3758			{
3759				var aanFeatures = oSettings.aanFeatures;
3760	
3761				if ( ! aanFeatures[cOption] )
3762				{
3763					aanFeatures[cOption] = [];
3764				}
3765	
3766				aanFeatures[cOption].push( featureNode );
3767				insert.append( featureNode );
3768			}
3769		}
3770	
3771		/* Built our DOM structure - replace the holding div with what we want */
3772		holding.replaceWith( insert );
3773		oSettings.nHolding = null;
3774	}
3775	
3776	
3777	/**
3778	 * Use the DOM source to create up an array of header cells. The idea here is to
3779	 * create a layout grid (array) of rows x columns, which contains a reference
3780	 * to the cell that that point in the grid (regardless of col/rowspan), such that
3781	 * any column / row could be removed and the new grid constructed
3782	 *  @param array {object} aLayout Array to store the calculated layout in
3783	 *  @param {node} nThead The header/footer element for the table
3784	 *  @memberof DataTable#oApi
3785	 */
3786	function _fnDetectHeader ( aLayout, nThead )
3787	{
3788		var nTrs = $(nThead).children('tr');
3789		var nTr, nCell;
3790		var i, k, l, iLen, jLen, iColShifted, iColumn, iColspan, iRowspan;
3791		var bUnique;
3792		var fnShiftCol = function ( a, i, j ) {
3793			var k = a[i];
3794	                while ( k[j] ) {
3795				j++;
3796			}
3797			return j;
3798		};
3799	
3800		aLayout.splice( 0, aLayout.length );
3801	
3802		/* We know how many rows there are in the layout - so prep it */
3803		for ( i=0, iLen=nTrs.length ; i<iLen ; i++ )
3804		{
3805			aLayout.push( [] );
3806		}
3807	
3808		/* Calculate a layout array */
3809		for ( i=0, iLen=nTrs.length ; i<iLen ; i++ )
3810		{
3811			nTr = nTrs[i];
3812			iColumn = 0;
3813	
3814			/* For every cell in the row... */
3815			nCell = nTr.firstChild;
3816			while ( nCell ) {
3817				if ( nCell.nodeName.toUpperCase() == "TD" ||
3818				     nCell.nodeName.toUpperCase() == "TH" )
3819				{
3820					/* Get the col and rowspan attributes from the DOM and sanitise them */
3821					iColspan = nCell.getAttribute('colspan') * 1;
3822					iRowspan = nCell.getAttribute('rowspan') * 1;
3823					iColspan = (!iColspan || iColspan===0 || iColspan===1) ? 1 : iColspan;
3824					iRowspan = (!iRowspan || iRowspan===0 || iRowspan===1) ? 1 : iRowspan;
3825	
3826					/* There might be colspan cells already in this row, so shift our target
3827					 * accordingly
3828					 */
3829					iColShifted = fnShiftCol( aLayout, i, iColumn );
3830	
3831					/* Cache calculation for unique columns */
3832					bUnique = iColspan === 1 ? true : false;
3833	
3834					/* If there is col / rowspan, copy the information into the layout grid */
3835					for ( l=0 ; l<iColspan ; l++ )
3836					{
3837						for ( k=0 ; k<iRowspan ; k++ )
3838						{
3839							aLayout[i+k][iColShifted+l] = {
3840								"cell": nCell,
3841								"unique": bUnique
3842							};
3843							aLayout[i+k].nTr = nTr;
3844						}
3845					}
3846				}
3847				nCell = nCell.nextSibling;
3848			}
3849		}
3850	}
3851	
3852	
3853	/**
3854	 * Get an array of unique th elements, one for each column
3855	 *  @param {object} oSettings dataTables settings object
3856	 *  @param {node} nHeader automatically detect the layout from this node - optional
3857	 *  @param {array} aLayout thead/tfoot layout from _fnDetectHeader - optional
3858	 *  @returns array {node} aReturn list of unique th's
3859	 *  @memberof DataTable#oApi
3860	 */
3861	function _fnGetUniqueThs ( oSettings, nHeader, aLayout )
3862	{
3863		var aReturn = [];
3864		if ( !aLayout )
3865		{
3866			aLayout = oSettings.aoHeader;
3867			if ( nHeader )
3868			{
3869				aLayout = [];
3870				_fnDetectHeader( aLayout, nHeader );
3871			}
3872		}
3873	
3874		for ( var i=0, iLen=aLayout.length ; i<iLen ; i++ )
3875		{
3876			for ( var j=0, jLen=aLayout[i].length ; j<jLen ; j++ )
3877			{
3878				if ( aLayout[i][j].unique &&
3879					 (!aReturn[j] || !oSettings.bSortCellsTop) )
3880				{
3881					aReturn[j] = aLayout[i][j].cell;
3882				}
3883			}
3884		}
3885	
3886		return aReturn;
3887	}
3888	
3889	/**
3890	 * Set the start position for draw
3891	 *  @param {object} oSettings dataTables settings object
3892	 */
3893	function _fnStart( oSettings )
3894	{
3895		var bServerSide = _fnDataSource( oSettings ) == 'ssp';
3896		var iInitDisplayStart = oSettings.iInitDisplayStart;
3897	
3898		// Check and see if we have an initial draw position from state saving
3899		if ( iInitDisplayStart !== undefined && iInitDisplayStart !== -1 )
3900		{
3901			oSettings._iDisplayStart = bServerSide ?
3902				iInitDisplayStart :
3903				iInitDisplayStart >= oSettings.fnRecordsDisplay() ?
3904					0 :
3905					iInitDisplayStart;
3906	
3907			oSettings.iInitDisplayStart = -1;
3908		}
3909	}
3910	
3911	/**
3912	 * Create an Ajax call based on the table's settings, taking into account that
3913	 * parameters can have multiple forms, and backwards compatibility.
3914	 *
3915	 * @param {object} oSettings dataTables settings object
3916	 * @param {array} data Data to send to the server, required by
3917	 *     DataTables - may be augmented by developer callbacks
3918	 * @param {function} fn Callback function to run when data is obtained
3919	 */
3920	function _fnBuildAjax( oSettings, data, fn )
3921	{
3922		// Compatibility with 1.9-, allow fnServerData and event to manipulate
3923		_fnCallbackFire( oSettings, 'aoServerParams', 'serverParams', [data] );
3924	
3925		// Convert to object based for 1.10+ if using the old array scheme which can
3926		// come from server-side processing or serverParams
3927		if ( data && Array.isArray(data) ) {
3928			var tmp = {};
3929			var rbracket = /(.*?)\[\]$/;
3930	
3931			$.each( data, function (key, val) {
3932				var match = val.name.match(rbracket);
3933	
3934				if ( match ) {
3935					// Support for arrays
3936					var name = match[0];
3937	
3938					if ( ! tmp[ name ] ) {
3939						tmp[ name ] = [];
3940					}
3941					tmp[ name ].push( val.value );
3942				}
3943				else {
3944					tmp[val.name] = val.value;
3945				}
3946			} );
3947			data = tmp;
3948		}
3949	
3950		var ajaxData;
3951		var ajax = oSettings.ajax;
3952		var instance = oSettings.oInstance;
3953		var callback = function ( json ) {
3954			var status = oSettings.jqXHR
3955				? oSettings.jqXHR.status
3956				: null;
3957	
3958			if ( json === null || (typeof status === 'number' && status == 204 ) ) {
3959				json = {};
3960				_fnAjaxDataSrc( oSettings, json, [] );
3961			}
3962	
3963			var error = json.error || json.sError;
3964			if ( error ) {
3965				_fnLog( oSettings, 0, error );
3966			}
3967	
3968			oSettings.json = json;
3969	
3970			_fnCallbackFire( oSettings, null, 'xhr', [oSettings, json, oSettings.jqXHR] );
3971			fn( json );
3972		};
3973	
3974		if ( $.isPlainObject( ajax ) && ajax.data )
3975		{
3976			ajaxData = ajax.data;
3977	
3978			var newData = typeof ajaxData === 'function' ?
3979				ajaxData( data, oSettings ) :  // fn can manipulate data or return
3980				ajaxData;                      // an object object or array to merge
3981	
3982			// If the function returned something, use that alone
3983			data = typeof ajaxData === 'function' && newData ?
3984				newData :
3985				$.extend( true, data, newData );
3986	
3987			// Remove the data property as we've resolved it already and don't want
3988			// jQuery to do it again (it is restored at the end of the function)
3989			delete ajax.data;
3990		}
3991	
3992		var baseAjax = {
3993			"data": data,
3994			"success": callback,
3995			"dataType": "json",
3996			"cache": false,
3997			"type": oSettings.sServerMethod,
3998			"error": function (xhr, error, thrown) {
3999				var ret = _fnCallbackFire( oSettings, null, 'xhr', [oSettings, null, oSettings.jqXHR] );
4000	
4001				if ( $.inArray( true, ret ) === -1 ) {
4002					if ( error == "parsererror" ) {
4003						_fnLog( oSettings, 0, 'Invalid JSON response', 1 );
4004					}
4005					else if ( xhr.readyState === 4 ) {
4006						_fnLog( oSettings, 0, 'Ajax error', 7 );
4007					}
4008				}
4009	
4010				_fnProcessingDisplay( oSettings, false );
4011			}
4012		};
4013	
4014		// Store the data submitted for the API
4015		oSettings.oAjaxData = data;
4016	
4017		// Allow plug-ins and external processes to modify the data
4018		_fnCallbackFire( oSettings, null, 'preXhr', [oSettings, data] );
4019	
4020		if ( oSettings.fnServerData )
4021		{
4022			// DataTables 1.9- compatibility
4023			oSettings.fnServerData.call( instance,
4024				oSettings.sAjaxSource,
4025				$.map( data, function (val, key) { // Need to convert back to 1.9 trad format
4026					return { name: key, value: val };
4027				} ),
4028				callback,
4029				oSettings
4030			);
4031		}
4032		else if ( oSettings.sAjaxSource || typeof ajax === 'string' )
4033		{
4034			// DataTables 1.9- compatibility
4035			oSettings.jqXHR = $.ajax( $.extend( baseAjax, {
4036				url: ajax || oSettings.sAjaxSource
4037			} ) );
4038		}
4039		else if ( typeof ajax === 'function' )
4040		{
4041			// Is a function - let the caller define what needs to be done
4042			oSettings.jqXHR = ajax.call( instance, data, callback, oSettings );
4043		}
4044		else
4045		{
4046			// Object to extend the base settings
4047			oSettings.jqXHR = $.ajax( $.extend( baseAjax, ajax ) );
4048	
4049			// Restore for next time around
4050			ajax.data = ajaxData;
4051		}
4052	}
4053	
4054	
4055	/**
4056	 * Update the table using an Ajax call
4057	 *  @param {object} settings dataTables settings object
4058	 *  @returns {boolean} Block the table drawing or not
4059	 *  @memberof DataTable#oApi
4060	 */
4061	function _fnAjaxUpdate( settings )
4062	{
4063		settings.iDraw++;
4064		_fnProcessingDisplay( settings, true );
4065	
4066