Subversion Repositories ALCASAR

Rev

Rev 2808 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log

Rev Author Line No. Line
2808 rexy 1
/*
2
 * File:        jquery.dataTables.js
2976 rexy 3
 * Version:     1.8.2+jquery1.9fix+parseJSONfix2+bindfix+samesitefix
2808 rexy 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-2011 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
26
 */
27
/*jslint evil: true, undef: true, browser: true */
28
/*globals $, jQuery,_fnExternApiFunc,_fnInitialise,_fnInitComplete,_fnLanguageProcess,_fnAddColumn,_fnColumnOptions,_fnAddData,_fnCreateTr,_fnGatherData,_fnBuildHead,_fnDrawHead,_fnDraw,_fnReDraw,_fnAjaxUpdate,_fnAjaxParameters,_fnAjaxUpdateDraw,_fnServerParams,_fnAddOptionsHtml,_fnFeatureHtmlTable,_fnScrollDraw,_fnAdjustColumnSizing,_fnFeatureHtmlFilter,_fnFilterComplete,_fnFilterCustom,_fnFilterColumn,_fnFilter,_fnBuildSearchArray,_fnBuildSearchRow,_fnFilterCreateSearch,_fnDataToSearch,_fnSort,_fnSortAttachListener,_fnSortingClasses,_fnFeatureHtmlPaginate,_fnPageChange,_fnFeatureHtmlInfo,_fnUpdateInfo,_fnFeatureHtmlLength,_fnFeatureHtmlProcessing,_fnProcessingDisplay,_fnVisibleToColumnIndex,_fnColumnIndexToVisible,_fnNodeToDataIndex,_fnVisbleColumns,_fnCalculateEnd,_fnConvertToWidth,_fnCalculateColumnWidths,_fnScrollingWidthAdjust,_fnGetWidestNode,_fnGetMaxLenString,_fnStringToCss,_fnArrayCmp,_fnDetectType,_fnSettingsFromNode,_fnGetDataMaster,_fnGetTrNodes,_fnGetTdNodes,_fnEscapeRegex,_fnDeleteIndex,_fnReOrderIndex,_fnColumnOrdering,_fnLog,_fnClearTable,_fnSaveState,_fnLoadState,_fnCreateCookie,_fnReadCookie,_fnDetectHeader,_fnGetUniqueThs,_fnScrollBarWidth,_fnApplyToChildren,_fnMap,_fnGetRowData,_fnGetCellData,_fnSetCellData,_fnGetObjectDataFn,_fnSetObjectDataFn*/
29
 
30
(function($, window, document) {
31
	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
32
	 * Section - DataTables variables
33
	 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
34
 
35
	/*
36
	 * Variable: dataTableSettings
37
	 * Purpose:  Store the settings for each dataTables instance
38
	 * Scope:    jQuery.fn
39
	 */
40
	$.fn.dataTableSettings = [];
41
	var _aoSettings = $.fn.dataTableSettings; /* Short reference for fast internal lookup */
42
 
43
	/*
44
	 * Variable: dataTableExt
45
	 * Purpose:  Container for customisable parts of DataTables
46
	 * Scope:    jQuery.fn
47
	 */
48
	$.fn.dataTableExt = {};
49
	var _oExt = $.fn.dataTableExt;
50
 
51
 
52
	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
53
	 * Section - DataTables extensible objects
54
	 * 
55
	 * The _oExt object is used to provide an area where user defined plugins can be 
56
	 * added to DataTables. The following properties of the object are used:
57
	 *   oApi - Plug-in API functions
58
	 *   aTypes - Auto-detection of types
59
	 *   oSort - Sorting functions used by DataTables (based on the type)
60
	 *   oPagination - Pagination functions for different input styles
61
	 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
62
 
63
	/*
64
	 * Variable: sVersion
65
	 * Purpose:  Version string for plug-ins to check compatibility
66
	 * Scope:    jQuery.fn.dataTableExt
67
	 * Notes:    Allowed format is a.b.c.d.e where:
68
	 *   a:int, b:int, c:int, d:string(dev|beta), e:int. d and e are optional
69
	 */
70
	_oExt.sVersion = "1.8.2";
71
 
72
	/*
73
	 * Variable: sErrMode
74
	 * Purpose:  How should DataTables report an error. Can take the value 'alert' or 'throw'
75
	 * Scope:    jQuery.fn.dataTableExt
76
	 */
77
	_oExt.sErrMode = "alert";
78
 
79
	/*
80
	 * Variable: iApiIndex
81
	 * Purpose:  Index for what 'this' index API functions should use
82
	 * Scope:    jQuery.fn.dataTableExt
83
	 */
84
	_oExt.iApiIndex = 0;
85
 
86
	/*
87
	 * Variable: oApi
88
	 * Purpose:  Container for plugin API functions
89
	 * Scope:    jQuery.fn.dataTableExt
90
	 */
91
	_oExt.oApi = { };
92
 
93
	/*
94
	 * Variable: aFiltering
95
	 * Purpose:  Container for plugin filtering functions
96
	 * Scope:    jQuery.fn.dataTableExt
97
	 */
98
	_oExt.afnFiltering = [ ];
99
 
100
	/*
101
	 * Variable: aoFeatures
102
	 * Purpose:  Container for plugin function functions
103
	 * Scope:    jQuery.fn.dataTableExt
104
	 * Notes:    Array of objects with the following parameters:
105
	 *   fnInit: Function for initialisation of Feature. Takes oSettings and returns node
106
	 *   cFeature: Character that will be matched in sDom - case sensitive
107
	 *   sFeature: Feature name - just for completeness :-)
108
	 */
109
	_oExt.aoFeatures = [ ];
110
 
111
	/*
112
	 * Variable: ofnSearch
113
	 * Purpose:  Container for custom filtering functions
114
	 * Scope:    jQuery.fn.dataTableExt
115
	 * Notes:    This is an object (the name should match the type) for custom filtering function,
116
	 *   which can be used for live DOM checking or formatted text filtering
117
	 */
118
	_oExt.ofnSearch = { };
119
 
120
	/*
121
	 * Variable: afnSortData
122
	 * Purpose:  Container for custom sorting data source functions
123
	 * Scope:    jQuery.fn.dataTableExt
124
	 * Notes:    Array (associative) of functions which is run prior to a column of this 
125
	 *   'SortDataType' being sorted upon.
126
	 *   Function input parameters:
127
	 *     object:oSettings-  DataTables settings object
128
	 *     int:iColumn - Target column number
129
	 *   Return value: Array of data which exactly matched the full data set size for the column to
130
	 *     be sorted upon
131
	 */
132
	_oExt.afnSortData = [ ];
133
 
134
	/*
135
	 * Variable: oStdClasses
136
	 * Purpose:  Storage for the various classes that DataTables uses
137
	 * Scope:    jQuery.fn.dataTableExt
138
	 */
139
	_oExt.oStdClasses = {
140
		/* Two buttons buttons */
141
		"sPagePrevEnabled": "paginate_enabled_previous",
142
		"sPagePrevDisabled": "paginate_disabled_previous",
143
		"sPageNextEnabled": "paginate_enabled_next",
144
		"sPageNextDisabled": "paginate_disabled_next",
145
		"sPageJUINext": "",
146
		"sPageJUIPrev": "",
147
 
148
		/* Full numbers paging buttons */
149
		"sPageButton": "paginate_button",
150
		"sPageButtonActive": "paginate_active",
151
		"sPageButtonStaticDisabled": "paginate_button paginate_button_disabled",
152
		"sPageFirst": "first",
153
		"sPagePrevious": "previous",
154
		"sPageNext": "next",
155
		"sPageLast": "last",
156
 
157
		/* Striping classes */
158
		"sStripeOdd": "odd",
159
		"sStripeEven": "even",
160
 
161
		/* Empty row */
162
		"sRowEmpty": "dataTables_empty",
163
 
164
		/* Features */
165
		"sWrapper": "dataTables_wrapper",
166
		"sFilter": "dataTables_filter",
167
		"sInfo": "dataTables_info",
168
		"sPaging": "dataTables_paginate paging_", /* Note that the type is postfixed */
169
		"sLength": "dataTables_length",
170
		"sProcessing": "dataTables_processing",
171
 
172
		/* Sorting */
173
		"sSortAsc": "sorting_asc",
174
		"sSortDesc": "sorting_desc",
175
		"sSortable": "sorting", /* Sortable in both directions */
176
		"sSortableAsc": "sorting_asc_disabled",
177
		"sSortableDesc": "sorting_desc_disabled",
178
		"sSortableNone": "sorting_disabled",
179
		"sSortColumn": "sorting_", /* Note that an int is postfixed for the sorting order */
180
		"sSortJUIAsc": "",
181
		"sSortJUIDesc": "",
182
		"sSortJUI": "",
183
		"sSortJUIAscAllowed": "",
184
		"sSortJUIDescAllowed": "",
185
		"sSortJUIWrapper": "",
186
		"sSortIcon": "",
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
		/* Striping classes */
224
		"sStripeOdd": "odd",
225
		"sStripeEven": "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
		"sSortIcon": "DataTables_sort_icon",
254
 
255
		/* Scrolling */
256
		"sScrollWrapper": "dataTables_scroll",
257
		"sScrollHead": "dataTables_scrollHead ui-state-default",
258
		"sScrollHeadInner": "dataTables_scrollHeadInner",
259
		"sScrollBody": "dataTables_scrollBody",
260
		"sScrollFoot": "dataTables_scrollFoot ui-state-default",
261
		"sScrollFootInner": "dataTables_scrollFootInner",
262
 
263
		/* Misc */
264
		"sFooterTH": "ui-state-default"
265
	};
266
 
267
	/*
268
	 * Variable: oPagination
269
	 * Purpose:  Container for the various type of pagination that dataTables supports
270
	 * Scope:    jQuery.fn.dataTableExt
271
	 */
272
	_oExt.oPagination = {
273
		/*
274
		 * Variable: two_button
275
		 * Purpose:  Standard two button (forward/back) pagination
276
		 * Scope:    jQuery.fn.dataTableExt.oPagination
277
		 */
278
		"two_button": {
279
			/*
280
			 * Function: oPagination.two_button.fnInit
281
			 * Purpose:  Initialise dom elements required for pagination with forward/back buttons only
282
			 * Returns:  -
283
			 * Inputs:   object:oSettings - dataTables settings object
284
			 *           node:nPaging - the DIV which contains this pagination control
285
			 *           function:fnCallbackDraw - draw function which must be called on update
286
			 */
287
			"fnInit": function ( oSettings, nPaging, fnCallbackDraw )
288
			{
289
				var nPrevious, nNext, nPreviousInner, nNextInner;
290
 
291
				/* Store the next and previous elements in the oSettings object as they can be very
292
				 * usful for automation - particularly testing
293
				 */
294
				if ( !oSettings.bJUI )
295
				{
296
					nPrevious = document.createElement( 'div' );
297
					nNext = document.createElement( 'div' );
298
				}
299
				else
300
				{
301
					nPrevious = document.createElement( 'a' );
302
					nNext = document.createElement( 'a' );
303
 
304
					nNextInner = document.createElement('span');
305
					nNextInner.className = oSettings.oClasses.sPageJUINext;
306
					nNext.appendChild( nNextInner );
307
 
308
					nPreviousInner = document.createElement('span');
309
					nPreviousInner.className = oSettings.oClasses.sPageJUIPrev;
310
					nPrevious.appendChild( nPreviousInner );
311
				}
312
 
313
				nPrevious.className = oSettings.oClasses.sPagePrevDisabled;
314
				nNext.className = oSettings.oClasses.sPageNextDisabled;
315
 
316
				nPrevious.title = oSettings.oLanguage.oPaginate.sPrevious;
317
				nNext.title = oSettings.oLanguage.oPaginate.sNext;
318
 
319
				nPaging.appendChild( nPrevious );
320
				nPaging.appendChild( nNext );
321
 
322
				$(nPrevious).on( 'click.DT', function() {
323
					if ( oSettings.oApi._fnPageChange( oSettings, "previous" ) )
324
					{
325
						/* Only draw when the page has actually changed */
326
						fnCallbackDraw( oSettings );
327
					}
328
				} );
329
 
330
				$(nNext).on( 'click.DT', function() {
331
					if ( oSettings.oApi._fnPageChange( oSettings, "next" ) )
332
					{
333
						fnCallbackDraw( oSettings );
334
					}
335
				} );
336
 
337
				/* Take the brutal approach to cancelling text selection */
338
				$(nPrevious).on( 'selectstart.DT', function () { return false; } );
339
				$(nNext).on( 'selectstart.DT', function () { return false; } );
340
 
341
				/* ID the first elements only */
342
				if ( oSettings.sTableId !== '' && typeof oSettings.aanFeatures.p == "undefined" )
343
				{
344
					nPaging.setAttribute( 'id', oSettings.sTableId+'_paginate' );
345
					nPrevious.setAttribute( 'id', oSettings.sTableId+'_previous' );
346
					nNext.setAttribute( 'id', oSettings.sTableId+'_next' );
347
				}
348
			},
349
 
350
			/*
351
			 * Function: oPagination.two_button.fnUpdate
352
			 * Purpose:  Update the two button pagination at the end of the draw
353
			 * Returns:  -
354
			 * Inputs:   object:oSettings - dataTables settings object
355
			 *           function:fnCallbackDraw - draw function to call on page change
356
			 */
357
			"fnUpdate": function ( oSettings, fnCallbackDraw )
358
			{
359
				if ( !oSettings.aanFeatures.p )
360
				{
361
					return;
362
				}
363
 
364
				/* Loop over each instance of the pager */
365
				var an = oSettings.aanFeatures.p;
366
				for ( var i=0, iLen=an.length ; i<iLen ; i++ )
367
				{
368
					if ( an[i].childNodes.length !== 0 )
369
					{
370
						an[i].childNodes[0].className = 
371
							( oSettings._iDisplayStart === 0 ) ? 
372
							oSettings.oClasses.sPagePrevDisabled : oSettings.oClasses.sPagePrevEnabled;
373
 
374
						an[i].childNodes[1].className = 
375
							( oSettings.fnDisplayEnd() == oSettings.fnRecordsDisplay() ) ? 
376
							oSettings.oClasses.sPageNextDisabled : oSettings.oClasses.sPageNextEnabled;
377
					}
378
				}
379
			}
380
		},
381
 
382
 
383
		/*
384
		 * Variable: iFullNumbersShowPages
385
		 * Purpose:  Change the number of pages which can be seen
386
		 * Scope:    jQuery.fn.dataTableExt.oPagination
387
		 */
388
		"iFullNumbersShowPages": 5,
389
 
390
		/*
391
		 * Variable: full_numbers
392
		 * Purpose:  Full numbers pagination
393
		 * Scope:    jQuery.fn.dataTableExt.oPagination
394
		 */
395
		"full_numbers": {
396
			/*
397
			 * Function: oPagination.full_numbers.fnInit
398
			 * Purpose:  Initialise dom elements required for pagination with a list of the pages
399
			 * Returns:  -
400
			 * Inputs:   object:oSettings - dataTables settings object
401
			 *           node:nPaging - the DIV which contains this pagination control
402
			 *           function:fnCallbackDraw - draw function which must be called on update
403
			 */
404
			"fnInit": function ( oSettings, nPaging, fnCallbackDraw )
405
			{
406
				var nFirst = document.createElement( 'span' );
407
				var nPrevious = document.createElement( 'span' );
408
				var nList = document.createElement( 'span' );
409
				var nNext = document.createElement( 'span' );
410
				var nLast = document.createElement( 'span' );
411
 
412
				nFirst.innerHTML = oSettings.oLanguage.oPaginate.sFirst;
413
				nPrevious.innerHTML = oSettings.oLanguage.oPaginate.sPrevious;
414
				nNext.innerHTML = oSettings.oLanguage.oPaginate.sNext;
415
				nLast.innerHTML = oSettings.oLanguage.oPaginate.sLast;
416
 
417
				var oClasses = oSettings.oClasses;
418
				nFirst.className = oClasses.sPageButton+" "+oClasses.sPageFirst;
419
				nPrevious.className = oClasses.sPageButton+" "+oClasses.sPagePrevious;
420
				nNext.className= oClasses.sPageButton+" "+oClasses.sPageNext;
421
				nLast.className = oClasses.sPageButton+" "+oClasses.sPageLast;
422
 
423
				nPaging.appendChild( nFirst );
424
				nPaging.appendChild( nPrevious );
425
				nPaging.appendChild( nList );
426
				nPaging.appendChild( nNext );
427
				nPaging.appendChild( nLast );
428
 
429
				$(nFirst).on( 'click.DT', function () {
430
					if ( oSettings.oApi._fnPageChange( oSettings, "first" ) )
431
					{
432
						fnCallbackDraw( oSettings );
433
					}
434
				} );
435
 
436
				$(nPrevious).on( 'click.DT', function() {
437
					if ( oSettings.oApi._fnPageChange( oSettings, "previous" ) )
438
					{
439
						fnCallbackDraw( oSettings );
440
					}
441
				} );
442
 
443
				$(nNext).on( 'click.DT', function() {
444
					if ( oSettings.oApi._fnPageChange( oSettings, "next" ) )
445
					{
446
						fnCallbackDraw( oSettings );
447
					}
448
				} );
449
 
450
				$(nLast).on( 'click.DT', function() {
451
					if ( oSettings.oApi._fnPageChange( oSettings, "last" ) )
452
					{
453
						fnCallbackDraw( oSettings );
454
					}
455
				} );
456
 
457
				/* Take the brutal approach to cancelling text selection */
458
				$('span', nPaging)
459
					.on( 'mousedown.DT', function () { return false; } )
460
					.on( 'selectstart.DT', function () { return false; } );
461
 
462
				/* ID the first elements only */
463
				if ( oSettings.sTableId !== '' && typeof oSettings.aanFeatures.p == "undefined" )
464
				{
465
					nPaging.setAttribute( 'id', oSettings.sTableId+'_paginate' );
466
					nFirst.setAttribute( 'id', oSettings.sTableId+'_first' );
467
					nPrevious.setAttribute( 'id', oSettings.sTableId+'_previous' );
468
					nNext.setAttribute( 'id', oSettings.sTableId+'_next' );
469
					nLast.setAttribute( 'id', oSettings.sTableId+'_last' );
470
				}
471
			},
472
 
473
			/*
474
			 * Function: oPagination.full_numbers.fnUpdate
475
			 * Purpose:  Update the list of page buttons shows
476
			 * Returns:  -
477
			 * Inputs:   object:oSettings - dataTables settings object
478
			 *           function:fnCallbackDraw - draw function to call on page change
479
			 */
480
			"fnUpdate": function ( oSettings, fnCallbackDraw )
481
			{
482
				if ( !oSettings.aanFeatures.p )
483
				{
484
					return;
485
				}
486
 
487
				var iPageCount = _oExt.oPagination.iFullNumbersShowPages;
488
				var iPageCountHalf = Math.floor(iPageCount / 2);
489
				var iPages = Math.ceil((oSettings.fnRecordsDisplay()) / oSettings._iDisplayLength);
490
				var iCurrentPage = Math.ceil(oSettings._iDisplayStart / oSettings._iDisplayLength) + 1;
491
				var sList = "";
492
				var iStartButton, iEndButton, i, iLen;
493
				var oClasses = oSettings.oClasses;
494
 
495
				/* Pages calculation */
496
				if (iPages < iPageCount)
497
< iPageCount)				{
498
< iPageCount)					iStartButton = 1;
499
< iPageCount)					iEndButton = iPages;
500
< iPageCount)				}
501
< iPageCount)				else
502
< iPageCount)				{
503
< iPageCount)					if (iCurrentPage <= iPageCountHalf)
504
< iPageCount)<= iPageCountHalf)					{
505
< iPageCount)<= iPageCountHalf)						iStartButton = 1;
506
< iPageCount)<= iPageCountHalf)						iEndButton = iPageCount;
507
< iPageCount)<= iPageCountHalf)					}
508
< iPageCount)<= iPageCountHalf)					else
509
< iPageCount)<= iPageCountHalf)					{
510
< iPageCount)<= iPageCountHalf)						if (iCurrentPage >= (iPages - iPageCountHalf))
511
< iPageCount)<= iPageCountHalf)						{
512
< iPageCount)<= iPageCountHalf)							iStartButton = iPages - iPageCount + 1;
513
< iPageCount)<= iPageCountHalf)							iEndButton = iPages;
514
< iPageCount)<= iPageCountHalf)						}
515
< iPageCount)<= iPageCountHalf)						else
516
< iPageCount)<= iPageCountHalf)						{
517
< iPageCount)<= iPageCountHalf)							iStartButton = iCurrentPage - Math.ceil(iPageCount / 2) + 1;
518
< iPageCount)<= iPageCountHalf)							iEndButton = iStartButton + iPageCount - 1;
519
< iPageCount)<= iPageCountHalf)						}
520
< iPageCount)<= iPageCountHalf)					}
521
< iPageCount)<= iPageCountHalf)				}
522
 
523
< iPageCount)<= iPageCountHalf)				/* Build the dynamic list */
524
< iPageCount)<= iPageCountHalf)				for ( i=iStartButton ; i<=iEndButton ; i++ )
525
< iPageCount)<= iPageCountHalf)				{
526
< iPageCount)<= iPageCountHalf)					if ( iCurrentPage != i )
527
< iPageCount)<= iPageCountHalf)					{
528
< iPageCount)<= iPageCountHalf)						sList += '<span class="'+oClasses.sPageButton+'">'+i+'</span>';
529
< iPageCount)<= iPageCountHalf)					}
530
< iPageCount)<= iPageCountHalf)					else
531
< iPageCount)<= iPageCountHalf)					{
532
< iPageCount)<= iPageCountHalf)						sList += '<span class="'+oClasses.sPageButtonActive+'">'+i+'</span>';
533
< iPageCount)<= iPageCountHalf)					}
534
< iPageCount)<= iPageCountHalf)				}
535
 
536
< iPageCount)<= iPageCountHalf)				/* Loop over each instance of the pager */
537
< iPageCount)<= iPageCountHalf)				var an = oSettings.aanFeatures.p;
538
< iPageCount)<= iPageCountHalf)				var anButtons, anStatic, nPaginateList;
539
< iPageCount)<= iPageCountHalf)				var fnClick = function(e) {
540
< iPageCount)<= iPageCountHalf)					/* Use the information in the element to jump to the required page */
541
< iPageCount)<= iPageCountHalf)					var iTarget = (this.innerHTML * 1) - 1;
542
< iPageCount)<= iPageCountHalf)					oSettings._iDisplayStart = iTarget * oSettings._iDisplayLength;
543
< iPageCount)<= iPageCountHalf)					fnCallbackDraw( oSettings );
544
< iPageCount)<= iPageCountHalf)					e.preventDefault();
545
< iPageCount)<= iPageCountHalf)				};
546
< iPageCount)<= iPageCountHalf)				var fnFalse = function () { return false; };
547
 
548
< iPageCount)<= iPageCountHalf)				for ( i=0, iLen=an.length ; i<iLen ; i++ )
549
< iPageCount)<= iPageCountHalf)				{
550
< iPageCount)<= iPageCountHalf)					if ( an[i].childNodes.length === 0 )
551
< iPageCount)<= iPageCountHalf)					{
552
< iPageCount)<= iPageCountHalf)						continue;
553
< iPageCount)<= iPageCountHalf)					}
554
 
555
< iPageCount)<= iPageCountHalf)					/* Build up the dynamic list forst - html and listeners */
556
< iPageCount)<= iPageCountHalf)					var qjPaginateList = $('span:eq(2)', an[i]);
557
< iPageCount)<= iPageCountHalf)					qjPaginateList.html( sList );
558
< iPageCount)<= iPageCountHalf)					$('span', qjPaginateList).on( 'click.DT', fnClick ).on( 'mousedown.DT', fnFalse )
559
< iPageCount)<= iPageCountHalf)						.on( 'selectstart.DT', fnFalse );
560
 
561
< iPageCount)<= iPageCountHalf)					/* Update the 'premanent botton's classes */
562
< iPageCount)<= iPageCountHalf)					anButtons = an[i].getElementsByTagName('span');
563
< iPageCount)<= iPageCountHalf)					anStatic = [
564
< iPageCount)<= iPageCountHalf)						anButtons[0], anButtons[1], 
565
< iPageCount)<= iPageCountHalf)						anButtons[anButtons.length-2], anButtons[anButtons.length-1]
566
< iPageCount)<= iPageCountHalf)					];
567
< iPageCount)<= iPageCountHalf)					$(anStatic).removeClass( oClasses.sPageButton+" "+oClasses.sPageButtonActive+" "+oClasses.sPageButtonStaticDisabled );
568
< iPageCount)<= iPageCountHalf)					if ( iCurrentPage == 1 )
569
< iPageCount)<= iPageCountHalf)					{
570
< iPageCount)<= iPageCountHalf)						anStatic[0].className += " "+oClasses.sPageButtonStaticDisabled;
571
< iPageCount)<= iPageCountHalf)						anStatic[1].className += " "+oClasses.sPageButtonStaticDisabled;
572
< iPageCount)<= iPageCountHalf)					}
573
< iPageCount)<= iPageCountHalf)					else
574
< iPageCount)<= iPageCountHalf)					{
575
< iPageCount)<= iPageCountHalf)						anStatic[0].className += " "+oClasses.sPageButton;
576
< iPageCount)<= iPageCountHalf)						anStatic[1].className += " "+oClasses.sPageButton;
577
< iPageCount)<= iPageCountHalf)					}
578
 
579
< iPageCount)<= iPageCountHalf)					if ( iPages === 0 || iCurrentPage == iPages || oSettings._iDisplayLength == -1 )
580
< iPageCount)<= iPageCountHalf)					{
581
< iPageCount)<= iPageCountHalf)						anStatic[2].className += " "+oClasses.sPageButtonStaticDisabled;
582
< iPageCount)<= iPageCountHalf)						anStatic[3].className += " "+oClasses.sPageButtonStaticDisabled;
583
< iPageCount)<= iPageCountHalf)					}
584
< iPageCount)<= iPageCountHalf)					else
585
< iPageCount)<= iPageCountHalf)					{
586
< iPageCount)<= iPageCountHalf)						anStatic[2].className += " "+oClasses.sPageButton;
587
< iPageCount)<= iPageCountHalf)						anStatic[3].className += " "+oClasses.sPageButton;
588
< iPageCount)<= iPageCountHalf)					}
589
< iPageCount)<= iPageCountHalf)				}
590
< iPageCount)<= iPageCountHalf)			}
591
< iPageCount)<= iPageCountHalf)		}
592
< iPageCount)<= iPageCountHalf)	};
593
 
594
< iPageCount)<= iPageCountHalf)	/*
595
< iPageCount)<= iPageCountHalf)	 * Variable: oSort
596
< iPageCount)<= iPageCountHalf)	 * Purpose:  Wrapper for the sorting functions that can be used in DataTables
597
< iPageCount)<= iPageCountHalf)	 * Scope:    jQuery.fn.dataTableExt
598
< iPageCount)<= iPageCountHalf)	 * Notes:    The functions provided in this object are basically standard javascript sort
599
< iPageCount)<= iPageCountHalf)	 *   functions - they expect two inputs which they then compare and then return a priority
600
< iPageCount)<= iPageCountHalf)	 *   result. For each sort method added, two functions need to be defined, an ascending sort and
601
< iPageCount)<= iPageCountHalf)	 *   a descending sort.
602
< iPageCount)<= iPageCountHalf)	 */
603
< iPageCount)<= iPageCountHalf)	_oExt.oSort = {
604
< iPageCount)<= iPageCountHalf)		/*
605
< iPageCount)<= iPageCountHalf)		 * text sorting
606
< iPageCount)<= iPageCountHalf)		 */
607
< iPageCount)<= iPageCountHalf)		"string-asc": function ( a, b )
608
< iPageCount)<= iPageCountHalf)		{
609
< iPageCount)<= iPageCountHalf)			if ( typeof a != 'string' ) { a = ''; }
610
< iPageCount)<= iPageCountHalf)			if ( typeof b != 'string' ) { b = ''; }
611
< iPageCount)<= iPageCountHalf)			var x = a.toLowerCase();
612
< iPageCount)<= iPageCountHalf)			var y = b.toLowerCase();
613
< iPageCount)<= iPageCountHalf)			return ((x < y) ? -1 : ((x > y) ? 1 : 0));
614
< iPageCount)<= iPageCountHalf)		},
615
 
616
< iPageCount)<= iPageCountHalf)		"string-desc": function ( a, b )
617
< iPageCount)<= iPageCountHalf)		{
618
< iPageCount)<= iPageCountHalf)			if ( typeof a != 'string' ) { a = ''; }
619
< iPageCount)<= iPageCountHalf)			if ( typeof b != 'string' ) { b = ''; }
620
< iPageCount)<= iPageCountHalf)			var x = a.toLowerCase();
621
< iPageCount)<= iPageCountHalf)			var y = b.toLowerCase();
622
< iPageCount)<= iPageCountHalf)			return ((x < y) ? 1 : ((x > y) ? -1 : 0));
623
< iPageCount)<= iPageCountHalf)		},
624
 
625
 
626
< iPageCount)<= iPageCountHalf)		/*
627
< iPageCount)<= iPageCountHalf)		 * html sorting (ignore html tags)
628
< iPageCount)<= iPageCountHalf)		 */
629
< iPageCount)<= iPageCountHalf)		"html-asc": function ( a, b )
630
< iPageCount)<= iPageCountHalf)		{
631
< iPageCount)<= iPageCountHalf)			var x = a.replace( /<.*?>/g, "" ).toLowerCase();
632
< iPageCount)<= iPageCountHalf)<.*?>			var y = b.replace( /<.*?>/g, "" ).toLowerCase();
633
< iPageCount)<= iPageCountHalf)<.*?><.*?>			return ((x < y) ? -1 : ((x > y) ? 1 : 0));
634
< iPageCount)<= iPageCountHalf)<.*?><.*?>		},
635
 
636
< iPageCount)<= iPageCountHalf)<.*?><.*?>		"html-desc": function ( a, b )
637
< iPageCount)<= iPageCountHalf)<.*?><.*?>		{
638
< iPageCount)<= iPageCountHalf)<.*?><.*?>			var x = a.replace( /<.*?>/g, "" ).toLowerCase();
639
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?>			var y = b.replace( /<.*?>/g, "" ).toLowerCase();
640
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			return ((x < y) ? 1 : ((x > y) ? -1 : 0));
641
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		},
642
 
643
 
644
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
645
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * date sorting
646
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
647
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		"date-asc": function ( a, b )
648
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
649
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var x = Date.parse( a );
650
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var y = Date.parse( b );
651
 
652
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( isNaN(x) || x==="" )
653
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
654
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			x = Date.parse( "01/01/1970 00:00:00" );
655
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
656
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( isNaN(y) || y==="" )
657
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
658
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				y =	Date.parse( "01/01/1970 00:00:00" );
659
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
660
 
661
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			return x - y;
662
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		},
663
 
664
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		"date-desc": function ( a, b )
665
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
666
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var x = Date.parse( a );
667
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var y = Date.parse( b );
668
 
669
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( isNaN(x) || x==="" )
670
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
671
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			x = Date.parse( "01/01/1970 00:00:00" );
672
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
673
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( isNaN(y) || y==="" )
674
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
675
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				y =	Date.parse( "01/01/1970 00:00:00" );
676
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
677
 
678
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			return y - x;
679
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		},
680
 
681
 
682
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
683
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * numerical sorting
684
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
685
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		"numeric-asc": function ( a, b )
686
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
687
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var x = (a=="-" || a==="") ? 0 : a*1;
688
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var y = (b=="-" || b==="") ? 0 : b*1;
689
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			return x - y;
690
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		},
691
 
692
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		"numeric-desc": function ( a, b )
693
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
694
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var x = (a=="-" || a==="") ? 0 : a*1;
695
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var y = (b=="-" || b==="") ? 0 : b*1;
696
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			return y - x;
697
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
698
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	};
699
 
700
 
701
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	/*
702
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 * Variable: aTypes
703
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 * Purpose:  Container for the various type of type detection that dataTables supports
704
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 * Scope:    jQuery.fn.dataTableExt
705
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 * Notes:    The functions in this array are expected to parse a string to see if it is a data
706
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 *   type that it recognises. If so then the function should return the name of the type (a
707
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 *   corresponding sort function should be defined!), if the type is not recognised then the
708
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 *   function should return null such that the parser and move on to check the next type.
709
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 *   Note that ordering is important in this array - the functions are processed linearly,
710
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 *   starting at index 0.
711
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 *   Note that the input for these functions is always a string! It cannot be any other data
712
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 *   type
713
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 */
714
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	_oExt.aTypes = [
715
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
716
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: -
717
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Check to see if a string is numeric
718
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  string:'numeric' or null
719
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   mixed:sText - string to check
720
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
721
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function ( sData )
722
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
723
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Allow zero length strings as a number */
724
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof sData == 'number' )
725
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
726
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				return 'numeric';
727
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
728
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else if ( typeof sData != 'string' )
729
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
730
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				return null;
731
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
732
 
733
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var sValidFirstChars = "0123456789-";
734
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var sValidChars = "0123456789.";
735
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var Char;
736
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var bDecimal = false;
737
 
738
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Check for a valid first char (no period and allow negatives) */
739
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			Char = sData.charAt(0); 
740
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if (sValidFirstChars.indexOf(Char) == -1) 
741
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
742
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				return null;
743
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
744
 
745
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Check all the other characters are valid */
746
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			for ( var i=1 ; i<sData.length ; i++ ) 
747
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
748
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				Char = sData.charAt(i); 
749
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if (sValidChars.indexOf(Char) == -1) 
750
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
751
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					return null;
752
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
753
 
754
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Only allowed one decimal place... */
755
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( Char == "." )
756
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
757
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( bDecimal )
758
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
759
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						return null;
760
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
761
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					bDecimal = true;
762
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
763
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
764
 
765
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			return 'numeric';
766
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		},
767
 
768
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
769
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: -
770
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Check to see if a string is actually a formatted date
771
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  string:'date' or null
772
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   string:sText - string to check
773
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
774
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function ( sData )
775
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
776
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var iParse = Date.parse(sData);
777
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( (iParse !== null && !isNaN(iParse)) || (typeof sData == 'string' && sData.length === 0) )
778
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
779
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				return 'date';
780
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
781
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			return null;
782
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		},
783
 
