Context navigation

source: main/waeup.sirp/trunk/src/waeup/sirp/browser/static/jquery.dataTables.js @ 6010

Last change on this file since 6010 was 6010, checked in by uli, 14 years ago
Add stylesheets and javascripts for lean datatables and the new theme.
File size: 206.3 KB

Line
1	/*
2	* File: jquery.dataTables.js
3	* Version: 1.7.6
4	* Description: Paginate, search and sort HTML tables
5	* Author: Allan Jardine (www.sprymedia.co.uk)
6	* Created: 28/3/2008
7	* Language: Javascript
8	* License: GPL v2 or BSD 3 point style
9	* Project: Mtaala
10	* Contact: allan.jardine@sprymedia.co.uk
11	*
12	* Copyright 2008-2010 Allan Jardine, all rights reserved.
13	*
14	* This source file is free software, under either the GPL v2 license or a
15	* BSD style license, as supplied with this software.
16	*
17	* This source file is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
19	* or FITNESS FOR A PARTICULAR PURPOSE. See the license files for details.
20	*
21	* For details please refer to: http://www.datatables.net
22	*/
23
24	/*
25	* When considering jsLint, we need to allow eval() as it it is used for reading cookies and
26	* building the dynamic multi-column sort functions.
27	*/
28	/jslint evil: true, undef: true, browser: true /
29	/globals $, jQuery,_fnExternApiFunc,_fnInitalise,_fnInitComplete,_fnLanguageProcess,_fnAddColumn,_fnColumnOptions,_fnAddData,_fnGatherData,_fnDrawHead,_fnDraw,_fnReDraw,_fnAjaxUpdate,_fnAjaxUpdateDraw,_fnAddOptionsHtml,_fnFeatureHtmlTable,_fnScrollDraw,_fnAjustColumnSizing,_fnFeatureHtmlFilter,_fnFilterComplete,_fnFilterCustom,_fnFilterColumn,_fnFilter,_fnBuildSearchArray,_fnBuildSearchRow,_fnFilterCreateSearch,_fnDataToSearch,_fnSort,_fnSortAttachListener,_fnSortingClasses,_fnFeatureHtmlPaginate,_fnPageChange,_fnFeatureHtmlInfo,_fnUpdateInfo,_fnFeatureHtmlLength,_fnFeatureHtmlProcessing,_fnProcessingDisplay,_fnVisibleToColumnIndex,_fnColumnIndexToVisible,_fnNodeToDataIndex,_fnVisbleColumns,_fnCalculateEnd,_fnConvertToWidth,_fnCalculateColumnWidths,_fnScrollingWidthAdjust,_fnGetWidestNode,_fnGetMaxLenString,_fnStringToCss,_fnArrayCmp,_fnDetectType,_fnSettingsFromNode,_fnGetDataMaster,_fnGetTrNodes,_fnGetTdNodes,_fnEscapeRegex,_fnDeleteIndex,_fnReOrderIndex,_fnColumnOrdering,_fnLog,_fnClearTable,_fnSaveState,_fnLoadState,_fnCreateCookie,_fnReadCookie,_fnGetUniqueThs,_fnScrollBarWidth,_fnApplyToChildren,_fnMap/
30
31	(function($, window, document) {
32	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
33	* Section - DataTables variables
34	* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
35
36	/*
37	* Variable: dataTableSettings
38	* Purpose: Store the settings for each dataTables instance
39	* Scope: jQuery.fn
40	*/
41	$.fn.dataTableSettings = [];
42	var _aoSettings = $.fn.dataTableSettings; /* Short reference for fast internal lookup */
43
44	/*
45	* Variable: dataTableExt
46	* Purpose: Container for customisable parts of DataTables
47	* Scope: jQuery.fn
48	*/
49	$.fn.dataTableExt = {};
50	var _oExt = $.fn.dataTableExt;
51
52
53	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
54	* Section - DataTables extensible objects
55	*
56	* The _oExt object is used to provide an area where user dfined plugins can be
57	* added to DataTables. The following properties of the object are used:
58	* oApi - Plug-in API functions
59	* aTypes - Auto-detection of types
60	* oSort - Sorting functions used by DataTables (based on the type)
61	* oPagination - Pagination functions for different input styles
62	* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
63
64	/*
65	* Variable: sVersion
66	* Purpose: Version string for plug-ins to check compatibility
67	* Scope: jQuery.fn.dataTableExt
68	* Notes: Allowed format is a.b.c.d.e where:
69	* a:int, b:int, c:int, d:string(dev\|beta), e:int. d and e are optional
70	*/
71	_oExt.sVersion = "1.7.6";
72
73	/*
74	* Variable: sErrMode
75	* Purpose: How should DataTables report an error. Can take the value 'alert' or 'throw'
76	* Scope: jQuery.fn.dataTableExt
77	*/
78	_oExt.sErrMode = "alert";
79
80	/*
81	* Variable: iApiIndex
82	* Purpose: Index for what 'this' index API functions should use
83	* Scope: jQuery.fn.dataTableExt
84	*/
85	_oExt.iApiIndex = 0;
86
87	/*
88	* Variable: oApi
89	* Purpose: Container for plugin API functions
90	* Scope: jQuery.fn.dataTableExt
91	*/
92	_oExt.oApi = { };
93
94	/*
95	* Variable: aFiltering
96	* Purpose: Container for plugin filtering functions
97	* Scope: jQuery.fn.dataTableExt
98	*/
99	_oExt.afnFiltering = [ ];
100
101	/*
102	* Variable: aoFeatures
103	* Purpose: Container for plugin function functions
104	* Scope: jQuery.fn.dataTableExt
105	* Notes: Array of objects with the following parameters:
106	* fnInit: Function for initialisation of Feature. Takes oSettings and returns node
107	* cFeature: Character that will be matched in sDom - case sensitive
108	* sFeature: Feature name - just for completeness :-)
109	*/
110	_oExt.aoFeatures = [ ];
111
112	/*
113	* Variable: ofnSearch
114	* Purpose: Container for custom filtering functions
115	* Scope: jQuery.fn.dataTableExt
116	* Notes: This is an object (the name should match the type) for custom filtering function,
117	* which can be used for live DOM checking or formatted text filtering
118	*/
119	_oExt.ofnSearch = { };
120
121	/*
122	* Variable: afnSortData
123	* Purpose: Container for custom sorting data source functions
124	* Scope: jQuery.fn.dataTableExt
125	* Notes: Array (associative) of functions which is run prior to a column of this
126	* 'SortDataType' being sorted upon.
127	* Function input parameters:
128	* object:oSettings- DataTables settings object
129	* int:iColumn - Target column number
130	* Return value: Array of data which exactly matched the full data set size for the column to
131	* be sorted upon
132	*/
133	_oExt.afnSortData = [ ];
134
135	/*
136	* Variable: oStdClasses
137	* Purpose: Storage for the various classes that DataTables uses
138	* Scope: jQuery.fn.dataTableExt
139	*/
140	_oExt.oStdClasses = {
141	/* Two buttons buttons */
142	"sPagePrevEnabled": "paginate_enabled_previous",
143	"sPagePrevDisabled": "paginate_disabled_previous",
144	"sPageNextEnabled": "paginate_enabled_next",
145	"sPageNextDisabled": "paginate_disabled_next",
146	"sPageJUINext": "",
147	"sPageJUIPrev": "",
148
149	/* Full numbers paging buttons */
150	"sPageButton": "paginate_button",
151	"sPageButtonActive": "paginate_active",
152	"sPageButtonStaticDisabled": "paginate_button",
153	"sPageFirst": "first",
154	"sPagePrevious": "previous",
155	"sPageNext": "next",
156	"sPageLast": "last",
157
158	/* Stripping classes */
159	"sStripOdd": "odd",
160	"sStripEven": "even",
161
162	/* Empty row */
163	"sRowEmpty": "dataTables_empty",
164
165	/* Features */
166	"sWrapper": "dataTables_wrapper",
167	"sFilter": "dataTables_filter",
168	"sInfo": "dataTables_info",
169	"sPaging": "dataTables_paginate paging_", /* Note that the type is postfixed */
170	"sLength": "dataTables_length",
171	"sProcessing": "dataTables_processing",
172
173	/* Sorting */
174	"sSortAsc": "sorting_asc",
175	"sSortDesc": "sorting_desc",
176	"sSortable": "sorting", /* Sortable in both directions */
177	"sSortableAsc": "sorting_asc_disabled",
178	"sSortableDesc": "sorting_desc_disabled",
179	"sSortableNone": "sorting_disabled",
180	"sSortColumn": "sorting_", /* Note that an int is postfixed for the sorting order */
181	"sSortJUIAsc": "",
182	"sSortJUIDesc": "",
183	"sSortJUI": "",
184	"sSortJUIAscAllowed": "",
185	"sSortJUIDescAllowed": "",
186	"sSortJUIWrapper": "",
187
188	/* Scrolling */
189	"sScrollWrapper": "dataTables_scroll",
190	"sScrollHead": "dataTables_scrollHead",
191	"sScrollHeadInner": "dataTables_scrollHeadInner",
192	"sScrollBody": "dataTables_scrollBody",
193	"sScrollFoot": "dataTables_scrollFoot",
194	"sScrollFootInner": "dataTables_scrollFootInner",
195
196	/* Misc */
197	"sFooterTH": ""
198	};
199
200	/*
201	* Variable: oJUIClasses
202	* Purpose: Storage for the various classes that DataTables uses - jQuery UI suitable
203	* Scope: jQuery.fn.dataTableExt
204	*/
205	_oExt.oJUIClasses = {
206	/* Two buttons buttons */
207	"sPagePrevEnabled": "fg-button ui-button ui-state-default ui-corner-left",
208	"sPagePrevDisabled": "fg-button ui-button ui-state-default ui-corner-left ui-state-disabled",
209	"sPageNextEnabled": "fg-button ui-button ui-state-default ui-corner-right",
210	"sPageNextDisabled": "fg-button ui-button ui-state-default ui-corner-right ui-state-disabled",
211	"sPageJUINext": "ui-icon ui-icon-circle-arrow-e",
212	"sPageJUIPrev": "ui-icon ui-icon-circle-arrow-w",
213
214	/* Full numbers paging buttons */
215	"sPageButton": "fg-button ui-button ui-state-default",
216	"sPageButtonActive": "fg-button ui-button ui-state-default ui-state-disabled",
217	"sPageButtonStaticDisabled": "fg-button ui-button ui-state-default ui-state-disabled",
218	"sPageFirst": "first ui-corner-tl ui-corner-bl",
219	"sPagePrevious": "previous",
220	"sPageNext": "next",
221	"sPageLast": "last ui-corner-tr ui-corner-br",
222
223	/* Stripping classes */
224	"sStripOdd": "odd",
225	"sStripEven": "even",
226
227	/* Empty row */
228	"sRowEmpty": "dataTables_empty",
229
230	/* Features */
231	"sWrapper": "dataTables_wrapper",
232	"sFilter": "dataTables_filter",
233	"sInfo": "dataTables_info",
234	"sPaging": "dataTables_paginate fg-buttonset ui-buttonset fg-buttonset-multi "+
235	"ui-buttonset-multi paging_", /* Note that the type is postfixed */
236	"sLength": "dataTables_length",
237	"sProcessing": "dataTables_processing",
238
239	/* Sorting */
240	"sSortAsc": "ui-state-default",
241	"sSortDesc": "ui-state-default",
242	"sSortable": "ui-state-default",
243	"sSortableAsc": "ui-state-default",
244	"sSortableDesc": "ui-state-default",
245	"sSortableNone": "ui-state-default",
246	"sSortColumn": "sorting_", /* Note that an int is postfixed for the sorting order */
247	"sSortJUIAsc": "css_right ui-icon ui-icon-triangle-1-n",
248	"sSortJUIDesc": "css_right ui-icon ui-icon-triangle-1-s",
249	"sSortJUI": "css_right ui-icon ui-icon-carat-2-n-s",
250	"sSortJUIAscAllowed": "css_right ui-icon ui-icon-carat-1-n",
251	"sSortJUIDescAllowed": "css_right ui-icon ui-icon-carat-1-s",
252	"sSortJUIWrapper": "DataTables_sort_wrapper",
253
254	/* Scrolling */
255	"sScrollWrapper": "dataTables_scroll",
256	"sScrollHead": "dataTables_scrollHead ui-state-default",
257	"sScrollHeadInner": "dataTables_scrollHeadInner",
258	"sScrollBody": "dataTables_scrollBody",
259	"sScrollFoot": "dataTables_scrollFoot ui-state-default",
260	"sScrollFootInner": "dataTables_scrollFootInner",
261
262	/* Misc */
263	"sFooterTH": "ui-state-default"
264	};
265
266	/*
267	* Variable: oPagination
268	* Purpose: Container for the various type of pagination that dataTables supports
269	* Scope: jQuery.fn.dataTableExt
270	*/
271	_oExt.oPagination = {
272	/*
273	* Variable: two_button
274	* Purpose: Standard two button (forward/back) pagination
275	* Scope: jQuery.fn.dataTableExt.oPagination
276	*/
277	"two_button": {
278	/*
279	* Function: oPagination.two_button.fnInit
280	* Purpose: Initalise dom elements required for pagination with forward/back buttons only
281	* Returns: -
282	* Inputs: object:oSettings - dataTables settings object
283	* node:nPaging - the DIV which contains this pagination control
284	* function:fnCallbackDraw - draw function which must be called on update
285	*/
286	"fnInit": function ( oSettings, nPaging, fnCallbackDraw )
287	{
288	var nPrevious, nNext, nPreviousInner, nNextInner;
289
290	/* Store the next and previous elements in the oSettings object as they can be very
291	* usful for automation - particularly testing
292	*/
293	if ( !oSettings.bJUI )
294	{
295	nPrevious = document.createElement( 'div' );
296	nNext = document.createElement( 'div' );
297	}
298	else
299	{
300	nPrevious = document.createElement( 'a' );
301	nNext = document.createElement( 'a' );
302
303	nNextInner = document.createElement('span');
304	nNextInner.className = oSettings.oClasses.sPageJUINext;
305	nNext.appendChild( nNextInner );
306
307	nPreviousInner = document.createElement('span');
308	nPreviousInner.className = oSettings.oClasses.sPageJUIPrev;
309	nPrevious.appendChild( nPreviousInner );
310	}
311
312	nPrevious.className = oSettings.oClasses.sPagePrevDisabled;
313	nNext.className = oSettings.oClasses.sPageNextDisabled;
314
315	nPrevious.title = oSettings.oLanguage.oPaginate.sPrevious;
316	nNext.title = oSettings.oLanguage.oPaginate.sNext;
317
318	nPaging.appendChild( nPrevious );
319	nPaging.appendChild( nNext );
320
321	$(nPrevious).bind( 'click.DT', function() {
322	if ( oSettings.oApi._fnPageChange( oSettings, "previous" ) )
323	{
324	/* Only draw when the page has actually changed */
325	fnCallbackDraw( oSettings );
326	}
327	} );
328
329	$(nNext).bind( 'click.DT', function() {
330	if ( oSettings.oApi._fnPageChange( oSettings, "next" ) )
331	{
332	fnCallbackDraw( oSettings );
333	}
334	} );
335
336	/* Take the brutal approach to cancelling text selection */
337	$(nPrevious).bind( 'selectstart.DT', function () { return false; } );
338	$(nNext).bind( 'selectstart.DT', function () { return false; } );
339
340	/* ID the first elements only */
341	if ( oSettings.sTableId !== '' && typeof oSettings.aanFeatures.p == "undefined" )
342	{
343	nPaging.setAttribute( 'id', oSettings.sTableId+'_paginate' );
344	nPrevious.setAttribute( 'id', oSettings.sTableId+'_previous' );
345	nNext.setAttribute( 'id', oSettings.sTableId+'_next' );
346	}
347	},
348
349	/*
350	* Function: oPagination.two_button.fnUpdate
351	* Purpose: Update the two button pagination at the end of the draw
352	* Returns: -
353	* Inputs: object:oSettings - dataTables settings object
354	* function:fnCallbackDraw - draw function to call on page change
355	*/
356	"fnUpdate": function ( oSettings, fnCallbackDraw )
357	{
358	if ( !oSettings.aanFeatures.p )
359	{
360	return;
361	}
362
363	/* Loop over each instance of the pager */
364	var an = oSettings.aanFeatures.p;
365	for ( var i=0, iLen=an.length ; i<iLen ; i++ )
366	{
367	if ( an[i].childNodes.length !== 0 )
368	{
369	an[i].childNodes[0].className =
370	( oSettings._iDisplayStart === 0 ) ?
371	oSettings.oClasses.sPagePrevDisabled : oSettings.oClasses.sPagePrevEnabled;
372
373	an[i].childNodes[1].className =
374	( oSettings.fnDisplayEnd() == oSettings.fnRecordsDisplay() ) ?
375	oSettings.oClasses.sPageNextDisabled : oSettings.oClasses.sPageNextEnabled;
376	}
377	}
378	}
379	},
380
381
382	/*
383	* Variable: iFullNumbersShowPages
384	* Purpose: Change the number of pages which can be seen
385	* Scope: jQuery.fn.dataTableExt.oPagination
386	*/
387	"iFullNumbersShowPages": 5,
388
389	/*
390	* Variable: full_numbers
391	* Purpose: Full numbers pagination
392	* Scope: jQuery.fn.dataTableExt.oPagination
393	*/
394	"full_numbers": {
395	/*
396	* Function: oPagination.full_numbers.fnInit
397	* Purpose: Initalise dom elements required for pagination with a list of the pages
398	* Returns: -
399	* Inputs: object:oSettings - dataTables settings object
400	* node:nPaging - the DIV which contains this pagination control
401	* function:fnCallbackDraw - draw function which must be called on update
402	*/
403	"fnInit": function ( oSettings, nPaging, fnCallbackDraw )
404	{
405	var nFirst = document.createElement( 'span' );
406	var nPrevious = document.createElement( 'span' );
407	var nList = document.createElement( 'span' );
408	var nNext = document.createElement( 'span' );
409	var nLast = document.createElement( 'span' );
410
411	nFirst.innerHTML = oSettings.oLanguage.oPaginate.sFirst;
412	nPrevious.innerHTML = oSettings.oLanguage.oPaginate.sPrevious;
413	nNext.innerHTML = oSettings.oLanguage.oPaginate.sNext;
414	nLast.innerHTML = oSettings.oLanguage.oPaginate.sLast;
415
416	var oClasses = oSettings.oClasses;
417	nFirst.className = oClasses.sPageButton+" "+oClasses.sPageFirst;
418	nPrevious.className = oClasses.sPageButton+" "+oClasses.sPagePrevious;
419	nNext.className= oClasses.sPageButton+" "+oClasses.sPageNext;
420	nLast.className = oClasses.sPageButton+" "+oClasses.sPageLast;
421
422	nPaging.appendChild( nFirst );
423	nPaging.appendChild( nPrevious );
424	nPaging.appendChild( nList );
425	nPaging.appendChild( nNext );
426	nPaging.appendChild( nLast );
427
428	$(nFirst).bind( 'click.DT', function () {
429	if ( oSettings.oApi._fnPageChange( oSettings, "first" ) )
430	{
431	fnCallbackDraw( oSettings );
432	}
433	} );
434
435	$(nPrevious).bind( 'click.DT', function() {
436	if ( oSettings.oApi._fnPageChange( oSettings, "previous" ) )
437	{
438	fnCallbackDraw( oSettings );
439	}
440	} );
441
442	$(nNext).bind( 'click.DT', function() {
443	if ( oSettings.oApi._fnPageChange( oSettings, "next" ) )
444	{
445	fnCallbackDraw( oSettings );
446	}
447	} );
448
449	$(nLast).bind( 'click.DT', function() {
450	if ( oSettings.oApi._fnPageChange( oSettings, "last" ) )
451	{
452	fnCallbackDraw( oSettings );
453	}
454	} );
455
456	/* Take the brutal approach to cancelling text selection */
457	$('span', nPaging)
458	.bind( 'mousedown.DT', function () { return false; } )
459	.bind( 'selectstart.DT', function () { return false; } );
460
461	/* ID the first elements only */
462	if ( oSettings.sTableId !== '' && typeof oSettings.aanFeatures.p == "undefined" )
463	{
464	nPaging.setAttribute( 'id', oSettings.sTableId+'_paginate' );
465	nFirst.setAttribute( 'id', oSettings.sTableId+'_first' );
466	nPrevious.setAttribute( 'id', oSettings.sTableId+'_previous' );
467	nNext.setAttribute( 'id', oSettings.sTableId+'_next' );
468	nLast.setAttribute( 'id', oSettings.sTableId+'_last' );
469	}
470	},
471
472	/*
473	* Function: oPagination.full_numbers.fnUpdate
474	* Purpose: Update the list of page buttons shows
475	* Returns: -
476	* Inputs: object:oSettings - dataTables settings object
477	* function:fnCallbackDraw - draw function to call on page change
478	*/
479	"fnUpdate": function ( oSettings, fnCallbackDraw )
480	{
481	if ( !oSettings.aanFeatures.p )
482	{
483	return;
484	}
485
486	var iPageCount = _oExt.oPagination.iFullNumbersShowPages;
487	var iPageCountHalf = Math.floor(iPageCount / 2);
488	var iPages = Math.ceil((oSettings.fnRecordsDisplay()) / oSettings._iDisplayLength);
489	var iCurrentPage = Math.ceil(oSettings._iDisplayStart / oSettings._iDisplayLength) + 1;
490	var sList = "";
491	var iStartButton, iEndButton, i, iLen;
492	var oClasses = oSettings.oClasses;
493
494	/* Pages calculation */
495	if (iPages < iPageCount)
496	{
497	iStartButton = 1;
498	iEndButton = iPages;
499	}
500	else
501	{
502	if (iCurrentPage <= iPageCountHalf)
503	{
504	iStartButton = 1;
505	iEndButton = iPageCount;
506	}
507	else
508	{
509	if (iCurrentPage >= (iPages - iPageCountHalf))
510	{
511	iStartButton = iPages - iPageCount + 1;
512	iEndButton = iPages;
513	}
514	else
515	{
516	iStartButton = iCurrentPage - Math.ceil(iPageCount / 2) + 1;
517	iEndButton = iStartButton + iPageCount - 1;
518	}
519	}
520	}
521
522	/* Build the dynamic list */
523	for ( i=iStartButton ; i<=iEndButton ; i++ )
524	{
525	if ( iCurrentPage != i )
526	{
527	sList += '<span class="'+oClasses.sPageButton+'">'+i+'</span>';
528	}
529	else
530	{
531	sList += '<span class="'+oClasses.sPageButtonActive+'">'+i+'</span>';
532	}
533	}
534
535	/* Loop over each instance of the pager */
536	var an = oSettings.aanFeatures.p;
537	var anButtons, anStatic, nPaginateList;
538	var fnClick = function() {
539	/* Use the information in the element to jump to the required page */
540	var iTarget = (this.innerHTML * 1) - 1;
541	oSettings._iDisplayStart = iTarget * oSettings._iDisplayLength;
542	fnCallbackDraw( oSettings );
543	return false;
544	};
545	var fnFalse = function () { return false; };
546
547	for ( i=0, iLen=an.length ; i<iLen ; i++ )
548	{
549	if ( an[i].childNodes.length === 0 )
550	{
551	continue;
552	}
553
554	/* Build up the dynamic list forst - html and listeners */
555	var qjPaginateList = $('span:eq(2)', an[i]);
556	qjPaginateList.html( sList );
557	$('span', qjPaginateList).bind( 'click.DT', fnClick ).bind( 'mousedown.DT', fnFalse )
558	.bind( 'selectstart.DT', fnFalse );
559
560	/* Update the 'premanent botton's classes */
561	anButtons = an[i].getElementsByTagName('span');
562	anStatic = [
563	anButtons[0], anButtons[1],
564	anButtons[anButtons.length-2], anButtons[anButtons.length-1]
565	];
566	$(anStatic).removeClass( oClasses.sPageButton+" "+oClasses.sPageButtonActive+" "+oClasses.sPageButtonStaticDisabled );
567	if ( iCurrentPage == 1 )
568	{
569	anStatic[0].className += " "+oClasses.sPageButtonStaticDisabled;
570	anStatic[1].className += " "+oClasses.sPageButtonStaticDisabled;
571	}
572	else
573	{
574	anStatic[0].className += " "+oClasses.sPageButton;
575	anStatic[1].className += " "+oClasses.sPageButton;
576	}
577
578	if ( iPages === 0 \|\| iCurrentPage == iPages \|\| oSettings._iDisplayLength == -1 )
579	{
580	anStatic[2].className += " "+oClasses.sPageButtonStaticDisabled;
581	anStatic[3].className += " "+oClasses.sPageButtonStaticDisabled;
582	}
583	else
584	{
585	anStatic[2].className += " "+oClasses.sPageButton;
586	anStatic[3].className += " "+oClasses.sPageButton;
587	}
588	}
589	}
590	}
591	};
592
593	/*
594	* Variable: oSort
595	* Purpose: Wrapper for the sorting functions that can be used in DataTables
596	* Scope: jQuery.fn.dataTableExt
597	* Notes: The functions provided in this object are basically standard javascript sort
598	* functions - they expect two inputs which they then compare and then return a priority
599	* result. For each sort method added, two functions need to be defined, an ascending sort and
600	* a descending sort.
601	*/
602	_oExt.oSort = {
603	/*
604	* text sorting
605	*/
606	"string-asc": function ( a, b )
607	{
608	var x = a.toLowerCase();
609	var y = b.toLowerCase();
610	return ((x < y) ? -1 : ((x > y) ? 1 : 0));
611	},
612
613	"string-desc": function ( a, b )
614	{
615	var x = a.toLowerCase();
616	var y = b.toLowerCase();
617	return ((x < y) ? 1 : ((x > y) ? -1 : 0));
618	},
619
620
621	/*
622	* html sorting (ignore html tags)
623	*/
624	"html-asc": function ( a, b )
625	{
626	var x = a.replace( /<.*?>/g, "" ).toLowerCase();
627	var y = b.replace( /<.*?>/g, "" ).toLowerCase();
628	return ((x < y) ? -1 : ((x > y) ? 1 : 0));
629	},
630
631	"html-desc": function ( a, b )
632	{
633	var x = a.replace( /<.*?>/g, "" ).toLowerCase();
634	var y = b.replace( /<.*?>/g, "" ).toLowerCase();
635	return ((x < y) ? 1 : ((x > y) ? -1 : 0));
636	},
637
638
639	/*
640	* date sorting
641	*/
642	"date-asc": function ( a, b )
643	{
644	var x = Date.parse( a );
645	var y = Date.parse( b );
646
647	if ( isNaN(x) \|\| x==="" )
648	{
649	x = Date.parse( "01/01/1970 00:00:00" );
650	}
651	if ( isNaN(y) \|\| y==="" )
652	{
653	y = Date.parse( "01/01/1970 00:00:00" );
654	}
655
656	return x - y;
657	},
658
659	"date-desc": function ( a, b )
660	{
661	var x = Date.parse( a );
662	var y = Date.parse( b );
663
664	if ( isNaN(x) \|\| x==="" )
665	{
666	x = Date.parse( "01/01/1970 00:00:00" );
667	}
668	if ( isNaN(y) \|\| y==="" )
669	{
670	y = Date.parse( "01/01/1970 00:00:00" );
671	}
672
673	return y - x;
674	},
675
676
677	/*
678	* numerical sorting
679	*/
680	"numeric-asc": function ( a, b )
681	{
682	var x = (a=="-" \|\| a==="") ? 0 : a*1;
683	var y = (b=="-" \|\| b==="") ? 0 : b*1;
684	return x - y;
685	},
686
687	"numeric-desc": function ( a, b )
688	{
689	var x = (a=="-" \|\| a==="") ? 0 : a*1;
690	var y = (b=="-" \|\| b==="") ? 0 : b*1;
691	return y - x;
692	}
693	};
694
695
696	/*
697	* Variable: aTypes
698	* Purpose: Container for the various type of type detection that dataTables supports
699	* Scope: jQuery.fn.dataTableExt
700	* Notes: The functions in this array are expected to parse a string to see if it is a data
701	* type that it recognises. If so then the function should return the name of the type (a
702	* corresponding sort function should be defined!), if the type is not recognised then the
703	* function should return null such that the parser and move on to check the next type.
704	* Note that ordering is important in this array - the functions are processed linearly,
705	* starting at index 0.
706	* Note that the input for these functions is always a string! It cannot be any other data
707	* type
708	*/
709	_oExt.aTypes = [
710	/*
711	* Function: -
712	* Purpose: Check to see if a string is numeric
713	* Returns: string:'numeric' or null
714	* Inputs: string:sText - string to check
715	*/
716	function ( sData )
717	{
718	/* Allow zero length strings as a number */
719	if ( sData.length === 0 )
720	{
721	return 'numeric';
722	}
723
724	var sValidFirstChars = "0123456789-";
725	var sValidChars = "0123456789.";
726	var Char;
727	var bDecimal = false;
728
729	/* Check for a valid first char (no period and allow negatives) */
730	Char = sData.charAt(0);
731	if (sValidFirstChars.indexOf(Char) == -1)
732	{
733	return null;
734	}
735
736	/* Check all the other characters are valid */
737	for ( var i=1 ; i<sData.length ; i++ )
738	{
739	Char = sData.charAt(i);
740	if (sValidChars.indexOf(Char) == -1)
741	{
742	return null;
743	}
744
745	/* Only allowed one decimal place... */
746	if ( Char == "." )
747	{
748	if ( bDecimal )
749	{
750	return null;
751	}
752	bDecimal = true;
753	}
754	}
755
756	return 'numeric';
757	},
758
759	/*
760	* Function: -
761	* Purpose: Check to see if a string is actually a formatted date
762	* Returns: string:'date' or null
763	* Inputs: string:sText - string to check
764	*/
765	function ( sData )
766	{
767	var iParse = Date.parse(sData);
768	if ( (iParse !== null && !isNaN(iParse)) \|\| sData.length === 0 )
769	{
770	return 'date';
771	}
772	return null;
773	},
774
775	/*
776	* Function: -
777	* Purpose: Check to see if a string should be treated as an HTML string
778	* Returns: string:'html' or null
779	* Inputs: string:sText - string to check
780	*/
781	function ( sData )
782	{
783	if ( sData.indexOf('<') != -1 && sData.indexOf('>') != -1 )
784	{
785	return 'html';
786	}
787	return null;
788	}
789	];
790
791	/*
792	* Function: fnVersionCheck
793	* Purpose: Check a version string against this version of DataTables. Useful for plug-ins
794	* Returns: bool:true -this version of DataTables is greater or equal to the required version
795	* false -this version of DataTales is not suitable
796	* Inputs: string:sVersion - the version to check against. May be in the following formats:
797	* "a", "a.b" or "a.b.c"
798	* Notes: This function will only check the first three parts of a version string. It is
799	* assumed that beta and dev versions will meet the requirements. This might change in future
800	*/
801	_oExt.fnVersionCheck = function( sVersion )
802	{
803	/* This is cheap, but very effective */
804	var fnZPad = function (Zpad, count)
805	{
806	while(Zpad.length < count) {
807	Zpad += '0';
808	}
809	return Zpad;
810	};
811	var aThis = _oExt.sVersion.split('.');
812	var aThat = sVersion.split('.');
813	var sThis = '', sThat = '';
814
815	for ( var i=0, iLen=aThat.length ; i<iLen ; i++ )
816	{
817	sThis += fnZPad( aThis[i], 3 );
818	sThat += fnZPad( aThat[i], 3 );
819	}
820
821	return parseInt(sThis, 10) >= parseInt(sThat, 10);
822	};
823
824	/*
825	* Variable: _oExternConfig
826	* Purpose: Store information for DataTables to access globally about other instances
827	* Scope: jQuery.fn.dataTableExt
828	*/
829	_oExt._oExternConfig = {
830	/* int:iNextUnique - next unique number for an instance */
831	"iNextUnique": 0
832	};
833
834
835	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
836	* Section - DataTables prototype
837	* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
838
839	/*
840	* Function: dataTable
841	* Purpose: DataTables information
842	* Returns: -
843	* Inputs: object:oInit - initalisation options for the table
844	*/
845	$.fn.dataTable = function( oInit )
846	{
847	/*
848	* Function: classSettings
849	* Purpose: Settings container function for all 'class' properties which are required
850	* by dataTables
851	* Returns: -
852	* Inputs: -
853	*/
854	function classSettings ()
855	{
856	this.fnRecordsTotal = function ()
857	{
858	if ( this.oFeatures.bServerSide ) {
859	return parseInt(this._iRecordsTotal, 10);
860	} else {
861	return this.aiDisplayMaster.length;
862	}
863	};
864
865	this.fnRecordsDisplay = function ()
866	{
867	if ( this.oFeatures.bServerSide ) {
868	return parseInt(this._iRecordsDisplay, 10);
869	} else {
870	return this.aiDisplay.length;
871	}
872	};
873
874	this.fnDisplayEnd = function ()
875	{
876	if ( this.oFeatures.bServerSide ) {
877	if ( this.oFeatures.bPaginate === false \|\| this._iDisplayLength == -1 ) {
878	return this._iDisplayStart+this.aiDisplay.length;
879	} else {
880	return Math.min( this._iDisplayStart+this._iDisplayLength,
881	this._iRecordsDisplay );
882	}
883	} else {
884	return this._iDisplayEnd;
885	}
886	};
887
888	/*
889	* Variable: oInstance
890	* Purpose: The DataTables object for this table
891	* Scope: jQuery.dataTable.classSettings
892	*/
893	this.oInstance = null;
894
895	/*
896	* Variable: sInstance
897	* Purpose: Unique idendifier for each instance of the DataTables object
898	* Scope: jQuery.dataTable.classSettings
899	*/
900	this.sInstance = null;
901
902	/*
903	* Variable: oFeatures
904	* Purpose: Indicate the enablement of key dataTable features
905	* Scope: jQuery.dataTable.classSettings
906	*/
907	this.oFeatures = {
908	"bPaginate": true,
909	"bLengthChange": true,
910	"bFilter": true,
911	"bSort": true,
912	"bInfo": true,
913	"bAutoWidth": true,
914	"bProcessing": false,
915	"bSortClasses": true,
916	"bStateSave": false,
917	"bServerSide": false
918	};
919
920	/*
921	* Variable: oScroll
922	* Purpose: Container for scrolling options
923	* Scope: jQuery.dataTable.classSettings
924	*/
925	this.oScroll = {
926	"sX": "",
927	"sXInner": "",
928	"sY": "",
929	"bCollapse": false,
930	"bInfinite": false,
931	"iLoadGap": 100,
932	"iBarWidth": 0,
933	"bAutoCss": true
934	};
935
936	/*
937	* Variable: aanFeatures
938	* Purpose: Array referencing the nodes which are used for the features
939	* Scope: jQuery.dataTable.classSettings
940	* Notes: The parameters of this object match what is allowed by sDom - i.e.
941	* 'l' - Length changing
942	* 'f' - Filtering input
943	* 't' - The table!
944	* 'i' - Information
945	* 'p' - Pagination
946	* 'r' - pRocessing
947	*/
948	this.aanFeatures = [];
949
950	/*
951	* Variable: oLanguage
952	* Purpose: Store the language strings used by dataTables
953	* Scope: jQuery.dataTable.classSettings
954	* Notes: The words in the format _VAR_ are variables which are dynamically replaced
955	* by javascript
956	*/
957	this.oLanguage = {
958	"sProcessing": "Processing...",
959	"sLengthMenu": "Show _MENU_ entries",
960	"sZeroRecords": "No matching records found",
961	"sEmptyTable": "No data available in table",
962	"sInfo": "Showing _START_ to _END_ of _TOTAL_ entries",
963	"sInfoEmpty": "Showing 0 to 0 of 0 entries",
964	"sInfoFiltered": "(filtered from _MAX_ total entries)",
965	"sInfoPostFix": "",
966	"sSearch": "Search:",
967	"sUrl": "",
968	"oPaginate": {
969	"sFirst": "First",
970	"sPrevious": "Previous",
971	"sNext": "Next",
972	"sLast": "Last"
973	},
974	"fnInfoCallback": null
975	};
976
977	/*
978	* Variable: aoData
979	* Purpose: Store data information
980	* Scope: jQuery.dataTable.classSettings
981	* Notes: This is an array of objects with the following parameters:
982	* int: _iId - internal id for tracking
983	* array: _aData - internal data - used for sorting / filtering etc
984	* node: nTr - display node
985	* array node: _anHidden - hidden TD nodes
986	* string: _sRowStripe
987	*/
988	this.aoData = [];
989
990	/*
991	* Variable: aiDisplay
992	* Purpose: Array of indexes which are in the current display (after filtering etc)
993	* Scope: jQuery.dataTable.classSettings
994	*/
995	this.aiDisplay = [];
996
997	/*
998	* Variable: aiDisplayMaster
999	* Purpose: Array of indexes for display - no filtering
1000	* Scope: jQuery.dataTable.classSettings
1001	*/
1002	this.aiDisplayMaster = [];
1003
1004	/*
1005	* Variable: aoColumns
1006	* Purpose: Store information about each column that is in use
1007	* Scope: jQuery.dataTable.classSettings
1008	*/
1009	this.aoColumns = [];
1010
1011	/*
1012	* Variable: iNextId
1013	* Purpose: Store the next unique id to be used for a new row
1014	* Scope: jQuery.dataTable.classSettings
1015	*/
1016	this.iNextId = 0;
1017
1018	/*
1019	* Variable: asDataSearch
1020	* Purpose: Search data array for regular expression searching
1021	* Scope: jQuery.dataTable.classSettings
1022	*/
1023	this.asDataSearch = [];
1024
1025	/*
1026	* Variable: oPreviousSearch
1027	* Purpose: Store the previous search incase we want to force a re-search
1028	* or compare the old search to a new one
1029	* Scope: jQuery.dataTable.classSettings
1030	*/
1031	this.oPreviousSearch = {
1032	"sSearch": "",
1033	"bRegex": false,
1034	"bSmart": true
1035	};
1036
1037	/*
1038	* Variable: aoPreSearchCols
1039	* Purpose: Store the previous search for each column
1040	* Scope: jQuery.dataTable.classSettings
1041	*/
1042	this.aoPreSearchCols = [];
1043
1044	/*
1045	* Variable: aaSorting
1046	* Purpose: Sorting information
1047	* Scope: jQuery.dataTable.classSettings
1048	* Notes: Index 0 - column number
1049	* Index 1 - current sorting direction
1050	* Index 2 - index of asSorting for this column
1051	*/
1052	this.aaSorting = [ [0, 'asc', 0] ];
1053
1054	/*
1055	* Variable: aaSortingFixed
1056	* Purpose: Sorting information that is always applied
1057	* Scope: jQuery.dataTable.classSettings
1058	*/
1059	this.aaSortingFixed = null;
1060
1061	/*
1062	* Variable: asStripClasses
1063	* Purpose: Classes to use for the striping of a table
1064	* Scope: jQuery.dataTable.classSettings
1065	*/
1066	this.asStripClasses = [];
1067
1068	/*
1069	* Variable: asDestoryStrips
1070	* Purpose: If restoring a table - we should restore it's striping classes as well
1071	* Scope: jQuery.dataTable.classSettings
1072	*/
1073	this.asDestoryStrips = [];
1074
1075	/*
1076	* Variable: sDestroyWidth
1077	* Purpose: If restoring a table - we should restore it's width
1078	* Scope: jQuery.dataTable.classSettings
1079	*/
1080	this.sDestroyWidth = 0;
1081
1082	/*
1083	* Variable: fnRowCallback
1084	* Purpose: Call this function every time a row is inserted (draw)
1085	* Scope: jQuery.dataTable.classSettings
1086	*/
1087	this.fnRowCallback = null;
1088
1089	/*
1090	* Variable: fnHeaderCallback
1091	* Purpose: Callback function for the header on each draw
1092	* Scope: jQuery.dataTable.classSettings
1093	*/
1094	this.fnHeaderCallback = null;
1095
1096	/*
1097	* Variable: fnFooterCallback
1098	* Purpose: Callback function for the footer on each draw
1099	* Scope: jQuery.dataTable.classSettings
1100	*/
1101	this.fnFooterCallback = null;
1102
1103	/*
1104	* Variable: aoDrawCallback
1105	* Purpose: Array of callback functions for draw callback functions
1106	* Scope: jQuery.dataTable.classSettings
1107	* Notes: Each array element is an object with the following parameters:
1108	* function:fn - function to call
1109	* string:sName - name callback (feature). useful for arranging array
1110	*/
1111	this.aoDrawCallback = [];
1112
1113	/*
1114	* Variable: fnInitComplete
1115	* Purpose: Callback function for when the table has been initalised
1116	* Scope: jQuery.dataTable.classSettings
1117	*/
1118	this.fnInitComplete = null;
1119
1120	/*
1121	* Variable: sTableId
1122	* Purpose: Cache the table ID for quick access
1123	* Scope: jQuery.dataTable.classSettings
1124	*/
1125	this.sTableId = "";
1126
1127	/*
1128	* Variable: nTable
1129	* Purpose: Cache the table node for quick access
1130	* Scope: jQuery.dataTable.classSettings
1131	*/
1132	this.nTable = null;
1133
1134	/*
1135	* Variable: nTHead
1136	* Purpose: Permanent ref to the thead element
1137	* Scope: jQuery.dataTable.classSettings
1138	*/
1139	this.nTHead = null;
1140
1141	/*
1142	* Variable: nTFoot
1143	* Purpose: Permanent ref to the tfoot element - if it exists
1144	* Scope: jQuery.dataTable.classSettings
1145	*/
1146	this.nTFoot = null;
1147
1148	/*
1149	* Variable: nTBody
1150	* Purpose: Permanent ref to the tbody element
1151	* Scope: jQuery.dataTable.classSettings
1152	*/
1153	this.nTBody = null;
1154
1155	/*
1156	* Variable: nTableWrapper
1157	* Purpose: Cache the wrapper node (contains all DataTables controlled elements)
1158	* Scope: jQuery.dataTable.classSettings
1159	*/
1160	this.nTableWrapper = null;
1161
1162	/*
1163	* Variable: bInitialised
1164	* Purpose: Indicate if all required information has been read in
1165	* Scope: jQuery.dataTable.classSettings
1166	*/
1167	this.bInitialised = false;
1168
1169	/*
1170	* Variable: aoOpenRows
1171	* Purpose: Information about open rows
1172	* Scope: jQuery.dataTable.classSettings
1173	* Notes: Has the parameters 'nTr' and 'nParent'
1174	*/
1175	this.aoOpenRows = [];
1176
1177	/*
1178	* Variable: sDom
1179	* Purpose: Dictate the positioning that the created elements will take
1180	* Scope: jQuery.dataTable.classSettings
1181	* Notes:
1182	* The following options are allowed:
1183	* 'l' - Length changing
1184	* 'f' - Filtering input
1185	* 't' - The table!
1186	* 'i' - Information
1187	* 'p' - Pagination
1188	* 'r' - pRocessing
1189	* The following constants are allowed:
1190	* 'H' - jQueryUI theme "header" classes
1191	* 'F' - jQueryUI theme "footer" classes
1192	* The following syntax is expected:
1193	* '<' and '>' - div elements
1194	* '<"class" and '>' - div with a class
1195	* Examples:
1196	* '<"wrapper"flipt>', '<lf<t>ip>'
1197	*/
1198	this.sDom = 'lfrtip';
1199
1200	/*
1201	* Variable: sPaginationType
1202	* Purpose: Note which type of sorting should be used
1203	* Scope: jQuery.dataTable.classSettings
1204	*/
1205	this.sPaginationType = "two_button";
1206
1207	/*
1208	* Variable: iCookieDuration
1209	* Purpose: The cookie duration (for bStateSave) in seconds - default 2 hours
1210	* Scope: jQuery.dataTable.classSettings
1211	*/
1212	this.iCookieDuration = 60 * 60 * 2;
1213
1214	/*
1215	* Variable: sCookiePrefix
1216	* Purpose: The cookie name prefix
1217	* Scope: jQuery.dataTable.classSettings
1218	*/
1219	this.sCookiePrefix = "SpryMedia_DataTables_";
1220
1221	/*
1222	* Variable: fnCookieCallback
1223	* Purpose: Callback function for cookie creation
1224	* Scope: jQuery.dataTable.classSettings
1225	*/
1226	this.fnCookieCallback = null;
1227
1228	/*
1229	* Variable: aoStateSave
1230	* Purpose: Array of callback functions for state saving
1231	* Scope: jQuery.dataTable.classSettings
1232	* Notes: Each array element is an object with the following parameters:
1233	* function:fn - function to call. Takes two parameters, oSettings and the JSON string to
1234	* save that has been thus far created. Returns a JSON string to be inserted into a
1235	* json object (i.e. '"param": [ 0, 1, 2]')
1236	* string:sName - name of callback
1237	*/
1238	this.aoStateSave = [];
1239
1240	/*
1241	* Variable: aoStateLoad
1242	* Purpose: Array of callback functions for state loading
1243	* Scope: jQuery.dataTable.classSettings
1244	* Notes: Each array element is an object with the following parameters:
1245	* function:fn - function to call. Takes two parameters, oSettings and the object stored.
1246	* May return false to cancel state loading.
1247	* string:sName - name of callback
1248	*/
1249	this.aoStateLoad = [];
1250
1251	/*
1252	* Variable: oLoadedState
1253	* Purpose: State that was loaded from the cookie. Useful for back reference
1254	* Scope: jQuery.dataTable.classSettings
1255	*/
1256	this.oLoadedState = null;
1257
1258	/*
1259	* Variable: sAjaxSource
1260	* Purpose: Source url for AJAX data for the table
1261	* Scope: jQuery.dataTable.classSettings
1262	*/
1263	this.sAjaxSource = null;
1264
1265	/*
1266	* Variable: bAjaxDataGet
1267	* Purpose: Note if draw should be blocked while getting data
1268	* Scope: jQuery.dataTable.classSettings
1269	*/
1270	this.bAjaxDataGet = true;
1271
1272	/*
1273	* Variable: fnServerData
1274	* Purpose: Function to get the server-side data - can be overruled by the developer
1275	* Scope: jQuery.dataTable.classSettings
1276	*/
1277	this.fnServerData = function ( url, data, callback ) {
1278	$.ajax( {
1279	"url": url,
1280	"data": data,
1281	"success": callback,
1282	"dataType": "json",
1283	"cache": false,
1284	"error": function (xhr, error, thrown) {
1285	if ( error == "parsererror" ) {
1286	alert( "DataTables warning: JSON data from server could not be parsed. "+
1287	"This is caused by a JSON formatting error." );
1288	}
1289	}
1290	} );
1291	};
1292
1293	/*
1294	* Variable: fnFormatNumber
1295	* Purpose: Format numbers for display
1296	* Scope: jQuery.dataTable.classSettings
1297	*/
1298	this.fnFormatNumber = function ( iIn )
1299	{
1300	if ( iIn < 1000 )
1301	{
1302	/* A small optimisation for what is likely to be the vast majority of use cases */
1303	return iIn;
1304	}
1305	else
1306	{
1307	var s=(iIn+""), a=s.split(""), out="", iLen=s.length;
1308
1309	for ( var i=0 ; i<iLen ; i++ )
1310	{
1311	if ( i%3 === 0 && i !== 0 )
1312	{
1313	out = ','+out;
1314	}
1315	out = a[iLen-i-1]+out;
1316	}
1317	}
1318	return out;
1319	};
1320
1321	/*
1322	* Variable: aLengthMenu
1323	* Purpose: List of options that can be used for the user selectable length menu
1324	* Scope: jQuery.dataTable.classSettings
1325	* Note: This varaible can take for form of a 1D array, in which case the value and the
1326	* displayed value in the menu are the same, or a 2D array in which case the value comes
1327	* from the first array, and the displayed value to the end user comes from the second
1328	* array. 2D example: [ [ 10, 25, 50, 100, -1 ], [ 10, 25, 50, 100, 'All' ] ];
1329	*/
1330	this.aLengthMenu = [ 10, 25, 50, 100 ];
1331
1332	/*
1333	* Variable: iDraw
1334	* Purpose: Counter for the draws that the table does. Also used as a tracker for
1335	* server-side processing
1336	* Scope: jQuery.dataTable.classSettings
1337	*/
1338	this.iDraw = 0;
1339
1340	/*
1341	* Variable: bDrawing
1342	* Purpose: Indicate if a redraw is being done - useful for Ajax
1343	* Scope: jQuery.dataTable.classSettings
1344	*/
1345	this.bDrawing = 0;
1346
1347	/*
1348	* Variable: iDrawError
1349	* Purpose: Last draw error
1350	* Scope: jQuery.dataTable.classSettings
1351	*/
1352	this.iDrawError = -1;
1353
1354	/*
1355	* Variable: _iDisplayLength, _iDisplayStart, _iDisplayEnd
1356	* Purpose: Display length variables
1357	* Scope: jQuery.dataTable.classSettings
1358	* Notes: These variable must NOT be used externally to get the data length. Rather, use
1359	* the fnRecordsTotal() (etc) functions.
1360	*/
1361	this._iDisplayLength = 10;
1362	this._iDisplayStart = 0;
1363	this._iDisplayEnd = 10;
1364
1365	/*
1366	* Variable: _iRecordsTotal, _iRecordsDisplay
1367	* Purpose: Display length variables used for server side processing
1368	* Scope: jQuery.dataTable.classSettings
1369	* Notes: These variable must NOT be used externally to get the data length. Rather, use
1370	* the fnRecordsTotal() (etc) functions.
1371	*/
1372	this._iRecordsTotal = 0;
1373	this._iRecordsDisplay = 0;
1374
1375	/*
1376	* Variable: bJUI
1377	* Purpose: Should we add the markup needed for jQuery UI theming?
1378	* Scope: jQuery.dataTable.classSettings
1379	*/
1380	this.bJUI = false;
1381
1382	/*
1383	* Variable: bJUI
1384	* Purpose: Should we add the markup needed for jQuery UI theming?
1385	* Scope: jQuery.dataTable.classSettings
1386	*/
1387	this.oClasses = _oExt.oStdClasses;
1388
1389	/*
1390	* Variable: bFiltered and bSorted
1391	* Purpose: Flags to allow callback functions to see what actions have been performed
1392	* Scope: jQuery.dataTable.classSettings
1393	*/
1394	this.bFiltered = false;
1395	this.bSorted = false;
1396
1397	/*
1398	* Variable: oInit
1399	* Purpose: Initialisation object that is used for the table
1400	* Scope: jQuery.dataTable.classSettings
1401	*/
1402	this.oInit = null;
1403	}
1404
1405	/*
1406	* Variable: oApi
1407	* Purpose: Container for publicly exposed 'private' functions
1408	* Scope: jQuery.dataTable
1409	*/
1410	this.oApi = {};
1411
1412
1413	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
1414	* Section - API functions
1415	* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1416
1417	/*
1418	* Function: fnDraw
1419	* Purpose: Redraw the table
1420	* Returns: -
1421	* Inputs: bool:bComplete - Refilter and resort (if enabled) the table before the draw.
1422	* Optional: default - true
1423	*/
1424	this.fnDraw = function( bComplete )
1425	{
1426	var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
1427	if ( typeof bComplete != 'undefined' && bComplete === false )
1428	{
1429	_fnCalculateEnd( oSettings );
1430	_fnDraw( oSettings );
1431	}
1432	else
1433	{
1434	_fnReDraw( oSettings );
1435	}
1436	};
1437
1438	/*
1439	* Function: fnFilter
1440	* Purpose: Filter the input based on data
1441	* Returns: -
1442	* Inputs: string:sInput - string to filter the table on
1443	* int:iColumn - optional - column to limit filtering to
1444	* bool:bRegex - optional - treat as regular expression or not - default false
1445	* bool:bSmart - optional - perform smart filtering or not - default true
1446	* bool:bShowGlobal - optional - show the input global filter in it's input box(es)
1447	* - default true
1448	*/
1449	this.fnFilter = function( sInput, iColumn, bRegex, bSmart, bShowGlobal )
1450	{
1451	var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
1452
1453	if ( !oSettings.oFeatures.bFilter )
1454	{
1455	return;
1456	}
1457
1458	if ( typeof bRegex == 'undefined' )
1459	{
1460	bRegex = false;
1461	}
1462
1463	if ( typeof bSmart == 'undefined' )
1464	{
1465	bSmart = true;
1466	}
1467
1468	if ( typeof bShowGlobal == 'undefined' )
1469	{
1470	bShowGlobal = true;
1471	}
1472
1473	if ( typeof iColumn == "undefined" \|\| iColumn === null )
1474	{
1475	/* Global filter */
1476	_fnFilterComplete( oSettings, {
1477	"sSearch":sInput,
1478	"bRegex": bRegex,
1479	"bSmart": bSmart
1480	}, 1 );
1481
1482	if ( bShowGlobal && typeof oSettings.aanFeatures.f != 'undefined' )
1483	{
1484	var n = oSettings.aanFeatures.f;
1485	for ( var i=0, iLen=n.length ; i<iLen ; i++ )
1486	{
1487	$('input', n[i]).val( sInput );
1488	}
1489	}
1490	}
1491	else
1492	{
1493	/* Single column filter */
1494	oSettings.aoPreSearchCols[ iColumn ].sSearch = sInput;
1495	oSettings.aoPreSearchCols[ iColumn ].bRegex = bRegex;
1496	oSettings.aoPreSearchCols[ iColumn ].bSmart = bSmart;
1497	_fnFilterComplete( oSettings, oSettings.oPreviousSearch, 1 );
1498	}
1499	};
1500
1501	/*
1502	* Function: fnSettings
1503	* Purpose: Get the settings for a particular table for extern. manipulation
1504	* Returns: -
1505	* Inputs: -
1506	*/
1507	this.fnSettings = function( nNode )
1508	{
1509	return _fnSettingsFromNode( this[_oExt.iApiIndex] );
1510	};
1511
1512	/*
1513	* Function: fnVersionCheck
1514	* Notes: The function is the same as the 'static' function provided in the ext variable
1515	*/
1516	this.fnVersionCheck = _oExt.fnVersionCheck;
1517
1518	/*
1519	* Function: fnSort
1520	* Purpose: Sort the table by a particular row
1521	* Returns: -
1522	* Inputs: int:iCol - the data index to sort on. Note that this will
1523	* not match the 'display index' if you have hidden data entries
1524	*/
1525	this.fnSort = function( aaSort )
1526	{
1527	var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
1528	oSettings.aaSorting = aaSort;
1529	_fnSort( oSettings );
1530	};
1531
1532	/*
1533	* Function: fnSortListener
1534	* Purpose: Attach a sort listener to an element for a given column
1535	* Returns: -
1536	* Inputs: node:nNode - the element to attach the sort listener to
1537	* int:iColumn - the column that a click on this node will sort on
1538	* function:fnCallback - callback function when sort is run - optional
1539	*/
1540	this.fnSortListener = function( nNode, iColumn, fnCallback )
1541	{
1542	_fnSortAttachListener( _fnSettingsFromNode( this[_oExt.iApiIndex] ), nNode, iColumn,
1543	fnCallback );
1544	};
1545
1546	/*
1547	* Function: fnAddData
1548	* Purpose: Add new row(s) into the table
1549	* Returns: array int: array of indexes (aoData) which have been added (zero length on error)
1550	* Inputs: array:mData - the data to be added. The length must match
1551	* the original data from the DOM
1552	* or
1553	* array array:mData - 2D array of data to be added
1554	* bool:bRedraw - redraw the table or not - default true
1555	* Notes: Warning - the refilter here will cause the table to redraw
1556	* starting at zero
1557	* Notes: Thanks to Yekimov Denis for contributing the basis for this function!
1558	*/
1559	this.fnAddData = function( mData, bRedraw )
1560	{
1561	if ( mData.length === 0 )
1562	{
1563	return [];
1564	}
1565
1566	var aiReturn = [];
1567	var iTest;
1568
1569	/* Find settings from table node */
1570	var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
1571
1572	/* Check if we want to add multiple rows or not */
1573	if ( typeof mData[0] == "object" )
1574	{
1575	for ( var i=0 ; i<mData.length ; i++ )
1576	{
1577	iTest = _fnAddData( oSettings, mData[i] );
1578	if ( iTest == -1 )
1579	{
1580	return aiReturn;
1581	}
1582	aiReturn.push( iTest );
1583	}
1584	}
1585	else
1586	{
1587	iTest = _fnAddData( oSettings, mData );
1588	if ( iTest == -1 )
1589	{
1590	return aiReturn;
1591	}
1592	aiReturn.push( iTest );
1593	}
1594
1595	oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
1596
1597	if ( typeof bRedraw == 'undefined' \|\| bRedraw )
1598	{
1599	_fnReDraw( oSettings );
1600	}
1601	return aiReturn;
1602	};
1603
1604	/*
1605	* Function: fnDeleteRow
1606	* Purpose: Remove a row for the table
1607	* Returns: array:aReturn - the row that was deleted
1608	* Inputs: mixed:mTarget -
1609	* int: - index of aoData to be deleted, or
1610	* node(TR): - TR element you want to delete
1611	* function:fnCallBack - callback function - default null
1612	* bool:bRedraw - redraw the table or not - default true
1613	*/
1614	this.fnDeleteRow = function( mTarget, fnCallBack, bRedraw )
1615	{
1616	/* Find settings from table node */
1617	var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
1618	var i, iAODataIndex;
1619
1620	iAODataIndex = (typeof mTarget == 'object') ?
1621	_fnNodeToDataIndex(oSettings, mTarget) : mTarget;
1622
1623	/* Return the data array from this row */
1624	var oData = oSettings.aoData.splice( iAODataIndex, 1 );
1625
1626	/* Remove the target row from the search array */
1627	var iDisplayIndex = $.inArray( iAODataIndex, oSettings.aiDisplay );
1628	oSettings.asDataSearch.splice( iDisplayIndex, 1 );
1629
1630	/* Delete from the display arrays */
1631	_fnDeleteIndex( oSettings.aiDisplayMaster, iAODataIndex );
1632	_fnDeleteIndex( oSettings.aiDisplay, iAODataIndex );
1633
1634	/* If there is a user callback function - call it */
1635	if ( typeof fnCallBack == "function" )
1636	{
1637	fnCallBack.call( this, oSettings, oData );
1638	}
1639
1640	/* Check for an 'overflow' they case for dislaying the table */
1641	if ( oSettings._iDisplayStart >= oSettings.aiDisplay.length )
1642	{
1643	oSettings._iDisplayStart -= oSettings._iDisplayLength;
1644	if ( oSettings._iDisplayStart < 0 )
1645	{
1646	oSettings._iDisplayStart = 0;
1647	}
1648	}
1649
1650	if ( typeof bRedraw == 'undefined' \|\| bRedraw )
1651	{
1652	_fnCalculateEnd( oSettings );
1653	_fnDraw( oSettings );
1654	}
1655
1656	return oData;
1657	};
1658
1659	/*
1660	* Function: fnClearTable
1661	* Purpose: Quickly and simply clear a table
1662	* Returns: -
1663	* Inputs: bool:bRedraw - redraw the table or not - default true
1664	* Notes: Thanks to Yekimov Denis for contributing the basis for this function!
1665	*/
1666	this.fnClearTable = function( bRedraw )
1667	{
1668	/* Find settings from table node */
1669	var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
1670	_fnClearTable( oSettings );
1671
1672	if ( typeof bRedraw == 'undefined' \|\| bRedraw )
1673	{
1674	_fnDraw( oSettings );
1675	}
1676	};
1677
1678	/*
1679	* Function: fnOpen
1680	* Purpose: Open a display row (append a row after the row in question)
1681	* Returns: node:nNewRow - the row opened
1682	* Inputs: node:nTr - the table row to 'open'
1683	* string:sHtml - the HTML to put into the row
1684	* string:sClass - class to give the new TD cell
1685	*/
1686	this.fnOpen = function( nTr, sHtml, sClass )
1687	{
1688	/* Find settings from table node */
1689	var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
1690
1691	/* the old open one if there is one */
1692	this.fnClose( nTr );
1693
1694	var nNewRow = document.createElement("tr");
1695	var nNewCell = document.createElement("td");
1696	nNewRow.appendChild( nNewCell );
1697	nNewCell.className = sClass;
1698	nNewCell.colSpan = _fnVisbleColumns( oSettings );
1699	nNewCell.innerHTML = sHtml;
1700
1701	/* If the nTr isn't on the page at the moment - then we don't insert at the moment */
1702	var nTrs = $('tr', oSettings.nTBody);
1703	if ( $.inArray(nTr, nTrs) != -1 )
1704	{
1705	$(nNewRow).insertAfter(nTr);
1706	}
1707
1708	oSettings.aoOpenRows.push( {
1709	"nTr": nNewRow,
1710	"nParent": nTr
1711	} );
1712
1713	return nNewRow;
1714	};
1715
1716	/*
1717	* Function: fnClose
1718	* Purpose: Close a display row
1719	* Returns: int: 0 (success) or 1 (failed)
1720	* Inputs: node:nTr - the table row to 'close'
1721	*/
1722	this.fnClose = function( nTr )
1723	{
1724	/* Find settings from table node */
1725	var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
1726
1727	for ( var i=0 ; i<oSettings.aoOpenRows.length ; i++ )
1728	{
1729	if ( oSettings.aoOpenRows[i].nParent == nTr )
1730	{
1731	var nTrParent = oSettings.aoOpenRows[i].nTr.parentNode;
1732	if ( nTrParent )
1733	{
1734	/* Remove it if it is currently on display */
1735	nTrParent.removeChild( oSettings.aoOpenRows[i].nTr );
1736	}
1737	oSettings.aoOpenRows.splice( i, 1 );
1738	return 0;
1739	}
1740	}
1741	return 1;
1742	};
1743
1744	/*
1745	* Function: fnGetData
1746	* Purpose: Return an array with the data which is used to make up the table
1747	* Returns: array array string: 2d data array ([row][column]) or array string: 1d data array
1748	* or
1749	* array string (if iRow specified)
1750	* Inputs: mixed:mRow - optional - if not present, then the full 2D array for the table
1751	* if given then:
1752	* int: - return 1D array for aoData entry of this index
1753	* node(TR): - return 1D array for this TR element
1754	* Inputs: int:iRow - optional - if present then the array returned will be the data for
1755	* the row with the index 'iRow'
1756	*/
1757	this.fnGetData = function( mRow )
1758	{
1759	var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
1760
1761	if ( typeof mRow != 'undefined' )
1762	{
1763	var iRow = (typeof mRow == 'object') ?
1764	_fnNodeToDataIndex(oSettings, mRow) : mRow;
1765	return ( (aRowData = oSettings.aoData[iRow]) ? aRowData._aData : null);
1766	}
1767	return _fnGetDataMaster( oSettings );
1768	};
1769
1770	/*
1771	* Function: fnGetNodes
1772	* Purpose: Return an array with the TR nodes used for drawing the table
1773	* Returns: array node: TR elements
1774	* or
1775	* node (if iRow specified)
1776	* Inputs: int:iRow - optional - if present then the array returned will be the node for
1777	* the row with the index 'iRow'
1778	*/
1779	this.fnGetNodes = function( iRow )
1780	{
1781	var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
1782
1783	if ( typeof iRow != 'undefined' )
1784	{
1785	return ( (aRowData = oSettings.aoData[iRow]) ? aRowData.nTr : null );
1786	}
1787	return _fnGetTrNodes( oSettings );
1788	};
1789
1790	/*
1791	* Function: fnGetPosition
1792	* Purpose: Get the array indexes of a particular cell from it's DOM element
1793	* Returns: int: - row index, or array[ int, int, int ]: - row index, column index (visible)
1794	* and column index including hidden columns
1795	* Inputs: node:nNode - this can either be a TR or a TD in the table, the return is
1796	* dependent on this input
1797	*/
1798	this.fnGetPosition = function( nNode )
1799	{
1800	var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
1801	var i;
1802
1803	if ( nNode.nodeName.toUpperCase() == "TR" )
1804	{
1805	return _fnNodeToDataIndex(oSettings, nNode);
1806	}
1807	else if ( nNode.nodeName.toUpperCase() == "TD" )
1808	{
1809	var iDataIndex = _fnNodeToDataIndex(oSettings, nNode.parentNode);
1810	var iCorrector = 0;
1811	for ( var j=0 ; j<oSettings.aoColumns.length ; j++ )
1812	{
1813	if ( oSettings.aoColumns[j].bVisible )
1814	{
1815	if ( oSettings.aoData[iDataIndex].nTr.getElementsByTagName('td')[j-iCorrector] == nNode )
1816	{
1817	return [ iDataIndex, j-iCorrector, j ];
1818	}
1819	}
1820	else
1821	{
1822	iCorrector++;
1823	}
1824	}
1825	}
1826	return null;
1827	};
1828
1829	/*
1830	* Function: fnUpdate
1831	* Purpose: Update a table cell or row
1832	* Returns: int: 0 okay, 1 error
1833	* Inputs: array string 'or' string:mData - data to update the cell/row with
1834	* mixed:mRow -
1835	* int: - index of aoData to be updated, or
1836	* node(TR): - TR element you want to update
1837	* int:iColumn - the column to update - optional (not used of mData is 2D)
1838	* bool:bRedraw - redraw the table or not - default true
1839	* bool:bAction - perform predraw actions or not (you will want this as 'true' if
1840	* you have bRedraw as true) - default true
1841	*/
1842	this.fnUpdate = function( mData, mRow, iColumn, bRedraw, bAction )
1843	{
1844	var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
1845	var iVisibleColumn;
1846	var sDisplay;
1847	var iRow = (typeof mRow == 'object') ?
1848	_fnNodeToDataIndex(oSettings, mRow) : mRow;
1849
1850	if ( typeof mData != 'object' )
1851	{
1852	sDisplay = mData;
1853	oSettings.aoData[iRow]._aData[iColumn] = sDisplay;
1854
1855	if ( oSettings.aoColumns[iColumn].fnRender !== null )
1856	{
1857	sDisplay = oSettings.aoColumns[iColumn].fnRender( {
1858	"iDataRow": iRow,
1859	"iDataColumn": iColumn,
1860	"aData": oSettings.aoData[iRow]._aData,
1861	"oSettings": oSettings
1862	} );
1863
1864	if ( oSettings.aoColumns[iColumn].bUseRendered )
1865	{
1866	oSettings.aoData[iRow]._aData[iColumn] = sDisplay;
1867	}
1868	}
1869
1870	iVisibleColumn = _fnColumnIndexToVisible( oSettings, iColumn );
1871	if ( iVisibleColumn !== null )
1872	{
1873	oSettings.aoData[iRow].nTr.getElementsByTagName('td')[iVisibleColumn].innerHTML =
1874	sDisplay;
1875	}
1876	else
1877	{
1878	oSettings.aoData[iRow]._anHidden[iColumn].innerHTML = sDisplay;
1879	}
1880	}
1881	else
1882	{
1883	if ( mData.length != oSettings.aoColumns.length )
1884	{
1885	_fnLog( oSettings, 0, 'An array passed to fnUpdate must have the same number of '+
1886	'columns as the table in question - in this case '+oSettings.aoColumns.length );
1887	return 1;
1888	}
1889
1890	for ( var i=0 ; i<mData.length ; i++ )
1891	{
1892	sDisplay = mData[i];
1893	oSettings.aoData[iRow]._aData[i] = sDisplay;
1894
1895	if ( oSettings.aoColumns[i].fnRender !== null )
1896	{
1897	sDisplay = oSettings.aoColumns[i].fnRender( {
1898	"iDataRow": iRow,
1899	"iDataColumn": i,
1900	"aData": oSettings.aoData[iRow]._aData,
1901	"oSettings": oSettings
1902	} );
1903
1904	if ( oSettings.aoColumns[i].bUseRendered )
1905	{
1906	oSettings.aoData[iRow]._aData[i] = sDisplay;
1907	}
1908	}
1909
1910	iVisibleColumn = _fnColumnIndexToVisible( oSettings, i );
1911	if ( iVisibleColumn !== null )
1912	{
1913	oSettings.aoData[iRow].nTr.getElementsByTagName('td')[iVisibleColumn].innerHTML =
1914	sDisplay;
1915	}
1916	else
1917	{
1918	oSettings.aoData[iRow]._anHidden[i].innerHTML = sDisplay;
1919	}
1920	}
1921	}
1922
1923	/* Modify the search index for this row (strictly this is likely not needed, since fnReDraw
1924	* will rebuild the search array - however, the redraw might be disabled by the user)
1925	*/
1926	var iDisplayIndex = $.inArray( iRow, oSettings.aiDisplay );
1927	oSettings.asDataSearch[iDisplayIndex] = _fnBuildSearchRow( oSettings,
1928	oSettings.aoData[iRow]._aData );
1929
1930	/* Perform pre-draw actions */
1931	if ( typeof bAction == 'undefined' \|\| bAction )
1932	{
1933	_fnAjustColumnSizing( oSettings );
1934	}
1935
1936	/* Redraw the table */
1937	if ( typeof bRedraw == 'undefined' \|\| bRedraw )
1938	{
1939	_fnReDraw( oSettings );
1940	}
1941	return 0;
1942	};
1943
1944
1945	/*
1946	* Function: fnShowColoumn
1947	* Purpose: Show a particular column
1948	* Returns: -
1949	* Inputs: int:iCol - the column whose display should be changed
1950	* bool:bShow - show (true) or hide (false) the column
1951	* bool:bRedraw - redraw the table or not - default true
1952	*/
1953	this.fnSetColumnVis = function ( iCol, bShow, bRedraw )
1954	{
1955	var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
1956	var i, iLen;
1957	var iColumns = oSettings.aoColumns.length;
1958	var nTd, anTds, nCell, anTrs, jqChildren;
1959
1960	/* No point in doing anything if we are requesting what is already true */
1961	if ( oSettings.aoColumns[iCol].bVisible == bShow )
1962	{
1963	return;
1964	}
1965
1966	var nTrHead = $('>tr', oSettings.nTHead)[0];
1967	var nTrFoot = $('>tr', oSettings.nTFoot)[0];
1968	var anTheadTh = [];
1969	var anTfootTh = [];
1970	for ( i=0 ; i<iColumns ; i++ )
1971	{
1972	anTheadTh.push( oSettings.aoColumns[i].nTh );
1973	anTfootTh.push( oSettings.aoColumns[i].nTf );
1974	}
1975
1976	/* Show the column */
1977	if ( bShow )
1978	{
1979	var iInsert = 0;
1980	for ( i=0 ; i<iCol ; i++ )
1981	{
1982	if ( oSettings.aoColumns[i].bVisible )
1983	{
1984	iInsert++;
1985	}
1986	}
1987
1988	/* Need to decide if we should use appendChild or insertBefore */
1989	if ( iInsert >= _fnVisbleColumns( oSettings ) )
1990	{
1991	nTrHead.appendChild( anTheadTh[iCol] );
1992	anTrs = $('>tr', oSettings.nTHead);
1993	for ( i=1, iLen=anTrs.length ; i<iLen ; i++ )
1994	{
1995	anTrs[i].appendChild( oSettings.aoColumns[iCol].anThExtra[i-1] );
1996	}
1997
1998	if ( nTrFoot )
1999	{
2000	nTrFoot.appendChild( anTfootTh[iCol] );
2001	anTrs = $('>tr', oSettings.nTFoot);
2002	for ( i=1, iLen=anTrs.length ; i<iLen ; i++ )
2003	{
2004	anTrs[i].appendChild( oSettings.aoColumns[iCol].anTfExtra[i-1] );
2005	}
2006	}
2007
2008	for ( i=0, iLen=oSettings.aoData.length ; i<iLen ; i++ )
2009	{
2010	nTd = oSettings.aoData[i]._anHidden[iCol];
2011	oSettings.aoData[i].nTr.appendChild( nTd );
2012	}
2013	}
2014	else
2015	{
2016	/* Which coloumn should we be inserting before? */
2017	var iBefore;
2018	for ( i=iCol ; i<iColumns ; i++ )
2019	{
2020	iBefore = _fnColumnIndexToVisible( oSettings, i );
2021	if ( iBefore !== null )
2022	{
2023	break;
2024	}
2025	}
2026
2027	nTrHead.insertBefore( anTheadTh[iCol], nTrHead.getElementsByTagName('th')[iBefore] );
2028	anTrs = $('>tr', oSettings.nTHead);
2029	for ( i=1, iLen=anTrs.length ; i<iLen ; i++ )
2030	{
2031	jqChildren = $(anTrs[i]).children();
2032	anTrs[i].insertBefore( oSettings.aoColumns[iCol].anThExtra[i-1], jqChildren[iBefore] );
2033	}
2034
2035	if ( nTrFoot )
2036	{
2037	nTrFoot.insertBefore( anTfootTh[iCol], nTrFoot.getElementsByTagName('th')[iBefore] );
2038	anTrs = $('>tr', oSettings.nTFoot);
2039	for ( i=1, iLen=anTrs.length ; i<iLen ; i++ )
2040	{
2041	jqChildren = $(anTrs[i]).children();
2042	anTrs[i].insertBefore( oSettings.aoColumns[iCol].anTfExtra[i-1], jqChildren[iBefore] );
2043	}
2044	}
2045
2046	anTds = _fnGetTdNodes( oSettings );
2047	for ( i=0, iLen=oSettings.aoData.length ; i<iLen ; i++ )
2048	{
2049	nTd = oSettings.aoData[i]._anHidden[iCol];
2050	oSettings.aoData[i].nTr.insertBefore( nTd, $('>td:eq('+iBefore+')',
2051	oSettings.aoData[i].nTr)[0] );
2052	}
2053	}
2054
2055	oSettings.aoColumns[iCol].bVisible = true;
2056	}
2057	else
2058	{
2059	/* Remove a column from display */
2060	nTrHead.removeChild( anTheadTh[iCol] );
2061	for ( i=0, iLen=oSettings.aoColumns[iCol].anThExtra.length ; i<iLen ; i++ )
2062	{
2063	nCell = oSettings.aoColumns[iCol].anThExtra[i];
2064	nCell.parentNode.removeChild( nCell );
2065	}
2066
2067	if ( nTrFoot )
2068	{
2069	nTrFoot.removeChild( anTfootTh[iCol] );
2070	for ( i=0, iLen=oSettings.aoColumns[iCol].anTfExtra.length ; i<iLen ; i++ )
2071	{
2072	nCell = oSettings.aoColumns[iCol].anTfExtra[i];
2073	nCell.parentNode.removeChild( nCell );
2074	}
2075	}
2076
2077	anTds = _fnGetTdNodes( oSettings );
2078	for ( i=0, iLen=oSettings.aoData.length ; i<iLen ; i++ )
2079	{
2080	nTd = anTds[ ( ioSettings.aoColumns.length) + (iCol1) ];
2081	oSettings.aoData[i]._anHidden[iCol] = nTd;
2082	nTd.parentNode.removeChild( nTd );
2083	}
2084
2085	oSettings.aoColumns[iCol].bVisible = false;
2086	}
2087
2088	/* If there are any 'open' rows, then we need to alter the colspan for this col change */
2089	for ( i=0, iLen=oSettings.aoOpenRows.length ; i<iLen ; i++ )
2090	{
2091	oSettings.aoOpenRows[i].nTr.colSpan = _fnVisbleColumns( oSettings );
2092	}
2093
2094	/* Do a redraw incase anything depending on the table columns needs it
2095	* (built-in: scrolling)
2096	*/
2097	if ( typeof bRedraw == 'undefined' \|\| bRedraw )
2098	{
2099	_fnAjustColumnSizing( oSettings );
2100	_fnDraw( oSettings );
2101	}
2102
2103	_fnSaveState( oSettings );
2104	};
2105
2106	/*
2107	* Function: fnPageChange
2108	* Purpose: Change the pagination
2109	* Returns: -
2110	* Inputs: string:sAction - paging action to take: "first", "previous", "next" or "last"
2111	* bool:bRedraw - redraw the table or not - optional - default true
2112	*/
2113	this.fnPageChange = function ( sAction, bRedraw )
2114	{
2115	var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
2116	_fnPageChange( oSettings, sAction );
2117	_fnCalculateEnd( oSettings );
2118
2119	if ( typeof bRedraw == 'undefined' \|\| bRedraw )
2120	{
2121	_fnDraw( oSettings );
2122	}
2123	};
2124
2125	/*
2126	* Function: fnDestroy
2127	* Purpose: Destructor for the DataTable
2128	* Returns: -
2129	* Inputs: -
2130	*/
2131	this.fnDestroy = function ( )
2132	{
2133	var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
2134	var nOrig = oSettings.nTableWrapper.parentNode;
2135	var nBody = oSettings.nTBody;
2136	var i, iLen;
2137
2138	/* Flag to note that the table is currently being destoryed - no action should be taken */
2139	oSettings.bDestroying = true;
2140
2141	/* Blitz all DT events */
2142	$(oSettings.nTableWrapper).find('*').andSelf().unbind('.DT');
2143
2144	/* Restore hidden columns */
2145	for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
2146	{
2147	if ( oSettings.aoColumns[i].bVisible === false )
2148	{
2149	this.fnSetColumnVis( i, true );
2150	}
2151	}
2152
2153	/* If there is an 'empty' indicator row, remove it */
2154	$('tbody>tr>td.'+oSettings.oClasses.sRowEmpty, oSettings.nTable).parent().remove();
2155
2156	/* When scrolling we had to break the table up - restore it */
2157	if ( oSettings.nTable != oSettings.nTHead.parentNode )
2158	{
2159	$('>thead', oSettings.nTable).remove();
2160	oSettings.nTable.appendChild( oSettings.nTHead );
2161	}
2162
2163	if ( oSettings.nTFoot && oSettings.nTable != oSettings.nTFoot.parentNode )
2164	{
2165	$('>tfoot', oSettings.nTable).remove();
2166	oSettings.nTable.appendChild( oSettings.nTFoot );
2167	}
2168
2169	/* Remove the DataTables generated nodes, events and classes */
2170	oSettings.nTable.parentNode.removeChild( oSettings.nTable );
2171	$(oSettings.nTableWrapper).remove();
2172
2173	oSettings.aaSorting = [];
2174	oSettings.aaSortingFixed = [];
2175	_fnSortingClasses( oSettings );
2176
2177	$(_fnGetTrNodes( oSettings )).removeClass( oSettings.asStripClasses.join(' ') );
2178
2179	if ( !oSettings.bJUI )
2180	{
2181	$('th', oSettings.nTHead).removeClass( [ _oExt.oStdClasses.sSortable,
2182	_oExt.oStdClasses.sSortableAsc,
2183	_oExt.oStdClasses.sSortableDesc,
2184	_oExt.oStdClasses.sSortableNone ].join(' ')
2185	);
2186	}
2187	else
2188	{
2189	$('th', oSettings.nTHead).removeClass( [ _oExt.oStdClasses.sSortable,
2190	_oExt.oJUIClasses.sSortableAsc,
2191	_oExt.oJUIClasses.sSortableDesc,
2192	_oExt.oJUIClasses.sSortableNone ].join(' ')
2193	);
2194	$('th span', oSettings.nTHead).remove();
2195	}
2196
2197	/* Add the TR elements back into the table in their original order */
2198	nOrig.appendChild( oSettings.nTable );
2199	for ( i=0, iLen=oSettings.aoData.length ; i<iLen ; i++ )
2200	{
2201	nBody.appendChild( oSettings.aoData[i].nTr );
2202	}
2203
2204	/* Restore the width of the original table */
2205	oSettings.nTable.style.width = _fnStringToCss(oSettings.sDestroyWidth);
2206
2207	/* If the were originally odd/even type classes - then we add them back here. Note
2208	* this is not fool proof (for example if not all rows as odd/even classes - but
2209	* it's a good effort without getting carried away
2210	*/
2211	$('>tr:even', nBody).addClass( oSettings.asDestoryStrips[0] );
2212	$('>tr:odd', nBody).addClass( oSettings.asDestoryStrips[1] );
2213
2214	/* Remove the settings object from the settings array */
2215	for ( i=0, iLen=_aoSettings.length ; i<iLen ; i++ )
2216	{
2217	if ( _aoSettings[i] == oSettings )
2218	{
2219	_aoSettings.splice( i, 1 );
2220	}
2221	}
2222
2223	/* End it all */
2224	oSettings = null;
2225	};
2226
2227	/*
2228	* Function: fnAjustColumnSizing
2229	* Purpose: Update tale sizing based on content. This would most likely be used for scrolling
2230	* and will typically need a redraw after it.
2231	* Returns: -
2232	* Inputs: bool:bRedraw - redraw the table or not, you will typically want to - default true
2233	*/
2234	this.fnAdjustColumnSizing = function ( bRedraw )
2235	{
2236	var oSettings = _fnSettingsFromNode(this[_oExt.iApiIndex]);
2237	_fnAjustColumnSizing( oSettings );
2238
2239	if ( typeof bRedraw == 'undefined' \|\| bRedraw )
2240	{
2241	this.fnDraw( false );
2242	}
2243	else if ( oSettings.oScroll.sX !== "" \|\| oSettings.oScroll.sY !== "" )
2244	{
2245	/* If not redrawing, but scrolling, we want to apply the new column sizes anyway */
2246	this.oApi._fnScrollDraw(oSettings);
2247	}
2248	};
2249
2250	/*
2251	* Plugin API functions
2252	*
2253	* This call will add the functions which are defined in _oExt.oApi to the
2254	* DataTables object, providing a rather nice way to allow plug-in API functions. Note that
2255	* this is done here, so that API function can actually override the built in API functions if
2256	* required for a particular purpose.
2257	*/
2258
2259	/*
2260	* Function: _fnExternApiFunc
2261	* Purpose: Create a wrapper function for exporting an internal func to an external API func
2262	* Returns: function: - wrapped function
2263	* Inputs: string:sFunc - API function name
2264	*/
2265	function _fnExternApiFunc (sFunc)
2266	{
2267	return function() {
2268	var aArgs = [_fnSettingsFromNode(this[_oExt.iApiIndex])].concat(
2269	Array.prototype.slice.call(arguments) );
2270	return _oExt.oApi[sFunc].apply( this, aArgs );
2271	};
2272	}
2273
2274	for ( var sFunc in _oExt.oApi )
2275	{
2276	if ( sFunc )
2277	{
2278	/*
2279	* Function: anon
2280	* Purpose: Wrap the plug-in API functions in order to provide the settings as 1st arg
2281	* and execute in this scope
2282	* Returns: -
2283	* Inputs: -
2284	*/
2285	this[sFunc] = _fnExternApiFunc(sFunc);
2286	}
2287	}
2288
2289
2290
2291	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2292	* Section - Local functions
2293	* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2294
2295	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2296	* Section - Initalisation
2297	*/
2298
2299	/*
2300	* Function: _fnInitalise
2301	* Purpose: Draw the table for the first time, adding all required features
2302	* Returns: -
2303	* Inputs: object:oSettings - dataTables settings object
2304	*/
2305	function _fnInitalise ( oSettings )
2306	{
2307	var i, iLen;
2308
2309	/* Ensure that the table data is fully initialised */
2310	if ( oSettings.bInitialised === false )
2311	{
2312	setTimeout( function(){ _fnInitalise( oSettings ); }, 200 );
2313	return;
2314	}
2315
2316	/* Show the display HTML options */
2317	_fnAddOptionsHtml( oSettings );
2318
2319	/* Draw the headers for the table */
2320	_fnDrawHead( oSettings );
2321
2322	/* Okay to show that something is going on now */
2323	_fnProcessingDisplay( oSettings, true );
2324
2325	/* Calculate sizes for columns */
2326	if ( oSettings.oFeatures.bAutoWidth )
2327	{
2328	_fnCalculateColumnWidths( oSettings );
2329	}
2330
2331	for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
2332	{
2333	if ( oSettings.aoColumns[i].sWidth !== null )
2334	{
2335	oSettings.aoColumns[i].nTh.style.width = _fnStringToCss( oSettings.aoColumns[i].sWidth );
2336	}
2337	}
2338
2339	/* If there is default sorting required - let's do it. The sort function will do the
2340	* drawing for us. Otherwise we draw the table regardless of the Ajax source - this allows
2341	* the table to look initialised for Ajax sourcing data (show 'loading' message possibly)
2342	*/
2343	if ( oSettings.oFeatures.bSort )
2344	{
2345	_fnSort( oSettings );
2346	}
2347	else
2348	{
2349	oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
2350	_fnCalculateEnd( oSettings );
2351	_fnDraw( oSettings );
2352	}
2353
2354	/* if there is an ajax source load the data */
2355	if ( oSettings.sAjaxSource !== null && !oSettings.oFeatures.bServerSide )
2356	{
2357	oSettings.fnServerData.call( oSettings.oInstance, oSettings.sAjaxSource, [], function(json) {
2358	/* Got the data - add it to the table */
2359	for ( i=0 ; i<json.aaData.length ; i++ )
2360	{
2361	_fnAddData( oSettings, json.aaData[i] );
2362	}
2363
2364	/* Reset the init display for cookie saving. We've already done a filter, and
2365	* therefore cleared it before. So we need to make it appear 'fresh'
2366	*/
2367	oSettings.iInitDisplayStart = oSettings._iDisplayStart;
2368
2369	if ( oSettings.oFeatures.bSort )
2370	{
2371	_fnSort( oSettings );
2372	}
2373	else
2374	{
2375	oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
2376	_fnCalculateEnd( oSettings );
2377	_fnDraw( oSettings );
2378	}
2379
2380	_fnProcessingDisplay( oSettings, false );
2381	_fnInitComplete( oSettings, json );
2382	} );
2383	return;
2384	}
2385
2386	/* Server-side processing initialisation complete is done at the end of _fnDraw */
2387	if ( !oSettings.oFeatures.bServerSide )
2388	{
2389	_fnProcessingDisplay( oSettings, false );
2390	_fnInitComplete( oSettings );
2391	}
2392	}
2393
2394	/*
2395	* Function: _fnInitalise
2396	* Purpose: Draw the table for the first time, adding all required features
2397	* Returns: -
2398	* Inputs: object:oSettings - dataTables settings object
2399	*/
2400	function _fnInitComplete ( oSettings, json )
2401	{
2402	oSettings._bInitComplete = true;
2403	if ( typeof oSettings.fnInitComplete == 'function' )
2404	{
2405	if ( typeof json != 'undefined' )
2406	{
2407	oSettings.fnInitComplete.call( oSettings.oInstance, oSettings, json );
2408	}
2409	else
2410	{
2411	oSettings.fnInitComplete.call( oSettings.oInstance, oSettings );
2412	}
2413	}
2414	}
2415
2416	/*
2417	* Function: _fnLanguageProcess
2418	* Purpose: Copy language variables from remote object to a local one
2419	* Returns: -
2420	* Inputs: object:oSettings - dataTables settings object
2421	* object:oLanguage - Language information
2422	* bool:bInit - init once complete
2423	*/
2424	function _fnLanguageProcess( oSettings, oLanguage, bInit )
2425	{
2426	_fnMap( oSettings.oLanguage, oLanguage, 'sProcessing' );
2427	_fnMap( oSettings.oLanguage, oLanguage, 'sLengthMenu' );
2428	_fnMap( oSettings.oLanguage, oLanguage, 'sEmptyTable' );
2429	_fnMap( oSettings.oLanguage, oLanguage, 'sZeroRecords' );
2430	_fnMap( oSettings.oLanguage, oLanguage, 'sInfo' );
2431	_fnMap( oSettings.oLanguage, oLanguage, 'sInfoEmpty' );
2432	_fnMap( oSettings.oLanguage, oLanguage, 'sInfoFiltered' );
2433	_fnMap( oSettings.oLanguage, oLanguage, 'sInfoPostFix' );
2434	_fnMap( oSettings.oLanguage, oLanguage, 'sSearch' );
2435
2436	if ( typeof oLanguage.oPaginate != 'undefined' )
2437	{
2438	_fnMap( oSettings.oLanguage.oPaginate, oLanguage.oPaginate, 'sFirst' );
2439	_fnMap( oSettings.oLanguage.oPaginate, oLanguage.oPaginate, 'sPrevious' );
2440	_fnMap( oSettings.oLanguage.oPaginate, oLanguage.oPaginate, 'sNext' );
2441	_fnMap( oSettings.oLanguage.oPaginate, oLanguage.oPaginate, 'sLast' );
2442	}
2443
2444	/* Backwards compatibility - if there is no sEmptyTable given, then use the same as
2445	* sZeroRecords - assuming that is given.
2446	*/
2447	if ( typeof oLanguage.sEmptyTable == 'undefined' &&
2448	typeof oLanguage.sZeroRecords != 'undefined' )
2449	{
2450	_fnMap( oSettings.oLanguage, oLanguage, 'sZeroRecords', 'sEmptyTable' );
2451	}
2452
2453	if ( bInit )
2454	{
2455	_fnInitalise( oSettings );
2456	}
2457	}
2458
2459	/*
2460	* Function: _fnAddColumn
2461	* Purpose: Add a column to the list used for the table with default values
2462	* Returns: -
2463	* Inputs: object:oSettings - dataTables settings object
2464	* node:nTh - the th element for this column
2465	*/
2466	function _fnAddColumn( oSettings, nTh )
2467	{
2468	oSettings.aoColumns[ oSettings.aoColumns.length++ ] = {
2469	"sType": null,
2470	"_bAutoType": true,
2471	"bVisible": true,
2472	"bSearchable": true,
2473	"bSortable": true,
2474	"asSorting": [ 'asc', 'desc' ],
2475	"sSortingClass": oSettings.oClasses.sSortable,
2476	"sSortingClassJUI": oSettings.oClasses.sSortJUI,
2477	"sTitle": nTh ? nTh.innerHTML : '',
2478	"sName": '',
2479	"sWidth": null,
2480	"sWidthOrig": null,
2481	"sClass": null,
2482	"fnRender": null,
2483	"bUseRendered": true,
2484	"iDataSort": oSettings.aoColumns.length-1,
2485	"sSortDataType": 'std',
2486	"nTh": nTh ? nTh : document.createElement('th'),
2487	"nTf": null,
2488	"anThExtra": [],
2489	"anTfExtra": []
2490	};
2491
2492	var iCol = oSettings.aoColumns.length-1;
2493	var oCol = oSettings.aoColumns[ iCol ];
2494
2495	/* Add a column specific filter */
2496	if ( typeof oSettings.aoPreSearchCols[ iCol ] == 'undefined' \|\|
2497	oSettings.aoPreSearchCols[ iCol ] === null )
2498	{
2499	oSettings.aoPreSearchCols[ iCol ] = {
2500	"sSearch": "",
2501	"bRegex": false,
2502	"bSmart": true
2503	};
2504	}
2505	else
2506	{
2507	/* Don't require that the user must specify bRegex and / or bSmart */
2508	if ( typeof oSettings.aoPreSearchCols[ iCol ].bRegex == 'undefined' )
2509	{
2510	oSettings.aoPreSearchCols[ iCol ].bRegex = true;
2511	}
2512
2513	if ( typeof oSettings.aoPreSearchCols[ iCol ].bSmart == 'undefined' )
2514	{
2515	oSettings.aoPreSearchCols[ iCol ].bSmart = true;
2516	}
2517	}
2518
2519	/* Use the column options function to initialise classes etc */
2520	_fnColumnOptions( oSettings, iCol, null );
2521	}
2522
2523	/*
2524	* Function: _fnColumnOptions
2525	* Purpose: Apply options for a column
2526	* Returns: -
2527	* Inputs: object:oSettings - dataTables settings object
2528	* int:iCol - column index to consider
2529	* object:oOptions - object with sType, bVisible and bSearchable
2530	*/
2531	function _fnColumnOptions( oSettings, iCol, oOptions )
2532	{
2533	var oCol = oSettings.aoColumns[ iCol ];
2534
2535	/* User specified column options */
2536	if ( typeof oOptions != 'undefined' && oOptions !== null )
2537	{
2538	if ( typeof oOptions.sType != 'undefined' )
2539	{
2540	oCol.sType = oOptions.sType;
2541	oCol._bAutoType = false;
2542	}
2543
2544	_fnMap( oCol, oOptions, "bVisible" );
2545	_fnMap( oCol, oOptions, "bSearchable" );
2546	_fnMap( oCol, oOptions, "bSortable" );
2547	_fnMap( oCol, oOptions, "sTitle" );
2548	_fnMap( oCol, oOptions, "sName" );
2549	_fnMap( oCol, oOptions, "sWidth" );
2550	_fnMap( oCol, oOptions, "sWidth", "sWidthOrig" );
2551	_fnMap( oCol, oOptions, "sClass" );
2552	_fnMap( oCol, oOptions, "fnRender" );
2553	_fnMap( oCol, oOptions, "bUseRendered" );
2554	_fnMap( oCol, oOptions, "iDataSort" );
2555	_fnMap( oCol, oOptions, "asSorting" );
2556	_fnMap( oCol, oOptions, "sSortDataType" );
2557	}
2558
2559	/* Feature sorting overrides column specific when off */
2560	if ( !oSettings.oFeatures.bSort )
2561	{
2562	oCol.bSortable = false;
2563	}
2564
2565	/* Check that the class assignment is correct for sorting */
2566	if ( !oCol.bSortable \|\|
2567	($.inArray('asc', oCol.asSorting) == -1 && $.inArray('desc', oCol.asSorting) == -1) )
2568	{
2569	oCol.sSortingClass = oSettings.oClasses.sSortableNone;
2570	oCol.sSortingClassJUI = "";
2571	}
2572	else if ( $.inArray('asc', oCol.asSorting) != -1 && $.inArray('desc', oCol.asSorting) == -1 )
2573	{
2574	oCol.sSortingClass = oSettings.oClasses.sSortableAsc;
2575	oCol.sSortingClassJUI = oSettings.oClasses.sSortJUIAscAllowed;
2576	}
2577	else if ( $.inArray('asc', oCol.asSorting) == -1 && $.inArray('desc', oCol.asSorting) != -1 )
2578	{
2579	oCol.sSortingClass = oSettings.oClasses.sSortableDesc;
2580	oCol.sSortingClassJUI = oSettings.oClasses.sSortJUIDescAllowed;
2581	}
2582	}
2583
2584	/*
2585	* Function: _fnAddData
2586	* Purpose: Add a data array to the table, creating DOM node etc
2587	* Returns: int: - >=0 if successful (index of new aoData entry), -1 if failed
2588	* Inputs: object:oSettings - dataTables settings object
2589	* array:aData - data array to be added
2590	* Notes: There are two basic methods for DataTables to get data to display - a JS array
2591	* (which is dealt with by this function), and the DOM, which has it's own optimised
2592	* function (_fnGatherData). Be careful to make the same changes here as there and vice-versa
2593	*/
2594	function _fnAddData ( oSettings, aDataSupplied )
2595	{
2596	/* Sanity check the length of the new array */
2597	if ( aDataSupplied.length != oSettings.aoColumns.length &&
2598	oSettings.iDrawError != oSettings.iDraw )
2599	{
2600	_fnLog( oSettings, 0, "Added data (size "+aDataSupplied.length+") does not match known "+
2601	"number of columns ("+oSettings.aoColumns.length+")" );
2602	oSettings.iDrawError = oSettings.iDraw;
2603	return -1;
2604	}
2605
2606
2607	/* Create the object for storing information about this new row */
2608	var aData = aDataSupplied.slice();
2609	var iThisIndex = oSettings.aoData.length;
2610	oSettings.aoData.push( {
2611	"nTr": document.createElement('tr'),
2612	"_iId": oSettings.iNextId++,
2613	"_aData": aData,
2614	"_anHidden": [],
2615	"_sRowStripe": ''
2616	} );
2617
2618	/* Create the cells */
2619	var nTd, sThisType;
2620	for ( var i=0 ; i<aData.length ; i++ )
2621	{
2622	nTd = document.createElement('td');
2623
2624	/* Allow null data (from a data array) - simply deal with it as a blank string */
2625	if ( aData[i] === null )
2626	{
2627	aData[i] = '';
2628	}
2629
2630	if ( typeof oSettings.aoColumns[i].fnRender == 'function' )
2631	{
2632	var sRendered = oSettings.aoColumns[i].fnRender( {
2633	"iDataRow": iThisIndex,
2634	"iDataColumn": i,
2635	"aData": aData,
2636	"oSettings": oSettings
2637	} );
2638	nTd.innerHTML = sRendered;
2639	if ( oSettings.aoColumns[i].bUseRendered )
2640	{
2641	/* Use the rendered data for filtering/sorting */
2642	oSettings.aoData[iThisIndex]._aData[i] = sRendered;
2643	}
2644	}
2645	else
2646	{
2647	nTd.innerHTML = aData[i];
2648	}
2649
2650	/* Cast everything as a string - so we can treat everything equally when sorting */
2651	if ( typeof aData[i] != 'string' )
2652	{
2653	aData[i] += "";
2654	}
2655	aData[i] = $.trim(aData[i]);
2656
2657	/* Add user defined class */
2658	if ( oSettings.aoColumns[i].sClass !== null )
2659	{
2660	nTd.className = oSettings.aoColumns[i].sClass;
2661	}
2662
2663	/* See if we should auto-detect the column type */
2664	if ( oSettings.aoColumns[i]._bAutoType && oSettings.aoColumns[i].sType != 'string' )
2665	{
2666	/* Attempt to auto detect the type - same as _fnGatherData() */
2667	sThisType = _fnDetectType( oSettings.aoData[iThisIndex]._aData[i] );
2668	if ( oSettings.aoColumns[i].sType === null )
2669	{
2670	oSettings.aoColumns[i].sType = sThisType;
2671	}
2672	else if ( oSettings.aoColumns[i].sType != sThisType )
2673	{
2674	/* String is always the 'fallback' option */
2675	oSettings.aoColumns[i].sType = 'string';
2676	}
2677	}
2678
2679	if ( oSettings.aoColumns[i].bVisible )
2680	{
2681	oSettings.aoData[iThisIndex].nTr.appendChild( nTd );
2682	oSettings.aoData[iThisIndex]._anHidden[i] = null;
2683	}
2684	else
2685	{
2686	oSettings.aoData[iThisIndex]._anHidden[i] = nTd;
2687	}
2688	}
2689
2690	/* Add to the display array */
2691	oSettings.aiDisplayMaster.push( iThisIndex );
2692	return iThisIndex;
2693	}
2694
2695	/*
2696	* Function: _fnGatherData
2697	* Purpose: Read in the data from the target table from the DOM
2698	* Returns: -
2699	* Inputs: object:oSettings - dataTables settings object
2700	* Notes: This is a optimised version of _fnAddData (more or less) for reading information
2701	* from the DOM. The basic actions must be identical in the two functions.
2702	*/
2703	function _fnGatherData( oSettings )
2704	{
2705	var iLoop, i, iLen, j, jLen, jInner,
2706	nTds, nTrs, nTd, aLocalData, iThisIndex,
2707	iRow, iRows, iColumn, iColumns;
2708
2709	/*
2710	* Process by row first
2711	* Add the data object for the whole table - storing the tr node. Note - no point in getting
2712	* DOM based data if we are going to go and replace it with Ajax source data.
2713	*/
2714	if ( oSettings.sAjaxSource === null )
2715	{
2716	nTrs = oSettings.nTBody.childNodes;
2717	for ( i=0, iLen=nTrs.length ; i<iLen ; i++ )
2718	{
2719	if ( nTrs[i].nodeName.toUpperCase() == "TR" )
2720	{
2721	iThisIndex = oSettings.aoData.length;
2722	oSettings.aoData.push( {
2723	"nTr": nTrs[i],
2724	"_iId": oSettings.iNextId++,
2725	"_aData": [],
2726	"_anHidden": [],
2727	"_sRowStripe": ''
2728	} );
2729
2730	oSettings.aiDisplayMaster.push( iThisIndex );
2731
2732	aLocalData = oSettings.aoData[iThisIndex]._aData;
2733	nTds = nTrs[i].childNodes;
2734	jInner = 0;
2735
2736	for ( j=0, jLen=nTds.length ; j<jLen ; j++ )
2737	{
2738	if ( nTds[j].nodeName.toUpperCase() == "TD" )
2739	{
2740	aLocalData[jInner] = $.trim(nTds[j].innerHTML);
2741	jInner++;
2742	}
2743	}
2744	}
2745	}
2746	}
2747
2748	/* Gather in the TD elements of the Table - note that this is basically the same as
2749	* fnGetTdNodes, but that function takes account of hidden columns, which we haven't yet
2750	* setup!
2751	*/
2752	nTrs = _fnGetTrNodes( oSettings );
2753	nTds = [];
2754	for ( i=0, iLen=nTrs.length ; i<iLen ; i++ )
2755	{
2756	for ( j=0, jLen=nTrs[i].childNodes.length ; j<jLen ; j++ )
2757	{
2758	nTd = nTrs[i].childNodes[j];
2759	if ( nTd.nodeName.toUpperCase() == "TD" )
2760	{
2761	nTds.push( nTd );
2762	}
2763	}
2764	}
2765
2766	/* Sanity check */
2767	if ( nTds.length != nTrs.length * oSettings.aoColumns.length )
2768	{
2769	_fnLog( oSettings, 1, "Unexpected number of TD elements. Expected "+
2770	(nTrs.length * oSettings.aoColumns.length)+" and got "+nTds.length+". DataTables does "+
2771	"not support rowspan / colspan in the table body, and there must be one cell for each "+
2772	"row/column combination." );
2773	}
2774
2775	/* Now process by column */
2776	for ( iColumn=0, iColumns=oSettings.aoColumns.length ; iColumn<iColumns ; iColumn++ )
2777	{
2778	/* Get the title of the column - unless there is a user set one */
2779	if ( oSettings.aoColumns[iColumn].sTitle === null )
2780	{
2781	oSettings.aoColumns[iColumn].sTitle = oSettings.aoColumns[iColumn].nTh.innerHTML;
2782	}
2783
2784	var
2785	bAutoType = oSettings.aoColumns[iColumn]._bAutoType,
2786	bRender = typeof oSettings.aoColumns[iColumn].fnRender == 'function',
2787	bClass = oSettings.aoColumns[iColumn].sClass !== null,
2788	bVisible = oSettings.aoColumns[iColumn].bVisible,
2789	nCell, sThisType, sRendered;
2790
2791	/* A single loop to rule them all (and be more efficient) */
2792	if ( bAutoType \|\| bRender \|\| bClass \|\| !bVisible )
2793	{
2794	for ( iRow=0, iRows=oSettings.aoData.length ; iRow<iRows ; iRow++ )
2795	{
2796	nCell = nTds[ (iRow*iColumns) + iColumn ];
2797
2798	/* Type detection */
2799	if ( bAutoType )
2800	{
2801	if ( oSettings.aoColumns[iColumn].sType != 'string' )
2802	{
2803	sThisType = _fnDetectType( oSettings.aoData[iRow]._aData[iColumn] );
2804	if ( oSettings.aoColumns[iColumn].sType === null )
2805	{
2806	oSettings.aoColumns[iColumn].sType = sThisType;
2807	}
2808	else if ( oSettings.aoColumns[iColumn].sType != sThisType )
2809	{
2810	/* String is always the 'fallback' option */
2811	oSettings.aoColumns[iColumn].sType = 'string';
2812	}
2813	}
2814	}
2815
2816	/* Rendering */
2817	if ( bRender )
2818	{
2819	sRendered = oSettings.aoColumns[iColumn].fnRender( {
2820	"iDataRow": iRow,
2821	"iDataColumn": iColumn,
2822	"aData": oSettings.aoData[iRow]._aData,
2823	"oSettings": oSettings
2824	} );
2825	nCell.innerHTML = sRendered;
2826	if ( oSettings.aoColumns[iColumn].bUseRendered )
2827	{
2828	/* Use the rendered data for filtering/sorting */
2829	oSettings.aoData[iRow]._aData[iColumn] = sRendered;
2830	}
2831	}
2832
2833	/* Classes */
2834	if ( bClass )
2835	{
2836	nCell.className += ' '+oSettings.aoColumns[iColumn].sClass;
2837	}
2838
2839	/* Column visability */
2840	if ( !bVisible )
2841	{
2842	oSettings.aoData[iRow]._anHidden[iColumn] = nCell;
2843	nCell.parentNode.removeChild( nCell );
2844	}
2845	else
2846	{
2847	oSettings.aoData[iRow]._anHidden[iColumn] = null;
2848	}
2849	}
2850	}
2851	}
2852	}
2853
2854
2855
2856	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2857	* Section - Drawing functions
2858	*/
2859
2860	/*
2861	* Function: _fnDrawHead
2862	* Purpose: Create the HTML header for the table
2863	* Returns: -
2864	* Inputs: object:oSettings - dataTables settings object
2865	*/
2866	function _fnDrawHead( oSettings )
2867	{
2868	var i, nTh, iLen, j, jLen;
2869	var anTr = oSettings.nTHead.getElementsByTagName('tr');
2870	var iThs = oSettings.nTHead.getElementsByTagName('th').length;
2871	var iCorrector = 0;
2872	var jqChildren;
2873
2874	/* If there is a header in place - then use it - otherwise it's going to get nuked... */
2875	if ( iThs !== 0 )
2876	{
2877	/* We've got a thead from the DOM, so remove hidden columns and apply width to vis cols */
2878	for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
2879	{
2880	nTh = oSettings.aoColumns[i].nTh;
2881
2882	if ( oSettings.aoColumns[i].sClass !== null )
2883	{
2884	$(nTh).addClass( oSettings.aoColumns[i].sClass );
2885	}
2886
2887	/* Cache and remove (if needed) any extra elements for this column in the header */
2888	for ( j=1, jLen=anTr.length ; j<jLen ; j++ )
2889	{
2890	jqChildren = $(anTr[j]).children();
2891	oSettings.aoColumns[i].anThExtra.push( jqChildren[i-iCorrector] );
2892	if ( !oSettings.aoColumns[i].bVisible )
2893	{
2894	anTr[j].removeChild( jqChildren[i-iCorrector] );
2895	}
2896	}
2897
2898	if ( oSettings.aoColumns[i].bVisible )
2899	{
2900	/* Set the title of the column if it is user defined (not what was auto detected) */
2901	if ( oSettings.aoColumns[i].sTitle != nTh.innerHTML )
2902	{
2903	nTh.innerHTML = oSettings.aoColumns[i].sTitle;
2904	}
2905	}
2906	else
2907	{
2908	nTh.parentNode.removeChild( nTh );
2909	iCorrector++;
2910	}
2911	}
2912	}
2913	else
2914	{
2915	/* We don't have a header in the DOM - so we are going to have to create one */
2916	var nTr = document.createElement( "tr" );
2917
2918	for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
2919	{
2920	nTh = oSettings.aoColumns[i].nTh;
2921	nTh.innerHTML = oSettings.aoColumns[i].sTitle;
2922
2923	if ( oSettings.aoColumns[i].sClass !== null )
2924	{
2925	$(nTh).addClass( oSettings.aoColumns[i].sClass );
2926	}
2927
2928	if ( oSettings.aoColumns[i].bVisible )
2929	{
2930	nTr.appendChild( nTh );
2931	}
2932	}
2933	$(oSettings.nTHead).html( '' )[0].appendChild( nTr );
2934	}
2935
2936	/* Add the extra markup needed by jQuery UI's themes */
2937	if ( oSettings.bJUI )
2938	{
2939	for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
2940	{
2941	nTh = oSettings.aoColumns[i].nTh;
2942
2943	var nDiv = document.createElement('div');
2944	nDiv.className = oSettings.oClasses.sSortJUIWrapper;
2945	$(nTh).contents().appendTo(nDiv);
2946
2947	nDiv.appendChild( document.createElement('span') );
2948	nTh.appendChild( nDiv );
2949	}
2950	}
2951
2952	/* Add sort listener */
2953	var fnNoSelect = function (e) {
2954	this.onselectstart = function() { return false; };
2955	return false;
2956	};
2957
2958	if ( oSettings.oFeatures.bSort )
2959	{
2960	for ( i=0 ; i<oSettings.aoColumns.length ; i++ )
2961	{
2962	if ( oSettings.aoColumns[i].bSortable !== false )
2963	{
2964	_fnSortAttachListener( oSettings, oSettings.aoColumns[i].nTh, i );
2965
2966	/* Take the brutal approach to cancelling text selection in header */
2967	$(oSettings.aoColumns[i].nTh).bind( 'mousedown.DT', fnNoSelect );
2968	}
2969	else
2970	{
2971	$(oSettings.aoColumns[i].nTh).addClass( oSettings.oClasses.sSortableNone );
2972	}
2973	}
2974	}
2975
2976	/* Cache the footer elements */
2977	if ( oSettings.nTFoot !== null )
2978	{
2979	iCorrector = 0;
2980	anTr = oSettings.nTFoot.getElementsByTagName('tr');
2981	var nTfs = anTr[0].getElementsByTagName('th');
2982
2983	for ( i=0, iLen=nTfs.length ; i<iLen ; i++ )
2984	{
2985	if ( typeof oSettings.aoColumns[i] != 'undefined' )
2986	{
2987	oSettings.aoColumns[i].nTf = nTfs[i-iCorrector];
2988
2989	if ( oSettings.oClasses.sFooterTH !== "" )
2990	{
2991	oSettings.aoColumns[i].nTf.className += " "+oSettings.oClasses.sFooterTH;
2992	}
2993
2994	/* Deal with any extra elements for this column from the footer */
2995	for ( j=1, jLen=anTr.length ; j<jLen ; j++ )
2996	{
2997	jqChildren = $(anTr[j]).children();
2998	oSettings.aoColumns[i].anTfExtra.push( jqChildren[i-iCorrector] );
2999	if ( !oSettings.aoColumns[i].bVisible )
3000	{
3001	anTr[j].removeChild( jqChildren[i-iCorrector] );
3002	}
3003	}
3004
3005	if ( !oSettings.aoColumns[i].bVisible )
3006	{
3007	nTfs[i-iCorrector].parentNode.removeChild( nTfs[i-iCorrector] );
3008	iCorrector++;
3009	}
3010	}
3011	}
3012	}
3013	}
3014
3015	/*
3016	* Function: _fnDraw
3017	* Purpose: Insert the required TR nodes into the table for display
3018	* Returns: -
3019	* Inputs: object:oSettings - dataTables settings object
3020	*/
3021	function _fnDraw( oSettings )
3022	{
3023	var i, iLen;
3024	var anRows = [];
3025	var iRowCount = 0;
3026	var bRowError = false;
3027	var iStrips = oSettings.asStripClasses.length;
3028	var iOpenRows = oSettings.aoOpenRows.length;
3029
3030	oSettings.bDrawing = true;
3031
3032	/* Check and see if we have an initial draw position from state saving */
3033	if ( typeof oSettings.iInitDisplayStart != 'undefined' && oSettings.iInitDisplayStart != -1 )
3034	{
3035	if ( oSettings.oFeatures.bServerSide )
3036	{
3037	oSettings._iDisplayStart = oSettings.iInitDisplayStart;
3038	}
3039	else
3040	{
3041	oSettings._iDisplayStart = (oSettings.iInitDisplayStart >= oSettings.fnRecordsDisplay()) ?
3042	0 : oSettings.iInitDisplayStart;
3043	}
3044	oSettings.iInitDisplayStart = -1;
3045	_fnCalculateEnd( oSettings );
3046	}
3047
3048	/* If we are dealing with Ajax - do it here */
3049	if ( !oSettings.bDestroying && oSettings.oFeatures.bServerSide &&
3050	!_fnAjaxUpdate( oSettings ) )
3051	{
3052	return;
3053	}
3054	else if ( !oSettings.oFeatures.bServerSide )
3055	{
3056	oSettings.iDraw++;
3057	}
3058
3059	if ( oSettings.aiDisplay.length !== 0 )
3060	{
3061	var iStart = oSettings._iDisplayStart;
3062	var iEnd = oSettings._iDisplayEnd;
3063
3064	if ( oSettings.oFeatures.bServerSide )
3065	{
3066	iStart = 0;
3067	iEnd = oSettings.aoData.length;
3068	}
3069
3070	for ( var j=iStart ; j<iEnd ; j++ )
3071	{
3072	var aoData = oSettings.aoData[ oSettings.aiDisplay[j] ];
3073	var nRow = aoData.nTr;
3074
3075	/* Remove the old stripping classes and then add the new one */
3076	if ( iStrips !== 0 )
3077	{
3078	var sStrip = oSettings.asStripClasses[ iRowCount % iStrips ];
3079	if ( aoData._sRowStripe != sStrip )
3080	{
3081	$(nRow).removeClass( aoData._sRowStripe ).addClass( sStrip );
3082	aoData._sRowStripe = sStrip;
3083	}
3084	}
3085
3086	/* Custom row callback function - might want to manipule the row */
3087	if ( typeof oSettings.fnRowCallback == "function" )
3088	{
3089	nRow = oSettings.fnRowCallback.call( oSettings.oInstance, nRow,
3090	oSettings.aoData[ oSettings.aiDisplay[j] ]._aData, iRowCount, j );
3091	if ( !nRow && !bRowError )
3092	{
3093	_fnLog( oSettings, 0, "A node was not returned by fnRowCallback" );
3094	bRowError = true;
3095	}
3096	}
3097
3098	anRows.push( nRow );
3099	iRowCount++;
3100
3101	/* If there is an open row - and it is attached to this parent - attach it on redraw */
3102	if ( iOpenRows !== 0 )
3103	{
3104	for ( var k=0 ; k<iOpenRows ; k++ )
3105	{
3106	if ( nRow == oSettings.aoOpenRows[k].nParent )
3107	{
3108	anRows.push( oSettings.aoOpenRows[k].nTr );
3109	}
3110	}
3111	}
3112	}
3113	}
3114	else
3115	{
3116	/* Table is empty - create a row with an empty message in it */
3117	anRows[ 0 ] = document.createElement( 'tr' );
3118
3119	if ( typeof oSettings.asStripClasses[0] != 'undefined' )
3120	{
3121	anRows[ 0 ].className = oSettings.asStripClasses[0];
3122	}
3123
3124	var nTd = document.createElement( 'td' );
3125	nTd.setAttribute( 'valign', "top" );
3126	nTd.colSpan = _fnVisbleColumns( oSettings );
3127	nTd.className = oSettings.oClasses.sRowEmpty;
3128	if ( typeof oSettings.oLanguage.sEmptyTable != 'undefined' &&
3129	oSettings.fnRecordsTotal() === 0 )
3130	{
3131	nTd.innerHTML = oSettings.oLanguage.sEmptyTable;
3132	}
3133	else
3134	{
3135	nTd.innerHTML = oSettings.oLanguage.sZeroRecords.replace(
3136	'_MAX_', oSettings.fnFormatNumber(oSettings.fnRecordsTotal()) );
3137	}
3138
3139	anRows[ iRowCount ].appendChild( nTd );
3140	}
3141
3142	/* Callback the header and footer custom funcation if there is one */
3143	if ( typeof oSettings.fnHeaderCallback == 'function' )
3144	{
3145	oSettings.fnHeaderCallback.call( oSettings.oInstance, $('>tr', oSettings.nTHead)[0],
3146	_fnGetDataMaster( oSettings ), oSettings._iDisplayStart, oSettings.fnDisplayEnd(),
3147	oSettings.aiDisplay );
3148	}
3149
3150	if ( typeof oSettings.fnFooterCallback == 'function' )
3151	{
3152	oSettings.fnFooterCallback.call( oSettings.oInstance, $('>tr', oSettings.nTFoot)[0],
3153	_fnGetDataMaster( oSettings ), oSettings._iDisplayStart, oSettings.fnDisplayEnd(),
3154	oSettings.aiDisplay );
3155	}
3156
3157	/*
3158	* Need to remove any old row from the display - note we can't just empty the tbody using
3159	* $().html('') since this will unbind the jQuery event handlers (even although the node
3160	* still exists!) - equally we can't use innerHTML, since IE throws an exception.
3161	*/
3162	var
3163	nAddFrag = document.createDocumentFragment(),
3164	nRemoveFrag = document.createDocumentFragment(),
3165	nBodyPar, nTrs;
3166
3167	if ( oSettings.nTBody )
3168	{
3169	nBodyPar = oSettings.nTBody.parentNode;
3170	nRemoveFrag.appendChild( oSettings.nTBody );
3171
3172	/* When doing infinite scrolling, only remove child rows when sorting, filtering or start
3173	* up. When not infinite scroll, always do it.
3174	*/
3175	if ( !oSettings.oScroll.bInfinite \|\| !oSettings._bInitComplete \|\|
3176	oSettings.bSorted \|\| oSettings.bFiltered )
3177	{
3178	nTrs = oSettings.nTBody.childNodes;
3179	for ( i=nTrs.length-1 ; i>=0 ; i-- )
3180	{
3181	nTrs[i].parentNode.removeChild( nTrs[i] );
3182	}
3183	}
3184
3185	/* Put the draw table into the dom */
3186	for ( i=0, iLen=anRows.length ; i<iLen ; i++ )
3187	{
3188	nAddFrag.appendChild( anRows[i] );
3189	}
3190
3191	oSettings.nTBody.appendChild( nAddFrag );
3192	if ( nBodyPar !== null )
3193	{
3194	nBodyPar.appendChild( oSettings.nTBody );
3195	}
3196	}
3197
3198	/* Call all required callback functions for the end of a draw */
3199	for ( i=oSettings.aoDrawCallback.length-1 ; i>=0 ; i-- )
3200	{
3201	oSettings.aoDrawCallback[i].fn.call( oSettings.oInstance, oSettings );
3202	}
3203
3204	/* Draw is complete, sorting and filtering must be as well */
3205	oSettings.bSorted = false;
3206	oSettings.bFiltered = false;
3207	oSettings.bDrawing = false;
3208
3209	if ( oSettings.oFeatures.bServerSide )
3210	{
3211	_fnProcessingDisplay( oSettings, false );
3212	if ( typeof oSettings._bInitComplete == 'undefined' )
3213	{
3214	_fnInitComplete( oSettings );
3215	}
3216	}
3217	}
3218
3219	/*
3220	* Function: _fnReDraw
3221	* Purpose: Redraw the table - taking account of the various features which are enabled
3222	* Returns: -
3223	* Inputs: object:oSettings - dataTables settings object
3224	*/
3225	function _fnReDraw( oSettings )
3226	{
3227	if ( oSettings.oFeatures.bSort )
3228	{
3229	/* Sorting will refilter and draw for us */
3230	_fnSort( oSettings, oSettings.oPreviousSearch );
3231	}
3232	else if ( oSettings.oFeatures.bFilter )
3233	{
3234	/* Filtering will redraw for us */
3235	_fnFilterComplete( oSettings, oSettings.oPreviousSearch );
3236	}
3237	else
3238	{
3239	_fnCalculateEnd( oSettings );
3240	_fnDraw( oSettings );
3241	}
3242	}
3243
3244	/*
3245	* Function: _fnAjaxUpdate
3246	* Purpose: Update the table using an Ajax call
3247	* Returns: bool: block the table drawing or not
3248	* Inputs: object:oSettings - dataTables settings object
3249	*/
3250	function _fnAjaxUpdate( oSettings )
3251	{
3252	if ( oSettings.bAjaxDataGet )
3253	{
3254	_fnProcessingDisplay( oSettings, true );
3255	var iColumns = oSettings.aoColumns.length;
3256	var aoData = [];
3257	var i;
3258
3259	/* Paging and general */
3260	oSettings.iDraw++;
3261	aoData.push( { "name": "sEcho", "value": oSettings.iDraw } );
3262	aoData.push( { "name": "iColumns", "value": iColumns } );
3263	aoData.push( { "name": "sColumns", "value": _fnColumnOrdering(oSettings) } );
3264	aoData.push( { "name": "iDisplayStart", "value": oSettings._iDisplayStart } );
3265	aoData.push( { "name": "iDisplayLength", "value": oSettings.oFeatures.bPaginate !== false ?
3266	oSettings._iDisplayLength : -1 } );
3267
3268	/* Filtering */
3269	if ( oSettings.oFeatures.bFilter !== false )
3270	{
3271	aoData.push( { "name": "sSearch", "value": oSettings.oPreviousSearch.sSearch } );
3272	aoData.push( { "name": "bRegex", "value": oSettings.oPreviousSearch.bRegex } );
3273	for ( i=0 ; i<iColumns ; i++ )
3274	{
3275	aoData.push( { "name": "sSearch_"+i, "value": oSettings.aoPreSearchCols[i].sSearch } );
3276	aoData.push( { "name": "bRegex_"+i, "value": oSettings.aoPreSearchCols[i].bRegex } );
3277	aoData.push( { "name": "bSearchable_"+i, "value": oSettings.aoColumns[i].bSearchable } );
3278	}
3279	}
3280
3281	/* Sorting */
3282	if ( oSettings.oFeatures.bSort !== false )
3283	{
3284	var iFixed = oSettings.aaSortingFixed !== null ? oSettings.aaSortingFixed.length : 0;
3285	var iUser = oSettings.aaSorting.length;
3286	aoData.push( { "name": "iSortingCols", "value": iFixed+iUser } );
3287	for ( i=0 ; i<iFixed ; i++ )
3288	{
3289	aoData.push( { "name": "iSortCol_"+i, "value": oSettings.aaSortingFixed[i][0] } );
3290	aoData.push( { "name": "sSortDir_"+i, "value": oSettings.aaSortingFixed[i][1] } );
3291	}
3292
3293	for ( i=0 ; i<iUser ; i++ )
3294	{
3295	aoData.push( { "name": "iSortCol_"+(i+iFixed), "value": oSettings.aaSorting[i][0] } );
3296	aoData.push( { "name": "sSortDir_"+(i+iFixed), "value": oSettings.aaSorting[i][1] } );
3297	}
3298
3299	for ( i=0 ; i<iColumns ; i++ )
3300	{
3301	aoData.push( { "name": "bSortable_"+i, "value": oSettings.aoColumns[i].bSortable } );
3302	}
3303	}
3304
3305	oSettings.fnServerData.call( oSettings.oInstance, oSettings.sAjaxSource, aoData,
3306	function(json) {
3307	_fnAjaxUpdateDraw( oSettings, json );
3308	} );
3309	return false;
3310	}
3311	else
3312	{
3313	return true;
3314	}
3315	}
3316
3317	/*
3318	* Function: _fnAjaxUpdateDraw
3319	* Purpose: Data the data from the server (nuking the old) and redraw the table
3320	* Returns: -
3321	* Inputs: object:oSettings - dataTables settings object
3322	* object:json - json data return from the server.
3323	* The following must be defined:
3324	* iTotalRecords, iTotalDisplayRecords, aaData
3325	* The following may be defined:
3326	* sColumns
3327	*/
3328	function _fnAjaxUpdateDraw ( oSettings, json )
3329	{
3330	if ( typeof json.sEcho != 'undefined' )
3331	{
3332	/* Protect against old returns over-writing a new one. Possible when you get
3333	* very fast interaction, and later queires are completed much faster
3334	*/
3335	if ( json.sEcho*1 < oSettings.iDraw )
3336	{
3337	return;
3338	}
3339	else
3340	{
3341	oSettings.iDraw = json.sEcho * 1;
3342	}
3343	}
3344
3345	if ( !oSettings.oScroll.bInfinite \|\|
3346	(oSettings.oScroll.bInfinite && (oSettings.bSorted \|\| oSettings.bFiltered)) )
3347	{
3348	_fnClearTable( oSettings );
3349	}
3350	oSettings._iRecordsTotal = json.iTotalRecords;
3351	oSettings._iRecordsDisplay = json.iTotalDisplayRecords;
3352
3353	/* Determine if reordering is required */
3354	var sOrdering = _fnColumnOrdering(oSettings);
3355	var bReOrder = (typeof json.sColumns != 'undefined' && sOrdering !== "" && json.sColumns != sOrdering );
3356	if ( bReOrder )
3357	{
3358	var aiIndex = _fnReOrderIndex( oSettings, json.sColumns );
3359	}
3360
3361	for ( var i=0, iLen=json.aaData.length ; i<iLen ; i++ )
3362	{
3363	if ( bReOrder )
3364	{
3365	/* If we need to re-order, then create a new array with the correct order and add it */
3366	var aData = [];
3367	for ( var j=0, jLen=oSettings.aoColumns.length ; j<jLen ; j++ )
3368	{
3369	aData.push( json.aaData[i][ aiIndex[j] ] );
3370	}
3371	_fnAddData( oSettings, aData );
3372	}
3373	else
3374	{
3375	/* No re-order required, sever got it "right" - just straight add */
3376	_fnAddData( oSettings, json.aaData[i] );
3377	}
3378	}
3379	oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
3380
3381	oSettings.bAjaxDataGet = false;
3382	_fnDraw( oSettings );
3383	oSettings.bAjaxDataGet = true;
3384	_fnProcessingDisplay( oSettings, false );
3385	}
3386
3387
3388	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
3389	* Section - Options (features) HTML
3390	*/
3391
3392	/*
3393	* Function: _fnAddOptionsHtml
3394	* Purpose: Add the options to the page HTML for the table
3395	* Returns: -
3396	* Inputs: object:oSettings - dataTables settings object
3397	*/
3398	function _fnAddOptionsHtml ( oSettings )
3399	{
3400	/*
3401	* Create a temporary, empty, div which we can later on replace with what we have generated
3402	* we do it this way to rendering the 'options' html offline - speed :-)
3403	*/
3404	var nHolding = document.createElement( 'div' );
3405	oSettings.nTable.parentNode.insertBefore( nHolding, oSettings.nTable );
3406
3407	/*
3408	* All DataTables are wrapped in a div - this is not currently optional - backwards
3409	* compatability. It can be removed if you don't want it.
3410	*/
3411	oSettings.nTableWrapper = document.createElement( 'div' );
3412	oSettings.nTableWrapper.className = oSettings.oClasses.sWrapper;
3413	if ( oSettings.sTableId !== '' )
3414	{
3415	oSettings.nTableWrapper.setAttribute( 'id', oSettings.sTableId+'_wrapper' );
3416	}
3417
3418	/* Track where we want to insert the option */
3419	var nInsertNode = oSettings.nTableWrapper;
3420
3421	/* Loop over the user set positioning and place the elements as needed */
3422	var aDom = oSettings.sDom.split('');
3423	var nTmp, iPushFeature, cOption, nNewNode, cNext, sAttr, j;
3424	for ( var i=0 ; i<aDom.length ; i++ )
3425	{
3426	iPushFeature = 0;
3427	cOption = aDom[i];
3428
3429	if ( cOption == '<' )
3430	{
3431	/* New container div */
3432	nNewNode = document.createElement( 'div' );
3433
3434	/* Check to see if we should append an id and/or a class name to the container */
3435	cNext = aDom[i+1];
3436	if ( cNext == "'" \|\| cNext == '"' )
3437	{
3438	sAttr = "";
3439	j = 2;
3440	while ( aDom[i+j] != cNext )
3441	{
3442	sAttr += aDom[i+j];
3443	j++;
3444	}
3445
3446	/* Replace jQuery UI constants */
3447	if ( sAttr == "H" )
3448	{
3449	sAttr = "fg-toolbar ui-toolbar ui-widget-header ui-corner-tl ui-corner-tr ui-helper-clearfix";
3450	}
3451	else if ( sAttr == "F" )
3452	{
3453	sAttr = "fg-toolbar ui-toolbar ui-widget-header ui-corner-bl ui-corner-br ui-helper-clearfix";
3454	}
3455
3456	/* The attribute can be in the format of "#id.class", "#id" or "class" This logic
3457	* breaks the string into parts and applies them as needed
3458	*/
3459	if ( sAttr.indexOf('.') != -1 )
3460	{
3461	var aSplit = sAttr.split('.');
3462	nNewNode.setAttribute('id', aSplit[0].substr(1, aSplit[0].length-1) );
3463	nNewNode.className = aSplit[1];
3464	}
3465	else if ( sAttr.charAt(0) == "#" )
3466	{
3467	nNewNode.setAttribute('id', sAttr.substr(1, sAttr.length-1) );
3468	}
3469	else
3470	{
3471	nNewNode.className = sAttr;
3472	}
3473
3474	i += j; /* Move along the position array */
3475	}
3476
3477	nInsertNode.appendChild( nNewNode );
3478	nInsertNode = nNewNode;
3479	}
3480	else if ( cOption == '>' )
3481	{
3482	/* End container div */
3483	nInsertNode = nInsertNode.parentNode;
3484	}
3485	else if ( cOption == 'l' && oSettings.oFeatures.bPaginate && oSettings.oFeatures.bLengthChange )
3486	{
3487	/* Length */
3488	nTmp = _fnFeatureHtmlLength( oSettings );
3489	iPushFeature = 1;
3490	}
3491	else if ( cOption == 'f' && oSettings.oFeatures.bFilter )
3492	{
3493	/* Filter */
3494	nTmp = _fnFeatureHtmlFilter( oSettings );
3495	iPushFeature = 1;
3496	}
3497	else if ( cOption == 'r' && oSettings.oFeatures.bProcessing )
3498	{
3499	/* pRocessing */
3500	nTmp = _fnFeatureHtmlProcessing( oSettings );
3501	iPushFeature = 1;
3502	}
3503	else if ( cOption == 't' )
3504	{
3505	/* Table */
3506	nTmp = _fnFeatureHtmlTable( oSettings );
3507	iPushFeature = 1;
3508	}
3509	else if ( cOption == 'i' && oSettings.oFeatures.bInfo )
3510	{
3511	/* Info */
3512	nTmp = _fnFeatureHtmlInfo( oSettings );
3513	iPushFeature = 1;
3514	}
3515	else if ( cOption == 'p' && oSettings.oFeatures.bPaginate )
3516	{
3517	/* Pagination */
3518	nTmp = _fnFeatureHtmlPaginate( oSettings );
3519	iPushFeature = 1;
3520	}
3521	else if ( _oExt.aoFeatures.length !== 0 )
3522	{
3523	/* Plug-in features */
3524	var aoFeatures = _oExt.aoFeatures;
3525	for ( var k=0, kLen=aoFeatures.length ; k<kLen ; k++ )
3526	{
3527	if ( cOption == aoFeatures[k].cFeature )
3528	{
3529	nTmp = aoFeatures[k].fnInit( oSettings );
3530	if ( nTmp )
3531	{
3532	iPushFeature = 1;
3533	}
3534	break;
3535	}
3536	}
3537	}
3538
3539	/* Add to the 2D features array */
3540	if ( iPushFeature == 1 && nTmp !== null )
3541	{
3542	if ( typeof oSettings.aanFeatures[cOption] != 'object' )
3543	{
3544	oSettings.aanFeatures[cOption] = [];
3545	}
3546	oSettings.aanFeatures[cOption].push( nTmp );
3547	nInsertNode.appendChild( nTmp );
3548	}
3549	}
3550
3551	/* Built our DOM structure - replace the holding div with what we want */
3552	nHolding.parentNode.replaceChild( oSettings.nTableWrapper, nHolding );
3553	}
3554
3555
3556	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
3557	* Section - Feature: Filtering
3558	*/
3559
3560	/*
3561	* Function: _fnFeatureHtmlTable
3562	* Purpose: Add any control elements for the table - specifically scrolling
3563	* Returns: node: - Node to add to the DOM
3564	* Inputs: object:oSettings - dataTables settings object
3565	*/
3566	function _fnFeatureHtmlTable ( oSettings )
3567	{
3568	/* Chack if scrolling is enabled or not - if not then leave the DOM unaltered */
3569	if ( oSettings.oScroll.sX === "" && oSettings.oScroll.sY === "" )
3570	{
3571	return oSettings.nTable;
3572	}
3573
3574	/*
3575	* The HTML structure that we want to generate in this function is:
3576	* div - nScroller
3577	* div - nScrollHead
3578	* div - nScrollHeadInner
3579	* table - nScrollHeadTable
3580	* thead - nThead
3581	* div - nScrollBody
3582	* table - oSettings.nTable
3583	* thead - nTheadSize
3584	* tbody - nTbody
3585	* div - nScrollFoot
3586	* div - nScrollFootInner
3587	* table - nScrollFootTable
3588	* tfoot - nTfoot
3589	*/
3590	var
3591	nScroller = document.createElement('div'),
3592	nScrollHead = document.createElement('div'),
3593	nScrollHeadInner = document.createElement('div'),
3594	nScrollBody = document.createElement('div'),
3595	nScrollFoot = document.createElement('div'),
3596	nScrollFootInner = document.createElement('div'),
3597	nScrollHeadTable = oSettings.nTable.cloneNode(false),
3598	nScrollFootTable = oSettings.nTable.cloneNode(false),
3599	nThead = oSettings.nTable.getElementsByTagName('thead')[0],
3600	nTfoot = oSettings.nTable.getElementsByTagName('tfoot').length === 0 ? null :
3601	oSettings.nTable.getElementsByTagName('tfoot')[0],
3602	oClasses = (typeof oInit.bJQueryUI != 'undefined' && oInit.bJQueryUI) ?
3603	_oExt.oJUIClasses : _oExt.oStdClasses;
3604
3605	nScrollHead.appendChild( nScrollHeadInner );
3606	nScrollFoot.appendChild( nScrollFootInner );
3607	nScrollBody.appendChild( oSettings.nTable );
3608	nScroller.appendChild( nScrollHead );
3609	nScroller.appendChild( nScrollBody );
3610	nScrollHeadInner.appendChild( nScrollHeadTable );
3611	nScrollHeadTable.appendChild( nThead );
3612	if ( nTfoot !== null )
3613	{
3614	nScroller.appendChild( nScrollFoot );
3615	nScrollFootInner.appendChild( nScrollFootTable );
3616	nScrollFootTable.appendChild( nTfoot );
3617	}
3618
3619	nScroller.className = oClasses.sScrollWrapper;
3620	nScrollHead.className = oClasses.sScrollHead;
3621	nScrollHeadInner.className = oClasses.sScrollHeadInner;
3622	nScrollBody.className = oClasses.sScrollBody;
3623	nScrollFoot.className = oClasses.sScrollFoot;
3624	nScrollFootInner.className = oClasses.sScrollFootInner;
3625
3626	if ( oSettings.oScroll.bAutoCss )
3627	{
3628	nScrollHead.style.overflow = "hidden";
3629	nScrollHead.style.position = "relative";
3630	nScrollFoot.style.overflow = "hidden";
3631	nScrollBody.style.overflow = "auto";
3632	}
3633
3634	nScrollHead.style.border = "0";
3635	nScrollHead.style.width = "100%";
3636	nScrollFoot.style.border = "0";
3637	nScrollHeadInner.style.width = "150%"; /* will be overwritten */
3638
3639	/* Modify attributes to respect the clones */
3640	nScrollHeadTable.removeAttribute('id');
3641	nScrollHeadTable.style.marginLeft = "0";
3642	oSettings.nTable.style.marginLeft = "0";
3643	if ( nTfoot !== null )
3644	{
3645	nScrollFootTable.removeAttribute('id');
3646	nScrollFootTable.style.marginLeft = "0";
3647	}
3648
3649	/* Move any caption elements from the body to the header */
3650	var nCaptions = $('>caption', oSettings.nTable);
3651	for ( var i=0, iLen=nCaptions.length ; i<iLen ; i++ )
3652	{
3653	nScrollHeadTable.appendChild( nCaptions[i] );
3654	}
3655
3656	/*
3657	* Sizing
3658	*/
3659	/* When xscrolling add the width and a scroller to move the header with the body */
3660	if ( oSettings.oScroll.sX !== "" )
3661	{
3662	nScrollHead.style.width = _fnStringToCss( oSettings.oScroll.sX );
3663	nScrollBody.style.width = _fnStringToCss( oSettings.oScroll.sX );
3664
3665	if ( nTfoot !== null )
3666	{
3667	nScrollFoot.style.width = _fnStringToCss( oSettings.oScroll.sX );
3668	}
3669
3670	/* When the body is scrolled, then we also want to scroll the headers */
3671	$(nScrollBody).scroll( function (e) {
3672	nScrollHead.scrollLeft = this.scrollLeft;
3673
3674	if ( nTfoot !== null )
3675	{
3676	nScrollFoot.scrollLeft = this.scrollLeft;
3677	}
3678	} );
3679	}
3680
3681	/* When yscrolling, add the height */
3682	if ( oSettings.oScroll.sY !== "" )
3683	{
3684	nScrollBody.style.height = _fnStringToCss( oSettings.oScroll.sY );
3685	}
3686
3687	/* Redraw - align columns across the tables */
3688	oSettings.aoDrawCallback.push( {
3689	"fn": _fnScrollDraw,
3690	"sName": "scrolling"
3691	} );
3692
3693	/* Infinite scrolling event handlers */
3694	if ( oSettings.oScroll.bInfinite )
3695	{
3696	$(nScrollBody).scroll( function() {
3697	/* Use a blocker to stop scrolling from loading more data while other data is still loading */
3698	if ( !oSettings.bDrawing )
3699	{
3700	/* Check if we should load the next data set */
3701	if ( $(this).scrollTop() + $(this).height() >
3702	$(oSettings.nTable).height() - oSettings.oScroll.iLoadGap )
3703	{
3704	/* Only do the redraw if we have to - we might be at the end of the data */
3705	if ( oSettings.fnDisplayEnd() < oSettings.fnRecordsDisplay() )
3706	{
3707	_fnPageChange( oSettings, 'next' );
3708	_fnCalculateEnd( oSettings );
3709	_fnDraw( oSettings );
3710	}
3711	}
3712	}
3713	} );
3714	}
3715
3716	oSettings.nScrollHead = nScrollHead;
3717	oSettings.nScrollFoot = nScrollFoot;
3718
3719	return nScroller;
3720	}
3721
3722	/*
3723	* Function: _fnScrollDraw
3724	* Purpose: Update the various tables for resizing
3725	* Returns: node: - Node to add to the DOM
3726	* Inputs: object:o - dataTables settings object
3727	* Notes: It's a bit of a pig this function, but basically the idea to:
3728	* 1. Re-create the table inside the scrolling div
3729	* 2. Take live measurements from the DOM
3730	* 3. Apply the measurements
3731	* 4. Clean up
3732	*/
3733	function _fnScrollDraw ( o )
3734	{
3735	var
3736	nScrollHeadInner = o.nScrollHead.getElementsByTagName('div')[0],
3737	nScrollHeadTable = nScrollHeadInner.getElementsByTagName('table')[0],
3738	nScrollBody = o.nTable.parentNode,
3739	i, iLen, j, jLen, anHeadToSize, anHeadSizers, anFootSizers, anFootToSize, oStyle, iVis,
3740	iWidth, aApplied=[], iSanityWidth;
3741
3742	/*
3743	* 1. Re-create the table inside the scrolling div
3744	*/
3745
3746	/* Remove the old minimised thead and tfoot elements in the inner table */
3747	var nTheadSize = o.nTable.getElementsByTagName('thead');
3748	if ( nTheadSize.length > 0 )
3749	{
3750	o.nTable.removeChild( nTheadSize[0] );
3751	}
3752
3753	if ( o.nTFoot !== null )
3754	{
3755	/* Remove the old minimised footer element in the cloned header */
3756	var nTfootSize = o.nTable.getElementsByTagName('tfoot');
3757	if ( nTfootSize.length > 0 )
3758	{
3759	o.nTable.removeChild( nTfootSize[0] );
3760	}
3761	}
3762
3763	/* Clone the current header and footer elements and then place it into the inner table */
3764	nTheadSize = o.nTHead.cloneNode(true);
3765	o.nTable.insertBefore( nTheadSize, o.nTable.childNodes[0] );
3766
3767	if ( o.nTFoot !== null )
3768	{
3769	nTfootSize = o.nTFoot.cloneNode(true);
3770	o.nTable.insertBefore( nTfootSize, o.nTable.childNodes[1] );
3771	}
3772
3773	/*
3774	* 2. Take live measurements from the DOM - do not alter the DOM itself!
3775	*/
3776
3777	/* Remove old sizing and apply the calculated column widths
3778	* Get the unique column headers in the newly created (cloned) header. We want to apply the
3779	* calclated sizes to this header
3780	*/
3781	var nThs = _fnGetUniqueThs( nTheadSize );
3782	for ( i=0, iLen=nThs.length ; i<iLen ; i++ )
3783	{
3784	iVis = _fnVisibleToColumnIndex( o, i );
3785	nThs[i].style.width = o.aoColumns[iVis].sWidth;
3786	}
3787
3788	if ( o.nTFoot !== null )
3789	{
3790	_fnApplyToChildren( function(n) {
3791	n.style.width = "";
3792	}, nTfootSize.getElementsByTagName('tr') );
3793	}
3794
3795	/* Size the table as a whole */
3796	iSanityWidth = $(o.nTable).outerWidth();
3797	if ( o.oScroll.sX === "" )
3798	{
3799	/* No x scrolling */
3800	o.nTable.style.width = "100%";
3801
3802	/* I know this is rubbish - but IE7 will make the width of the table when 100% include
3803	* the scrollbar - which is shouldn't. This needs feature detection in future - to do
3804	*/
3805	if ( $.browser.msie && $.browser.version <= 7 )
3806	{
3807	o.nTable.style.width = _fnStringToCss( $(o.nTable).outerWidth()-o.oScroll.iBarWidth );
3808	}
3809	}
3810	else
3811	{
3812	if ( o.oScroll.sXInner !== "" )
3813	{
3814	/* x scroll inner has been given - use it */
3815	o.nTable.style.width = _fnStringToCss(o.oScroll.sXInner);
3816	}
3817	else if ( iSanityWidth == $(nScrollBody).width() &&
3818	$(nScrollBody).height() < $(o.nTable).height() )
3819	{
3820	/* There is y-scrolling - try to take account of the y scroll bar */
3821	o.nTable.style.width = _fnStringToCss( iSanityWidth-o.oScroll.iBarWidth );
3822	if ( $(o.nTable).outerWidth() > iSanityWidth-o.oScroll.iBarWidth )
3823	{
3824	/* Not possible to take account of it */
3825	o.nTable.style.width = _fnStringToCss( iSanityWidth );
3826	}
3827	}
3828	else
3829	{
3830	/* All else fails */
3831	o.nTable.style.width = _fnStringToCss( iSanityWidth );
3832	}
3833	}
3834
3835	/* Recalculate the sanity width - now that we've applied the required width, before it was
3836	* a temporary variable. This is required because the column width calculation is done
3837	* before this table DOM is created.
3838	*/
3839	iSanityWidth = $(o.nTable).outerWidth();
3840
3841	/* We want the hidden header to have zero height, so remove padding and borders. Then
3842	* set the width based on the real headers
3843	*/
3844	anHeadToSize = o.nTHead.getElementsByTagName('tr');
3845	anHeadSizers = nTheadSize.getElementsByTagName('tr');
3846
3847	_fnApplyToChildren( function(nSizer, nToSize) {
3848	oStyle = nSizer.style;
3849	oStyle.paddingTop = "0";
3850	oStyle.paddingBottom = "0";
3851	oStyle.borderTopWidth = "0";
3852	oStyle.borderBottomWidth = "0";
3853	oStyle.height = 0;
3854
3855	iWidth = $(nSizer).width();
3856	nToSize.style.width = _fnStringToCss( iWidth );
3857	aApplied.push( iWidth );
3858	}, anHeadSizers, anHeadToSize );
3859	$(anHeadSizers).height(0);
3860
3861	if ( o.nTFoot !== null )
3862	{
3863	/* Clone the current footer and then place it into the body table as a "hidden header" */
3864	anFootSizers = nTfootSize.getElementsByTagName('tr');
3865	anFootToSize = o.nTFoot.getElementsByTagName('tr');
3866
3867	_fnApplyToChildren( function(nSizer, nToSize) {
3868	oStyle = nSizer.style;
3869	oStyle.paddingTop = "0";
3870	oStyle.paddingBottom = "0";
3871	oStyle.borderTopWidth = "0";
3872	oStyle.borderBottomWidth = "0";
3873	oStyle.height = 0;
3874
3875	iWidth = $(nSizer).width();
3876	nToSize.style.width = _fnStringToCss( iWidth );
3877	aApplied.push( iWidth );
3878	}, anFootSizers, anFootToSize );
3879	$(anFootSizers).height(0);
3880	}
3881
3882	/*
3883	* 3. Apply the measurements
3884	*/
3885
3886	/* "Hide" the header and footer that we used for the sizing. We want to also fix their width
3887	* to what they currently are
3888	*/
3889	_fnApplyToChildren( function(nSizer) {
3890	nSizer.innerHTML = "";
3891	nSizer.style.width = _fnStringToCss( aApplied.shift() );
3892	}, anHeadSizers );
3893
3894	if ( o.nTFoot !== null )
3895	{
3896	_fnApplyToChildren( function(nSizer) {
3897	nSizer.innerHTML = "";
3898	nSizer.style.width = _fnStringToCss( aApplied.shift() );
3899	}, anFootSizers );
3900	}
3901
3902	/* Sanity check that the table is of a sensible width. If not then we are going to get
3903	* misalignment
3904	*/
3905	if ( $(o.nTable).outerWidth() < iSanityWidth )
3906	{
3907	if ( o.oScroll.sX === "" )
3908	{
3909	_fnLog( o, 1, "The table cannot fit into the current element which will cause column"+
3910	" misalignment. It is suggested that you enable x-scrolling or increase the width"+
3911	" the table has in which to be drawn" );
3912	}
3913	else if ( o.oScroll.sXInner !== "" )
3914	{
3915	_fnLog( o, 1, "The table cannot fit into the current element which will cause column"+
3916	" misalignment. It is suggested that you increase the sScrollXInner property to"+
3917	" allow it to draw in a larger area, or simply remove that parameter to allow"+
3918	" automatic calculation" );
3919	}
3920	}
3921
3922
3923	/*
3924	* 4. Clean up
3925	*/
3926
3927	if ( o.oScroll.sY === "" )
3928	{
3929	/* IE7< puts a vertical scrollbar in place (when it shouldn't be) due to subtracting
3930	* the scrollbar height from the visible display, rather than adding it on. We need to
3931	* set the height in order to sort this. Don't want to do it in any other browsers.
3932	*/
3933	if ( $.browser.msie && $.browser.version <= 7 )
3934	{
3935	nScrollBody.style.height = _fnStringToCss( o.nTable.offsetHeight+o.oScroll.iBarWidth );
3936	}
3937	}
3938
3939	if ( o.oScroll.sY !== "" && o.oScroll.bCollapse )
3940	{
3941	nScrollBody.style.height = _fnStringToCss( o.oScroll.sY );
3942
3943	var iExtra = (o.oScroll.sX !== "" && o.nTable.offsetWidth > nScrollBody.offsetWidth) ?
3944	o.oScroll.iBarWidth : 0;
3945	if ( o.nTable.offsetHeight < nScrollBody.offsetHeight )
3946	{
3947	nScrollBody.style.height = _fnStringToCss( $(o.nTable).height()+iExtra );
3948	}
3949	}
3950
3951	/* Finally set the width's of the header and footer tables */
3952	var iOuterWidth = $(o.nTable).outerWidth();
3953	nScrollHeadTable.style.width = _fnStringToCss( iOuterWidth );
3954	nScrollHeadInner.style.width = _fnStringToCss( iOuterWidth+o.oScroll.iBarWidth );
3955
3956	if ( o.nTFoot !== null )
3957	{
3958	var
3959	nScrollFootInner = o.nScrollFoot.getElementsByTagName('div')[0],
3960	nScrollFootTable = nScrollFootInner.getElementsByTagName('table')[0];
3961
3962	nScrollFootInner.style.width = _fnStringToCss( o.nTable.offsetWidth+o.oScroll.iBarWidth );
3963	nScrollFootTable.style.width = _fnStringToCss( o.nTable.offsetWidth );
3964	}
3965
3966	/* If sorting or filtering has occured, jump the scrolling back to the top */
3967	if ( o.bSorted \|\| o.bFiltered )
3968	{
3969	nScrollBody.scrollTop = 0;
3970	}
3971	}
3972
3973	/*
3974	* Function: _fnAjustColumnSizing
3975	* Purpose: Ajust the table column widths for new data
3976	* Returns: -
3977	* Inputs: object:oSettings - dataTables settings object
3978	* Notes: You would probably want to do a redraw after calling this function!
3979	*/
3980	function _fnAjustColumnSizing ( oSettings )
3981	{
3982	/* Not interested in doing column width calculation if autowidth is disabled */
3983	if ( oSettings.oFeatures.bAutoWidth === false )
3984	{
3985	return false;
3986	}
3987
3988	_fnCalculateColumnWidths( oSettings );
3989	for ( var i=0 , iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
3990	{
3991	oSettings.aoColumns[i].nTh.style.width = oSettings.aoColumns[i].sWidth;
3992	}
3993	}
3994
3995
3996	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
3997	* Section - Feature: Filtering
3998	*/
3999
4000	/*
4001	* Function: _fnFeatureHtmlFilter
4002	* Purpose: Generate the node required for filtering text
4003	* Returns: node
4004	* Inputs: object:oSettings - dataTables settings object
4005	*/
4006	function _fnFeatureHtmlFilter ( oSettings )
4007	{
4008	var nFilter = document.createElement( 'div' );
4009	if ( oSettings.sTableId !== '' && typeof oSettings.aanFeatures.f == "undefined" )
4010	{
4011	nFilter.setAttribute( 'id', oSettings.sTableId+'_filter' );
4012	}
4013	nFilter.className = oSettings.oClasses.sFilter;
4014	var sSpace = oSettings.oLanguage.sSearch==="" ? "" : " ";
4015	nFilter.innerHTML = oSettings.oLanguage.sSearch+sSpace+'<input type="text" />';
4016
4017	var jqFilter = $("input", nFilter);
4018	jqFilter.val( oSettings.oPreviousSearch.sSearch.replace('"','"') );
4019	jqFilter.bind( 'keyup.DT', function(e) {
4020	/* Update all other filter input elements for the new display */
4021	var n = oSettings.aanFeatures.f;
4022	for ( var i=0, iLen=n.length ; i<iLen ; i++ )
4023	{
4024	if ( n[i] != this.parentNode )
4025	{
4026	$('input', n[i]).val( this.value );
4027	}
4028	}
4029
4030	/* Now do the filter */
4031	if ( this.value != oSettings.oPreviousSearch.sSearch )
4032	{
4033	_fnFilterComplete( oSettings, {
4034	"sSearch": this.value,
4035	"bRegex": oSettings.oPreviousSearch.bRegex,
4036	"bSmart": oSettings.oPreviousSearch.bSmart
4037	} );
4038	}
4039	} );
4040
4041	jqFilter.bind( 'keypress.DT', function(e) {
4042	/* Prevent default */
4043	if ( e.keyCode == 13 )
4044	{
4045	return false;
4046	}
4047	} );
4048
4049	return nFilter;
4050	}
4051
4052	/*
4053	* Function: _fnFilterComplete
4054	* Purpose: Filter the table using both the global filter and column based filtering
4055	* Returns: -
4056	* Inputs: object:oSettings - dataTables settings object
4057	* object:oSearch: search information
4058	* int:iForce - optional - force a research of the master array (1) or not (undefined or 0)
4059	*/
4060	function _fnFilterComplete ( oSettings, oInput, iForce )
4061	{
4062	/* Filter on everything */
4063	_fnFilter( oSettings, oInput.sSearch, iForce, oInput.bRegex, oInput.bSmart );
4064
4065	/* Now do the individual column filter */
4066	for ( var i=0 ; i<oSettings.aoPreSearchCols.length ; i++ )
4067	{
4068	_fnFilterColumn( oSettings, oSettings.aoPreSearchCols[i].sSearch, i,
4069	oSettings.aoPreSearchCols[i].bRegex, oSettings.aoPreSearchCols[i].bSmart );
4070	}
4071
4072	/* Custom filtering */
4073	if ( _oExt.afnFiltering.length !== 0 )
4074	{
4075	_fnFilterCustom( oSettings );
4076	}
4077
4078	/* Tell the draw function we have been filtering */
4079	oSettings.bFiltered = true;
4080
4081	/* Redraw the table */
4082	oSettings._iDisplayStart = 0;
4083	_fnCalculateEnd( oSettings );
4084	_fnDraw( oSettings );
4085
4086	/* Rebuild search array 'offline' */
4087	_fnBuildSearchArray( oSettings, 0 );
4088	}
4089
4090	/*
4091	* Function: _fnFilterCustom
4092	* Purpose: Apply custom filtering functions
4093	* Returns: -
4094	* Inputs: object:oSettings - dataTables settings object
4095	*/
4096	function _fnFilterCustom( oSettings )
4097	{
4098	var afnFilters = _oExt.afnFiltering;
4099	for ( var i=0, iLen=afnFilters.length ; i<iLen ; i++ )
4100	{
4101	var iCorrector = 0;
4102	for ( var j=0, jLen=oSettings.aiDisplay.length ; j<jLen ; j++ )
4103	{
4104	var iDisIndex = oSettings.aiDisplay[j-iCorrector];
4105
4106	/* Check if we should use this row based on the filtering function */
4107	if ( !afnFilters[i]( oSettings, oSettings.aoData[iDisIndex]._aData, iDisIndex ) )
4108	{
4109	oSettings.aiDisplay.splice( j-iCorrector, 1 );
4110	iCorrector++;
4111	}
4112	}
4113	}
4114	}
4115
4116	/*
4117	* Function: _fnFilterColumn
4118	* Purpose: Filter the table on a per-column basis
4119	* Returns: -
4120	* Inputs: object:oSettings - dataTables settings object
4121	* string:sInput - string to filter on
4122	* int:iColumn - column to filter
4123	* bool:bRegex - treat search string as a regular expression or not
4124	* bool:bSmart - use smart filtering or not
4125	*/
4126	function _fnFilterColumn ( oSettings, sInput, iColumn, bRegex, bSmart )
4127	{
4128	if ( sInput === "" )
4129	{
4130	return;
4131	}
4132
4133	var iIndexCorrector = 0;
4134	var rpSearch = _fnFilterCreateSearch( sInput, bRegex, bSmart );
4135
4136	for ( var i=oSettings.aiDisplay.length-1 ; i>=0 ; i-- )
4137	{
4138	var sData = _fnDataToSearch( oSettings.aoData[ oSettings.aiDisplay[i] ]._aData[iColumn],
4139	oSettings.aoColumns[iColumn].sType );
4140	if ( ! rpSearch.test( sData ) )
4141	{
4142	oSettings.aiDisplay.splice( i, 1 );
4143	iIndexCorrector++;
4144	}
4145	}
4146	}
4147
4148	/*
4149	* Function: _fnFilter
4150	* Purpose: Filter the data table based on user input and draw the table
4151	* Returns: -
4152	* Inputs: object:oSettings - dataTables settings object
4153	* string:sInput - string to filter on
4154	* int:iForce - optional - force a research of the master array (1) or not (undefined or 0)
4155	* bool:bRegex - treat as a regular expression or not
4156	* bool:bSmart - perform smart filtering or not
4157	*/
4158	function _fnFilter( oSettings, sInput, iForce, bRegex, bSmart )
4159	{
4160	var i;
4161	var rpSearch = _fnFilterCreateSearch( sInput, bRegex, bSmart );
4162
4163	/* Check if we are forcing or not - optional parameter */
4164	if ( typeof iForce == 'undefined' \|\| iForce === null )
4165	{
4166	iForce = 0;
4167	}
4168
4169	/* Need to take account of custom filtering functions - always filter */
4170	if ( _oExt.afnFiltering.length !== 0 )
4171	{
4172	iForce = 1;
4173	}
4174
4175	/*
4176	* If the input is blank - we want the full data set
4177	*/
4178	if ( sInput.length <= 0 )
4179	{
4180	oSettings.aiDisplay.splice( 0, oSettings.aiDisplay.length);
4181	oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
4182	}
4183	else
4184	{
4185	/*
4186	* We are starting a new search or the new search string is smaller
4187	* then the old one (i.e. delete). Search from the master array
4188	*/
4189	if ( oSettings.aiDisplay.length == oSettings.aiDisplayMaster.length \|\|
4190	oSettings.oPreviousSearch.sSearch.length > sInput.length \|\| iForce == 1 \|\|
4191	sInput.indexOf(oSettings.oPreviousSearch.sSearch) !== 0 )
4192	{
4193	/* Nuke the old display array - we are going to rebuild it */
4194	oSettings.aiDisplay.splice( 0, oSettings.aiDisplay.length);
4195
4196	/* Force a rebuild of the search array */
4197	_fnBuildSearchArray( oSettings, 1 );
4198
4199	/* Search through all records to populate the search array
4200	* The the oSettings.aiDisplayMaster and asDataSearch arrays have 1 to 1
4201	* mapping
4202	*/
4203	for ( i=0 ; i<oSettings.aiDisplayMaster.length ; i++ )
4204	{
4205	if ( rpSearch.test(oSettings.asDataSearch[i]) )
4206	{
4207	oSettings.aiDisplay.push( oSettings.aiDisplayMaster[i] );
4208	}
4209	}
4210	}
4211	else
4212	{
4213	/* Using old search array - refine it - do it this way for speed
4214	* Don't have to search the whole master array again
4215	*/
4216	var iIndexCorrector = 0;
4217
4218	/* Search the current results */
4219	for ( i=0 ; i<oSettings.asDataSearch.length ; i++ )
4220	{
4221	if ( ! rpSearch.test(oSettings.asDataSearch[i]) )
4222	{
4223	oSettings.aiDisplay.splice( i-iIndexCorrector, 1 );
4224	iIndexCorrector++;
4225	}
4226	}
4227	}
4228	}
4229	oSettings.oPreviousSearch.sSearch = sInput;
4230	oSettings.oPreviousSearch.bRegex = bRegex;
4231	oSettings.oPreviousSearch.bSmart = bSmart;
4232	}
4233
4234	/*
4235	* Function: _fnBuildSearchArray
4236	* Purpose: Create an array which can be quickly search through
4237	* Returns: -
4238	* Inputs: object:oSettings - dataTables settings object
4239	* int:iMaster - use the master data array - optional
4240	*/
4241	function _fnBuildSearchArray ( oSettings, iMaster )
4242	{
4243	/* Clear out the old data */
4244	oSettings.asDataSearch.splice( 0, oSettings.asDataSearch.length );
4245
4246	var aArray = (typeof iMaster != 'undefined' && iMaster == 1) ?
4247	oSettings.aiDisplayMaster : oSettings.aiDisplay;
4248
4249	for ( var i=0, iLen=aArray.length ; i<iLen ; i++ )
4250	{
4251	oSettings.asDataSearch[i] = _fnBuildSearchRow( oSettings,
4252	oSettings.aoData[ aArray[i] ]._aData );
4253	}
4254	}
4255
4256	/*
4257	* Function: _fnBuildSearchRow
4258	* Purpose: Create a searchable string from a single data row
4259	* Returns: -
4260	* Inputs: object:oSettings - dataTables settings object
4261	* array:aData - aoData[]._aData array to use for the data to search
4262	*/
4263	function _fnBuildSearchRow( oSettings, aData )
4264	{
4265	var sSearch = '';
4266	var nTmp = document.createElement('div');
4267
4268	for ( var j=0, jLen=oSettings.aoColumns.length ; j<jLen ; j++ )
4269	{
4270	if ( oSettings.aoColumns[j].bSearchable )
4271	{
4272	var sData = aData[j];
4273	sSearch += _fnDataToSearch( sData, oSettings.aoColumns[j].sType )+' ';
4274	}
4275	}
4276
4277	/* If it looks like there is an HTML entity in the string, attempt to decode it */
4278	if ( sSearch.indexOf('&') !== -1 )
4279	{
4280	nTmp.innerHTML = sSearch;
4281	sSearch = nTmp.textContent ? nTmp.textContent : nTmp.innerText;
4282
4283	/* IE and Opera appear to put an newline where there is a <br> tag - remove it */
4284	sSearch = sSearch.replace(/\n/g," ").replace(/\r/g,"");
4285	}
4286
4287	return sSearch;
4288	}
4289
4290	/*
4291	* Function: _fnFilterCreateSearch
4292	* Purpose: Build a regular expression object suitable for searching a table
4293	* Returns: RegExp: - constructed object
4294	* Inputs: string:sSearch - string to search for
4295	* bool:bRegex - treat as a regular expression or not
4296	* bool:bSmart - perform smart filtering or not
4297	*/
4298	function _fnFilterCreateSearch( sSearch, bRegex, bSmart )
4299	{
4300	var asSearch, sRegExpString;
4301
4302	if ( bSmart )
4303	{
4304	/* Generate the regular expression to use. Something along the lines of:
4305	* ^(?=.?\bone\b)(?=.?\btwo\b)(?=.?\bthree\b).$
4306	*/
4307	asSearch = bRegex ? sSearch.split( ' ' ) : _fnEscapeRegex( sSearch ).split( ' ' );
4308	sRegExpString = '^(?=.?'+asSearch.join( ')(?=.?' )+').*$';
4309	return new RegExp( sRegExpString, "i" );
4310	}
4311	else
4312	{
4313	sSearch = bRegex ? sSearch : _fnEscapeRegex( sSearch );
4314	return new RegExp( sSearch, "i" );
4315	}
4316	}
4317
4318	/*
4319	* Function: _fnDataToSearch
4320	* Purpose: Convert raw data into something that the user can search on
4321	* Returns: string: - search string
4322	* Inputs: string:sData - data to be modified
4323	* string:sType - data type
4324	*/
4325	function _fnDataToSearch ( sData, sType )
4326	{
4327	if ( typeof _oExt.ofnSearch[sType] == "function" )
4328	{
4329	return _oExt.ofnSearch[sType]( sData );
4330	}
4331	else if ( sType == "html" )
4332	{
4333	return sData.replace(/\n/g," ").replace( /<.*?>/g, "" );
4334	}
4335	else if ( typeof sData == "string" )
4336	{
4337	return sData.replace(/\n/g," ");
4338	}
4339	return sData;
4340	}
4341
4342
4343	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
4344	* Section - Feature: Sorting
4345	*/
4346
4347	/*
4348	* Function: _fnSort
4349	* Purpose: Change the order of the table
4350	* Returns: -
4351	* Inputs: object:oSettings - dataTables settings object
4352	* bool:bApplyClasses - optional - should we apply classes or not
4353	* Notes: We always sort the master array and then apply a filter again
4354	* if it is needed. This probably isn't optimal - but atm I can't think
4355	* of any other way which is (each has disadvantages). we want to sort aiDisplayMaster -
4356	* but according to aoData[]._aData
4357	*/
4358	function _fnSort ( oSettings, bApplyClasses )
4359	{
4360	var
4361	iDataSort, iDataType,
4362	i, iLen, j, jLen,
4363	aaSort = [],
4364	aiOrig = [],
4365	oSort = _oExt.oSort,
4366	aoData = oSettings.aoData,
4367	aoColumns = oSettings.aoColumns;
4368
4369	/* No sorting required if server-side or no sorting array */
4370	if ( !oSettings.oFeatures.bServerSide &&
4371	(oSettings.aaSorting.length !== 0 \|\| oSettings.aaSortingFixed !== null) )
4372	{
4373	if ( oSettings.aaSortingFixed !== null )
4374	{
4375	aaSort = oSettings.aaSortingFixed.concat( oSettings.aaSorting );
4376	}
4377	else
4378	{
4379	aaSort = oSettings.aaSorting.slice();
4380	}
4381
4382	/* If there is a sorting data type, and a fuction belonging to it, then we need to
4383	* get the data from the developer's function and apply it for this column
4384	*/
4385	for ( i=0 ; i<aaSort.length ; i++ )
4386	{
4387	var iColumn = aaSort[i][0];
4388	var iVisColumn = _fnColumnIndexToVisible( oSettings, iColumn );
4389	var sDataType = oSettings.aoColumns[ iColumn ].sSortDataType;
4390	if ( typeof _oExt.afnSortData[sDataType] != 'undefined' )
4391	{
4392	var aData = _oExt.afnSortData[sDataType]( oSettings, iColumn, iVisColumn );
4393	for ( j=0, jLen=aoData.length ; j<jLen ; j++ )
4394	{
4395	aoData[j]._aData[iColumn] = aData[j];
4396	}
4397	}
4398	}
4399
4400	/* Create a value - key array of the current row positions such that we can use their
4401	* current position during the sort, if values match, in order to perform stable sorting
4402	*/
4403	for ( i=0, iLen=oSettings.aiDisplayMaster.length ; i<iLen ; i++ )
4404	{
4405	aiOrig[ oSettings.aiDisplayMaster[i] ] = i;
4406	}
4407
4408	/* Do the sort - here we want multi-column sorting based on a given data source (column)
4409	* and sorting function (from oSort) in a certain direction. It's reasonably complex to
4410	* follow on it's own, but this is what we want (example two column sorting):
4411	* fnLocalSorting = function(a,b){
4412	* var iTest;
4413	* iTest = oSort['string-asc']('data11', 'data12');
4414	* if (iTest !== 0)
4415	* return iTest;
4416	* iTest = oSort['numeric-desc']('data21', 'data22');
4417	* if (iTest !== 0)
4418	* return iTest;
4419	* return oSort['numeric-asc']( aiOrig[a], aiOrig[b] );
4420	* }
4421	* Basically we have a test for each sorting column, if the data in that column is equal,
4422	* test the next column. If all columns match, then we use a numeric sort on the row
4423	* positions in the original data array to provide a stable sort.
4424	*/
4425	var iSortLen = aaSort.length;
4426	oSettings.aiDisplayMaster.sort( function ( a, b ) {
4427	var iTest;
4428	for ( i=0 ; i<iSortLen ; i++ )
4429	{
4430	iDataSort = aoColumns[ aaSort[i][0] ].iDataSort;
4431	iDataType = aoColumns[ iDataSort ].sType;
4432	iTest = oSort[ iDataType+"-"+aaSort[i][1] ](
4433	aoData[a]._aData[iDataSort],
4434	aoData[b]._aData[iDataSort]
4435	);
4436
4437	if ( iTest !== 0 )
4438	{
4439	return iTest;
4440	}
4441	}
4442
4443	return oSort['numeric-asc']( aiOrig[a], aiOrig[b] );
4444	} );
4445	}
4446
4447	/* Alter the sorting classes to take account of the changes */
4448	if ( typeof bApplyClasses == 'undefined' \|\| bApplyClasses )
4449	{
4450	_fnSortingClasses( oSettings );
4451	}
4452
4453	/* Tell the draw function that we have sorted the data */
4454	oSettings.bSorted = true;
4455
4456	/* Copy the master data into the draw array and re-draw */
4457	if ( oSettings.oFeatures.bFilter )
4458	{
4459	/* _fnFilter() will redraw the table for us */
4460	_fnFilterComplete( oSettings, oSettings.oPreviousSearch, 1 );
4461	}
4462	else
4463	{
4464	oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
4465	oSettings._iDisplayStart = 0; /* reset display back to page 0 */
4466	_fnCalculateEnd( oSettings );
4467	_fnDraw( oSettings );
4468	}
4469	}
4470
4471	/*
4472	* Function: _fnSortAttachListener
4473	* Purpose: Attach a sort handler (click) to a node
4474	* Returns: -
4475	* Inputs: object:oSettings - dataTables settings object
4476	* node:nNode - node to attach the handler to
4477	* int:iDataIndex - column sorting index
4478	* function:fnCallback - callback function - optional
4479	*/
4480	function _fnSortAttachListener ( oSettings, nNode, iDataIndex, fnCallback )
4481	{
4482	$(nNode).bind( 'click.DT', function (e) {
4483	/* If the column is not sortable - don't to anything */
4484	if ( oSettings.aoColumns[iDataIndex].bSortable === false )
4485	{
4486	return;
4487	}
4488
4489	/*
4490	* This is a little bit odd I admit... I declare a temporary function inside the scope of
4491	* _fnDrawHead and the click handler in order that the code presented here can be used
4492	* twice - once for when bProcessing is enabled, and another time for when it is
4493	* disabled, as we need to perform slightly different actions.
4494	* Basically the issue here is that the Javascript engine in modern browsers don't
4495	* appear to allow the rendering engine to update the display while it is still excuting
4496	* it's thread (well - it does but only after long intervals). This means that the
4497	* 'processing' display doesn't appear for a table sort. To break the js thread up a bit
4498	* I force an execution break by using setTimeout - but this breaks the expected
4499	* thread continuation for the end-developer's point of view (their code would execute
4500	* too early), so we on;y do it when we absolutely have to.
4501	*/
4502	var fnInnerSorting = function () {
4503	var iColumn, iNextSort;
4504
4505	/* If the shift key is pressed then we are multipe column sorting */
4506	if ( e.shiftKey )
4507	{
4508	/* Are we already doing some kind of sort on this column? */
4509	var bFound = false;
4510	for ( var i=0 ; i<oSettings.aaSorting.length ; i++ )
4511	{
4512	if ( oSettings.aaSorting[i][0] == iDataIndex )
4513	{
4514	bFound = true;
4515	iColumn = oSettings.aaSorting[i][0];
4516	iNextSort = oSettings.aaSorting[i][2]+1;
4517
4518	if ( typeof oSettings.aoColumns[iColumn].asSorting[iNextSort] == 'undefined' )
4519	{
4520	/* Reached the end of the sorting options, remove from multi-col sort */
4521	oSettings.aaSorting.splice( i, 1 );
4522	}
4523	else
4524	{
4525	/* Move onto next sorting direction */
4526	oSettings.aaSorting[i][1] = oSettings.aoColumns[iColumn].asSorting[iNextSort];
4527	oSettings.aaSorting[i][2] = iNextSort;
4528	}
4529	break;
4530	}
4531	}
4532
4533	/* No sort yet - add it in */
4534	if ( bFound === false )
4535	{
4536	oSettings.aaSorting.push( [ iDataIndex,
4537	oSettings.aoColumns[iDataIndex].asSorting[0], 0 ] );
4538	}
4539	}
4540	else
4541	{
4542	/* If no shift key then single column sort */
4543	if ( oSettings.aaSorting.length == 1 && oSettings.aaSorting[0][0] == iDataIndex )
4544	{
4545	iColumn = oSettings.aaSorting[0][0];
4546	iNextSort = oSettings.aaSorting[0][2]+1;
4547	if ( typeof oSettings.aoColumns[iColumn].asSorting[iNextSort] == 'undefined' )
4548	{
4549	iNextSort = 0;
4550	}
4551	oSettings.aaSorting[0][1] = oSettings.aoColumns[iColumn].asSorting[iNextSort];
4552	oSettings.aaSorting[0][2] = iNextSort;
4553	}
4554	else
4555	{
4556	oSettings.aaSorting.splice( 0, oSettings.aaSorting.length );
4557	oSettings.aaSorting.push( [ iDataIndex,
4558	oSettings.aoColumns[iDataIndex].asSorting[0], 0 ] );
4559	}
4560	}
4561
4562	/* Run the sort */
4563	_fnSort( oSettings );
4564	}; /* /fnInnerSorting */
4565
4566	if ( !oSettings.oFeatures.bProcessing )
4567	{
4568	fnInnerSorting();
4569	}
4570	else
4571	{
4572	_fnProcessingDisplay( oSettings, true );
4573	setTimeout( function() {
4574	fnInnerSorting();
4575	if ( !oSettings.oFeatures.bServerSide )
4576	{
4577	_fnProcessingDisplay( oSettings, false );
4578	}
4579	}, 0 );
4580	}
4581
4582	/* Call the user specified callback function - used for async user interaction */
4583	if ( typeof fnCallback == 'function' )
4584	{
4585	fnCallback( oSettings );
4586	}
4587	} );
4588	}
4589
4590	/*
4591	* Function: _fnSortingClasses
4592	* Purpose: Set the sortting classes on the header
4593	* Returns: -
4594	* Inputs: object:oSettings - dataTables settings object
4595	* Notes: It is safe to call this function when bSort and bSortClasses are false
4596	*/
4597	function _fnSortingClasses( oSettings )
4598	{
4599	var i, iLen, j, jLen, iFound;
4600	var aaSort, sClass;
4601	var iColumns = oSettings.aoColumns.length;
4602	var oClasses = oSettings.oClasses;
4603
4604	for ( i=0 ; i<iColumns ; i++ )
4605	{
4606	if ( oSettings.aoColumns[i].bSortable )
4607	{
4608	$(oSettings.aoColumns[i].nTh).removeClass( oClasses.sSortAsc +" "+ oClasses.sSortDesc +
4609	" "+ oSettings.aoColumns[i].sSortingClass );
4610	}
4611	}
4612
4613	if ( oSettings.aaSortingFixed !== null )
4614	{
4615	aaSort = oSettings.aaSortingFixed.concat( oSettings.aaSorting );
4616	}
4617	else
4618	{
4619	aaSort = oSettings.aaSorting.slice();
4620	}
4621
4622	/* Apply the required classes to the header */
4623	for ( i=0 ; i<oSettings.aoColumns.length ; i++ )
4624	{
4625	if ( oSettings.aoColumns[i].bSortable )
4626	{
4627	sClass = oSettings.aoColumns[i].sSortingClass;
4628	iFound = -1;
4629	for ( j=0 ; j<aaSort.length ; j++ )
4630	{
4631	if ( aaSort[j][0] == i )
4632	{
4633	sClass = ( aaSort[j][1] == "asc" ) ?
4634	oClasses.sSortAsc : oClasses.sSortDesc;
4635	iFound = j;
4636	break;
4637	}
4638	}
4639	$(oSettings.aoColumns[i].nTh).addClass( sClass );
4640
4641	if ( oSettings.bJUI )
4642	{
4643	/* jQuery UI uses extra markup */
4644	var jqSpan = $("span", oSettings.aoColumns[i].nTh);
4645	jqSpan.removeClass(oClasses.sSortJUIAsc +" "+ oClasses.sSortJUIDesc +" "+
4646	oClasses.sSortJUI +" "+ oClasses.sSortJUIAscAllowed +" "+ oClasses.sSortJUIDescAllowed );
4647
4648	var sSpanClass;
4649	if ( iFound == -1 )
4650	{
4651	sSpanClass = oSettings.aoColumns[i].sSortingClassJUI;
4652	}
4653	else if ( aaSort[iFound][1] == "asc" )
4654	{
4655	sSpanClass = oClasses.sSortJUIAsc;
4656	}
4657	else
4658	{
4659	sSpanClass = oClasses.sSortJUIDesc;
4660	}
4661
4662	jqSpan.addClass( sSpanClass );
4663	}
4664	}
4665	else
4666	{
4667	/* No sorting on this column, so add the base class. This will have been assigned by
4668	* _fnAddColumn
4669	*/
4670	$(oSettings.aoColumns[i].nTh).addClass( oSettings.aoColumns[i].sSortingClass );
4671	}
4672	}
4673
4674	/*
4675	* Apply the required classes to the table body
4676	* Note that this is given as a feature switch since it can significantly slow down a sort
4677	* on large data sets (adding and removing of classes is always slow at the best of times..)
4678	* Further to this, note that this code is admitadly fairly ugly. It could be made a lot
4679	* simpiler using jQuery selectors and add/removeClass, but that is significantly slower
4680	* (on the order of 5 times slower) - hence the direct DOM manipulation here.
4681	*/
4682	sClass = oClasses.sSortColumn;
4683
4684	if ( oSettings.oFeatures.bSort && oSettings.oFeatures.bSortClasses )
4685	{
4686	var nTds = _fnGetTdNodes( oSettings );
4687
4688	/* Remove the old classes */
4689	if ( nTds.length >= iColumns )
4690	{
4691	for ( i=0 ; i<iColumns ; i++ )
4692	{
4693	if ( nTds[i].className.indexOf(sClass+"1") != -1 )
4694	{
4695	for ( j=0, jLen=(nTds.length/iColumns) ; j<jLen ; j++ )
4696	{
4697	nTds[(iColumns*j)+i].className =
4698	$.trim( nTds[(iColumns*j)+i].className.replace( sClass+"1", "" ) );
4699	}
4700	}
4701	else if ( nTds[i].className.indexOf(sClass+"2") != -1 )
4702	{
4703	for ( j=0, jLen=(nTds.length/iColumns) ; j<jLen ; j++ )
4704	{
4705	nTds[(iColumns*j)+i].className =
4706	$.trim( nTds[(iColumns*j)+i].className.replace( sClass+"2", "" ) );
4707	}
4708	}
4709	else if ( nTds[i].className.indexOf(sClass+"3") != -1 )
4710	{
4711	for ( j=0, jLen=(nTds.length/iColumns) ; j<jLen ; j++ )
4712	{
4713	nTds[(iColumns*j)+i].className =
4714	$.trim( nTds[(iColumns*j)+i].className.replace( " "+sClass+"3", "" ) );
4715	}
4716	}
4717	}
4718	}
4719
4720	/* Add the new classes to the table */
4721	var iClass = 1, iTargetCol;
4722	for ( i=0 ; i<aaSort.length ; i++ )
4723	{
4724	iTargetCol = parseInt( aaSort[i][0], 10 );
4725	for ( j=0, jLen=(nTds.length/iColumns) ; j<jLen ; j++ )
4726	{
4727	nTds[(iColumns*j)+iTargetCol].className += " "+sClass+iClass;
4728	}
4729
4730	if ( iClass < 3 )
4731	{
4732	iClass++;
4733	}
4734	}
4735	}
4736	}
4737
4738
4739	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
4740	* Section - Feature: Pagination. Note that most of the paging logic is done in
4741	* _oExt.oPagination
4742	*/
4743
4744	/*
4745	* Function: _fnFeatureHtmlPaginate
4746	* Purpose: Generate the node required for default pagination
4747	* Returns: node
4748	* Inputs: object:oSettings - dataTables settings object
4749	*/
4750	function _fnFeatureHtmlPaginate ( oSettings )
4751	{
4752	if ( oSettings.oScroll.bInfinite )
4753	{
4754	return null;
4755	}
4756
4757	var nPaginate = document.createElement( 'div' );
4758	nPaginate.className = oSettings.oClasses.sPaging+oSettings.sPaginationType;
4759
4760	_oExt.oPagination[ oSettings.sPaginationType ].fnInit( oSettings, nPaginate,
4761	function( oSettings ) {
4762	_fnCalculateEnd( oSettings );
4763	_fnDraw( oSettings );
4764	}
4765	);
4766
4767	/* Add a draw callback for the pagination on first instance, to update the paging display */
4768	if ( typeof oSettings.aanFeatures.p == "undefined" )
4769	{
4770	oSettings.aoDrawCallback.push( {
4771	"fn": function( oSettings ) {
4772	_oExt.oPagination[ oSettings.sPaginationType ].fnUpdate( oSettings, function( oSettings ) {
4773	_fnCalculateEnd( oSettings );
4774	_fnDraw( oSettings );
4775	} );
4776	},
4777	"sName": "pagination"
4778	} );
4779	}
4780	return nPaginate;
4781	}
4782
4783	/*
4784	* Function: _fnPageChange
4785	* Purpose: Alter the display settings to change the page
4786	* Returns: bool:true - page has changed, false - no change (no effect) eg 'first' on page 1
4787	* Inputs: object:oSettings - dataTables settings object
4788	* string:sAction - paging action to take: "first", "previous", "next" or "last"
4789	*/
4790	function _fnPageChange ( oSettings, sAction )
4791	{
4792	var iOldStart = oSettings._iDisplayStart;
4793
4794	if ( sAction == "first" )
4795	{
4796	oSettings._iDisplayStart = 0;
4797	}
4798	else if ( sAction == "previous" )
4799	{
4800	oSettings._iDisplayStart = oSettings._iDisplayLength>=0 ?
4801	oSettings._iDisplayStart - oSettings._iDisplayLength :
4802	0;
4803
4804	/* Correct for underrun */
4805	if ( oSettings._iDisplayStart < 0 )
4806	{
4807	oSettings._iDisplayStart = 0;
4808	}
4809	}
4810	else if ( sAction == "next" )
4811	{
4812	if ( oSettings._iDisplayLength >= 0 )
4813	{
4814	/* Make sure we are not over running the display array */
4815	if ( oSettings._iDisplayStart + oSettings._iDisplayLength < oSettings.fnRecordsDisplay() )
4816	{
4817	oSettings._iDisplayStart += oSettings._iDisplayLength;
4818	}
4819	}
4820	else
4821	{
4822	oSettings._iDisplayStart = 0;
4823	}
4824	}
4825	else if ( sAction == "last" )
4826	{
4827	if ( oSettings._iDisplayLength >= 0 )
4828	{
4829	var iPages = parseInt( (oSettings.fnRecordsDisplay()-1) / oSettings._iDisplayLength, 10 ) + 1;
4830	oSettings._iDisplayStart = (iPages-1) * oSettings._iDisplayLength;
4831	}
4832	else
4833	{
4834	oSettings._iDisplayStart = 0;
4835	}
4836	}
4837	else
4838	{
4839	_fnLog( oSettings, 0, "Unknown paging action: "+sAction );
4840	}
4841
4842	return iOldStart != oSettings._iDisplayStart;
4843	}
4844
4845
4846	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
4847	* Section - Feature: HTML info
4848	*/
4849
4850	/*
4851	* Function: _fnFeatureHtmlInfo
4852	* Purpose: Generate the node required for the info display
4853	* Returns: node
4854	* Inputs: object:oSettings - dataTables settings object
4855	*/
4856	function _fnFeatureHtmlInfo ( oSettings )
4857	{
4858	var nInfo = document.createElement( 'div' );
4859	nInfo.className = oSettings.oClasses.sInfo;
4860
4861	/* Actions that are to be taken once only for this feature */
4862	if ( typeof oSettings.aanFeatures.i == "undefined" )
4863	{
4864	/* Add draw callback */
4865	oSettings.aoDrawCallback.push( {
4866	"fn": _fnUpdateInfo,
4867	"sName": "information"
4868	} );
4869
4870	/* Add id */
4871	if ( oSettings.sTableId !== '' )
4872	{
4873	nInfo.setAttribute( 'id', oSettings.sTableId+'_info' );
4874	}
4875	}
4876
4877	return nInfo;
4878	}
4879
4880	/*
4881	* Function: _fnUpdateInfo
4882	* Purpose: Update the information elements in the display
4883	* Returns: -
4884	* Inputs: object:oSettings - dataTables settings object
4885	*/
4886	function _fnUpdateInfo ( oSettings )
4887	{
4888	/* Show information about the table */
4889	if ( !oSettings.oFeatures.bInfo \|\| oSettings.aanFeatures.i.length === 0 )
4890	{
4891	return;
4892	}
4893
4894	var
4895	iStart = oSettings._iDisplayStart+1, iEnd = oSettings.fnDisplayEnd(),
4896	iMax = oSettings.fnRecordsTotal(), iTotal = oSettings.fnRecordsDisplay(),
4897	sStart = oSettings.fnFormatNumber( iStart ), sEnd = oSettings.fnFormatNumber( iEnd ),
4898	sMax = oSettings.fnFormatNumber( iMax ), sTotal = oSettings.fnFormatNumber( iTotal ),
4899	sOut;
4900
4901	/* When infinite scrolling, we are always starting at 1. _iDisplayStart is used only
4902	* internally
4903	*/
4904	if ( oSettings.oScroll.bInfinite )
4905	{
4906	sStart = oSettings.fnFormatNumber( 1 );
4907	}
4908
4909	if ( oSettings.fnRecordsDisplay() === 0 &&
4910	oSettings.fnRecordsDisplay() == oSettings.fnRecordsTotal() )
4911	{
4912	/* Empty record set */
4913	sOut = oSettings.oLanguage.sInfoEmpty+ oSettings.oLanguage.sInfoPostFix;
4914	}
4915	else if ( oSettings.fnRecordsDisplay() === 0 )
4916	{
4917	/* Rmpty record set after filtering */
4918	sOut = oSettings.oLanguage.sInfoEmpty +' '+
4919	oSettings.oLanguage.sInfoFiltered.replace('_MAX_', sMax)+
4920	oSettings.oLanguage.sInfoPostFix;
4921	}
4922	else if ( oSettings.fnRecordsDisplay() == oSettings.fnRecordsTotal() )
4923	{
4924	/* Normal record set */
4925	sOut = oSettings.oLanguage.sInfo.
4926	replace('_START_', sStart).
4927	replace('_END_', sEnd).
4928	replace('_TOTAL_', sTotal)+
4929	oSettings.oLanguage.sInfoPostFix;
4930	}
4931	else
4932	{
4933	/* Record set after filtering */
4934	sOut = oSettings.oLanguage.sInfo.
4935	replace('_START_', sStart).
4936	replace('_END_', sEnd).
4937	replace('_TOTAL_', sTotal) +' '+
4938	oSettings.oLanguage.sInfoFiltered.replace('_MAX_',
4939	oSettings.fnFormatNumber(oSettings.fnRecordsTotal()))+
4940	oSettings.oLanguage.sInfoPostFix;
4941	}
4942
4943	if ( oSettings.oLanguage.fnInfoCallback !== null )
4944	{
4945	sOut = oSettings.oLanguage.fnInfoCallback( oSettings, iStart, iEnd, iMax, iTotal, sOut );
4946	}
4947
4948	var n = oSettings.aanFeatures.i;
4949	for ( var i=0, iLen=n.length ; i<iLen ; i++ )
4950	{
4951	$(n[i]).html( sOut );
4952	}
4953	}
4954
4955
4956	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
4957	* Section - Feature: Length change
4958	*/
4959
4960	/*
4961	* Function: _fnFeatureHtmlLength
4962	* Purpose: Generate the node required for user display length changing
4963	* Returns: node
4964	* Inputs: object:oSettings - dataTables settings object
4965	*/
4966	function _fnFeatureHtmlLength ( oSettings )
4967	{
4968	if ( oSettings.oScroll.bInfinite )
4969	{
4970	return null;
4971	}
4972
4973	/* This can be overruled by not using the _MENU_ var/macro in the language variable */
4974	var sName = (oSettings.sTableId === "") ? "" : 'name="'+oSettings.sTableId+'_length"';
4975	var sStdMenu = '<select size="1" '+sName+'>';
4976	var i, iLen;
4977
4978	if ( oSettings.aLengthMenu.length == 2 && typeof oSettings.aLengthMenu[0] == 'object' &&
4979	typeof oSettings.aLengthMenu[1] == 'object' )
4980	{
4981	for ( i=0, iLen=oSettings.aLengthMenu[0].length ; i<iLen ; i++ )
4982	{
4983	sStdMenu += '<option value="'+oSettings.aLengthMenu[0][i]+'">'+
4984	oSettings.aLengthMenu[1][i]+'</option>';
4985	}
4986	}
4987	else
4988	{
4989	for ( i=0, iLen=oSettings.aLengthMenu.length ; i<iLen ; i++ )
4990	{
4991	sStdMenu += '<option value="'+oSettings.aLengthMenu[i]+'">'+
4992	oSettings.aLengthMenu[i]+'</option>';
4993	}
4994	}
4995	sStdMenu += '</select>';
4996
4997	var nLength = document.createElement( 'div' );
4998	if ( oSettings.sTableId !== '' && typeof oSettings.aanFeatures.l == "undefined" )
4999	{
5000	nLength.setAttribute( 'id', oSettings.sTableId+'_length' );
5001	}
5002	nLength.className = oSettings.oClasses.sLength;
5003	nLength.innerHTML = oSettings.oLanguage.sLengthMenu.replace( '_MENU_', sStdMenu );
5004
5005	/*
5006	* Set the length to the current display length - thanks to Andrea Pavlovic for this fix,
5007	* and Stefan Skopnik for fixing the fix!
5008	*/
5009	$('select option[value="'+oSettings._iDisplayLength+'"]',nLength).attr("selected",true);
5010
5011	$('select', nLength).bind( 'change.DT', function(e) {
5012	var iVal = $(this).val();
5013
5014	/* Update all other length options for the new display */
5015	var n = oSettings.aanFeatures.l;
5016	for ( i=0, iLen=n.length ; i<iLen ; i++ )
5017	{
5018	if ( n[i] != this.parentNode )
5019	{
5020	$('select', n[i]).val( iVal );
5021	}
5022	}
5023
5024	/* Redraw the table */
5025	oSettings._iDisplayLength = parseInt(iVal, 10);
5026	_fnCalculateEnd( oSettings );
5027
5028	/* If we have space to show extra rows (backing up from the end point - then do so */
5029	if ( oSettings.fnDisplayEnd() == oSettings.fnRecordsDisplay() )
5030	{
5031	oSettings._iDisplayStart = oSettings.fnDisplayEnd() - oSettings._iDisplayLength;
5032	if ( oSettings._iDisplayStart < 0 )
5033	{
5034	oSettings._iDisplayStart = 0;
5035	}
5036	}
5037
5038	if ( oSettings._iDisplayLength == -1 )
5039	{
5040	oSettings._iDisplayStart = 0;
5041	}
5042
5043	_fnDraw( oSettings );
5044	} );
5045
5046	return nLength;
5047	}
5048
5049
5050	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
5051	* Section - Feature: Processing incidator
5052	*/
5053
5054	/*
5055	* Function: _fnFeatureHtmlProcessing
5056	* Purpose: Generate the node required for the processing node
5057	* Returns: node
5058	* Inputs: object:oSettings - dataTables settings object
5059	*/
5060	function _fnFeatureHtmlProcessing ( oSettings )
5061	{
5062	var nProcessing = document.createElement( 'div' );
5063
5064	if ( oSettings.sTableId !== '' && typeof oSettings.aanFeatures.r == "undefined" )
5065	{
5066	nProcessing.setAttribute( 'id', oSettings.sTableId+'_processing' );
5067	}
5068	nProcessing.innerHTML = oSettings.oLanguage.sProcessing;
5069	nProcessing.className = oSettings.oClasses.sProcessing;
5070	oSettings.nTable.parentNode.insertBefore( nProcessing, oSettings.nTable );
5071
5072	return nProcessing;
5073	}
5074
5075	/*
5076	* Function: _fnProcessingDisplay
5077	* Purpose: Display or hide the processing indicator
5078	* Returns: -
5079	* Inputs: object:oSettings - dataTables settings object
5080	* bool:
5081	* true - show the processing indicator
5082	* false - don't show
5083	*/
5084	function _fnProcessingDisplay ( oSettings, bShow )
5085	{
5086	if ( oSettings.oFeatures.bProcessing )
5087	{
5088	var an = oSettings.aanFeatures.r;
5089	for ( var i=0, iLen=an.length ; i<iLen ; i++ )
5090	{
5091	an[i].style.visibility = bShow ? "visible" : "hidden";
5092	}
5093	}
5094	}
5095
5096
5097	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
5098	* Section - Support functions
5099	*/
5100
5101	/*
5102	* Function: _fnVisibleToColumnIndex
5103	* Purpose: Covert the index of a visible column to the index in the data array (take account
5104	* of hidden columns)
5105	* Returns: int:i - the data index
5106	* Inputs: object:oSettings - dataTables settings object
5107	*/
5108	function _fnVisibleToColumnIndex( oSettings, iMatch )
5109	{
5110	var iColumn = -1;
5111
5112	for ( var i=0 ; i<oSettings.aoColumns.length ; i++ )
5113	{
5114	if ( oSettings.aoColumns[i].bVisible === true )
5115	{
5116	iColumn++;
5117	}
5118
5119	if ( iColumn == iMatch )
5120	{
5121	return i;
5122	}
5123	}
5124
5125	return null;
5126	}
5127
5128	/*
5129	* Function: _fnColumnIndexToVisible
5130	* Purpose: Covert the index of an index in the data array and convert it to the visible
5131	* column index (take account of hidden columns)
5132	* Returns: int:i - the data index
5133	* Inputs: object:oSettings - dataTables settings object
5134	*/
5135	function _fnColumnIndexToVisible( oSettings, iMatch )
5136	{
5137	var iVisible = -1;
5138	for ( var i=0 ; i<oSettings.aoColumns.length ; i++ )
5139	{
5140	if ( oSettings.aoColumns[i].bVisible === true )
5141	{
5142	iVisible++;
5143	}
5144
5145	if ( i == iMatch )
5146	{
5147	return oSettings.aoColumns[i].bVisible === true ? iVisible : null;
5148	}
5149	}
5150
5151	return null;
5152	}
5153
5154
5155	/*
5156	* Function: _fnNodeToDataIndex
5157	* Purpose: Take a TR element and convert it to an index in aoData
5158	* Returns: int:i - index if found, null if not
5159	* Inputs: object:s - dataTables settings object
5160	* node:n - the TR element to find
5161	*/
5162	function _fnNodeToDataIndex( s, n )
5163	{
5164	var i, iLen;
5165
5166	/* Optimisation - see if the nodes which are currently visible match, since that is
5167	* the most likely node to be asked for (a selector or event for example)
5168	*/
5169	for ( i=s._iDisplayStart, iLen=s._iDisplayEnd ; i<iLen ; i++ )
5170	{
5171	if ( s.aoData[ s.aiDisplay[i] ].nTr == n )
5172	{
5173	return s.aiDisplay[i];
5174	}
5175	}
5176
5177	/* Otherwise we are in for a slog through the whole data cache */
5178	for ( i=0, iLen=s.aoData.length ; i<iLen ; i++ )
5179	{
5180	if ( s.aoData[i].nTr == n )
5181	{
5182	return i;
5183	}
5184	}
5185	return null;
5186	}
5187
5188	/*
5189	* Function: _fnVisbleColumns
5190	* Purpose: Get the number of visible columns
5191	* Returns: int:i - the number of visible columns
5192	* Inputs: object:oS - dataTables settings object
5193	*/
5194	function _fnVisbleColumns( oS )
5195	{
5196	var iVis = 0;
5197	for ( var i=0 ; i<oS.aoColumns.length ; i++ )
5198	{
5199	if ( oS.aoColumns[i].bVisible === true )
5200	{
5201	iVis++;
5202	}
5203	}
5204	return iVis;
5205	}
5206
5207	/*
5208	* Function: _fnCalculateEnd
5209	* Purpose: Rcalculate the end point based on the start point
5210	* Returns: -
5211	* Inputs: object:oSettings - dataTables settings object
5212	*/
5213	function _fnCalculateEnd( oSettings )
5214	{
5215	if ( oSettings.oFeatures.bPaginate === false )
5216	{
5217	oSettings._iDisplayEnd = oSettings.aiDisplay.length;
5218	}
5219	else
5220	{
5221	/* Set the end point of the display - based on how many elements there are
5222	* still to display
5223	*/
5224	if ( oSettings._iDisplayStart + oSettings._iDisplayLength > oSettings.aiDisplay.length \|\|
5225	oSettings._iDisplayLength == -1 )
5226	{
5227	oSettings._iDisplayEnd = oSettings.aiDisplay.length;
5228	}
5229	else
5230	{
5231	oSettings._iDisplayEnd = oSettings._iDisplayStart + oSettings._iDisplayLength;
5232	}
5233	}
5234	}
5235
5236	/*
5237	* Function: _fnConvertToWidth
5238	* Purpose: Convert a CSS unit width to pixels (e.g. 2em)
5239	* Returns: int:iWidth - width in pixels
5240	* Inputs: string:sWidth - width to be converted
5241	* node:nParent - parent to get the with for (required for
5242	* relative widths) - optional
5243	*/
5244	function _fnConvertToWidth ( sWidth, nParent )
5245	{
5246	if ( !sWidth \|\| sWidth === null \|\| sWidth === '' )
5247	{
5248	return 0;
5249	}
5250
5251	if ( typeof nParent == "undefined" )
5252	{
5253	nParent = document.getElementsByTagName('body')[0];
5254	}
5255
5256	var iWidth;
5257	var nTmp = document.createElement( "div" );
5258	nTmp.style.width = sWidth;
5259
5260	nParent.appendChild( nTmp );
5261	iWidth = nTmp.offsetWidth;
5262	nParent.removeChild( nTmp );
5263
5264	return ( iWidth );
5265	}
5266
5267	/*
5268	* Function: _fnCalculateColumnWidths
5269	* Purpose: Calculate the width of columns for the table
5270	* Returns: -
5271	* Inputs: object:oSettings - dataTables settings object
5272	*/
5273	function _fnCalculateColumnWidths ( oSettings )
5274	{
5275	var iTableWidth = oSettings.nTable.offsetWidth;
5276	var iUserInputs = 0;
5277	var iTmpWidth;
5278	var iVisibleColumns = 0;
5279	var iColums = oSettings.aoColumns.length;
5280	var i;
5281	var oHeaders = $('th', oSettings.nTHead);
5282
5283	/* Convert any user input sizes into pixel sizes */
5284	for ( i=0 ; i<iColums ; i++ )
5285	{
5286	if ( oSettings.aoColumns[i].bVisible )
5287	{
5288	iVisibleColumns++;
5289
5290	if ( oSettings.aoColumns[i].sWidth !== null )
5291	{
5292	iTmpWidth = _fnConvertToWidth( oSettings.aoColumns[i].sWidthOrig,
5293	oSettings.nTable.parentNode );
5294	if ( iTmpWidth !== null )
5295	{
5296	oSettings.aoColumns[i].sWidth = _fnStringToCss( iTmpWidth );
5297	}
5298
5299	iUserInputs++;
5300	}
5301	}
5302	}
5303
5304	/* If the number of columns in the DOM equals the number that we have to process in
5305	* DataTables, then we can use the offsets that are created by the web-browser. No custom
5306	* sizes can be set in order for this to happen, nor scrolling used
5307	*/
5308	if ( iColums == oHeaders.length && iUserInputs === 0 && iVisibleColumns == iColums &&
5309	oSettings.oScroll.sX === "" && oSettings.oScroll.sY === "" )
5310	{
5311	for ( i=0 ; i<oSettings.aoColumns.length ; i++ )
5312	{
5313	iTmpWidth = $(oHeaders[i]).width();
5314	if ( iTmpWidth !== null )
5315	{
5316	oSettings.aoColumns[i].sWidth = _fnStringToCss( iTmpWidth );
5317	}
5318	}
5319	}
5320	else
5321	{
5322	/* Otherwise we are going to have to do some calculations to get the width of each column.
5323	* Construct a 1 row table with the widest node in the data, and any user defined widths,
5324	* then insert it into the DOM and allow the browser to do all the hard work of
5325	* calculating table widths.
5326	*/
5327	var
5328	nCalcTmp = oSettings.nTable.cloneNode( false ),
5329	nBody = document.createElement( 'tbody' ),
5330	nTr = document.createElement( 'tr' ),
5331	nDivSizing;
5332
5333	nCalcTmp.removeAttribute( "id" );
5334	nCalcTmp.appendChild( oSettings.nTHead.cloneNode(true) );
5335	if ( oSettings.nTFoot !== null )
5336	{
5337	nCalcTmp.appendChild( oSettings.nTFoot.cloneNode(true) );
5338	_fnApplyToChildren( function(n) {
5339	n.style.width = "";
5340	}, nCalcTmp.getElementsByTagName('tr') );
5341	}
5342
5343	nCalcTmp.appendChild( nBody );
5344	nBody.appendChild( nTr );
5345
5346	/* Remove any sizing that was previously applied by the styles */
5347	var jqColSizing = $('thead th', nCalcTmp);
5348	if ( jqColSizing.length === 0 )
5349	{
5350	jqColSizing = $('tbody tr:eq(0)>td', nCalcTmp);
5351	}
5352	jqColSizing.each( function (i) {
5353	this.style.width = "";
5354
5355	var iIndex = _fnVisibleToColumnIndex( oSettings, i );
5356	if ( iIndex !== null && oSettings.aoColumns[iIndex].sWidthOrig !== "" )
5357	{
5358	this.style.width = oSettings.aoColumns[iIndex].sWidthOrig;
5359	}
5360	} );
5361
5362	/* Find the biggest td for each column and put it into the table */
5363	for ( i=0 ; i<iColums ; i++ )
5364	{
5365	if ( oSettings.aoColumns[i].bVisible )
5366	{
5367	var nTd = _fnGetWidestNode( oSettings, i );
5368	if ( nTd !== null )
5369	{
5370	nTd = nTd.cloneNode(true);
5371	nTr.appendChild( nTd );
5372	}
5373	}
5374	}
5375
5376	/* Build the table and 'display' it */
5377	var nWrapper = oSettings.nTable.parentNode;
5378	nWrapper.appendChild( nCalcTmp );
5379
5380	/* When scrolling (X or Y) we want to set the width of the table as appropriate. However,
5381	* when not scrolling leave the table width as it is. This results in slightly different,
5382	* but I think correct behaviour
5383	*/
5384	if ( oSettings.oScroll.sX !== "" && oSettings.oScroll.sXInner !== "" )
5385	{
5386	nCalcTmp.style.width = _fnStringToCss(oSettings.oScroll.sXInner);
5387	}
5388	else if ( oSettings.oScroll.sX !== "" )
5389	{
5390	nCalcTmp.style.width = "";
5391	if ( $(nCalcTmp).width() < nWrapper.offsetWidth )
5392	{
5393	nCalcTmp.style.width = _fnStringToCss( nWrapper.offsetWidth );
5394	}
5395	}
5396	else if ( oSettings.oScroll.sY !== "" )
5397	{
5398	nCalcTmp.style.width = _fnStringToCss( nWrapper.offsetWidth );
5399	}
5400	nCalcTmp.style.visibility = "hidden";
5401
5402	/* Scrolling considerations */
5403	_fnScrollingWidthAdjust( oSettings, nCalcTmp );
5404
5405	/* Read the width's calculated by the browser and store them for use by the caller. We
5406	* first of all try to use the elements in the body, but it is possible that there are
5407	* no elements there, under which circumstances we use the header elements
5408	*/
5409	var oNodes = $("tbody tr:eq(0)>td", nCalcTmp);
5410	if ( oNodes.length === 0 )
5411	{
5412	oNodes = $("thead tr:eq(0)>th", nCalcTmp);
5413	}
5414
5415	var iIndex, iCorrector = 0, iWidth;
5416	for ( i=0 ; i<oSettings.aoColumns.length ; i++ )
5417	{
5418	if ( oSettings.aoColumns[i].bVisible )
5419	{
5420	iWidth = $(oNodes[iCorrector]).outerWidth();
5421	if ( iWidth !== null && iWidth > 0 )
5422	{
5423	oSettings.aoColumns[i].sWidth = _fnStringToCss( iWidth );
5424	}
5425	iCorrector++;
5426	}
5427	}
5428
5429	oSettings.nTable.style.width = _fnStringToCss( $(nCalcTmp).outerWidth() );
5430	nCalcTmp.parentNode.removeChild( nCalcTmp );
5431	}
5432	}
5433
5434	/*
5435	* Function: _fnScrollingWidthAdjust
5436	* Purpose: Adjust a table's width to take account of scrolling
5437	* Returns: -
5438	* Inputs: object:oSettings - dataTables settings object
5439	* node:n - table node
5440	*/
5441	function _fnScrollingWidthAdjust ( oSettings, n )
5442	{
5443	if ( oSettings.oScroll.sX === "" && oSettings.oScroll.sY !== "" )
5444	{
5445	/* When y-scrolling only, we want to remove the width of the scroll bar so the table
5446	* + scroll bar will fit into the area avaialble.
5447	*/
5448	var iOrigWidth = $(n).width();
5449	n.style.width = _fnStringToCss( $(n).outerWidth()-oSettings.oScroll.iBarWidth );
5450	}
5451	else if ( oSettings.oScroll.sX !== "" )
5452	{
5453	/* When x-scrolling both ways, fix the table at it's current size, without adjusting */
5454	n.style.width = _fnStringToCss( $(n).outerWidth() );
5455	}
5456	}
5457
5458	/*
5459	* Function: _fnGetWidestNode
5460	* Purpose: Get the widest node
5461	* Returns: string: - max strlens for each column
5462	* Inputs: object:oSettings - dataTables settings object
5463	* int:iCol - column of interest
5464	* boolean:bFast - Should we use fast (but non-accurate) calculation - optional,
5465	* default true
5466	* Notes: This operation is _expensive_ (!!!). It requires a lot of DOM interaction, but
5467	* this is the only way to reliably get the widest string. For example 'mmm' would be wider
5468	* than 'iiii' so we can't just ocunt characters. If this can be optimised it would be good
5469	* to do so!
5470	*/
5471	function _fnGetWidestNode( oSettings, iCol, bFast )
5472	{
5473	/* Use fast not non-accurate calculate based on the strlen */
5474	if ( typeof bFast == 'undefined' \|\| bFast )
5475	{
5476	var iMaxLen = _fnGetMaxLenString( oSettings, iCol );
5477	var iFastVis = _fnColumnIndexToVisible( oSettings, iCol);
5478	if ( iMaxLen < 0 )
5479	{
5480	return null;
5481	}
5482	return oSettings.aoData[iMaxLen].nTr.getElementsByTagName('td')[iFastVis];
5483	}
5484
5485	/* Use the slow approach, but get high quality answers - note that this code is not actually
5486	* used by DataTables by default. If you want to use it you can alter the call to
5487	* _fnGetWidestNode to pass 'false' as the third argument
5488	*/
5489	var
5490	iMax = -1, i, iLen,
5491	iMaxIndex = -1,
5492	n = document.createElement('div');
5493
5494	n.style.visibility = "hidden";
5495	n.style.position = "absolute";
5496	document.body.appendChild( n );
5497
5498	for ( i=0, iLen=oSettings.aoData.length ; i<iLen ; i++ )
5499	{
5500	n.innerHTML = oSettings.aoData[i]._aData[iCol];
5501	if ( n.offsetWidth > iMax )
5502	{
5503	iMax = n.offsetWidth;
5504	iMaxIndex = i;
5505	}
5506	}
5507	document.body.removeChild( n );
5508
5509	if ( iMaxIndex >= 0 )
5510	{
5511	var iVis = _fnColumnIndexToVisible( oSettings, iCol);
5512	var nRet = oSettings.aoData[iMaxIndex].nTr.getElementsByTagName('td')[iVis];
5513	if ( nRet )
5514	{
5515	return nRet;
5516	}
5517	}
5518	return null;
5519	}
5520
5521	/*
5522	* Function: _fnGetMaxLenString
5523	* Purpose: Get the maximum strlen for each data column
5524	* Returns: string: - max strlens for each column
5525	* Inputs: object:oSettings - dataTables settings object
5526	* int:iCol - column of interest
5527	*/
5528	function _fnGetMaxLenString( oSettings, iCol )
5529	{
5530	var iMax = -1;
5531	var iMaxIndex = -1;
5532
5533	for ( var i=0 ; i<oSettings.aoData.length ; i++ )
5534	{
5535	var s = oSettings.aoData[i]._aData[iCol];
5536	if ( s.length > iMax )
5537	{
5538	iMax = s.length;
5539	iMaxIndex = i;
5540	}
5541	}
5542
5543	return iMaxIndex;
5544	}
5545
5546	/*
5547	* Function: _fnStringToCss
5548	* Purpose: Append a CSS unit (only if required) to a string
5549	* Returns: 0 if match, 1 if length is different, 2 if no match
5550	* Inputs: array:aArray1 - first array
5551	* array:aArray2 - second array
5552	*/
5553	function _fnStringToCss( s )
5554	{
5555	if ( s === null )
5556	{
5557	return "0px";
5558	}
5559
5560	if ( typeof s == 'number' )
5561	{
5562	if ( s < 0 )
5563	{
5564	return "0px";
5565	}
5566	return s+"px";
5567	}
5568
5569	/* Check if the last character is not 0-9 */
5570	var c = s.charCodeAt( s.length-1 );
5571	if (c < 0x30 \|\| c > 0x39)
5572	{
5573	return s;
5574	}
5575	return s+"px";
5576	}
5577
5578	/*
5579	* Function: _fnArrayCmp
5580	* Purpose: Compare two arrays
5581	* Returns: 0 if match, 1 if length is different, 2 if no match
5582	* Inputs: array:aArray1 - first array
5583	* array:aArray2 - second array
5584	*/
5585	function _fnArrayCmp( aArray1, aArray2 )
5586	{
5587	if ( aArray1.length != aArray2.length )
5588	{
5589	return 1;
5590	}
5591
5592	for ( var i=0 ; i<aArray1.length ; i++ )
5593	{
5594	if ( aArray1[i] != aArray2[i] )
5595	{
5596	return 2;
5597	}
5598	}
5599
5600	return 0;
5601	}
5602
5603	/*
5604	* Function: _fnDetectType
5605	* Purpose: Get the sort type based on an input string
5606	* Returns: string: - type (defaults to 'string' if no type can be detected)
5607	* Inputs: string:sData - data we wish to know the type of
5608	* Notes: This function makes use of the DataTables plugin objct _oExt
5609	* (.aTypes) such that new types can easily be added.
5610	*/
5611	function _fnDetectType( sData )
5612	{
5613	var aTypes = _oExt.aTypes;
5614	var iLen = aTypes.length;
5615
5616	for ( var i=0 ; i<iLen ; i++ )
5617	{
5618	var sType = aTypes[i]( sData );
5619	if ( sType !== null )
5620	{
5621	return sType;
5622	}
5623	}
5624
5625	return 'string';
5626	}
5627
5628	/*
5629	* Function: _fnSettingsFromNode
5630	* Purpose: Return the settings object for a particular table
5631	* Returns: object: Settings object - or null if not found
5632	* Inputs: node:nTable - table we are using as a dataTable
5633	*/
5634	function _fnSettingsFromNode ( nTable )
5635	{
5636	for ( var i=0 ; i<_aoSettings.length ; i++ )
5637	{
5638	if ( _aoSettings[i].nTable == nTable )
5639	{
5640	return _aoSettings[i];
5641	}
5642	}
5643
5644	return null;
5645	}
5646
5647	/*
5648	* Function: _fnGetDataMaster
5649	* Purpose: Return an array with the full table data
5650	* Returns: array array:aData - Master data array
5651	* Inputs: object:oSettings - dataTables settings object
5652	*/
5653	function _fnGetDataMaster ( oSettings )
5654	{
5655	var aData = [];
5656	var iLen = oSettings.aoData.length;
5657	for ( var i=0 ; i<iLen; i++ )
5658	{
5659	aData.push( oSettings.aoData[i]._aData );
5660	}
5661	return aData;
5662	}
5663
5664	/*
5665	* Function: _fnGetTrNodes
5666	* Purpose: Return an array with the TR nodes for the table
5667	* Returns: array: - TR array
5668	* Inputs: object:oSettings - dataTables settings object
5669	*/
5670	function _fnGetTrNodes ( oSettings )
5671	{
5672	var aNodes = [];
5673	var iLen = oSettings.aoData.length;
5674	for ( var i=0 ; i<iLen ; i++ )
5675	{
5676	aNodes.push( oSettings.aoData[i].nTr );
5677	}
5678	return aNodes;
5679	}
5680
5681	/*
5682	* Function: _fnGetTdNodes
5683	* Purpose: Return an array with the TD nodes for the table
5684	* Returns: array: - TD array
5685	* Inputs: object:oSettings - dataTables settings object
5686	*/
5687	function _fnGetTdNodes ( oSettings )
5688	{
5689	var nTrs = _fnGetTrNodes( oSettings );
5690	var nTds = [], nTd;
5691	var anReturn = [];
5692	var iCorrector;
5693	var iRow, iRows, iColumn, iColumns;
5694
5695	for ( iRow=0, iRows=nTrs.length ; iRow<iRows ; iRow++ )
5696	{
5697	nTds = [];
5698	for ( iColumn=0, iColumns=nTrs[iRow].childNodes.length ; iColumn<iColumns ; iColumn++ )
5699	{
5700	nTd = nTrs[iRow].childNodes[iColumn];
5701	if ( nTd.nodeName.toUpperCase() == "TD" )
5702	{
5703	nTds.push( nTd );
5704	}
5705	}
5706
5707	iCorrector = 0;
5708	for ( iColumn=0, iColumns=oSettings.aoColumns.length ; iColumn<iColumns ; iColumn++ )
5709	{
5710	if ( oSettings.aoColumns[iColumn].bVisible )
5711	{
5712	anReturn.push( nTds[iColumn-iCorrector] );
5713	}
5714	else
5715	{
5716	anReturn.push( oSettings.aoData[iRow]._anHidden[iColumn] );
5717	iCorrector++;
5718	}
5719	}
5720	}
5721	return anReturn;
5722	}
5723
5724	/*
5725	* Function: _fnEscapeRegex
5726	* Purpose: scape a string stuch that it can be used in a regular expression
5727	* Returns: string: - escaped string
5728	* Inputs: string:sVal - string to escape
5729	*/
5730	function _fnEscapeRegex ( sVal )
5731	{
5732	var acEscape = [ '/', '.', '*', '+', '?', '\|', '(', ')', '[', ']', '{', '}', '\\', '$', '^' ];
5733	var reReplace = new RegExp( '(\\' + acEscape.join('\|\\') + ')', 'g' );
5734	return sVal.replace(reReplace, '\\$1');
5735	}
5736
5737	/*
5738	* Function: _fnDeleteIndex
5739	* Purpose: Take an array of integers (index array) and remove a target integer (value - not
5740	* the key!)
5741	* Returns: -
5742	* Inputs: a:array int - Index array to target
5743	* int:iTarget - value to find
5744	*/
5745	function _fnDeleteIndex( a, iTarget )
5746	{
5747	var iTargetIndex = -1;
5748
5749	for ( var i=0, iLen=a.length ; i<iLen ; i++ )
5750	{
5751	if ( a[i] == iTarget )
5752	{
5753	iTargetIndex = i;
5754	}
5755	else if ( a[i] > iTarget )
5756	{
5757	a[i]--;
5758	}
5759	}
5760
5761	if ( iTargetIndex != -1 )
5762	{
5763	a.splice( iTargetIndex, 1 );
5764	}
5765	}
5766
5767	/*
5768	* Function: _fnReOrderIndex
5769	* Purpose: Figure out how to reorder a display list
5770	* Returns: array int:aiReturn - index list for reordering
5771	* Inputs: object:oSettings - dataTables settings object
5772	*/
5773	function _fnReOrderIndex ( oSettings, sColumns )
5774	{
5775	var aColumns = sColumns.split(',');
5776	var aiReturn = [];
5777
5778	for ( var i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
5779	{
5780	for ( var j=0 ; j<iLen ; j++ )
5781	{
5782	if ( oSettings.aoColumns[i].sName == aColumns[j] )
5783	{
5784	aiReturn.push( j );
5785	break;
5786	}
5787	}
5788	}
5789
5790	return aiReturn;
5791	}
5792
5793	/*
5794	* Function: _fnColumnOrdering
5795	* Purpose: Get the column ordering that DataTables expects
5796	* Returns: string: - comma separated list of names
5797	* Inputs: object:oSettings - dataTables settings object
5798	*/
5799	function _fnColumnOrdering ( oSettings )
5800	{
5801	var sNames = '';
5802	for ( var i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
5803	{
5804	sNames += oSettings.aoColumns[i].sName+',';
5805	}
5806	if ( sNames.length == iLen )
5807	{
5808	return "";
5809	}
5810	return sNames.slice(0, -1);
5811	}
5812
5813	/*
5814	* Function: _fnLog
5815	* Purpose: Log an error message
5816	* Returns: -
5817	* Inputs: int:iLevel - log error messages, or display them to the user
5818	* string:sMesg - error message
5819	*/
5820	function _fnLog( oSettings, iLevel, sMesg )
5821	{
5822	var sAlert = oSettings.sTableId === "" ?
5823	"DataTables warning: " +sMesg :
5824	"DataTables warning (table id = '"+oSettings.sTableId+"'): " +sMesg;
5825
5826	if ( iLevel === 0 )
5827	{
5828	if ( _oExt.sErrMode == 'alert' )
5829	{
5830	alert( sAlert );
5831	}
5832	else
5833	{
5834	throw sAlert;
5835	}
5836	return;
5837	}
5838	else if ( typeof console != 'undefined' && typeof console.log != 'undefined' )
5839	{
5840	console.log( sAlert );
5841	}
5842	}
5843
5844	/*
5845	* Function: _fnClearTable
5846	* Purpose: Nuke the table
5847	* Returns: -
5848	* Inputs: object:oSettings - dataTables settings object
5849	*/
5850	function _fnClearTable( oSettings )
5851	{
5852	oSettings.aoData.splice( 0, oSettings.aoData.length );
5853	oSettings.aiDisplayMaster.splice( 0, oSettings.aiDisplayMaster.length );
5854	oSettings.aiDisplay.splice( 0, oSettings.aiDisplay.length );
5855	_fnCalculateEnd( oSettings );
5856	}
5857
5858	/*
5859	* Function: _fnSaveState
5860	* Purpose: Save the state of a table in a cookie such that the page can be reloaded
5861	* Returns: -
5862	* Inputs: object:oSettings - dataTables settings object
5863	*/
5864	function _fnSaveState ( oSettings )
5865	{
5866	if ( !oSettings.oFeatures.bStateSave \|\| typeof oSettings.bDestroying != 'undefined' )
5867	{
5868	return;
5869	}
5870
5871	/* Store the interesting variables */
5872	var i, iLen, sTmp;
5873	var sValue = "{";
5874	sValue += '"iCreate":'+ new Date().getTime()+',';
5875	sValue += '"iStart":'+ oSettings._iDisplayStart+',';
5876	sValue += '"iEnd":'+ oSettings._iDisplayEnd+',';
5877	sValue += '"iLength":'+ oSettings._iDisplayLength+',';
5878	sValue += '"sFilter":"'+ encodeURIComponent(oSettings.oPreviousSearch.sSearch)+'",';
5879	sValue += '"sFilterEsc":'+ !oSettings.oPreviousSearch.bRegex+',';
5880
5881	sValue += '"aaSorting":[ ';
5882	for ( i=0 ; i<oSettings.aaSorting.length ; i++ )
5883	{
5884	sValue += '['+oSettings.aaSorting[i][0]+',"'+oSettings.aaSorting[i][1]+'"],';
5885	}
5886	sValue = sValue.substring(0, sValue.length-1);
5887	sValue += "],";
5888
5889	sValue += '"aaSearchCols":[ ';
5890	for ( i=0 ; i<oSettings.aoPreSearchCols.length ; i++ )
5891	{
5892	sValue += '["'+encodeURIComponent(oSettings.aoPreSearchCols[i].sSearch)+
5893	'",'+!oSettings.aoPreSearchCols[i].bRegex+'],';
5894	}
5895	sValue = sValue.substring(0, sValue.length-1);
5896	sValue += "],";
5897
5898	sValue += '"abVisCols":[ ';
5899	for ( i=0 ; i<oSettings.aoColumns.length ; i++ )
5900	{
5901	sValue += oSettings.aoColumns[i].bVisible+",";
5902	}
5903	sValue = sValue.substring(0, sValue.length-1);
5904	sValue += "]";
5905
5906	/* Save state from any plug-ins */
5907	for ( i=0, iLen=oSettings.aoStateSave.length ; i<iLen ; i++ )
5908	{
5909	sTmp = oSettings.aoStateSave[i].fn( oSettings, sValue );
5910	if ( sTmp !== "" )
5911	{
5912	sValue = sTmp;
5913	}
5914	}
5915
5916	sValue += "}";
5917
5918	_fnCreateCookie( oSettings.sCookiePrefix+oSettings.sInstance, sValue,
5919	oSettings.iCookieDuration, oSettings.sCookiePrefix, oSettings.fnCookieCallback );
5920	}
5921
5922	/*
5923	* Function: _fnLoadState
5924	* Purpose: Attempt to load a saved table state from a cookie
5925	* Returns: -
5926	* Inputs: object:oSettings - dataTables settings object
5927	* object:oInit - DataTables init object so we can override settings
5928	*/
5929	function _fnLoadState ( oSettings, oInit )
5930	{
5931	if ( !oSettings.oFeatures.bStateSave )
5932	{
5933	return;
5934	}
5935
5936	var oData, i, iLen;
5937	var sData = _fnReadCookie( oSettings.sCookiePrefix+oSettings.sInstance );
5938	if ( sData !== null && sData !== '' )
5939	{
5940	/* Try/catch the JSON eval - if it is bad then we ignore it - note that 1.7.0 and before
5941	* incorrectly used single quotes for some strings - hence the replace below
5942	*/
5943	try
5944	{
5945	oData = (typeof $.parseJSON == 'function') ?
5946	$.parseJSON( sData.replace(/'/g, '"') ) : eval( '('+sData+')' );
5947	}
5948	catch( e )
5949	{
5950	return;
5951	}
5952
5953	/* Allow custom and plug-in manipulation functions to alter the data set which was
5954	* saved, and also reject any saved state by returning false
5955	*/
5956	for ( i=0, iLen=oSettings.aoStateLoad.length ; i<iLen ; i++ )
5957	{
5958	if ( !oSettings.aoStateLoad[i].fn( oSettings, oData ) )
5959	{
5960	return;
5961	}
5962	}
5963
5964	/* Store the saved state so it might be accessed at any time (particualrly a plug-in */
5965	oSettings.oLoadedState = $.extend( true, {}, oData );
5966
5967	/* Restore key features */
5968	oSettings._iDisplayStart = oData.iStart;
5969	oSettings.iInitDisplayStart = oData.iStart;
5970	oSettings._iDisplayEnd = oData.iEnd;
5971	oSettings._iDisplayLength = oData.iLength;
5972	oSettings.oPreviousSearch.sSearch = decodeURIComponent(oData.sFilter);
5973	oSettings.aaSorting = oData.aaSorting.slice();
5974	oSettings.saved_aaSorting = oData.aaSorting.slice();
5975
5976	/*
5977	* Search filtering - global reference added in 1.4.1
5978	* Note that we use a 'not' for the value of the regular expression indicator to maintain
5979	* compatibility with pre 1.7 versions, where this was basically inverted. Added in 1.7.0
5980	*/
5981	if ( typeof oData.sFilterEsc != 'undefined' )
5982	{
5983	oSettings.oPreviousSearch.bRegex = !oData.sFilterEsc;
5984	}
5985
5986	/* Column filtering - added in 1.5.0 beta 6 */
5987	if ( typeof oData.aaSearchCols != 'undefined' )
5988	{
5989	for ( i=0 ; i<oData.aaSearchCols.length ; i++ )
5990	{
5991	oSettings.aoPreSearchCols[i] = {
5992	"sSearch": decodeURIComponent(oData.aaSearchCols[i][0]),
5993	"bRegex": !oData.aaSearchCols[i][1]
5994	};
5995	}
5996	}
5997
5998	/* Column visibility state - added in 1.5.0 beta 10 */
5999	if ( typeof oData.abVisCols != 'undefined' )
6000	{
6001	/* Pass back visibiliy settings to the init handler, but to do not here override
6002	* the init object that the user might have passed in
6003	*/
6004	oInit.saved_aoColumns = [];
6005	for ( i=0 ; i<oData.abVisCols.length ; i++ )
6006	{
6007	oInit.saved_aoColumns[i] = {};
6008	oInit.saved_aoColumns[i].bVisible = oData.abVisCols[i];
6009	}
6010	}
6011	}
6012	}
6013
6014	/*
6015	* Function: _fnCreateCookie
6016	* Purpose: Create a new cookie with a value to store the state of a table
6017	* Returns: -
6018	* Inputs: string:sName - name of the cookie to create
6019	* string:sValue - the value the cookie should take
6020	* int:iSecs - duration of the cookie
6021	* string:sBaseName - sName is made up of the base + file name - this is the base
6022	* function:fnCallback - User definable function to modify the cookie
6023	*/
6024	function _fnCreateCookie ( sName, sValue, iSecs, sBaseName, fnCallback )
6025	{
6026	var date = new Date();
6027	date.setTime( date.getTime()+(iSecs*1000) );
6028
6029	/*
6030	* Shocking but true - it would appear IE has major issues with having the path not having
6031	* a trailing slash on it. We need the cookie to be available based on the path, so we
6032	* have to append the file name to the cookie name. Appalling. Thanks to vex for adding the
6033	* patch to use at least some of the path
6034	*/
6035	var aParts = window.location.pathname.split('/');
6036	var sNameFile = sName + '_' + aParts.pop().replace(/[\/:]/g,"").toLowerCase();
6037	var sFullCookie, oData;
6038
6039	if ( fnCallback !== null )
6040	{
6041	oData = (typeof $.parseJSON == 'function') ?
6042	$.parseJSON( sValue ) : eval( '('+sValue+')' );
6043	sFullCookie = fnCallback( sNameFile, oData, date.toGMTString(),
6044	aParts.join('/')+"/" );
6045	}
6046	else
6047	{
6048	sFullCookie = sNameFile + "=" + encodeURIComponent(sValue) +
6049	"; expires=" + date.toGMTString() +"; path=" + aParts.join('/')+"/";
6050	}
6051
6052	/* Are we going to go over the cookie limit of 4KiB? If so, try to delete a cookies
6053	* belonging to DataTables. This is FAR from bullet proof
6054	*/
6055	var sOldName="", iOldTime=9999999999999;
6056	var iLength = _fnReadCookie( sNameFile )!==null ? document.cookie.length :
6057	sFullCookie.length + document.cookie.length;
6058
6059	if ( iLength+10 > 4096 ) /* Magic 10 for padding */
6060	{
6061	var aCookies =document.cookie.split(';');
6062	for ( var i=0, iLen=aCookies.length ; i<iLen ; i++ )
6063	{
6064	if ( aCookies[i].indexOf( sBaseName ) != -1 )
6065	{
6066	/* It's a DataTables cookie, so eval it and check the time stamp */
6067	var aSplitCookie = aCookies[i].split('=');
6068	try { oData = eval( '('+decodeURIComponent(aSplitCookie[1])+')' ); }
6069	catch( e ) { continue; }
6070
6071	if ( typeof oData.iCreate != 'undefined' && oData.iCreate < iOldTime )
6072	{
6073	sOldName = aSplitCookie[0];
6074	iOldTime = oData.iCreate;
6075	}
6076	}
6077	}
6078
6079	if ( sOldName !== "" )
6080	{
6081	document.cookie = sOldName+"=; expires=Thu, 01-Jan-1970 00:00:01 GMT; path="+
6082	aParts.join('/') + "/";
6083	}
6084	}
6085
6086	document.cookie = sFullCookie;
6087	}
6088
6089	/*
6090	* Function: _fnReadCookie
6091	* Purpose: Read an old cookie to get a cookie with an old table state
6092	* Returns: string: - contents of the cookie - or null if no cookie with that name found
6093	* Inputs: string:sName - name of the cookie to read
6094	*/
6095	function _fnReadCookie ( sName )
6096	{
6097	var
6098	aParts = window.location.pathname.split('/'),
6099	sNameEQ = sName + '_' + aParts[aParts.length-1].replace(/[\/:]/g,"").toLowerCase() + '=',
6100	sCookieContents = document.cookie.split(';');
6101
6102	for( var i=0 ; i<sCookieContents.length ; i++ )
6103	{
6104	var c = sCookieContents[i];
6105
6106	while (c.charAt(0)==' ')
6107	{
6108	c = c.substring(1,c.length);
6109	}
6110
6111	if (c.indexOf(sNameEQ) === 0)
6112	{
6113	return decodeURIComponent( c.substring(sNameEQ.length,c.length) );
6114	}
6115	}
6116	return null;
6117	}
6118
6119	/*
6120	* Function: _fnGetUniqueThs
6121	* Purpose: Get an array of unique th elements, one for each column
6122	* Returns: array node:aReturn - list of unique ths
6123	* Inputs: node:nThead - The thead element for the table
6124	*/
6125	function _fnGetUniqueThs ( nThead )
6126	{
6127	var nTrs = nThead.getElementsByTagName('tr');
6128
6129	/* Nice simple case */
6130	if ( nTrs.length == 1 )
6131	{
6132	return nTrs[0].getElementsByTagName('th');
6133	}
6134
6135	/* Otherwise we need to figure out the layout array to get the nodes */
6136	var aLayout = [], aReturn = [];
6137	var ROWSPAN = 2, COLSPAN = 3, TDELEM = 4;
6138	var i, j, k, iLen, jLen, iColumnShifted;
6139	var fnShiftCol = function ( a, i, j ) {
6140	while ( typeof a[i][j] != 'undefined' ) {
6141	j++;
6142	}
6143	return j;
6144	};
6145	var fnAddRow = function ( i ) {
6146	if ( typeof aLayout[i] == 'undefined' ) {
6147	aLayout[i] = [];
6148	}
6149	};
6150
6151	/* Calculate a layout array */
6152	for ( i=0, iLen=nTrs.length ; i<iLen ; i++ )
6153	{
6154	fnAddRow( i );
6155	var iColumn = 0;
6156	var nTds = [];
6157
6158	for ( j=0, jLen=nTrs[i].childNodes.length ; j<jLen ; j++ )
6159	{
6160	if ( nTrs[i].childNodes[j].nodeName.toUpperCase() == "TD" \|\|
6161	nTrs[i].childNodes[j].nodeName.toUpperCase() == "TH" )
6162	{
6163	nTds.push( nTrs[i].childNodes[j] );
6164	}
6165	}
6166
6167	for ( j=0, jLen=nTds.length ; j<jLen ; j++ )
6168	{
6169	var iColspan = nTds[j].getAttribute('colspan') * 1;
6170	var iRowspan = nTds[j].getAttribute('rowspan') * 1;
6171
6172	if ( !iColspan \|\| iColspan===0 \|\| iColspan===1 )
6173	{
6174	iColumnShifted = fnShiftCol( aLayout, i, iColumn );
6175	aLayout[i][iColumnShifted] = (nTds[j].nodeName.toUpperCase()=="TD") ? TDELEM : nTds[j];
6176	if ( iRowspan \|\| iRowspan===0 \|\| iRowspan===1 )
6177	{
6178	for ( k=1 ; k<iRowspan ; k++ )
6179	{
6180	fnAddRow( i+k );
6181	aLayout[i+k][iColumnShifted] = ROWSPAN;
6182	}
6183	}
6184	iColumn++;
6185	}
6186	else
6187	{
6188	iColumnShifted = fnShiftCol( aLayout, i, iColumn );
6189	for ( k=0 ; k<iColspan ; k++ )
6190	{
6191	aLayout[i][iColumnShifted+k] = COLSPAN;
6192	}
6193	iColumn += iColspan;
6194	}
6195	}
6196	}
6197
6198	/* Convert the layout array into a node array */
6199	for ( i=0, iLen=aLayout.length ; i<iLen ; i++ )
6200	{
6201	for ( j=0, jLen=aLayout[i].length ; j<jLen ; j++ )
6202	{
6203	if ( typeof aLayout[i][j] == 'object' && typeof aReturn[j] == 'undefined' )
6204	{
6205	aReturn[j] = aLayout[i][j];
6206	}
6207	}
6208	}
6209
6210	return aReturn;
6211	}
6212
6213	/*
6214	* Function: _fnScrollBarWidth
6215	* Purpose: Get the width of a scroll bar in this browser being used
6216	* Returns: int: - width in pixels
6217	* Inputs: -
6218	* Notes: All credit for this function belongs to Alexandre Gomes. Thanks for sharing!
6219	* http://www.alexandre-gomes.com/?p=115
6220	*/
6221	function _fnScrollBarWidth ()
6222	{
6223	var inner = document.createElement('p');
6224	var style = inner.style;
6225	style.width = "100%";
6226	style.height = "200px";
6227
6228	var outer = document.createElement('div');
6229	style = outer.style;
6230	style.position = "absolute";
6231	style.top = "0px";
6232	style.left = "0px";
6233	style.visibility = "hidden";
6234	style.width = "200px";
6235	style.height = "150px";
6236	style.overflow = "hidden";
6237	outer.appendChild(inner);
6238
6239	document.body.appendChild(outer);
6240	var w1 = inner.offsetWidth;
6241	outer.style.overflow = 'scroll';
6242	var w2 = inner.offsetWidth;
6243	if ( w1 == w2 )
6244	{
6245	w2 = outer.clientWidth;
6246	}
6247
6248	document.body.removeChild(outer);
6249	return (w1 - w2);
6250	}
6251
6252	/*
6253	* Function: _fnApplyToChildren
6254	* Purpose: Apply a given function to the display child nodes of an element array (typically
6255	* TD children of TR rows
6256	* Returns: - (done by reference)
6257	* Inputs: function:fn - Method to apply to the objects
6258	* array nodes:an1 - List of elements to look through for display children
6259	* array nodes:an2 - Another list (identical structure to the first) - optional
6260	*/
6261	function _fnApplyToChildren( fn, an1, an2 )
6262	{
6263	for ( var i=0, iLen=an1.length ; i<iLen ; i++ )
6264	{
6265	for ( var j=0, jLen=an1[i].childNodes.length ; j<jLen ; j++ )
6266	{
6267	if ( an1[i].childNodes[j].nodeType == 1 )
6268	{
6269	if ( typeof an2 != 'undefined' )
6270	{
6271	fn( an1[i].childNodes[j], an2[i].childNodes[j] );
6272	}
6273	else
6274	{
6275	fn( an1[i].childNodes[j] );
6276	}
6277	}
6278	}
6279	}
6280	}
6281
6282	/*
6283	* Function: _fnMap
6284	* Purpose: See if a property is defined on one object, if so assign it to the other object
6285	* Returns: - (done by reference)
6286	* Inputs: object:oRet - target object
6287	* object:oSrc - source object
6288	* string:sName - property
6289	* string:sMappedName - name to map too - optional, sName used if not given
6290	*/
6291	function _fnMap( oRet, oSrc, sName, sMappedName )
6292	{
6293	if ( typeof sMappedName == 'undefined' )
6294	{
6295	sMappedName = sName;
6296	}
6297	if ( typeof oSrc[sName] != 'undefined' )
6298	{
6299	oRet[sMappedName] = oSrc[sName];
6300	}
6301	}
6302
6303	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
6304	* Section - API
6305	*
6306	* I'm not overly happy with this solution - I'd much rather that there was a way of getting
6307	* a list of all the private functions and do what we need to dynamically - but that doesn't
6308	* appear to be possible. Bonkers. A better solution would be to provide a 'bind' type object
6309	* To do - bind type method in DTs 2.x.
6310	*/
6311	this.oApi._fnExternApiFunc = _fnExternApiFunc;
6312	this.oApi._fnInitalise = _fnInitalise;
6313	this.oApi._fnLanguageProcess = _fnLanguageProcess;
6314	this.oApi._fnAddColumn = _fnAddColumn;
6315	this.oApi._fnColumnOptions = _fnColumnOptions;
6316	this.oApi._fnAddData = _fnAddData;
6317	this.oApi._fnGatherData = _fnGatherData;
6318	this.oApi._fnDrawHead = _fnDrawHead;
6319	this.oApi._fnDraw = _fnDraw;
6320	this.oApi._fnReDraw = _fnReDraw;
6321	this.oApi._fnAjaxUpdate = _fnAjaxUpdate;
6322	this.oApi._fnAjaxUpdateDraw = _fnAjaxUpdateDraw;
6323	this.oApi._fnAddOptionsHtml = _fnAddOptionsHtml;
6324	this.oApi._fnFeatureHtmlTable = _fnFeatureHtmlTable;
6325	this.oApi._fnScrollDraw = _fnScrollDraw;
6326	this.oApi._fnAjustColumnSizing = _fnAjustColumnSizing;
6327	this.oApi._fnFeatureHtmlFilter = _fnFeatureHtmlFilter;
6328	this.oApi._fnFilterComplete = _fnFilterComplete;
6329	this.oApi._fnFilterCustom = _fnFilterCustom;
6330	this.oApi._fnFilterColumn = _fnFilterColumn;
6331	this.oApi._fnFilter = _fnFilter;
6332	this.oApi._fnBuildSearchArray = _fnBuildSearchArray;
6333	this.oApi._fnBuildSearchRow = _fnBuildSearchRow;
6334	this.oApi._fnFilterCreateSearch = _fnFilterCreateSearch;
6335	this.oApi._fnDataToSearch = _fnDataToSearch;
6336	this.oApi._fnSort = _fnSort;
6337	this.oApi._fnSortAttachListener = _fnSortAttachListener;
6338	this.oApi._fnSortingClasses = _fnSortingClasses;
6339	this.oApi._fnFeatureHtmlPaginate = _fnFeatureHtmlPaginate;
6340	this.oApi._fnPageChange = _fnPageChange;
6341	this.oApi._fnFeatureHtmlInfo = _fnFeatureHtmlInfo;
6342	this.oApi._fnUpdateInfo = _fnUpdateInfo;
6343	this.oApi._fnFeatureHtmlLength = _fnFeatureHtmlLength;
6344	this.oApi._fnFeatureHtmlProcessing = _fnFeatureHtmlProcessing;
6345	this.oApi._fnProcessingDisplay = _fnProcessingDisplay;
6346	this.oApi._fnVisibleToColumnIndex = _fnVisibleToColumnIndex;
6347	this.oApi._fnColumnIndexToVisible = _fnColumnIndexToVisible;
6348	this.oApi._fnNodeToDataIndex = _fnNodeToDataIndex;
6349	this.oApi._fnVisbleColumns = _fnVisbleColumns;
6350	this.oApi._fnCalculateEnd = _fnCalculateEnd;
6351	this.oApi._fnConvertToWidth = _fnConvertToWidth;
6352	this.oApi._fnCalculateColumnWidths = _fnCalculateColumnWidths;
6353	this.oApi._fnScrollingWidthAdjust = _fnScrollingWidthAdjust;
6354	this.oApi._fnGetWidestNode = _fnGetWidestNode;
6355	this.oApi._fnGetMaxLenString = _fnGetMaxLenString;
6356	this.oApi._fnStringToCss = _fnStringToCss;
6357	this.oApi._fnArrayCmp = _fnArrayCmp;
6358	this.oApi._fnDetectType = _fnDetectType;
6359	this.oApi._fnSettingsFromNode = _fnSettingsFromNode;
6360	this.oApi._fnGetDataMaster = _fnGetDataMaster;
6361	this.oApi._fnGetTrNodes = _fnGetTrNodes;
6362	this.oApi._fnGetTdNodes = _fnGetTdNodes;
6363	this.oApi._fnEscapeRegex = _fnEscapeRegex;
6364	this.oApi._fnDeleteIndex = _fnDeleteIndex;
6365	this.oApi._fnReOrderIndex = _fnReOrderIndex;
6366	this.oApi._fnColumnOrdering = _fnColumnOrdering;
6367	this.oApi._fnLog = _fnLog;
6368	this.oApi._fnClearTable = _fnClearTable;
6369	this.oApi._fnSaveState = _fnSaveState;
6370	this.oApi._fnLoadState = _fnLoadState;
6371	this.oApi._fnCreateCookie = _fnCreateCookie;
6372	this.oApi._fnReadCookie = _fnReadCookie;
6373	this.oApi._fnGetUniqueThs = _fnGetUniqueThs;
6374	this.oApi._fnScrollBarWidth = _fnScrollBarWidth;
6375	this.oApi._fnApplyToChildren = _fnApplyToChildren;
6376	this.oApi._fnMap = _fnMap;
6377
6378
6379	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
6380	* Section - Constructor
6381	*/
6382
6383	/* Want to be able to reference "this" inside the this.each function */
6384	var _that = this;
6385	return this.each(function()
6386	{
6387	var i=0, iLen, j, jLen, k, kLen;
6388
6389	/* Check to see if we are re-initalising a table */
6390	for ( i=0, iLen=_aoSettings.length ; i<iLen ; i++ )
6391	{
6392	/* Base check on table node */
6393	if ( _aoSettings[i].nTable == this )
6394	{
6395	if ( typeof oInit == 'undefined' \|\|
6396	( typeof oInit.bRetrieve != 'undefined' && oInit.bRetrieve === true ) )
6397	{
6398	return _aoSettings[i].oInstance;
6399	}
6400	else if ( typeof oInit.bDestroy != 'undefined' && oInit.bDestroy === true )
6401	{
6402	_aoSettings[i].oInstance.fnDestroy();
6403	break;
6404	}
6405	else
6406	{
6407	_fnLog( _aoSettings[i], 0, "Cannot reinitialise DataTable.\n\n"+
6408	"To retrieve the DataTables object for this table, please pass either no arguments "+
6409	"to the dataTable() function, or set bRetrieve to true. Alternatively, to destory "+
6410	"the old table and create a new one, set bDestroy to true (note that a lot of "+
6411	"changes to the configuration can be made through the API which is usually much "+
6412	"faster)." );
6413	return;
6414	}
6415	}
6416
6417	/* If the element we are initialising has the same ID as a table which was previously
6418	* initialised, but the table nodes don't match (from before) then we destory the old
6419	* instance by simply deleting it. This is under the assumption that the table has been
6420	* destroyed by other methods. Anyone using non-id selectors will need to do this manually
6421	*/
6422	if ( _aoSettings[i].sTableId !== "" && _aoSettings[i].sTableId == this.getAttribute('id') )
6423	{
6424	_aoSettings.splice( i, 1 );
6425	break;
6426	}
6427	}
6428
6429	/* Make a complete and independent copy of the settings object */
6430	var oSettings = new classSettings();
6431	_aoSettings.push( oSettings );
6432
6433	var bInitHandedOff = false;
6434	var bUsePassedData = false;
6435
6436	/* Set the id */
6437	var sId = this.getAttribute( 'id' );
6438	if ( sId !== null )
6439	{
6440	oSettings.sTableId = sId;
6441	oSettings.sInstance = sId;
6442	}
6443	else
6444	{
6445	oSettings.sInstance = _oExt._oExternConfig.iNextUnique ++;
6446	}
6447
6448	/* Sanity check */
6449	if ( this.nodeName.toLowerCase() != 'table' )
6450	{
6451	_fnLog( oSettings, 0, "Attempted to initialise DataTables on a node which is not a "+
6452	"table: "+this.nodeName );
6453	return;
6454	}
6455
6456	/* Set the table node */
6457	oSettings.nTable = this;
6458
6459	/* Keep a reference to the 'this' instance for the table. Note that if this table is being
6460	* created with others, we retrieve a unique instance to ease API access.
6461	*/
6462	oSettings.oInstance = _that.length == 1 ? _that : $(this).dataTable();
6463
6464	/* Bind the API functions to the settings, so we can perform actions whenever oSettings is
6465	* available
6466	*/
6467	oSettings.oApi = _that.oApi;
6468
6469	/* State the table's width for if a destroy is called at a later time */
6470	oSettings.sDestroyWidth = $(this).width();
6471
6472	/* Store the features that we have available */
6473	if ( typeof oInit != 'undefined' && oInit !== null )
6474	{
6475	oSettings.oInit = oInit;
6476	_fnMap( oSettings.oFeatures, oInit, "bPaginate" );
6477	_fnMap( oSettings.oFeatures, oInit, "bLengthChange" );
6478	_fnMap( oSettings.oFeatures, oInit, "bFilter" );
6479	_fnMap( oSettings.oFeatures, oInit, "bSort" );
6480	_fnMap( oSettings.oFeatures, oInit, "bInfo" );
6481	_fnMap( oSettings.oFeatures, oInit, "bProcessing" );
6482	_fnMap( oSettings.oFeatures, oInit, "bAutoWidth" );
6483	_fnMap( oSettings.oFeatures, oInit, "bSortClasses" );
6484	_fnMap( oSettings.oFeatures, oInit, "bServerSide" );
6485	_fnMap( oSettings.oScroll, oInit, "sScrollX", "sX" );
6486	_fnMap( oSettings.oScroll, oInit, "sScrollXInner", "sXInner" );
6487	_fnMap( oSettings.oScroll, oInit, "sScrollY", "sY" );
6488	_fnMap( oSettings.oScroll, oInit, "bScrollCollapse", "bCollapse" );
6489	_fnMap( oSettings.oScroll, oInit, "bScrollInfinite", "bInfinite" );
6490	_fnMap( oSettings.oScroll, oInit, "iScrollLoadGap", "iLoadGap" );
6491	_fnMap( oSettings.oScroll, oInit, "bScrollAutoCss", "bAutoCss" );
6492	_fnMap( oSettings, oInit, "asStripClasses" );
6493	_fnMap( oSettings, oInit, "fnRowCallback" );
6494	_fnMap( oSettings, oInit, "fnHeaderCallback" );
6495	_fnMap( oSettings, oInit, "fnFooterCallback" );
6496	_fnMap( oSettings, oInit, "fnCookieCallback" );
6497	_fnMap( oSettings, oInit, "fnInitComplete" );
6498	_fnMap( oSettings, oInit, "fnServerData" );
6499	_fnMap( oSettings, oInit, "fnFormatNumber" );
6500	_fnMap( oSettings, oInit, "aaSorting" );
6501	_fnMap( oSettings, oInit, "aaSortingFixed" );
6502	_fnMap( oSettings, oInit, "aLengthMenu" );
6503	_fnMap( oSettings, oInit, "sPaginationType" );
6504	_fnMap( oSettings, oInit, "sAjaxSource" );
6505	_fnMap( oSettings, oInit, "iCookieDuration" );
6506	_fnMap( oSettings, oInit, "sCookiePrefix" );
6507	_fnMap( oSettings, oInit, "sDom" );
6508	_fnMap( oSettings, oInit, "oSearch", "oPreviousSearch" );
6509	_fnMap( oSettings, oInit, "aoSearchCols", "aoPreSearchCols" );
6510	_fnMap( oSettings, oInit, "iDisplayLength", "_iDisplayLength" );
6511	_fnMap( oSettings, oInit, "bJQueryUI", "bJUI" );
6512	_fnMap( oSettings.oLanguage, oInit, "fnInfoCallback" );
6513
6514	/* Callback functions which are array driven */
6515	if ( typeof oInit.fnDrawCallback == 'function' )
6516	{
6517	oSettings.aoDrawCallback.push( {
6518	"fn": oInit.fnDrawCallback,
6519	"sName": "user"
6520	} );
6521	}
6522
6523	if ( typeof oInit.fnStateSaveCallback == 'function' )
6524	{
6525	oSettings.aoStateSave.push( {
6526	"fn": oInit.fnStateSaveCallback,
6527	"sName": "user"
6528	} );
6529	}
6530
6531	if ( typeof oInit.fnStateLoadCallback == 'function' )
6532	{
6533	oSettings.aoStateLoad.push( {
6534	"fn": oInit.fnStateLoadCallback,
6535	"sName": "user"
6536	} );
6537	}
6538
6539	if ( oSettings.oFeatures.bServerSide && oSettings.oFeatures.bSort &&
6540	oSettings.oFeatures.bSortClasses )
6541	{
6542	/* Enable sort classes for server-side processing. Safe to do it here, since server-side
6543	* processing must be enabled by the developer
6544	*/
6545	oSettings.aoDrawCallback.push( {
6546	"fn": _fnSortingClasses,
6547	"sName": "server_side_sort_classes"
6548	} );
6549	}
6550
6551	if ( typeof oInit.bJQueryUI != 'undefined' && oInit.bJQueryUI )
6552	{
6553	/* Use the JUI classes object for display. You could clone the oStdClasses object if
6554	* you want to have multiple tables with multiple independent classes
6555	*/
6556	oSettings.oClasses = _oExt.oJUIClasses;
6557
6558	if ( typeof oInit.sDom == 'undefined' )
6559	{
6560	/* Set the DOM to use a layout suitable for jQuery UI's theming */
6561	oSettings.sDom = '<"H"lfr>t<"F"ip>';
6562	}
6563	}
6564
6565	/* Calculate the scroll bar width and cache it for use later on */
6566	if ( oSettings.oScroll.sX !== "" \|\| oSettings.oScroll.sY !== "" )
6567	{
6568	oSettings.oScroll.iBarWidth = _fnScrollBarWidth();
6569	}
6570
6571	if ( typeof oInit.iDisplayStart != 'undefined' &&
6572	typeof oSettings.iInitDisplayStart == 'undefined' )
6573	{
6574	/* Display start point, taking into account the save saving */
6575	oSettings.iInitDisplayStart = oInit.iDisplayStart;
6576	oSettings._iDisplayStart = oInit.iDisplayStart;
6577	}
6578
6579	/* Must be done after everything which can be overridden by a cookie! */
6580	if ( typeof oInit.bStateSave != 'undefined' )
6581	{
6582	oSettings.oFeatures.bStateSave = oInit.bStateSave;
6583	_fnLoadState( oSettings, oInit );
6584	oSettings.aoDrawCallback.push( {
6585	"fn": _fnSaveState,
6586	"sName": "state_save"
6587	} );
6588	}
6589
6590	if ( typeof oInit.aaData != 'undefined' )
6591	{
6592	bUsePassedData = true;
6593	}
6594
6595	/* Backwards compatability */
6596	/* aoColumns / aoData - remove at some point... */
6597	if ( typeof oInit != 'undefined' && typeof oInit.aoData != 'undefined' )
6598	{
6599	oInit.aoColumns = oInit.aoData;
6600	}
6601
6602	/* Language definitions */
6603	if ( typeof oInit.oLanguage != 'undefined' )
6604	{
6605	if ( typeof oInit.oLanguage.sUrl != 'undefined' && oInit.oLanguage.sUrl !== "" )
6606	{
6607	/* Get the language definitions from a file */
6608	oSettings.oLanguage.sUrl = oInit.oLanguage.sUrl;
6609	$.getJSON( oSettings.oLanguage.sUrl, null, function( json ) {
6610	_fnLanguageProcess( oSettings, json, true ); } );
6611	bInitHandedOff = true;
6612	}
6613	else
6614	{
6615	_fnLanguageProcess( oSettings, oInit.oLanguage, false );
6616	}
6617	}
6618	/* Warning: The _fnLanguageProcess function is async to the remainder of this function due
6619	* to the XHR. We use _bInitialised in _fnLanguageProcess() to check this the processing
6620	* below is complete. The reason for spliting it like this is optimisation - we can fire
6621	* off the XHR (if needed) and then continue processing the data.
6622	*/
6623	}
6624	else
6625	{
6626	/* Create a dummy object for quick manipulation later on. */
6627	oInit = {};
6628	}
6629
6630	/*
6631	* Stripes
6632	* Add the strip classes now that we know which classes to apply - unless overruled
6633	*/
6634	if ( typeof oInit.asStripClasses == 'undefined' )
6635	{
6636	oSettings.asStripClasses.push( oSettings.oClasses.sStripOdd );
6637	oSettings.asStripClasses.push( oSettings.oClasses.sStripEven );
6638	}
6639
6640	/* Remove row stripe classes if they are already on the table row */
6641	var bStripeRemove = false;
6642	var anRows = $('>tbody>tr', this);
6643	for ( i=0, iLen=oSettings.asStripClasses.length ; i<iLen ; i++ )
6644	{
6645	if ( anRows.filter(":lt(2)").hasClass( oSettings.asStripClasses[i]) )
6646	{
6647	bStripeRemove = true;
6648	break;
6649	}
6650	}
6651
6652	if ( bStripeRemove )
6653	{
6654	/* Store the classes which we are about to remove so they can be readded on destory */
6655	oSettings.asDestoryStrips = [ '', '' ];
6656	if ( $(anRows[0]).hasClass(oSettings.oClasses.sStripOdd) )
6657	{
6658	oSettings.asDestoryStrips[0] += oSettings.oClasses.sStripOdd+" ";
6659	}
6660	if ( $(anRows[0]).hasClass(oSettings.oClasses.sStripEven) )
6661	{
6662	oSettings.asDestoryStrips[0] += oSettings.oClasses.sStripEven;
6663	}
6664	if ( $(anRows[1]).hasClass(oSettings.oClasses.sStripOdd) )
6665	{
6666	oSettings.asDestoryStrips[1] += oSettings.oClasses.sStripOdd+" ";
6667	}
6668	if ( $(anRows[1]).hasClass(oSettings.oClasses.sStripEven) )
6669	{
6670	oSettings.asDestoryStrips[1] += oSettings.oClasses.sStripEven;
6671	}
6672
6673	anRows.removeClass( oSettings.asStripClasses.join(' ') );
6674	}
6675
6676	/*
6677	* Columns
6678	* See if we should load columns automatically or use defined ones
6679	*/
6680	var nThead = this.getElementsByTagName('thead');
6681	var anThs = nThead.length===0 ? [] : _fnGetUniqueThs( nThead[0] );
6682	var aoColumnsInit;
6683
6684	/* If not given a column array, generate one with nulls */
6685	if ( typeof oInit.aoColumns == 'undefined' )
6686	{
6687	aoColumnsInit = [];
6688	for ( i=0, iLen=anThs.length ; i<iLen ; i++ )
6689	{
6690	aoColumnsInit.push( null );
6691	}
6692	}
6693	else
6694	{
6695	aoColumnsInit = oInit.aoColumns;
6696	}
6697
6698	/* Add the columns */
6699	for ( i=0, iLen=aoColumnsInit.length ; i<iLen ; i++ )
6700	{
6701	/* Check if we have column visibilty state to restore */
6702	if ( typeof oInit.saved_aoColumns != 'undefined' && oInit.saved_aoColumns.length == iLen )
6703	{
6704	if ( aoColumnsInit[i] === null )
6705	{
6706	aoColumnsInit[i] = {};
6707	}
6708	aoColumnsInit[i].bVisible = oInit.saved_aoColumns[i].bVisible;
6709	}
6710
6711	_fnAddColumn( oSettings, anThs ? anThs[i] : null );
6712	}
6713
6714	/* Add options from column definations */
6715	if ( typeof oInit.aoColumnDefs != 'undefined' )
6716	{
6717	/* Loop over the column defs array - loop in reverse so first instace has priority */
6718	for ( i=oInit.aoColumnDefs.length-1 ; i>=0 ; i-- )
6719	{
6720	/* Each column def can target multiple columns, as it is an array */
6721	var aTargets = oInit.aoColumnDefs[i].aTargets;
6722	if ( !$.isArray( aTargets ) )
6723	{
6724	_fnLog( oSettings, 1, 'aTargets must be an array of targets, not a '+(typeof aTargets) );
6725	}
6726	for ( j=0, jLen=aTargets.length ; j<jLen ; j++ )
6727	{
6728	if ( typeof aTargets[j] == 'number' && aTargets[j] >= 0 )
6729	{
6730	/* 0+ integer, left to right column counting. We add columns which are unknown
6731	* automatically. Is this the right behaviour for this? We should at least
6732	* log it in future. We cannot do this for the negative or class targets, only here.
6733	*/
6734	while( oSettings.aoColumns.length <= aTargets[j] )
6735	{
6736	_fnAddColumn( oSettings );
6737	}
6738	_fnColumnOptions( oSettings, aTargets[j], oInit.aoColumnDefs[i] );
6739	}
6740	else if ( typeof aTargets[j] == 'number' && aTargets[j] < 0 )
6741	{
6742	/* Negative integer, right to left column counting */
6743	_fnColumnOptions( oSettings, oSettings.aoColumns.length+aTargets[j],
6744	oInit.aoColumnDefs[i] );
6745	}
6746	else if ( typeof aTargets[j] == 'string' )
6747	{
6748	/* Class name matching on TH element */
6749	for ( k=0, kLen=oSettings.aoColumns.length ; k<kLen ; k++ )
6750	{
6751	if ( aTargets[j] == "_all" \|\|
6752	oSettings.aoColumns[k].nTh.className.indexOf( aTargets[j] ) != -1 )
6753	{
6754	_fnColumnOptions( oSettings, k, oInit.aoColumnDefs[i] );
6755	}
6756	}
6757	}
6758	}
6759	}
6760	}
6761
6762	/* Add options from column array - after the defs array so this has priority */
6763	if ( typeof aoColumnsInit != 'undefined' )
6764	{
6765	for ( i=0, iLen=aoColumnsInit.length ; i<iLen ; i++ )
6766	{
6767	_fnColumnOptions( oSettings, i, aoColumnsInit[i] );
6768	}
6769	}
6770
6771	/*
6772	* Sorting
6773	* Check the aaSorting array
6774	*/
6775	for ( i=0, iLen=oSettings.aaSorting.length ; i<iLen ; i++ )
6776	{
6777	if ( oSettings.aaSorting[i][0] >= oSettings.aoColumns.length )
6778	{
6779	oSettings.aaSorting[i][0] = 0;
6780	}
6781	var oColumn = oSettings.aoColumns[ oSettings.aaSorting[i][0] ];
6782
6783	/* Add a default sorting index */
6784	if ( typeof oSettings.aaSorting[i][2] == 'undefined' )
6785	{
6786	oSettings.aaSorting[i][2] = 0;
6787	}
6788
6789	/* If aaSorting is not defined, then we use the first indicator in asSorting */
6790	if ( typeof oInit.aaSorting == "undefined" &&
6791	typeof oSettings.saved_aaSorting == "undefined" )
6792	{
6793	oSettings.aaSorting[i][1] = oColumn.asSorting[0];
6794	}
6795
6796	/* Set the current sorting index based on aoColumns.asSorting */
6797	for ( j=0, jLen=oColumn.asSorting.length ; j<jLen ; j++ )
6798	{
6799	if ( oSettings.aaSorting[i][1] == oColumn.asSorting[j] )
6800	{
6801	oSettings.aaSorting[i][2] = j;
6802	break;
6803	}
6804	}
6805	}
6806
6807	/* Do a first pass on the sorting classes (allows any size changes to be taken into
6808	* account, and also will apply sorting disabled classes if disabled
6809	*/
6810	_fnSortingClasses( oSettings );
6811
6812	/*
6813	* Final init
6814	* Sanity check that there is a thead and tbody. If not let's just create them
6815	*/
6816	if ( this.getElementsByTagName('thead').length === 0 )
6817	{
6818	this.appendChild( document.createElement( 'thead' ) );
6819	}
6820
6821	if ( this.getElementsByTagName('tbody').length === 0 )
6822	{
6823	this.appendChild( document.createElement( 'tbody' ) );
6824	}
6825
6826	oSettings.nTHead = this.getElementsByTagName('thead')[0];
6827	oSettings.nTBody = this.getElementsByTagName('tbody')[0];
6828	if ( this.getElementsByTagName('tfoot').length > 0 )
6829	{
6830	oSettings.nTFoot = this.getElementsByTagName('tfoot')[0];
6831	}
6832
6833	/* Check if there is data passing into the constructor */
6834	if ( bUsePassedData )
6835	{
6836	for ( i=0 ; i<oInit.aaData.length ; i++ )
6837	{
6838	_fnAddData( oSettings, oInit.aaData[ i ] );
6839	}
6840	}
6841	else
6842	{
6843	/* Grab the data from the page */
6844	_fnGatherData( oSettings );
6845	}
6846
6847	/* Copy the data index array */
6848	oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
6849
6850	/* Initialisation complete - table can be drawn */
6851	oSettings.bInitialised = true;
6852
6853	/* Check if we need to initialise the table (it might not have been handed off to the
6854	* language processor)
6855	*/
6856	if ( bInitHandedOff === false )
6857	{
6858	_fnInitalise( oSettings );
6859	}
6860	});
6861	};
6862	})(jQuery, window, document);

Note: See TracBrowser for help on using the repository browser.

Download in other formats: