https://artlofthotel.com/cdn/datatables/jquery.dataTables.js

85	 * It is useful to have variables which are scoped locally so only the
86	 * DataTables functions can access them and they don't leak into global space.
87	 * At the same time these functions are often useful over multiple files in the
88	 * core and API, so we list, or at least document, all variables which are used
89	 * by DataTables as private variables here. This also ensures that there is no
90	 * clashing of variable names and that they can easily referenced for reuse.
91	 */
92	
93	
94	// Defined else where
95	//  _selector_run
96	//  _selector_opts
97	//  _selector_first
98	//  _selector_row_indexes
99	
100	var _ext; // DataTable.ext
101	var _Api; // DataTable.Api
102	var _api_register; // DataTable.Api.register
103	var _api_registerPlural; // DataTable.Api.registerPlural
104	
105	var _re_dic = {};
106	var _re_new_lines = /[\r\n]/g;
107	var _re_html = /<.*?>/g;
108	var _re_date_start = /^[\w\+\-]/;
109	var _re_date_end = /[\w\+\-]$/;
110	
111	// Escape regular expression special characters
112	var _re_escape_regex = new RegExp( '(\\' + [ '/', '.', '*', '+', '?', '|', '(', ')', '[', ']', '{', '}', '\\', '$', '^', '-' ].join('|\\') + ')', 'g' );
113	
114	// http://en.wikipedia.org/wiki/Foreign_exchange_market
115	// - \u20BD - Russian ruble.
116	// - \u20a9 - South Korean Won
117	// - \u20BA - Turkish Lira
118	// - \u20B9 - Indian Rupee
119	// - R - Brazil (R$) and South Africa
120	// - fr - Swiss Franc
121	// - kr - Swedish krona, Norwegian krone and Danish krone
122	// - \u2009 is thin space and \u202F is narrow no-break space, both used in many
123	//   standards as thousands separators.
124	var _re_formatted_numeric = /[',$£€¥%\u2009\u202F\u20BD\u20a9\u20BArfk]/gi;
125	
126	
127	var _empty = function ( d ) {
128		return !d || d === true || d === '-' ? true : false;
129	};
130	
131	
132	var _intVal = function ( s ) {
133		var integer = parseInt( s, 10 );
134		return !isNaN(integer) && isFinite(s) ? integer : null;
135	};
136	
137	// Convert from a formatted number with characters other than `.` as the
138	// decimal place, to a Javascript number
139	var _numToDecimal = function ( num, decimalPoint ) {
140		// Cache created regular expressions for speed as this function is called often
141		if ( ! _re_dic[ decimalPoint ] ) {
142			_re_dic[ decimalPoint ] = new RegExp( _fnEscapeRegex( decimalPoint ), 'g' );
143		}
144		return typeof num === 'string' && decimalPoint !== '.' ?
145			num.replace( /\./g, '' ).replace( _re_dic[ decimalPoint ], '.' ) :
146			num;
147	};
148	
149	
150	var _isNumber = function ( d, decimalPoint, formatted ) {
151		var strType = typeof d === 'string';
152	
153		// If empty return immediately so there must be a number if it is a
154		// formatted string (this stops the string "k", or "kr", etc being detected
155		// as a formatted number for currency
156		if ( _empty( d ) ) {
157			return true;
158		}
159	
160		if ( decimalPoint && strType ) {
161			d = _numToDecimal( d, decimalPoint );
162		}
163	
164		if ( formatted && strType ) {
165			d = d.replace( _re_formatted_numeric, '' );
166		}
167	
168		return !isNaN( parseFloat(d) ) && isFinite( d );
169	};
170	
171	
172	// A string without HTML in it can be considered to be HTML still
173	var _isHtml = function ( d ) {
174		return _empty( d ) || typeof d === 'string';
175	};
176	
177	
178	var _htmlNumeric = function ( d, decimalPoint, formatted ) {
179		if ( _empty( d ) ) {
180			return true;
181		}
182	
183		var html = _isHtml( d );
184		return ! html ?
185			null :
186			_isNumber( _stripHtml( d ), decimalPoint, formatted ) ?
187				true :
188				null;
189	};
190	
191	
192	var _pluck = function ( a, prop, prop2 ) {
193		var out = [];
194		var i=0, ien=a.length;
195	
196		// Could have the test in the loop for slightly smaller code, but speed
197		// is essential here
198		if ( prop2 !== undefined ) {
199			for ( ; i<ien ; i++ ) {
200				if ( a[i] && a[i][ prop ] ) {
201					out.push( a[i][ prop ][ prop2 ] );
202				}
203			}
204		}
205		else {
206			for ( ; i<ien ; i++ ) {
207				if ( a[i] ) {
208					out.push( a[i][ prop ] );
209				}
210			}
211		}
212	
213		return out;
214	};
215	
216	
217	// Basically the same as _pluck, but rather than looping over `a` we use `order`
218	// as the indexes to pick from `a`
219	var _pluck_order = function ( a, order, prop, prop2 )
220	{
221		var out = [];
222		var i=0, ien=order.length;
223	
224		// Could have the test in the loop for slightly smaller code, but speed
225		// is essential here
226		if ( prop2 !== undefined ) {
227			for ( ; i<ien ; i++ ) {
228				if ( a[ order[i] ][ prop ] ) {
229					out.push( a[ order[i] ][ prop ][ prop2 ] );
230				}
231			}
232		}
233		else {
234			for ( ; i<ien ; i++ ) {
235				out.push( a[ order[i] ][ prop ] );
236			}
237		}
238	
239		return out;
240	};
241	
242	
243	var _range = function ( len, start )
244	{
245		var out = [];
246		var end;
247	
248		if ( start === undefined ) {
249			start = 0;
250			end = len;
251		}
252		else {
253			end = start;
254			start = len;
255		}
256	
257		for ( var i=start ; i<end ; i++ ) {
258			out.push( i );
259		}
260	
261		return out;
262	};
263	
264	
265	var _removeEmpty = function ( a )
266	{
267		var out = [];
268	
269		for ( var i=0, ien=a.length ; i<ien ; i++ ) {
270			if ( a[i] ) { // careful - will remove all falsy values!
271				out.push( a[i] );
272			}
273		}
274	
275		return out;
276	};
277	
278	
279	var _stripHtml = function ( d ) {
280		return d.replace( _re_html, '' );
281	};
282	
283	
284	/**
285	 * Find the unique elements in a source array.
286	 *
287	 * @param  {array} src Source array
288	 * @return {array} Array of unique items
289	 * @ignore
290	 */
291	var _unique = function ( src )
292	{
293		// A faster unique method is to use object keys to identify used values,
294		// but this doesn't work with arrays or objects, which we must also
295		// consider. See jsperf.com/compare-array-unique-versions/4 for more
296		// information.
297		var
298			out = [],
299			val,
300			i, ien=src.length,
301			j, k=0;
302	
303		again: for ( i=0 ; i<ien ; i++ ) {
304			val = src[i];
305	
306			for ( j=0 ; j<k ; j++ ) {
307				if ( out[j] === val ) {
308					continue again;
309				}
310			}
311	
312			out.push( val );
313			k++;
314		}
315	
316		return out;
317	};
318	
319	
320	
321	/**
322	 * Create a mapping object that allows camel case parameters to be looked up
323	 * for their Hungarian counterparts. The mapping is stored in a private
324	 * parameter called `_hungarianMap` which can be accessed on the source object.
325	 *  @param {object} o
326	 *  @memberof DataTable#oApi
327	 */
328	function _fnHungarianMap ( o )
329	{
330		var
331			hungarian = 'a aa ai ao as b fn i m o s ',
332			match,
333			newKey,
334			map = {};
335	
336		$.each( o, function (key, val) {
337			match = key.match(/^([^A-Z]+?)([A-Z])/);
338	
339			if ( match && hungarian.indexOf(match[1]+' ') !== -1 )
340			{
341				newKey = key.replace( match[0], match[2].toLowerCase() );
342				map[ newKey ] = key;
343	
344				if ( match[1] === 'o' )
345				{
346					_fnHungarianMap( o[key] );
347				}
348			}
349		} );
350	
351		o._hungarianMap = map;
352	}
353	
354	
355	/**
356	 * Convert from camel case parameters to Hungarian, based on a Hungarian map
357	 * created by _fnHungarianMap.
358	 *  @param {object} src The model object which holds all parameters that can be
359	 *    mapped.
360	 *  @param {object} user The object to convert from camel case to Hungarian.
361	 *  @param {boolean} force When set to `true`, properties which already have a
362	 *    Hungarian value in the `user` object will be overwritten. Otherwise they
363	 *    won't be.
364	 *  @memberof DataTable#oApi
365	 */
366	function _fnCamelToHungarian ( src, user, force )
367	{
368		if ( ! src._hungarianMap ) {
369			_fnHungarianMap( src );
370		}
371	
372		var hungarianKey;
373	
374		$.each( user, function (key, val) {
375			hungarianKey = src._hungarianMap[ key ];
376	
377			if ( hungarianKey !== undefined && (force || user[hungarianKey] === undefined) )
378			{
379				// For objects, we need to buzz down into the object to copy parameters
380				if ( hungarianKey.charAt(0) === 'o' )
381				{
382					// Copy the camelCase options over to the hungarian
383					if ( ! user[ hungarianKey ] ) {
384						user[ hungarianKey ] = {};
385					}
386					$.extend( true, user[hungarianKey], user[key] );
387	
388					_fnCamelToHungarian( src[hungarianKey], user[hungarianKey], force );
389				}
390				else {
391					user[hungarianKey] = user[ key ];
392				}
393			}
394		} );
395	}
396	
397	
398	/**
399	 * Language compatibility - when certain options are given, and others aren't, we
400	 * need to duplicate the values over, in order to provide backwards compatibility
401	 * with older language files.
402	 *  @param {object} oSettings dataTables settings object
403	 *  @memberof DataTable#oApi
404	 */
405	function _fnLanguageCompat( lang )
406	{
407		var defaults = DataTable.defaults.oLanguage;
408		var zeroRecords = lang.sZeroRecords;
409	
410		/* Backwards compatibility - if there is no sEmptyTable given, then use the same as
411		 * sZeroRecords - assuming that is given.
412		 */
413		if ( ! lang.sEmptyTable && zeroRecords &&
414			defaults.sEmptyTable === "No data available in table" )
415		{
416			_fnMap( lang, lang, 'sZeroRecords', 'sEmptyTable' );
417		}
418	
419		/* Likewise with loading records */
420		if ( ! lang.sLoadingRecords && zeroRecords &&
421			defaults.sLoadingRecords === "Loading..." )
422		{
423			_fnMap( lang, lang, 'sZeroRecords', 'sLoadingRecords' );
424		}
425	
426		// Old parameter name of the thousands separator mapped onto the new
427		if ( lang.sInfoThousands ) {
428			lang.sThousands = lang.sInfoThousands;
429		}
430	
431		var decimal = lang.sDecimal;
432		if ( decimal ) {
433			_addNumericSort( decimal );
434		}
435	}
436	
437	
438	/**
439	 * Map one parameter onto another
440	 *  @param {object} o Object to map
441	 *  @param {*} knew The new parameter name
442	 *  @param {*} old The old parameter name
443	 */
444	var _fnCompatMap = function ( o, knew, old ) {
445		if ( o[ knew ] !== undefined ) {
446			o[ old ] = o[ knew ];
447		}
448	};
449	
450	
451	/**
452	 * Provide backwards compatibility for the main DT options. Note that the new
453	 * options are mapped onto the old parameters, so this is an external interface
454	 * change only.
455	 *  @param {object} init Object to map
456	 */
457	function _fnCompatOpts ( init )
458	{
459		_fnCompatMap( init, 'ordering',      'bSort' );
460		_fnCompatMap( init, 'orderMulti',    'bSortMulti' );
461		_fnCompatMap( init, 'orderClasses',  'bSortClasses' );
462		_fnCompatMap( init, 'orderCellsTop', 'bSortCellsTop' );
463		_fnCompatMap( init, 'order',         'aaSorting' );
464		_fnCompatMap( init, 'orderFixed',    'aaSortingFixed' );
465		_fnCompatMap( init, 'paging',        'bPaginate' );
466		_fnCompatMap( init, 'pagingType',    'sPaginationType' );
467		_fnCompatMap( init, 'pageLength',    'iDisplayLength' );
468		_fnCompatMap( init, 'searching',     'bFilter' );
469	
470		// Column search objects are in an array, so it needs to be converted
471		// element by element
472		var searchCols = init.aoSearchCols;
473	
474		if ( searchCols ) {
475			for ( var i=0, ien=searchCols.length ; i<ien ; i++ ) {
476				if ( searchCols[i] ) {
477					_fnCamelToHungarian( DataTable.models.oSearch, searchCols[i] );
478				}
479			}
480		}
481	}
482	
483	
484	/**
485	 * Provide backwards compatibility for column options. Note that the new options
486	 * are mapped onto the old parameters, so this is an external interface change
487	 * only.
488	 *  @param {object} init Object to map
489	 */
490	function _fnCompatCols ( init )
491	{
492		_fnCompatMap( init, 'orderable',     'bSortable' );
493		_fnCompatMap( init, 'orderData',     'aDataSort' );
494		_fnCompatMap( init, 'orderSequence', 'asSorting' );
495		_fnCompatMap( init, 'orderDataType', 'sortDataType' );
496	
497		// orderData can be given as an integer
498		var dataSort = init.aDataSort;
499		if ( dataSort && ! $.isArray( dataSort ) ) {
500			init.aDataSort = [ dataSort ];
501		}
502	}
503	
504	
505	/**
506	 * Browser feature detection for capabilities, quirks
507	 *  @param {object} settings dataTables settings object
508	 *  @memberof DataTable#oApi
509	 */
510	function _fnBrowserDetect( settings )
511	{
512		var browser = settings.oBrowser;
513	
514		// Scrolling feature / quirks detection
515		var n = $('<div/>')
516			.css( {
517				position: 'absolute',
518				top: 0,
519				left: 0,
520				height: 1,
521				width: 1,
522				overflow: 'hidden'
523			} )
524			.append(
525				$('<div/>')
526					.css( {
527						position: 'absolute',
528						top: 1,
529						left: 1,
530						width: 100,
531						overflow: 'scroll'
532					} )
533					.append(
534						$('<div class="test"/>')
535							.css( {
536								width: '100%',
537								height: 10
538							} )
539					)
540			)
541			.appendTo( 'body' );
542	
543		var test = n.find('.test');
544	
545		// IE6/7 will oversize a width 100% element inside a scrolling element, to
546		// include the width of the scrollbar, while other browsers ensure the inner
547		// element is contained without forcing scrolling
548		browser.bScrollOversize = test[0].offsetWidth === 100;
549	
550		// In rtl text layout, some browsers (most, but not all) will place the
551		// scrollbar on the left, rather than the right.
552		browser.bScrollbarLeft = Math.round( test.offset().left ) !== 1;
553	
554		n.remove();
555	}
556	
557	
558	/**
559	 * Array.prototype reduce[Right] method, used for browsers which don't support
560	 * JS 1.6. Done this way to reduce code size, since we iterate either way
561	 *  @param {object} settings dataTables settings object
562	 *  @memberof DataTable#oApi
563	 */
564	function _fnReduce ( that, fn, init, start, end, inc )
565	{
566		var
567			i = start,
568			value,
569			isSet = false;
570	
571		if ( init !== undefined ) {
572			value = init;
573			isSet = true;
574		}
575	
576		while ( i !== end ) {
577			if ( ! that.hasOwnProperty(i) ) {
578				continue;
579			}
580	
581			value = isSet ?
582				fn( value, that[i], i, that ) :
583				that[i];
584	
585			isSet = true;
586			i += inc;
587		}
588	
589		return value;
590	}
591	
592	/**
593	 * Add a column to the list used for the table with default values
594	 *  @param {object} oSettings dataTables settings object
595	 *  @param {node} nTh The th element for this column
596	 *  @memberof DataTable#oApi
597	 */
598	function _fnAddColumn( oSettings, nTh )
599	{
600		// Add column to aoColumns array
601		var oDefaults = DataTable.defaults.column;
602		var iCol = oSettings.aoColumns.length;
603		var oCol = $.extend( {}, DataTable.models.oColumn, oDefaults, {
604			"nTh": nTh ? nTh : document.createElement('th'),
605			"sTitle":    oDefaults.sTitle    ? oDefaults.sTitle    : nTh ? nTh.innerHTML : '',
606			"aDataSort": oDefaults.aDataSort ? oDefaults.aDataSort : [iCol],
607			"mData": oDefaults.mData ? oDefaults.mData : iCol,
608			idx: iCol
609		} );
610		oSettings.aoColumns.push( oCol );
611	
612		// Add search object for column specific search. Note that the `searchCols[ iCol ]`
613		// passed into extend can be undefined. This allows the user to give a default
614		// with only some of the parameters defined, and also not give a default
615		var searchCols = oSettings.aoPreSearchCols;
616		searchCols[ iCol ] = $.extend( {}, DataTable.models.oSearch, searchCols[ iCol ] );
617	
618		// Use the default column options function to initialise classes etc
619		_fnColumnOptions( oSettings, iCol, $(nTh).data() );
620	}
621	
622	
623	/**
624	 * Apply options for a column
625	 *  @param {object} oSettings dataTables settings object
626	 *  @param {int} iCol column index to consider
627	 *  @param {object} oOptions object with sType, bVisible and bSearchable etc
628	 *  @memberof DataTable#oApi
629	 */
630	function _fnColumnOptions( oSettings, iCol, oOptions )
631	{
632		var oCol = oSettings.aoColumns[ iCol ];
633		var oClasses = oSettings.oClasses;
634		var th = $(oCol.nTh);
635	
636		// Try to get width information from the DOM. We can't get it from CSS
637		// as we'd need to parse the CSS stylesheet. `width` option can override
638		if ( ! oCol.sWidthOrig ) {
639			// Width attribute
640			oCol.sWidthOrig = th.attr('width') || null;
641	
642			// Style attribute
643			var t = (th.attr('style') || '').match(/width:\s*(\d+[pxem%]+)/);
644			if ( t ) {
645				oCol.sWidthOrig = t[1];
646			}
647		}
648	
649		/* User specified column options */
650		if ( oOptions !== undefined && oOptions !== null )
651		{
652			// Backwards compatibility
653			_fnCompatCols( oOptions );
654	
655			// Map camel case parameters to their Hungarian counterparts
656			_fnCamelToHungarian( DataTable.defaults.column, oOptions );
657	
658			/* Backwards compatibility for mDataProp */
659			if ( oOptions.mDataProp !== undefined && !oOptions.mData )
660			{
661				oOptions.mData = oOptions.mDataProp;
662			}
663	
664			if ( oOptions.sType )
665			{
666				oCol._sManualType = oOptions.sType;
667			}
668	
669			// `class` is a reserved word in Javascript, so we need to provide
670			// the ability to use a valid name for the camel case input
671			if ( oOptions.className && ! oOptions.sClass )
672			{
673				oOptions.sClass = oOptions.className;
674			}
675	
676			$.extend( oCol, oOptions );
677			_fnMap( oCol, oOptions, "sWidth", "sWidthOrig" );
678	
679			/* iDataSort to be applied (backwards compatibility), but aDataSort will take
680			 * priority if defined
681			 */
682			if ( oOptions.iDataSort !== undefined )
683			{
684				oCol.aDataSort = [ oOptions.iDataSort ];
685			}
686			_fnMap( oCol, oOptions, "aDataSort" );
687		}
688	
689		/* Cache the data get and set functions for speed */
690		var mDataSrc = oCol.mData;
691		var mData = _fnGetObjectDataFn( mDataSrc );
692		var mRender = oCol.mRender ? _fnGetObjectDataFn( oCol.mRender ) : null;
693	
694		var attrTest = function( src ) {
695			return typeof src === 'string' && src.indexOf('@') !== -1;
696		};
697		oCol._bAttrSrc = $.isPlainObject( mDataSrc ) && (
698			attrTest(mDataSrc.sort) || attrTest(mDataSrc.type) || attrTest(mDataSrc.filter)
699		);
700	
701		oCol.fnGetData = function (rowData, type, meta) {
702			var innerData = mData( rowData, type, undefined, meta );
703	
704			return mRender && type ?
705				mRender( innerData, type, rowData, meta ) :
706				innerData;
707		};
708		oCol.fnSetData = function ( rowData, val, meta ) {
709			return _fnSetObjectDataFn( mDataSrc )( rowData, val, meta );
710		};
711	
712		// Indicate if DataTables should read DOM data as an object or array
713		// Used in _fnGetRowElements
714		if ( typeof mDataSrc !== 'number' ) {
715			oSettings._rowReadObject = true;
716		}
717	
718		/* Feature sorting overrides column specific when off */
719		if ( !oSettings.oFeatures.bSort )
720		{
721			oCol.bSortable = false;
722			th.addClass( oClasses.sSortableNone ); // Have to add class here as order event isn't called
723		}
724	
725		/* Check that the class assignment is correct for sorting */
726		var bAsc = $.inArray('asc', oCol.asSorting) !== -1;
727		var bDesc = $.inArray('desc', oCol.asSorting) !== -1;
728		if ( !oCol.bSortable || (!bAsc && !bDesc) )
729		{
730			oCol.sSortingClass = oClasses.sSortableNone;
731			oCol.sSortingClassJUI = "";
732		}
733		else if ( bAsc && !bDesc )
734		{
735			oCol.sSortingClass = oClasses.sSortableAsc;
736			oCol.sSortingClassJUI = oClasses.sSortJUIAscAllowed;
737		}
738		else if ( !bAsc && bDesc )
739		{
740			oCol.sSortingClass = oClasses.sSortableDesc;
741			oCol.sSortingClassJUI = oClasses.sSortJUIDescAllowed;
742		}
743		else
744		{
745			oCol.sSortingClass = oClasses.sSortable;
746			oCol.sSortingClassJUI = oClasses.sSortJUI;
747		}
748	}
749	
750	
751	/**
752	 * Adjust the table column widths for new data. Note: you would probably want to
753	 * do a redraw after calling this function!
754	 *  @param {object} settings dataTables settings object
755	 *  @memberof DataTable#oApi
756	 */
757	function _fnAdjustColumnSizing ( settings )
758	{
759		/* Not interested in doing column width calculation if auto-width is disabled */
760		if ( settings.oFeatures.bAutoWidth !== false )
761		{
762			var columns = settings.aoColumns;
763	
764			_fnCalculateColumnWidths( settings );
765			for ( var i=0 , iLen=columns.length ; i<iLen ; i++ )
766			{
767				columns[i].nTh.style.width = columns[i].sWidth;
768			}
769		}
770	
771		var scroll = settings.oScroll;
772		if ( scroll.sY !== '' || scroll.sX !== '')
773		{
774			_fnScrollDraw( settings );
775		}
776	
777		_fnCallbackFire( settings, null, 'column-sizing', [settings] );
778	}
779	
780	
781	/**
782	 * Covert the index of a visible column to the index in the data array (take account
783	 * of hidden columns)
784	 *  @param {object} oSettings dataTables settings object
785	 *  @param {int} iMatch Visible column index to lookup
786	 *  @returns {int} i the data index
787	 *  @memberof DataTable#oApi
788	 */
789	function _fnVisibleToColumnIndex( oSettings, iMatch )
790	{
791		var aiVis = _fnGetColumns( oSettings, 'bVisible' );
792	
793		return typeof aiVis[iMatch] === 'number' ?
794			aiVis[iMatch] :
795			null;
796	}
797	
798	
799	/**
800	 * Covert the index of an index in the data array and convert it to the visible
801	 *   column index (take account of hidden columns)
802	 *  @param {int} iMatch Column index to lookup
803	 *  @param {object} oSettings dataTables settings object
804	 *  @returns {int} i the data index
805	 *  @memberof DataTable#oApi
806	 */
807	function _fnColumnIndexToVisible( oSettings, iMatch )
808	{
809		var aiVis = _fnGetColumns( oSettings, 'bVisible' );
810		var iPos = $.inArray( iMatch, aiVis );
811	
812		return iPos !== -1 ? iPos : null;
813	}
814	
815	
816	/**
817	 * Get the number of visible columns
818	 *  @param {object} oSettings dataTables settings object
819	 *  @returns {int} i the number of visible columns
820	 *  @memberof DataTable#oApi
821	 */
822	function _fnVisbleColumns( oSettings )
823	{
824		return _fnGetColumns( oSettings, 'bVisible' ).length;
825	}
826	
827	
828	/**
829	 * Get an array of column indexes that match a given property
830	 *  @param {object} oSettings dataTables settings object
831	 *  @param {string} sParam Parameter in aoColumns to look for - typically
832	 *    bVisible or bSearchable
833	 *  @returns {array} Array of indexes with matched properties
834	 *  @memberof DataTable#oApi
835	 */
836	function _fnGetColumns( oSettings, sParam )
837	{
838		var a = [];
839	
840		$.map( oSettings.aoColumns, function(val, i) {
841			if ( val[sParam] ) {
842				a.push( i );
843			}
844		} );
845	
846		return a;
847	}
848	
849	
850	/**
851	 * Calculate the 'type' of a column
852	 *  @param {object} settings dataTables settings object
853	 *  @memberof DataTable#oApi
854	 */
855	function _fnColumnTypes ( settings )
856	{
857		var columns = settings.aoColumns;
858		var data = settings.aoData;
859		var types = DataTable.ext.type.detect;
860		var i, ien, j, jen, k, ken;
861		var col, cell, detectedType, cache;
862	
863		// For each column, spin over the 
864		for ( i=0, ien=columns.length ; i<ien ; i++ ) {
865			col = columns[i];
866			cache = [];
867	
868			if ( ! col.sType && col._sManualType ) {
869				col.sType = col._sManualType;
870			}
871			else if ( ! col.sType ) {
872				for ( j=0, jen=types.length ; j<jen ; j++ ) {
873					for ( k=0, ken=data.length ; k<ken ; k++ ) {
874						// Use a cache array so we only need to get the type data
875						// from the formatter once (when using multiple detectors)
876						if ( cache[k] === undefined ) {
877							cache[k] = _fnGetCellData( settings, k, i, 'type' );
878						}
879	
880						detectedType = types[j]( cache[k], settings );
881	
882						// If null, then this type can't apply to this column, so
883						// rather than testing all cells, break out. There is an
884						// exception for the last type which is `html`. We need to
885						// scan all rows since it is possible to mix string and HTML
886						// types
887						if ( ! detectedType && j !== types.length-1 ) {
888							break;
889						}
890	
891						// Only a single match is needed for html type since it is
892						// bottom of the pile and very similar to string
893						if ( detectedType === 'html' ) {
894							break;
895						}
896					}
897	
898					// Type is valid for all data points in the column - use this
899					// type
900					if ( detectedType ) {
901						col.sType = detectedType;
902						break;
903					}
904				}
905	
906				// Fall back - if no type was detected, always use string
907				if ( ! col.sType ) {
908					col.sType = 'string';
909				}
910			}
911		}
912	}
913	
914	
915	/**
916	 * Take the column definitions and static columns arrays and calculate how
917	 * they relate to column indexes. The callback function will then apply the
918	 * definition found for a column to a suitable configuration object.
919	 *  @param {object} oSettings dataTables settings object
920	 *  @param {array} aoColDefs The aoColumnDefs array that is to be applied
921	 *  @param {array} aoCols The aoColumns array that defines columns individually
922	 *  @param {function} fn Callback function - takes two parameters, the calculated
923	 *    column index and the definition for that column.
924	 *  @memberof DataTable#oApi
925	 */
926	function _fnApplyColumnDefs( oSettings, aoColDefs, aoCols, fn )
927	{
928		var i, iLen, j, jLen, k, kLen, def;
929		var columns = oSettings.aoColumns;
930	
931		// Column definitions with aTargets
932		if ( aoColDefs )
933		{
934			/* Loop over the definitions array - loop in reverse so first instance has priority */
935			for ( i=aoColDefs.length-1 ; i>=0 ; i-- )
936			{
937				def = aoColDefs[i];
938	
939				/* Each definition can target multiple columns, as it is an array */
940				var aTargets = def.targets !== undefined ?
941					def.targets :
942					def.aTargets;
943	
944				if ( ! $.isArray( aTargets ) )
945				{
946					aTargets = [ aTargets ];
947				}
948	
949				for ( j=0, jLen=aTargets.length ; j<jLen ; j++ )
950				{
951					if ( typeof aTargets[j] === 'number' && aTargets[j] >= 0 )
952					{
953						/* Add columns that we don't yet know about */
954						while( columns.length <= aTargets[j] )
955						{
956							_fnAddColumn( oSettings );
957						}
958	
959						/* Integer, basic index */
960						fn( aTargets[j], def );
961					}
962					else if ( typeof aTargets[j] === 'number' && aTargets[j] < 0 )
963					{
964						/* Negative integer, right to left column counting */
965						fn( columns.length+aTargets[j], def );
966					}
967					else if ( typeof aTargets[j] === 'string' )
968					{
969						/* Class name matching on TH element */
970						for ( k=0, kLen=columns.length ; k<kLen ; k++ )
971						{
972							if ( aTargets[j] == "_all" ||
973							     $(columns[k].nTh).hasClass( aTargets[j] ) )
974							{
975								fn( k, def );
976							}
977						}
978					}
979				}
980			}
981		}
982	
983		// Statically defined columns array
984		if ( aoCols )
985		{
986			for ( i=0, iLen=aoCols.length ; i<iLen ; i++ )
987			{
988				fn( i, aoCols[i] );
989			}
990		}
991	}
992	
993	/**
994	 * Add a data array to the table, creating DOM node etc. This is the parallel to
995	 * _fnGatherData, but for adding rows from a Javascript source, rather than a
996	 * DOM source.
997	 *  @param {object} oSettings dataTables settings object
998	 *  @param {array} aData data array to be added
999	 *  @param {node} [nTr] TR element to add to the table - optional. If not given,
1000	 *    DataTables will create a row automatically
1001	 *  @param {array} [anTds] Array of TD|TH elements for the row - must be given
1002	 *    if nTr is.
1003	 *  @returns {int} >=0 if successful (index of new aoData entry), -1 if failed
1004	 *  @memberof DataTable#oApi
1005	 */
1006	function _fnAddData ( oSettings, aDataIn, nTr, anTds )
1007	{
1008		/* Create the object for storing information about this new row */
1009		var iRow = oSettings.aoData.length;
1010		var oData = $.extend( true, {}, DataTable.models.oRow, {
1011			src: nTr ? 'dom' : 'data'
1012		} );
1013	
1014		oData._aData = aDataIn;
1015		oSettings.aoData.push( oData );
1016	
1017		/* Create the cells */
1018		var nTd, sThisType;
1019		var columns = oSettings.aoColumns;
1020		for ( var i=0, iLen=columns.length ; i<iLen ; i++ )
1021		{
1022			// When working with a row, the data source object must be populated. In
1023			// all other cases, the data source object is already populated, so we
1024			// don't overwrite it, which might break bindings etc
1025			if ( nTr ) {
1026				_fnSetCellData( oSettings, iRow, i, _fnGetCellData( oSettings, iRow, i ) );
1027			}
1028			columns[i].sType = null;
1029		}
1030	
1031		/* Add to the display array */
1032		oSettings.aiDisplayMaster.push( iRow );
1033	
1034		/* Create the DOM information, or register it if already present */
1035		if ( nTr || ! oSettings.oFeatures.bDeferRender )
1036		{
1037			_fnCreateTr( oSettings, iRow, nTr, anTds );
1038		}
1039	
1040		return iRow;
1041	}
1042	
1043	
1044	/**
1045	 * Add one or more TR elements to the table. Generally we'd expect to
1046	 * use this for reading data from a DOM sourced table, but it could be
1047	 * used for an TR element. Note that if a TR is given, it is used (i.e.
1048	 * it is not cloned).
1049	 *  @param {object} settings dataTables settings object
1050	 *  @param {array|node|jQuery} trs The TR element(s) to add to the table
1051	 *  @returns {array} Array of indexes for the added rows
1052	 *  @memberof DataTable#oApi
1053	 */
1054	function _fnAddTr( settings, trs )
1055	{
1056		var row;
1057	
1058		// Allow an individual node to be passed in
1059		if ( ! (trs instanceof $) ) {
1060			trs = $(trs);
1061		}
1062	
1063		return trs.map( function (i, el) {
1064			row = _fnGetRowElements( settings, el );
1065			return _fnAddData( settings, row.data, el, row.cells );
1066		} );
1067	}
1068	
1069	
1070	/**
1071	 * Take a TR element and convert it to an index in aoData
1072	 *  @param {object} oSettings dataTables settings object
1073	 *  @param {node} n the TR element to find
1074	 *  @returns {int} index if the node is found, null if not
1075	 *  @memberof DataTable#oApi
1076	 */
1077	function _fnNodeToDataIndex( oSettings, n )
1078	{
1079		return (n._DT_RowIndex!==undefined) ? n._DT_RowIndex : null;
1080	}
1081	
1082	
1083	/**
1084	 * Take a TD element and convert it into a column data index (not the visible index)
1085	 *  @param {object} oSettings dataTables settings object
1086	 *  @param {int} iRow The row number the TD/TH can be found in
1087	 *  @param {node} n The TD/TH element to find
1088	 *  @returns {int} index if the node is found, -1 if not
1089	 *  @memberof DataTable#oApi
1090	 */
1091	function _fnNodeToColumnIndex( oSettings, iRow, n )
1092	{
1093		return $.inArray( n, oSettings.aoData[ iRow ].anCells );
1094	}
1095	
1096	
1097	/**
1098	 * Get the data for a given cell from the internal cache, taking into account data mapping
1099	 *  @param {object} settings dataTables settings object
1100	 *  @param {int} rowIdx aoData row id
1101	 *  @param {int} colIdx Column index
1102	 *  @param {string} type data get type ('display', 'type' 'filter' 'sort')
1103	 *  @returns {*} Cell data
1104	 *  @memberof DataTable#oApi
1105	 */
1106	function _fnGetCellData( settings, rowIdx, colIdx, type )
1107	{
1108		var draw           = settings.iDraw;
1109		var col            = settings.aoColumns[colIdx];
1110		var rowData        = settings.aoData[rowIdx]._aData;
1111		var defaultContent = col.sDefaultContent;
1112		var cellData       = col.fnGetData( rowData, type, {
1113			settings: settings,
1114			row:      rowIdx,
1115			col:      colIdx
1116		} );
1117	
1118		if ( cellData === undefined ) {
1119			if ( settings.iDrawError != draw && defaultContent === null ) {
1120				_fnLog( settings, 0, "Requested unknown parameter "+
1121					(typeof col.mData=='function' ? '{function}' : "'"+col.mData+"'")+
1122					" for row "+rowIdx, 4 );
1123				settings.iDrawError = draw;
1124			}
1125			return defaultContent;
1126		}
1127	
1128		/* When the data source is null, we can use default column data */
1129		if ( (cellData === rowData || cellData === null) && defaultContent !== null ) {
1130			cellData = defaultContent;
1131		}
1132		else if ( typeof cellData === 'function' ) {
1133			// If the data source is a function, then we run it and use the return,
1134			// executing in the scope of the data object (for instances)
1135			return cellData.call( rowData );
1136		}
1137	
1138		if ( cellData === null && type == 'display' ) {
1139			return '';
1140		}
1141		return cellData;
1142	}
1143	
1144	
1145	/**
1146	 * Set the value for a specific cell, into the internal data cache
1147	 *  @param {object} settings dataTables settings object
1148	 *  @param {int} rowIdx aoData row id
1149	 *  @param {int} colIdx Column index
1150	 *  @param {*} val Value to set
1151	 *  @memberof DataTable#oApi
1152	 */
1153	function _fnSetCellData( settings, rowIdx, colIdx, val )
1154	{
1155		var col     = settings.aoColumns[colIdx];
1156		var rowData = settings.aoData[rowIdx]._aData;
1157	
1158		col.fnSetData( rowData, val, {
1159			settings: settings,
1160			row:      rowIdx,
1161			col:      colIdx
1162		}  );
1163	}
1164	
1165	
1166	// Private variable that is used to match action syntax in the data property object
1167	var __reArray = /\[.*?\]$/;
1168	var __reFn = /\(\)$/;
1169	
1170	/**
1171	 * Split string on periods, taking into account escaped periods
1172	 * @param  {string} str String to split
1173	 * @return {array} Split string
1174	 */
1175	function _fnSplitObjNotation( str )
1176	{
1177		return $.map( str.match(/(\\.|[^\.])+/g), function ( s ) {
1178			return s.replace(/\\./g, '.');
1179		} );
1180	}
1181	
1182	
1183	/**
1184	 * Return a function that can be used to get data from a source object, taking
1185	 * into account the ability to use nested objects as a source
1186	 *  @param {string|int|function} mSource The data source for the object
1187	 *  @returns {function} Data get function
1188	 *  @memberof DataTable#oApi
1189	 */
1190	function _fnGetObjectDataFn( mSource )
1191	{
1192		if ( $.isPlainObject( mSource ) )
1193		{
1194			/* Build an object of get functions, and wrap them in a single call */
1195			var o = {};
1196			$.each( mSource, function (key, val) {
1197				if ( val ) {
1198					o[key] = _fnGetObjectDataFn( val );
1199				}
1200			} );
1201	
1202			return function (data, type, row, meta) {
1203				var t = o[type] || o._;
1204				return t !== undefined ?
1205					t(data, type, row, meta) :
1206					data;
1207			};
1208		}
1209		else if ( mSource === null )
1210		{
1211			/* Give an empty string for rendering / sorting etc */
1212			return function (data) { // type, row and meta also passed, but not used
1213				return data;
1214			};
1215		}
1216		else if ( typeof mSource === 'function' )
1217		{
1218			return function (data, type, row, meta) {
1219				return mSource( data, type, row, meta );
1220			};
1221		}
1222		else if ( typeof mSource === 'string' && (mSource.indexOf('.') !== -1 ||
1223			      mSource.indexOf('[') !== -1 || mSource.indexOf('(') !== -1) )
1224		{
1225			/* If there is a . in the source string then the data source is in a
1226			 * nested object so we loop over the data for each level to get the next
1227			 * level down. On each loop we test for undefined, and if found immediately
1228			 * return. This allows entire objects to be missing and sDefaultContent to
1229			 * be used if defined, rather than throwing an error
1230			 */
1231			var fetchData = function (data, type, src) {
1232				var arrayNotation, funcNotation, out, innerSrc;
1233	
1234				if ( src !== "" )
1235				{
1236					var a = _fnSplitObjNotation( src );
1237	
1238					for ( var i=0, iLen=a.length ; i<iLen ; i++ )
1239					{
1240						// Check if we are dealing with special notation
1241						arrayNotation = a[i].match(__reArray);
1242						funcNotation = a[i].match(__reFn);
1243	
1244						if ( arrayNotation )
1245						{
1246							// Array notation
1247							a[i] = a[i].replace(__reArray, '');
1248	
1249							// Condition allows simply [] to be passed in
1250							if ( a[i] !== "" ) {
1251								data = data[ a[i] ];
1252							}
1253							out = [];
1254	
1255							// Get the remainder of the nested object to get
1256							a.splice( 0, i+1 );
1257							innerSrc = a.join('.');
1258	
1259							// Traverse each entry in the array getting the properties requested
1260							for ( var j=0, jLen=data.length ; j<jLen ; j++ ) {
1261								out.push( fetchData( data[j], type, innerSrc ) );
1262							}
1263	
1264							// If a string is given in between the array notation indicators, that
1265							// is used to join the strings together, otherwise an array is returned
1266							var join = arrayNotation[0].substring(1, arrayNotation[0].length-1);
1267							data = (join==="") ? out : out.join(join);
1268	
1269							// The inner call to fetchData has already traversed through the remainder
1270							// of the source requested, so we exit from the loop
1271							break;
1272						}
1273						else if ( funcNotation )
1274						{
1275							// Function call
1276							a[i] = a[i].replace(__reFn, '');
1277							data = data[ a[i] ]();
1278							continue;
1279						}
1280	
1281						if ( data === null || data[ a[i] ] === undefined )
1282						{
1283							return undefined;
1284						}
1285						data = data[ a[i] ];
1286					}
1287				}
1288	
1289				return data;
1290			};
1291	
1292			return function (data, type) { // row and meta also passed, but not used
1293				return fetchData( data, type, mSource );
1294			};
1295		}
1296		else
1297		{
1298			/* Array or flat object mapping */
1299			return function (data, type) { // row and meta also passed, but not used
1300				return data[mSource];
1301			};
1302		}
1303	}
1304	
1305	
1306	/**
1307	 * Return a function that can be used to set data from a source object, taking
1308	 * into account the ability to use nested objects as a source
1309	 *  @param {string|int|function} mSource The data source for the object
1310	 *  @returns {function} Data set function
1311	 *  @memberof DataTable#oApi
1312	 */
1313	function _fnSetObjectDataFn( mSource )
1314	{
1315		if ( $.isPlainObject( mSource ) )
1316		{
1317			/* Unlike get, only the underscore (global) option is used for for
1318			 * setting data since we don't know the type here. This is why an object
1319			 * option is not documented for `mData` (which is read/write), but it is
1320			 * for `mRender` which is read only.
1321			 */
1322			return _fnSetObjectDataFn( mSource._ );
1323		}
1324		else if ( mSource === null )
1325		{
1326			/* Nothing to do when the data source is null */
1327			return function () {};
1328		}
1329		else if ( typeof mSource === 'function' )
1330		{
1331			return function (data, val, meta) {
1332				mSource( data, 'set', val, meta );
1333			};
1334		}
1335		else if ( typeof mSource === 'string' && (mSource.indexOf('.') !== -1 ||
1336			      mSource.indexOf('[') !== -1 || mSource.indexOf('(') !== -1) )
1337		{
1338			/* Like the get, we need to get data from a nested object */
1339			var setData = function (data, val, src) {
1340				var a = _fnSplitObjNotation( src ), b;
1341				var aLast = a[a.length-1];
1342				var arrayNotation, funcNotation, o, innerSrc;
1343	
1344				for ( var i=0, iLen=a.length-1 ; i<iLen ; i++ )
1345				{
1346					// Check if we are dealing with an array notation request
1347					arrayNotation = a[i].match(__reArray);
1348					funcNotation = a[i].match(__reFn);
1349	
1350					if ( arrayNotation )
1351					{
1352						a[i] = a[i].replace(__reArray, '');
1353						data[ a[i] ] = [];
1354	
1355						// Get the remainder of the nested object to set so we can recurse
1356						b = a.slice();
1357						b.splice( 0, i+1 );
1358						innerSrc = b.join('.');
1359	
1360						// Traverse each entry in the array setting the properties requested
1361						for ( var j=0, jLen=val.length ; j<jLen ; j++ )
1362						{
1363							o = {};
1364							setData( o, val[j], innerSrc );
1365							data[ a[i] ].push( o );
1366						}
1367	
1368						// The inner call to setData has already traversed through the remainder
1369						// of the source and has set the data, thus we can exit here
1370						return;
1371					}
1372					else if ( funcNotation )
1373					{
1374						// Function call
1375						a[i] = a[i].replace(__reFn, '');
1376						data = data[ a[i] ]( val );
1377					}
1378	
1379					// If the nested object doesn't currently exist - since we are
1380					// trying to set the value - create it
1381					if ( data[ a[i] ] === null || data[ a[i] ] === undefined )
1382					{
1383						data[ a[i] ] = {};
1384					}
1385					data = data[ a[i] ];
1386				}
1387	
1388				// Last item in the input - i.e, the actual set
1389				if ( aLast.match(__reFn ) )
1390				{
1391					// Function call
1392					data = data[ aLast.replace(__reFn, '') ]( val );
1393				}
1394				else
1395				{
1396					// If array notation is used, we just want to strip it and use the property name
1397					// and assign the value. If it isn't used, then we get the result we want anyway
1398					data[ aLast.replace(__reArray, '') ] = val;
1399				}
1400			};
1401	
1402			return function (data, val) { // meta is also passed in, but not used
1403				return setData( data, val, mSource );
1404			};
1405		}
1406		else
1407		{
1408			/* Array or flat object mapping */
1409			return function (data, val) { // meta is also passed in, but not used
1410				data[mSource] = val;
1411			};
1412		}
1413	}
1414	
1415	
1416	/**
1417	 * Return an array with the full table data
1418	 *  @param {object} oSettings dataTables settings object
1419	 *  @returns array {array} aData Master data array
1420	 *  @memberof DataTable#oApi
1421	 */
1422	function _fnGetDataMaster ( settings )
1423	{
1424		return _pluck( settings.aoData, '_aData' );
1425	}
1426	
1427	
1428	/**
1429	 * Nuke the table
1430	 *  @param {object} oSettings dataTables settings object
1431	 *  @memberof DataTable#oApi
1432	 */
1433	function _fnClearTable( settings )
1434	{
1435		settings.aoData.length = 0;
1436		settings.aiDisplayMaster.length = 0;
1437		settings.aiDisplay.length = 0;
1438	}
1439	
1440	
1441	 /**
1442	 * Take an array of integers (index array) and remove a target integer (value - not
1443	 * the key!)
1444	 *  @param {array} a Index array to target
1445	 *  @param {int} iTarget value to find
1446	 *  @memberof DataTable#oApi
1447	 */
1448	function _fnDeleteIndex( a, iTarget, splice )
1449	{
1450		var iTargetIndex = -1;
1451	
1452		for ( var i=0, iLen=a.length ; i<iLen ; i++ )
1453		{
1454			if ( a[i] == iTarget )
1455			{
1456				iTargetIndex = i;
1457			}
1458			else if ( a[i] > iTarget )
1459			{
1460				a[i]--;
1461			}
1462		}
1463	
1464		if ( iTargetIndex != -1 && splice === undefined )
1465		{
1466			a.splice( iTargetIndex, 1 );
1467		}
1468	}
1469	
1470	
1471	/**

1606					if ( objectRead ) {
1607						if ( ! col._setter ) {
1608							// Cache the setter function
1609							col._setter = _fnSetObjectDataFn( col.mData );
1610						}
1611						col._setter( d, contents );
1612					}
1613					else {
1614						d[i] = contents;
1615					}
1616				}
1617			}
1618	
1619			i++;
1620		};
1621	
1622		if ( td ) {
1623			// `tr` element was passed in
1624			while ( td ) {
1625				name = td.nodeName.toUpperCase();
1626	
1627				if ( name == "TD" || name == "TH" ) {
1628					cellProcess( td );
1629					tds.push( td );
1630				}
1631	
1632				td = td.nextSibling;
1633			}
1634		}
1635		else {
1636			// Existing row object passed in
1637			tds = row.anCells;
1638			
1639			for ( var j=0, jen=tds.length ; j<jen ; j++ ) {
1640				cellProcess( tds[j] );
1641			}
1642		}
1643	
1644		return {
1645			data: d,
1646			cells: tds
1647		};
1648	}
1649	/**
1650	 * Create a new TR element (and it's TD children) for a row
1651	 *  @param {object} oSettings dataTables settings object
1652	 *  @param {int} iRow Row to consider
1653	 *  @param {node} [nTrIn] TR element to add to the table - optional. If not given,
1654	 *    DataTables will create a row automatically
1655	 *  @param {array} [anTds] Array of TD|TH elements for the row - must be given
1656	 *    if nTr is.
1657	 *  @memberof DataTable#oApi
1658	 */
1659	function _fnCreateTr ( oSettings, iRow, nTrIn, anTds )
1660	{
1661		var
1662			row = oSettings.aoData[iRow],
1663			rowData = row._aData,
1664			cells = [],
1665			nTr, nTd, oCol,
1666			i, iLen;
1667	
1668		if ( row.nTr === null )
1669		{
1670			nTr = nTrIn || document.createElement('tr');
1671	
1672			row.nTr = nTr;
1673			row.anCells = cells;
1674	
1675			/* Use a private property on the node to allow reserve mapping from the node
1676			 * to the aoData array for fast look up
1677			 */
1678			nTr._DT_RowIndex = iRow;
1679	
1680			/* Special parameters can be given by the data source to be used on the row */
1681			_fnRowAttributes( row );
1682	
1683			/* Process each column */
1684			for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
1685			{
1686				oCol = oSettings.aoColumns[i];
1687	
1688				nTd = nTrIn ? anTds[i] : document.createElement( oCol.sCellType );
1689				cells.push( nTd );
1690	
1691				// Need to create the HTML if new, or if a rendering function is defined
1692				if ( !nTrIn || oCol.mRender || oCol.mData !== i )
1693				{
1694					nTd.innerHTML = _fnGetCellData( oSettings, iRow, i, 'display' );
1695				}
1696	
1697				/* Add user defined class */
1698				if ( oCol.sClass )
1699				{
1700					nTd.className += ' '+oCol.sClass;
1701				}
1702	
1703				// Visibility - add or remove as required
1704				if ( oCol.bVisible && ! nTrIn )
1705				{
1706					nTr.appendChild( nTd );
1707				}
1708				else if ( ! oCol.bVisible && nTrIn )
1709				{
1710					nTd.parentNode.removeChild( nTd );
1711				}
1712	
1713				if ( oCol.fnCreatedCell )
1714				{
1715					oCol.fnCreatedCell.call( oSettings.oInstance,
1716						nTd, _fnGetCellData( oSettings, iRow, i ), rowData, iRow, i
1717					);
1718				}
1719			}
1720	
1721			_fnCallbackFire( oSettings, 'aoRowCreatedCallback', null, [nTr, rowData, iRow] );
1722		}
1723	
1724		// Remove once webkit bug 131819 and Chromium bug 365619 have been resolved
1725		// and deployed
1726		row.nTr.setAttribute( 'role', 'row' );
1727	}
1728	
1729	
1730	/**
1731	 * Add attributes to a row based on the special `DT_*` parameters in a data
1732	 * source object.
1733	 *  @param {object} DataTables row object for the row to be modified
1734	 *  @memberof DataTable#oApi
1735	 */
1736	function _fnRowAttributes( row )
1737	{
1738		var tr = row.nTr;
1739		var data = row._aData;
1740	
1741		if ( tr ) {
1742			if ( data.DT_RowId ) {
1743				tr.id = data.DT_RowId;
1744			}
1745	
1746			if ( data.DT_RowClass ) {
1747				// Remove any classes added by DT_RowClass before
1748				var a = data.DT_RowClass.split(' ');
1749				row.__rowc = row.__rowc ?
1750					_unique( row.__rowc.concat( a ) ) :
1751					a;
1752	
1753				$(tr)
1754					.removeClass( row.__rowc.join(' ') )
1755					.addClass( data.DT_RowClass );
1756			}
1757	
1758			if ( data.DT_RowAttr ) {
1759				$(tr).attr( data.DT_RowAttr );
1760			}
1761	
1762			if ( data.DT_RowData ) {
1763				$(tr).data( data.DT_RowData );
1764			}
1765		}
1766	}
1767	
1768	
1769	/**
1770	 * Create the HTML header for the table
1771	 *  @param {object} oSettings dataTables settings object
1772	 *  @memberof DataTable#oApi
1773	 */
1774	function _fnBuildHead( oSettings )
1775	{
1776		var i, ien, cell, row, column;
1777		var thead = oSettings.nTHead;
1778		var tfoot = oSettings.nTFoot;
1779		var createHeader = $('th, td', thead).length === 0;
1780		var classes = oSettings.oClasses;
1781		var columns = oSettings.aoColumns;
1782	
1783		if ( createHeader ) {
1784			row = $('<tr/>').appendTo( thead );
1785		}
1786	
1787		for ( i=0, ien=columns.length ; i<ien ; i++ ) {
1788			column = columns[i];
1789			cell = $( column.nTh ).addClass( column.sClass );
1790	
1791			if ( createHeader ) {
1792				cell.appendTo( row );
1793			}
1794	
1795			// 1.11 move into sorting
1796			if ( oSettings.oFeatures.bSort ) {
1797				cell.addClass( column.sSortingClass );
1798	
1799				if ( column.bSortable !== false ) {
1800					cell
1801						.attr( 'tabindex', oSettings.iTabIndex )
1802						.attr( 'aria-controls', oSettings.sTableId );
1803	
1804					_fnSortAttachListener( oSettings, column.nTh, i );
1805				}
1806			}
1807	
1808			if ( column.sTitle != cell.html() ) {
1809				cell.html( column.sTitle );
1810			}
1811	
1812			_fnRenderer( oSettings, 'header' )(
1813				oSettings, cell, column, classes
1814			);
1815		}
1816	
1817		if ( createHeader ) {
1818			_fnDetectHeader( oSettings.aoHeader, thead );
1819		}
1820		
1821		/* ARIA role for the rows */
1822	 	$(thead).find('>tr').attr('role', 'row');
1823	
1824		/* Deal with the footer - add classes if required */
1825		$(thead).find('>tr>th, >tr>td').addClass( classes.sHeaderTH );
1826		$(tfoot).find('>tr>th, >tr>td').addClass( classes.sFooterTH );
1827	
1828		// Cache the footer cells. Note that we only take the cells from the first
1829		// row in the footer. If there is more than one row the user wants to
1830		// interact with, they need to use the table().foot() method. Note also this
1831		// allows cells to be used for multiple columns using colspan
1832		if ( tfoot !== null ) {
1833			var cells = oSettings.aoFooter[0];
1834	
1835			for ( i=0, ien=cells.length ; i<ien ; i++ ) {
1836				column = columns[i];
1837				column.nTf = cells[i].cell;
1838	
1839				if ( column.sClass ) {
1840					$(column.nTf).addClass( column.sClass );
1841				}
1842			}
1843		}
1844	}
1845	
1846	
1847	/**
1848	 * Draw the header (or footer) element based on the column visibility states. The
1849	 * methodology here is to use the layout array from _fnDetectHeader, modified for
1850	 * the instantaneous column visibility, to construct the new layout. The grid is
1851	 * traversed over cell at a time in a rows x columns grid fashion, although each
1852	 * cell insert can cover multiple elements in the grid - which is tracks using the
1853	 * aApplied array. Cell inserts in the grid will only occur where there isn't
1854	 * already a cell in that position.
1855	 *  @param {object} oSettings dataTables settings object
1856	 *  @param array {objects} aoSource Layout array from _fnDetectHeader
1857	 *  @param {boolean} [bIncludeHidden=false] If true then include the hidden columns in the calc,
1858	 *  @memberof DataTable#oApi
1859	 */
1860	function _fnDrawHead( oSettings, aoSource, bIncludeHidden )
1861	{
1862		var i, iLen, j, jLen, k, kLen, n, nLocalTr;
1863		var aoLocal = [];
1864		var aApplied = [];
1865		var iColumns = oSettings.aoColumns.length;
1866		var iRowspan, iColspan;
1867	
1868		if ( ! aoSource )
1869		{
1870			return;
1871		}
1872	
1873		if (  bIncludeHidden === undefined )
1874		{
1875			bIncludeHidden = false;
1876		}
1877	
1878		/* Make a copy of the master layout array, but without the visible columns in it */
1879		for ( i=0, iLen=aoSource.length ; i<iLen ; i++ )
1880		{
1881			aoLocal[i] = aoSource[i].slice();
1882			aoLocal[i].nTr = aoSource[i].nTr;
1883	
1884			/* Remove any columns which are currently hidden */
1885			for ( j=iColumns-1 ; j>=0 ; j-- )
1886			{
1887				if ( !oSettings.aoColumns[j].bVisible && !bIncludeHidden )
1888				{
1889					aoLocal[i].splice( j, 1 );
1890				}
1891			}
1892	
1893			/* Prep the applied array - it needs an element for each row */
1894			aApplied.push( [] );
1895		}
1896	
1897		for ( i=0, iLen=aoLocal.length ; i<iLen ; i++ )
1898		{
1899			nLocalTr = aoLocal[i].nTr;
1900	
1901			/* All cells are going to be replaced, so empty out the row */
1902			if ( nLocalTr )
1903			{
1904				while( (n = nLocalTr.firstChild) )
1905				{
1906					nLocalTr.removeChild( n );
1907				}
1908			}
1909	
1910			for ( j=0, jLen=aoLocal[i].length ; j<jLen ; j++ )
1911			{
1912				iRowspan = 1;
1913				iColspan = 1;
1914	
1915				/* Check to see if there is already a cell (row/colspan) covering our target
1916				 * insert point. If there is, then there is nothing to do.
1917				 */
1918				if ( aApplied[i][j] === undefined )
1919				{
1920					nLocalTr.appendChild( aoLocal[i][j].cell );
1921					aApplied[i][j] = 1;
1922	
1923					/* Expand the cell to cover as many rows as needed */
1924					while ( aoLocal[i+iRowspan] !== undefined &&
1925					        aoLocal[i][j].cell == aoLocal[i+iRowspan][j].cell )
1926					{
1927						aApplied[i+iRowspan][j] = 1;
1928						iRowspan++;
1929					}
1930	
1931					/* Expand the cell to cover as many columns as needed */
1932					while ( aoLocal[i][j+iColspan] !== undefined &&
1933					        aoLocal[i][j].cell == aoLocal[i][j+iColspan].cell )
1934					{
1935						/* Must update the applied array over the rows for the columns */
1936						for ( k=0 ; k<iRowspan ; k++ )
1937						{
1938							aApplied[i+k][j+iColspan] = 1;
1939						}
1940						iColspan++;
1941					}
1942	
1943					/* Do the actual expansion in the DOM */
1944					$(aoLocal[i][j].cell)
1945						.attr('rowspan', iRowspan)
1946						.attr('colspan', iColspan);
1947				}
1948			}
1949		}
1950	}
1951	
1952	
1953	/**
1954	 * Insert the required TR nodes into the table for display
1955	 *  @param {object} oSettings dataTables settings object
1956	 *  @memberof DataTable#oApi
1957	 */
1958	function _fnDraw( oSettings )
1959	{
1960		/* Provide a pre-callback function which can be used to cancel the draw is false is returned */
1961		var aPreDraw = _fnCallbackFire( oSettings, 'aoPreDrawCallback', 'preDraw', [oSettings] );
1962		if ( $.inArray( false, aPreDraw ) !== -1 )
1963		{
1964			_fnProcessingDisplay( oSettings, false );
1965			return;
1966		}
1967	
1968		var i, iLen, n;
1969		var anRows = [];
1970		var iRowCount = 0;
1971		var asStripeClasses = oSettings.asStripeClasses;
1972		var iStripes = asStripeClasses.length;
1973		var iOpenRows = oSettings.aoOpenRows.length;
1974		var oLang = oSettings.oLanguage;
1975		var iInitDisplayStart = oSettings.iInitDisplayStart;
1976		var bServerSide = _fnDataSource( oSettings ) == 'ssp';
1977		var aiDisplay = oSettings.aiDisplay;
1978	
1979		oSettings.bDrawing = true;
1980	
1981		/* Check and see if we have an initial draw position from state saving */
1982		if ( iInitDisplayStart !== undefined && iInitDisplayStart !== -1 )
1983		{
1984			oSettings._iDisplayStart = bServerSide ?
1985				iInitDisplayStart :
1986				iInitDisplayStart >= oSettings.fnRecordsDisplay() ?
1987					0 :
1988					iInitDisplayStart;
1989	
1990			oSettings.iInitDisplayStart = -1;
1991		}
1992	
1993		var iDisplayStart = oSettings._iDisplayStart;
1994		var iDisplayEnd = oSettings.fnDisplayEnd();
1995	
1996		/* Server-side processing draw intercept */
1997		if ( oSettings.bDeferLoading )
1998		{
1999			oSettings.bDeferLoading = false;
2000			oSettings.iDraw++;
2001			_fnProcessingDisplay( oSettings, false );
2002		}
2003		else if ( !bServerSide )
2004		{
2005			oSettings.iDraw++;
2006		}
2007		else if ( !oSettings.bDestroying && !_fnAjaxUpdate( oSettings ) )
2008		{
2009			return;
2010		}
2011	
2012		if ( aiDisplay.length !== 0 )
2013		{
2014			var iStart = bServerSide ? 0 : iDisplayStart;
2015			var iEnd = bServerSide ? oSettings.aoData.length : iDisplayEnd;
2016	
2017			for ( var j=iStart ; j<iEnd ; j++ )
2018			{
2019				var iDataIndex = aiDisplay[j];
2020				var aoData = oSettings.aoData[ iDataIndex ];
2021				if ( aoData.nTr === null )
2022				{
2023					_fnCreateTr( oSettings, iDataIndex );
2024				}
2025	
2026				var nRow = aoData.nTr;
2027	
2028				/* Remove the old striping classes and then add the new one */
2029				if ( iStripes !== 0 )
2030				{
2031					var sStripe = asStripeClasses[ iRowCount % iStripes ];
2032					if ( aoData._sRowStripe != sStripe )
2033					{
2034						$(nRow).removeClass( aoData._sRowStripe ).addClass( sStripe );
2035						aoData._sRowStripe = sStripe;
2036					}
2037				}
2038	
2039				// Row callback functions - might want to manipulate the row
2040				// iRowCount and j are not currently documented. Are they at all
2041				// useful?
2042				_fnCallbackFire( oSettings, 'aoRowCallback', null,
2043					[nRow, aoData._aData, iRowCount, j

2043] );
2044	
2045				anRows.push( nRow );
2046				iRowCount++;
2047			}
2048		}
2049		else
2050		{
2051			/* Table is empty - create a row with an empty message in it */
2052			var sZero = oLang.sZeroRecords;
2053			if ( oSettings.iDraw == 1 &&  _fnDataSource( oSettings ) == 'ajax' )
2054			{
2055				sZero = oLang.sLoadingRecords;
2056			}
2057			else if ( oLang.sEmptyTable && oSettings.fnRecordsTotal() === 0 )
2058			{
2059				sZero = oLang.sEmptyTable;
2060			}
2061	
2062			anRows[ 0 ] = $( '<tr/>', { 'class': iStripes ? asStripeClasses[0] : '' } )
2063				.append( $('<td />', {
2064					'valign':  'top',
2065					'colSpan': _fnVisbleColumns( oSettings ),
2066					'class':   oSettings.oClasses.sRowEmpty
2067				} ).html( sZero ) )[0];
2068		}
2069	
2070		/* Header and footer callbacks */
2071		_fnCallbackFire( oSettings, 'aoHeaderCallback', 'header', [ $(oSettings.nTHead).children('tr')[0],
2072			_fnGetDataMaster( oSettings ), iDisplayStart, iDisplayEnd, aiDisplay ] );
2073	
2074		_fnCallbackFire( oSettings, 'aoFooterCallback', 'footer', [ $(oSettings.nTFoot).children('tr')[0],
2075			_fnGetDataMaster( oSettings ), iDisplayStart, iDisplayEnd, aiDisplay ] );
2076	
2077		var body = $(oSettings.nTBody);
2078	
2079		body.children().detach();
2080		body.append( $(anRows) );
2081	
2082		/* Call all required callback functions for the end of a draw */
2083		_fnCallbackFire( oSettings, 'aoDrawCallback', 'draw', [oSettings] );
2084	
2085		/* Draw is complete, sorting and filtering must be as well */
2086		oSettings.bSorted = false;
2087		oSettings.bFiltered = false;
2088		oSettings.bDrawing = false;
2089	}
2090	
2091	
2092	/**
2093	 * Redraw the table - taking account of the various features which are enabled
2094	 *  @param {object} oSettings dataTables settings object
2095	 *  @param {boolean} [holdPosition] Keep the current paging position. By default
2096	 *    the paging is reset to the first page
2097	 *  @memberof DataTable#oApi
2098	 */
2099	function _fnReDraw( settings, holdPosition )
2100	{
2101		var
2102			features = settings.oFeatures,
2103			sort     = features.bSort,
2104			filter   = features.bFilter;
2105	
2106		if ( sort ) {
2107			_fnSort( settings );
2108		}
2109	
2110		if ( filter ) {
2111			_fnFilterComplete( settings, settings.oPreviousSearch );
2112		}
2113		else {
2114			// No filtering, so we want to just use the display master
2115			settings.aiDisplay = settings.aiDisplayMaster.slice();
2116		}
2117	
2118		if ( holdPosition !== true ) {
2119			settings._iDisplayStart = 0;
2120		}
2121	
2122		// Let any modules know about the draw hold position state (used by
2123		// scrolling internally)
2124		settings._drawHold = holdPosition;
2125	
2126		_fnDraw( settings );
2127	
2128		settings._drawHold = false;
2129	}
2130	
2131	
2132	/**
2133	 * Add the options to the page HTML for the table
2134	 *  @param {object} oSettings dataTables settings object
2135	 *  @memberof DataTable#oApi
2136	 */
2137	function _fnAddOptionsHtml ( oSettings )
2138	{
2139		var classes = oSettings.oClasses;
2140		var table = $(oSettings.nTable);
2141		var holding = $('<div/>').insertBefore( table ); // Holding element for speed
2142		var features = oSettings.oFeatures;
2143	
2144		// All DataTables are wrapped in a div
2145		var insert = $('<div/>', {
2146			id:      oSettings.sTableId+'_wrapper',
2147			'class': classes.sWrapper + (oSettings.nTFoot ? '' : ' '+classes.sNoFooter)
2148		} );
2149	
2150		oSettings.nHolding = holding[0];
2151		oSettings.nTableWrapper = insert[0];
2152		oSettings.nTableReinsertBefore = oSettings.nTable.nextSibling;
2153	
2154		/* Loop over the user set positioning and place the elements as needed */
2155		var aDom = oSettings.sDom.split('');
2156		var featureNode, cOption, nNewNode, cNext, sAttr, j;
2157		for ( var i=0 ; i<aDom.length ; i++ )
2158		{
2159			featureNode = null;
2160			cOption = aDom[i];
2161	
2162			if ( cOption == '<' )
2163			{
2164				/* New container div */
2165				nNewNode = $('<div/>')[0];
2166	
2167				/* Check to see if we should append an id and/or a class name to the container */
2168				cNext = aDom[i+1];
2169				if ( cNext == "'" || cNext == '"' )
2170				{
2171					sAttr = "";
2172					j = 2;
2173					while ( aDom[i+j] != cNext )
2174					{
2175						sAttr += aDom[i+j];
2176						j++;
2177					}
2178	
2179					/* Replace jQuery UI constants @todo depreciated */
2180					if ( sAttr == "H" )
2181					{
2182						sAttr = classes.sJUIHeader;
2183					}
2184					else if ( sAttr == "F" )
2185					{
2186						sAttr = classes.sJUIFooter;
2187					}
2188	
2189					/* The attribute can be in the format of "#id.class", "#id" or "class" This logic
2190					 * breaks the string into parts and applies them as needed
2191					 */
2192					if ( sAttr.indexOf('.') != -1 )
2193					{
2194						var aSplit = sAttr.split('.');
2195						nNewNode.id = aSplit[0].substr(1, aSplit[0].length-1);
2196						nNewNode.className = aSplit[1];
2197					}
2198					else if ( sAttr.charAt(0) == "#" )
2199					{
2200						nNewNode.id = sAttr.substr(1, sAttr.length-1);
2201					}
2202					else
2203					{
2204						nNewNode.className = sAttr;
2205					}
2206	
2207					i += j; /* Move along the position array */
2208				}
2209	
2210				insert.append( nNewNode );
2211				insert = $(nNewNode);
2212			}
2213			else if ( cOption == '>' )
2214			{
2215				/* End container div */
2216				insert = insert.parent();
2217			}
2218			// @todo Move options into their own plugins?
2219			else if ( cOption == 'l' && features.bPaginate && features.bLengthChange )
2220			{
2221				/* Length */
2222				featureNode = _fnFeatureHtmlLength( oSettings );
2223			}
2224			else if ( cOption == 'f' && features.bFilter )
2225			{
2226				/* Filter */
2227				featureNode = _fnFeatureHtmlFilter( oSettings );
2228			}
2229			else if ( cOption == 'r' && features.bProcessing )
2230			{
2231				/* pRocessing */
2232				featureNode = _fnFeatureHtmlProcessing( oSettings );
2233			}
2234			else if ( cOption == 't' )
2235			{
2236				/* Table */
2237				featureNode = _fnFeatureHtmlTable( oSettings );
2238			}
2239			else if ( cOption ==  'i' && features.bInfo )
2240			{
2241				/* Info */
2242				featureNode = _fnFeatureHtmlInfo( oSettings );
2243			}
2244			else if ( cOption == 'p' && features.bPaginate )
2245			{
2246				/* Pagination */
2247				featureNode = _fnFeatureHtmlPaginate( oSettings );
2248			}
2249			else if ( DataTable.ext.feature.length !== 0 )
2250			{
2251				/* Plug-in features */
2252				var aoFeatures = DataTable.ext.feature;
2253				for ( var k=0, kLen=aoFeatures.length ; k<kLen ; k++ )
2254				{
2255					if ( cOption == aoFeatures[k].cFeature )
2256					{
2257						featureNode = aoFeatures[k].fnInit( oSettings );
2258						break;
2259					}
2260				}
2261			}
2262	
2263			/* Add to the 2D features array */
2264			if ( featureNode )
2265			{
2266				var aanFeatures = oSettings.aanFeatures;
2267	
2268				if ( ! aanFeatures[cOption] )
2269				{
2270					aanFeatures[cOption] = [];
2271				}
2272	
2273				aanFeatures[cOption].push( featureNode );
2274				insert.append( featureNode );
2275			}
2276		}
2277	
2278		/* Built our DOM structure - replace the holding div with what we want */
2279		holding.replaceWith( insert );
2280	

2280}
2281	
2282	
2283	/**
2284	 * Use the DOM source to create up an array of header cells. The idea here is to
2285	 * create a layout grid (array) of rows x columns, which contains a reference
2286	 * to the cell that that point in the grid (regardless of col/rowspan), such that
2287	 * any column / row could be removed and the new grid constructed
2288	 *  @param array {object} aLayout Array to store the calculated layout in
2289	 *  @param {node} nThead The header/footer element for the table
2290	 *  @memberof DataTable#oApi
2291	 */
2292	function _fnDetectHeader ( aLayout, nThead )
2293	{
2294		var nTrs = $(nThead).children('tr');
2295		var nTr, nCell;
2296		var i, k, l, iLen, jLen, iColShifted, iColumn, iColspan, iRowspan;
2297		var bUnique;
2298		var fnShiftCol = function ( a, i, j ) {
2299			var k = a[i];
2300	                while ( k[j] ) {
2301				j++;
2302			}
2303			return j;
2304		};
2305	
2306		aLayout.splice( 0, aLayout.length );
2307	
2308		/* We know how many rows there are in the layout - so prep it */
2309		for ( i=0, iLen=nTrs.length ; i<iLen ; i++ )
2310		{
2311			aLayout.push( [] );
2312		}
2313	
2314		/* Calculate a layout array */
2315		for ( i=0, iLen=nTrs.length ; i<iLen ; i++ )
2316		{
2317			nTr = nTrs[i];
2318			iColumn = 0;
2319	
2320			/* For every cell in the row... */
2321			nCell = nTr.firstChild;
2322			while ( nCell ) {
2323				if ( nCell.nodeName.toUpperCase() == "TD" ||
2324				     nCell.nodeName.toUpperCase() == "TH" )
2325				{
2326					/* Get the col and rowspan attributes from the DOM and sanitise them */
2327					iColspan = nCell.getAttribute('colspan') * 1;
2328					iRowspan = nCell.getAttribute('rowspan') * 1;
2329					iColspan = (!iColspan || iColspan===0 || iColspan===1) ? 1 : iColspan;
2330					iRowspan = (!iRowspan || iRowspan===0 || iRowspan===1) ? 1 : iRowspan;
2331	
2332					/* There might be colspan cells already in this row, so shift our target
2333					 * accordingly
2334					 */
2335					iColShifted = fnShiftCol( aLayout, i, iColumn );
2336	
2337					/* Cache calculation for unique columns */
2338					bUnique = iColspan === 1 ? true : false;
2339	
2340					/* If there is col / rowspan, copy the information into the layout grid */
2341					for ( l=0 ; l<iColspan ; l++ )
2342					{
2343						for ( k=0 ; k<iRowspan ; k++ )
2344						{
2345							aLayout[i+k][iColShifted+l] = {
2346								"cell": nCell,
2347								"unique": bUnique
2348							};
2349							aLayout[i+k].nTr = nTr;
2350						}
2351					}
2352				}
2353				nCell = nCell.nextSibling;
2354			}
2355		}
2356	}
2357	
2358	
2359	/**
2360	 * Get an array of unique th elements, one for each column
2361	 *  @param {object} oSettings dataTables settings object
2362	 *  @param {node} nHeader automatically detect the layout from this node - optional
2363	 *  @param {array} aLayout thead/tfoot layout from _fnDetectHeader - optional
2364	 *  @returns array {node} aReturn list of unique th's
2365	 *  @memberof DataTable#oApi
2366	 */
2367	function _fnGetUniqueThs ( oSettings, nHeader, aLayout )
2368	{
2369		var aReturn = [];
2370		if ( !aLayout )
2371		{
2372			aLayout = oSettings.aoHeader;
2373			if ( nHeader )
2374			{
2375				aLayout = [];
2376				_fnDetectHeader( aLayout, nHeader );
2377			}
2378		}
2379	
2380		for ( var i=0, iLen=aLayout.length ; i<iLen ; i++ )
2381		{
2382			for ( var j=0, jLen=aLayout[i].length ; j<jLen ; j++ )
2383			{
2384				if ( aLayout[i][j].unique &&
2385					 (!aReturn[j] || !oSettings.bSortCellsTop) )
2386				{
2387					aReturn[j] = aLayout[i][j].cell;
2388				}
2389			}
2390		}
2391	
2392		return aReturn;
2393	}
2394	
2395	/**
2396	 * Create an Ajax call based on the table's settings, taking into account that
2397	 * parameters can have multiple forms, and backwards compatibility.
2398	 *
2399	 * @param {object} oSettings dataTables settings object
2400	 * @param {array} data Data to send to the server, required by
2401	 *     DataTables - may be augmented by developer callbacks
2402	 * @param {function} fn Callback function to run when data is obtained
2403	 */
2404	function _fnBuildAjax( oSettings, data, fn )
2405	{
2406		// Compatibility with 1.9-, allow fnServerData and event to manipulate
2407		_fnCallbackFire( oSettings, 'aoServerParams', 'serverParams', [data] );
2408	
2409		// Convert to object based for 1.10+ if using the old array scheme which can
2410		// come from server-side processing or serverParams
2411		if ( data && $.isArray(data) ) {
2412			var tmp = {};
2413			var rbracket = /(.*?)\[\]$/;
2414	
2415			$.each( data, function (key, val) {
2416				var match = val.name.match(rbracket);
2417	
2418				if ( match ) {
2419					// Support for arrays
2420					var name = match[0];
2421	
2422					if ( ! tmp[ name ] ) {
2423						tmp[ name ] = [];
2424					}
2425					tmp[ name ].push( val.value );
2426				}
2427				else {
2428					tmp[val.name] = val.value;
2429				}
2430			} );
2431			data = tmp;
2432		}
2433	
2434		var ajaxData;
2435		var ajax = oSettings.ajax;
2436		var instance = oSettings.oInstance;
2437		var callback = function ( json ) {
2438			_fnCallbackFire( oSettings, null, 'xhr', [oSettings, json, oSettings.jqXHR] );
2439			fn( json );
2440		};
2441	
2442		if ( $.isPlainObject( ajax ) && ajax.data )
2443		{
2444			ajaxData = ajax.data;
2445	
2446			var newData = $.isFunction( ajaxData ) ?
2447				ajaxData( data, oSettings ) :  // fn can manipulate data or return
2448				ajaxData;                      // an object object or array to merge
2449	
2450			// If the function returned something, use that alone
2451			data = $.isFunction( ajaxData ) && newData ?
2452				newData :
2453				$.extend( true, data, newData );
2454	
2455			// Remove the data property as we've resolved it already and don't want
2456			// jQuery to do it again (it is restored at the end of the function)
2457			delete ajax.data;
2458		}
2459	
2460		var baseAjax = {
2461			"data": data,
2462			"success": function (json) {
2463				var error = json.error || json.sError;
2464				if ( error ) {
2465					_fnLog( oSettings, 0, error );
2466				}
2467	
2468				oSettings.json = json;
2469				callback( json );
2470			},
2471			"dataType": "json",
2472			"cache": false,
2473			"type": oSettings.sServerMethod,
2474			"error": function (xhr, error, thrown) {
2475				var ret = _fnCallbackFire( oSettings, null, 'xhr', [oSettings, null, oSettings.jqXHR] );
2476	
2477				if ( $.inArray( true, ret ) === -1 ) {
2478					if ( error == "parsererror" ) {
2479						_fnLog( oSettings, 0, 'Invalid JSON response', 1 );
2480					}
2481					else if ( xhr.readyState === 4 ) {
2482						_fnLog( oSettings, 0, 'Ajax error', 7 );
2483					}
2484				}
2485	
2486				_fnProcessingDisplay( oSettings, false );
2487			}
2488		};
2489	
2490		// Store the data submitted for the API
2491		oSettings.oAjaxData = data;
2492	
2493		// Allow plug-ins and external processes to modify the data
2494		_fnCallbackFire( oSettings, null, 'preXhr', [oSettings, data] );
2495	
2496		if ( oSettings.fnServerData )
2497		{
2498			// DataTables 1.9- compatibility
2499			oSettings.fnServerData.call( instance,
2500				oSettings.sAjaxSource,
2501				$.map( data, function (val, key) { // Need to convert back to 1.9 trad format
2502					return { name: key, value: val };
2503				} ),
2504				callback,
2505				oSettings
2506			);
2507		}
2508		else if ( oSettings.sAjaxSource || typeof ajax === 'string' )
2509		{
2510			// DataTables 1.9- compatibility
2511			oSettings.jqXHR = $.ajax( $.extend( baseAjax, {
2512				url: ajax || oSettings.sAjaxSource
2513			} ) );
2514		}
2515		else if ( $.isFunction( ajax ) )
2516		{
2517			// Is a function - let the caller define what needs to be done
2518			oSettings.jqXHR = ajax.call( instance, data, callback, oSettings );
2519		}
2520		else
2521		{
2522			// Object to extend the base settings
2523			oSettings.jqXHR = $.ajax( $.extend( baseAjax, ajax ) );
2524	
2525			// Restore for next time around
2526			ajax.data = ajaxData;
2527		}
2528	}
2529	
2530	
2531	/**
2532	 * Update the table using an Ajax call
2533	 *  @param {object} settings dataTables settings object
2534	 *  @returns {boolean} Block the table drawing or not
2535	 *  @memberof DataTable#oApi
2536	 */
2537	function _fnAjaxUpdate( settings )
2538	{
2539		if ( settings.bAjaxDataGet ) {
2540			settings.iDraw++;
2541			_fnProcessingDisplay( settings, true );
2542	
2543			_fnBuildAjax(
2544				settings,
2545				_fnAjaxParameters( settings ),
2546				function(json) {
2547					_fnAjaxUpdateDraw( settings, json );
2548				}
2549			);
2550	
2551			return false;
2552		}
2553		return true;
2554	}
2555	
2556	
2557	/**
2558	 * Build up the parameters in an object needed for a server-side processing
2559	 * request. Note that this is basically done twice, is different ways - a modern
2560	 * method which is used by default in DataTables 1.10 which uses objects and
2561	 * arrays, or the 1.9- method with is name / value pairs. 1.9 method is used if
2562	 * the sAjaxSource option is used in the initialisation, or the legacyAjax
2563	 * option is set.
2564	 *  @param {object} oSettings dataTables settings object
2565	 *  @returns {bool} block the table drawing or not
2566	 *  @memberof DataTable#oApi
2567	 */
2568	function _fnAjaxParameters( settings )
2569	{
2570		var
2571			columns = settings.aoColumns,
2572			columnCount = columns.length,
2573			features = settings.oFeatures,
2574			preSearch = settings.oPreviousSearch,
2575			preColSearch = settings.aoPreSearchCols,
2576			i, data = [], dataProp, column, columnSearch,
2577			sort = _fnSortFlatten( settings ),
2578			displayStart = settings._iDisplayStart,
2579			displayLength = features.bPaginate !== false ?
2580				settings._iDisplayLength :
2581				-1;
2582	
2583		var param = function ( name, value ) {
2584			data.push( { 'name': name, 'value': value } );
2585		};
2586	
2587		// DataTables 1.9- compatible method
2588		param( 'sEcho',          settings.iDraw );
2589		param( 'iColumns',       columnCount );
2590		param( 'sColumns',       _pluck( columns, 'sName' ).join(',') );
2591		param( 'iDisplayStart',  displayStart );
2592		param( 'iDisplayLength', displayLength );
2593	
2594		// DataTables 1.10+ method
2595		var d = {
2596			draw:    settings.iDraw,
2597			columns: [],
2598			order:   [],
2599			start:   displayStart,
2600			length:  displayLength,
2601			search:  {
2602				value: preSearch.sSearch,
2603				regex: preSearch.bRegex
2604			}
2605		};
2606	
2607		for ( i=0 ; i<columnCount ; i++ ) {
2608			column = columns[i];
2609			columnSearch = preColSearch[i];
2610			dataProp = typeof column.mData=="function" ? 'function' : column.mData ;
2611	
2612			d.columns.push( {
2613				data:       dataProp,
2614				name:       column.sName,
2615				searchable: column.bSearchable,
2616				orderable:  column.bSortable,
2617				search:     {
2618					value: columnSearch.sSearch,
2619					regex: columnSearch.bRegex
2620				}
2621			} );
2622	
2623			param( "mDataProp_"+i, dataProp );
2624	
2625			if ( features.bFilter ) {
2626				param( 'sSearch_'+i,     columnSearch.sSearch );
2627				param( 'bRegex_'+i,      columnSearch.bRegex );
2628				param( 'bSearchable_'+i, column.bSearchable );
2629			}
2630	
2631			if ( features.bSort ) {
2632				param( 'bSortable_'+i, column.bSortable );
2633			}
2634		}
2635	
2636		if ( features.bFilter ) {
2637			param( 'sSearch', preSearch.sSearch );
2638			param( 'bRegex', preSearch.bRegex );
2639		}
2640	
2641		if ( features.bSort ) {
2642			$.each( sort, function ( i, val ) {
2643				d.order.push( { column: val.col, dir: val.dir } );
2644	
2645				param( 'iSortCol_'+i, val.col );
2646				param( 'sSortDir_'+i, val.dir );
2647			} );
2648	
2649			param( 'iSortingCols', sort.length );
2650		}
2651	
2652		// If the legacy.ajax parameter is null, then we automatically decide which
2653		// form to use, based on sAjaxSource
2654		var legacy = DataTable.ext.legacy.ajax;
2655		if ( legacy === null ) {
2656			return settings.sAjaxSource ? data : d;
2657		}
2658	
2659		// Otherwise, if legacy has been specified then we use that to decide on the
2660		// form
2661		return legacy ? data : d;
2662	}
2663	
2664	
2665	/**
2666	 * Data the data from the server (nuking the old) and redraw the table
2667	 *  @param {object} oSettings dataTables settings object
2668	 *  @param {object} json json data return from the server.
2669	 *  @param {string} json.sEcho Tracking flag for DataTables to match requests
2670	 *  @param {int} json.iTotalRecords Number of records in the data set, not accounting for filtering
2671	 *  @param {int} json.iTotalDisplayRecords Number of records in the data set, accounting for filtering
2672	 *  @param {array} json.aaData The data to display on this page
2673	 *  @param {string} [json.sColumns] Column ordering (sName, comma separated)
2674	 *  @memberof DataTable#oApi
2675	 */
2676	function _fnAjaxUpdateDraw ( settings, json )
2677	{
2678		// v1.10 uses camelCase variables, while 1.9 uses Hungarian notation.
2679		// Support both
2680		var compat = function ( old, modern ) {
2681			return json[old] !== undefined ? json[old] : json[modern];
2682		};
2683	
2684		var data = _fnAjaxDataSrc( settings, json );
2685		var draw            = compat( 'sEcho',                'draw' );
2686		var recordsTotal    = compat( 'iTotalRecords',        'recordsTotal' );
2687		var recordsFiltered = compat( 'iTotalDisplayRecords', 'recordsFiltered' );
2688	
2689		if ( draw ) {
2690			// Protect against out of sequence returns
2691			if ( draw*1 < settings.iDraw ) {
2692				return;
2693			}
2694			settings.iDraw = draw * 1;
2695		}
2696	
2697		_fnClearTable( settings );
2698		settings._iRecordsTotal   = parseInt(recordsTotal, 10);
2699		settings._iRecordsDisplay = parseInt(recordsFiltered, 10);
2700	
2701		for ( var i=0, ien=data.length ; i<ien ; i++ ) {
2702			_fnAddData( settings, data[i] );
2703		}
2704		settings.aiDisplay = settings.aiDisplayMaster.slice();
2705	
2706		settings.bAjaxDataGet = false;
2707		_fnDraw( settings );
2708	
2709		if ( ! settings._bInitComplete ) {
2710			_fnInitComplete( settings, json );
2711		}
2712	
2713		settings.bAjaxDataGet = true;
2714		_fnProcessingDisplay( settings, false );
2715	}
2716	
2717	
2718	/**
2719	 * Get the data from the JSON data source to use for drawing a table. Using
2720	 * `_fnGetObjectDataFn` allows the data to be sourced from a property of the
2721	 * source object, or from a processing function.
2722	 *  @param {object} oSettings dataTables settings object
2723	 *  @param  {object} json Data source object / array from the server
2724	 *  @return {array} Array of data to use
2725	 */
2726	function _fnAjaxDataSrc ( oSettings, json )
2727	{
2728		var dataSrc = $.isPlainObject( oSettings.ajax ) && oSettings.ajax.dataSrc !== undefined ?
2729			oSettings.ajax.dataSrc :
2730			oSettings.sAjaxDataProp; // Compatibility with 1.9-.
2731	
2732		// Compatibility with 1.9-. In order to read from aaData, check if the
2733		// default has been changed, if not, check for aaData
2734		if ( dataSrc === 'data' ) {
2735			return json.aaData || json[dataSrc];
2736		}
2737	
2738		return dataSrc !== "" ?
2739			_fnGetObjectDataFn( dataSrc )( json ) :
2740			json;
2741	}
2742	
2743	/**
2744	 * Generate the node required for filtering text
2745	 *  @returns {node} Filter control element
2746	 *  @param {object} oSettings dataTables settings object
2747	 *  @memberof DataTable#oApi
2748	 */
2749	function _fnFeatureHtmlFilter ( settings )
2750	{
2751		var classes = settings.oClasses;
2752		var tableId = settings.sTableId;
2753		var language = settings.oLanguage;
2754		var previousSearch = settings.oPreviousSearch;
2755		var features = settings.aanFeatures;
2756		var input = '<input type="search" class="'+classes.sFilterInput+'"/>';
2757	
2758		var str = language.sSearch;
2759		str = str.match(/_INPUT_/) ?
2760			str.replace('_INPUT_', input) :
2761			str+input;
2762	
2763		var filter = $('<div/>', {
2764				'id': ! features.f ? tableId+'_filter' : null,
2765				'class': classes.sFilter
2766			} )
2767			.append( $('<label/>' ).append( str ) );
2768	
2769		var searchFn = function() {
2770			/* Update all other filter input elements for the new display */
2771			var n = features.f;
2772			var val = !this.value ? "" : this.value; // mental IE8 fix :-(
2773	
2774			/* Now do the filter */
2775			if ( val != previousSearch.sSearch ) {
2776				_fnFilterComplete( settings, {
2777					"sSearch": val,
2778					"bRegex": previousSearch.bRegex,
2779					"bSmart": previousSearch.bSmart ,
2780					"bCaseInsensitive": previousSearch.bCaseInsensitive
2781				} );
2782	
2783				// Need to redraw, without resorting
2784				settings._iDisplayStart = 0;
2785				_fnDraw( settings );
2786			}
2787		};
2788	
2789		var searchDelay = settings.searchDelay !== null ?
2790			settings.searchDelay :
2791			_fnDataSource( settings ) === 'ssp' ?
2792				400 :
2793				0;
2794	
2795		var jqFilter = $('input', filter)
2796			.val( previousSearch.sSearch )
2797			.attr( 'placeholder', language.sSearchPlaceholder )
2798			.bind(
2799				'keyup.DT search.DT input.DT paste.DT cut.DT',
2800				searchDelay ?
2801					_fnThrottle( searchFn, searchDelay ) :
2802					searchFn
2803			)
2804			.bind( 'keypress.DT', function(e) {
2805				/* Prevent form submission */
2806				if ( e.keyCode == 13 ) {
2807					return false;
2808				}
2809			} )
2810			.attr('aria-controls', tableId);
2811	
2812		// Update the input elements whenever the table is filtered
2813		$(settings.nTable).on( 'search.dt.DT', function ( ev, s ) {
2814			if ( settings === s ) {
2815				// IE9 throws an 'unknown error' if document.activeElement is used
2816				// inside an iframe or frame...
2817				try {
2818					if ( jqFilter[0] !== document.activeElement ) {
2819						jqFilter.val( previousSearch.sSearch );
2820					}
2821				}
2822				catch ( e ) {}
2823			}
2824		} );
2825	
2826		return filter[0];
2827	}
2828	
2829	
2830	/**
2831	 * Filter the table using both the global filter and column based filtering
2832	 *  @param {object} oSettings dataTables settings object
2833	 *  @param {object} oSearch search information
2834	 *  @param {int} [iForce] force a research of the master array (1) or not (undefined or 0)
2835	 *  @memberof DataTable#oApi
2836	 */
2837	function _fnFilterComplete ( oSettings, oInput, iForce )
2838	{
2839		var oPrevSearch = oSettings.oPreviousSearch;
2840		var aoPrevSearch = oSettings.aoPreSearchCols;
2841		var fnSaveFilter = function ( oFilter ) {
2842			/* Save the filtering values */
2843			oPrevSearch.sSearch = oFilter.sSearch;
2844			oPrevSearch.bRegex = oFilter.bRegex;
2845			oPrevSearch.bSmart = oFilter.bSmart;
2846			oPrevSearch.bCaseInsensitive = oFilter.bCaseInsensitive;
2847		};
2848		var fnRegex = function ( o ) {
2849			// Backwards compatibility with the bEscapeRegex option
2850			return o.bEscapeRegex !== undefined ? !o.bEscapeRegex : o.bRegex;
2851		};
2852	
2853		// Resolve any column types that are unknown due to addition or invalidation
2854		// @todo As per sort - can this be moved into an event handler?
2855		_fnColumnTypes( oSettings );
2856	
2857		/* In server-side processing all filtering is done by the server, so no point hanging around here */
2858		if ( _fnDataSource( oSettings ) != 'ssp' )
2859		{
2860			/* Global filter */
2861			_fnFilter( oSettings, oInput.sSearch, iForce, fnRegex(oInput), oInput.bSmart, oInput.bCaseInsensitive );
2862			fnSaveFilter( oInput );
2863	
2864			/* Now do the individual column filter */
2865			for ( var i=0 ; i<aoPrevSearch.length ; i++ )
2866			{
2867				_fnFilterColumn( oSettings, aoPrevSearch[i].sSearch, i, fnRegex(aoPrevSearch[i]),
2868					aoPrevSearch[i].bSmart, aoPrevSearch[i].bCaseInsensitive );
2869			}
2870	
2871			/* Custom filtering */
2872			_fnFilterCustom( oSettings );
2873		}
2874		else
2875		{
2876			fnSaveFilter( oInput );
2877		}
2878	
2879		/* Tell the draw function we have been filtering */
2880		oSettings.bFiltered = true;
2881		_fnCallbackFire( oSettings, null, 'search', [oSettings] );
2882	}
2883	
2884	
2885	/**
2886	 * Apply custom filtering functions
2887	 *  @param {object} oSettings dataTables settings object
2888	 *  @memberof DataTable#oApi
2889	 */
2890	function _fnFilterCustom( settings )
2891	{
2892		var filters = DataTable.ext.search;
2893		var displayRows = settings.aiDisplay;
2894		var row, rowIdx;
2895	
2896		for ( var i=0, ien=filters.length ; i<ien ; i++ ) {
2897			var rows = [];
2898	
2899			// Loop over each row and see if it should be included
2900			for ( var j=0, jen=displayRows.length ; j<jen ; j++ ) {
2901				rowIdx = displayRows[ j ];
2902				row = settings.aoData[ rowIdx ];
2903	
2904				if ( filters[i]( settings, row._aFilterData, rowIdx, row._aData, j ) ) {
2905					rows.push( rowIdx );
2906				}
2907			}
2908	
2909			// So the array reference doesn't break set the results into the
2910			// existing array
2911			displayRows.length = 0;
2912			displayRows.push.apply( displayRows, rows );
2913		}
2914	}
2915	
2916	
2917	/**
2918	 * Filter the table on a per-column basis
2919	 *  @param {object} oSettings dataTables settings object
2920	 *  @param {string} sInput string to filter on
2921	 *  @param {int} iColumn column to filter
2922	 *  @param {bool} bRegex treat search string as a regular expression or not
2923	 *  @param {bool} bSmart use smart filtering or not
2924	 *  @param {bool} bCaseInsensitive Do case insenstive matching or not
2925	 *  @memberof DataTable#oApi
2926	 */
2927	function _fnFilterColumn ( settings, searchStr, colIdx, regex, smart, caseInsensitive )
2928	{
2929		if ( searchStr === '' ) {
2930			return;
2931		}
2932	
2933		var data;
2934		var display = settings.aiDisplay;
2935		var rpSearch = _fnFilterCreateSearch( searchStr, regex, smart, caseInsensitive );
2936	
2937		for ( var i=display.length-1 ; i>=0 ; i-- ) {
2938			data = settings.aoData[ display[i] ]._aFilterData[ colIdx ];
2939	
2940			if ( ! rpSearch.test( data ) ) {
2941				display.splice( i, 1 );
2942			}
2943		}
2944	}
2945	
2946	
2947	/**
2948	 * Filter the data table based on user input and draw the table
2949	 *  @param {object} settings dataTables settings object
2950	 *  @param {string} input string to filter on
2951	 *  @param {int} force optional - force a research of the master array (1) or not (undefined or 0)
2952	 *  @param {bool} regex treat as a regular expression or not
2953	 *  @param {bool} smart perform smart filtering or not
2954	 *  @param {bool} caseInsensitive Do case insenstive matching or not
2955	 *  @memberof DataTable#oApi
2956	 */
2957	function _fnFilter( settings, input, force, regex, smart, caseInsensitive )
2958	{
2959		var rpSearch = _fnFilterCreateSearch( input, regex, smart, caseInsensitive );
2960		var prevSearch = settings.oPreviousSearch.sSearch;
2961		var displayMaster = settings.aiDisplayMaster;
2962		var display, invalidated, i;
2963	
2964		// Need to take account of custom filtering functions - always filter
2965		if ( DataTable.ext.search.length !== 0 ) {
2966			force = true;
2967		}
2968	
2969		// Check if any of the rows were invalidated
2970		invalidated = _fnFilterData( settings );
2971	
2972		// If the input is blank - we just want the full data set
2973		if ( input.length <= 0 ) {
2974			settings.aiDisplay = displayMaster.slice();
2975		}
2976		else {
2977			// New search - start from the master array
2978			if ( invalidated ||
2979				 force ||
2980				 prevSearch.length > input.length ||
2981				 input.indexOf(prevSearch) !== 0 ||
2982				 settings.bSorted // On resort, the display master needs to be
2983				                  // re-filtered since indexes will have changed
2984			) {
2985				settings.aiDisplay = displayMaster.slice();
2986			}
2987	
2988			// Search the display array
2989			display = settings.aiDisplay;
2990	
2991			for ( i=display.length-1 ; i>=0 ; i-- ) {
2992				if ( ! rpSearch.test( settings.aoData[ display[i] ]._sFilterRow ) ) {
2993					display.splice( i, 1 );
2994				}
2995			}
2996		}
2997	}
2998	
2999	
3000	/**
3001	 * Build a regular expression object suitable for searching a table
3002	 *  @param {string} sSearch string to search for
3003	 *  @param {bool} bRegex treat as a regular expression or not
3004	 *  @param {bool} bSmart perform smart filtering or not
3005	 *  @param {bool} bCaseInsensitive Do case insensitive matching or not
3006	 *  @returns {RegExp} constructed object
3007	 *  @memberof DataTable#oApi
3008	 */
3009	function _fnFilterCreateSearch( search, regex, smart, caseInsensitive )
3010	{
3011		search = regex ?
3012			search :
3013			_fnEscapeRegex( search );
3014		
3015		if ( smart ) {
3016			/* For smart filtering we want to allow the search to work regardless of
3017			 * word order. We also want double quoted text to be preserved, so word
3018			 * order is important - a la google. So this is what we want to
3019			 * generate:
3020			 * 
3021			 * ^(?=.*?\bone\b)(?=.*?\btwo three\b)(?=.*?\bfour\b).*$
3022			 */
3023			var a = $.map( search.match( /"[^"]+"|[^ ]+/g ) || [''], function ( word ) {
3024				if ( word.charAt(0) === '"' ) {
3025					var m = word.match( /^"(.*)"$/ );
3026					word = m ? m[1] : word;
3027				}
3028	
3029				return word.replace('"', '');
3030			} );
3031	
3032			search = '^(?=.*?'+a.join( ')(?=.*?' )+').*$';
3033		}
3034	
3035		return new RegExp( search, caseInsensitive ? 'i' : '' );
3036	}
3037	
3038	
3039	/**
3040	 * Escape a string such that it can be used in a regular expression
3041	 *  @param {string} sVal string to escape
3042	 *  @returns {string} escaped string
3043	 *  @memberof DataTable#oApi
3044	 */
3045	function _fnEscapeRegex ( sVal )
3046	{
3047		return sVal.replace( _re_escape_regex, '\\$1' );
3048	}
3049	
3050	
3051	
3052	var __filter_div = $('<div>')[0];
3053	var __filter_div_textContent = __filter_div.textContent !== undefined;
3054	
3055	// Update the filtering data for each row if needed (by invalidation or first run)
3056	function _fnFilterData ( settings )
3057	{
3058		var columns = settings.aoColumns;
3059		var column;
3060		var i, j, ien, jen, filterData, cellData, row;
3061		var fomatters = DataTable.ext.type.search;
3062		var wasInvalidated = false;
3063	
3064		for ( i=0, ien=settings.aoData.length ; i<ien ; i++ ) {
3065			row = settings.aoData[i];
3066	
3067			if ( ! row._aFilterData ) {
3068				filterData = [];
3069	
3070				for ( j=0, jen=columns.length ; j<jen ; j++ ) {
3071					column = columns[j];
3072	
3073					if ( column.bSearchable ) {
3074						cellData = _fnGetCellData( settings, i, j, 'filter' );
3075	
3076						if ( fomatters[ column.sType ] ) {
3077							cellData = fomatters[ column.sType ]( cellData );
3078						}
3079	
3080						// Search in DataTables 1.10 is string based. In 1.11 this
3081						// should be altered to also allow strict type checking.
3082						if ( cellData === null ) {
3083							cellData = '';
3084						}
3085	
3086						if ( typeof cellData !== 'string' && cellData.toString ) {
3087							cellData = cellData.toString();
3088						}
3089					}
3090					else {
3091						cellData = '';
3092					}
3093	
3094					// If it looks like there is an HTML entity in the string,
3095					// attempt to decode it so sorting works as expected. Note that
3096					// we could use a single line of jQuery to do this, but the DOM
3097					// method used here is much faster http://jsperf.com/html-decode
3098					if ( cellData.indexOf && cellData.indexOf('&') !== -1 ) {
3099						__filter_div.innerHTML = cellData;
3100						cellData = __filter_div_textContent ?
3101							__filter_div.textContent :
3102							__filter_div.innerText;
3103					}
3104	
3105					if ( cellData.replace ) {
3106						cellData = cellData.replace(/[\r\n]/g, '');
3107					}
3108	
3109					filterData.push( cellData );
3110				}
3111	
3112				row._aFilterData = filterData;
3113				row._sFilterRow = filterData.join('  ');
3114				wasInvalidated = true;
3115			}
3116		}
3117	
3118		return wasInvalidated;
3119	}
3120	
3121	
3122	/**
3123	 * Convert from the internal Hungarian notation to camelCase for external
3124	 * interaction
3125	 *  @param {object} obj Object to convert
3126	 *  @returns {object} Inverted object
3127	 *  @memberof DataTable#oApi
3128	 */
3129	function _fnSearchToCamel ( obj )
3130	{
3131		return {
3132			search:          obj.sSearch,
3133			smart:           obj.bSmart,
3134			regex:           obj.bRegex,
3135			caseInsensitive: obj.bCaseInsensitive
3136		};
3137	}
3138	
3139	
3140	
3141	/**
3142	 * Convert from camelCase notation to the internal Hungarian. We could use the
3143	 * Hungarian convert function here, but this is cleaner
3144	 *  @param {object} obj Object to convert
3145	 *  @returns {object} Inverted object
3146	 *  @memberof DataTable#oApi
3147	 */
3148	function _fnSearchToHung ( obj )
3149	{
3150		return {
3151			sSearch:          obj.search,
3152			bSmart:           obj.smart,
3153			bRegex:           obj.regex,
3154			bCaseInsensitive: obj.caseInsensitive
3155		};
3156	}
3157	
3158	/**
3159	 * Generate the node required for the info display
3160	 *  @param {object} oSettings dataTables settings object
3161	 *  @returns {node} Information element
3162	 *  @memberof DataTable#oApi
3163	 */
3164	function _fnFeatureHtmlInfo ( settings )
3165	{
3166		var
3167			tid = settings.sTableId,
3168			nodes = settings.aanFeatures.i,
3169			n = $('<div/>', {
3170				'class': settings.oClasses.sInfo,
3171				'id': ! nodes ? tid+'_info' : null
3172			} );
3173	
3174		if ( ! nodes ) {
3175			// Update display on each draw
3176			settings.aoDrawCallback.push( {
3177				"fn": _fnUpdateInfo,
3178				"sName": "information"
3179			} );
3180	
3181			n
3182				.attr( 'role', 'status' )
3183				.attr( 'aria-live', 'polite' );
3184	
3185			// Table is described by our info div
3186			$(settings.nTable).attr( 'aria-describedby', tid+'_info' );
3187		}
3188	
3189		return n[0];
3190	}
3191	
3192	
3193	/**
3194	 * Update the information elements in the display
3195	 *  @param {object} settings dataTables settings object
3196	 *  @memberof DataTable#oApi
3197	 */
3198	function _fnUpdateInfo ( settings )
3199	{
3200		/* Show information about the table */
3201		var nodes = settings.aanFeatures.i;
3202		if ( nodes.length === 0 ) {
3203			return;
3204		}
3205	
3206		var
3207			lang  = settings.oLanguage,
3208			start = settings._iDisplayStart+1,
3209			end   = settings.fnDisplayEnd(),
3210			max   = settings.fnRecordsTotal(),
3211			total = settings.fnRecordsDisplay(),
3212			out   = total ?
3213				lang.sInfo :
3214				lang.sInfoEmpty;
3215	
3216		if ( total !== max ) {
3217			/* Record set after filtering */
3218			out += ' ' + lang.sInfoFiltered;
3219		}
3220	
3221		// Convert the macros
3222		out += lang.sInfoPostFix;
3223		out = _fnInfoMacros( settings, out );
3224	
3225		var callback = lang.fnInfoCallback;
3226		if ( callback !== null ) {
3227			out = callback.call( settings.oInstance,
3228				settings, start, end, max, total, out
3229			);
3230		}
3231	
3232		$(nodes).html( out );
3233	}
3234	
3235	
3236	function _fnInfoMacros ( settings, str )
3237	{
3238		// When infinite scrolling, we are always starting at 1. _iDisplayStart is used only
3239		// internally
3240		var
3241			formatter  = settings.fnFormatNumber,
3242			start      = settings._iDisplayStart+1,
3243			len        = settings._iDisplayLength,
3244			vis        = settings.fnRecordsDisplay(),
3245			all        = len === -1;
3246	
3247		return str.
3248			replace(/_START_/g, formatter.call( settings, start ) ).
3249			replace(/_END_/g,   formatter.call( settings, settings.fnDisplayEnd() ) ).
3250			replace(/_MAX_/g,   formatter.call( settings, settings.fnRecordsTotal() ) ).
3251			replace(/_TOTAL_/g, formatter.call( settings, vis ) ).
3252			replace(/_PAGE_/g,  formatter.call( settings, all ? 1 : Math.ceil( start / len ) ) ).
3253			replace(/_PAGES_/g, formatter.call( settings, all ? 1 : Math.ceil( vis / len ) ) );
3254	}
3255	
3256	
3257	
3258	/**
3259	 * Draw the table for the first time, adding all required features
3260	 *  @param {object} settings dataTables settings object
3261	 *  @memberof DataTable#oApi
3262	 */
3263	function _fnInitialise ( settings )
3264	{
3265		var i, iLen, iAjaxStart=settings.iInitDisplayStart;
3266		var columns = settings.aoColumns, column;
3267		var features = settings.oFeatures;
3268	
3269		/* Ensure that the table data is fully initialised */
3270		if ( ! settings.bInitialised ) {
3271			setTimeout( function(){ _fnInitialise( settings ); }, 200 );
3272			return;
3273		}
3274	
3275		/* Show the display HTML options */
3276		_fnAddOptionsHtml( settings );
3277	
3278		/* Build and draw the header / footer for the table */
3279		_fnBuildHead( settings );
3280		_fnDrawHead( settings, settings.aoHeader );
3281		_fnDrawHead( settings, settings.aoFooter );
3282	
3283		/* Okay to show that something is going on now */
3284		_fnProcessingDisplay( settings, true );
3285	
3286		/* Calculate sizes for columns */
3287		if ( features.bAutoWidth ) {
3288			_fnCalculateColumnWidths( settings );
3289		}
3290	
3291		for ( i=0, iLen=columns.length ; i<iLen ; i++ ) {
3292			column = columns[i];
3293	
3294			if ( column.sWidth ) {
3295				column.nTh.style.width = _fnStringToCss( column.sWidth );
3296			}
3297		}
3298	
3299		// If there is default sorting required - let's do it. The sort function
3300		// will do the drawing for us. Otherwise we draw the table regardless of the
3301		// Ajax source - this allows the table to look initialised for Ajax sourcing
3302		// data (show 'loading' message possibly)
3303		_fnReDraw( settings );
3304	
3305		// Server-side processing init complete is done by _fnAjaxUpdateDraw
3306		var dataSrc = _fnDataSource( settings );
3307		if ( dataSrc != 'ssp' ) {
3308			// if there is an ajax source load the data
3309			if ( dataSrc == 'ajax' ) {
3310				_fnBuildAjax( settings, [], function(json) {
3311					var aData = _fnAjaxDataSrc( settings, json );
3312	
3313					// Got the data - add it to the table
3314					for ( i=0 ; i<aData.length ; i++ ) {
3315						_fnAddData( settings, aData[i] );
3316					}
3317	
3318					// Reset the init display for cookie saving. We've already done
3319					// a filter, and therefore cleared it before. So we need to make
3320					// it appear 'fresh'
3321					settings.iInitDisplayStart = iAjaxStart;
3322	
3323					_fnReDraw( settings );
3324	
3325					_fnProcessingDisplay( settings, false );
3326					_fnInitComplete( settings, json );
3327				}, settings );
3328			}
3329			else {
3330				_fnProcessingDisplay( settings, false );
3331				_fnInitComplete( settings );
3332			}
3333		}
3334	}
3335	
3336	
3337	/**
3338	 * Draw the table for the first time, adding all required features
3339	 *  @param {object} oSettings dataTables settings object
3340	 *  @param {object} [json] JSON from the server that completed the table, if using Ajax source
3341	 *    with client-side processing (optional)
3342	 *  @memberof DataTable#oApi
3343	 */
3344	function _fnInitComplete ( settings, json )
3345	{
3346		settings._bInitComplete = true;
3347	
3348		// On an Ajax load we now have data and therefore want to apply the column
3349		// sizing
3350		if ( json ) {
3351			_fnAdjustColumnSizing( settings );
3352		}
3353	
3354		_fnCallbackFire( settings, 'aoInitComplete', 'init', [settings, json] );
3355	}
3356	
3357	
3358	function _fnLengthChange ( settings, val )
3359	{
3360		var len = parseInt( val, 10 );
3361		settings._iDisplayLength = len;
3362	
3363		_fnLengthOverflow( settings );
3364	
3365		// Fire length change event
3366		_fnCallbackFire( settings, null, 'length', [settings, len] );
3367	}
3368	
3369	
3370	/**
3371	 * Generate the node required for user display length changing
3372	 *  @param {object} settings dataTables settings object
3373	 *  @returns {node} Display length feature node
3374	 *  @memberof DataTable#oApi
3375	 */
3376	function _fnFeatureHtmlLength ( settings )
3377	{
3378		var
3379			classes  = settings.oClasses,
3380			tableId  = settings.sTableId,
3381			menu     = settings.aLengthMenu,
3382			d2       = $.isArray( menu[0] ),
3383			lengths  = d2 ? menu[0] : menu,
3384			language = d2 ? menu[1] : menu;
3385	
3386		var select = $('<select/>', {
3387			'name':          tableId+'_length',
3388			'aria-controls': tableId,
3389			'class':         classes.sLengthSelect
3390		} );
3391	
3392		for ( var i=0, ien=lengths.length ; i<ien ; i++ ) {
3393			select[0][ i ] = new Option( language[i], lengths[i] );
3394		}
3395	
3396		var div = $('<div><label/></div>').addClass( classes.sLength );
3397		if ( ! settings.aanFeatures.l ) {
3398			div[0].id = tableId+'_length';
3399		}
3400	
3401		div.children().append(
3402			settings.oLanguage.sLengthMenu.replace( '_MENU_', select[0].outerHTML )
3403		);
3404	
3405		// Can't use `select` variable as user might provide their own and the
3406		// reference is broken by the use of outerHTML
3407		$('select', div)
3408			.val( settings._iDisplayLength )
3409			.bind( 'change.DT', function(e) {
3410				_fnLengthChange( settings, $(this).val() );
3411				_fnDraw( settings );
3412			} );
3413	
3414		// Update node value whenever anything changes the table's length
3415		$(settings.nTable).bind( 'length.dt.DT', function (e, s, len) {
3416			if ( settings === s ) {
3417				$('select', div).val( len );
3418			}
3419		} );
3420	
3421		return div[0];
3422	}
3423	
3424	
3425	
3426	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
3427	 * Note that most of the paging logic is done in
3428	 * DataTable.ext.pager
3429	 */
3430	
3431	/**
3432	 * Generate the node required for default pagination
3433	 *  @param {object} oSettings dataTables settings object
3434	 *  @returns {node} Pagination feature node
3435	 *  @memberof DataTable#oApi
3436	 */
3437	function _fnFeatureHtmlPaginate ( settings )
3438	{
3439		var
3440			type   = settings.sPaginationType,
3441			plugin = DataTable.ext.pager[ type ],
3442			modern = typeof plugin === 'function',
3443			redraw = function( settings ) {
3444				_fnDraw( settings );
3445			},
3446			node = $('<div/>').addClass( settings.oClasses.sPaging + type )[0],
3447			features = settings.aanFeatures;
3448	
3449		if ( ! modern ) {
3450			plugin.fnInit( settings, node, redraw );
3451		}
3452	
3453		/* Add a draw callback for the pagination on first instance, to update the paging display */
3454		if ( ! features.p )
3455		{
3456			node.id = settings.sTableId+'_paginate';
3457	
3458			settings.aoDrawCallback.push( {
3459				"fn": function( settings ) {
3460					if ( modern ) {
3461						var
3462							start      = settings._iDisplayStart,
3463							len        = settings._iDisplayLength,
3464							visRecords = settings.fnRecordsDisplay(),
3465							all        = len === -1,
3466							page = all ? 0 : Math.ceil( start / len ),
3467							pages = all ? 1 : Math.ceil( visRecords / len ),
3468							buttons = plugin(page, pages),
3469							i, ien;
3470	
3471						for ( i=0, ien=features.p.length ; i<ien ; i++ ) {
3472							_fnRenderer( settings, 'pageButton' )(
3473								settings, features.p[i], i, buttons, page, pages
3474							);
3475						}
3476					}
3477					else {
3478						plugin.fnUpdate( settings, redraw );
3479					}
3480				},
3481				"sName": "pagination"
3482			} );
3483		}
3484	
3485		return node;
3486	}
3487	
3488	
3489	/**
3490	 * Alter the display settings to change the page
3491	 *  @param {object} settings DataTables settings object
3492	 *  @param {string|int} action Paging action to take: "first", "previous",
3493	 *    "next" or "last" or page number to jump to (integer)
3494	 *  @param [bool] redraw Automatically draw the update or not
3495	 *  @returns {bool} true page has changed, false - no change
3496	 *  @memberof DataTable#oApi
3497	 */
3498	function _fnPageChange ( settings, action, redraw )
3499	{
3500		var
3501			start     = settings._iDisplayStart,
3502			len       = settings._iDisplayLength,
3503			records   = settings.fnRecordsDisplay();
3504	
3505		if ( records === 0 || len === -1 )
3506		{
3507			start = 0;
3508		}
3509		else if ( typeof action === "number" )
3510		{
3511			start = action * len;
3512	
3513			if ( start > records )
3514			{
3515				start = 0;
3516			}
3517		}
3518		else if ( action == "first" )
3519		{
3520			start = 0;
3521		}
3522		else if ( action == "previous" )
3523		{
3524			start = len >= 0 ?
3525				start - len :
3526				0;
3527	
3528			if ( start < 0 )
3529			{
3530			  start = 0;
3531			}
3532		}
3533		else if ( action == "next" )
3534		{
3535			if ( start + len < records )
3536			{
3537				start += len;
3538			}
3539		}
3540		else if ( action == "last" )
3541		{
3542			start = Math.floor( (records-1) / len) * len;
3543		}
3544		else
3545		{
3546			_fnLog( settings, 0, "Unknown paging action: "+action, 5 );
3547		}
3548	
3549		var changed = settings._iDisplayStart !== start;
3550		settings._iDisplayStart = start;
3551	
3552		if ( changed ) {
3553			_fnCallbackFire( settings, null, 'page', [settings] );
3554	
3555			if ( redraw ) {
3556				_fnDraw( settings );
3557			}
3558		}
3559	
3560		return changed;
3561	}
3562	
3563	
3564	
3565	/**
3566	 * Generate the node required for the processing node
3567	 *  @param {object} settings dataTables settings object
3568	 *  @returns {node} Processing element
3569	 *  @memberof DataTable#oApi
3570	 */
3571	function _fnFeatureHtmlProcessing ( settings )
3572	{
3573		return $('<div/>', {
3574				'id': ! settings.aanFeatures.r ? settings.sTableId+'_processing' : null,
3575				'class': settings.oClasses.sProcessing
3576			} )
3577			.html( settings.oLanguage.sProcessing )
3578			.insertBefore( settings.nTable )[0];
3579	}
3580	
3581	
3582	/**
3583	 * Display or hide the processing indicator
3584	 *  @param {object} settings dataTables settings object
3585	 *  @param {bool} show Show the processing indicator (true) or not (false)
3586	 *  @memberof DataTable#oApi
3587	 */
3588	function _fnProcessingDisplay ( settings, show )
3589	{
3590		if ( settings.oFeatures.bProcessing ) {
3591			$(settings.aanFeatures.r).css( 'display', show ? 'block' : 'none' );
3592		}
3593	
3594		_fnCallbackFire( settings, null, 'processing', [settings, show] );
3595	}
3596	
3597	/**
3598	 * Add any control elements for the table - specifically scrolling
3599	 *  @param {object} settings dataTables settings object
3600	 *  @returns {node} Node to add to the DOM
3601	 *  @memberof DataTable#oApi
3602	 */
3603	function _fnFeatureHtmlTable ( settings )
3604	{
3605		var table = $(settings.nTable);
3606	
3607		// Add the ARIA grid role to the table
3608		table.attr( 'role', 'grid' );
3609	
3610		// Scrolling from here on in
3611		var scroll = settings.oScroll;
3612	
3613		if ( scroll.sX === '' && scroll.sY === '' ) {
3614			return settings.nTable;
3615		}
3616	
3617		var scrollX = scroll.sX;
3618		var scrollY = scroll.sY;
3619		var classes = settings.oClasses;
3620		var caption = table.children('caption');
3621		var captionSide = caption.length ? caption[0]._captionSide : null;
3622		var headerClone = $( table[0].cloneNode(false) );
3623		var footerClone = $( table[0].cloneNode(false) );
3624		var footer = table.children('tfoot');
3625		var _div = '<div/>';
3626		var size = function ( s ) {
3627			return !s ? null : _fnStringToCss( s );
3628		};
3629	
3630		// This is fairly messy, but with x scrolling enabled, if the table has a
3631		// width attribute, regardless of any width applied using the column width
3632		// options, the browser will shrink or grow the table as needed to fit into
3633		// that 100%. That would make the width options useless. So we remove it.
3634		// This is okay, under the assumption that width:100% is applied to the
3635		// table in CSS (it is in the default stylesheet) which will set the table
3636		// width as appropriate (the attribute and css behave differently...)
3637		if ( scroll.sX && table.attr('width') === '100%' ) {
3638			table.removeAttr('width');
3639		}
3640	
3641		if ( ! footer.length ) {
3642			footer = null;
3643		}
3644	
3645		/*
3646		 * The HTML structure that we want to generate in this function is:
3647		 *  div - scroller
3648		 *    div - scroll head
3649		 *      div - scroll head inner
3650		 *        table - scroll head table
3651		 *          thead - thead
3652		 *    div - scroll body
3653		 *      table - table (master table)
3654		 *        thead - thead clone for sizing
3655		 *        tbody - tbody
3656		 *    div - scroll foot
3657		 *      div - scroll foot inner
3658		 *        table - scroll foot table
3659		 *          tfoot - tfoot
3660		 */
3661		var scroller = $( _div, { 'class': classes.sScrollWrapper } )
3662			.append(
3663				$(_div, { 'class': classes.sScrollHead } )
3664					.css( {
3665						overflow: 'hidden',
3666						position: 'relative',
3667						border: 0,
3668						width: scrollX ? size(scrollX) : '100%'
3669					} )
3670					.append(
3671						$(_div, { 'class': classes.sScrollHeadInner } )
3672							.css( {
3673								'box-sizing': 'content-box',
3674								width: scroll.sXInner || '100%'
3675							} )
3676							.append(
3677								headerClone
3678									.removeAttr('id')
3679									.css( 'margin-left', 0 )
3680									.append( captionSide === 'top' ? caption : null )
3681									.append(
3682										table.children('thead')
3683									)
3684							)
3685					)
3686			)
3687			.append(
3688				$(_div, { 'class': classes.sScrollBody } )
3689					.css( {
3690						overflow: 'auto',
3691						height: size( scrollY ),
3692						width: size( scrollX )
3693					} )
3694					.append( table )
3695			);
3696	
3697		if ( footer ) {
3698			scroller.append(
3699				$(_div, { 'class': classes.sScrollFoot } )
3700					.css( {
3701						overflow: 'hidden',
3702						border: 0,
3703						width: scrollX ? size(scrollX) : '100%'
3704					} )
3705					.append(
3706						$(_div, { 'class': classes.sScrollFootInner } )
3707							.append(
3708								footerClone
3709									.removeAttr('id')
3710									.css( 'margin-left', 0 )
3711									.append( captionSide === 'bottom' ? caption : null )
3712									.append(
3713										table.children('tfoot')
3714									)
3715							)
3716					)
3717			);
3718		}
3719	
3720		var children = scroller.children();
3721		var scrollHead = children[0];
3722		var scrollBody = children[1];
3723		var scrollFoot = footer ? children[2] : null;
3724	
3725		// When the body is scrolled, then we also want to scroll the headers
3726		if ( scrollX ) {
3727			$(scrollBody).on( 'scroll.DT', function (e) {
3728				var scrollLeft = this.scrollLeft;
3729	
3730				scrollHead.scrollLeft = scrollLeft;
3731	
3732				if ( footer ) {
3733					scrollFoot.scrollLeft = scrollLeft;
3734				}
3735			} );
3736		}
3737	
3738		settings.nScrollHead = scrollHead;
3739		settings.nScrollBody = scrollBody;
3740		settings.nScrollFoot = scrollFoot;
3741	
3742		// On redraw - align columns
3743		settings.aoDrawCallback.push( {
3744			"fn": _fnScrollDraw,
3745			"sName": "scrolling"
3746		} );
3747	
3748		return scroller[0];
3749	}
3750	
3751	
3752	
3753	/**
3754	 * Update the header, footer and body tables for resizing - i.e. column
3755	 * alignment.
3756	 *
3757	 * Welcome to the most horrible function DataTables. The process that this
3758	 * function follows is basically:
3759	 *   1. Re-create the table inside the scrolling div
3760	 *   2. Take live measurements from the DOM
3761	 *   3. Apply the measurements to align the columns
3762	 *   4. Clean up
3763	 *
3764	 *  @param {object} settings dataTables settings object
3765	 *  @memberof DataTable#oApi
3766	 */
3767	function _fnScrollDraw ( settings )
3768	{
3769		// Given that this is such a monster function, a lot of variables are use
3770		// to try and keep the minimised size as small as possible
3771		var
3772			scroll         = settings.oScroll,
3773			scrollX        = scroll.sX,
3774			scrollXInner   = scroll.sXInner,
3775			scrollY        = scroll.sY,
3776			barWidth       = scroll.iBarWidth,
3777			divHeader      = $(settings.nScrollHead),
3778			divHeaderStyle = divHeader[0].style,
3779			divHeaderInner = divHeader.children('div'),
3780			divHeaderInnerStyle = divHeaderInner[0].style,
3781			divHeaderTable = divHeaderInner.children('table'),
3782			divBodyEl      = settings.nScrollBody,