784
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
785
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: -
786
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Check to see if a string should be treated as an HTML string
787
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  string:'html' or null
788
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   string:sText - string to check
789
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
790
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function ( sData )
791
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
792
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof sData == 'string' && sData.indexOf('<') != -1 && sData.indexOf('>') != -1 )
793
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
794
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				return 'html';
795
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
796
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			return null;
797
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
798
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	];
799
 
800
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	/*
801
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 * Function: fnVersionCheck
802
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 * Purpose:  Check a version string against this version of DataTables. Useful for plug-ins
803
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 * Returns:  bool:true -this version of DataTables is greater or equal to the required version
804
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 *                false -this version of DataTales is not suitable
805
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 * Inputs:   string:sVersion - the version to check against. May be in the following formats:
806
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 *             "a", "a.b" or "a.b.c"
807
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 * Notes:    This function will only check the first three parts of a version string. It is
808
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 *   assumed that beta and dev versions will meet the requirements. This might change in future
809
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 */
810
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	_oExt.fnVersionCheck = function( sVersion )
811
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	{
812
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/* This is cheap, but very effective */
813
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		var fnZPad = function (Zpad, count)
814
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
815
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			while(Zpad.length < count) {
816
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				Zpad += '0';
817
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
818
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			return Zpad;
819
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		};
820
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		var aThis = _oExt.sVersion.split('.');
821
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		var aThat = sVersion.split('.');
822
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		var sThis = '', sThat = '';
823
 
824
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		for ( var i=0, iLen=aThat.length ; i<iLen ; i++ )
825
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
826
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			sThis += fnZPad( aThis[i], 3 );
827
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			sThat += fnZPad( aThat[i], 3 );
828
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
829
 
830
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		return parseInt(sThis, 10) >= parseInt(sThat, 10);
831
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	};
832
 
833
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	/*
834
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 * Variable: _oExternConfig
835
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 * Purpose:  Store information for DataTables to access globally about other instances
836
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 * Scope:    jQuery.fn.dataTableExt
837
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 */
838
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	_oExt._oExternConfig = {
839
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/* int:iNextUnique - next unique number for an instance */
840
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		"iNextUnique": 0
841
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	};
842
 
843
 
844
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
845
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 * Section - DataTables prototype
846
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
847
 
848
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	/*
849
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 * Function: dataTable
850
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 * Purpose:  DataTables information
851
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 * Returns:  -
852
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 * Inputs:   object:oInit - initialisation options for the table
853
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	 */
854
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	$.fn.dataTable = function( oInit )
855
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>	{
856
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
857
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: classSettings
858
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Settings container function for all 'class' properties which are required
859
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *   by dataTables
860
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
861
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   -
862
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
863
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function classSettings ()
864
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
865
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.fnRecordsTotal = function ()
866
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
867
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( this.oFeatures.bServerSide ) {
868
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					return parseInt(this._iRecordsTotal, 10);
869
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				} else {
870
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					return this.aiDisplayMaster.length;
871
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
872
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			};
873
 
874
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.fnRecordsDisplay = function ()
875
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
876
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( this.oFeatures.bServerSide ) {
877
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					return parseInt(this._iRecordsDisplay, 10);
878
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				} else {
879
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					return this.aiDisplay.length;
880
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
881
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			};
882
 
883
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.fnDisplayEnd = function ()
884
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
885
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( this.oFeatures.bServerSide ) {
886
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( this.oFeatures.bPaginate === false || this._iDisplayLength == -1 ) {
887
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						return this._iDisplayStart+this.aiDisplay.length;
888
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					} else {
889
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						return Math.min( this._iDisplayStart+this._iDisplayLength, 
890
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							this._iRecordsDisplay );
891
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
892
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				} else {
893
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					return this._iDisplayEnd;
894
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
895
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			};
896
 
897
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
898
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: oInstance
899
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  The DataTables object for this table
900
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings 
901
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
902
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.oInstance = null;
903
 
904
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
905
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: sInstance
906
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Unique idendifier for each instance of the DataTables object
907
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings 
908
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
909
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.sInstance = null;
910
 
911
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
912
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: oFeatures
913
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Indicate the enablement of key dataTable features
914
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings 
915
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
916
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.oFeatures = {
917
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"bPaginate": true,
918
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"bLengthChange": true,
919
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"bFilter": true,
920
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"bSort": true,
921
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"bInfo": true,
922
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"bAutoWidth": true,
923
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"bProcessing": false,
924
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"bSortClasses": true,
925
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"bStateSave": false,
926
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"bServerSide": false,
927
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"bDeferRender": false
928
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			};
929
 
930
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
931
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: oScroll
932
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Container for scrolling options
933
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings 
934
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
935
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.oScroll = {
936
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sX": "",
937
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sXInner": "",
938
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sY": "",
939
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"bCollapse": false,
940
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"bInfinite": false,
941
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"iLoadGap": 100,
942
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"iBarWidth": 0,
943
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"bAutoCss": true
944
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			};
945
 
946
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
947
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: aanFeatures
948
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Array referencing the nodes which are used for the features
949
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings 
950
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Notes:    The parameters of this object match what is allowed by sDom - i.e.
951
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   'l' - Length changing
952
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   'f' - Filtering input
953
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   't' - The table!
954
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   'i' - Information
955
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   'p' - Pagination
956
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   'r' - pRocessing
957
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
958
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.aanFeatures = [];
959
 
960
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
961
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: oLanguage
962
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Store the language strings used by dataTables
963
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
964
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Notes:    The words in the format _VAR_ are variables which are dynamically replaced
965
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   by javascript
966
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
967
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.oLanguage = {
968
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sProcessing": "Processing...",
969
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sLengthMenu": "Show _MENU_ entries",
970
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sZeroRecords": "No matching records found",
971
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sEmptyTable": "No data available in table",
972
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sLoadingRecords": "Loading...",
973
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sInfo": "Showing _START_ to _END_ of _TOTAL_ entries",
974
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sInfoEmpty": "Showing 0 to 0 of 0 entries",
975
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sInfoFiltered": "(filtered from _MAX_ total entries)",
976
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sInfoPostFix": "",
977
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sInfoThousands": ",",
978
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sSearch": "Search:",
979
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sUrl": "",
980
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"oPaginate": {
981
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					"sFirst":    "First",
982
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					"sPrevious": "Previous",
983
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					"sNext":     "Next",
984
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					"sLast":     "Last"
985
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				},
986
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"fnInfoCallback": null
987
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			};
988
 
989
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
990
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: aoData
991
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Store data information
992
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings 
993
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Notes:    This is an array of objects with the following parameters:
994
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   int: _iId - internal id for tracking
995
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   array: _aData - internal data - used for sorting / filtering etc
996
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   node: nTr - display node
997
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   array node: _anHidden - hidden TD nodes
998
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   string: _sRowStripe
999
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1000
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.aoData = [];
1001
 
1002
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1003
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: aiDisplay
1004
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Array of indexes which are in the current display (after filtering etc)
1005
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1006
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1007
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.aiDisplay = [];
1008
 
1009
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1010
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: aiDisplayMaster
1011
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Array of indexes for display - no filtering
1012
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1013
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1014
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.aiDisplayMaster = [];
1015
 
1016
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1017
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: aoColumns
1018
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Store information about each column that is in use
1019
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings 
1020
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1021
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.aoColumns = [];
1022
 
1023
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1024
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: aoHeader
1025
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Store information about the table's header
1026
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings 
1027
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1028
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.aoHeader = [];
1029
 
1030
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1031
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: aoFooter
1032
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Store information about the table's footer
1033
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings 
1034
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1035
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.aoFooter = [];
1036
 
1037
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1038
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: iNextId
1039
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Store the next unique id to be used for a new row
1040
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings 
1041
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1042
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.iNextId = 0;
1043
 
1044
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1045
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: asDataSearch
1046
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Search data array for regular expression searching
1047
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1048
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1049
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.asDataSearch = [];
1050
 
1051
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1052
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: oPreviousSearch
1053
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Store the previous search incase we want to force a re-search
1054
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   or compare the old search to a new one
1055
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1056
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1057
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.oPreviousSearch = {
1058
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sSearch": "",
1059
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"bRegex": false,
1060
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"bSmart": true
1061
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			};
1062
 
1063
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1064
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: aoPreSearchCols
1065
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Store the previous search for each column
1066
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1067
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1068
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.aoPreSearchCols = [];
1069
 
1070
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1071
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: aaSorting
1072
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Sorting information
1073
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1074
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Notes:    Index 0 - column number
1075
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *           Index 1 - current sorting direction
1076
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *           Index 2 - index of asSorting for this column
1077
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1078
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.aaSorting = [ [0, 'asc', 0] ];
1079
 
1080
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1081
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: aaSortingFixed
1082
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Sorting information that is always applied
1083
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1084
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1085
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.aaSortingFixed = null;
1086
 
1087
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1088
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: asStripeClasses
1089
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Classes to use for the striping of a table
1090
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1091
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1092
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.asStripeClasses = [];
1093
 
1094
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1095
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: asDestroyStripes
1096
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  If restoring a table - we should restore its striping classes as well
1097
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1098
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1099
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.asDestroyStripes = [];
1100
 
1101
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1102
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: sDestroyWidth
1103
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  If restoring a table - we should restore its width
1104
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1105
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1106
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.sDestroyWidth = 0;
1107
 
1108
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1109
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: fnRowCallback
1110
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Call this function every time a row is inserted (draw)
1111
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1112
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1113
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.fnRowCallback = null;
1114
 
1115
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1116
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: fnHeaderCallback
1117
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Callback function for the header on each draw
1118
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1119
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1120
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.fnHeaderCallback = null;
1121
 
1122
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1123
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: fnFooterCallback
1124
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Callback function for the footer on each draw
1125
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1126
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1127
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.fnFooterCallback = null;
1128
 
1129
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1130
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: aoDrawCallback
1131
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Array of callback functions for draw callback functions
1132
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1133
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Notes:    Each array element is an object with the following parameters:
1134
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   function:fn - function to call
1135
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   string:sName - name callback (feature). useful for arranging array
1136
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1137
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.aoDrawCallback = [];
1138
 
1139
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1140
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: fnPreDrawCallback
1141
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Callback function for just before the table is redrawn. A return of false
1142
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *           will be used to cancel the draw.
1143
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1144
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1145
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.fnPreDrawCallback = null;
1146
 
1147
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1148
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: fnInitComplete
1149
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Callback function for when the table has been initialised
1150
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1151
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1152
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.fnInitComplete = null;
1153
 
1154
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1155
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: sTableId
1156
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Cache the table ID for quick access
1157
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1158
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1159
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.sTableId = "";
1160
 
1161
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1162
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: nTable
1163
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Cache the table node for quick access
1164
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1165
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1166
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.nTable = null;
1167
 
1168
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1169
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: nTHead
1170
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Permanent ref to the thead element
1171
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1172
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1173
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.nTHead = null;
1174
 
1175
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1176
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: nTFoot
1177
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Permanent ref to the tfoot element - if it exists
1178
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1179
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1180
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.nTFoot = null;
1181
 
1182
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1183
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: nTBody
1184
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Permanent ref to the tbody element
1185
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1186
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1187
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.nTBody = null;
1188
 
1189
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1190
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: nTableWrapper
1191
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Cache the wrapper node (contains all DataTables controlled elements)
1192
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1193
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1194
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.nTableWrapper = null;
1195
 
1196
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1197
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: bDeferLoading
1198
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Indicate if when using server-side processing the loading of data 
1199
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *           should be deferred until the second draw
1200
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1201
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1202
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.bDeferLoading = false;
1203
 
1204
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1205
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: bInitialised
1206
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Indicate if all required information has been read in
1207
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1208
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1209
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.bInitialised = false;
1210
 
1211
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1212
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: aoOpenRows
1213
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Information about open rows
1214
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1215
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Notes:    Has the parameters 'nTr' and 'nParent'
1216
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1217
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.aoOpenRows = [];
1218
 
1219
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1220
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: sDom
1221
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Dictate the positioning that the created elements will take
1222
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1223
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Notes:    
1224
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   The following options are allowed:
1225
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *     'l' - Length changing
1226
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *     'f' - Filtering input
1227
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *     't' - The table!
1228
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *     'i' - Information
1229
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *     'p' - Pagination
1230
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *     'r' - pRocessing
1231
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   The following constants are allowed:
1232
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *     'H' - jQueryUI theme "header" classes
1233
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *     'F' - jQueryUI theme "footer" classes
1234
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   The following syntax is expected:
1235
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *     '<' and '>' - div elements
1236
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *     '<"class" and '>' - div with a class
1237
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   Examples:
1238
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *     '<"wrapper"flipt>', '<lf<t>ip>'
1239
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1240
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.sDom = 'lfrtip';
1241
 
1242
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1243
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: sPaginationType
1244
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Note which type of sorting should be used
1245
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1246
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1247
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.sPaginationType = "two_button";
1248
 
1249
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1250
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: iCookieDuration
1251
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  The cookie duration (for bStateSave) in seconds - default 2 hours
1252
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1253
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1254
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.iCookieDuration = 60 * 60 * 2;
1255
 
1256
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1257
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: sCookiePrefix
1258
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  The cookie name prefix
1259
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1260
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1261
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.sCookiePrefix = "SpryMedia_DataTables_";
1262
 
1263
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1264
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: fnCookieCallback
1265
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Callback function for cookie creation
1266
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1267
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1268
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.fnCookieCallback = null;
1269
 
1270
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1271
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: aoStateSave
1272
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Array of callback functions for state saving
1273
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1274
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Notes:    Each array element is an object with the following parameters:
1275
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   function:fn - function to call. Takes two parameters, oSettings and the JSON string to
1276
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *     save that has been thus far created. Returns a JSON string to be inserted into a 
1277
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *     json object (i.e. '"param": [ 0, 1, 2]')
1278
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   string:sName - name of callback
1279
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1280
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.aoStateSave = [];
1281
 
1282
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1283
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: aoStateLoad
1284
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Array of callback functions for state loading
1285
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1286
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Notes:    Each array element is an object with the following parameters:
1287
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   function:fn - function to call. Takes two parameters, oSettings and the object stored.
1288
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *     May return false to cancel state loading.
1289
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   string:sName - name of callback
1290
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1291
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.aoStateLoad = [];
1292
 
1293
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1294
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: oLoadedState
1295
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  State that was loaded from the cookie. Useful for back reference
1296
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1297
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1298
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.oLoadedState = null;
1299
 
1300
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1301
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: sAjaxSource
1302
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Source url for AJAX data for the table
1303
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1304
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1305
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.sAjaxSource = null;
1306
 
1307
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1308
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: sAjaxDataProp
1309
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Property from a given object from which to read the table data from. This can
1310
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *           be an empty string (when not server-side processing), in which case it is 
1311
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *           assumed an an array is given directly.
1312
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1313
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1314
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.sAjaxDataProp = 'aaData';
1315
 
1316
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1317
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: bAjaxDataGet
1318
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Note if draw should be blocked while getting data
1319
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1320
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1321
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.bAjaxDataGet = true;
1322
 
1323
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1324
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: jqXHR
1325
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  The last jQuery XHR object that was used for server-side data gathering. 
1326
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *           This can be used for working with the XHR information in one of the callbacks
1327
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1328
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1329
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.jqXHR = null;
1330
 
1331
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1332
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: fnServerData
1333
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Function to get the server-side data - can be overruled by the developer
1334
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1335
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1336
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.fnServerData = function ( url, data, callback, settings ) {
1337
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				settings.jqXHR = $.ajax( {
1338
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					"url": url,
1339
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					"data": data,
1340
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					"success": function (json) {
1341
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						$(settings.oInstance).trigger('xhr', settings);
1342
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						callback( json );
1343
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					},
1344
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					"dataType": "json",
1345
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					"cache": false,
1346
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					"error": function (xhr, error, thrown) {
1347
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						if ( error == "parsererror" ) {
1348
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							alert( "DataTables warning: JSON data from server could not be parsed. "+
1349
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>								"This is caused by a JSON formatting error." );
1350
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
1351
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
1352
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				} );
1353
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			};
1354
 
1355
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1356
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: aoServerParams
1357
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Functions which are called prior to sending an Ajax request so extra parameters
1358
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *           can easily be sent to the server
1359
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1360
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Notes:    Each array element is an object with the following parameters:
1361
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   function:fn - function to call
1362
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   string:sName - name callback - useful for knowing where it came from (plugin etc)
1363
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1364
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.aoServerParams = [];
1365
 
1366
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1367
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: fnFormatNumber
1368
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Format numbers for display
1369
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1370
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1371
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.fnFormatNumber = function ( iIn )
1372
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1373
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( iIn < 1000 )
1374
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
1375
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* A small optimisation for what is likely to be the vast majority of use cases */
1376
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					return iIn;
1377
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
1378
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				else
1379
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
1380
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					var s=(iIn+""), a=s.split(""), out="", iLen=s.length;
1381
 
1382
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					for ( var i=0 ; i<iLen ; i++ )
1383
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
1384
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						if ( i%3 === 0 && i !== 0 )
1385
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
1386
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							out = this.oLanguage.sInfoThousands+out;
1387
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
1388
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						out = a[iLen-i-1]+out;
1389
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
1390
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
1391
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				return out;
1392
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			};
1393
 
1394
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1395
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: aLengthMenu
1396
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  List of options that can be used for the user selectable length menu
1397
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1398
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Note:     This varaible can take for form of a 1D array, in which case the value and the 
1399
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   displayed value in the menu are the same, or a 2D array in which case the value comes
1400
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   from the first array, and the displayed value to the end user comes from the second
1401
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   array. 2D example: [ [ 10, 25, 50, 100, -1 ], [ 10, 25, 50, 100, 'All' ] ];
1402
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1403
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.aLengthMenu = [ 10, 25, 50, 100 ];
1404
 
1405
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1406
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: iDraw
1407
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Counter for the draws that the table does. Also used as a tracker for
1408
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   server-side processing
1409
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1410
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1411
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.iDraw = 0;
1412
 
1413
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1414
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: bDrawing
1415
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Indicate if a redraw is being done - useful for Ajax
1416
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1417
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1418
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.bDrawing = 0;
1419
 
1420
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1421
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: iDrawError
1422
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Last draw error
1423
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1424
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1425
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.iDrawError = -1;
1426
 
1427
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1428
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: _iDisplayLength, _iDisplayStart, _iDisplayEnd
1429
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Display length variables
1430
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1431
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Notes:    These variable must NOT be used externally to get the data length. Rather, use
1432
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   the fnRecordsTotal() (etc) functions.
1433
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1434
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this._iDisplayLength = 10;
1435
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this._iDisplayStart = 0;
1436
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this._iDisplayEnd = 10;
1437
 
1438
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1439
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: _iRecordsTotal, _iRecordsDisplay
1440
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Display length variables used for server side processing
1441
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1442
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Notes:    These variable must NOT be used externally to get the data length. Rather, use
1443
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *   the fnRecordsTotal() (etc) functions.
1444
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1445
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this._iRecordsTotal = 0;
1446
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this._iRecordsDisplay = 0;
1447
 
1448
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1449
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: bJUI
1450
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Should we add the markup needed for jQuery UI theming?
1451
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1452
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1453
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.bJUI = false;
1454
 
1455
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1456
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: oClasses
1457
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Should we add the markup needed for jQuery UI theming?
1458
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1459
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1460
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.oClasses = _oExt.oStdClasses;
1461
 
1462
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1463
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: bFiltered and bSorted
1464
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Flags to allow callback functions to see what actions have been performed
1465
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1466
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1467
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.bFiltered = false;
1468
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.bSorted = false;
1469
 
1470
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1471
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: bSortCellsTop
1472
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Indicate that if multiple rows are in the header and there is more than one
1473
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *           unique cell per column, if the top one (true) or bottom one (false) should
1474
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *           be used for sorting / title by DataTables
1475
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1476
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1477
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.bSortCellsTop = false;
1478
 
1479
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1480
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: oInit
1481
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Initialisation object that is used for the table
1482
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1483
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1484
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.oInit = null;
1485
 
1486
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
1487
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Variable: aoDestroyCallback
1488
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Purpose:  Destroy callback functions
1489
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Scope:    jQuery.dataTable.classSettings
1490
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1491
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.aoDestroyCallback = [];
1492
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
1493
 
1494
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
1495
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Variable: oApi
1496
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Container for publicly exposed 'private' functions
1497
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Scope:    jQuery.dataTable
1498
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
1499
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		this.oApi = {};
1500
 
1501
 
1502
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
1503
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Section - API functions
1504
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1505
 
1506
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
1507
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: fnDraw
1508
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Redraw the table
1509
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
1510
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   bool:bComplete - Refilter and resort (if enabled) the table before the draw.
1511
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *             Optional: default - true
1512
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
1513
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		this.fnDraw = function( bComplete )
1514
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
1515
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
1516
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof bComplete != 'undefined' && bComplete === false )
1517
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1518
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnCalculateEnd( oSettings );
1519
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnDraw( oSettings );
1520
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1521
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else
1522
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1523
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnReDraw( oSettings );
1524
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1525
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		};
1526
 
1527
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
1528
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: fnFilter
1529
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Filter the input based on data
1530
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
1531
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   string:sInput - string to filter the table on
1532
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           int:iColumn - optional - column to limit filtering to
1533
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           bool:bRegex - optional - treat as regular expression or not - default false
1534
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           bool:bSmart - optional - perform smart filtering or not - default true
1535
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           bool:bShowGlobal - optional - show the input global filter in it's input box(es)
1536
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *              - default true
1537
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
1538
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		this.fnFilter = function( sInput, iColumn, bRegex, bSmart, bShowGlobal )
1539
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
1540
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
1541
 
1542
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( !oSettings.oFeatures.bFilter )
1543
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1544
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				return;
1545
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1546
 
1547
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof bRegex == 'undefined' )
1548
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1549
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				bRegex = false;
1550
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1551
 
1552
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof bSmart == 'undefined' )
1553
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1554
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				bSmart = true;
1555
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1556
 
1557
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof bShowGlobal == 'undefined' )
1558
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1559
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				bShowGlobal = true;
1560
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1561
 
1562
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof iColumn == "undefined" || iColumn === null )
1563
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1564
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Global filter */
1565
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnFilterComplete( oSettings, {
1566
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					"sSearch":sInput,
1567
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					"bRegex": bRegex,
1568
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					"bSmart": bSmart
1569
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}, 1 );
1570
 
1571
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( bShowGlobal && typeof oSettings.aanFeatures.f != 'undefined' )
1572
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
1573
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					var n = oSettings.aanFeatures.f;
1574
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					for ( var i=0, iLen=n.length ; i<iLen ; i++ )
1575
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
1576
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						$('input', n[i]).val( sInput );
1577
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
1578
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
1579
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1580
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else
1581
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1582
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Single column filter */
1583
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.aoPreSearchCols[ iColumn ].sSearch = sInput;
1584
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.aoPreSearchCols[ iColumn ].bRegex = bRegex;
1585
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.aoPreSearchCols[ iColumn ].bSmart = bSmart;
1586
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnFilterComplete( oSettings, oSettings.oPreviousSearch, 1 );
1587
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1588
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		};
1589
 
1590
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
1591
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: fnSettings
1592
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Get the settings for a particular table for extern. manipulation
1593
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
1594
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   -
1595
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
1596
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		this.fnSettings = function( nNode  )
1597
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
1598
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			return _fnSettingsFromNode( this[_oExt.iApiIndex] );
1599
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		};
1600
 
1601
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
1602
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: fnVersionCheck
1603
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Notes:    The function is the same as the 'static' function provided in the ext variable
1604
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
1605
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		this.fnVersionCheck = _oExt.fnVersionCheck;
1606
 
1607
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
1608
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: fnSort
1609
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Sort the table by a particular row
1610
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
1611
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   int:iCol - the data index to sort on. Note that this will
1612
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *   not match the 'display index' if you have hidden data entries
1613
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
1614
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		this.fnSort = function( aaSort )
1615
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
1616
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
1617
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.aaSorting = aaSort;
1618
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			_fnSort( oSettings );
1619
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		};
1620
 
1621
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
1622
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: fnSortListener
1623
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Attach a sort listener to an element for a given column
1624
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
1625
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   node:nNode - the element to attach the sort listener to
1626
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           int:iColumn - the column that a click on this node will sort on
1627
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           function:fnCallback - callback function when sort is run - optional
1628
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
1629
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		this.fnSortListener = function( nNode, iColumn, fnCallback )
1630
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
1631
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			_fnSortAttachListener( _fnSettingsFromNode( this[_oExt.iApiIndex] ), nNode, iColumn,
1632
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 	fnCallback );
1633
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		};
1634
 
1635
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
1636
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: fnAddData
1637
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Add new row(s) into the table
1638
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  array int: array of indexes (aoData) which have been added (zero length on error)
1639
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   array:mData - the data to be added. The length must match
1640
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *               the original data from the DOM
1641
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *             or
1642
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *             array array:mData - 2D array of data to be added
1643
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           bool:bRedraw - redraw the table or not - default true
1644
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Notes:    Warning - the refilter here will cause the table to redraw
1645
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *             starting at zero
1646
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Notes:    Thanks to Yekimov Denis for contributing the basis for this function!
1647
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
1648
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		this.fnAddData = function( mData, bRedraw )
1649
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
1650
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( mData.length === 0 )
1651
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1652
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				return [];
1653
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1654
 
1655
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var aiReturn = [];
1656
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var iTest;
1657
 
1658
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Find settings from table node */
1659
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
1660
 
1661
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Check if we want to add multiple rows or not */
1662
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof mData[0] == "object" )
1663
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1664
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				for ( var i=0 ; i<mData.length ; i++ )
1665
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
1666
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					iTest = _fnAddData( oSettings, mData[i] );
1667
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( iTest == -1 )
1668
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
1669
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						return aiReturn;
1670
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
1671
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					aiReturn.push( iTest );
1672
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
1673
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1674
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else
1675
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1676
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				iTest = _fnAddData( oSettings, mData );
1677
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( iTest == -1 )
1678
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
1679
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					return aiReturn;
1680
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
1681
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				aiReturn.push( iTest );
1682
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1683
 
1684
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
1685
 
1686
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof bRedraw == 'undefined' || bRedraw )
1687
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1688
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnReDraw( oSettings );
1689
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1690
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			return aiReturn;
1691
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		};
1692
 
1693
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
1694
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: fnDeleteRow
1695
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Remove a row for the table
1696
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  array:aReturn - the row that was deleted
1697
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   mixed:mTarget - 
1698
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *             int: - index of aoData to be deleted, or
1699
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *             node(TR): - TR element you want to delete
1700
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           function:fnCallBack - callback function - default null
1701
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           bool:bRedraw - redraw the table or not - default true
1702
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
1703
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		this.fnDeleteRow = function( mTarget, fnCallBack, bRedraw )
1704
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
1705
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Find settings from table node */
1706
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
1707
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var i, iAODataIndex;
1708
 
1709
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			iAODataIndex = (typeof mTarget == 'object') ? 
1710
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnNodeToDataIndex(oSettings, mTarget) : mTarget;
1711
 
1712
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Return the data array from this row */
1713
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var oData = oSettings.aoData.splice( iAODataIndex, 1 );
1714
 
1715
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Remove the target row from the search array */
1716
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var iDisplayIndex = $.inArray( iAODataIndex, oSettings.aiDisplay );
1717
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.asDataSearch.splice( iDisplayIndex, 1 );
1718
 
1719
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Delete from the display arrays */
1720
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			_fnDeleteIndex( oSettings.aiDisplayMaster, iAODataIndex );
1721
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			_fnDeleteIndex( oSettings.aiDisplay, iAODataIndex );
1722
 
1723
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* If there is a user callback function - call it */
1724
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof fnCallBack == "function" )
1725
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1726
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				fnCallBack.call( this, oSettings, oData );
1727
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1728
 
1729
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Check for an 'overflow' they case for dislaying the table */
1730
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings._iDisplayStart >= oSettings.aiDisplay.length )
1731
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1732
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings._iDisplayStart -= oSettings._iDisplayLength;
1733
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( oSettings._iDisplayStart < 0 )
1734
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
1735
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oSettings._iDisplayStart = 0;
1736
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
1737
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1738
 
1739
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof bRedraw == 'undefined' || bRedraw )
1740
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1741
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnCalculateEnd( oSettings );
1742
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnDraw( oSettings );
1743
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1744
 
1745
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			return oData;
1746
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		};
1747
 
1748
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
1749
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: fnClearTable
1750
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Quickly and simply clear a table
1751
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
1752
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   bool:bRedraw - redraw the table or not - default true
1753
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Notes:    Thanks to Yekimov Denis for contributing the basis for this function!
1754
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
1755
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		this.fnClearTable = function( bRedraw )
1756
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
1757
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Find settings from table node */
1758
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
1759
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			_fnClearTable( oSettings );
1760
 
1761
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof bRedraw == 'undefined' || bRedraw )
1762
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1763
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnDraw( oSettings );
1764
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1765
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		};
1766
 
1767
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
1768
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: fnOpen
1769
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Open a display row (append a row after the row in question)
1770
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  node:nNewRow - the row opened
1771
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   node:nTr - the table row to 'open'
1772
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           string|node|jQuery:mHtml - the HTML to put into the row
1773
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           string:sClass - class to give the new TD cell
1774
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
1775
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		this.fnOpen = function( nTr, mHtml, sClass )
1776
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
1777
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Find settings from table node */
1778
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
1779
 
1780
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* the old open one if there is one */
1781
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			this.fnClose( nTr );
1782
 
1783
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var nNewRow = document.createElement("tr");
1784
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var nNewCell = document.createElement("td");
1785
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nNewRow.appendChild( nNewCell );
1786
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nNewCell.className = sClass;
1787
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nNewCell.colSpan = _fnVisbleColumns( oSettings );
1788
 
1789
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if( typeof mHtml.jquery != 'undefined' || typeof mHtml == "object" )
1790
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1791
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nNewCell.appendChild( mHtml );
1792
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1793
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else
1794
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1795
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nNewCell.innerHTML = mHtml;
1796
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1797
 
1798
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* If the nTr isn't on the page at the moment - then we don't insert at the moment */
1799
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var nTrs = $('tr', oSettings.nTBody);
1800
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( $.inArray(nTr, nTrs) != -1 )
1801
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1802
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				$(nNewRow).insertAfter(nTr);
1803
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1804
 
1805
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.aoOpenRows.push( {
1806
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"nTr": nNewRow,
1807
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"nParent": nTr
1808
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			} );
1809
 
1810
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			return nNewRow;
1811
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		};
1812
 
1813
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
1814
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: fnClose
1815
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Close a display row
1816
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  int: 0 (success) or 1 (failed)
1817
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   node:nTr - the table row to 'close'
1818
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
1819
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		this.fnClose = function( nTr )
1820
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
1821
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Find settings from table node */
1822
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
1823
 
1824
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			for ( var i=0 ; i<oSettings.aoOpenRows.length ; i++ )
1825
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1826
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( oSettings.aoOpenRows[i].nParent == nTr )
1827
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
1828
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					var nTrParent = oSettings.aoOpenRows[i].nTr.parentNode;
1829
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( nTrParent )
1830
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
1831
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						/* Remove it if it is currently on display */
1832
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						nTrParent.removeChild( oSettings.aoOpenRows[i].nTr );
1833
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
1834
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oSettings.aoOpenRows.splice( i, 1 );
1835
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					return 0;
1836
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
1837
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1838
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			return 1;
1839
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		};
1840
 
1841
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
1842
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: fnGetData
1843
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Return an array with the data which is used to make up the table
1844
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  array array string: 2d data array ([row][column]) or array string: 1d data array
1845
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           or string if both row and column are given
1846
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   mixed:mRow - optional - if not present, then the full 2D array for the table 
1847
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *             if given then:
1848
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *               int: - return data object for aoData entry of this index
1849
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *               node(TR): - return data object for this TR element
1850
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           int:iCol - optional - the column that you want the data of. This will take into
1851
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *               account mDataProp and return the value DataTables uses for this column
1852
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
1853
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		this.fnGetData = function( mRow, iCol )
1854
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
1855
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
1856
 
1857
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof mRow != 'undefined' )
1858
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1859
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				var iRow = (typeof mRow == 'object') ? 
1860
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					_fnNodeToDataIndex(oSettings, mRow) : mRow;
1861
 
1862
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( typeof iCol != 'undefined' )
1863
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
1864
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					return _fnGetCellData( oSettings, iRow, iCol, '' );
1865
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
1866
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				return (typeof oSettings.aoData[iRow] != 'undefined') ? 
1867
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oSettings.aoData[iRow]._aData : null;
1868
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1869
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			return _fnGetDataMaster( oSettings );
1870
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		};
1871
 
1872
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
1873
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: fnGetNodes
1874
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Return an array with the TR nodes used for drawing the table
1875
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  array node: TR elements
1876
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           or
1877
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           node (if iRow specified)
1878
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   int:iRow - optional - if present then the array returned will be the node for
1879
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *             the row with the index 'iRow'
1880
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
1881
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		this.fnGetNodes = function( iRow )
1882
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
1883
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
1884
 
1885
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof iRow != 'undefined' )
1886
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1887
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				return (typeof oSettings.aoData[iRow] != 'undefined') ? oSettings.aoData[iRow].nTr : null;
1888
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1889
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			return _fnGetTrNodes( oSettings );
1890
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		};
1891
 
1892
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
1893
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: fnGetPosition
1894
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Get the array indexes of a particular cell from it's DOM element
1895
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  int: - row index, or array[ int, int, int ]: - row index, column index (visible)
1896
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *             and column index including hidden columns
1897
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   node:nNode - this can either be a TR, TD or TH in the table's body, the return is
1898
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *             dependent on this input
1899
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
1900
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		this.fnGetPosition = function( nNode )
1901
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
1902
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
1903
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var sNodeName = nNode.nodeName.toUpperCase();
1904
 
1905
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( sNodeName == "TR" )
1906
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1907
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				return _fnNodeToDataIndex(oSettings, nNode);
1908
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1909
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else if ( sNodeName == "TD" || sNodeName == "TH" )
1910
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1911
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				var iDataIndex = _fnNodeToDataIndex(oSettings, nNode.parentNode);
1912
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				var anCells = _fnGetTdNodes( oSettings, iDataIndex );
1913
 
1914
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				for ( var i=0 ; i<oSettings.aoColumns.length ; i++ )
1915
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
1916
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( anCells[i] == nNode )
1917
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
1918
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						return [ iDataIndex, _fnColumnIndexToVisible(oSettings, i ), i ];
1919
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
1920
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
1921
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1922
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			return null;
1923
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		};
1924
 
