1 /*

     2  * File:        jquery.dataTables.js

     3  * Version:     1.7.4

     4  * Description: Paginate, search and sort HTML tables

     5  * Author:      Allan Jardine (www.sprymedia.co.uk)

     6  * Created:     28/3/2008

     7  * Language:    Javascript

     8  * License:     GPL v2 or BSD 3 point style

     9  * Project:     Mtaala

    10  * Contact:     allan.jardine@sprymedia.co.uk

    11  * 

    12  * Copyright 2008-2010 Allan Jardine, all rights reserved.

    13  *

    14  * This source file is free software, under either the GPL v2 license or a

    15  * BSD style license, as supplied with this software.

    16  * 

    17  * This source file is distributed in the hope that it will be useful, but 

    18  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 

    19  * or FITNESS FOR A PARTICULAR PURPOSE. See the license files for details.

    20  * 

    21  * For details please refer to: http://www.datatables.net

    22  */

    23 

    24 /*

    25  * When considering jsLint, we need to allow eval() as it it is used for reading cookies and 

    26  * building the dynamic multi-column sort functions.

    27  */

    28 /*jslint evil: true, undef: true, browser: true */

    29 /*globals $, jQuery,_fnExternApiFunc,_fnInitalise,_fnLanguageProcess,_fnAddColumn,_fnColumnOptions,_fnAddData,_fnGatherData,_fnDrawHead,_fnDraw,_fnReDraw,_fnAjaxUpdate,_fnAjaxUpdateDraw,_fnAddOptionsHtml,_fnFeatureHtmlTable,_fnScrollDraw,_fnAjustColumnSizing,_fnFeatureHtmlFilter,_fnFilterComplete,_fnFilterCustom,_fnFilterColumn,_fnFilter,_fnBuildSearchArray,_fnBuildSearchRow,_fnFilterCreateSearch,_fnDataToSearch,_fnSort,_fnSortAttachListener,_fnSortingClasses,_fnFeatureHtmlPaginate,_fnPageChange,_fnFeatureHtmlInfo,_fnUpdateInfo,_fnFeatureHtmlLength,_fnFeatureHtmlProcessing,_fnProcessingDisplay,_fnVisibleToColumnIndex,_fnColumnIndexToVisible,_fnNodeToDataIndex,_fnVisbleColumns,_fnCalculateEnd,_fnConvertToWidth,_fnCalculateColumnWidths,_fnScrollingWidthAdjust,_fnGetWidestNode,_fnGetMaxLenString,_fnStringToCss,_fnArrayCmp,_fnDetectType,_fnSettingsFromNode,_fnGetDataMaster,_fnGetTrNodes,_fnGetTdNodes,_fnEscapeRegex,_fnDeleteIndex,_fnReOrderIndex,_fnColumnOrdering,_fnLog,_fnClearTable,_fnSaveState,_fnLoadState,_fnCreateCookie,_fnReadCookie,_fnGetUniqueThs,_fnScrollBarWidth,_fnApplyToChildren,_fnMap*/

    30 

    31 (function($, window, document) {

    32 	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

    33 	 * Section - DataTables variables

    34 	 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

    35 	

    36 	/*

    37 	 * Variable: dataTableSettings

    38 	 * Purpose:  Store the settings for each dataTables instance

    39 	 * Scope:    jQuery.fn

    40 	 */

    41 	$.fn.dataTableSettings = [];

    42 	var _aoSettings = $.fn.dataTableSettings; /* Short reference for fast internal lookup */

    43 	

    44 	/*

    45 	 * Variable: dataTableExt

    46 	 * Purpose:  Container for customisable parts of DataTables

    47 	 * Scope:    jQuery.fn

    48 	 */

    49 	$.fn.dataTableExt = {};

    50 	var _oExt = $.fn.dataTableExt;

    51 	

    52 	

    53 	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

    54 	 * Section - DataTables extensible objects

    55 	 * 

    56 	 * The _oExt object is used to provide an area where user dfined plugins can be 

    57 	 * added to DataTables. The following properties of the object are used:

    58 	 *   oApi - Plug-in API functions

    59 	 *   aTypes - Auto-detection of types

    60 	 *   oSort - Sorting functions used by DataTables (based on the type)

    61 	 *   oPagination - Pagination functions for different input styles

    62 	 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

    63 	

    64 	/*

    65 	 * Variable: sVersion

    66 	 * Purpose:  Version string for plug-ins to check compatibility

    67 	 * Scope:    jQuery.fn.dataTableExt

    68 	 * Notes:    Allowed format is a.b.c.d.e where:

    69 	 *   a:int, b:int, c:int, d:string(dev|beta), e:int. d and e are optional

    70 	 */

    71 	_oExt.sVersion = "1.7.4";

    72 	

    73 	/*

    74 	 * Variable: sErrMode

    75 	 * Purpose:  How should DataTables report an error. Can take the value 'alert' or 'throw'

    76 	 * Scope:    jQuery.fn.dataTableExt

    77 	 */

    78 	_oExt.sErrMode = "alert";

    79 	

    80 	/*

    81 	 * Variable: iApiIndex

    82 	 * Purpose:  Index for what 'this' index API functions should use

    83 	 * Scope:    jQuery.fn.dataTableExt

    84 	 */

    85 	_oExt.iApiIndex = 0;

    86 	

    87 	/*

    88 	 * Variable: oApi

    89 	 * Purpose:  Container for plugin API functions

    90 	 * Scope:    jQuery.fn.dataTableExt

    91 	 */

    92 	_oExt.oApi = { };

    93 	

    94 	/*

    95 	 * Variable: aFiltering

    96 	 * Purpose:  Container for plugin filtering functions

    97 	 * Scope:    jQuery.fn.dataTableExt

    98 	 */

    99 	_oExt.afnFiltering = [ ];

   100 	

   101 	/*

   102 	 * Variable: aoFeatures

   103 	 * Purpose:  Container for plugin function functions

   104 	 * Scope:    jQuery.fn.dataTableExt

   105 	 * Notes:    Array of objects with the following parameters:

   106 	 *   fnInit: Function for initialisation of Feature. Takes oSettings and returns node

   107 	 *   cFeature: Character that will be matched in sDom - case sensitive

   108 	 *   sFeature: Feature name - just for completeness :-)

   109 	 */

   110 	_oExt.aoFeatures = [ ];

   111 	

   112 	/*

   113 	 * Variable: ofnSearch

   114 	 * Purpose:  Container for custom filtering functions

   115 	 * Scope:    jQuery.fn.dataTableExt

   116 	 * Notes:    This is an object (the name should match the type) for custom filtering function,

   117 	 *   which can be used for live DOM checking or formatted text filtering

   118 	 */

   119 	_oExt.ofnSearch = { };

   120 	

   121 	/*

   122 	 * Variable: afnSortData

   123 	 * Purpose:  Container for custom sorting data source functions

   124 	 * Scope:    jQuery.fn.dataTableExt

   125 	 * Notes:    Array (associative) of functions which is run prior to a column of this 

   126 	 *   'SortDataType' being sorted upon.

   127 	 *   Function input parameters:

   128 	 *     object:oSettings-  DataTables settings object

   129 	 *     int:iColumn - Target column number

   130 	 *   Return value: Array of data which exactly matched the full data set size for the column to

   131 	 *     be sorted upon

   132 	 */

   133 	_oExt.afnSortData = [ ];

   134 	

   135 	/*

   136 	 * Variable: oStdClasses

   137 	 * Purpose:  Storage for the various classes that DataTables uses

   138 	 * Scope:    jQuery.fn.dataTableExt

   139 	 */

   140 	_oExt.oStdClasses = {

   141 		/* Two buttons buttons */

   142 		"sPagePrevEnabled": "paginate_enabled_previous",

   143 		"sPagePrevDisabled": "paginate_disabled_previous",

   144 		"sPageNextEnabled": "paginate_enabled_next",

   145 		"sPageNextDisabled": "paginate_disabled_next",

   146 		"sPageJUINext": "",

   147 		"sPageJUIPrev": "",

   148 		

   149 		/* Full numbers paging buttons */

   150 		"sPageButton": "paginate_button",

   151 		"sPageButtonActive": "paginate_active",

   152 		"sPageButtonStaticDisabled": "paginate_button",

   153 		"sPageFirst": "first",

   154 		"sPagePrevious": "previous",

   155 		"sPageNext": "next",

   156 		"sPageLast": "last",

   157 		

   158 		/* Stripping classes */

   159 		"sStripOdd": "odd",

   160 		"sStripEven": "even",

   161 		

   162 		/* Empty row */

   163 		"sRowEmpty": "dataTables_empty",

   164 		

   165 		/* Features */

   166 		"sWrapper": "dataTables_wrapper",

   167 		"sFilter": "dataTables_filter",

   168 		"sInfo": "dataTables_info",

   169 		"sPaging": "dataTables_paginate paging_", /* Note that the type is postfixed */

   170 		"sLength": "dataTables_length",

   171 		"sProcessing": "dataTables_processing",

   172 		

   173 		/* Sorting */

   174 		"sSortAsc": "sorting_asc",

   175 		"sSortDesc": "sorting_desc",

   176 		"sSortable": "sorting", /* Sortable in both directions */

   177 		"sSortableAsc": "sorting_asc_disabled",

   178 		"sSortableDesc": "sorting_desc_disabled",

   179 		"sSortableNone": "sorting_disabled",

   180 		"sSortColumn": "sorting_", /* Note that an int is postfixed for the sorting order */

   181 		"sSortJUIAsc": "",

   182 		"sSortJUIDesc": "",

   183 		"sSortJUI": "",

   184 		"sSortJUIAscAllowed": "",

   185 		"sSortJUIDescAllowed": "",

   186 		"sSortJUIWrapper": "",

   187 		

   188 		/* Scrolling */

   189 		"sScrollWrapper": "dataTables_scroll",

   190 		"sScrollHead": "dataTables_scrollHead",

   191 		"sScrollHeadInner": "dataTables_scrollHeadInner",

   192 		"sScrollBody": "dataTables_scrollBody",

   193 		"sScrollFoot": "dataTables_scrollFoot",

   194 		"sScrollFootInner": "dataTables_scrollFootInner",

   195 		

   196 		/* Misc */

   197 		"sFooterTH": ""

   198 	};

   199 	

   200 	/*

   201 	 * Variable: oJUIClasses

   202 	 * Purpose:  Storage for the various classes that DataTables uses - jQuery UI suitable

   203 	 * Scope:    jQuery.fn.dataTableExt

   204 	 */

   205 	_oExt.oJUIClasses = {

   206 		/* Two buttons buttons */

   207 		"sPagePrevEnabled": "fg-button ui-button ui-state-default ui-corner-left",

   208 		"sPagePrevDisabled": "fg-button ui-button ui-state-default ui-corner-left ui-state-disabled",

   209 		"sPageNextEnabled": "fg-button ui-button ui-state-default ui-corner-right",

   210 		"sPageNextDisabled": "fg-button ui-button ui-state-default ui-corner-right ui-state-disabled",

   211 		"sPageJUINext": "ui-icon ui-icon-circle-arrow-e",

   212 		"sPageJUIPrev": "ui-icon ui-icon-circle-arrow-w",

   213 		

   214 		/* Full numbers paging buttons */

   215 		"sPageButton": "fg-button ui-button ui-state-default",

   216 		"sPageButtonActive": "fg-button ui-button ui-state-default ui-state-disabled",

   217 		"sPageButtonStaticDisabled": "fg-button ui-button ui-state-default ui-state-disabled",

   218 		"sPageFirst": "first ui-corner-tl ui-corner-bl",

   219 		"sPagePrevious": "previous",

   220 		"sPageNext": "next",

   221 		"sPageLast": "last ui-corner-tr ui-corner-br",

   222 		

   223 		/* Stripping classes */

   224 		"sStripOdd": "odd",

   225 		"sStripEven": "even",

   226 		

   227 		/* Empty row */

   228 		"sRowEmpty": "dataTables_empty",

   229 		

   230 		/* Features */

   231 		"sWrapper": "dataTables_wrapper",

   232 		"sFilter": "dataTables_filter",

   233 		"sInfo": "dataTables_info",

   234 		"sPaging": "dataTables_paginate fg-buttonset ui-buttonset fg-buttonset-multi "+

   235 			"ui-buttonset-multi paging_", /* Note that the type is postfixed */

   236 		"sLength": "dataTables_length",

   237 		"sProcessing": "dataTables_processing",

   238 		

   239 		/* Sorting */

   240 		"sSortAsc": "ui-state-default",

   241 		"sSortDesc": "ui-state-default",

   242 		"sSortable": "ui-state-default",

   243 		"sSortableAsc": "ui-state-default",

   244 		"sSortableDesc": "ui-state-default",

   245 		"sSortableNone": "ui-state-default",

   246 		"sSortColumn": "sorting_", /* Note that an int is postfixed for the sorting order */

   247 		"sSortJUIAsc": "css_right ui-icon ui-icon-triangle-1-n",

   248 		"sSortJUIDesc": "css_right ui-icon ui-icon-triangle-1-s",

   249 		"sSortJUI": "css_right ui-icon ui-icon-carat-2-n-s",

   250 		"sSortJUIAscAllowed": "css_right ui-icon ui-icon-carat-1-n",

   251 		"sSortJUIDescAllowed": "css_right ui-icon ui-icon-carat-1-s",

   252 		"sSortJUIWrapper": "DataTables_sort_wrapper",

   253 		

   254 		/* Scrolling */

   255 		"sScrollWrapper": "dataTables_scroll",

   256 		"sScrollHead": "dataTables_scrollHead ui-state-default",

   257 		"sScrollHeadInner": "dataTables_scrollHeadInner",

   258 		"sScrollBody": "dataTables_scrollBody",

   259 		"sScrollFoot": "dataTables_scrollFoot ui-state-default",

   260 		"sScrollFootInner": "dataTables_scrollFootInner",

   261 		

   262 		/* Misc */

   263 		"sFooterTH": "ui-state-default"

   264 	};

   265 	

   266 	/*

   267 	 * Variable: oPagination

   268 	 * Purpose:  Container for the various type of pagination that dataTables supports

   269 	 * Scope:    jQuery.fn.dataTableExt

   270 	 */

   271 	_oExt.oPagination = {

   272 		/*

   273 		 * Variable: two_button

   274 		 * Purpose:  Standard two button (forward/back) pagination

   275 	 	 * Scope:    jQuery.fn.dataTableExt.oPagination

   276 		 */

   277 		"two_button": {

   278 			/*

   279 			 * Function: oPagination.two_button.fnInit

   280 			 * Purpose:  Initalise dom elements required for pagination with forward/back buttons only

   281 			 * Returns:  -

   282 	 		 * Inputs:   object:oSettings - dataTables settings object

   283 	     *           node:nPaging - the DIV which contains this pagination control

   284 			 *           function:fnCallbackDraw - draw function which must be called on update

   285 			 */

   286 			"fnInit": function ( oSettings, nPaging, fnCallbackDraw )

   287 			{

   288 				var nPrevious, nNext, nPreviousInner, nNextInner;

   289 				

   290 				/* Store the next and previous elements in the oSettings object as they can be very

   291 				 * usful for automation - particularly testing

   292 				 */

   293 				if ( !oSettings.bJUI )

   294 				{

   295 					nPrevious = document.createElement( 'div' );

   296 					nNext = document.createElement( 'div' );

   297 				}

   298 				else

   299 				{

   300 					nPrevious = document.createElement( 'a' );

   301 					nNext = document.createElement( 'a' );

   302 					

   303 					nNextInner = document.createElement('span');

   304 					nNextInner.className = oSettings.oClasses.sPageJUINext;

   305 					nNext.appendChild( nNextInner );

   306 					

   307 					nPreviousInner = document.createElement('span');

   308 					nPreviousInner.className = oSettings.oClasses.sPageJUIPrev;

   309 					nPrevious.appendChild( nPreviousInner );

   310 				}

   311 				

   312 				nPrevious.className = oSettings.oClasses.sPagePrevDisabled;

   313 				nNext.className = oSettings.oClasses.sPageNextDisabled;

   314 				

   315 				nPrevious.title = oSettings.oLanguage.oPaginate.sPrevious;

   316 				nNext.title = oSettings.oLanguage.oPaginate.sNext;

   317 				

   318 				nPaging.appendChild( nPrevious );

   319 				nPaging.appendChild( nNext );

   320 				

   321 				$(nPrevious).click( function() {

   322 					if ( oSettings.oApi._fnPageChange( oSettings, "previous" ) )

   323 					{

   324 						/* Only draw when the page has actually changed */

   325 						fnCallbackDraw( oSettings );

   326 					}

   327 				} );

   328 				

   329 				$(nNext).click( function() {

   330 					if ( oSettings.oApi._fnPageChange( oSettings, "next" ) )

   331 					{

   332 						fnCallbackDraw( oSettings );

   333 					}

   334 				} );

   335 				

   336 				/* Take the brutal approach to cancelling text selection */

   337 				$(nPrevious).bind( 'selectstart', function () { return false; } );

   338 				$(nNext).bind( 'selectstart', function () { return false; } );

   339 				

   340 				/* ID the first elements only */

   341 				if ( oSettings.sTableId !== '' && typeof oSettings.aanFeatures.p == "undefined" )

   342 				{

   343 					nPaging.setAttribute( 'id', oSettings.sTableId+'_paginate' );

   344 					nPrevious.setAttribute( 'id', oSettings.sTableId+'_previous' );

   345 					nNext.setAttribute( 'id', oSettings.sTableId+'_next' );

   346 				}

   347 			},

   348 			

   349 			/*

   350 			 * Function: oPagination.two_button.fnUpdate

   351 			 * Purpose:  Update the two button pagination at the end of the draw

   352 			 * Returns:  -

   353 	 		 * Inputs:   object:oSettings - dataTables settings object

   354 			 *           function:fnCallbackDraw - draw function to call on page change

   355 			 */

   356 			"fnUpdate": function ( oSettings, fnCallbackDraw )

   357 			{

   358 				if ( !oSettings.aanFeatures.p )

   359 				{

   360 					return;

   361 				}

   362 				

   363 				/* Loop over each instance of the pager */

   364 				var an = oSettings.aanFeatures.p;

   365 				for ( var i=0, iLen=an.length ; i<iLen ; i++ )

   366 				{

   367 					if ( an[i].childNodes.length !== 0 )

   368 					{

   369 						an[i].childNodes[0].className = 

   370 							( oSettings._iDisplayStart === 0 ) ? 

   371 							oSettings.oClasses.sPagePrevDisabled : oSettings.oClasses.sPagePrevEnabled;

   372 						

   373 						an[i].childNodes[1].className = 

   374 							( oSettings.fnDisplayEnd() == oSettings.fnRecordsDisplay() ) ? 

   375 							oSettings.oClasses.sPageNextDisabled : oSettings.oClasses.sPageNextEnabled;

   376 					}

   377 				}

   378 			}

   379 		},

   380 		

   381 		

   382 		/*

   383 		 * Variable: iFullNumbersShowPages

   384 		 * Purpose:  Change the number of pages which can be seen

   385 	 	 * Scope:    jQuery.fn.dataTableExt.oPagination

   386 		 */

   387 		"iFullNumbersShowPages": 5,

   388 		

   389 		/*

   390 		 * Variable: full_numbers

   391 		 * Purpose:  Full numbers pagination

   392 	 	 * Scope:    jQuery.fn.dataTableExt.oPagination

   393 		 */

   394 		"full_numbers": {

   395 			/*

   396 			 * Function: oPagination.full_numbers.fnInit

   397 			 * Purpose:  Initalise dom elements required for pagination with a list of the pages

   398 			 * Returns:  -

   399 	 		 * Inputs:   object:oSettings - dataTables settings object

   400 	     *           node:nPaging - the DIV which contains this pagination control

   401 			 *           function:fnCallbackDraw - draw function which must be called on update

   402 			 */

   403 			"fnInit": function ( oSettings, nPaging, fnCallbackDraw )

   404 			{

   405 				var nFirst = document.createElement( 'span' );

   406 				var nPrevious = document.createElement( 'span' );

   407 				var nList = document.createElement( 'span' );

   408 				var nNext = document.createElement( 'span' );

   409 				var nLast = document.createElement( 'span' );

   410 				

   411 				nFirst.innerHTML = oSettings.oLanguage.oPaginate.sFirst;

   412 				nPrevious.innerHTML = oSettings.oLanguage.oPaginate.sPrevious;

   413 				nNext.innerHTML = oSettings.oLanguage.oPaginate.sNext;

   414 				nLast.innerHTML = oSettings.oLanguage.oPaginate.sLast;

   415 				

   416 				var oClasses = oSettings.oClasses;

   417 				nFirst.className = oClasses.sPageButton+" "+oClasses.sPageFirst;

   418 				nPrevious.className = oClasses.sPageButton+" "+oClasses.sPagePrevious;

   419 				nNext.className= oClasses.sPageButton+" "+oClasses.sPageNext;

   420 				nLast.className = oClasses.sPageButton+" "+oClasses.sPageLast;

   421 				

   422 				nPaging.appendChild( nFirst );

   423 				nPaging.appendChild( nPrevious );

   424 				nPaging.appendChild( nList );

   425 				nPaging.appendChild( nNext );

   426 				nPaging.appendChild( nLast );

   427 				

   428 				$(nFirst).click( function () {

   429 					if ( oSettings.oApi._fnPageChange( oSettings, "first" ) )

   430 					{

   431 						fnCallbackDraw( oSettings );

   432 					}

   433 				} );

   434 				

   435 				$(nPrevious).click( function() {

   436 					if ( oSettings.oApi._fnPageChange( oSettings, "previous" ) )

   437 					{

   438 						fnCallbackDraw( oSettings );

   439 					}

   440 				} );

   441 				

   442 				$(nNext).click( function() {

   443 					if ( oSettings.oApi._fnPageChange( oSettings, "next" ) )

   444 					{

   445 						fnCallbackDraw( oSettings );

   446 					}

   447 				} );

   448 				

   449 				$(nLast).click( function() {

   450 					if ( oSettings.oApi._fnPageChange( oSettings, "last" ) )

   451 					{

   452 						fnCallbackDraw( oSettings );

   453 					}

   454 				} );

   455 				

   456 				/* Take the brutal approach to cancelling text selection */

   457 				$('span', nPaging)

   458 					.bind( 'mousedown', function () { return false; } )

   459 					.bind( 'selectstart', function () { return false; } );

   460 				

   461 				/* ID the first elements only */

   462 				if ( oSettings.sTableId !== '' && typeof oSettings.aanFeatures.p == "undefined" )

   463 				{

   464 					nPaging.setAttribute( 'id', oSettings.sTableId+'_paginate' );

   465 					nFirst.setAttribute( 'id', oSettings.sTableId+'_first' );

   466 					nPrevious.setAttribute( 'id', oSettings.sTableId+'_previous' );

   467 					nNext.setAttribute( 'id', oSettings.sTableId+'_next' );

   468 					nLast.setAttribute( 'id', oSettings.sTableId+'_last' );

   469 				}

   470 			},

   471 			

   472 			/*

   473 			 * Function: oPagination.full_numbers.fnUpdate

   474 			 * Purpose:  Update the list of page buttons shows

   475 			 * Returns:  -

   476 	 		 * Inputs:   object:oSettings - dataTables settings object

   477 			 *           function:fnCallbackDraw - draw function to call on page change

   478 			 */

   479 			"fnUpdate": function ( oSettings, fnCallbackDraw )

   480 			{

   481 				if ( !oSettings.aanFeatures.p )

   482 				{

   483 					return;

   484 				}

   485 				

   486 				var iPageCount = _oExt.oPagination.iFullNumbersShowPages;

   487 				var iPageCountHalf = Math.floor(iPageCount / 2);

   488 				var iPages = Math.ceil((oSettings.fnRecordsDisplay()) / oSettings._iDisplayLength);

   489 				var iCurrentPage = Math.ceil(oSettings._iDisplayStart / oSettings._iDisplayLength) + 1;

   490 				var sList = "";

   491 				var iStartButton, iEndButton, i, iLen;

   492 				var oClasses = oSettings.oClasses;

   493 				

   494 				/* Pages calculation */

   495 				if (iPages < iPageCount)

   496 				{

   497 					iStartButton = 1;

   498 					iEndButton = iPages;

   499 				}

   500 				else

   501 				{

   502 					if (iCurrentPage <= iPageCountHalf)

   503 					{

   504 						iStartButton = 1;

   505 						iEndButton = iPageCount;

   506 					}

   507 					else

   508 					{

   509 						if (iCurrentPage >= (iPages - iPageCountHalf))

   510 						{

   511 							iStartButton = iPages - iPageCount + 1;

   512 							iEndButton = iPages;

   513 						}

   514 						else

   515 						{

   516 							iStartButton = iCurrentPage - Math.ceil(iPageCount / 2) + 1;

   517 							iEndButton = iStartButton + iPageCount - 1;

   518 						}

   519 					}

   520 				}

   521 				

   522 				/* Build the dynamic list */

   523 				for ( i=iStartButton ; i<=iEndButton ; i++ )

   524 				{

   525 					if ( iCurrentPage != i )

   526 					{

   527 						sList += '<span class="'+oClasses.sPageButton+'">'+i+'</span>';

   528 					}

   529 					else

   530 					{

   531 						sList += '<span class="'+oClasses.sPageButtonActive+'">'+i+'</span>';

   532 					}

   533 				}

   534 				

   535 				/* Loop over each instance of the pager */

   536 				var an = oSettings.aanFeatures.p;

   537 				var anButtons, anStatic, nPaginateList;

   538 				var fnClick = function() {

   539 					/* Use the information in the element to jump to the required page */

   540 					var iTarget = (this.innerHTML * 1) - 1;

   541 					oSettings._iDisplayStart = iTarget * oSettings._iDisplayLength;

   542 					fnCallbackDraw( oSettings );

   543 					return false;

   544 				};

   545 				var fnFalse = function () { return false; };

   546 				

   547 				for ( i=0, iLen=an.length ; i<iLen ; i++ )

   548 				{

   549 					if ( an[i].childNodes.length === 0 )

   550 					{

   551 						continue;

   552 					}

   553 					

   554 					/* Build up the dynamic list forst - html and listeners */

   555 					var qjPaginateList = $('span:eq(2)', an[i]);

   556 					qjPaginateList.html( sList );

   557 					$('span', qjPaginateList).click( fnClick ).bind( 'mousedown', fnFalse )

   558 						.bind( 'selectstart', fnFalse );

   559 					

   560 					/* Update the 'premanent botton's classes */

   561 					anButtons = an[i].getElementsByTagName('span');

   562 					anStatic = [

   563 						anButtons[0], anButtons[1], 

   564 						anButtons[anButtons.length-2], anButtons[anButtons.length-1]

   565 					];

   566 					$(anStatic).removeClass( oClasses.sPageButton+" "+oClasses.sPageButtonActive+" "+oClasses.sPageButtonStaticDisabled );

   567 					if ( iCurrentPage == 1 )

   568 					{

   569 						anStatic[0].className += " "+oClasses.sPageButtonStaticDisabled;

   570 						anStatic[1].className += " "+oClasses.sPageButtonStaticDisabled;

   571 					}

   572 					else

   573 					{

   574 						anStatic[0].className += " "+oClasses.sPageButton;

   575 						anStatic[1].className += " "+oClasses.sPageButton;

   576 					}

   577 					

   578 					if ( iPages === 0 || iCurrentPage == iPages || oSettings._iDisplayLength == -1 )

   579 					{

   580 						anStatic[2].className += " "+oClasses.sPageButtonStaticDisabled;

   581 						anStatic[3].className += " "+oClasses.sPageButtonStaticDisabled;

   582 					}

   583 					else

   584 					{

   585 						anStatic[2].className += " "+oClasses.sPageButton;

   586 						anStatic[3].className += " "+oClasses.sPageButton;

   587 					}

   588 				}

   589 			}

   590 		}

   591 	};

   592 	

   593 	/*

   594 	 * Variable: oSort

   595 	 * Purpose:  Wrapper for the sorting functions that can be used in DataTables

   596 	 * Scope:    jQuery.fn.dataTableExt

   597 	 * Notes:    The functions provided in this object are basically standard javascript sort

   598 	 *   functions - they expect two inputs which they then compare and then return a priority

   599 	 *   result. For each sort method added, two functions need to be defined, an ascending sort and

   600 	 *   a descending sort.

   601 	 */

   602 	_oExt.oSort = {

   603 		/*

   604 		 * text sorting

   605 		 */

   606 		"string-asc": function ( a, b )

   607 		{

   608 			var x = a.toLowerCase();

   609 			var y = b.toLowerCase();

   610 			return ((x < y) ? -1 : ((x > y) ? 1 : 0));

   611 		},

   612 		

   613 		"string-desc": function ( a, b )

   614 		{

   615 			var x = a.toLowerCase();

   616 			var y = b.toLowerCase();

   617 			return ((x < y) ? 1 : ((x > y) ? -1 : 0));

   618 		},

   619 		

   620 		

   621 		/*

   622 		 * html sorting (ignore html tags)

   623 		 */

   624 		"html-asc": function ( a, b )

   625 		{

   626 			var x = a.replace( /<.*?>/g, "" ).toLowerCase();

   627 			var y = b.replace( /<.*?>/g, "" ).toLowerCase();

   628 			return ((x < y) ? -1 : ((x > y) ? 1 : 0));

   629 		},

   630 		

   631 		"html-desc": function ( a, b )

   632 		{

   633 			var x = a.replace( /<.*?>/g, "" ).toLowerCase();

   634 			var y = b.replace( /<.*?>/g, "" ).toLowerCase();

   635 			return ((x < y) ? 1 : ((x > y) ? -1 : 0));

   636 		},

   637 		

   638 		

   639 		/*

   640 		 * date sorting

   641 		 */

   642 		"date-asc": function ( a, b )

   643 		{

   644 			var x = Date.parse( a );

   645 			var y = Date.parse( b );

   646 			

   647 			if ( isNaN(x) || x==="" )

   648 			{

   649     		x = Date.parse( "01/01/1970 00:00:00" );

   650 			}

   651 			if ( isNaN(y) || y==="" )

   652 			{

   653 				y =	Date.parse( "01/01/1970 00:00:00" );

   654 			}

   655 			

   656 			return x - y;

   657 		},

   658 		

   659 		"date-desc": function ( a, b )

   660 		{

   661 			var x = Date.parse( a );

   662 			var y = Date.parse( b );

   663 			

   664 			if ( isNaN(x) || x==="" )

   665 			{

   666     		x = Date.parse( "01/01/1970 00:00:00" );

   667 			}

   668 			if ( isNaN(y) || y==="" )

   669 			{

   670 				y =	Date.parse( "01/01/1970 00:00:00" );

   671 			}

   672 			

   673 			return y - x;

   674 		},

   675 		

   676 		

   677 		/*

   678 		 * numerical sorting

   679 		 */

   680 		"numeric-asc": function ( a, b )

   681 		{

   682 			var x = (a=="-" || a==="") ? 0 : a*1;

   683 			var y = (b=="-" || b==="") ? 0 : b*1;

   684 			return x - y;

   685 		},

   686 		

   687 		"numeric-desc": function ( a, b )

   688 		{

   689 			var x = (a=="-" || a==="") ? 0 : a*1;

   690 			var y = (b=="-" || b==="") ? 0 : b*1;

   691 			return y - x;

   692 		}

   693 	};

   694 	

   695 	

   696 	/*

   697 	 * Variable: aTypes

   698 	 * Purpose:  Container for the various type of type detection that dataTables supports

   699 	 * Scope:    jQuery.fn.dataTableExt

   700 	 * Notes:    The functions in this array are expected to parse a string to see if it is a data

   701 	 *   type that it recognises. If so then the function should return the name of the type (a

   702 	 *   corresponding sort function should be defined!), if the type is not recognised then the

   703 	 *   function should return null such that the parser and move on to check the next type.

   704 	 *   Note that ordering is important in this array - the functions are processed linearly,

   705 	 *   starting at index 0.

   706 	 *   Note that the input for these functions is always a string! It cannot be any other data

   707 	 *   type

   708 	 */

   709 	_oExt.aTypes = [

   710 		/*

   711 		 * Function: -

   712 		 * Purpose:  Check to see if a string is numeric

   713 		 * Returns:  string:'numeric' or null

   714 		 * Inputs:   string:sText - string to check

   715 		 */

   716 		function ( sData )

   717 		{

   718 			/* Allow zero length strings as a number */

   719 			if ( sData.length === 0 )

   720 			{

   721 				return 'numeric';

   722 			}

   723 			

   724 			var sValidFirstChars = "0123456789-";

   725 			var sValidChars = "0123456789.";

   726 			var Char;

   727 			var bDecimal = false;

   728 			

   729 			/* Check for a valid first char (no period and allow negatives) */

   730 			Char = sData.charAt(0); 

   731 			if (sValidFirstChars.indexOf(Char) == -1) 

   732 			{

   733 				return null;

   734 			}

   735 			

   736 			/* Check all the other characters are valid */

   737 			for ( var i=1 ; i<sData.length ; i++ ) 

   738 			{

   739 				Char = sData.charAt(i); 

   740 				if (sValidChars.indexOf(Char) == -1) 

   741 				{

   742 					return null;

   743 				}

   744 				

   745 				/* Only allowed one decimal place... */

   746 				if ( Char == "." )

   747 				{

   748 					if ( bDecimal )

   749 					{

   750 						return null;

   751 					}

   752 					bDecimal = true;

   753 				}

   754 			}

   755 			

   756 			return 'numeric';

   757 		},

   758 		

   759 		/*

   760 		 * Function: -

   761 		 * Purpose:  Check to see if a string is actually a formatted date

   762 		 * Returns:  string:'date' or null

   763 		 * Inputs:   string:sText - string to check

   764 		 */

   765 		function ( sData )

   766 		{

   767 			var iParse = Date.parse(sData);

   768 			if ( (iParse !== null && !isNaN(iParse)) || sData.length === 0 )

   769 			{

   770 				return 'date';

   771 			}

   772 			return null;

   773 		},

   774 		

   775 		/*

   776 		 * Function: -

   777 		 * Purpose:  Check to see if a string should be treated as an HTML string

   778 		 * Returns:  string:'html' or null

   779 		 * Inputs:   string:sText - string to check

   780 		 */

   781 		function ( sData )

   782 		{

   783 			if ( sData.indexOf('<') != -1 && sData.indexOf('>') != -1 )

   784 			{

   785 				return 'html';

   786 			}

   787 			return null;

   788 		}

   789 	];

   790 	

   791 	/*

   792 	 * Function: fnVersionCheck

   793 	 * Purpose:  Check a version string against this version of DataTables. Useful for plug-ins

   794 	 * Returns:  bool:true -this version of DataTables is greater or equal to the required version

   795 	 *                false -this version of DataTales is not suitable

   796 	 * Inputs:   string:sVersion - the version to check against. May be in the following formats:

   797 	 *             "a", "a.b" or "a.b.c"

   798 	 * Notes:    This function will only check the first three parts of a version string. It is

   799 	 *   assumed that beta and dev versions will meet the requirements. This might change in future

   800 	 */

   801 	_oExt.fnVersionCheck = function( sVersion )

   802 	{

   803 		/* This is cheap, but very effective */

   804 		var fnZPad = function (Zpad, count)

   805 		{

   806 			while(Zpad.length < count) {

   807 				Zpad += '0';

   808 			}

   809 			return Zpad;

   810 		};

   811 		var aThis = _oExt.sVersion.split('.');

   812 		var aThat = sVersion.split('.');

   813 		var sThis = '', sThat = '';

   814 		

   815 		for ( var i=0, iLen=aThat.length ; i<iLen ; i++ )

   816 		{

   817 			sThis += fnZPad( aThis[i], 3 );

   818 			sThat += fnZPad( aThat[i], 3 );

   819 		}

   820 		

   821 		return parseInt(sThis, 10) >= parseInt(sThat, 10);

   822 	};

   823 	

   824 	/*

   825 	 * Variable: _oExternConfig

   826 	 * Purpose:  Store information for DataTables to access globally about other instances

   827 	 * Scope:    jQuery.fn.dataTableExt

   828 	 */

   829 	_oExt._oExternConfig = {

   830 		/* int:iNextUnique - next unique number for an instance */

   831 		"iNextUnique": 0

   832 	};

   833 	

   834 	

   835 	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

   836 	 * Section - DataTables prototype

   837 	 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

   838 	

   839 	/*

   840 	 * Function: dataTable

   841 	 * Purpose:  DataTables information

   842 	 * Returns:  -

   843 	 * Inputs:   object:oInit - initalisation options for the table

   844 	 */

   845 	$.fn.dataTable = function( oInit )

   846 	{

   847 		/*

   848 		 * Function: classSettings

   849 		 * Purpose:  Settings container function for all 'class' properties which are required

   850 		 *   by dataTables

   851 		 * Returns:  -

   852 		 * Inputs:   -

   853 		 */

   854 		function classSettings ()

   855 		{

   856 			this.fnRecordsTotal = function ()

   857 			{

   858 				if ( this.oFeatures.bServerSide ) {

   859 					return parseInt(this._iRecordsTotal, 10);

   860 				} else {

   861 					return this.aiDisplayMaster.length;

   862 				}

   863 			};

   864 			

   865 			this.fnRecordsDisplay = function ()

   866 			{

   867 				if ( this.oFeatures.bServerSide ) {

   868 					return parseInt(this._iRecordsDisplay, 10);

   869 				} else {

   870 					return this.aiDisplay.length;

   871 				}

   872 			};

   873 			

   874 			this.fnDisplayEnd = function ()

   875 			{

   876 				if ( this.oFeatures.bServerSide ) {

   877 					if ( this.oFeatures.bPaginate === false || this._iDisplayLength == -1 ) {

   878 						return this._iDisplayStart+this.aiDisplay.length;

   879 					} else {

   880 						return Math.min( this._iDisplayStart+this._iDisplayLength, 

   881 							this._iRecordsDisplay );

   882 					}

   883 				} else {

   884 					return this._iDisplayEnd;

   885 				}

   886 			};

   887 			

   888 			/*

   889 			 * Variable: oInstance

   890 			 * Purpose:  The DataTables object for this table

   891 			 * Scope:    jQuery.dataTable.classSettings 

   892 			 */

   893 			this.oInstance = null;

   894 			

   895 			/*

   896 			 * Variable: sInstance

   897 			 * Purpose:  Unique idendifier for each instance of the DataTables object

   898 			 * Scope:    jQuery.dataTable.classSettings 

   899 			 */

   900 			this.sInstance = null;

   901 			

   902 			/*

   903 			 * Variable: oFeatures

   904 			 * Purpose:  Indicate the enablement of key dataTable features

   905 			 * Scope:    jQuery.dataTable.classSettings 

   906 			 */

   907 			this.oFeatures = {

   908 				"bPaginate": true,

   909 				"bLengthChange": true,

   910 				"bFilter": true,

   911 				"bSort": true,

   912 				"bInfo": true,

   913 				"bAutoWidth": true,

   914 				"bProcessing": false,

   915 				"bSortClasses": true,

   916 				"bStateSave": false,

   917 				"bServerSide": false

   918 			};

   919 			

   920 			/*

   921 			 * Variable: oScroll

   922 			 * Purpose:  Container for scrolling options

   923 			 * Scope:    jQuery.dataTable.classSettings 

   924 			 */

   925 			this.oScroll = {

   926 				"sX": "",

   927 				"sXInner": "",

   928 				"sY": "",

   929 				"bCollapse": false,

   930 				"bInfinite": false,

   931 				"iLoadGap": 100,

   932 				"iBarWidth": 0

   933 			};

   934 			

   935 			/*

   936 			 * Variable: aanFeatures

   937 			 * Purpose:  Array referencing the nodes which are used for the features

   938 			 * Scope:    jQuery.dataTable.classSettings 

   939 			 * Notes:    The parameters of this object match what is allowed by sDom - i.e.

   940 			 *   'l' - Length changing

   941 			 *   'f' - Filtering input

   942 			 *   't' - The table!

   943 			 *   'i' - Information

   944 			 *   'p' - Pagination

   945 			 *   'r' - pRocessing

   946 			 */

   947 			this.aanFeatures = [];

   948 			

   949 			/*

   950 			 * Variable: oLanguage

   951 			 * Purpose:  Store the language strings used by dataTables

   952 			 * Scope:    jQuery.dataTable.classSettings

   953 			 * Notes:    The words in the format _VAR_ are variables which are dynamically replaced

   954 			 *   by javascript

   955 			 */

   956 			this.oLanguage = {

   957 				"sProcessing": "Processing...",

   958 				"sLengthMenu": "Show _MENU_ entries",

   959 				"sZeroRecords": "No matching records found",

   960 				"sEmptyTable": "No data available in table",

   961 				"sInfo": "Showing _START_ to _END_ of _TOTAL_ entries",

   962 				"sInfoEmpty": "Showing 0 to 0 of 0 entries",

   963 				"sInfoFiltered": "(filtered from _MAX_ total entries)",

   964 				"sInfoPostFix": "",

   965 				"sSearch": "Search:",

   966 				"sUrl": "",

   967 				"oPaginate": {

   968 					"sFirst":    "First",

   969 					"sPrevious": "Previous",

   970 					"sNext":     "Next",

   971 					"sLast":     "Last"

   972 				},

   973 				"fnInfoCallback": null

   974 			};

   975 			

   976 			/*

   977 			 * Variable: aoData

   978 			 * Purpose:  Store data information

   979 			 * Scope:    jQuery.dataTable.classSettings 

   980 			 * Notes:    This is an array of objects with the following parameters:

   981 			 *   int: _iId - internal id for tracking

   982 			 *   array: _aData - internal data - used for sorting / filtering etc

   983 			 *   node: nTr - display node

   984 			 *   array node: _anHidden - hidden TD nodes

   985 			 *   string: _sRowStripe

   986 			 */

   987 			this.aoData = [];

   988 			

   989 			/*

   990 			 * Variable: aiDisplay

   991 			 * Purpose:  Array of indexes which are in the current display (after filtering etc)

   992 			 * Scope:    jQuery.dataTable.classSettings

   993 			 */

   994 			this.aiDisplay = [];

   995 			

   996 			/*

   997 			 * Variable: aiDisplayMaster

   998 			 * Purpose:  Array of indexes for display - no filtering

   999 			 * Scope:    jQuery.dataTable.classSettings

  1000 			 */

  1001 			this.aiDisplayMaster = [];

  1002 							

  1003 			/*

  1004 			 * Variable: aoColumns

  1005 			 * Purpose:  Store information about each column that is in use

  1006 			 * Scope:    jQuery.dataTable.classSettings 

  1007 			 */

  1008 			this.aoColumns = [];

  1009 			

  1010 			/*

  1011 			 * Variable: iNextId

  1012 			 * Purpose:  Store the next unique id to be used for a new row

  1013 			 * Scope:    jQuery.dataTable.classSettings 

  1014 			 */

  1015 			this.iNextId = 0;

  1016 			

  1017 			/*

  1018 			 * Variable: asDataSearch

  1019 			 * Purpose:  Search data array for regular expression searching

  1020 			 * Scope:    jQuery.dataTable.classSettings

  1021 			 */

  1022 			this.asDataSearch = [];

  1023 			

  1024 			/*

  1025 			 * Variable: oPreviousSearch

  1026 			 * Purpose:  Store the previous search incase we want to force a re-search

  1027 			 *   or compare the old search to a new one

  1028 			 * Scope:    jQuery.dataTable.classSettings

  1029 			 */

  1030 			this.oPreviousSearch = {

  1031 				"sSearch": "",

  1032 				"bRegex": false,

  1033 				"bSmart": true

  1034 			};

  1035 			

  1036 			/*

  1037 			 * Variable: aoPreSearchCols

  1038 			 * Purpose:  Store the previous search for each column

  1039 			 * Scope:    jQuery.dataTable.classSettings

  1040 			 */

  1041 			this.aoPreSearchCols = [];

  1042 			

  1043 			/*

  1044 			 * Variable: aaSorting

  1045 			 * Purpose:  Sorting information

  1046 			 * Scope:    jQuery.dataTable.classSettings

  1047 			 * Notes:    Index 0 - column number

  1048 			 *           Index 1 - current sorting direction

  1049 			 *           Index 2 - index of asSorting for this column

  1050 			 */

  1051 			this.aaSorting = [ [0, 'asc', 0] ];

  1052 			

  1053 			/*

  1054 			 * Variable: aaSortingFixed

  1055 			 * Purpose:  Sorting information that is always applied

  1056 			 * Scope:    jQuery.dataTable.classSettings

  1057 			 */

  1058 			this.aaSortingFixed = null;

  1059 			

  1060 			/*

  1061 			 * Variable: asStripClasses

  1062 			 * Purpose:  Classes to use for the striping of a table

  1063 			 * Scope:    jQuery.dataTable.classSettings

  1064 			 */

  1065 			this.asStripClasses = [];

  1066 			

  1067 			/*

  1068 			 * Variable: asDestoryStrips

  1069 			 * Purpose:  If restoring a table - we should restore it's striping classes as well

  1070 			 * Scope:    jQuery.dataTable.classSettings

  1071 			 */

  1072 			this.asDestoryStrips = [];

  1073 			

  1074 			/*

  1075 			 * Variable: sDestroyWidth

  1076 			 * Purpose:  If restoring a table - we should restore it's width

  1077 			 * Scope:    jQuery.dataTable.classSettings

  1078 			 */

  1079 			this.sDestroyWidth = 0;

  1080 			

  1081 			/*

  1082 			 * Variable: fnRowCallback

  1083 			 * Purpose:  Call this function every time a row is inserted (draw)

  1084 			 * Scope:    jQuery.dataTable.classSettings

  1085 			 */

  1086 			this.fnRowCallback = null;

  1087 			

  1088 			/*

  1089 			 * Variable: fnHeaderCallback

  1090 			 * Purpose:  Callback function for the header on each draw

  1091 			 * Scope:    jQuery.dataTable.classSettings

  1092 			 */

  1093 			this.fnHeaderCallback = null;

  1094 			

  1095 			/*

  1096 			 * Variable: fnFooterCallback

  1097 			 * Purpose:  Callback function for the footer on each draw

  1098 			 * Scope:    jQuery.dataTable.classSettings

  1099 			 */

  1100 			this.fnFooterCallback = null;

  1101 			

  1102 			/*

  1103 			 * Variable: aoDrawCallback

  1104 			 * Purpose:  Array of callback functions for draw callback functions

  1105 			 * Scope:    jQuery.dataTable.classSettings

  1106 			 * Notes:    Each array element is an object with the following parameters:

  1107 			 *   function:fn - function to call

  1108 			 *   string:sName - name callback (feature). useful for arranging array

  1109 			 */

  1110 			this.aoDrawCallback = [];

  1111 			

  1112 			/*

  1113 			 * Variable: fnInitComplete

  1114 			 * Purpose:  Callback function for when the table has been initalised

  1115 			 * Scope:    jQuery.dataTable.classSettings

  1116 			 */

  1117 			this.fnInitComplete = null;

  1118 			

  1119 			/*

  1120 			 * Variable: sTableId

  1121 			 * Purpose:  Cache the table ID for quick access

  1122 			 * Scope:    jQuery.dataTable.classSettings

  1123 			 */

  1124 			this.sTableId = "";

  1125 			

  1126 			/*

  1127 			 * Variable: nTable

  1128 			 * Purpose:  Cache the table node for quick access

  1129 			 * Scope:    jQuery.dataTable.classSettings

  1130 			 */

  1131 			this.nTable = null;

  1132 			

  1133 			/*

  1134 			 * Variable: nTHead

  1135 			 * Purpose:  Permanent ref to the thead element

  1136 			 * Scope:    jQuery.dataTable.classSettings