1925
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
1926
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: fnUpdate
1927
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Update a table cell or row - this method will accept either a single value to
1928
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *             update the cell with, an array of values with one element for each column or
1929
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *             an object in the same format as the original data source. The function is
1930
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *             self-referencing in order to make the multi column updates easier.
1931
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  int: 0 okay, 1 error
1932
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object | array string | string:mData - data to update the cell/row with
1933
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           mixed:mRow - 
1934
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *             int: - index of aoData to be updated, or
1935
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *             node(TR): - TR element you want to update
1936
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           int:iColumn - the column to update - optional (not used of mData is an array or object)
1937
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           bool:bRedraw - redraw the table or not - default true
1938
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           bool:bAction - perform predraw actions or not (you will want this as 'true' if
1939
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *             you have bRedraw as true) - default true
1940
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
1941
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		this.fnUpdate = function( mData, mRow, iColumn, bRedraw, bAction )
1942
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
1943
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
1944
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var iVisibleColumn, i, iLen, sDisplay;
1945
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var iRow = (typeof mRow == 'object') ? 
1946
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnNodeToDataIndex(oSettings, mRow) : mRow;
1947
 
1948
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( $.isArray(mData) && typeof mData == 'object' )
1949
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1950
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Array update - update the whole row */
1951
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.aoData[iRow]._aData = mData.slice();
1952
 
1953
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				for ( i=0 ; i<oSettings.aoColumns.length ; i++ )
1954
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
1955
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					this.fnUpdate( _fnGetCellData( oSettings, iRow, i ), iRow, i, false, false );
1956
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
1957
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1958
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else if ( mData !== null && typeof mData == 'object' )
1959
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1960
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Object update - update the whole row - assume the developer gets the object right */
1961
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.aoData[iRow]._aData = $.extend( true, {}, mData );
1962
 
1963
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				for ( i=0 ; i<oSettings.aoColumns.length ; i++ )
1964
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
1965
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					this.fnUpdate( _fnGetCellData( oSettings, iRow, i ), iRow, i, false, false );
1966
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
1967
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1968
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else
1969
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
1970
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Individual cell update */
1971
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				sDisplay = mData;
1972
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnSetCellData( oSettings, iRow, iColumn, sDisplay );
1973
 
1974
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( oSettings.aoColumns[iColumn].fnRender !== null )
1975
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
1976
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					sDisplay = oSettings.aoColumns[iColumn].fnRender( {
1977
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						"iDataRow": iRow,
1978
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						"iDataColumn": iColumn,
1979
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						"aData": oSettings.aoData[iRow]._aData,
1980
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						"oSettings": oSettings
1981
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					} );
1982
 
1983
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( oSettings.aoColumns[iColumn].bUseRendered )
1984
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
1985
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						_fnSetCellData( oSettings, iRow, iColumn, sDisplay );
1986
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
1987
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
1988
 
1989
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( oSettings.aoData[iRow].nTr !== null )
1990
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
1991
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* Do the actual HTML update */
1992
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					_fnGetTdNodes( oSettings, iRow )[iColumn].innerHTML = sDisplay;
1993
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
1994
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
1995
 
1996
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Modify the search index for this row (strictly this is likely not needed, since fnReDraw
1997
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * will rebuild the search array - however, the redraw might be disabled by the user)
1998
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
1999
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var iDisplayIndex = $.inArray( iRow, oSettings.aiDisplay );
2000
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.asDataSearch[iDisplayIndex] = _fnBuildSearchRow( oSettings, 
2001
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnGetRowData( oSettings, iRow, 'filter' ) );
2002
 
2003
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Perform pre-draw actions */
2004
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof bAction == 'undefined' || bAction )
2005
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2006
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnAdjustColumnSizing( oSettings );
2007
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2008
 
2009
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Redraw the table */
2010
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof bRedraw == 'undefined' || bRedraw )
2011
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2012
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnReDraw( oSettings );
2013
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2014
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			return 0;
2015
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		};
2016
 
2017
 
2018
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
2019
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: fnShowColoumn
2020
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Show a particular column
2021
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
2022
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   int:iCol - the column whose display should be changed
2023
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           bool:bShow - show (true) or hide (false) the column
2024
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           bool:bRedraw - redraw the table or not - default true
2025
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
2026
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		this.fnSetColumnVis = function ( iCol, bShow, bRedraw )
2027
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
2028
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
2029
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var i, iLen;
2030
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var iColumns = oSettings.aoColumns.length;
2031
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var nTd, nCell, anTrs, jqChildren, bAppend, iBefore;
2032
 
2033
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* No point in doing anything if we are requesting what is already true */
2034
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.aoColumns[iCol].bVisible == bShow )
2035
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2036
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				return;
2037
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2038
 
2039
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Show the column */
2040
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( bShow )
2041
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2042
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				var iInsert = 0;
2043
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				for ( i=0 ; i<iCol ; i++ )
2044
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
2045
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( oSettings.aoColumns[i].bVisible )
2046
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
2047
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						iInsert++;
2048
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
2049
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
2050
 
2051
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Need to decide if we should use appendChild or insertBefore */
2052
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				bAppend = (iInsert >= _fnVisbleColumns( oSettings ));
2053
 
2054
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Which coloumn should we be inserting before? */
2055
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( !bAppend )
2056
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
2057
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					for ( i=iCol ; i<iColumns ; i++ )
2058
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
2059
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						if ( oSettings.aoColumns[i].bVisible )
2060
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
2061
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							iBefore = i;
2062
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							break;
2063
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
2064
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
2065
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
2066
 
2067
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				for ( i=0, iLen=oSettings.aoData.length ; i<iLen ; i++ )
2068
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
2069
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( oSettings.aoData[i].nTr !== null )
2070
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
2071
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						if ( bAppend )
2072
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
2073
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							oSettings.aoData[i].nTr.appendChild( 
2074
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>								oSettings.aoData[i]._anHidden[iCol]
2075
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							);
2076
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
2077
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						else
2078
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
2079
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							oSettings.aoData[i].nTr.insertBefore(
2080
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>								oSettings.aoData[i]._anHidden[iCol], 
2081
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>								_fnGetTdNodes( oSettings, i )[iBefore] );
2082
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
2083
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
2084
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
2085
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2086
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else
2087
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2088
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Remove a column from display */
2089
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				for ( i=0, iLen=oSettings.aoData.length ; i<iLen ; i++ )
2090
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
2091
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( oSettings.aoData[i].nTr !== null )
2092
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
2093
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						nTd = _fnGetTdNodes( oSettings, i )[iCol];
2094
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						oSettings.aoData[i]._anHidden[iCol] = nTd;
2095
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						nTd.parentNode.removeChild( nTd );
2096
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
2097
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
2098
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2099
 
2100
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Clear to set the visible flag */
2101
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.aoColumns[iCol].bVisible = bShow;
2102
 
2103
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Redraw the header and footer based on the new column visibility */
2104
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			_fnDrawHead( oSettings, oSettings.aoHeader );
2105
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.nTFoot )
2106
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2107
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnDrawHead( oSettings, oSettings.aoFooter );
2108
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2109
 
2110
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* If there are any 'open' rows, then we need to alter the colspan for this col change */
2111
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			for ( i=0, iLen=oSettings.aoOpenRows.length ; i<iLen ; i++ )
2112
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2113
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.aoOpenRows[i].nTr.colSpan = _fnVisbleColumns( oSettings );
2114
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2115
 
2116
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Do a redraw incase anything depending on the table columns needs it 
2117
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * (built-in: scrolling) 
2118
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
2119
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof bRedraw == 'undefined' || bRedraw )
2120
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2121
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnAdjustColumnSizing( oSettings );
2122
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnDraw( oSettings );
2123
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2124
 
2125
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			_fnSaveState( oSettings );
2126
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		};
2127
 
2128
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
2129
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: fnPageChange
2130
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Change the pagination
2131
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
2132
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   string:sAction - paging action to take: "first", "previous", "next" or "last"
2133
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           bool:bRedraw - redraw the table or not - optional - default true
2134
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
2135
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		this.fnPageChange = function ( sAction, bRedraw )
2136
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
2137
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
2138
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			_fnPageChange( oSettings, sAction );
2139
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			_fnCalculateEnd( oSettings );
2140
 
2141
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof bRedraw == 'undefined' || bRedraw )
2142
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2143
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnDraw( oSettings );
2144
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2145
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		};
2146
 
2147
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
2148
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: fnDestroy
2149
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Destructor for the DataTable
2150
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
2151
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   -
2152
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
2153
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		this.fnDestroy = function ( )
2154
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
2155
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
2156
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var nOrig = oSettings.nTableWrapper.parentNode;
2157
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var nBody = oSettings.nTBody;
2158
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var i, iLen;
2159
 
2160
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Flag to note that the table is currently being destoryed - no action should be taken */
2161
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.bDestroying = true;
2162
 
2163
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Restore hidden columns */
2164
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			for ( i=0, iLen=oSettings.aoDestroyCallback.length ; i<iLen ; i++ ) {
2165
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.aoDestroyCallback[i].fn();
2166
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2167
 
2168
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Restore hidden columns */
2169
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
2170
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2171
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( oSettings.aoColumns[i].bVisible === false )
2172
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
2173
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					this.fnSetColumnVis( i, true );
2174
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
2175
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2176
 
2177
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Blitz all DT events */
2178
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			$(oSettings.nTableWrapper).find('*').andSelf().off('.DT');
2179
 
2180
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* If there is an 'empty' indicator row, remove it */
2181
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			$('tbody>tr>td.'+oSettings.oClasses.sRowEmpty, oSettings.nTable).parent().remove();
2182
 
2183
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* When scrolling we had to break the table up - restore it */
2184
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.nTable != oSettings.nTHead.parentNode )
2185
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2186
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				$(oSettings.nTable).children('thead').remove();
2187
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.nTable.appendChild( oSettings.nTHead );
2188
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2189
 
2190
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.nTFoot && oSettings.nTable != oSettings.nTFoot.parentNode )
2191
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2192
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				$(oSettings.nTable).children('tfoot').remove();
2193
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.nTable.appendChild( oSettings.nTFoot );
2194
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2195
 
2196
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Remove the DataTables generated nodes, events and classes */
2197
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.nTable.parentNode.removeChild( oSettings.nTable );
2198
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			$(oSettings.nTableWrapper).remove();
2199
 
2200
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.aaSorting = [];
2201
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.aaSortingFixed = [];
2202
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			_fnSortingClasses( oSettings );
2203
 
2204
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			$(_fnGetTrNodes( oSettings )).removeClass( oSettings.asStripeClasses.join(' ') );
2205
 
2206
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( !oSettings.bJUI )
2207
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2208
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				$('th', oSettings.nTHead).removeClass( [ _oExt.oStdClasses.sSortable,
2209
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					_oExt.oStdClasses.sSortableAsc,
2210
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					_oExt.oStdClasses.sSortableDesc,
2211
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					_oExt.oStdClasses.sSortableNone ].join(' ')
2212
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				);
2213
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2214
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else
2215
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2216
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				$('th', oSettings.nTHead).removeClass( [ _oExt.oStdClasses.sSortable,
2217
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					_oExt.oJUIClasses.sSortableAsc,
2218
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					_oExt.oJUIClasses.sSortableDesc,
2219
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					_oExt.oJUIClasses.sSortableNone ].join(' ')
2220
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				);
2221
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				$('th span.'+_oExt.oJUIClasses.sSortIcon, oSettings.nTHead).remove();
2222
 
2223
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				$('th', oSettings.nTHead).each( function () {
2224
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					var jqWrapper = $('div.'+_oExt.oJUIClasses.sSortJUIWrapper, this);
2225
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					var kids = jqWrapper.contents();
2226
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					$(this).append( kids );
2227
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					jqWrapper.remove();
2228
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				} );
2229
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2230
 
2231
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Add the TR elements back into the table in their original order */
2232
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.nTableReinsertBefore )
2233
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2234
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nOrig.insertBefore( oSettings.nTable, oSettings.nTableReinsertBefore );
2235
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2236
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else
2237
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2238
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nOrig.appendChild( oSettings.nTable );
2239
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2240
 
2241
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			for ( i=0, iLen=oSettings.aoData.length ; i<iLen ; i++ )
2242
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2243
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( oSettings.aoData[i].nTr !== null )
2244
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
2245
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nBody.appendChild( oSettings.aoData[i].nTr );
2246
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
2247
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2248
 
2249
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Restore the width of the original table */
2250
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.oFeatures.bAutoWidth === true )
2251
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2252
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			  oSettings.nTable.style.width = _fnStringToCss(oSettings.sDestroyWidth);
2253
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2254
 
2255
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* If the were originally odd/even type classes - then we add them back here. Note
2256
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * this is not fool proof (for example if not all rows as odd/even classes - but 
2257
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * it's a good effort without getting carried away
2258
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
2259
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			$(nBody).children('tr:even').addClass( oSettings.asDestroyStripes[0] );
2260
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			$(nBody).children('tr:odd').addClass( oSettings.asDestroyStripes[1] );
2261
 
2262
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Remove the settings object from the settings array */
2263
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			for ( i=0, iLen=_aoSettings.length ; i<iLen ; i++ )
2264
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2265
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( _aoSettings[i] == oSettings )
2266
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
2267
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					_aoSettings.splice( i, 1 );
2268
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
2269
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2270
 
2271
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* End it all */
2272
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings = null;
2273
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		};
2274
 
2275
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
2276
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: fnAdjustColumnSizing
2277
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Update table sizing based on content. This would most likely be used for scrolling
2278
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *   and will typically need a redraw after it.
2279
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
2280
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   bool:bRedraw - redraw the table or not, you will typically want to - default true
2281
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
2282
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		this.fnAdjustColumnSizing = function ( bRedraw )
2283
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
2284
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var oSettings = _fnSettingsFromNode(this[_oExt.iApiIndex]);
2285
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			_fnAdjustColumnSizing( oSettings );
2286
 
2287
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof bRedraw == 'undefined' || bRedraw )
2288
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2289
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				this.fnDraw( false );
2290
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2291
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else if ( oSettings.oScroll.sX !== "" || oSettings.oScroll.sY !== "" )
2292
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2293
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* If not redrawing, but scrolling, we want to apply the new column sizes anyway */
2294
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				this.oApi._fnScrollDraw(oSettings);
2295
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2296
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		};
2297
 
2298
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
2299
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Plugin API functions
2300
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * 
2301
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * This call will add the functions which are defined in _oExt.oApi to the
2302
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * DataTables object, providing a rather nice way to allow plug-in API functions. Note that
2303
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * this is done here, so that API function can actually override the built in API functions if
2304
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * required for a particular purpose.
2305
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
2306
 
2307
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
2308
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnExternApiFunc
2309
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Create a wrapper function for exporting an internal func to an external API func
2310
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  function: - wrapped function
2311
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   string:sFunc - API function name
2312
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
2313
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnExternApiFunc (sFunc)
2314
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
2315
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			return function() {
2316
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					var aArgs = [_fnSettingsFromNode(this[_oExt.iApiIndex])].concat( 
2317
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						Array.prototype.slice.call(arguments) );
2318
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					return _oExt.oApi[sFunc].apply( this, aArgs );
2319
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				};
2320
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
2321
 
2322
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		for ( var sFunc in _oExt.oApi )
2323
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
2324
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( sFunc )
2325
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2326
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/*
2327
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				 * Function: anon
2328
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				 * Purpose:  Wrap the plug-in API functions in order to provide the settings as 1st arg 
2329
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				 *   and execute in this scope
2330
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				 * Returns:  -
2331
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				 * Inputs:   -
2332
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				 */
2333
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				this[sFunc] = _fnExternApiFunc(sFunc);
2334
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2335
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
2336
 
2337
 
2338
 
2339
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2340
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Section - Local functions
2341
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2342
 
2343
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2344
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Section - Initialisation
2345
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
2346
 
2347
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
2348
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnInitialise
2349
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Draw the table for the first time, adding all required features
2350
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
2351
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
2352
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
2353
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnInitialise ( oSettings )
2354
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
2355
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var i, iLen, iAjaxStart=oSettings.iInitDisplayStart;
2356
 
2357
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Ensure that the table data is fully initialised */
2358
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.bInitialised === false )
2359
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2360
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				setTimeout( function(){ _fnInitialise( oSettings ); }, 200 );
2361
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				return;
2362
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2363
 
2364
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Show the display HTML options */
2365
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			_fnAddOptionsHtml( oSettings );
2366
 
2367
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Build and draw the header / footer for the table */
2368
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			_fnBuildHead( oSettings );
2369
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			_fnDrawHead( oSettings, oSettings.aoHeader );
2370
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.nTFoot )
2371
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2372
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnDrawHead( oSettings, oSettings.aoFooter );
2373
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2374
 
2375
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Okay to show that something is going on now */
2376
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			_fnProcessingDisplay( oSettings, true );
2377
 
2378
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Calculate sizes for columns */
2379
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.oFeatures.bAutoWidth )
2380
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2381
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnCalculateColumnWidths( oSettings );
2382
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2383
 
2384
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
2385
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2386
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( oSettings.aoColumns[i].sWidth !== null )
2387
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
2388
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oSettings.aoColumns[i].nTh.style.width = _fnStringToCss( oSettings.aoColumns[i].sWidth );
2389
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
2390
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2391
 
2392
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* If there is default sorting required - let's do it. The sort function will do the
2393
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * drawing for us. Otherwise we draw the table regardless of the Ajax source - this allows
2394
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * the table to look initialised for Ajax sourcing data (show 'loading' message possibly)
2395
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
2396
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.oFeatures.bSort )
2397
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2398
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnSort( oSettings );
2399
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2400
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else if ( oSettings.oFeatures.bFilter )
2401
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2402
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnFilterComplete( oSettings, oSettings.oPreviousSearch );
2403
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2404
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else
2405
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2406
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
2407
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnCalculateEnd( oSettings );
2408
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnDraw( oSettings );
2409
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2410
 
2411
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* if there is an ajax source load the data */
2412
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.sAjaxSource !== null && !oSettings.oFeatures.bServerSide )
2413
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2414
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				var aoData = [];
2415
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnServerParams( oSettings, aoData );
2416
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.fnServerData.call( oSettings.oInstance, oSettings.sAjaxSource, aoData, function(json) {
2417
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					var aData = json;
2418
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( oSettings.sAjaxDataProp !== "" )
2419
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
2420
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						var fnDataSrc = _fnGetObjectDataFn( oSettings.sAjaxDataProp );
2421
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						aData = fnDataSrc( json );
2422
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
2423
 
2424
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* Got the data - add it to the table */
2425
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					for ( i=0 ; i<aData.length ; i++ )
2426
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
2427
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						_fnAddData( oSettings, aData[i] );
2428
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
2429
 
2430
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* Reset the init display for cookie saving. We've already done a filter, and
2431
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					 * therefore cleared it before. So we need to make it appear 'fresh'
2432
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					 */
2433
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oSettings.iInitDisplayStart = iAjaxStart;
2434
 
2435
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( oSettings.oFeatures.bSort )
2436
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
2437
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						_fnSort( oSettings );
2438
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
2439
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					else
2440
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
2441
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
2442
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						_fnCalculateEnd( oSettings );
2443
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						_fnDraw( oSettings );
2444
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
2445
 
2446
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					_fnProcessingDisplay( oSettings, false );
2447
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					_fnInitComplete( oSettings, json );
2448
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}, oSettings );
2449
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				return;
2450
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2451
 
2452
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Server-side processing initialisation complete is done at the end of _fnDraw */
2453
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( !oSettings.oFeatures.bServerSide )
2454
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2455
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnProcessingDisplay( oSettings, false );
2456
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnInitComplete( oSettings );
2457
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2458
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
2459
 
2460
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
2461
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnInitComplete
2462
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Draw the table for the first time, adding all required features
2463
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
2464
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
2465
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
2466
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnInitComplete ( oSettings, json )
2467
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
2468
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings._bInitComplete = true;
2469
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof oSettings.fnInitComplete == 'function' )
2470
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2471
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( typeof json != 'undefined' )
2472
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
2473
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oSettings.fnInitComplete.call( oSettings.oInstance, oSettings, json );
2474
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
2475
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				else
2476
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
2477
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oSettings.fnInitComplete.call( oSettings.oInstance, oSettings );
2478
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
2479
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2480
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
2481
 
2482
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
2483
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnLanguageProcess
2484
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Copy language variables from remote object to a local one
2485
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
2486
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
2487
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           object:oLanguage - Language information
2488
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           bool:bInit - init once complete
2489
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
2490
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnLanguageProcess( oSettings, oLanguage, bInit )
2491
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
2492
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.oLanguage = $.extend( true, oSettings.oLanguage, oLanguage );
2493
 
2494
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Backwards compatibility - if there is no sEmptyTable given, then use the same as
2495
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * sZeroRecords - assuming that is given.
2496
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
2497
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof oLanguage.sEmptyTable == 'undefined' && 
2498
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			     typeof oLanguage.sZeroRecords != 'undefined' )
2499
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2500
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnMap( oSettings.oLanguage, oLanguage, 'sZeroRecords', 'sEmptyTable' );
2501
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2502
 
2503
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Likewise with loading records */
2504
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof oLanguage.sLoadingRecords == 'undefined' && 
2505
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			     typeof oLanguage.sZeroRecords != 'undefined' )
2506
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2507
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnMap( oSettings.oLanguage, oLanguage, 'sZeroRecords', 'sLoadingRecords' );
2508
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2509
 
2510
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( bInit )
2511
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2512
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnInitialise( oSettings );
2513
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2514
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
2515
 
2516
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
2517
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnAddColumn
2518
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Add a column to the list used for the table with default values
2519
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
2520
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
2521
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           node:nTh - the th element for this column
2522
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
2523
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnAddColumn( oSettings, nTh )
2524
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
2525
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var iCol = oSettings.aoColumns.length;
2526
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var oCol = {
2527
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sType": null,
2528
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"_bAutoType": true,
2529
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"bVisible": true,
2530
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"bSearchable": true,
2531
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"bSortable": true,
2532
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"asSorting": [ 'asc', 'desc' ],
2533
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sSortingClass": oSettings.oClasses.sSortable,
2534
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sSortingClassJUI": oSettings.oClasses.sSortJUI,
2535
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sTitle": nTh ? nTh.innerHTML : '',
2536
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sName": '',
2537
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sWidth": null,
2538
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sWidthOrig": null,
2539
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sClass": null,
2540
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"fnRender": null,
2541
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"bUseRendered": true,
2542
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"iDataSort": iCol,
2543
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"mDataProp": iCol,
2544
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"fnGetData": null,
2545
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"fnSetData": null,
2546
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sSortDataType": 'std',
2547
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sDefaultContent": null,
2548
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sContentPadding": "",
2549
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"nTh": nTh ? nTh : document.createElement('th'),
2550
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"nTf": null
2551
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			};
2552
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.aoColumns.push( oCol );
2553
 
2554
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Add a column specific filter */
2555
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof oSettings.aoPreSearchCols[ iCol ] == 'undefined' ||
2556
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			     oSettings.aoPreSearchCols[ iCol ] === null )
2557
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2558
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.aoPreSearchCols[ iCol ] = {
2559
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					"sSearch": "",
2560
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					"bRegex": false,
2561
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					"bSmart": true
2562
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				};
2563
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2564
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else
2565
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2566
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Don't require that the user must specify bRegex and / or bSmart */
2567
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( typeof oSettings.aoPreSearchCols[ iCol ].bRegex == 'undefined' )
2568
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
2569
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oSettings.aoPreSearchCols[ iCol ].bRegex = true;
2570
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
2571
 
2572
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( typeof oSettings.aoPreSearchCols[ iCol ].bSmart == 'undefined' )
2573
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
2574
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oSettings.aoPreSearchCols[ iCol ].bSmart = true;
2575
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
2576
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2577
 
2578
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Use the column options function to initialise classes etc */
2579
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			_fnColumnOptions( oSettings, iCol, null );
2580
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
2581
 
2582
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
2583
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnColumnOptions
2584
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Apply options for a column
2585
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
2586
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
2587
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           int:iCol - column index to consider
2588
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           object:oOptions - object with sType, bVisible and bSearchable
2589
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
2590
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnColumnOptions( oSettings, iCol, oOptions )
2591
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
2592
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var oCol = oSettings.aoColumns[ iCol ];
2593
 
2594
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* User specified column options */
2595
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof oOptions != 'undefined' && oOptions !== null )
2596
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2597
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( typeof oOptions.sType != 'undefined' )
2598
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
2599
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oCol.sType = oOptions.sType;
2600
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oCol._bAutoType = false;
2601
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
2602
 
2603
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnMap( oCol, oOptions, "bVisible" );
2604
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnMap( oCol, oOptions, "bSearchable" );
2605
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnMap( oCol, oOptions, "bSortable" );
2606
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnMap( oCol, oOptions, "sTitle" );
2607
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnMap( oCol, oOptions, "sName" );
2608
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnMap( oCol, oOptions, "sWidth" );
2609
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnMap( oCol, oOptions, "sWidth", "sWidthOrig" );
2610
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnMap( oCol, oOptions, "sClass" );
2611
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnMap( oCol, oOptions, "fnRender" );
2612
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnMap( oCol, oOptions, "bUseRendered" );
2613
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnMap( oCol, oOptions, "iDataSort" );
2614
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnMap( oCol, oOptions, "mDataProp" );
2615
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnMap( oCol, oOptions, "asSorting" );
2616
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnMap( oCol, oOptions, "sSortDataType" );
2617
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnMap( oCol, oOptions, "sDefaultContent" );
2618
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnMap( oCol, oOptions, "sContentPadding" );
2619
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2620
 
2621
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Cache the data get and set functions for speed */
2622
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oCol.fnGetData = _fnGetObjectDataFn( oCol.mDataProp );
2623
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oCol.fnSetData = _fnSetObjectDataFn( oCol.mDataProp );
2624
 
2625
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Feature sorting overrides column specific when off */
2626
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( !oSettings.oFeatures.bSort )
2627
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2628
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oCol.bSortable = false;
2629
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2630
 
2631
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Check that the class assignment is correct for sorting */
2632
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( !oCol.bSortable ||
2633
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				 ($.inArray('asc', oCol.asSorting) == -1 && $.inArray('desc', oCol.asSorting) == -1) )
2634
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2635
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oCol.sSortingClass = oSettings.oClasses.sSortableNone;
2636
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oCol.sSortingClassJUI = "";
2637
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2638
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else if ( oCol.bSortable ||
2639
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			          ($.inArray('asc', oCol.asSorting) == -1 && $.inArray('desc', oCol.asSorting) == -1) )
2640
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2641
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			  oCol.sSortingClass = oSettings.oClasses.sSortable;
2642
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			  oCol.sSortingClassJUI = oSettings.oClasses.sSortJUI;
2643
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2644
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else if ( $.inArray('asc', oCol.asSorting) != -1 && $.inArray('desc', oCol.asSorting) == -1 )
2645
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2646
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oCol.sSortingClass = oSettings.oClasses.sSortableAsc;
2647
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oCol.sSortingClassJUI = oSettings.oClasses.sSortJUIAscAllowed;
2648
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2649
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else if ( $.inArray('asc', oCol.asSorting) == -1 && $.inArray('desc', oCol.asSorting) != -1 )
2650
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2651
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oCol.sSortingClass = oSettings.oClasses.sSortableDesc;
2652
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oCol.sSortingClassJUI = oSettings.oClasses.sSortJUIDescAllowed;
2653
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2654
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
2655
 
2656
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
2657
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnAddData
2658
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Add a data array to the table, creating DOM node etc
2659
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  int: - >=0 if successful (index of new aoData entry), -1 if failed
2660
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
2661
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           array:aData - data array to be added
2662
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Notes:    There are two basic methods for DataTables to get data to display - a JS array
2663
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *   (which is dealt with by this function), and the DOM, which has it's own optimised
2664
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *   function (_fnGatherData). Be careful to make the same changes here as there and vice-versa
2665
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
2666
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnAddData ( oSettings, aDataSupplied )
2667
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
2668
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var oCol;
2669
 
2670
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Take an independent copy of the data source so we can bash it about as we wish */
2671
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var aDataIn = ($.isArray(aDataSupplied)) ?
2672
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				aDataSupplied.slice() :
2673
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				$.extend( true, {}, aDataSupplied );
2674
 
2675
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Create the object for storing information about this new row */
2676
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var iRow = oSettings.aoData.length;
2677
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var oData = {
2678
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"nTr": null,
2679
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"_iId": oSettings.iNextId++,
2680
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"_aData": aDataIn,
2681
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"_anHidden": [],
2682
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"_sRowStripe": ""
2683
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			};
2684
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.aoData.push( oData );
2685
 
2686
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Create the cells */
2687
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var nTd, sThisType;
2688
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			for ( var i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
2689
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2690
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oCol = oSettings.aoColumns[i];
2691
 
2692
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Use rendered data for filtering/sorting */
2693
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( typeof oCol.fnRender == 'function' && oCol.bUseRendered && oCol.mDataProp !== null )
2694
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
2695
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					_fnSetCellData( oSettings, iRow, i, oCol.fnRender( {
2696
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						"iDataRow": iRow,
2697
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						"iDataColumn": i,
2698
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						"aData": oData._aData,
2699
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						"oSettings": oSettings
2700
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					} ) );
2701
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
2702
 
2703
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* See if we should auto-detect the column type */
2704
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( oCol._bAutoType && oCol.sType != 'string' )
2705
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
2706
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* Attempt to auto detect the type - same as _fnGatherData() */
2707
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					var sVarType = _fnGetCellData( oSettings, iRow, i, 'type' );
2708
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( sVarType !== null && sVarType !== '' )
2709
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
2710
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						sThisType = _fnDetectType( sVarType );
2711
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						if ( oCol.sType === null )
2712
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
2713
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							oCol.sType = sThisType;
2714
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
2715
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						else if ( oCol.sType != sThisType && oCol.sType != "html" )
2716
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
2717
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							/* String is always the 'fallback' option */
2718
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							oCol.sType = 'string';
2719
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
2720
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
2721
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
2722
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2723
 
2724
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Add to the display array */
2725
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.aiDisplayMaster.push( iRow );
2726
 
2727
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Create the DOM imformation */
2728
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( !oSettings.oFeatures.bDeferRender )
2729
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2730
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnCreateTr( oSettings, iRow );
2731
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2732
 
2733
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			return iRow;
2734
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
2735
 
2736
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
2737
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnCreateTr
2738
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Create a new TR element (and it's TD children) for a row
2739
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  void
2740
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
2741
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           int:iRow - Row to consider
2742
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
2743
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnCreateTr ( oSettings, iRow )
2744
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
2745
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var oData = oSettings.aoData[iRow];
2746
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var nTd;
2747
 
2748
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oData.nTr === null )
2749
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2750
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oData.nTr = document.createElement('tr');
2751
 
2752
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Special parameters can be given by the data source to be used on the row */
2753
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( typeof oData._aData.DT_RowId != 'undefined' )
2754
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
2755
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oData.nTr.setAttribute( 'id', oData._aData.DT_RowId );
2756
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
2757
 
2758
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( typeof oData._aData.DT_RowClass != 'undefined' )
2759
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
2760
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					$(oData.nTr).addClass( oData._aData.DT_RowClass );
2761
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
2762
 
2763
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Process each column */
2764
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				for ( var i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
2765
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
2766
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					var oCol = oSettings.aoColumns[i];
2767
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nTd = document.createElement('td');
2768
 
2769
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* Render if needed - if bUseRendered is true then we already have the rendered
2770
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					 * value in the data source - so can just use that
2771
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					 */
2772
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( typeof oCol.fnRender == 'function' && (!oCol.bUseRendered || oCol.mDataProp === null) )
2773
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
2774
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						nTd.innerHTML = oCol.fnRender( {
2775
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							"iDataRow": iRow,
2776
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							"iDataColumn": i,
2777
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							"aData": oData._aData,
2778
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							"oSettings": oSettings
2779
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						} );
2780
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
2781
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					else
2782
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
2783
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						nTd.innerHTML = _fnGetCellData( oSettings, iRow, i, 'display' );
2784
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
2785
 
2786
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* Add user defined class */
2787
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( oCol.sClass !== null )
2788
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
2789
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						nTd.className = oCol.sClass;
2790
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
2791
 
2792
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( oCol.bVisible )
2793
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
2794
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						oData.nTr.appendChild( nTd );
2795
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						oData._anHidden[i] = null;
2796
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
2797
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					else
2798
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
2799
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						oData._anHidden[i] = nTd;
2800
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
2801
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
2802
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2803
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
2804
 
2805
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
2806
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnGatherData
2807
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Read in the data from the target table from the DOM
2808
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
2809
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
2810
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Notes:    This is a optimised version of _fnAddData (more or less) for reading information
2811
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *   from the DOM. The basic actions must be identical in the two functions.
2812
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
2813
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnGatherData( oSettings )
2814
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
2815
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var iLoop, i, iLen, j, jLen, jInner,
2816
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 	nTds, nTrs, nTd, aLocalData, iThisIndex,
2817
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				iRow, iRows, iColumn, iColumns, sNodeName;
2818
 
2819
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
2820
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Process by row first
2821
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Add the data object for the whole table - storing the tr node. Note - no point in getting
2822
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * DOM based data if we are going to go and replace it with Ajax source data.
2823
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
2824
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.bDeferLoading || oSettings.sAjaxSource === null )
2825
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2826
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nTrs = oSettings.nTBody.childNodes;
2827
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				for ( i=0, iLen=nTrs.length ; i<iLen ; i++ )
2828
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
2829
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( nTrs[i].nodeName.toUpperCase() == "TR" )
2830
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
2831
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						iThisIndex = oSettings.aoData.length;
2832
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						oSettings.aoData.push( {
2833
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							"nTr": nTrs[i],
2834
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							"_iId": oSettings.iNextId++,
2835
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							"_aData": [],
2836
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							"_anHidden": [],
2837
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							"_sRowStripe": ''
2838
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						} );
2839
 
2840
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						oSettings.aiDisplayMaster.push( iThisIndex );
2841
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						nTds = nTrs[i].childNodes;
2842
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						jInner = 0;
2843
 
2844
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						for ( j=0, jLen=nTds.length ; j<jLen ; j++ )
2845
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
2846
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							sNodeName = nTds[j].nodeName.toUpperCase();
2847
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							if ( sNodeName == "TD" || sNodeName == "TH" )
2848
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							{
2849
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>								_fnSetCellData( oSettings, iThisIndex, jInner, $.trim(nTds[j].innerHTML) );
2850
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>								jInner++;
2851
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							}
2852
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
2853
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
2854
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
2855
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2856
 
2857
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Gather in the TD elements of the Table - note that this is basically the same as
2858
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * fnGetTdNodes, but that function takes account of hidden columns, which we haven't yet
2859
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * setup!
2860
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
2861
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nTrs = _fnGetTrNodes( oSettings );
2862
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nTds = [];
2863
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			for ( i=0, iLen=nTrs.length ; i<iLen ; i++ )
2864
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2865
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				for ( j=0, jLen=nTrs[i].childNodes.length ; j<jLen ; j++ )
2866
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
2867
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nTd = nTrs[i].childNodes[j];
2868
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					sNodeName = nTd.nodeName.toUpperCase();
2869
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( sNodeName == "TD" || sNodeName == "TH" )
2870
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
2871
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						nTds.push( nTd );
2872
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
2873
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
2874
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2875
 
2876
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Sanity check */
2877
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( nTds.length != nTrs.length * oSettings.aoColumns.length )
2878
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2879
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnLog( oSettings, 1, "Unexpected number of TD elements. Expected "+
2880
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					(nTrs.length * oSettings.aoColumns.length)+" and got "+nTds.length+". DataTables does "+
2881
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					"not support rowspan / colspan in the table body, and there must be one cell for each "+
2882
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					"row/column combination." );
2883
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2884
 
2885
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Now process by column */
2886
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			for ( iColumn=0, iColumns=oSettings.aoColumns.length ; iColumn<iColumns ; iColumn++ )
2887
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2888
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Get the title of the column - unless there is a user set one */
2889
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( oSettings.aoColumns[iColumn].sTitle === null )
2890
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
2891
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oSettings.aoColumns[iColumn].sTitle = oSettings.aoColumns[iColumn].nTh.innerHTML;
2892
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
2893
 
2894
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				var
2895
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					bAutoType = oSettings.aoColumns[iColumn]._bAutoType,
2896
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					bRender = typeof oSettings.aoColumns[iColumn].fnRender == 'function',
2897
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					bClass = oSettings.aoColumns[iColumn].sClass !== null,
2898
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					bVisible = oSettings.aoColumns[iColumn].bVisible,
2899
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nCell, sThisType, sRendered, sValType;
2900
 
2901
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* A single loop to rule them all (and be more efficient) */
2902
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( bAutoType || bRender || bClass || !bVisible )
2903
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
2904
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					for ( iRow=0, iRows=oSettings.aoData.length ; iRow<iRows ; iRow++ )
2905
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
2906
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						nCell = nTds[ (iRow*iColumns) + iColumn ];
2907
 
2908
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						/* Type detection */
2909
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						if ( bAutoType && oSettings.aoColumns[iColumn].sType != 'string' )
2910
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
2911
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							sValType = _fnGetCellData( oSettings, iRow, iColumn, 'type' );
2912
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							if ( sValType !== '' )
2913
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							{
2914
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>								sThisType = _fnDetectType( sValType );
2915
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>								if ( oSettings.aoColumns[iColumn].sType === null )
2916
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>								{
2917
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>									oSettings.aoColumns[iColumn].sType = sThisType;
2918
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>								}
2919
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>								else if ( oSettings.aoColumns[iColumn].sType != sThisType && 
2920
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>								          oSettings.aoColumns[iColumn].sType != "html" )
2921
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>								{
2922
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>									/* String is always the 'fallback' option */
2923
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>									oSettings.aoColumns[iColumn].sType = 'string';
2924
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>								}
2925
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							}
2926
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
2927
 
2928
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						/* Rendering */
2929
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						if ( bRender )
2930
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
2931
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							sRendered = oSettings.aoColumns[iColumn].fnRender( {
2932
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>									"iDataRow": iRow,
2933
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>									"iDataColumn": iColumn,
2934
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>									"aData": oSettings.aoData[iRow]._aData,
2935
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>									"oSettings": oSettings
2936
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>								} );
2937
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							nCell.innerHTML = sRendered;
2938
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							if ( oSettings.aoColumns[iColumn].bUseRendered )
2939
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							{
2940
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>								/* Use the rendered data for filtering/sorting */
2941
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>								_fnSetCellData( oSettings, iRow, iColumn, sRendered );
2942
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							}
2943
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
2944
 
2945
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						/* Classes */
2946
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						if ( bClass )
2947
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
2948
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							nCell.className += ' '+oSettings.aoColumns[iColumn].sClass;
2949
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
2950
 
2951
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						/* Column visability */
2952
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						if ( !bVisible )
2953
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
2954
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							oSettings.aoData[iRow]._anHidden[iColumn] = nCell;
2955
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							nCell.parentNode.removeChild( nCell );
2956
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
2957
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						else
2958
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
2959
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							oSettings.aoData[iRow]._anHidden[iColumn] = null;
2960
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
2961
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
2962
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
2963
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
2964
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
2965
 
2966
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
2967
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnBuildHead
2968
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Create the HTML header for the table
2969
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
2970
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
2971
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
2972
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnBuildHead( oSettings )
2973
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
2974
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var i, nTh, iLen, j, jLen;
2975
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var anTr = oSettings.nTHead.getElementsByTagName('tr');
2976
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var iThs = oSettings.nTHead.getElementsByTagName('th').length;
2977
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var iCorrector = 0;
2978
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var jqChildren;
2979
 
2980
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* If there is a header in place - then use it - otherwise it's going to get nuked... */
2981
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( iThs !== 0 )
2982
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
2983
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* We've got a thead from the DOM, so remove hidden columns and apply width to vis cols */
2984
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
2985
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
2986
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nTh = oSettings.aoColumns[i].nTh;
2987
 
2988
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( oSettings.aoColumns[i].sClass !== null )
2989
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
2990
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						$(nTh).addClass( oSettings.aoColumns[i].sClass );
2991
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
2992
 
2993
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* Set the title of the column if it is user defined (not what was auto detected) */
2994
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( oSettings.aoColumns[i].sTitle != nTh.innerHTML )
2995
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
2996
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						nTh.innerHTML = oSettings.aoColumns[i].sTitle;
2997
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
2998
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
2999
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3000
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else
3001
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3002
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* We don't have a header in the DOM - so we are going to have to create one */
3003
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				var nTr = document.createElement( "tr" );
3004
 
3005
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
3006
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3007
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nTh = oSettings.aoColumns[i].nTh;
3008
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nTh.innerHTML = oSettings.aoColumns[i].sTitle;
3009
 
3010
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( oSettings.aoColumns[i].sClass !== null )
3011
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
3012
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						$(nTh).addClass( oSettings.aoColumns[i].sClass );
3013
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
3014
 
3015
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nTr.appendChild( nTh );
3016
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3017
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				$(oSettings.nTHead).html( '' )[0].appendChild( nTr );
3018
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnDetectHeader( oSettings.aoHeader, oSettings.nTHead );
3019
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3020
 
3021
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Add the extra markup needed by jQuery UI's themes */
3022
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.bJUI )
3023
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3024
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
3025
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3026
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nTh = oSettings.aoColumns[i].nTh;
3027
 
3028
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					var nDiv = document.createElement('div');
3029
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nDiv.className = oSettings.oClasses.sSortJUIWrapper;
3030
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					$(nTh).contents().appendTo(nDiv);
3031
 
3032
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					var nSpan = document.createElement('span');
3033
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nSpan.className = oSettings.oClasses.sSortIcon;
3034
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nDiv.appendChild( nSpan );
3035
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nTh.appendChild( nDiv );
3036
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3037
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3038
 
3039
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Add sort listener */
3040
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var fnNoSelect = function (e) {
3041
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				this.onselectstart = function() { return false; };
3042
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				return false;
3043
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			};
3044
 
3045
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.oFeatures.bSort )
3046
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3047
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				for ( i=0 ; i<oSettings.aoColumns.length ; i++ )
3048
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3049
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( oSettings.aoColumns[i].bSortable !== false )
3050
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
3051
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						_fnSortAttachListener( oSettings, oSettings.aoColumns[i].nTh, i );
3052
 
3053
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						/* Take the brutal approach to cancelling text selection in header */
3054
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						$(oSettings.aoColumns[i].nTh).on( 'mousedown.DT', fnNoSelect );
3055
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
3056
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					else
3057
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
3058
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						$(oSettings.aoColumns[i].nTh).addClass( oSettings.oClasses.sSortableNone );
3059
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
3060
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3061
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3062
 
3063
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Deal with the footer - add classes if required */
3064
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.oClasses.sFooterTH !== "" )
3065
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3066
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				$(oSettings.nTFoot).children('tr').children('th').addClass( oSettings.oClasses.sFooterTH );
3067
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3068
 
3069
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Cache the footer elements */
3070
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.nTFoot !== null )
3071
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3072
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				var anCells = _fnGetUniqueThs( oSettings, null, oSettings.aoFooter );
3073
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
3074
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3075
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( typeof anCells[i] != 'undefined' )
3076
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
3077
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						oSettings.aoColumns[i].nTf = anCells[i];
3078
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
3079
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3080
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3081
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
3082
 
3083
 
3084
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
3085
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Section - Drawing functions
3086
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
3087
 
3088
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
3089
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnDrawHead
3090
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Draw the header (or footer) element based on the column visibility states. The
3091
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           methodology here is to use the layout array from _fnDetectHeader, modified for
3092
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           the instantaneous column visibility, to construct the new layout. The grid is
3093
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           traversed over cell at a time in a rows x columns grid fashion, although each 
3094
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           cell insert can cover multiple elements in the grid - which is tracks using the
3095
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           aApplied array. Cell inserts in the grid will only occur where there isn't
3096
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           already a cell in that position.
3097
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
3098
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
3099
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           array objects:aoSource - Layout array from _fnDetectHeader
3100
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           boolean:bIncludeHidden - If true then include the hidden columns in the calc, 
3101
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *             - optional: default false
3102
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
3103
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnDrawHead( oSettings, aoSource, bIncludeHidden )
3104
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
3105
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var i, iLen, j, jLen, k, kLen;
3106
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var aoLocal = [];
3107
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var aApplied = [];
3108
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var iColumns = oSettings.aoColumns.length;
3109
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var iRowspan, iColspan;
3110
 
3111
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof bIncludeHidden == 'undefined' )
3112
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3113
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				bIncludeHidden = false;
3114
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3115
 
3116
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Make a copy of the master layout array, but without the visible columns in it */
3117
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			for ( i=0, iLen=aoSource.length ; i<iLen ; i++ )
3118
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3119
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				aoLocal[i] = aoSource[i].slice();
3120
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				aoLocal[i].nTr = aoSource[i].nTr;
3121
 
3122
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Remove any columns which are currently hidden */
3123
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				for ( j=iColumns-1 ; j>=0 ; j-- )
3124
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3125
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( !oSettings.aoColumns[j].bVisible && !bIncludeHidden )
3126
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
3127
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						aoLocal[i].splice( j, 1 );
3128
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
3129
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3130
 
3131
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Prep the applied array - it needs an element for each row */
3132
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				aApplied.push( [] );
3133
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3134
 
3135
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			for ( i=0, iLen=aoLocal.length ; i<iLen ; i++ )
3136
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3137
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* All cells are going to be replaced, so empty out the row */
3138
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( aoLocal[i].nTr )
3139
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3140
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					for ( k=0, kLen=aoLocal[i].nTr.childNodes.length ; k<kLen ; k++ )
3141
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
3142
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						aoLocal[i].nTr.removeChild( aoLocal[i].nTr.childNodes[0] );
3143
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
3144
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3145
 
3146
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				for ( j=0, jLen=aoLocal[i].length ; j<jLen ; j++ )
3147
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3148
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					iRowspan = 1;
3149
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					iColspan = 1;
3150
 
3151
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* Check to see if there is already a cell (row/colspan) covering our target
3152
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					 * insert point. If there is, then there is nothing to do.
3153
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					 */
3154
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( typeof aApplied[i][j] == 'undefined' )
3155
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
3156
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						aoLocal[i].nTr.appendChild( aoLocal[i][j].cell );
3157
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						aApplied[i][j] = 1;
3158
 
3159
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						/* Expand the cell to cover as many rows as needed */
3160
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						while ( typeof aoLocal[i+iRowspan] != 'undefined' &&
3161
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						        aoLocal[i][j].cell == aoLocal[i+iRowspan][j].cell )
3162
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
3163
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							aApplied[i+iRowspan][j] = 1;
3164
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							iRowspan++;
3165
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
3166
 
3167
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						/* Expand the cell to cover as many columns as needed */
3168
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						while ( typeof aoLocal[i][j+iColspan] != 'undefined' &&
3169
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						        aoLocal[i][j].cell == aoLocal[i][j+iColspan].cell )
3170
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
3171
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							/* Must update the applied array over the rows for the columns */
3172
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							for ( k=0 ; k<iRowspan ; k++ )
3173
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							{
3174
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>								aApplied[i+k][j+iColspan] = 1;
3175
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							}
3176
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							iColspan++;
3177
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
3178
 
3179
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						/* Do the actual expansion in the DOM */
3180
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						aoLocal[i][j].cell.rowSpan = iRowspan;
3181
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						aoLocal[i][j].cell.colSpan = iColspan;
3182
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
3183
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3184
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3185
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
3186
 
3187
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
3188
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnDraw
3189
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Insert the required TR nodes into the table for display
3190
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
3191
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
3192
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
3193
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnDraw( oSettings )
3194
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
3195
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var i, iLen;
3196
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var anRows = [];
3197
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var iRowCount = 0;
3198
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var bRowError = false;
3199
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var iStripes = oSettings.asStripeClasses.length;
3200
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var iOpenRows = oSettings.aoOpenRows.length;
3201
 
3202
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Provide a pre-callback function which can be used to cancel the draw is false is returned */
3203
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.fnPreDrawCallback !== null &&
3204
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			     oSettings.fnPreDrawCallback.call( oSettings.oInstance, oSettings ) === false )
3205
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3206
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			     return;
3207
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3208
 
3209
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.bDrawing = true;
3210
 
3211
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Check and see if we have an initial draw position from state saving */
3212
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof oSettings.iInitDisplayStart != 'undefined' && oSettings.iInitDisplayStart != -1 )
3213
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3214
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( oSettings.oFeatures.bServerSide )
3215
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3216
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oSettings._iDisplayStart = oSettings.iInitDisplayStart;
3217
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3218
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				else
3219
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3220
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oSettings._iDisplayStart = (oSettings.iInitDisplayStart >= oSettings.fnRecordsDisplay()) ?
3221
 
3222
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3223
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.iInitDisplayStart = -1;
3224
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnCalculateEnd( oSettings );
3225
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3226
 
3227
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Server-side processing draw intercept */
3228
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.bDeferLoading )
3229
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3230
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.bDeferLoading = false;
3231
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.iDraw++;
3232
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3233
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else if ( !oSettings.oFeatures.bServerSide )
3234
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3235
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.iDraw++;
3236
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3237
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else if ( !oSettings.bDestroying && !_fnAjaxUpdate( oSettings ) )
3238
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3239
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				return;
3240
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3241
 
3242
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.aiDisplay.length !== 0 )
3243
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3244
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				var iStart = oSettings._iDisplayStart;
3245
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				var iEnd = oSettings._iDisplayEnd;
3246
 
3247
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( oSettings.oFeatures.bServerSide )
3248
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3249
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					iStart = 0;
3250
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					iEnd = oSettings.aoData.length;
3251
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3252
 
3253
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				for ( var j=iStart ; j<iEnd ; j++ )
3254
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3255
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					var aoData = oSettings.aoData[ oSettings.aiDisplay[j] ];
3256
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( aoData.nTr === null )
3257
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
3258
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						_fnCreateTr( oSettings, oSettings.aiDisplay[j] );
3259
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
3260
 
3261
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					var nRow = aoData.nTr;
3262
 
3263
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* Remove the old striping classes and then add the new one */
3264
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( iStripes !== 0 )
3265
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
3266
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						var sStripe = oSettings.asStripeClasses[ iRowCount % iStripes ];
3267
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						if ( aoData._sRowStripe != sStripe )
3268
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
3269
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							$(nRow).removeClass( aoData._sRowStripe ).addClass( sStripe );
3270
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							aoData._sRowStripe = sStripe;
3271
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
3272
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
3273
 
3274
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* Custom row callback function - might want to manipule the row */
3275
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( typeof oSettings.fnRowCallback == "function" )
3276
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
3277
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						nRow = oSettings.fnRowCallback.call( oSettings.oInstance, nRow, 
3278
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							oSettings.aoData[ oSettings.aiDisplay[j] ]._aData, iRowCount, j );
3279
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						if ( !nRow && !bRowError )
3280
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
3281
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							_fnLog( oSettings, 0, "A node was not returned by fnRowCallback" );
3282
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							bRowError = true;
3283
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
3284
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
3285
 
3286
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					anRows.push( nRow );
3287
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					iRowCount++;
3288
 
3289
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* If there is an open row - and it is attached to this parent - attach it on redraw */
3290
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( iOpenRows !== 0 )
3291
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
3292
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						for ( var k=0 ; k<iOpenRows ; k++ )
3293
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
3294
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							if ( nRow == oSettings.aoOpenRows[k].nParent )
3295
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							{
3296
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>								anRows.push( oSettings.aoOpenRows[k].nTr );
3297
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							}
3298
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
3299
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
3300
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3301
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3302
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else
3303
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3304
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Table is empty - create a row with an empty message in it */
3305
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				anRows[ 0 ] = document.createElement( 'tr' );
3306
 
3307
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( typeof oSettings.asStripeClasses[0] != 'undefined' )
3308
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3309
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					anRows[ 0 ].className = oSettings.asStripeClasses[0];
3310
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3311
 
3312
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				var sZero = oSettings.oLanguage.sZeroRecords.replace(
3313
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					'_MAX_', oSettings.fnFormatNumber(oSettings.fnRecordsTotal()) );
3314
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( oSettings.iDraw == 1 && oSettings.sAjaxSource !== null && !oSettings.oFeatures.bServerSide )
3315
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3316
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					sZero = oSettings.oLanguage.sLoadingRecords;
3317
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3318
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				else if ( typeof oSettings.oLanguage.sEmptyTable != 'undefined' &&
3319
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				     oSettings.fnRecordsTotal() === 0 )
3320
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3321
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					sZero = oSettings.oLanguage.sEmptyTable;
3322
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3323
 
3324
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				var nTd = document.createElement( 'td' );
3325
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nTd.setAttribute( 'valign', "top" );
3326
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nTd.colSpan = _fnVisbleColumns( oSettings );
3327
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nTd.className = oSettings.oClasses.sRowEmpty;
3328
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nTd.innerHTML = sZero;
3329
 
3330
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				anRows[ iRowCount ].appendChild( nTd );
3331
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3332
 
3333
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Callback the header and footer custom funcation if there is one */
3334
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof oSettings.fnHeaderCallback == 'function' )
3335
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3336
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.fnHeaderCallback.call( oSettings.oInstance, $(oSettings.nTHead).children('tr')[0], 
3337
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					_fnGetDataMaster( oSettings ), oSettings._iDisplayStart, oSettings.fnDisplayEnd(),
3338
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oSettings.aiDisplay );
3339
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3340
 
3341
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof oSettings.fnFooterCallback == 'function' )
3342
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3343
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.fnFooterCallback.call( oSettings.oInstance, $(oSettings.nTFoot).children('tr')[0], 
3344
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					_fnGetDataMaster( oSettings ), oSettings._iDisplayStart, oSettings.fnDisplayEnd(),
3345
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oSettings.aiDisplay );
3346
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3347
 
3348
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* 
3349
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Need to remove any old row from the display - note we can't just empty the tbody using
3350
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * $().html('') since this will unbind the jQuery event handlers (even although the node 
3351
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * still exists!) - equally we can't use innerHTML, since IE throws an exception.
3352
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
3353
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var
3354
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nAddFrag = document.createDocumentFragment(),
3355
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nRemoveFrag = document.createDocumentFragment(),
3356
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nBodyPar, nTrs;
3357
 
3358
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.nTBody )
3359
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3360
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nBodyPar = oSettings.nTBody.parentNode;
3361
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nRemoveFrag.appendChild( oSettings.nTBody );
3362
 
3363
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* When doing infinite scrolling, only remove child rows when sorting, filtering or start
3364
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				 * up. When not infinite scroll, always do it.
3365
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				 */
3366
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( !oSettings.oScroll.bInfinite || !oSettings._bInitComplete ||
3367
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				 	oSettings.bSorted || oSettings.bFiltered )
3368
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3369
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nTrs = oSettings.nTBody.childNodes;
3370
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					for ( i=nTrs.length-1 ; i>=0 ; i-- )
3371
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
3372
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						nTrs[i].parentNode.removeChild( nTrs[i] );
3373
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
3374
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3375
 
3376
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Put the draw table into the dom */
3377
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				for ( i=0, iLen=anRows.length ; i<iLen ; i++ )
3378
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3379
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nAddFrag.appendChild( anRows[i] );
3380
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3381
 
3382
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.nTBody.appendChild( nAddFrag );
3383
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( nBodyPar !== null )
3384
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3385
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nBodyPar.appendChild( oSettings.nTBody );
3386
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3387
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3388
 
3389
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Call all required callback functions for the end of a draw */
3390
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			for ( i=oSettings.aoDrawCallback.length-1 ; i>=0 ; i-- )
3391
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3392
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.aoDrawCallback[i].fn.call( oSettings.oInstance, oSettings );
3393
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3394
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			$(oSettings.oInstance).trigger('draw', oSettings);
3395
 
3396
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Draw is complete, sorting and filtering must be as well */
3397
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.bSorted = false;
3398
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.bFiltered = false;
3399
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.bDrawing = false;
3400
 
3401
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.oFeatures.bServerSide )
3402
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3403
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnProcessingDisplay( oSettings, false );
3404
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( typeof oSettings._bInitComplete == 'undefined' )
3405
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3406
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					_fnInitComplete( oSettings );
3407
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3408
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3409
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
3410
 
3411
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
3412
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnReDraw
3413
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Redraw the table - taking account of the various features which are enabled
3414
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
3415
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
3416
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
3417
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnReDraw( oSettings )
3418
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
3419
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.oFeatures.bSort )
3420
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3421
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Sorting will refilter and draw for us */
3422
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnSort( oSettings, oSettings.oPreviousSearch );
3423
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3424
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else if ( oSettings.oFeatures.bFilter )
3425
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3426
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Filtering will redraw for us */
3427
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnFilterComplete( oSettings, oSettings.oPreviousSearch );
3428
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3429
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else
3430
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3431
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnCalculateEnd( oSettings );
3432
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnDraw( oSettings );
3433
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3434
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
3435
 
3436
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
3437
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnAjaxUpdate
3438
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Update the table using an Ajax call
3439
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  bool: block the table drawing or not
3440
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
3441
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
3442
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnAjaxUpdate( oSettings )
3443
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
3444
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.bAjaxDataGet )
3445
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3446
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.iDraw++;
3447
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnProcessingDisplay( oSettings, true );
3448
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				var iColumns = oSettings.aoColumns.length;
3449
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				var aoData = _fnAjaxParameters( oSettings );
3450
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnServerParams( oSettings, aoData );
3451
 
3452
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.fnServerData.call( oSettings.oInstance, oSettings.sAjaxSource, aoData,
3453
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					function(json) {
3454
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						_fnAjaxUpdateDraw( oSettings, json );
3455
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}, oSettings );
3456
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				return false;
3457
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3458
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else
3459
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3460
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				return true;
3461
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3462
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
3463
 
3464
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
3465
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnAjaxParameters
3466
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Build up the parameters in an object needed for a server-side processing request
3467
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  bool: block the table drawing or not
3468
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
3469
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
3470
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnAjaxParameters( oSettings )
3471
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
3472
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var iColumns = oSettings.aoColumns.length;
3473
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var aoData = [], mDataProp;
3474
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var i;
3475
 
3476
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			aoData.push( { "name": "sEcho",          "value": oSettings.iDraw } );
3477
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			aoData.push( { "name": "iColumns",       "value": iColumns } );
3478
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			aoData.push( { "name": "sColumns",       "value": _fnColumnOrdering(oSettings) } );
3479
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			aoData.push( { "name": "iDisplayStart",  "value": oSettings._iDisplayStart } );
3480
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			aoData.push( { "name": "iDisplayLength", "value": oSettings.oFeatures.bPaginate !== false ?
3481
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings._iDisplayLength : -1 } );
3482
 
3483
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			for ( i=0 ; i<iColumns ; i++ )
3484
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3485
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			  mDataProp = oSettings.aoColumns[i].mDataProp;
3486
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				aoData.push( { "name": "mDataProp_"+i, "value": typeof(mDataProp)=="function" ? 'function' : mDataProp } );
3487
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3488
 
3489
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Filtering */
3490
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.oFeatures.bFilter !== false )
3491
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3492
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				aoData.push( { "name": "sSearch", "value": oSettings.oPreviousSearch.sSearch } );
3493
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				aoData.push( { "name": "bRegex",  "value": oSettings.oPreviousSearch.bRegex } );
3494
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				for ( i=0 ; i<iColumns ; i++ )
3495
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3496
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					aoData.push( { "name": "sSearch_"+i,     "value": oSettings.aoPreSearchCols[i].sSearch } );
3497
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					aoData.push( { "name": "bRegex_"+i,      "value": oSettings.aoPreSearchCols[i].bRegex } );
3498
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					aoData.push( { "name": "bSearchable_"+i, "value": oSettings.aoColumns[i].bSearchable } );
3499
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3500
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3501
 
3502
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Sorting */
3503
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.oFeatures.bSort !== false )
3504
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3505
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				var iFixed = oSettings.aaSortingFixed !== null ? oSettings.aaSortingFixed.length : 0;
3506
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				var iUser = oSettings.aaSorting.length;
3507
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				aoData.push( { "name": "iSortingCols",   "value": iFixed+iUser } );
3508
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				for ( i=0 ; i<iFixed ; i++ )
3509
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3510
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					aoData.push( { "name": "iSortCol_"+i,  "value": oSettings.aaSortingFixed[i][0] } );
3511
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					aoData.push( { "name": "sSortDir_"+i,  "value": oSettings.aaSortingFixed[i][1] } );
3512
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3513
 
3514
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				for ( i=0 ; i<iUser ; i++ )
3515
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3516
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					aoData.push( { "name": "iSortCol_"+(i+iFixed),  "value": oSettings.aaSorting[i][0] } );
3517
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					aoData.push( { "name": "sSortDir_"+(i+iFixed),  "value": oSettings.aaSorting[i][1] } );
3518
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3519
 
3520
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				for ( i=0 ; i<iColumns ; i++ )
3521
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3522
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					aoData.push( { "name": "bSortable_"+i,  "value": oSettings.aoColumns[i].bSortable } );
3523
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3524
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3525
 
3526
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			return aoData;
3527
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
3528
 
3529
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
3530
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnServerParams
3531
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Add Ajax parameters from plugins
3532
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
3533
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
3534
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           array objects:aoData - name/value pairs to send to the server
3535
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
3536
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnServerParams( oSettings, aoData )
3537
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
3538
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			for ( var i=0, iLen=oSettings.aoServerParams.length ; i<iLen ; i++ )
3539
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3540
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.aoServerParams[i].fn.call( oSettings.oInstance, aoData );
3541
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3542
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
3543
 
3544
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
3545
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnAjaxUpdateDraw
3546
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Data the data from the server (nuking the old) and redraw the table
3547
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
3548
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
3549
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           object:json - json data return from the server.
3550
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *             The following must be defined:
3551
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *               iTotalRecords, iTotalDisplayRecords, aaData
3552
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *             The following may be defined:
3553
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *               sColumns
3554
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
3555
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnAjaxUpdateDraw ( oSettings, json )
3556
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
3557
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof json.sEcho != 'undefined' )
3558
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3559
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Protect against old returns over-writing a new one. Possible when you get
3560
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				 * very fast interaction, and later queires are completed much faster
3561
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				 */
3562
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( json.sEcho*1 < oSettings.iDraw )
3563
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3564
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					return;
3565
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3566
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				else
3567
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3568
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oSettings.iDraw = json.sEcho * 1;
3569
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3570
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3571
 
3572
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( !oSettings.oScroll.bInfinite ||
3573
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				   (oSettings.oScroll.bInfinite && (oSettings.bSorted || oSettings.bFiltered)) )
3574
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3575
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnClearTable( oSettings );
3576
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3577
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings._iRecordsTotal = json.iTotalRecords;
3578
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings._iRecordsDisplay = json.iTotalDisplayRecords;
3579
 
3580
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Determine if reordering is required */
3581
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var sOrdering = _fnColumnOrdering(oSettings);
3582
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var bReOrder = (typeof json.sColumns != 'undefined' && sOrdering !== "" && json.sColumns != sOrdering );
3583
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( bReOrder )
3584
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3585
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				var aiIndex = _fnReOrderIndex( oSettings, json.sColumns );
3586
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3587
 
3588
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var fnDataSrc = _fnGetObjectDataFn( oSettings.sAjaxDataProp );
3589
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var aData = fnDataSrc( json );
3590
 
3591
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			for ( var i=0, iLen=aData.length ; i<iLen ; i++ )
3592
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3593
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( bReOrder )
3594
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3595
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* If we need to re-order, then create a new array with the correct order and add it */
3596
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					var aDataSorted = [];
3597
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					for ( var j=0, jLen=oSettings.aoColumns.length ; j<jLen ; j++ )
3598
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
3599
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						aDataSorted.push( aData[i][ aiIndex[j] ] );
3600
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
3601
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					_fnAddData( oSettings, aDataSorted );
3602
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3603
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				else
3604
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3605
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* No re-order required, sever got it "right" - just straight add */
3606
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					_fnAddData( oSettings, aData[i] );
3607
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3608
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3609
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
3610
 
3611
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.bAjaxDataGet = false;
3612
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			_fnDraw( oSettings );
3613
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.bAjaxDataGet = true;
3614
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			_fnProcessingDisplay( oSettings, false );
3615
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
3616
 
3617
 
3618
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
3619
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Section - Options (features) HTML
3620
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
3621
 
3622
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
3623
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnAddOptionsHtml
3624
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Add the options to the page HTML for the table
3625
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
3626
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
3627
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
3628
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnAddOptionsHtml ( oSettings )
3629
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
3630
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
3631
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Create a temporary, empty, div which we can later on replace with what we have generated
3632
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * we do it this way to rendering the 'options' html offline - speed :-)
3633
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
3634
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var nHolding = document.createElement( 'div' );
3635
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.nTable.parentNode.insertBefore( nHolding, oSettings.nTable );
3636
 
3637
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* 
3638
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * All DataTables are wrapped in a div
3639
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
3640
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.nTableWrapper = document.createElement( 'div' );
3641
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.nTableWrapper.className = oSettings.oClasses.sWrapper;
3642
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.sTableId !== '' )
3643
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3644
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.nTableWrapper.setAttribute( 'id', oSettings.sTableId+'_wrapper' );
3645
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3646
 
3647
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.nTableReinsertBefore = oSettings.nTable.nextSibling;
3648
 
3649
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Track where we want to insert the option */
3650
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var nInsertNode = oSettings.nTableWrapper;
3651
 
3652
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Loop over the user set positioning and place the elements as needed */
3653
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var aDom = oSettings.sDom.split('');
3654
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var nTmp, iPushFeature, cOption, nNewNode, cNext, sAttr, j;
3655
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			for ( var i=0 ; i<aDom.length ; i++ )
3656
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3657
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				iPushFeature = 0;
3658
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				cOption = aDom[i];
3659
 
3660
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( cOption == '<' )
3661
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3662
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* New container div */
3663
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nNewNode = document.createElement( 'div' );
3664
 
3665
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* Check to see if we should append an id and/or a class name to the container */
3666
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					cNext = aDom[i+1];
3667
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( cNext == "'" || cNext == '"' )
3668
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
3669
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						sAttr = "";
3670
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						j = 2;
3671
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						while ( aDom[i+j] != cNext )
3672
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
3673
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							sAttr += aDom[i+j];
3674
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							j++;
3675
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
3676
 
3677
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						/* Replace jQuery UI constants */
3678
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						if ( sAttr == "H" )
3679
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
3680
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							sAttr = "fg-toolbar ui-toolbar ui-widget-header ui-corner-tl ui-corner-tr ui-helper-clearfix";
3681
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
3682
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						else if ( sAttr == "F" )
3683
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
3684
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							sAttr = "fg-toolbar ui-toolbar ui-widget-header ui-corner-bl ui-corner-br ui-helper-clearfix";
3685
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
3686
 
3687
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						/* The attribute can be in the format of "#id.class", "#id" or "class" This logic
3688
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						 * breaks the string into parts and applies them as needed
3689
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						 */
3690
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						if ( sAttr.indexOf('.') != -1 )
3691
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
3692
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							var aSplit = sAttr.split('.');
3693
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							nNewNode.setAttribute('id', aSplit[0].substr(1, aSplit[0].length-1) );
3694
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							nNewNode.className = aSplit[1];
3695
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
3696
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						else if ( sAttr.charAt(0) == "#" )
3697
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
3698
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							nNewNode.setAttribute('id', sAttr.substr(1, sAttr.length-1) );
3699
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
3700
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						else
3701
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
3702
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							nNewNode.className = sAttr;
3703
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
3704
 
3705
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						i += j; /* Move along the position array */
3706
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
3707
 
3708
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nInsertNode.appendChild( nNewNode );
3709
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nInsertNode = nNewNode;
3710
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3711
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				else if ( cOption == '>' )
3712
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3713
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* End container div */
3714
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nInsertNode = nInsertNode.parentNode;
3715
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3716
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				else if ( cOption == 'l' && oSettings.oFeatures.bPaginate && oSettings.oFeatures.bLengthChange )
3717
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3718
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* Length */
3719
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nTmp = _fnFeatureHtmlLength( oSettings );
3720
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					iPushFeature = 1;
3721
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3722
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				else if ( cOption == 'f' && oSettings.oFeatures.bFilter )
3723
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3724
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* Filter */
3725
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nTmp = _fnFeatureHtmlFilter( oSettings );
3726
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					iPushFeature = 1;
3727
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3728
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				else if ( cOption == 'r' && oSettings.oFeatures.bProcessing )
3729
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3730
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* pRocessing */
3731
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nTmp = _fnFeatureHtmlProcessing( oSettings );
3732
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					iPushFeature = 1;
3733
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3734
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				else if ( cOption == 't' )
3735
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3736
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* Table */
3737
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nTmp = _fnFeatureHtmlTable( oSettings );
3738
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					iPushFeature = 1;
3739
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3740
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				else if ( cOption ==  'i' && oSettings.oFeatures.bInfo )
3741
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3742
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* Info */
3743
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nTmp = _fnFeatureHtmlInfo( oSettings );
3744
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					iPushFeature = 1;
3745
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3746
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				else if ( cOption == 'p' && oSettings.oFeatures.bPaginate )
3747
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3748
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* Pagination */
3749
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nTmp = _fnFeatureHtmlPaginate( oSettings );
3750
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					iPushFeature = 1;
3751
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3752
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				else if ( _oExt.aoFeatures.length !== 0 )
3753
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3754
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* Plug-in features */
3755
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					var aoFeatures = _oExt.aoFeatures;
3756
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					for ( var k=0, kLen=aoFeatures.length ; k<kLen ; k++ )
3757
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
3758
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						if ( cOption == aoFeatures[k].cFeature )
3759
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
3760
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							nTmp = aoFeatures[k].fnInit( oSettings );
3761
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							if ( nTmp )
3762
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							{
3763
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>								iPushFeature = 1;
3764
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							}
3765
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							break;
3766
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
3767
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
3768
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3769
 
3770
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Add to the 2D features array */
3771
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( iPushFeature == 1 && nTmp !== null )
3772
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3773
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( typeof oSettings.aanFeatures[cOption] != 'object' )
3774
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
3775
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						oSettings.aanFeatures[cOption] = [];
3776
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
3777
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oSettings.aanFeatures[cOption].push( nTmp );
3778
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nInsertNode.appendChild( nTmp );
3779
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3780
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3781
 
3782
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Built our DOM structure - replace the holding div with what we want */
3783
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nHolding.parentNode.replaceChild( oSettings.nTableWrapper, nHolding );
3784
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
3785
 
3786
 
3787
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
3788
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Section - Feature: Filtering
3789
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
3790
 
3791
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
3792
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnFeatureHtmlTable
3793
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Add any control elements for the table - specifically scrolling
3794
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  node: - Node to add to the DOM
3795
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
3796
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
3797
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnFeatureHtmlTable ( oSettings )
3798
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
3799
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Chack if scrolling is enabled or not - if not then leave the DOM unaltered */
3800
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.oScroll.sX === "" && oSettings.oScroll.sY === "" )
3801
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3802
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				return oSettings.nTable;
3803
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3804
 
3805
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
3806
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * The HTML structure that we want to generate in this function is:
3807
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *  div - nScroller
3808
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *    div - nScrollHead
3809
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *      div - nScrollHeadInner
3810
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *        table - nScrollHeadTable
3811
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *          thead - nThead
3812
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *    div - nScrollBody
3813
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *      table - oSettings.nTable
3814
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *        thead - nTheadSize
3815
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *        tbody - nTbody
3816
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *    div - nScrollFoot
3817
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *      div - nScrollFootInner
3818
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *        table - nScrollFootTable
3819
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 *          tfoot - nTfoot
3820
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
3821
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var
3822
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 	nScroller = document.createElement('div'),
3823
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 	nScrollHead = document.createElement('div'),
3824
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 	nScrollHeadInner = document.createElement('div'),
3825
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 	nScrollBody = document.createElement('div'),
3826
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 	nScrollFoot = document.createElement('div'),
3827
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 	nScrollFootInner = document.createElement('div'),
3828
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 	nScrollHeadTable = oSettings.nTable.cloneNode(false),
3829
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 	nScrollFootTable = oSettings.nTable.cloneNode(false),
3830
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nThead = oSettings.nTable.getElementsByTagName('thead')[0],
3831
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 	nTfoot = oSettings.nTable.getElementsByTagName('tfoot').length === 0 ? null : 
3832
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oSettings.nTable.getElementsByTagName('tfoot')[0],
3833
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oClasses = (typeof oInit.bJQueryUI != 'undefined' && oInit.bJQueryUI) ?
3834
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					_oExt.oJUIClasses : _oExt.oStdClasses;
3835
 
3836
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nScrollHead.appendChild( nScrollHeadInner );
3837
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nScrollFoot.appendChild( nScrollFootInner );
3838
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nScrollBody.appendChild( oSettings.nTable );
3839
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nScroller.appendChild( nScrollHead );
3840
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nScroller.appendChild( nScrollBody );
3841
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nScrollHeadInner.appendChild( nScrollHeadTable );
3842
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nScrollHeadTable.appendChild( nThead );
3843
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( nTfoot !== null )
3844
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3845
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScroller.appendChild( nScrollFoot );
3846
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollFootInner.appendChild( nScrollFootTable );
3847
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollFootTable.appendChild( nTfoot );
3848
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3849
 
3850
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nScroller.className = oClasses.sScrollWrapper;
3851
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nScrollHead.className = oClasses.sScrollHead;
3852
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nScrollHeadInner.className = oClasses.sScrollHeadInner;
3853
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nScrollBody.className = oClasses.sScrollBody;
3854
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nScrollFoot.className = oClasses.sScrollFoot;
3855
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nScrollFootInner.className = oClasses.sScrollFootInner;
3856
 
3857
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.oScroll.bAutoCss )
3858
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3859
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollHead.style.overflow = "hidden";
3860
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollHead.style.position = "relative";
3861
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollFoot.style.overflow = "hidden";
3862
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollBody.style.overflow = "auto";
3863
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3864
 
3865
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nScrollHead.style.border = "0";
3866
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nScrollHead.style.width = "100%";
3867
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nScrollFoot.style.border = "0";
3868
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nScrollHeadInner.style.width = "150%"; /* will be overwritten */
3869
 
3870
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Modify attributes to respect the clones */
3871
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nScrollHeadTable.removeAttribute('id');
3872
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nScrollHeadTable.style.marginLeft = "0";
3873
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.nTable.style.marginLeft = "0";
3874
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( nTfoot !== null )
3875
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3876
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollFootTable.removeAttribute('id');
3877
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollFootTable.style.marginLeft = "0";
3878
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3879
 
3880
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Move any caption elements from the body to the header */
3881
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var nCaptions = $(oSettings.nTable).children('caption');
3882
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			for ( var i=0, iLen=nCaptions.length ; i<iLen ; i++ )
3883
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3884
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollHeadTable.appendChild( nCaptions[i] );
3885
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3886
 
3887
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
3888
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Sizing
3889
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
3890
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* When xscrolling add the width and a scroller to move the header with the body */
3891
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.oScroll.sX !== "" )
3892
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3893
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollHead.style.width = _fnStringToCss( oSettings.oScroll.sX );
3894
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollBody.style.width = _fnStringToCss( oSettings.oScroll.sX );
3895
 
3896
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( nTfoot !== null )
3897
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3898
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nScrollFoot.style.width = _fnStringToCss( oSettings.oScroll.sX );	
3899
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3900
 
3901
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* When the body is scrolled, then we also want to scroll the headers */
3902
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				$(nScrollBody).scroll( function (e) {
3903
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nScrollHead.scrollLeft = this.scrollLeft;
3904
 
3905
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( nTfoot !== null )
3906
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
3907
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						nScrollFoot.scrollLeft = this.scrollLeft;
3908
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
3909
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				} );
3910
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3911
 
3912
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* When yscrolling, add the height */
3913
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.oScroll.sY !== "" )
3914
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3915
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollBody.style.height = _fnStringToCss( oSettings.oScroll.sY );
3916
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3917
 
3918
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Redraw - align columns across the tables */
3919
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.aoDrawCallback.push( {
3920
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"fn": _fnScrollDraw,
3921
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				"sName": "scrolling"
3922
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			} );
3923
 
3924
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Infinite scrolling event handlers */
3925
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.oScroll.bInfinite )
3926
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3927
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				$(nScrollBody).scroll( function() {
3928
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* Use a blocker to stop scrolling from loading more data while other data is still loading */
3929
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( !oSettings.bDrawing )
3930
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
3931
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						/* Check if we should load the next data set */
3932
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						if ( $(this).scrollTop() + $(this).height() > 
3933
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							$(oSettings.nTable).height() - oSettings.oScroll.iLoadGap )
3934
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
3935
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							/* Only do the redraw if we have to - we might be at the end of the data */
3936
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							if ( oSettings.fnDisplayEnd() < oSettings.fnRecordsDisplay() )
3937
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							{
3938
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>								_fnPageChange( oSettings, 'next' );
3939
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>								_fnCalculateEnd( oSettings );
3940
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>								_fnDraw( oSettings );
3941
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							}
3942
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
3943
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
3944
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				} );
3945
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3946
 
3947
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.nScrollHead = nScrollHead;
3948
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.nScrollFoot = nScrollFoot;
3949
 
3950
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			return nScroller;
3951
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
3952
 
3953
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
3954
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnScrollDraw
3955
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Update the various tables for resizing
3956
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  node: - Node to add to the DOM
3957
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:o - dataTables settings object
3958
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Notes:    It's a bit of a pig this function, but basically the idea to:
3959
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *   1. Re-create the table inside the scrolling div
3960
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *   2. Take live measurements from the DOM
3961
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *   3. Apply the measurements
3962
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *   4. Clean up
3963
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
3964
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnScrollDraw ( o )
3965
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
3966
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var
3967
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollHeadInner = o.nScrollHead.getElementsByTagName('div')[0],
3968
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollHeadTable = nScrollHeadInner.getElementsByTagName('table')[0],
3969
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollBody = o.nTable.parentNode,
3970
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				i, iLen, j, jLen, anHeadToSize, anHeadSizers, anFootSizers, anFootToSize, oStyle, iVis,
3971
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				iWidth, aApplied=[], iSanityWidth,
3972
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollFootInner = (o.nTFoot !== null) ? o.nScrollFoot.getElementsByTagName('div')[0] : null,
3973
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollFootTable = (o.nTFoot !== null) ? nScrollFootInner.getElementsByTagName('table')[0] : null,
3974
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				ie67 = (navigator.userAgent.match(/MSIE ([2-7]\.)/) !== null);
3975
 
3976
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
3977
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * 1. Re-create the table inside the scrolling div
3978
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
3979
 
3980
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Remove the old minimised thead and tfoot elements in the inner table */
3981
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var nTheadSize = o.nTable.getElementsByTagName('thead');
3982
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( nTheadSize.length > 0 )
3983
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3984
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				o.nTable.removeChild( nTheadSize[0] );
3985
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3986
 
3987
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( o.nTFoot !== null )
3988
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
3989
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Remove the old minimised footer element in the cloned header */
3990
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				var nTfootSize = o.nTable.getElementsByTagName('tfoot');
3991
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( nTfootSize.length > 0 )
3992
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
3993
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					o.nTable.removeChild( nTfootSize[0] );
3994
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
3995
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
3996
 
3997
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Clone the current header and footer elements and then place it into the inner table */
3998
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nTheadSize = o.nTHead.cloneNode(true);
3999
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			o.nTable.insertBefore( nTheadSize, o.nTable.childNodes[0] );
4000
 
4001
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( o.nTFoot !== null )
4002
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4003
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nTfootSize = o.nTFoot.cloneNode(true);
4004
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				o.nTable.insertBefore( nTfootSize, o.nTable.childNodes[1] );
4005
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4006
 
4007
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
4008
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * 2. Take live measurements from the DOM - do not alter the DOM itself!
4009
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
4010
 
4011
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Remove old sizing and apply the calculated column widths
4012
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * Get the unique column headers in the newly created (cloned) header. We want to apply the
4013
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * calclated sizes to this header
4014
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
4015
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( o.oScroll.sX === "" )
4016
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4017
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollBody.style.width = '100%';
4018
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollHeadInner.parentNode.style.width = '100%';
4019
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4020
 
4021
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var nThs = _fnGetUniqueThs( o, nTheadSize );
4022
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			for ( i=0, iLen=nThs.length ; i<iLen ; i++ )
4023
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4024
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				iVis = _fnVisibleToColumnIndex( o, i );
4025
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nThs[i].style.width = o.aoColumns[iVis].sWidth;
4026
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4027
 
4028
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( o.nTFoot !== null )
4029
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4030
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnApplyToChildren( function(n) {
4031
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					n.style.width = "";
4032
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}, nTfootSize.getElementsByTagName('tr') );
4033
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4034
 
4035
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Size the table as a whole */
4036
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			iSanityWidth = $(o.nTable).outerWidth();
4037
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( o.oScroll.sX === "" )
4038
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4039
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* No x scrolling */
4040
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				o.nTable.style.width = "100%";
4041
 
4042
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* I know this is rubbish - but IE7 will make the width of the table when 100% include
4043
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				 * the scrollbar - which is shouldn't. When there is a scrollbar we need to take this
4044
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				 * into account.
4045
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				 */
4046
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( ie67 && (nScrollBody.scrollHeight > 
4047
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nScrollBody.offsetHeight || $(nScrollBody).css('overflow-y') == "scroll")  )
4048
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
4049
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					o.nTable.style.width = _fnStringToCss( $(o.nTable).outerWidth()-o.oScroll.iBarWidth );
4050
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
4051
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4052
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else
4053
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4054
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( o.oScroll.sXInner !== "" )
4055
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
4056
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* x scroll inner has been given - use it */
4057
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					o.nTable.style.width = _fnStringToCss(o.oScroll.sXInner);
4058
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
4059
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				else if ( iSanityWidth == $(nScrollBody).width() &&
4060
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				   $(nScrollBody).height() < $(o.nTable).height() )
4061
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
4062
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* There is y-scrolling - try to take account of the y scroll bar */
4063
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					o.nTable.style.width = _fnStringToCss( iSanityWidth-o.oScroll.iBarWidth );
4064
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( $(o.nTable).outerWidth() > iSanityWidth-o.oScroll.iBarWidth )
4065
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
4066
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						/* Not possible to take account of it */
4067
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						o.nTable.style.width = _fnStringToCss( iSanityWidth );
4068
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
4069
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
4070
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				else
4071
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
4072
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* All else fails */
4073
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					o.nTable.style.width = _fnStringToCss( iSanityWidth );
4074
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
4075
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4076
 
4077
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Recalculate the sanity width - now that we've applied the required width, before it was
4078
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * a temporary variable. This is required because the column width calculation is done
4079
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * before this table DOM is created.
4080
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
4081
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			iSanityWidth = $(o.nTable).outerWidth();
4082
 
4083
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* We want the hidden header to have zero height, so remove padding and borders. Then
4084
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * set the width based on the real headers
4085
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
4086
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			anHeadToSize = o.nTHead.getElementsByTagName('tr');
4087
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			anHeadSizers = nTheadSize.getElementsByTagName('tr');
4088
 
4089
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			_fnApplyToChildren( function(nSizer, nToSize) {
4090
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oStyle = nSizer.style;
4091
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oStyle.paddingTop = "0";
4092
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oStyle.paddingBottom = "0";
4093
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oStyle.borderTopWidth = "0";
4094
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oStyle.borderBottomWidth = "0";
4095
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oStyle.height = 0;
4096
 
4097
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				iWidth = $(nSizer).width();
4098
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nToSize.style.width = _fnStringToCss( iWidth );
4099
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				aApplied.push( iWidth );
4100
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}, anHeadSizers, anHeadToSize );
4101
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			$(anHeadSizers).height(0);
4102
 
4103
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( o.nTFoot !== null )
4104
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4105
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Clone the current footer and then place it into the body table as a "hidden header" */
4106
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				anFootSizers = nTfootSize.getElementsByTagName('tr');
4107
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				anFootToSize = o.nTFoot.getElementsByTagName('tr');
4108
 
4109
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnApplyToChildren( function(nSizer, nToSize) {
4110
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oStyle = nSizer.style;
4111
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oStyle.paddingTop = "0";
4112
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oStyle.paddingBottom = "0";
4113
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oStyle.borderTopWidth = "0";
4114
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oStyle.borderBottomWidth = "0";
4115
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oStyle.height = 0;
4116
 
4117
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					iWidth = $(nSizer).width();
4118
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nToSize.style.width = _fnStringToCss( iWidth );
4119
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					aApplied.push( iWidth );
4120
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}, anFootSizers, anFootToSize );
4121
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				$(anFootSizers).height(0);
4122
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4123
 
4124
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
4125
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * 3. Apply the measurements
4126
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
4127
 
4128
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* "Hide" the header and footer that we used for the sizing. We want to also fix their width
4129
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * to what they currently are
4130
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
4131
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			_fnApplyToChildren( function(nSizer) {
4132
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nSizer.innerHTML = "";
4133
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nSizer.style.width = _fnStringToCss( aApplied.shift() );
4134
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}, anHeadSizers );
4135
 
4136
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( o.nTFoot !== null )
4137
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4138
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnApplyToChildren( function(nSizer) {
4139
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nSizer.innerHTML = "";
4140
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nSizer.style.width = _fnStringToCss( aApplied.shift() );
4141
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}, anFootSizers );
4142
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4143
 
4144
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Sanity check that the table is of a sensible width. If not then we are going to get
4145
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * misalignment - try to prevent this by not allowing the table to shrink below its min width
4146
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
4147
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( $(o.nTable).outerWidth() < iSanityWidth )
4148
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4149
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* The min width depends upon if we have a vertical scrollbar visible or not */
4150
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				var iCorrection = ((nScrollBody.scrollHeight > nScrollBody.offsetHeight || 
4151
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					$(nScrollBody).css('overflow-y') == "scroll")) ?
4152
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						iSanityWidth+o.oScroll.iBarWidth : iSanityWidth;
4153
 
4154
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* IE6/7 are a law unto themselves... */
4155
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( ie67 && (nScrollBody.scrollHeight > 
4156
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nScrollBody.offsetHeight || $(nScrollBody).css('overflow-y') == "scroll")  )
4157
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
4158
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					o.nTable.style.width = _fnStringToCss( iCorrection-o.oScroll.iBarWidth );
4159
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
4160
 
4161
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Apply the calculated minimum width to the table wrappers */
4162
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollBody.style.width = _fnStringToCss( iCorrection );
4163
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollHeadInner.parentNode.style.width = _fnStringToCss( iCorrection );
4164
 
4165
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( o.nTFoot !== null )
4166
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
4167
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nScrollFootInner.parentNode.style.width = _fnStringToCss( iCorrection );
4168
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
4169
 
4170
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* And give the user a warning that we've stopped the table getting too small */
4171
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( o.oScroll.sX === "" )
4172
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
4173
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					_fnLog( o, 1, "The table cannot fit into the current element which will cause column"+
4174
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						" misalignment. The table has been drawn at its minimum possible width." );
4175
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
4176
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				else if ( o.oScroll.sXInner !== "" )
4177
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
4178
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					_fnLog( o, 1, "The table cannot fit into the current element which will cause column"+
4179
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						" misalignment. Increase the sScrollXInner value or remove it to allow automatic"+
4180
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						" calculation" );
4181
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
4182
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4183
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else
4184
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4185
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollBody.style.width = _fnStringToCss( '100%' );
4186
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollHeadInner.parentNode.style.width = _fnStringToCss( '100%' );
4187
 
4188
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( o.nTFoot !== null )
4189
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
4190
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nScrollFootInner.parentNode.style.width = _fnStringToCss( '100%' );
4191
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
4192
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4193
 
4194
 
4195
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
4196
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * 4. Clean up
4197
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
4198
 
4199
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( o.oScroll.sY === "" )
4200
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4201
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* IE7< puts a vertical scrollbar in place (when it shouldn't be) due to subtracting
4202
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				 * the scrollbar height from the visible display, rather than adding it on. We need to
4203
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				 * set the height in order to sort this. Don't want to do it in any other browsers.
4204
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				 */
4205
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( ie67 )
4206
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
4207
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nScrollBody.style.height = _fnStringToCss( o.nTable.offsetHeight+o.oScroll.iBarWidth );
4208
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
4209
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4210
 
4211
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( o.oScroll.sY !== "" && o.oScroll.bCollapse )
4212
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4213
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollBody.style.height = _fnStringToCss( o.oScroll.sY );
4214
 
4215
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				var iExtra = (o.oScroll.sX !== "" && o.nTable.offsetWidth > nScrollBody.offsetWidth) ?
4216
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				 	o.oScroll.iBarWidth : 0;
4217
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( o.nTable.offsetHeight < nScrollBody.offsetHeight )
4218
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
4219
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					nScrollBody.style.height = _fnStringToCss( $(o.nTable).height()+iExtra );
4220
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
4221
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4222
 
4223
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Finally set the width's of the header and footer tables */
4224
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var iOuterWidth = $(o.nTable).outerWidth();
4225
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nScrollHeadTable.style.width = _fnStringToCss( iOuterWidth );
4226
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nScrollHeadInner.style.width = _fnStringToCss( iOuterWidth+o.oScroll.iBarWidth );
4227
 
4228
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( o.nTFoot !== null )
4229
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4230
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollFootInner.style.width = _fnStringToCss( o.nTable.offsetWidth+o.oScroll.iBarWidth );
4231
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollFootTable.style.width = _fnStringToCss( o.nTable.offsetWidth );
4232
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4233
 
4234
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* If sorting or filtering has occured, jump the scrolling back to the top */
4235
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( o.bSorted || o.bFiltered )
4236
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4237
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nScrollBody.scrollTop = 0;
4238
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4239
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
4240
 
4241
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
4242
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnAdjustColumnSizing
4243
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Adjust the table column widths for new data
4244
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
4245
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
4246
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Notes:    You would probably want to do a redraw after calling this function!
4247
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
4248
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnAdjustColumnSizing ( oSettings )
4249
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
4250
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Not interested in doing column width calculation if autowidth is disabled */
4251
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.oFeatures.bAutoWidth === false )
4252
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4253
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				return false;
4254
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4255
 
4256
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			_fnCalculateColumnWidths( oSettings );
4257
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			for ( var i=0 , iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
4258
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4259
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.aoColumns[i].nTh.style.width = oSettings.aoColumns[i].sWidth;
4260
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4261
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
4262
 
4263
 
4264
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
4265
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Section - Feature: Filtering
4266
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
4267
 
4268
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
4269
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnFeatureHtmlFilter
4270
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Generate the node required for filtering text
4271
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  node
4272
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
4273
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
4274
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnFeatureHtmlFilter ( oSettings )
4275
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
4276
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var sSearchStr = oSettings.oLanguage.sSearch;
4277
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			sSearchStr = (sSearchStr.indexOf('_INPUT_') !== -1) ?
4278
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			  sSearchStr.replace('_INPUT_', '<input type="text" />') :
4279
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			  sSearchStr==="" ? '<input type="text" />' : sSearchStr+' <input type="text" />';
4280
 
4281
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var nFilter = document.createElement( 'div' );
4282
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nFilter.className = oSettings.oClasses.sFilter;
4283
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			nFilter.innerHTML = '<label>'+sSearchStr+'</label>';
4284
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( oSettings.sTableId !== '' && typeof oSettings.aanFeatures.f == "undefined" )
4285
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4286
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nFilter.setAttribute( 'id', oSettings.sTableId+'_filter' );
4287
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4288
 
4289
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var jqFilter = $("input", nFilter);
4290
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			jqFilter.val( oSettings.oPreviousSearch.sSearch.replace('"','&quot;') );
4291
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			jqFilter.on( 'keyup.DT', function(e) {
4292
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Update all other filter input elements for the new display */
4293
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				var n = oSettings.aanFeatures.f;
4294
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				for ( var i=0, iLen=n.length ; i<iLen ; i++ )
4295
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
4296
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( n[i] != $(this).parents('div.dataTables_filter')[0] )
4297
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
4298
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						$('input', n[i]).val( this.value );
4299
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
4300
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
4301
 
4302
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Now do the filter */
4303
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( this.value != oSettings.oPreviousSearch.sSearch )
4304
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
4305
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					_fnFilterComplete( oSettings, { 
4306
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						"sSearch": this.value, 
4307
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						"bRegex":  oSettings.oPreviousSearch.bRegex,
4308
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						"bSmart":  oSettings.oPreviousSearch.bSmart 
4309
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					} );
4310
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
4311
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			} );
4312
 
4313
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			jqFilter.on( 'keypress.DT', function(e) {
4314
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Prevent default */
4315
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( e.keyCode == 13 )
4316
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
4317
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					return false;
4318
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
4319
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			} );
4320
 
4321
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			return nFilter;
4322
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
4323
 
4324
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
4325
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnFilterComplete
4326
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Filter the table using both the global filter and column based filtering
4327
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
4328
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
4329
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           object:oSearch: search information
4330
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           int:iForce - optional - force a research of the master array (1) or not (undefined or 0)
4331
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
4332
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnFilterComplete ( oSettings, oInput, iForce )
4333
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
4334
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Filter on everything */
4335
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			_fnFilter( oSettings, oInput.sSearch, iForce, oInput.bRegex, oInput.bSmart );
4336
 
4337
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Now do the individual column filter */
4338
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			for ( var i=0 ; i<oSettings.aoPreSearchCols.length ; i++ )
4339
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4340
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnFilterColumn( oSettings, oSettings.aoPreSearchCols[i].sSearch, i, 
4341
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oSettings.aoPreSearchCols[i].bRegex, oSettings.aoPreSearchCols[i].bSmart );
4342
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4343
 
4344
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Custom filtering */
4345
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( _oExt.afnFiltering.length !== 0 )
4346
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4347
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				_fnFilterCustom( oSettings );
4348
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4349
 
4350
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Tell the draw function we have been filtering */
4351
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.bFiltered = true;
4352
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			$(oSettings.oInstance).trigger('filter', oSettings);
4353
 
4354
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Redraw the table */
4355
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings._iDisplayStart = 0;
4356
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			_fnCalculateEnd( oSettings );
4357
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			_fnDraw( oSettings );
4358
 
4359
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Rebuild search array 'offline' */
4360
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			_fnBuildSearchArray( oSettings, 0 );
4361
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
4362
 
4363
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
4364
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnFilterCustom
4365
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Apply custom filtering functions
4366
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
4367
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
4368
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
4369
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnFilterCustom( oSettings )
4370
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
4371
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var afnFilters = _oExt.afnFiltering;
4372
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			for ( var i=0, iLen=afnFilters.length ; i<iLen ; i++ )
4373
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4374
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				var iCorrector = 0;
4375
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				for ( var j=0, jLen=oSettings.aiDisplay.length ; j<jLen ; j++ )
4376
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
4377
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					var iDisIndex = oSettings.aiDisplay[j-iCorrector];
4378
 
4379
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* Check if we should use this row based on the filtering function */
4380
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					if ( !afnFilters[i]( oSettings, _fnGetRowData( oSettings, iDisIndex, 'filter' ), iDisIndex ) )
4381
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
4382
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						oSettings.aiDisplay.splice( j-iCorrector, 1 );
4383
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						iCorrector++;
4384
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
4385
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
4386
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4387
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
4388
 
4389
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
4390
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnFilterColumn
4391
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Filter the table on a per-column basis
4392
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
4393
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
4394
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           string:sInput - string to filter on
4395
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           int:iColumn - column to filter
4396
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           bool:bRegex - treat search string as a regular expression or not
4397
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           bool:bSmart - use smart filtering or not
4398
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
4399
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnFilterColumn ( oSettings, sInput, iColumn, bRegex, bSmart )
4400
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
4401
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( sInput === "" )
4402
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4403
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				return;
4404
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4405
 
4406
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var iIndexCorrector = 0;
4407
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var rpSearch = _fnFilterCreateSearch( sInput, bRegex, bSmart );
4408
 
4409
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			for ( var i=oSettings.aiDisplay.length-1 ; i>=0 ; i-- )
4410
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4411
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				var sData = _fnDataToSearch( _fnGetCellData( oSettings, oSettings.aiDisplay[i], iColumn, 'filter' ),
4412
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oSettings.aoColumns[iColumn].sType );
4413
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( ! rpSearch.test( sData ) )
4414
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
4415
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oSettings.aiDisplay.splice( i, 1 );
4416
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					iIndexCorrector++;
4417
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
4418
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4419
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
4420
 
4421
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
4422
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnFilter
4423
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Filter the data table based on user input and draw the table
4424
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
4425
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
4426
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           string:sInput - string to filter on
4427
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           int:iForce - optional - force a research of the master array (1) or not (undefined or 0)
4428
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           bool:bRegex - treat as a regular expression or not
4429
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           bool:bSmart - perform smart filtering or not
4430
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
4431
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnFilter( oSettings, sInput, iForce, bRegex, bSmart )
4432
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
4433
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var i;
4434
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var rpSearch = _fnFilterCreateSearch( sInput, bRegex, bSmart );
4435
 
4436
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Check if we are forcing or not - optional parameter */
4437
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof iForce == 'undefined' || iForce === null )
4438
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4439
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				iForce = 0;
4440
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4441
 
4442
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* Need to take account of custom filtering functions - always filter */
4443
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( _oExt.afnFiltering.length !== 0 )
4444
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4445
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				iForce = 1;
4446
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4447
 
4448
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/*
4449
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 * If the input is blank - we want the full data set
4450
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 */
4451
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( sInput.length <= 0 )
4452
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4453
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.aiDisplay.splice( 0, oSettings.aiDisplay.length);
4454
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
4455
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4456
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else
4457
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4458
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/*
4459
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				 * We are starting a new search or the new search string is smaller 
4460
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				 * then the old one (i.e. delete). Search from the master array
4461
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			 	 */
4462
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( oSettings.aiDisplay.length == oSettings.aiDisplayMaster.length ||
4463
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					   oSettings.oPreviousSearch.sSearch.length > sInput.length || iForce == 1 ||
4464
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					   sInput.indexOf(oSettings.oPreviousSearch.sSearch) !== 0 )
4465
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
4466
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* Nuke the old display array - we are going to rebuild it */
4467
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oSettings.aiDisplay.splice( 0, oSettings.aiDisplay.length);
4468
 
4469
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* Force a rebuild of the search array */
4470
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					_fnBuildSearchArray( oSettings, 1 );
4471
 
4472
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					/* Search through all records to populate the search array
4473
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					 * The the oSettings.aiDisplayMaster and asDataSearch arrays have 1 to 1 
4474
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					 * mapping
4475
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					 */
4476
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					for ( i=0 ; i<oSettings.aiDisplayMaster.length ; i++ )
4477
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
4478
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						if ( rpSearch.test(oSettings.asDataSearch[i]) )
4479
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
4480
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>							oSettings.aiDisplay.push( oSettings.aiDisplayMaster[i] );
4481
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						}
4482
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					}
4483
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			  }
4484
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			  else
4485
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
4486
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			  	/* Using old search array - refine it - do it this way for speed
4487
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			  	 * Don't have to search the whole master array again
4488
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					 */
4489
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			  	var iIndexCorrector = 0;
4490
 
4491
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			  	/* Search the current results */
4492
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			  	for ( i=0 ; i<oSettings.asDataSearch.length ; i++ )
4493
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					{
4494
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			  		if ( ! rpSearch.test(oSettings.asDataSearch[i]) )
4495
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						{
4496
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			  			oSettings.aiDisplay.splice( i-iIndexCorrector, 1 );
4497
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			  			iIndexCorrector++;
4498
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			  		}
4499
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			  	}
4500
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			  }
4501
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4502
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.oPreviousSearch.sSearch = sInput;
4503
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.oPreviousSearch.bRegex = bRegex;
4504
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			oSettings.oPreviousSearch.bSmart = bSmart;
4505
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
4506
 
4507
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
4508
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnBuildSearchArray
4509
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Create an array which can be quickly search through
4510
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
4511
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
4512
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           int:iMaster - use the master data array - optional
4513
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
4514
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnBuildSearchArray ( oSettings, iMaster )
4515
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
4516
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( !oSettings.oFeatures.bServerSide )
4517
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4518
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Clear out the old data */
4519
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.asDataSearch.splice( 0, oSettings.asDataSearch.length );
4520
 
4521
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				var aArray = (typeof iMaster != 'undefined' && iMaster == 1) ?
4522
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				 	oSettings.aiDisplayMaster : oSettings.aiDisplay;
4523
 
4524
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				for ( var i=0, iLen=aArray.length ; i<iLen ; i++ )
4525
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
4526
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					oSettings.asDataSearch[i] = _fnBuildSearchRow( oSettings,
4527
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>						_fnGetRowData( oSettings, aArray[i], 'filter' ) );
4528
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
4529
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4530
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
4531
 
4532
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
4533
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnBuildSearchRow
4534
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Create a searchable string from a single data row
4535
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  -
4536
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
4537
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           array:aData - Row data array to use for the data to search
4538
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
4539
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnBuildSearchRow( oSettings, aData )
4540
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
4541
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var sSearch = '';
4542
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof oSettings.__nTmpFilter == 'undefined' ) {
4543
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				oSettings.__nTmpFilter = document.createElement('div');
4544
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4545
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var nTmp = oSettings.__nTmpFilter;
4546
 
4547
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			for ( var j=0, jLen=oSettings.aoColumns.length ; j<jLen ; j++ )
4548
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4549
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				if ( oSettings.aoColumns[j].bSearchable )
4550
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				{
4551
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					var sData = aData[j];
4552
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>					sSearch += _fnDataToSearch( sData, oSettings.aoColumns[j].sType )+'  ';
4553
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				}
4554
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4555
 
4556
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			/* If it looks like there is an HTML entity in the string, attempt to decode it */
4557
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( sSearch.indexOf('&') !== -1 )
4558
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4559
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				nTmp.innerHTML = sSearch;
4560
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				sSearch = nTmp.textContent ? nTmp.textContent : nTmp.innerText;
4561
 
4562
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* IE and Opera appear to put an newline where there is a <br> tag - remove it */
4563
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				sSearch = sSearch.replace(/\n/g," ").replace(/\r/g,"");
4564
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4565
 
4566
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			return sSearch;
4567
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
4568
 
4569
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
4570
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnFilterCreateSearch
4571
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Build a regular expression object suitable for searching a table
4572
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  RegExp: - constructed object
4573
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   string:sSearch - string to search for
4574
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           bool:bRegex - treat as a regular expression or not
4575
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           bool:bSmart - perform smart filtering or not
4576
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
4577
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnFilterCreateSearch( sSearch, bRegex, bSmart )
4578
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
4579
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			var asSearch, sRegExpString;
4580
 
4581
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( bSmart )
4582
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4583
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				/* Generate the regular expression to use. Something along the lines of:
4584
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				 * ^(?=.*?\bone\b)(?=.*?\btwo\b)(?=.*?\bthree\b).*$
4585
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				 */
4586
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				asSearch = bRegex ? sSearch.split( ' ' ) : _fnEscapeRegex( sSearch ).split( ' ' );
4587
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				sRegExpString = '^(?=.*?'+asSearch.join( ')(?=.*?' )+').*$';
4588
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				return new RegExp( sRegExpString, "i" );
4589
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4590
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else
4591
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4592
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				sSearch = bRegex ? sSearch : _fnEscapeRegex( sSearch );
4593
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				return new RegExp( sSearch, "i" );
4594
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4595
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		}
4596
 
4597
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		/*
4598
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Function: _fnDataToSearch
4599
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Purpose:  Convert raw data into something that the user can search on
4600
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Returns:  string: - search string
4601
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 * Inputs:   string:sData - data to be modified
4602
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 *           string:sType - data type
4603
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		 */
4604
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		function _fnDataToSearch ( sData, sType )
4605
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>		{
4606
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			if ( typeof _oExt.ofnSearch[sType] == "function" )
4607
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4608
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				return _oExt.ofnSearch[sType]( sData );
4609
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			}
4610
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			else if ( sType == "html" )
4611
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>			{
4612
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?>				return sData.replace(/\n/g," ").replace( /<.*?>/g, "" );
4613
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
4614
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			else if ( typeof sData == "string" )
4615
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
4616
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				return sData.replace(/\n/g," ");
4617
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
4618
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			else if ( sData === null )
4619
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
4620
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				return '';
4621
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
4622
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			return sData;
4623
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
4624
 
4625
 
4626
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
4627
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Section - Feature: Sorting
4628
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
4629
 
4630
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
4631
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>	 	 * Function: _fnSort
4632
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Change the order of the table
4633
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  -
4634
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
4635
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           bool:bApplyClasses - optional - should we apply classes or not
4636
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Notes:    We always sort the master array and then apply a filter again
4637
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *   if it is needed. This probably isn't optimal - but atm I can't think
4638
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *   of any other way which is (each has disadvantages). we want to sort aiDisplayMaster - 
4639
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *   but according to aoData[]._aData
4640
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
4641
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnSort ( oSettings, bApplyClasses )
4642
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
4643
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var
4644
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				iDataSort, iDataType,
4645
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				i, iLen, j, jLen,
4646
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				aaSort = [],
4647
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 	aiOrig = [],
4648
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				oSort = _oExt.oSort,
4649
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				aoData = oSettings.aoData,
4650
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				aoColumns = oSettings.aoColumns;
4651
 
4652
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* No sorting required if server-side or no sorting array */
4653
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( !oSettings.oFeatures.bServerSide && 
4654
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				(oSettings.aaSorting.length !== 0 || oSettings.aaSortingFixed !== null) )
4655
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
4656
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( oSettings.aaSortingFixed !== null )
4657
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
4658
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					aaSort = oSettings.aaSortingFixed.concat( oSettings.aaSorting );
4659
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
4660
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				else
4661
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
4662
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					aaSort = oSettings.aaSorting.slice();
4663
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
4664
 
4665
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* If there is a sorting data type, and a fuction belonging to it, then we need to
4666
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * get the data from the developer's function and apply it for this column
4667
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 */
4668
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				for ( i=0 ; i<aaSort.length ; i++ )
4669
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
4670
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					var iColumn = aaSort[i][0];
4671
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					var iVisColumn = _fnColumnIndexToVisible( oSettings, iColumn );
4672
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					var sDataType = oSettings.aoColumns[ iColumn ].sSortDataType;
4673
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					if ( typeof _oExt.afnSortData[sDataType] != 'undefined' )
4674
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
4675
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						var aData = _oExt.afnSortData[sDataType]( oSettings, iColumn, iVisColumn );
4676
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						for ( j=0, jLen=aoData.length ; j<jLen ; j++ )
4677
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						{
4678
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							_fnSetCellData( oSettings, j, iColumn, aData[j] );
4679
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						}
4680
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}
4681
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
4682
 
4683
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Create a value - key array of the current row positions such that we can use their
4684
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * current position during the sort, if values match, in order to perform stable sorting
4685
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 */
4686
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				for ( i=0, iLen=oSettings.aiDisplayMaster.length ; i<iLen ; i++ )
4687
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
4688
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					aiOrig[ oSettings.aiDisplayMaster[i] ] = i;
4689
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
4690
 
4691
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Do the sort - here we want multi-column sorting based on a given data source (column)
4692
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * and sorting function (from oSort) in a certain direction. It's reasonably complex to
4693
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * follow on it's own, but this is what we want (example two column sorting):
4694
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 *  fnLocalSorting = function(a,b){
4695
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 *  	var iTest;
4696
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 *  	iTest = oSort['string-asc']('data11', 'data12');
4697
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 *  	if (iTest !== 0)
4698
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 *  		return iTest;
4699
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 *    iTest = oSort['numeric-desc']('data21', 'data22');
4700
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 *    if (iTest !== 0)
4701
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 *  		return iTest;
4702
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 *  	return oSort['numeric-asc']( aiOrig[a], aiOrig[b] );
4703
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 *  }
4704
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * Basically we have a test for each sorting column, if the data in that column is equal,
4705
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * test the next column. If all columns match, then we use a numeric sort on the row 
4706
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * positions in the original data array to provide a stable sort.
4707
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 */
4708
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				var iSortLen = aaSort.length;
4709
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				oSettings.aiDisplayMaster.sort( function ( a, b ) {
4710
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					var iTest, iDataSort, sDataType;
4711
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					for ( i=0 ; i<iSortLen ; i++ )
4712
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
4713
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						iDataSort = aoColumns[ aaSort[i][0] ].iDataSort;
4714
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						sDataType = aoColumns[ iDataSort ].sType;
4715
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						iTest = oSort[ (sDataType?sDataType:'string')+"-"+aaSort[i][1] ](
4716
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							_fnGetCellData( oSettings, a, iDataSort, 'sort' ),
4717
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							_fnGetCellData( oSettings, b, iDataSort, 'sort' )
4718
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						);
4719
 
4720
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						if ( iTest !== 0 )
4721
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						{
4722
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							return iTest;
4723
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						}
4724
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}
4725
 
4726
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					return oSort['numeric-asc']( aiOrig[a], aiOrig[b] );
4727
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				} );
4728
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
4729
 
4730
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Alter the sorting classes to take account of the changes */
4731
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( (typeof bApplyClasses == 'undefined' || bApplyClasses) && !oSettings.oFeatures.bDeferRender )
4732
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
4733
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnSortingClasses( oSettings );
4734
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
4735
 
4736
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Tell the draw function that we have sorted the data */
4737
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			oSettings.bSorted = true;
4738
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			$(oSettings.oInstance).trigger('sort', oSettings);
4739
 
4740
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Copy the master data into the draw array and re-draw */
4741
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( oSettings.oFeatures.bFilter )
4742
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
4743
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* _fnFilter() will redraw the table for us */
4744
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnFilterComplete( oSettings, oSettings.oPreviousSearch, 1 );
4745
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
4746
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			else
4747
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
4748
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
4749
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				oSettings._iDisplayStart = 0; /* reset display back to page 0 */
4750
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnCalculateEnd( oSettings );
4751
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnDraw( oSettings );
4752
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
4753
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
4754
 
4755
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
4756
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnSortAttachListener
4757
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Attach a sort handler (click) to a node
4758
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  -
4759
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
4760
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           node:nNode - node to attach the handler to
4761
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           int:iDataIndex - column sorting index
4762
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           function:fnCallback - callback function - optional
4763
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
4764
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnSortAttachListener ( oSettings, nNode, iDataIndex, fnCallback )
4765
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
4766
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			$(nNode).on( 'click.DT', function (e) {
4767
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* If the column is not sortable - don't to anything */
4768
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( oSettings.aoColumns[iDataIndex].bSortable === false )
4769
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
4770
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					return;
4771
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
4772
 
4773
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/*
4774
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * This is a little bit odd I admit... I declare a temporary function inside the scope of
4775
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * _fnBuildHead and the click handler in order that the code presented here can be used 
4776
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * twice - once for when bProcessing is enabled, and another time for when it is 
4777
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * disabled, as we need to perform slightly different actions.
4778
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 *   Basically the issue here is that the Javascript engine in modern browsers don't 
4779
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * appear to allow the rendering engine to update the display while it is still excuting
4780
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * it's thread (well - it does but only after long intervals). This means that the 
4781
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * 'processing' display doesn't appear for a table sort. To break the js thread up a bit
4782
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * I force an execution break by using setTimeout - but this breaks the expected 
4783
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * thread continuation for the end-developer's point of view (their code would execute
4784
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * too early), so we on;y do it when we absolutely have to.
4785
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 */
4786
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				var fnInnerSorting = function () {
4787
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					var iColumn, iNextSort;
4788
 
4789
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					/* If the shift key is pressed then we are multipe column sorting */
4790
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					if ( e.shiftKey )
4791
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
4792
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						/* Are we already doing some kind of sort on this column? */
4793
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						var bFound = false;
4794
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						for ( var i=0 ; i<oSettings.aaSorting.length ; i++ )
4795
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						{
4796
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							if ( oSettings.aaSorting[i][0] == iDataIndex )
4797
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							{
4798
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>								bFound = true;
4799
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>								iColumn = oSettings.aaSorting[i][0];
4800
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>								iNextSort = oSettings.aaSorting[i][2]+1;
4801
 
4802
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>								if ( typeof oSettings.aoColumns[iColumn].asSorting[iNextSort] == 'undefined' )
4803
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>								{
4804
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>									/* Reached the end of the sorting options, remove from multi-col sort */
4805
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>									oSettings.aaSorting.splice( i, 1 );
4806
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>								}
4807
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>								else
4808
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>								{
4809
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>									/* Move onto next sorting direction */
4810
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>									oSettings.aaSorting[i][1] = oSettings.aoColumns[iColumn].asSorting[iNextSort];
4811
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>									oSettings.aaSorting[i][2] = iNextSort;
4812
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>								}
4813
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>								break;
4814
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							}
4815
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						}
4816
 
4817
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						/* No sort yet - add it in */
4818
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						if ( bFound === false )
4819
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						{
4820
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							oSettings.aaSorting.push( [ iDataIndex, 
4821
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>								oSettings.aoColumns[iDataIndex].asSorting[0], 0 ] );
4822
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						}
4823
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}
4824
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					else
4825
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
4826
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						/* If no shift key then single column sort */
4827
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						if ( oSettings.aaSorting.length == 1 && oSettings.aaSorting[0][0] == iDataIndex )
4828
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						{
4829
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							iColumn = oSettings.aaSorting[0][0];
4830
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							iNextSort = oSettings.aaSorting[0][2]+1;
4831
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							if ( typeof oSettings.aoColumns[iColumn].asSorting[iNextSort] == 'undefined' )
4832
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							{
4833
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>								iNextSort = 0;
4834
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							}
4835
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							oSettings.aaSorting[0][1] = oSettings.aoColumns[iColumn].asSorting[iNextSort];
4836
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							oSettings.aaSorting[0][2] = iNextSort;
4837
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						}
4838
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						else
4839
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						{
4840
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							oSettings.aaSorting.splice( 0, oSettings.aaSorting.length );
4841
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							oSettings.aaSorting.push( [ iDataIndex, 
4842
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>								oSettings.aoColumns[iDataIndex].asSorting[0], 0 ] );
4843
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						}
4844
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}
4845
 
4846
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					/* Run the sort */
4847
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					_fnSort( oSettings );
4848
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}; /* /fnInnerSorting */
4849
 
4850
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( !oSettings.oFeatures.bProcessing )
4851
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
4852
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					fnInnerSorting();
4853
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
4854
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				else
4855
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
4856
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					_fnProcessingDisplay( oSettings, true );
4857
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					setTimeout( function() {
4858
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						fnInnerSorting();
4859
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						if ( !oSettings.oFeatures.bServerSide )
4860
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						{
4861
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							_fnProcessingDisplay( oSettings, false );
4862
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						}
4863
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}, 0 );
4864
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
4865
 
4866
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Call the user specified callback function - used for async user interaction */
4867
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( typeof fnCallback == 'function' )
4868
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
4869
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					fnCallback( oSettings );
4870
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
4871
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			} );
4872
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
4873
 
4874
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
4875
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnSortingClasses
4876
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Set the sortting classes on the header
4877
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  -
4878
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
4879
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Notes:    It is safe to call this function when bSort and bSortClasses are false
4880
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
4881
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnSortingClasses( oSettings )
4882
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
4883
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var i, iLen, j, jLen, iFound;
4884
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var aaSort, sClass;
4885
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var iColumns = oSettings.aoColumns.length;
4886
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var oClasses = oSettings.oClasses;
4887
 
4888
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			for ( i=0 ; i<iColumns ; i++ )
4889
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
4890
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( oSettings.aoColumns[i].bSortable )
4891
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
4892
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					$(oSettings.aoColumns[i].nTh).removeClass( oClasses.sSortAsc +" "+ oClasses.sSortDesc +
4893
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						" "+ oSettings.aoColumns[i].sSortingClass );
4894
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
4895
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
4896
 
4897
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( oSettings.aaSortingFixed !== null )
4898
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
4899
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				aaSort = oSettings.aaSortingFixed.concat( oSettings.aaSorting );
4900
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
4901
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			else
4902
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
4903
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				aaSort = oSettings.aaSorting.slice();
4904
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
4905
 
4906
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Apply the required classes to the header */
4907
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			for ( i=0 ; i<oSettings.aoColumns.length ; i++ )
4908
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
4909
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( oSettings.aoColumns[i].bSortable )
4910
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
4911
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					sClass = oSettings.aoColumns[i].sSortingClass;
4912
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					iFound = -1;
4913
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					for ( j=0 ; j<aaSort.length ; j++ )
4914
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
4915
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						if ( aaSort[j][0] == i )
4916
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						{
4917
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							sClass = ( aaSort[j][1] == "asc" ) ?
4918
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>								oClasses.sSortAsc : oClasses.sSortDesc;
4919
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							iFound = j;
4920
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							break;
4921
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						}
4922
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}
4923
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					$(oSettings.aoColumns[i].nTh).addClass( sClass );
4924
 
4925
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					if ( oSettings.bJUI )
4926
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
4927
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						/* jQuery UI uses extra markup */
4928
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						var jqSpan = $("span", oSettings.aoColumns[i].nTh);
4929
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						jqSpan.removeClass(oClasses.sSortJUIAsc +" "+ oClasses.sSortJUIDesc +" "+ 
4930
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							oClasses.sSortJUI +" "+ oClasses.sSortJUIAscAllowed +" "+ oClasses.sSortJUIDescAllowed );
4931
 
4932
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						var sSpanClass;
4933
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						if ( iFound == -1 )
4934
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						{
4935
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						 	sSpanClass = oSettings.aoColumns[i].sSortingClassJUI;
4936
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						}
4937
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						else if ( aaSort[iFound][1] == "asc" )
4938
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						{
4939
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							sSpanClass = oClasses.sSortJUIAsc;
4940
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						}
4941
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						else
4942
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						{
4943
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							sSpanClass = oClasses.sSortJUIDesc;
4944
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						}
4945
 
4946
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						jqSpan.addClass( sSpanClass );
4947
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}
4948
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
4949
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				else
4950
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
4951
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					/* No sorting on this column, so add the base class. This will have been assigned by
4952
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					 * _fnAddColumn
4953
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					 */
4954
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					$(oSettings.aoColumns[i].nTh).addClass( oSettings.aoColumns[i].sSortingClass );
4955
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
4956
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
4957
 
4958
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* 
4959
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * Apply the required classes to the table body
4960
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * Note that this is given as a feature switch since it can significantly slow down a sort
4961
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * on large data sets (adding and removing of classes is always slow at the best of times..)
4962
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * Further to this, note that this code is admitadly fairly ugly. It could be made a lot 
4963
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * simpiler using jQuery selectors and add/removeClass, but that is significantly slower
4964
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * (on the order of 5 times slower) - hence the direct DOM manipulation here.
4965
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * Note that for defered drawing we do use jQuery - the reason being that taking the first
4966
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * row found to see if the whole column needs processed can miss classes since the first
4967
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * column might be new.
4968
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 */
4969
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			sClass = oClasses.sSortColumn;
4970
 
4971
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( oSettings.oFeatures.bSort && oSettings.oFeatures.bSortClasses )
4972
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
4973
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				var nTds = _fnGetTdNodes( oSettings );
4974
 
4975
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Remove the old classes */
4976
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( oSettings.oFeatures.bDeferRender )
4977
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
4978
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					$(nTds).removeClass(sClass+'1 '+sClass+'2 '+sClass+'3');
4979
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
4980
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				else if ( nTds.length >= iColumns )
4981
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
4982
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					for ( i=0 ; i<iColumns ; i++ )
4983
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
4984
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						if ( nTds[i].className.indexOf(sClass+"1") != -1 )
4985
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						{
4986
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							for ( j=0, jLen=(nTds.length/iColumns) ; j
4987
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
4988
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
4989
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
4990
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
4991
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
4992
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
4993
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
4994
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>iColumns) ; j<jLen ; j++ )
4995
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
4996
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
4997
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>"2", "" ) );
4998
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
4999
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5000
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>else if ( nTds[i].className.indexOf(sClass+"3") != -1 )
5001
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5002
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>for ( j=0, jLen=(nTds.length/iColumns) ; j
5003
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5004
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5005
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5006
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5007
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5008
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5009
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5010
 
5011
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>* Add the new classes to the table */
5012
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				var iClass = 1, iTargetCol;
5013
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				for ( i=0 ; i
5014
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5015
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5016
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>iColumns) ; j<jLen ; j++ )
5017
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5018
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>" "+sClass+iClass;
5019
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5020
 
5021
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( iClass < 3 )
5022
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5023
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5024
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5025
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5026
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5027
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5028
 
5029
 
5030
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
5031
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Section - Feature: Pagination. Note that most of the paging logic is done in 
5032
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * _oExt.oPagination
5033
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
5034
 
5035
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/*
5036
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnFeatureHtmlPaginate
5037
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Generate the node required for default pagination
5038
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  node
5039
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
5040
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
5041
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>function _fnFeatureHtmlPaginate ( oSettings )
5042
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5043
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings.oScroll.bInfinite )
5044
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5045
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>return null;
5046
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5047
 
5048
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var nPaginate = document.createElement( 'div' );
5049
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5050
 
5051
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5052
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>function( oSettings ) {
5053
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5054
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5055
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5056
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5057
 
5058
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/* Add a draw callback for the pagination on first instance, to update the paging display */
5059
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( typeof oSettings.aanFeatures.p == "undefined" )
5060
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5061
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5062
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>"fn": function( oSettings ) {
5063
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>function( oSettings ) {
5064
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5065
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5066
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5067
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5068
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>"sName": "pagination"
5069
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5070
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5071
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>return nPaginate;
5072
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5073
 
5074
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/*
5075
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnPageChange
5076
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Alter the display settings to change the page
5077
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  bool:true - page has changed, false - no change (no effect) eg 'first' on page 1
5078
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
5079
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           string:sAction - paging action to take: "first", "previous", "next" or "last"
5080
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
5081
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>function _fnPageChange ( oSettings, sAction )
5082
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5083
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var iOldStart = oSettings._iDisplayStart;
5084
 
5085
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( sAction == "first" )
5086
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5087
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5088
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5089
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>else if ( sAction == "previous" )
5090
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5091
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5092
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5093
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5094
 
5095
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/* Correct for underrun */
5096
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings._iDisplayStart < 0 )
5097
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5098
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5099
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5100
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5101
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>else if ( sAction == "next" )
5102
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5103
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings._iDisplayLength >= 0 )
5104
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5105
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/* Make sure we are not over running the display array */
5106
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings._iDisplayStart + oSettings._iDisplayLength < oSettings.fnRecordsDisplay() )
5107
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5108
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5109
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5110
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5111
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>else
5112
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5113
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5114
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5115
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5116
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>else if ( sAction == "last" )
5117
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5118
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings._iDisplayLength >= 0 )
5119
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5120
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var iPages = parseInt( (oSettings.fnRecordsDisplay()-1) / oSettings._iDisplayLength, 10 ) + 1;
5121
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings._iDisplayStart = (iPages-1) * oSettings._iDisplayLength;
5122
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
5123
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				else
5124
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
5125
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings._iDisplayStart = 0;
5126
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
5127
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
5128
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			else
5129
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
5130
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnLog( oSettings, 0, "Unknown paging action: "+sAction );
5131
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
5132
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			$(oSettings.oInstance).trigger('page', oSettings);
5133
 
5134
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			return iOldStart != oSettings._iDisplayStart;
5135
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
5136
 
5137
 
5138
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
5139
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5140
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/
5141
 
5142
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
5143
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5144
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>for the info display
5145
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5146
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5147
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/
5148
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnFeatureHtmlInfo ( oSettings )
5149
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
5150
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var nInfo = document.createElement( 'div' );
5151
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			nInfo.className = oSettings.oClasses.sInfo;
5152
 
5153
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Actions that are to be taken once only for this feature */
5154
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( typeof oSettings.aanFeatures.i == "undefined" )
5155
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
5156
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Add draw callback */
5157
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				oSettings.aoDrawCallback.push( {
5158
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					"fn": _fnUpdateInfo,
5159
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					"sName": "information"
5160
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				} );
5161
 
5162
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Add id */
5163
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( oSettings.sTableId !== '' )
5164
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
5165
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					nInfo.setAttribute( 'id', oSettings.sTableId+'_info' );
5166
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
5167
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
5168
 
5169
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			return nInfo;
5170
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
5171
 
5172
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
5173
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5174
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>in the display
5175
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5176
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5177
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/
5178
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnUpdateInfo ( oSettings )
5179
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
5180
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Show information about the table */
5181
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( !oSettings.oFeatures.bInfo || oSettings.aanFeatures.i.length === 0 )
5182
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
5183
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				return;
5184
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
5185
 
5186
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var
5187
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				iStart = oSettings._iDisplayStart+1, iEnd = oSettings.fnDisplayEnd(),
5188
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				iMax = oSettings.fnRecordsTotal(), iTotal = oSettings.fnRecordsDisplay(),
5189
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				sStart = oSettings.fnFormatNumber( iStart ), sEnd = oSettings.fnFormatNumber( iEnd ),
5190
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				sMax = oSettings.fnFormatNumber( iMax ), sTotal = oSettings.fnFormatNumber( iTotal ),
5191
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				sOut;
5192
 
5193
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* When infinite scrolling, we are always starting at 1. _iDisplayStart is used only
5194
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5195
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/
5196
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( oSettings.oScroll.bInfinite )
5197
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
5198
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				sStart = oSettings.fnFormatNumber( 1 );
5199
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
5200
 
5201
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( oSettings.fnRecordsDisplay() === 0 && 
5202
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				   oSettings.fnRecordsDisplay() == oSettings.fnRecordsTotal() )
5203
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
5204
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Empty record set */
5205
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				sOut = oSettings.oLanguage.sInfoEmpty+ oSettings.oLanguage.sInfoPostFix;
5206
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
5207
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			else if ( oSettings.fnRecordsDisplay() === 0 )
5208
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
5209
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Rmpty record set after filtering */
5210
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				sOut = oSettings.oLanguage.sInfoEmpty +' '+ 
5211
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings.oLanguage.sInfoFiltered.replace('_MAX_', sMax)+
5212
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						oSettings.oLanguage.sInfoPostFix;
5213
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
5214
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			else if ( oSettings.fnRecordsDisplay() == oSettings.fnRecordsTotal() )
5215
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
5216
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Normal record set */
5217
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				sOut = oSettings.oLanguage.sInfo.
5218
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						replace('_START_', sStart).
5219
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						replace('_END_',   sEnd).
5220
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						replace('_TOTAL_', sTotal)+ 
5221
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings.oLanguage.sInfoPostFix;
5222
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
5223
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			else
5224
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
5225
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Record set after filtering */
5226
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				sOut = oSettings.oLanguage.sInfo.
5227
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						replace('_START_', sStart).
5228
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						replace('_END_',   sEnd).
5229
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						replace('_TOTAL_', sTotal) +' '+ 
5230
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings.oLanguage.sInfoFiltered.replace('_MAX_', 
5231
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						oSettings.fnFormatNumber(oSettings.fnRecordsTotal()))+ 
5232
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings.oLanguage.sInfoPostFix;
5233
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
5234
 
5235
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( oSettings.oLanguage.fnInfoCallback !== null )
5236
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
5237
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				sOut = oSettings.oLanguage.fnInfoCallback( oSettings, iStart, iEnd, iMax, iTotal, sOut );
5238
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
5239
 
5240
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var n = oSettings.aanFeatures.i;
5241
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			for ( var i=0, iLen=n.length ; i
5242
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5243
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5244
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5245
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5246
 
5247
 
5248
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
5249
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5250
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/
5251
 
5252
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
5253
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5254
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>for user display length changing
5255
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5256
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5257
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/
5258
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnFeatureHtmlLength ( oSettings )
5259
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
5260
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( oSettings.oScroll.bInfinite )
5261
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
5262
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				return null;
5263
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
5264
 
5265
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* This can be overruled by not using the _MENU_ var/macro in the language variable */
5266
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var sName = (oSettings.sTableId === "") ? "" : 'name="'+oSettings.sTableId+'_length"';
5267
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var sStdMenu = '<select size="1" '+sName+'>';
5268
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var i, iLen;
5269
 
5270
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings.aLengthMenu.length == 2 && typeof oSettings.aLengthMenu[0] == 'object' && 
5271
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>'object' )
5272
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5273
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>for ( i=0, iLen=oSettings.aLengthMenu[0].length ; i<iLen ; i++ )
5274
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5275
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>'<option value="'+oSettings.aLengthMenu[0][i]+'">'+
5276
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>'</option>';
5277
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5278
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5279
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>else
5280
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5281
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>for ( i=0, iLen=oSettings.aLengthMenu.length ; i<iLen ; i++ )
5282
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5283
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>'<option value="'+oSettings.aLengthMenu[i]+'">'+
5284
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>'</option>';
5285
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5286
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5287
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>'</select>';
5288
 
5289
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var nLength = document.createElement( 'div' );
5290
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings.sTableId !== '' && typeof oSettings.aanFeatures.l == "undefined" )
5291
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5292
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>'id', oSettings.sTableId+'_length' );
5293
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5294
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5295
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>'<label>'+oSettings.oLanguage.sLengthMenu.replace( '_MENU_', sStdMenu )+'</label>';
5296
 
5297
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/*
5298
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * Set the length to the current display length - thanks to Andrea Pavlovic for this fix,
5299
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * and Stefan Skopnik for fixing the fix!
5300
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 */
5301
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>'select option[value="'+oSettings._iDisplayLength+'"]',nLength).attr("selected",true);
5302
 
5303
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>'select', nLength).on( 'change.DT', function(e) {
5304
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var iVal = $(this).val();
5305
 
5306
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/* Update all other length options for the new display */
5307
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var n = oSettings.aanFeatures.l;
5308
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>for ( i=0, iLen=n.length ; i<iLen ; i++ )
5309
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5310
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( n[i] != this.parentNode )
5311
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5312
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>'select', n[i]).val( iVal );
5313
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5314
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5315
 
5316
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/* Redraw the table */
5317
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>parseInt(iVal, 10);
5318
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5319
 
5320
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/* If we have space to show extra rows (backing up from the end point - then do so */
5321
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings.fnDisplayEnd() == oSettings.fnRecordsDisplay() )
5322
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5323
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5324
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings._iDisplayStart < 0 )
5325
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5326
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5327
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5328
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5329
 
5330
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings._iDisplayLength == -1 )
5331
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5332
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5333
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5334
 
5335
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5336
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5337
 
5338
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>return nLength;
5339
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5340
 
5341
 
5342
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
5343
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Section - Feature: Processing incidator
5344
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
5345
 
5346
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/*
5347
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnFeatureHtmlProcessing
5348
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Generate the node required for the processing node
5349
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  node
5350
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
5351
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
5352
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>function _fnFeatureHtmlProcessing ( oSettings )
5353
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5354
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var nProcessing = document.createElement( 'div' );
5355
 
5356
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings.sTableId !== '' && typeof oSettings.aanFeatures.r == "undefined" )
5357
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5358
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>'id', oSettings.sTableId+'_processing' );
5359
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5360
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5361
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5362
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5363
 
5364
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>return nProcessing;
5365
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5366
 
5367
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/*
5368
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnProcessingDisplay
5369
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Display or hide the processing indicator
5370
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  -
5371
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
5372
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           bool:
5373
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *   true - show the processing indicator
5374
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *   false - don't show
5375
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
5376
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>function _fnProcessingDisplay ( oSettings, bShow )
5377
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5378
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings.oFeatures.bProcessing )
5379
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5380
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var an = oSettings.aanFeatures.r;
5381
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>for ( var i=0, iLen=an.length ; i<iLen ; i++ )
5382
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5383
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>"visible" : "hidden";
5384
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5385
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5386
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5387
 
5388
 
5389
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
5390
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Section - Support functions
5391
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
5392
 
5393
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/*
5394
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnVisibleToColumnIndex
5395
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Covert the index of a visible column to the index in the data array (take account
5396
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *   of hidden columns)
5397
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  int:i - the data index
5398
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
5399
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
5400
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>function _fnVisibleToColumnIndex( oSettings, iMatch )
5401
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5402
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var iColumn = -1;
5403
 
5404
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>for ( var i=0 ; i<oSettings.aoColumns.length ; i++ )
5405
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5406
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings.aoColumns[i].bVisible === true )
5407
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5408
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5409
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5410
 
5411
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( iColumn == iMatch )
5412
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5413
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>return i;
5414
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5415
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5416
 
5417
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>return null;
5418
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5419
 
5420
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/*
5421
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnColumnIndexToVisible
5422
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Covert the index of an index in the data array and convert it to the visible
5423
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *   column index (take account of hidden columns)
5424
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  int:i - the data index
5425
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
5426
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
5427
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>function _fnColumnIndexToVisible( oSettings, iMatch )
5428
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5429
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var iVisible = -1;
5430
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>for ( var i=0 ; i<oSettings.aoColumns.length ; i++ )
5431
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5432
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings.aoColumns[i].bVisible === true )
5433
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5434
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5435
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5436
 
5437
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( i == iMatch )
5438
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5439
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>return oSettings.aoColumns[i].bVisible === true ? iVisible : null;
5440
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5441
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5442
 
5443
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>return null;
5444
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5445
 
5446
 
5447
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/*
5448
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnNodeToDataIndex
5449
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Take a TR element and convert it to an index in aoData
5450
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  int:i - index if found, null if not
5451
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:s - dataTables settings object
5452
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           node:n - the TR element to find
5453
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
5454
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>function _fnNodeToDataIndex( s, n )
5455
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5456
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var i, iLen;
5457
 
5458
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/* Optimisation - see if the nodes which are currently visible match, since that is
5459
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * the most likely node to be asked for (a selector or event for example)
5460
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 */
5461
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>for ( i=s._iDisplayStart, iLen=s._iDisplayEnd ; i<iLen ; i++ )
5462
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5463
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( s.aoData[ s.aiDisplay[i] ].nTr == n )
5464
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5465
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>return s.aiDisplay[i];
5466
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5467
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5468
 
5469
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/* Otherwise we are in for a slog through the whole data cache */
5470
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>for ( i=0, iLen=s.aoData.length ; i<iLen ; i++ )
5471
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5472
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( s.aoData[i].nTr == n )
5473
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5474
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>return i;
5475
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5476
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5477
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>return null;
5478
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5479
 
5480
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/*
5481
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnVisbleColumns
5482
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Get the number of visible columns
5483
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  int:i - the number of visible columns
5484
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oS - dataTables settings object
5485
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
5486
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>function _fnVisbleColumns( oS )
5487
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5488
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var iVis = 0;
5489
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>for ( var i=0 ; i<oS.aoColumns.length ; i++ )
5490
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5491
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oS.aoColumns[i].bVisible === true )
5492
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5493
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5494
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5495
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5496
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>return iVis;
5497
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5498
 
5499
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/*
5500
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnCalculateEnd
5501
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Rcalculate the end point based on the start point
5502
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  -
5503
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
5504
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
5505
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>function _fnCalculateEnd( oSettings )
5506
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5507
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings.oFeatures.bPaginate === false )
5508
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5509
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5510
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5511
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>else
5512
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5513
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/* Set the end point of the display - based on how many elements there are
5514
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * still to display
5515
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 */
5516
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings._iDisplayStart + oSettings._iDisplayLength > oSettings.aiDisplay.length ||
5517
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5518
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5519
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5520
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5521
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>else
5522
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5523
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5524
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5525
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5526
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5527
 
5528
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/*
5529
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnConvertToWidth
5530
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Convert a CSS unit width to pixels (e.g. 2em)
5531
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  int:iWidth - width in pixels
5532
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   string:sWidth - width to be converted
5533
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           node:nParent - parent to get the with for (required for
5534
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *             relative widths) - optional
5535
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
5536
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>function _fnConvertToWidth ( sWidth, nParent )
5537
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5538
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( !sWidth || sWidth === null || sWidth === '' )
5539
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5540
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>return 0;
5541
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5542
 
5543
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( typeof nParent == "undefined" )
5544
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5545
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>'body')[0];
5546
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5547
 
5548
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var iWidth;
5549
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var nTmp = document.createElement( "div" );
5550
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5551
 
5552
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5553
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5554
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5555
 
5556
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>return ( iWidth );
5557
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5558
 
5559
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/*
5560
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnCalculateColumnWidths
5561
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Calculate the width of columns for the table
5562
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  -
5563
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
5564
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
5565
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>function _fnCalculateColumnWidths ( oSettings )
5566
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5567
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var iTableWidth = oSettings.nTable.offsetWidth;
5568
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var iUserInputs = 0;
5569
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var iTmpWidth;
5570
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var iVisibleColumns = 0;
5571
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var iColums = oSettings.aoColumns.length;
5572
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var i, iIndex, iCorrector, iWidth;
5573
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var oHeaders = $('th', oSettings.nTHead);
5574
 
5575
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/* Convert any user input sizes into pixel sizes */
5576
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>for ( i=0 ; i<iColums ; i++ )
5577
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5578
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings.aoColumns[i].bVisible )
5579
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5580
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5581
 
5582
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings.aoColumns[i].sWidth !== null )
5583
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5584
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5585
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5586
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( iTmpWidth !== null )
5587
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5588
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5589
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5590
 
5591
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5592
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5593
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5594
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5595
 
5596
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/* If the number of columns in the DOM equals the number that we have to process in 
5597
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * DataTables, then we can use the offsets that are created by the web-browser. No custom 
5598
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * sizes can be set in order for this to happen, nor scrolling used
5599
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 */
5600
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( iColums == oHeaders.length && iUserInputs === 0 && iVisibleColumns == iColums &&
5601
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>"" && oSettings.oScroll.sY === "" )
5602
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5603
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>for ( i=0 ; i<oSettings.aoColumns.length ; i++ )
5604
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5605
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5606
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( iTmpWidth !== null )
5607
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5608
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5609
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5610
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5611
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5612
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>else
5613
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5614
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/* Otherwise we are going to have to do some calculations to get the width of each column.
5615
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * Construct a 1 row table with the widest node in the data, and any user defined widths,
5616
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * then insert it into the DOM and allow the browser to do all the hard work of
5617
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * calculating table widths.
5618
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 */
5619
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var
5620
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>false ),
5621
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>true),
5622
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>'tbody' ),
5623
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>'tr' ),
5624
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5625
 
5626
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>"id" );
5627
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5628
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings.nTFoot !== null )
5629
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5630
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>true) );
5631
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>function(n) {
5632
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>"";
5633
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>'tr') );
5634
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5635
 
5636
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5637
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5638
 
5639
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/* Remove any sizing that was previously applied by the styles */
5640
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var jqColSizing = $('thead th', nCalcTmp);
5641
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( jqColSizing.length === 0 )
5642
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5643
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>'tbody tr:eq(0)>td', nCalcTmp);
5644
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5645
 
5646
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/* Apply custom sizing to the cloned header */
5647
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var nThs = _fnGetUniqueThs( oSettings, nTheadClone );
5648
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5649
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>for ( i=0 ; i<iColums ; i++ )
5650
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5651
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var oColumn = oSettings.aoColumns[i];
5652
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oColumn.bVisible && oColumn.sWidthOrig !== null && oColumn.sWidthOrig !== "" )
5653
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5654
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5655
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5656
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>else if ( oColumn.bVisible )
5657
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5658
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>"";
5659
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5660
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>else
5661
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5662
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5663
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5664
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5665
 
5666
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/* Find the biggest td for each column and put it into the table */
5667
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>for ( i=0 ; i<iColums ; i++ )
5668
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5669
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings.aoColumns[i].bVisible )
5670
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5671
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var nTd = _fnGetWidestNode( oSettings, i );
5672
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( nTd !== null )
5673
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5674
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>true);
5675
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings.aoColumns[i].sContentPadding !== "" )
5676
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5677
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5678
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5679
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5680
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5681
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5682
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5683
 
5684
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/* Build the table and 'display' it */
5685
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var nWrapper = oSettings.nTable.parentNode;
5686
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5687
 
5688
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/* When scrolling (X or Y) we want to set the width of the table as appropriate. However,
5689
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * when not scrolling leave the table width as it is. This results in slightly different,
5690
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * but I think correct behaviour
5691
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 */
5692
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings.oScroll.sX !== "" && oSettings.oScroll.sXInner !== "" )
5693
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5694
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5695
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5696
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>else if ( oSettings.oScroll.sX !== "" )
5697
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5698
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>"";
5699
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( $(nCalcTmp).width() < nWrapper.offsetWidth )
5700
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5701
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5702
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5703
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5704
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>else if ( oSettings.oScroll.sY !== "" )
5705
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5706
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5707
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5708
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>"hidden";
5709
 
5710
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/* Scrolling considerations */
5711
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5712
 
5713
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/* Read the width's calculated by the browser and store them for use by the caller. We
5714
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * first of all try to use the elements in the body, but it is possible that there are
5715
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * no elements there, under which circumstances we use the header elements
5716
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 */
5717
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var oNodes = $("tbody tr:eq(0)", nCalcTmp).children();
5718
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oNodes.length === 0 )
5719
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5720
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>'thead', nCalcTmp)[0] );
5721
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5722
 
5723
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/* Browsers need a bit of a hand when a width is assigned to any columns when 
5724
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * x-scrolling as they tend to collapse the table to the min-width, even if
5725
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * we sent the column widths. So we need to keep track of what the table width
5726
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * should be by summing the user given values, and the automatic values
5727
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 */
5728
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings.oScroll.sX !== "" )
5729
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5730
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var iTotal = 0;
5731
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5732
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>for ( i=0 ; i<oSettings.aoColumns.length ; i++ )
5733
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5734
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings.aoColumns[i].bVisible )
5735
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5736
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings.aoColumns[i].sWidthOrig === null )
5737
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5738
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5739
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5740
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>else
5741
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5742
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>parseInt(oSettings.aoColumns[i].sWidth.replace('px',''), 10) +
5743
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5744
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5745
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5746
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5747
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5748
 
5749
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5750
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5751
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5752
 
5753
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5754
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>for ( i=0 ; i<oSettings.aoColumns.length ; i++ )
5755
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5756
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings.aoColumns[i].bVisible )
5757
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5758
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5759
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( iWidth !== null && iWidth > 0 )
5760
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5761
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5762
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5763
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5764
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5765
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5766
 
5767
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5768
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5769
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5770
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5771
 
5772
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/*
5773
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnScrollingWidthAdjust
5774
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Adjust a table's width to take account of scrolling
5775
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  -
5776
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
5777
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           node:n - table node
5778
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
5779
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>function _fnScrollingWidthAdjust ( oSettings, n )
5780
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5781
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings.oScroll.sX === "" && oSettings.oScroll.sY !== "" )
5782
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5783
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/* When y-scrolling only, we want to remove the width of the scroll bar so the table
5784
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * + scroll bar will fit into the area avaialble.
5785
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 */
5786
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var iOrigWidth = $(n).width();
5787
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5788
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5789
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>else if ( oSettings.oScroll.sX !== "" )
5790
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5791
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/* When x-scrolling both ways, fix the table at it's current size, without adjusting */
5792
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5793
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5794
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5795
 
5796
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/*
5797
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnGetWidestNode
5798
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Get the widest node
5799
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  string: - max strlens for each column
5800
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
5801
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           int:iCol - column of interest
5802
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
5803
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>function _fnGetWidestNode( oSettings, iCol )
5804
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5805
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var iMaxIndex = _fnGetMaxLenString( oSettings, iCol );
5806
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( iMaxIndex < 0 )
5807
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5808
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>return null;
5809
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5810
 
5811
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>if ( oSettings.aoData[iMaxIndex].nTr === null )
5812
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5813
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var n = document.createElement('td');
5814
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>'' );
5815
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>return n;
5816
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5817
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>return _fnGetTdNodes(oSettings, iMaxIndex)[iCol];
5818
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5819
 
5820
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/*
5821
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnGetMaxLenString
5822
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Get the maximum strlen for each data column
5823
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  string: - max strlens for each column
5824
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
5825
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           int:iCol - column of interest
5826
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
5827
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>function _fnGetMaxLenString( oSettings, iCol )
5828
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5829
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var iMax = -1;
5830
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var iMaxIndex = -1;
5831
 
5832
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>for ( var i=0 ; i<oSettings.aoData.length ; i++ )
5833
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>
5834
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>var s = _fnGetCellData( oSettings, i, iCol, 'display' )+"";
5835
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>/<.*?>/g, "" );
5836
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( s.length > iMax )
5837
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
5838
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					iMax = s.length;
5839
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					iMaxIndex = i;
5840
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
5841
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
5842
 
5843
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			return iMaxIndex;
5844
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
5845
 
5846
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
5847
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnStringToCss
5848
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Append a CSS unit (only if required) to a string
5849
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  0 if match, 1 if length is different, 2 if no match
5850
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   array:aArray1 - first array
5851
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           array:aArray2 - second array
5852
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
5853
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnStringToCss( s )
5854
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
5855
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( s === null )
5856
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
5857
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				return "0px";
5858
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
5859
 
5860
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( typeof s == 'number' )
5861
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
5862
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( s < 0 )
5863
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
5864
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					return "0px";
5865
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
5866
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				return s+"px";
5867
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
5868
 
5869
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Check if the last character is not 0-9 */
5870
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var c = s.charCodeAt( s.length-1 );
5871
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if (c < 0x30 || c > 0x39)
5872
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
5873
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				return s;
5874
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
5875
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			return s+"px";
5876
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
5877
 
5878
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
5879
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnArrayCmp
5880
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Compare two arrays
5881
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  0 if match, 1 if length is different, 2 if no match
5882
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   array:aArray1 - first array
5883
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           array:aArray2 - second array
5884
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
5885
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnArrayCmp( aArray1, aArray2 )
5886
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
5887
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( aArray1.length != aArray2.length )
5888
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
5889
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				return 1;
5890
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
5891
 
5892
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			for ( var i=0 ; i<aArray1.length ; i++ )
5893
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
5894
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( aArray1[i] != aArray2[i] )
5895
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
5896
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					return 2;
5897
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
5898
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
5899
 
5900
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			return 0;
5901
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
5902
 
5903
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
5904
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnDetectType
5905
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Get the sort type based on an input string
5906
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  string: - type (defaults to 'string' if no type can be detected)
5907
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   string:sData - data we wish to know the type of
5908
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Notes:    This function makes use of the DataTables plugin objct _oExt 
5909
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *   (.aTypes) such that new types can easily be added.
5910
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
5911
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnDetectType( sData )
5912
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
5913
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var aTypes = _oExt.aTypes;
5914
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var iLen = aTypes.length;
5915
 
5916
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			for ( var i=0 ; i<iLen ; i++ )
5917
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
5918
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				var sType = aTypes[i]( sData );
5919
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( sType !== null )
5920
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
5921
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					return sType;
5922
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
5923
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
5924
 
5925
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			return 'string';
5926
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
5927
 
5928
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
5929
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnSettingsFromNode
5930
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Return the settings object for a particular table
5931
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  object: Settings object - or null if not found
5932
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   node:nTable - table we are using as a dataTable
5933
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
5934
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnSettingsFromNode ( nTable )
5935
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
5936
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			for ( var i=0 ; i<_aoSettings.length ; i++ )
5937
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
5938
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( _aoSettings[i].nTable == nTable )
5939
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
5940
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					return _aoSettings[i];
5941
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
5942
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
5943
 
5944
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			return null;
5945
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
5946
 
5947
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
5948
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnGetDataMaster
5949
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Return an array with the full table data
5950
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  array array:aData - Master data array
5951
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
5952
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
5953
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnGetDataMaster ( oSettings )
5954
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
5955
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var aData = [];
5956
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var iLen = oSettings.aoData.length;
5957
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			for ( var i=0 ; i<iLen; i++ )
5958
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
5959
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				aData.push( oSettings.aoData[i]._aData );
5960
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
5961
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			return aData;
5962
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
5963
 
5964
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
5965
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnGetTrNodes
5966
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Return an array with the TR nodes for the table
5967
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  array: - TR array
5968
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
5969
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
5970
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnGetTrNodes ( oSettings )
5971
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
5972
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var aNodes = [];
5973
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			for ( var i=0, iLen=oSettings.aoData.length ; i<iLen ; i++ )
5974
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
5975
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( oSettings.aoData[i].nTr !== null )
5976
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
5977
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					aNodes.push( oSettings.aoData[i].nTr );
5978
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
5979
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
5980
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			return aNodes;
5981
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
5982
 
5983
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
5984
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnGetTdNodes
5985
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Return an flat array with all TD nodes for the table, or row
5986
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  array: - TD array
5987
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
5988
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           int:iIndividualRow - aoData index to get the nodes for - optional if not
5989
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *             given then the return array will contain all nodes for the table
5990
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
5991
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnGetTdNodes ( oSettings, iIndividualRow )
5992
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
5993
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var anReturn = [];
5994
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var iCorrector;
5995
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var anTds;
5996
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var iRow, iRows=oSettings.aoData.length,
5997
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				iColumn, iColumns, oData, sNodeName, iStart=0, iEnd=iRows;
5998
 
5999
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Allow the collection to be limited to just one row */
6000
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( typeof iIndividualRow != 'undefined' )
6001
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6002
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				iStart = iIndividualRow;
6003
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				iEnd = iIndividualRow+1;
6004
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6005
 
6006
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			for ( iRow=iStart ; iRow<iEnd ; iRow++ )
6007
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6008
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				oData = oSettings.aoData[iRow];
6009
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( oData.nTr !== null )
6010
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6011
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					/* get the TD child nodes - taking into account text etc nodes */
6012
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					anTds = [];
6013
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					for ( iColumn=0, iColumns=oData.nTr.childNodes.length ; iColumn<iColumns ; iColumn++ )
6014
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
6015
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						sNodeName = oData.nTr.childNodes[iColumn].nodeName.toLowerCase();
6016
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						if ( sNodeName == 'td' || sNodeName == 'th' )
6017
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						{
6018
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							anTds.push( oData.nTr.childNodes[iColumn] );
6019
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						}
6020
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}
6021
 
6022
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					iCorrector = 0;
6023
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					for ( iColumn=0, iColumns=oSettings.aoColumns.length ; iColumn<iColumns ; iColumn++ )
6024
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
6025
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						if ( oSettings.aoColumns[iColumn].bVisible )
6026
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						{
6027
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							anReturn.push( anTds[iColumn-iCorrector] );
6028
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						}
6029
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						else
6030
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						{
6031
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							anReturn.push( oData._anHidden[iColumn] );
6032
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							iCorrector++;
6033
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						}
6034
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}
6035
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6036
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6037
 
6038
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			return anReturn;
6039
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
6040
 
6041
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
6042
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnEscapeRegex
6043
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  scape a string stuch that it can be used in a regular expression
6044
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  string: - escaped string
6045
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   string:sVal - string to escape
6046
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
6047
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnEscapeRegex ( sVal )
6048
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
6049
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var acEscape = [ '/', '.', '*', '+', '?', '|', '(', ')', '[', ']', '{', '}', '\\', '$', '^' ];
6050
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		  var reReplace = new RegExp( '(\\' + acEscape.join('|\\') + ')', 'g' );
6051
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		  return sVal.replace(reReplace, '\\$1');
6052
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
6053
 
6054
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
6055
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnDeleteIndex
6056
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Take an array of integers (index array) and remove a target integer (value - not 
6057
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *             the key!)
6058
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  -
6059
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   a:array int - Index array to target
6060
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           int:iTarget - value to find
6061
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
6062
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnDeleteIndex( a, iTarget )
6063
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
6064
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var iTargetIndex = -1;
6065
 
6066
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			for ( var i=0, iLen=a.length ; i<iLen ; i++ )
6067
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6068
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( a[i] == iTarget )
6069
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6070
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					iTargetIndex = i;
6071
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6072
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				else if ( a[i] > iTarget )
6073
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6074
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					a[i]--;
6075
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6076
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6077
 
6078
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( iTargetIndex != -1 )
6079
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6080
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				a.splice( iTargetIndex, 1 );
6081
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6082
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
6083
 
6084
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
6085
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnReOrderIndex
6086
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Figure out how to reorder a display list
6087
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  array int:aiReturn - index list for reordering
6088
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
6089
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
6090
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnReOrderIndex ( oSettings, sColumns )
6091
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
6092
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var aColumns = sColumns.split(',');
6093
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var aiReturn = [];
6094
 
6095
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			for ( var i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
6096
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6097
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				for ( var j=0 ; j<iLen ; j++ )
6098
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6099
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					if ( oSettings.aoColumns[i].sName == aColumns[j] )
6100
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
6101
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						aiReturn.push( j );
6102
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						break;
6103
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}
6104
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6105
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6106
 
6107
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			return aiReturn;
6108
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
6109
 
6110
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
6111
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnColumnOrdering
6112
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Get the column ordering that DataTables expects
6113
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  string: - comma separated list of names
6114
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
6115
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
6116
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnColumnOrdering ( oSettings )
6117
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
6118
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var sNames = '';
6119
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			for ( var i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
6120
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6121
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				sNames += oSettings.aoColumns[i].sName+',';
6122
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6123
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( sNames.length == iLen )
6124
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6125
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				return "";
6126
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6127
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			return sNames.slice(0, -1);
6128
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
6129
 
6130
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
6131
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnLog
6132
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Log an error message
6133
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  -
6134
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   int:iLevel - log error messages, or display them to the user
6135
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           string:sMesg - error message
6136
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
6137
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnLog( oSettings, iLevel, sMesg )
6138
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
6139
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var sAlert = oSettings.sTableId === "" ?
6140
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 	"DataTables warning: " +sMesg :
6141
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 	"DataTables warning (table id = '"+oSettings.sTableId+"'): " +sMesg;
6142
 
6143
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( iLevel === 0 )
6144
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6145
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( _oExt.sErrMode == 'alert' )
6146
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6147
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					alert( sAlert );
6148
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6149
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				else
6150
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6151
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					throw sAlert;
6152
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6153
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				return;
6154
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6155
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			else if ( typeof console != 'undefined' && typeof console.log != 'undefined' )
6156
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6157
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				console.log( sAlert );
6158
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6159
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
6160
 
6161
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
6162
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnClearTable
6163
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Nuke the table
6164
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  -
6165
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
6166
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
6167
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnClearTable( oSettings )
6168
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
6169
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			oSettings.aoData.splice( 0, oSettings.aoData.length );
6170
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			oSettings.aiDisplayMaster.splice( 0, oSettings.aiDisplayMaster.length );
6171
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			oSettings.aiDisplay.splice( 0, oSettings.aiDisplay.length );
6172
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			_fnCalculateEnd( oSettings );
6173
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
6174
 
6175
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
6176
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnSaveState
6177
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Save the state of a table in a cookie such that the page can be reloaded
6178
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  -
6179
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
6180
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
6181
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnSaveState ( oSettings )
6182
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
6183
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( !oSettings.oFeatures.bStateSave || typeof oSettings.bDestroying != 'undefined' )
6184
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6185
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				return;
6186
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6187
 
6188
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Store the interesting variables */
6189
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var i, iLen, sTmp;
6190
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var sValue = "{";
6191
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			sValue += '"iCreate":'+ new Date().getTime()+',';
6192
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			sValue += '"iStart":'+ (oSettings.oScroll.bInfinite ? 0 : oSettings._iDisplayStart)+',';
6193
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			sValue += '"iEnd":'+ (oSettings.oScroll.bInfinite ? oSettings._iDisplayLength : oSettings._iDisplayEnd)+',';
6194
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			sValue += '"iLength":'+ oSettings._iDisplayLength+',';
6195
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			sValue += '"sFilter":"'+ encodeURIComponent(oSettings.oPreviousSearch.sSearch)+'",';
6196
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			sValue += '"sFilterEsc":'+ !oSettings.oPreviousSearch.bRegex+',';
6197
 
6198
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			sValue += '"aaSorting":[ ';
6199
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			for ( i=0 ; i<oSettings.aaSorting.length ; i++ )
6200
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6201
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				sValue += '['+oSettings.aaSorting[i][0]+',"'+oSettings.aaSorting[i][1]+'"],';
6202
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6203
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			sValue = sValue.substring(0, sValue.length-1);
6204
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			sValue += "],";
6205
 
6206
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			sValue += '"aaSearchCols":[ ';
6207
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			for ( i=0 ; i<oSettings.aoPreSearchCols.length ; i++ )
6208
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6209
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				sValue += '["'+encodeURIComponent(oSettings.aoPreSearchCols[i].sSearch)+
6210
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					'",'+!oSettings.aoPreSearchCols[i].bRegex+'],';
6211
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6212
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			sValue = sValue.substring(0, sValue.length-1);
6213
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			sValue += "],";
6214
 
6215
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			sValue += '"abVisCols":[ ';
6216
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			for ( i=0 ; i<oSettings.aoColumns.length ; i++ )
6217
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6218
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				sValue += oSettings.aoColumns[i].bVisible+",";
6219
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6220
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			sValue = sValue.substring(0, sValue.length-1);
6221
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			sValue += "]";
6222
 
6223
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Save state from any plug-ins */
6224
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			for ( i=0, iLen=oSettings.aoStateSave.length ; i<iLen ; i++ )
6225
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6226
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				sTmp = oSettings.aoStateSave[i].fn( oSettings, sValue );
6227
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( sTmp !== "" )
6228
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6229
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					sValue = sTmp;
6230
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6231
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6232
 
6233
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			sValue += "}";
6234
 
6235
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			_fnCreateCookie( oSettings.sCookiePrefix+oSettings.sInstance, sValue, 
6236
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				oSettings.iCookieDuration, oSettings.sCookiePrefix, oSettings.fnCookieCallback );
6237
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
6238
 
6239
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
6240
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnLoadState
6241
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Attempt to load a saved table state from a cookie
6242
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  -
6243
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
6244
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           object:oInit - DataTables init object so we can override settings
6245
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
6246
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnLoadState ( oSettings, oInit )
6247
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
6248
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( !oSettings.oFeatures.bStateSave )
6249
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6250
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				return;
6251
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6252
 
6253
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var oData, i, iLen;
6254
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var sData = _fnReadCookie( oSettings.sCookiePrefix+oSettings.sInstance );
6255
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( sData !== null && sData !== '' )
6256
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6257
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Try/catch the JSON eval - if it is bad then we ignore it - note that 1.7.0 and before
6258
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * incorrectly used single quotes for some strings - hence the replace below
6259
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 */
6260
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				try
6261
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6262
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oData = (typeof JSON.parse == 'function') ? 
6263
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						JSON.parse( sData.replace(/'/g, '"') ) : $.parseJSON( sData.replace(/'/g, '"') );
6264
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6265
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				catch( e )
6266
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6267
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					return;
6268
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6269
 
6270
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Allow custom and plug-in manipulation functions to alter the data set which was
6271
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * saved, and also reject any saved state by returning false
6272
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 */
6273
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				for ( i=0, iLen=oSettings.aoStateLoad.length ; i<iLen ; i++ )
6274
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6275
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					if ( !oSettings.aoStateLoad[i].fn( oSettings, oData ) )
6276
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
6277
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						return;
6278
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}
6279
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6280
 
6281
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Store the saved state so it might be accessed at any time (particualrly a plug-in */
6282
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				oSettings.oLoadedState = $.extend( true, {}, oData );
6283
 
6284
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Restore key features */
6285
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				oSettings._iDisplayStart = oData.iStart;
6286
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				oSettings.iInitDisplayStart = oData.iStart;
6287
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				oSettings._iDisplayEnd = oData.iEnd;
6288
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				oSettings._iDisplayLength = oData.iLength;
6289
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				oSettings.oPreviousSearch.sSearch = decodeURIComponent(oData.sFilter);
6290
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				oSettings.aaSorting = oData.aaSorting.slice();
6291
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				oSettings.saved_aaSorting = oData.aaSorting.slice();
6292
 
6293
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/*
6294
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * Search filtering - global reference added in 1.4.1
6295
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * Note that we use a 'not' for the value of the regular expression indicator to maintain
6296
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * compatibility with pre 1.7 versions, where this was basically inverted. Added in 1.7.0
6297
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 */
6298
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( typeof oData.sFilterEsc != 'undefined' )
6299
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6300
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings.oPreviousSearch.bRegex = !oData.sFilterEsc;
6301
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6302
 
6303
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Column filtering - added in 1.5.0 beta 6 */
6304
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( typeof oData.aaSearchCols != 'undefined' )
6305
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6306
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					for ( i=0 ; i<oData.aaSearchCols.length ; i++ )
6307
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
6308
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						oSettings.aoPreSearchCols[i] = {
6309
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							"sSearch": decodeURIComponent(oData.aaSearchCols[i][0]),
6310
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							"bRegex": !oData.aaSearchCols[i][1]
6311
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						};
6312
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}
6313
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6314
 
6315
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Column visibility state - added in 1.5.0 beta 10 */
6316
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( typeof oData.abVisCols != 'undefined' )
6317
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6318
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					/* Pass back visibiliy settings to the init handler, but to do not here override
6319
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					 * the init object that the user might have passed in
6320
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					 */
6321
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oInit.saved_aoColumns = [];
6322
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					for ( i=0 ; i<oData.abVisCols.length ; i++ )
6323
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
6324
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						oInit.saved_aoColumns[i] = {};
6325
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						oInit.saved_aoColumns[i].bVisible = oData.abVisCols[i];
6326
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}
6327
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6328
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6329
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
6330
 
6331
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
6332
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnCreateCookie
6333
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Create a new cookie with a value to store the state of a table
6334
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  -
6335
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   string:sName - name of the cookie to create
6336
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           string:sValue - the value the cookie should take
6337
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           int:iSecs - duration of the cookie
6338
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           string:sBaseName - sName is made up of the base + file name - this is the base
6339
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           function:fnCallback - User definable function to modify the cookie
6340
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
6341
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnCreateCookie ( sName, sValue, iSecs, sBaseName, fnCallback )
6342
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
6343
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var date = new Date();
6344
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			date.setTime( date.getTime()+(iSecs*1000) );
6345
 
6346
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* 
6347
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * Shocking but true - it would appear IE has major issues with having the path not having
6348
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * a trailing slash on it. We need the cookie to be available based on the path, so we
6349
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * have to append the file name to the cookie name. Appalling. Thanks to vex for adding the
6350
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * patch to use at least some of the path
6351
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 */
6352
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var aParts = window.location.pathname.split('/');
6353
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var sNameFile = sName + '_' + aParts.pop().replace(/[\/:]/g,"").toLowerCase();
6354
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var sFullCookie, oData;
6355
 
6356
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( fnCallback !== null )
6357
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6358
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				oData = (typeof JSON.parse == 'function') ? 
6359
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					JSON.parse( sValue ) : $.parseJSON( sValue );
6360
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				sFullCookie = fnCallback( sNameFile, oData, date.toGMTString(),
6361
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					aParts.join('/')+"/" );
6362
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6363
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			else
6364
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6365
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				sFullCookie = sNameFile + "=" + encodeURIComponent(sValue) +
2976 rexy 6366
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					"; expires=" + date.toGMTString() +"; path=" + aParts.join('/')+"/; samesite=strict";
2808 rexy 6367
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6368
 
6369
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Are we going to go over the cookie limit of 4KiB? If so, try to delete a cookies
6370
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * belonging to DataTables. This is FAR from bullet proof
6371
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 */
6372
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var sOldName="", iOldTime=9999999999999;
6373
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var iLength = _fnReadCookie( sNameFile )!==null ? document.cookie.length : 
6374
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				sFullCookie.length + document.cookie.length;
6375
 
6376
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( iLength+10 > 4096 ) /* Magic 10 for padding */
6377
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6378
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				var aCookies =document.cookie.split(';');
6379
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				for ( var i=0, iLen=aCookies.length ; i<iLen ; i++ )
6380
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6381
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					if ( aCookies[i].indexOf( sBaseName ) != -1 )
6382
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
6383
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						/* It's a DataTables cookie, so eval it and check the time stamp */
6384
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						var aSplitCookie = aCookies[i].split('=');
6385
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						try { oData = eval( '('+decodeURIComponent(aSplitCookie[1])+')' ); }
6386
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						catch( e ) { continue; }
6387
 
6388
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						if ( typeof oData.iCreate != 'undefined' && oData.iCreate < iOldTime )
6389
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						{
6390
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							sOldName = aSplitCookie[0];
6391
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							iOldTime = oData.iCreate;
6392
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						}
6393
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}
6394
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6395
 
6396
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( sOldName !== "" )
6397
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6398
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					document.cookie = sOldName+"=; expires=Thu, 01-Jan-1970 00:00:01 GMT; path="+
2976 rexy 6399
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						aParts.join('/') + "/; samesite=strict";
2808 rexy 6400
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6401
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6402
 
6403
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			document.cookie = sFullCookie;
6404
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
6405
 
6406
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
6407
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnReadCookie
6408
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Read an old cookie to get a cookie with an old table state
6409
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  string: - contents of the cookie - or null if no cookie with that name found
6410
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   string:sName - name of the cookie to read
6411
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
6412
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnReadCookie ( sName )
6413
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
6414
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var
6415
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				aParts = window.location.pathname.split('/'),
6416
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				sNameEQ = sName + '_' + aParts[aParts.length-1].replace(/[\/:]/g,"").toLowerCase() + '=',
6417
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 	sCookieContents = document.cookie.split(';');
6418
 
6419
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			for( var i=0 ; i<sCookieContents.length ; i++ )
6420
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6421
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				var c = sCookieContents[i];
6422
 
6423
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				while (c.charAt(0)==' ')
6424
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6425
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					c = c.substring(1,c.length);
6426
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6427
 
6428
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if (c.indexOf(sNameEQ) === 0)
6429
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6430
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					return decodeURIComponent( c.substring(sNameEQ.length,c.length) );
6431
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6432
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6433
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			return null;
6434
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
6435
 
6436
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
6437
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnDetectHeader
6438
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Use the DOM source to create up an array of header cells. The idea here is to
6439
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           create a layout grid (array) of rows x columns, which contains a reference
6440
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           to the cell that that point in the grid (regardless of col/rowspan), such that
6441
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           any column / row could be removed and the new grid constructed
6442
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  void
6443
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Outputs:  array object:aLayout - Array to store the calculated layout in
6444
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   node:nThead - The header/footer element for the table
6445
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
6446
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnDetectHeader ( aLayout, nThead )
6447
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
6448
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var nTrs = $(nThead).children('tr');
6449
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var nCell;
6450
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var i, j, k, l, iLen, jLen, iColShifted;
6451
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var fnShiftCol = function ( a, i, j ) {
6452
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				while ( typeof a[i][j] != 'undefined' ) {
6453
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					j++;
6454
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6455
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				return j;
6456
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			};
6457
 
6458
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			aLayout.splice( 0, aLayout.length );
6459
 
6460
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* We know how many rows there are in the layout - so prep it */
6461
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			for ( i=0, iLen=nTrs.length ; i<iLen ; i++ )
6462
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6463
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				aLayout.push( [] );
6464
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6465
 
6466
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Calculate a layout array */
6467
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			for ( i=0, iLen=nTrs.length ; i<iLen ; i++ )
6468
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6469
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				var iColumn = 0;
6470
 
6471
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* For every cell in the row... */
6472
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				for ( j=0, jLen=nTrs[i].childNodes.length ; j<jLen ; j++ )
6473
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6474
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					nCell = nTrs[i].childNodes[j];
6475
 
6476
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					if ( nCell.nodeName.toUpperCase() == "TD" ||
6477
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					     nCell.nodeName.toUpperCase() == "TH" )
6478
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
6479
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						/* Get the col and rowspan attributes from the DOM and sanitise them */
6480
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						var iColspan = nCell.getAttribute('colspan') * 1;
6481
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						var iRowspan = nCell.getAttribute('rowspan') * 1;
6482
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						iColspan = (!iColspan || iColspan===0 || iColspan===1) ? 1 : iColspan;
6483
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						iRowspan = (!iRowspan || iRowspan===0 || iRowspan===1) ? 1 : iRowspan;
6484
 
6485
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						/* There might be colspan cells already in this row, so shift our target 
6486
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						 * accordingly
6487
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						 */
6488
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						iColShifted = fnShiftCol( aLayout, i, iColumn );
6489
 
6490
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						/* If there is col / rowspan, copy the information into the layout grid */
6491
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						for ( l=0 ; l<iColspan ; l++ )
6492
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						{
6493
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							for ( k=0 ; k<iRowspan ; k++ )
6494
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							{
6495
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>								aLayout[i+k][iColShifted+l] = {
6496
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>									"cell": nCell,
6497
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>									"unique": iColspan == 1 ? true : false
6498
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>								};
6499
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>								aLayout[i+k].nTr = nTrs[i];
6500
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							}
6501
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						}
6502
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}
6503
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6504
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6505
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
6506
 
6507
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
6508
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnGetUniqueThs
6509
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Get an array of unique th elements, one for each column
6510
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  array node:aReturn - list of unique ths
6511
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
6512
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           node:nHeader - automatically detect the layout from this node - optional
6513
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           array object:aLayout - thead/tfoot layout from _fnDetectHeader - optional
6514
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
6515
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnGetUniqueThs ( oSettings, nHeader, aLayout )
6516
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
6517
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var aReturn = [];
6518
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( typeof aLayout == 'undefined' )
6519
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6520
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				aLayout = oSettings.aoHeader;
6521
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( typeof nHeader != 'undefined' )
6522
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6523
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					aLayout = [];
6524
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					_fnDetectHeader( aLayout, nHeader );
6525
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6526
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6527
 
6528
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			for ( var i=0, iLen=aLayout.length ; i<iLen ; i++ )
6529
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6530
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				for ( var j=0, jLen=aLayout[i].length ; j<jLen ; j++ )
6531
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6532
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					if ( aLayout[i][j].unique && 
6533
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						 (typeof aReturn[j] == 'undefined' || !oSettings.bSortCellsTop) )
6534
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
6535
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						aReturn[j] = aLayout[i][j].cell;
6536
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}
6537
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6538
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6539
 
6540
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			return aReturn;
6541
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
6542
 
6543
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
6544
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnScrollBarWidth
6545
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Get the width of a scroll bar in this browser being used
6546
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  int: - width in pixels
6547
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   -
6548
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Notes:    All credit for this function belongs to Alexandre Gomes. Thanks for sharing!
6549
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *   http://www.alexandre-gomes.com/?p=115
6550
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
6551
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnScrollBarWidth ()
6552
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{  
6553
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var inner = document.createElement('p');
6554
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var style = inner.style;
6555
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			style.width = "100%";
6556
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			style.height = "200px";
6557
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			style.padding = "0px";
6558
 
6559
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var outer = document.createElement('div');
6560
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			style = outer.style;
6561
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			style.position = "absolute";
6562
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			style.top = "0px";
6563
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			style.left = "0px";
6564
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			style.visibility = "hidden";
6565
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			style.width = "200px";
6566
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			style.height = "150px";
6567
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			style.padding = "0px";
6568
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			style.overflow = "hidden";
6569
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			outer.appendChild(inner);
6570
 
6571
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			document.body.appendChild(outer);
6572
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var w1 = inner.offsetWidth;
6573
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			outer.style.overflow = 'scroll';
6574
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var w2 = inner.offsetWidth;
6575
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( w1 == w2 )
6576
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6577
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				w2 = outer.clientWidth;
6578
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6579
 
6580
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			document.body.removeChild(outer);
6581
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			return (w1 - w2);  
6582
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
6583
 
6584
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
6585
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnApplyToChildren
6586
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Apply a given function to the display child nodes of an element array (typically
6587
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *   TD children of TR rows
6588
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  - (done by reference)
6589
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   function:fn - Method to apply to the objects
6590
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           array nodes:an1 - List of elements to look through for display children
6591
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           array nodes:an2 - Another list (identical structure to the first) - optional
6592
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
6593
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnApplyToChildren( fn, an1, an2 )
6594
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
6595
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			for ( var i=0, iLen=an1.length ; i<iLen ; i++ )
6596
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6597
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				for ( var j=0, jLen=an1[i].childNodes.length ; j<jLen ; j++ )
6598
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6599
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					if ( an1[i].childNodes[j].nodeType == 1 )
6600
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
6601
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						if ( typeof an2 != 'undefined' )
6602
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						{
6603
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							fn( an1[i].childNodes[j], an2[i].childNodes[j] );
6604
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						}
6605
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						else
6606
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						{
6607
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							fn( an1[i].childNodes[j] );
6608
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						}
6609
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}
6610
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6611
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6612
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
6613
 
6614
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
6615
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnMap
6616
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  See if a property is defined on one object, if so assign it to the other object
6617
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  - (done by reference)
6618
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oRet - target object
6619
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           object:oSrc - source object
6620
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           string:sName - property
6621
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           string:sMappedName - name to map too - optional, sName used if not given
6622
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
6623
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnMap( oRet, oSrc, sName, sMappedName )
6624
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
6625
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( typeof sMappedName == 'undefined' )
6626
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6627
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				sMappedName = sName;
6628
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6629
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( typeof oSrc[sName] != 'undefined' )
6630
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6631
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				oRet[sMappedName] = oSrc[sName];
6632
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6633
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
6634
 
6635
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
6636
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnGetRowData
6637
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Get an array of data for a given row from the internal data cache
6638
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  array: - Data array
6639
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
6640
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           int:iRow - aoData row id
6641
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           string:sSpecific - data get type ('type' 'filter' 'sort')
6642
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
6643
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnGetRowData( oSettings, iRow, sSpecific )
6644
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
6645
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var out = [];
6646
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			for ( var i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
6647
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6648
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				out.push( _fnGetCellData( oSettings, iRow, i, sSpecific ) );
6649
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6650
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			return out;
6651
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
6652
 
6653
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
6654
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnGetCellData
6655
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Get the data for a given cell from the internal cache, taking into account data mapping
6656
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  *: - Cell data
6657
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
6658
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           int:iRow - aoData row id
6659
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           int:iCol - Column index
6660
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           string:sSpecific - data get type ('display', 'type' 'filter' 'sort')
6661
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
6662
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnGetCellData( oSettings, iRow, iCol, sSpecific )
6663
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
6664
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var sData;
6665
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var oCol = oSettings.aoColumns[iCol];
6666
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var oData = oSettings.aoData[iRow]._aData;
6667
 
6668
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( (sData=oCol.fnGetData( oData )) === undefined )
6669
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6670
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( oSettings.iDrawError != oSettings.iDraw && oCol.sDefaultContent === null )
6671
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6672
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					_fnLog( oSettings, 0, "Requested unknown parameter '"+oCol.mDataProp+
6673
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						"' from the data source for row "+iRow );
6674
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings.iDrawError = oSettings.iDraw;
6675
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6676
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				return oCol.sDefaultContent;
6677
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6678
 
6679
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* When the data source is null, we can use default column data */
6680
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( sData === null && oCol.sDefaultContent !== null )
6681
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6682
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				sData = oCol.sDefaultContent;
6683
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6684
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			else if ( typeof sData == 'function' )
6685
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6686
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* If the data source is a function, then we run it and use the return */
6687
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				return sData();
6688
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6689
 
6690
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( sSpecific == 'display' && sData === null )
6691
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6692
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				return '';
6693
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6694
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			return sData;
6695
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
6696
 
6697
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
6698
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnSetCellData
6699
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Set the value for a specific cell, into the internal data cache
6700
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  *: - Cell data
6701
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   object:oSettings - dataTables settings object
6702
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           int:iRow - aoData row id
6703
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           int:iCol - Column index
6704
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           *:val - Value to set
6705
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
6706
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnSetCellData( oSettings, iRow, iCol, val )
6707
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
6708
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var oCol = oSettings.aoColumns[iCol];
6709
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var oData = oSettings.aoData[iRow]._aData;
6710
 
6711
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			oCol.fnSetData( oData, val );
6712
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
6713
 
6714
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
6715
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnGetObjectDataFn
6716
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Return a function that can be used to get data from a source object, taking
6717
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           into account the ability to use nested objects as a source
6718
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  function: - Data get function
6719
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   string|int|function:mSource - The data source for the object
6720
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
6721
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnGetObjectDataFn( mSource )
6722
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
6723
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( mSource === null )
6724
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6725
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Give an empty string for rendering / sorting etc */
6726
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				return function (data) {
6727
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					return null;
6728
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				};
6729
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6730
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			else if ( typeof mSource == 'function' )
6731
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6732
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			    return function (data) {
6733
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			        return mSource( data );
6734
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			    };
6735
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6736
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			else if ( typeof mSource == 'string' && mSource.indexOf('.') != -1 )
6737
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6738
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* If there is a . in the source string then the data source is in a nested object
6739
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * we provide two 'quick' functions for the look up to speed up the most common
6740
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * operation, and a generalised one for when it is needed
6741
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 */
6742
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				var a = mSource.split('.');
6743
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( a.length == 2 )
6744
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6745
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					return function (data) {
6746
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						return data[ a[0] ][ a[1] ];
6747
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					};
6748
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6749
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				else if ( a.length == 3 )
6750
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6751
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					return function (data) {
6752
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						return data[ a[0] ][ a[1] ][ a[2] ];
6753
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					};
6754
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6755
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				else
6756
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6757
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					return function (data) {
6758
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						for ( var i=0, iLen=a.length ; i<iLen ; i++ )
6759
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						{
6760
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							data = data[ a[i] ];
6761
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						}
6762
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						return data;
6763
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					};
6764
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6765
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6766
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			else
6767
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6768
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Array or flat object mapping */
6769
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				return function (data) {
6770
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					return data[mSource];	
6771
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				};
6772
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6773
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
6774
 
6775
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/*
6776
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Function: _fnSetObjectDataFn
6777
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Purpose:  Return a function that can be used to set data from a source object, taking
6778
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 *           into account the ability to use nested objects as a source
6779
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Returns:  function: - Data set function
6780
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Inputs:   string|int|function:mSource - The data source for the object
6781
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
6782
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		function _fnSetObjectDataFn( mSource )
6783
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
6784
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( mSource === null )
6785
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6786
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Nothing to do when the data source is null */
6787
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				return function (data, val) {};
6788
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6789
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			else if ( typeof mSource == 'function' )
6790
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6791
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			    return function (data, val) {
6792
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			        return mSource( data, val );
6793
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			    };
6794
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6795
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			else if ( typeof mSource == 'string' && mSource.indexOf('.') != -1 )
6796
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6797
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Like the get, we need to get data from a nested object. Again two fast lookup
6798
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * functions are provided, and a generalised one.
6799
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 */
6800
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				var a = mSource.split('.');
6801
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( a.length == 2 )
6802
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6803
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					return function (data, val) {
6804
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						data[ a[0] ][ a[1] ] = val;
6805
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					};
6806
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6807
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				else if ( a.length == 3 )
6808
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6809
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					return function (data, val) {
6810
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						data[ a[0] ][ a[1] ][ a[2] ] = val;
6811
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					};
6812
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6813
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				else
6814
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6815
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					return function (data, val) {
6816
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						for ( var i=0, iLen=a.length-1 ; i<iLen ; i++ )
6817
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						{
6818
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							data = data[ a[i] ];
6819
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						}
6820
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						data[ a[a.length-1] ] = val;
6821
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					};
6822
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6823
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6824
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			else
6825
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6826
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Array or flat object mapping */
6827
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				return function (data, val) {
6828
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					data[mSource] = val;	
6829
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				};
6830
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6831
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		}
6832
 
6833
 
6834
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
6835
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Section - API
6836
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * I'm not happy with this solution... - To be fixed in 2.0
6837
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
6838
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnExternApiFunc = _fnExternApiFunc;
6839
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnInitialise = _fnInitialise;
6840
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnInitComplete = _fnInitComplete;
6841
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnLanguageProcess = _fnLanguageProcess;
6842
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnAddColumn = _fnAddColumn;
6843
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnColumnOptions = _fnColumnOptions;
6844
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnAddData = _fnAddData;
6845
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnCreateTr = _fnCreateTr;
6846
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnGatherData = _fnGatherData;
6847
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnBuildHead = _fnBuildHead;
6848
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnDrawHead = _fnDrawHead;
6849
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnDraw = _fnDraw;
6850
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnReDraw = _fnReDraw;
6851
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnAjaxUpdate = _fnAjaxUpdate;
6852
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnAjaxParameters = _fnAjaxParameters;
6853
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnAjaxUpdateDraw = _fnAjaxUpdateDraw;
6854
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnServerParams = _fnServerParams;
6855
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnAddOptionsHtml = _fnAddOptionsHtml;
6856
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnFeatureHtmlTable = _fnFeatureHtmlTable;
6857
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnScrollDraw = _fnScrollDraw;
6858
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnAdjustColumnSizing = _fnAdjustColumnSizing;
6859
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnFeatureHtmlFilter = _fnFeatureHtmlFilter;
6860
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnFilterComplete = _fnFilterComplete;
6861
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnFilterCustom = _fnFilterCustom;
6862
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnFilterColumn = _fnFilterColumn;
6863
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnFilter = _fnFilter;
6864
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnBuildSearchArray = _fnBuildSearchArray;
6865
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnBuildSearchRow = _fnBuildSearchRow;
6866
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnFilterCreateSearch = _fnFilterCreateSearch;
6867
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnDataToSearch = _fnDataToSearch;
6868
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnSort = _fnSort;
6869
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnSortAttachListener = _fnSortAttachListener;
6870
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnSortingClasses = _fnSortingClasses;
6871
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnFeatureHtmlPaginate = _fnFeatureHtmlPaginate;
6872
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnPageChange = _fnPageChange;
6873
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnFeatureHtmlInfo = _fnFeatureHtmlInfo;
6874
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnUpdateInfo = _fnUpdateInfo;
6875
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnFeatureHtmlLength = _fnFeatureHtmlLength;
6876
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnFeatureHtmlProcessing = _fnFeatureHtmlProcessing;
6877
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnProcessingDisplay = _fnProcessingDisplay;
6878
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnVisibleToColumnIndex = _fnVisibleToColumnIndex;
6879
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnColumnIndexToVisible = _fnColumnIndexToVisible;
6880
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnNodeToDataIndex = _fnNodeToDataIndex;
6881
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnVisbleColumns = _fnVisbleColumns;
6882
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnCalculateEnd = _fnCalculateEnd;
6883
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnConvertToWidth = _fnConvertToWidth;
6884
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnCalculateColumnWidths = _fnCalculateColumnWidths;
6885
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnScrollingWidthAdjust = _fnScrollingWidthAdjust;
6886
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnGetWidestNode = _fnGetWidestNode;
6887
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnGetMaxLenString = _fnGetMaxLenString;
6888
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnStringToCss = _fnStringToCss;
6889
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnArrayCmp = _fnArrayCmp;
6890
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnDetectType = _fnDetectType;
6891
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnSettingsFromNode = _fnSettingsFromNode;
6892
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnGetDataMaster = _fnGetDataMaster;
6893
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnGetTrNodes = _fnGetTrNodes;
6894
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnGetTdNodes = _fnGetTdNodes;
6895
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnEscapeRegex = _fnEscapeRegex;
6896
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnDeleteIndex = _fnDeleteIndex;
6897
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnReOrderIndex = _fnReOrderIndex;
6898
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnColumnOrdering = _fnColumnOrdering;
6899
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnLog = _fnLog;
6900
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnClearTable = _fnClearTable;
6901
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnSaveState = _fnSaveState;
6902
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnLoadState = _fnLoadState;
6903
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnCreateCookie = _fnCreateCookie;
6904
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnReadCookie = _fnReadCookie;
6905
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnDetectHeader = _fnDetectHeader;
6906
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnGetUniqueThs = _fnGetUniqueThs;
6907
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnScrollBarWidth = _fnScrollBarWidth;
6908
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnApplyToChildren = _fnApplyToChildren;
6909
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnMap = _fnMap;
6910
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnGetRowData = _fnGetRowData;
6911
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnGetCellData = _fnGetCellData;
6912
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnSetCellData = _fnSetCellData;
6913
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnGetObjectDataFn = _fnGetObjectDataFn;
6914
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		this.oApi._fnSetObjectDataFn = _fnSetObjectDataFn;
6915
 
6916
 
6917
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
6918
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 * Section - Constructor
6919
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		 */
6920
 
6921
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		/* Want to be able to reference "this" inside the this.each function */
6922
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		var _that = this;
6923
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		return this.each(function()
6924
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		{
6925
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var i=0, iLen, j, jLen, k, kLen;
6926
 
6927
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Check to see if we are re-initialising a table */
6928
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			for ( i=0, iLen=_aoSettings.length ; i<iLen ; i++ )
6929
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6930
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Base check on table node */
6931
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( _aoSettings[i].nTable == this )
6932
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6933
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					if ( typeof oInit == 'undefined' || 
6934
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					   ( typeof oInit.bRetrieve != 'undefined' && oInit.bRetrieve === true ) )
6935
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
6936
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						return _aoSettings[i].oInstance;
6937
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}
6938
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					else if ( typeof oInit.bDestroy != 'undefined' && oInit.bDestroy === true )
6939
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
6940
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						_aoSettings[i].oInstance.fnDestroy();
6941
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						break;
6942
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}
6943
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					else
6944
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
6945
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						_fnLog( _aoSettings[i], 0, "Cannot reinitialise DataTable.\n\n"+
6946
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							"To retrieve the DataTables object for this table, please pass either no arguments "+
6947
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							"to the dataTable() function, or set bRetrieve to true. Alternatively, to destory "+
6948
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							"the old table and create a new one, set bDestroy to true (note that a lot of "+
6949
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							"changes to the configuration can be made through the API which is usually much "+
6950
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							"faster)." );
6951
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						return;
6952
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}
6953
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6954
 
6955
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* If the element we are initialising has the same ID as a table which was previously
6956
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * initialised, but the table nodes don't match (from before) then we destory the old
6957
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * instance by simply deleting it. This is under the assumption that the table has been
6958
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * destroyed by other methods. Anyone using non-id selectors will need to do this manually
6959
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 */
6960
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( _aoSettings[i].sTableId !== "" && _aoSettings[i].sTableId == this.getAttribute('id') )
6961
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
6962
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					_aoSettings.splice( i, 1 );
6963
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					break;
6964
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
6965
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6966
 
6967
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Make a complete and independent copy of the settings object */
6968
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var oSettings = new classSettings();
6969
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			_aoSettings.push( oSettings );
6970
 
6971
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var bInitHandedOff = false;
6972
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var bUsePassedData = false;
6973
 
6974
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Set the id */
6975
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var sId = this.getAttribute( 'id' );
6976
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( sId !== null )
6977
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6978
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				oSettings.sTableId = sId;
6979
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				oSettings.sInstance = sId;
6980
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6981
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			else
6982
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6983
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				oSettings.sInstance = _oExt._oExternConfig.iNextUnique ++;
6984
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6985
 
6986
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Sanity check */
6987
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( this.nodeName.toLowerCase() != 'table' )
6988
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
6989
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnLog( oSettings, 0, "Attempted to initialise DataTables on a node which is not a "+
6990
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					"table: "+this.nodeName );
6991
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				return;
6992
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
6993
 
6994
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Set the table node */
6995
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			oSettings.nTable = this;
6996
 
6997
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Keep a reference to the 'this' instance for the table. Note that if this table is being
6998
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * created with others, we retrieve a unique instance to ease API access.
6999
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 */
7000
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			oSettings.oInstance = _that.length == 1 ? _that : $(this).dataTable();
7001
 
7002
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Bind the API functions to the settings, so we can perform actions whenever oSettings is
7003
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * available
7004
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 */
7005
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			oSettings.oApi = _that.oApi;
7006
 
7007
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* State the table's width for if a destroy is called at a later time */
7008
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			oSettings.sDestroyWidth = $(this).width();
7009
 
7010
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Store the features that we have available */
7011
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( typeof oInit != 'undefined' && oInit !== null )
7012
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
7013
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				oSettings.oInit = oInit;
7014
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings.oFeatures, oInit, "bPaginate" );
7015
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings.oFeatures, oInit, "bLengthChange" );
7016
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings.oFeatures, oInit, "bFilter" );
7017
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings.oFeatures, oInit, "bSort" );
7018
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings.oFeatures, oInit, "bInfo" );
7019
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings.oFeatures, oInit, "bProcessing" );
7020
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings.oFeatures, oInit, "bAutoWidth" );
7021
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings.oFeatures, oInit, "bSortClasses" );
7022
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings.oFeatures, oInit, "bServerSide" );
7023
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings.oFeatures, oInit, "bDeferRender" );
7024
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings.oScroll, oInit, "sScrollX", "sX" );
7025
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings.oScroll, oInit, "sScrollXInner", "sXInner" );
7026
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings.oScroll, oInit, "sScrollY", "sY" );
7027
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings.oScroll, oInit, "bScrollCollapse", "bCollapse" );
7028
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings.oScroll, oInit, "bScrollInfinite", "bInfinite" );
7029
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings.oScroll, oInit, "iScrollLoadGap", "iLoadGap" );
7030
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings.oScroll, oInit, "bScrollAutoCss", "bAutoCss" );
7031
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings, oInit, "asStripClasses", "asStripeClasses" ); // legacy
7032
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings, oInit, "asStripeClasses" );
7033
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings, oInit, "fnPreDrawCallback" );
7034
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings, oInit, "fnRowCallback" );
7035
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings, oInit, "fnHeaderCallback" );
7036
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings, oInit, "fnFooterCallback" );
7037
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings, oInit, "fnCookieCallback" );
7038
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings, oInit, "fnInitComplete" );
7039
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings, oInit, "fnServerData" );
7040
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings, oInit, "fnFormatNumber" );
7041
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings, oInit, "aaSorting" );
7042
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings, oInit, "aaSortingFixed" );
7043
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings, oInit, "aLengthMenu" );
7044
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings, oInit, "sPaginationType" );
7045
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings, oInit, "sAjaxSource" );
7046
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings, oInit, "sAjaxDataProp" );
7047
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings, oInit, "iCookieDuration" );
7048
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings, oInit, "sCookiePrefix" );
7049
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings, oInit, "sDom" );
7050
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings, oInit, "bSortCellsTop" );
7051
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings, oInit, "oSearch", "oPreviousSearch" );
7052
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings, oInit, "aoSearchCols", "aoPreSearchCols" );
7053
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings, oInit, "iDisplayLength", "_iDisplayLength" );
7054
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings, oInit, "bJQueryUI", "bJUI" );
7055
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnMap( oSettings.oLanguage, oInit, "fnInfoCallback" );
7056
 
7057
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Callback functions which are array driven */
7058
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( typeof oInit.fnDrawCallback == 'function' )
7059
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7060
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings.aoDrawCallback.push( {
7061
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						"fn": oInit.fnDrawCallback,
7062
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						"sName": "user"
7063
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					} );
7064
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7065
 
7066
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Ajax additional variables are array driven */
7067
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( typeof oInit.fnServerParams == 'function' )
7068
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7069
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings.aoServerParams.push( {
7070
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						"fn": oInit.fnServerParams,
7071
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						"sName": "user"
7072
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					} );
7073
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7074
 
7075
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( typeof oInit.fnStateSaveCallback == 'function' )
7076
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7077
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings.aoStateSave.push( {
7078
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						"fn": oInit.fnStateSaveCallback,
7079
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						"sName": "user"
7080
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					} );
7081
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7082
 
7083
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( typeof oInit.fnStateLoadCallback == 'function' )
7084
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7085
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings.aoStateLoad.push( {
7086
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						"fn": oInit.fnStateLoadCallback,
7087
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						"sName": "user"
7088
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					} );
7089
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7090
 
7091
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( oSettings.oFeatures.bServerSide && oSettings.oFeatures.bSort &&
7092
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					   oSettings.oFeatures.bSortClasses )
7093
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7094
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					/* Enable sort classes for server-side processing. Safe to do it here, since server-side
7095
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					 * processing must be enabled by the developer
7096
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					 */
7097
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings.aoDrawCallback.push( {
7098
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						"fn": _fnSortingClasses,
7099
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						"sName": "server_side_sort_classes"
7100
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					} );
7101
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7102
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				else if ( oSettings.oFeatures.bDeferRender )
7103
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7104
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings.aoDrawCallback.push( {
7105
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						"fn": _fnSortingClasses,
7106
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						"sName": "defer_sort_classes"
7107
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					} );
7108
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7109
 
7110
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( typeof oInit.bJQueryUI != 'undefined' && oInit.bJQueryUI )
7111
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7112
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					/* Use the JUI classes object for display. You could clone the oStdClasses object if 
7113
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					 * you want to have multiple tables with multiple independent classes 
7114
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					 */
7115
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings.oClasses = _oExt.oJUIClasses;
7116
 
7117
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					if ( typeof oInit.sDom == 'undefined' )
7118
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
7119
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						/* Set the DOM to use a layout suitable for jQuery UI's theming */
7120
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						oSettings.sDom = '<"H"lfr>t<"F"ip>';
7121
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}
7122
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7123
 
7124
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Calculate the scroll bar width and cache it for use later on */
7125
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( oSettings.oScroll.sX !== "" || oSettings.oScroll.sY !== "" )
7126
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7127
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings.oScroll.iBarWidth = _fnScrollBarWidth();
7128
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7129
 
7130
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( typeof oInit.iDisplayStart != 'undefined' && 
7131
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				     typeof oSettings.iInitDisplayStart == 'undefined' )
7132
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7133
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					/* Display start point, taking into account the save saving */
7134
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings.iInitDisplayStart = oInit.iDisplayStart;
7135
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings._iDisplayStart = oInit.iDisplayStart;
7136
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7137
 
7138
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Must be done after everything which can be overridden by a cookie! */
7139
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( typeof oInit.bStateSave != 'undefined' )
7140
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7141
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings.oFeatures.bStateSave = oInit.bStateSave;
7142
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					_fnLoadState( oSettings, oInit );
7143
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings.aoDrawCallback.push( {
7144
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						"fn": _fnSaveState,
7145
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						"sName": "state_save"
7146
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					} );
7147
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7148
 
7149
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( typeof oInit.iDeferLoading != 'undefined' )
7150
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7151
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings.bDeferLoading = true;
7152
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings._iRecordsTotal = oInit.iDeferLoading;
7153
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings._iRecordsDisplay = oInit.iDeferLoading;
7154
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7155
 
7156
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( typeof oInit.aaData != 'undefined' )
7157
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7158
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					bUsePassedData = true;
7159
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7160
 
7161
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Backwards compatability */
7162
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* aoColumns / aoData - remove at some point... */
7163
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( typeof oInit != 'undefined' && typeof oInit.aoData != 'undefined' )
7164
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7165
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oInit.aoColumns = oInit.aoData;
7166
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7167
 
7168
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Language definitions */
7169
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( typeof oInit.oLanguage != 'undefined' )
7170
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7171
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					if ( typeof oInit.oLanguage.sUrl != 'undefined' && oInit.oLanguage.sUrl !== "" )
7172
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
7173
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						/* Get the language definitions from a file */
7174
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						oSettings.oLanguage.sUrl = oInit.oLanguage.sUrl;
7175
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						$.getJSON( oSettings.oLanguage.sUrl, null, function( json ) { 
7176
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							_fnLanguageProcess( oSettings, json, true ); } );
7177
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						bInitHandedOff = true;
7178
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}
7179
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					else
7180
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
7181
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						_fnLanguageProcess( oSettings, oInit.oLanguage, false );
7182
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}
7183
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7184
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Warning: The _fnLanguageProcess function is async to the remainder of this function due
7185
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * to the XHR. We use _bInitialised in _fnLanguageProcess() to check this the processing 
7186
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * below is complete. The reason for spliting it like this is optimisation - we can fire
7187
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 * off the XHR (if needed) and then continue processing the data.
7188
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				 */
7189
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
7190
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			else
7191
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
7192
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Create a dummy object for quick manipulation later on. */
7193
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				oInit = {};
7194
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
7195
 
7196
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/*
7197
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * Stripes
7198
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * Add the stripe classes now that we know which classes to apply - unless overruled
7199
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 */
7200
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( typeof oInit.asStripClasses == 'undefined' && 
7201
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			     typeof oInit.asStripeClasses == 'undefined' )
7202
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
7203
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				oSettings.asStripeClasses.push( oSettings.oClasses.sStripeOdd );
7204
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				oSettings.asStripeClasses.push( oSettings.oClasses.sStripeEven );
7205
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
7206
 
7207
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Remove row stripe classes if they are already on the table row */
7208
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var bStripeRemove = false;
7209
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var anRows = $(this).children('tbody').children('tr');
7210
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			for ( i=0, iLen=oSettings.asStripeClasses.length ; i<iLen ; i++ )
7211
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
7212
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( anRows.filter(":lt(2)").hasClass( oSettings.asStripeClasses[i]) )
7213
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7214
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					bStripeRemove = true;
7215
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					break;
7216
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7217
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
7218
 
7219
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( bStripeRemove )
7220
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
7221
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Store the classes which we are about to remove so they can be readded on destory */
7222
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				oSettings.asDestroyStripes = [ '', '' ];
7223
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( $(anRows[0]).hasClass(oSettings.oClasses.sStripeOdd) )
7224
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7225
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings.asDestroyStripes[0] += oSettings.oClasses.sStripeOdd+" ";
7226
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7227
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( $(anRows[0]).hasClass(oSettings.oClasses.sStripeEven) )
7228
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7229
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings.asDestroyStripes[0] += oSettings.oClasses.sStripeEven;
7230
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7231
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( $(anRows[1]).hasClass(oSettings.oClasses.sStripeOdd) )
7232
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7233
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings.asDestroyStripes[1] += oSettings.oClasses.sStripeOdd+" ";
7234
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7235
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( $(anRows[1]).hasClass(oSettings.oClasses.sStripeEven) )
7236
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7237
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings.asDestroyStripes[1] += oSettings.oClasses.sStripeEven;
7238
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7239
 
7240
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				anRows.removeClass( oSettings.asStripeClasses.join(' ') );
7241
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
7242
 
7243
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/*
7244
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * Columns
7245
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * See if we should load columns automatically or use defined ones
7246
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 */
7247
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var anThs = [];
7248
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var aoColumnsInit;
7249
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var nThead = this.getElementsByTagName('thead');
7250
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( nThead.length !== 0 )
7251
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
7252
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnDetectHeader( oSettings.aoHeader, nThead[0] );
7253
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				anThs = _fnGetUniqueThs( oSettings );
7254
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
7255
 
7256
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* If not given a column array, generate one with nulls */
7257
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( typeof oInit.aoColumns == 'undefined' )
7258
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
7259
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				aoColumnsInit = [];
7260
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				for ( i=0, iLen=anThs.length ; i<iLen ; i++ )
7261
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7262
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					aoColumnsInit.push( null );
7263
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7264
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
7265
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			else
7266
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
7267
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				aoColumnsInit = oInit.aoColumns;
7268
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
7269
 
7270
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Add the columns */
7271
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			for ( i=0, iLen=aoColumnsInit.length ; i<iLen ; i++ )
7272
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
7273
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Check if we have column visibilty state to restore */
7274
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( typeof oInit.saved_aoColumns != 'undefined' && oInit.saved_aoColumns.length == iLen )
7275
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7276
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					if ( aoColumnsInit[i] === null )
7277
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
7278
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						aoColumnsInit[i] = {};
7279
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}
7280
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					aoColumnsInit[i].bVisible = oInit.saved_aoColumns[i].bVisible;
7281
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7282
 
7283
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnAddColumn( oSettings, anThs ? anThs[i] : null );
7284
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
7285
 
7286
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Add options from column definations */
7287
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( typeof oInit.aoColumnDefs != 'undefined' )
7288
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
7289
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Loop over the column defs array - loop in reverse so first instace has priority */
7290
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				for ( i=oInit.aoColumnDefs.length-1 ; i>=0 ; i-- )
7291
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7292
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					/* Each column def can target multiple columns, as it is an array */
7293
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					var aTargets = oInit.aoColumnDefs[i].aTargets;
7294
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					if ( !$.isArray( aTargets ) )
7295
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
7296
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						_fnLog( oSettings, 1, 'aTargets must be an array of targets, not a '+(typeof aTargets) );
7297
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}
7298
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					for ( j=0, jLen=aTargets.length ; j<jLen ; j++ )
7299
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
7300
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						if ( typeof aTargets[j] == 'number' && aTargets[j] >= 0 )
7301
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						{
7302
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							/* 0+ integer, left to right column counting. We add columns which are unknown
7303
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							 * automatically. Is this the right behaviour for this? We should at least
7304
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							 * log it in future. We cannot do this for the negative or class targets, only here.
7305
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							 */
7306
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							while( oSettings.aoColumns.length <= aTargets[j] )
7307
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							{
7308
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>								_fnAddColumn( oSettings );
7309
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							}
7310
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							_fnColumnOptions( oSettings, aTargets[j], oInit.aoColumnDefs[i] );
7311
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						}
7312
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						else if ( typeof aTargets[j] == 'number' && aTargets[j] < 0 )
7313
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						{
7314
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							/* Negative integer, right to left column counting */
7315
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							_fnColumnOptions( oSettings, oSettings.aoColumns.length+aTargets[j], 
7316
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>								oInit.aoColumnDefs[i] );
7317
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						}
7318
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						else if ( typeof aTargets[j] == 'string' )
7319
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						{
7320
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							/* Class name matching on TH element */
7321
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							for ( k=0, kLen=oSettings.aoColumns.length ; k<kLen ; k++ )
7322
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							{
7323
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>								if ( aTargets[j] == "_all" ||
7324
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>								     $(oSettings.aoColumns[k].nTh).hasClass( aTargets[j] ) )
7325
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>								{
7326
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>									_fnColumnOptions( oSettings, k, oInit.aoColumnDefs[i] );
7327
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>								}
7328
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>							}
7329
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						}
7330
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}
7331
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7332
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
7333
 
7334
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Add options from column array - after the defs array so this has priority */
7335
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( typeof aoColumnsInit != 'undefined' )
7336
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
7337
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				for ( i=0, iLen=aoColumnsInit.length ; i<iLen ; i++ )
7338
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7339
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					_fnColumnOptions( oSettings, i, aoColumnsInit[i] );
7340
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7341
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
7342
 
7343
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/*
7344
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * Sorting
7345
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * Check the aaSorting array
7346
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 */
7347
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			for ( i=0, iLen=oSettings.aaSorting.length ; i<iLen ; i++ )
7348
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
7349
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( oSettings.aaSorting[i][0] >= oSettings.aoColumns.length )
7350
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7351
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings.aaSorting[i][0] = 0;
7352
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7353
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				var oColumn = oSettings.aoColumns[ oSettings.aaSorting[i][0] ];
7354
 
7355
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Add a default sorting index */
7356
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( typeof oSettings.aaSorting[i][2] == 'undefined' )
7357
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7358
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings.aaSorting[i][2] = 0;
7359
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7360
 
7361
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* If aaSorting is not defined, then we use the first indicator in asSorting */
7362
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				if ( typeof oInit.aaSorting == "undefined" && 
7363
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						 typeof oSettings.saved_aaSorting == "undefined" )
7364
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7365
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					oSettings.aaSorting[i][1] = oColumn.asSorting[0];
7366
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7367
 
7368
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Set the current sorting index based on aoColumns.asSorting */
7369
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				for ( j=0, jLen=oColumn.asSorting.length ; j<jLen ; j++ )
7370
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7371
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					if ( oSettings.aaSorting[i][1] == oColumn.asSorting[j] )
7372
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					{
7373
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						oSettings.aaSorting[i][2] = j;
7374
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>						break;
7375
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					}
7376
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7377
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
7378
 
7379
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Do a first pass on the sorting classes (allows any size changes to be taken into
7380
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * account, and also will apply sorting disabled classes if disabled
7381
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 */
7382
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			_fnSortingClasses( oSettings );
7383
 
7384
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/*
7385
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * Final init
7386
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * Cache the header, body and footer as required, creating them if needed
7387
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 */
7388
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var thead = $(this).children('thead');
7389
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( thead.length === 0 )
7390
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
7391
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				thead = [ document.createElement( 'thead' ) ];
7392
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				this.appendChild( thead[0] );
7393
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
7394
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			oSettings.nTHead = thead[0];
7395
 
7396
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var tbody = $(this).children('tbody');
7397
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( tbody.length === 0 )
7398
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
7399
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				tbody = [ document.createElement( 'tbody' ) ];
7400
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				this.appendChild( tbody[0] );
7401
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
7402
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			oSettings.nTBody = tbody[0];
7403
 
7404
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			var tfoot = $(this).children('tfoot');
7405
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( tfoot.length > 0 )
7406
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
7407
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				oSettings.nTFoot = tfoot[0];
7408
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnDetectHeader( oSettings.aoFooter, oSettings.nTFoot );
7409
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
7410
 
7411
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Check if there is data passing into the constructor */
7412
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( bUsePassedData )
7413
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
7414
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				for ( i=0 ; i<oInit.aaData.length ; i++ )
7415
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				{
7416
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>					_fnAddData( oSettings, oInit.aaData[ i ] );
7417
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				}
7418
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
7419
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			else
7420
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
7421
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				/* Grab the data from the page */
7422
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnGatherData( oSettings );
7423
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
7424
 
7425
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Copy the data index array */
7426
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
7427
 
7428
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Initialisation complete - table can be drawn */
7429
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			oSettings.bInitialised = true;
7430
 
7431
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			/* Check if we need to initialise the table (it might not have been handed off to the
7432
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 * language processor)
7433
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			 */
7434
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			if ( bInitHandedOff === false )
7435
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			{
7436
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>				_fnInitialise( oSettings );
7437
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>			}
7438
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>		});
7439
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>	};
7440
< iPageCount)<= iPageCountHalf)<.*?><.*?><.*?><.*?><.*?>})(jQuery, window, document);