classiccms 0.5.5 → 0.5.6

data/lib/classiccms/public/admin/datatables/src/core/core.support.js

@@ -0,0 +1,316 @@
+
+
+/**
+ * Return the settings object for a particular table
+ *  @param {node} nTable table we are using as a dataTable
+ *  @returns {object} Settings object - or null if not found
+ *  @memberof DataTable#oApi
+ */
+function _fnSettingsFromNode ( nTable )
+{
+	for ( var i=0 ; i<DataTable.settings.length ; i++ )
+	{
+		if ( DataTable.settings[i].nTable === nTable )
+		{
+			return DataTable.settings[i];
+		}
+	}
+	
+	return null;
+}
+
+
+/**
+ * Return an array with the TR nodes for the table
+ *  @param {object} oSettings dataTables settings object
+ *  @returns {array} TR array
+ *  @memberof DataTable#oApi
+ */
+function _fnGetTrNodes ( oSettings )
+{
+	var aNodes = [];
+	var aoData = oSettings.aoData;
+	for ( var i=0, iLen=aoData.length ; i<iLen ; i++ )
+	{
+		if ( aoData[i].nTr !== null )
+		{
+			aNodes.push( aoData[i].nTr );
+		}
+	}
+	return aNodes;
+}
+
+
+/**
+ * Return an flat array with all TD nodes for the table, or row
+ *  @param {object} oSettings dataTables settings object
+ *  @param {int} [iIndividualRow] aoData index to get the nodes for - optional 
+ *    if not given then the return array will contain all nodes for the table
+ *  @returns {array} TD array
+ *  @memberof DataTable#oApi
+ */
+function _fnGetTdNodes ( oSettings, iIndividualRow )
+{
+	var anReturn = [];
+	var iCorrector;
+	var anTds;
+	var iRow, iRows=oSettings.aoData.length,
+		iColumn, iColumns, oData, sNodeName, iStart=0, iEnd=iRows;
+	
+	/* Allow the collection to be limited to just one row */
+	if ( iIndividualRow !== undefined )
+	{
+		iStart = iIndividualRow;
+		iEnd = iIndividualRow+1;
+	}
+
+	for ( iRow=iStart ; iRow<iEnd ; iRow++ )
+	{
+		oData = oSettings.aoData[iRow];
+		if ( oData.nTr !== null )
+		{
+			/* get the TD child nodes - taking into account text etc nodes */
+			anTds = [];
+			for ( iColumn=0, iColumns=oData.nTr.childNodes.length ; iColumn<iColumns ; iColumn++ )
+			{
+				sNodeName = oData.nTr.childNodes[iColumn].nodeName.toLowerCase();
+				if ( sNodeName == 'td' || sNodeName == 'th' )
+				{
+					anTds.push( oData.nTr.childNodes[iColumn] );
+				}
+			}
+
+			iCorrector = 0;
+			for ( iColumn=0, iColumns=oSettings.aoColumns.length ; iColumn<iColumns ; iColumn++ )
+			{
+				if ( oSettings.aoColumns[iColumn].bVisible )
+				{
+					anReturn.push( anTds[iColumn-iCorrector] );
+				}
+				else
+				{
+					anReturn.push( oData._anHidden[iColumn] );
+					iCorrector++;
+				}
+			}
+		}
+	}
+
+	return anReturn;
+}
+
+
+/**
+ * Log an error message
+ *  @param {object} oSettings dataTables settings object
+ *  @param {int} iLevel log error messages, or display them to the user
+ *  @param {string} sMesg error message
+ *  @memberof DataTable#oApi
+ */
+function _fnLog( oSettings, iLevel, sMesg )
+{
+	var sAlert = (oSettings===null) ?
+		"DataTables warning: "+sMesg :
+		"DataTables warning (table id = '"+oSettings.sTableId+"'): "+sMesg;
+	
+	if ( iLevel === 0 )
+	{
+		if ( DataTable.ext.sErrMode == 'alert' )
+		{
+			alert( sAlert );
+		}
+		else
+		{
+			throw new Error(sAlert);
+		}
+		return;
+	}
+	else if ( window.console && console.log )
+	{
+		console.log( sAlert );
+	}
+}
+
+
+/**
+ * See if a property is defined on one object, if so assign it to the other object
+ *  @param {object} oRet target object
+ *  @param {object} oSrc source object
+ *  @param {string} sName property
+ *  @param {string} [sMappedName] name to map too - optional, sName used if not given
+ *  @memberof DataTable#oApi
+ */
+function _fnMap( oRet, oSrc, sName, sMappedName )
+{
+	if ( sMappedName === undefined )
+	{
+		sMappedName = sName;
+	}
+	if ( oSrc[sName] !== undefined )
+	{
+		oRet[sMappedName] = oSrc[sName];
+	}
+}
+
+
+/**
+ * Extend objects - very similar to jQuery.extend, but deep copy objects, and shallow
+ * copy arrays. The reason we need to do this, is that we don't want to deep copy array
+ * init values (such as aaSorting) since the dev wouldn't be able to override them, but
+ * we do want to deep copy arrays.
+ *  @param {object} oOut Object to extend
+ *  @param {object} oExtender Object from which the properties will be applied to oOut
+ *  @returns {object} oOut Reference, just for convenience - oOut === the return.
+ *  @memberof DataTable#oApi
+ *  @todo This doesn't take account of arrays inside the deep copied objects.
+ */
+function _fnExtend( oOut, oExtender )
+{
+	for ( var prop in oExtender )
+	{
+		if ( oExtender.hasOwnProperty(prop) )
+		{
+			if ( typeof oInit[prop] === 'object' && $.isArray(oExtender[prop]) === false )
+			{
+				$.extend( true, oOut[prop], oExtender[prop] );
+			}
+			else
+			{
+				oOut[prop] = oExtender[prop];
+			}
+		}
+	}
+
+	return oOut;
+}
+
+
+/**
+ * Bind an event handers to allow a click or return key to activate the callback.
+ * This is good for accessability since a return on the keyboard will have the
+ * same effect as a click, if the element has focus.
+ *  @param {element} n Element to bind the action to
+ *  @param {object} oData Data object to pass to the triggered function
+ *  @param {function} fn Callback function for when the event is triggered
+ *  @memberof DataTable#oApi
+ */
+function _fnBindAction( n, oData, fn )
+{
+	$(n)
+		.bind( 'click.DT', oData, function (e) {
+				n.blur(); // Remove focus outline for mouse users
+				fn(e);
+			} )
+		.bind( 'keypress.DT', oData, function (e){
+			if ( e.which === 13 ) {
+				fn(e);
+			} } )
+		.bind( 'selectstart.DT', function () {
+			/* Take the brutal approach to cancelling text selection */
+			return false;
+			} );
+}
+
+
+/**
+ * Register a callback function. Easily allows a callback function to be added to
+ * an array store of callback functions that can then all be called together.
+ *  @param {object} oSettings dataTables settings object
+ *  @param {string} sStore Name of the array storeage for the callbacks in oSettings
+ *  @param {function} fn Function to be called back
+ *  @param {string} sName Identifying name for the callback (i.e. a label)
+ *  @memberof DataTable#oApi
+ */
+function _fnCallbackReg( oSettings, sStore, fn, sName )
+{
+	if ( fn )
+	{
+		oSettings[sStore].push( {
+			"fn": fn,
+			"sName": sName
+		} );
+	}
+}
+
+
+/**
+ * Fire callback functions and trigger events. Note that the loop over the callback
+ * array store is done backwards! Further note that you do not want to fire off triggers
+ * in time sensitive applications (for example cell creation) as its slow.
+ *  @param {object} oSettings dataTables settings object
+ *  @param {string} sStore Name of the array storeage for the callbacks in oSettings
+ *  @param {string} sTrigger Name of the jQuery custom event to trigger. If null no trigger
+ *    is fired
+ *  @param {array} aArgs Array of arguments to pass to the callback function / trigger
+ *  @memberof DataTable#oApi
+ */
+function _fnCallbackFire( oSettings, sStore, sTrigger, aArgs )
+{
+	var aoStore = oSettings[sStore];
+	var aRet =[];
+
+	for ( var i=aoStore.length-1 ; i>=0 ; i-- )
+	{
+		aRet.push( aoStore[i].fn.apply( oSettings.oInstance, aArgs ) );
+	}
+
+	if ( sTrigger !== null )
+	{
+		$(oSettings.oInstance).trigger(sTrigger, aArgs);
+	}
+
+	return aRet;
+}
+
+
+/**
+ * JSON stringify. If JSON.stringify it provided by the browser, json2.js or any other
+ * library, then we use that as it is fast, safe and accurate. If the function isn't 
+ * available then we need to built it ourselves - the insperation for this function comes
+ * from Craig Buckler ( http://www.sitepoint.com/javascript-json-serialization/ ). It is
+ * not perfect and absolutely should not be used as a replacement to json2.js - but it does
+ * do what we need, without requiring a dependency for DataTables.
+ *  @param {object} o JSON object to be converted
+ *  @returns {string} JSON string
+ *  @memberof DataTable#oApi
+ */
+var _fnJsonString = (window.JSON) ? JSON.stringify : function( o )
+{
+	/* Not an object or array */
+	var sType = typeof o;
+	if (sType !== "object" || o === null)
+	{
+		// simple data type
+		if (sType === "string")
+		{
+			o = '"'+o+'"';
+		}
+		return o+"";
+	}
+
+	/* If object or array, need to recurse over it */
+	var
+		sProp, mValue,
+		json = [],
+		bArr = $.isArray(o);
+	
+	for (sProp in o)
+	{
+		mValue = o[sProp];
+		sType = typeof mValue;
+
+		if (sType === "string")
+		{
+			mValue = '"'+mValue+'"';
+		}
+		else if (sType === "object" && mValue !== null)
+		{
+			mValue = _fnJsonString(mValue);
+		}
+
+		json.push((bArr ? "" : '"'+sProp+'":') + mValue);
+	}
+
+	return (bArr ? "[" : "{") + json + (bArr ? "]" : "}");
+};
+

data/lib/classiccms/public/admin/datatables/src/ext/ext.classes.js

@@ -0,0 +1,112 @@
+
+$.extend( DataTable.ext.oStdClasses, {
+	"sTable": "dataTable",
+
+	/* Two buttons buttons */
+	"sPagePrevEnabled": "paginate_enabled_previous",
+	"sPagePrevDisabled": "paginate_disabled_previous",
+	"sPageNextEnabled": "paginate_enabled_next",
+	"sPageNextDisabled": "paginate_disabled_next",
+	"sPageJUINext": "",
+	"sPageJUIPrev": "",
+	
+	/* Full numbers paging buttons */
+	"sPageButton": "paginate_button",
+	"sPageButtonActive": "paginate_active",
+	"sPageButtonStaticDisabled": "paginate_button paginate_button_disabled",
+	"sPageFirst": "first",
+	"sPagePrevious": "previous",
+	"sPageNext": "next",
+	"sPageLast": "last",
+	
+	/* Striping classes */
+	"sStripeOdd": "odd",
+	"sStripeEven": "even",
+	
+	/* Empty row */
+	"sRowEmpty": "dataTables_empty",
+	
+	/* Features */
+	"sWrapper": "dataTables_wrapper",
+	"sFilter": "dataTables_filter",
+	"sInfo": "dataTables_info",
+	"sPaging": "dataTables_paginate paging_", /* Note that the type is postfixed */
+	"sLength": "dataTables_length",
+	"sProcessing": "dataTables_processing",
+	
+	/* Sorting */
+	"sSortAsc": "sorting_asc",
+	"sSortDesc": "sorting_desc",
+	"sSortable": "sorting", /* Sortable in both directions */
+	"sSortableAsc": "sorting_asc_disabled",
+	"sSortableDesc": "sorting_desc_disabled",
+	"sSortableNone": "sorting_disabled",
+	"sSortColumn": "sorting_", /* Note that an int is postfixed for the sorting order */
+	"sSortJUIAsc": "",
+	"sSortJUIDesc": "",
+	"sSortJUI": "",
+	"sSortJUIAscAllowed": "",
+	"sSortJUIDescAllowed": "",
+	"sSortJUIWrapper": "",
+	"sSortIcon": "",
+	
+	/* Scrolling */
+	"sScrollWrapper": "dataTables_scroll",
+	"sScrollHead": "dataTables_scrollHead",
+	"sScrollHeadInner": "dataTables_scrollHeadInner",
+	"sScrollBody": "dataTables_scrollBody",
+	"sScrollFoot": "dataTables_scrollFoot",
+	"sScrollFootInner": "dataTables_scrollFootInner",
+	
+	/* Misc */
+	"sFooterTH": "",
+	"sJUIHeader": "",
+	"sJUIFooter": ""
+} );
+
+
+$.extend( DataTable.ext.oJUIClasses, DataTable.ext.oStdClasses, {
+	/* Two buttons buttons */
+	"sPagePrevEnabled": "fg-button ui-button ui-state-default ui-corner-left",
+	"sPagePrevDisabled": "fg-button ui-button ui-state-default ui-corner-left ui-state-disabled",
+	"sPageNextEnabled": "fg-button ui-button ui-state-default ui-corner-right",
+	"sPageNextDisabled": "fg-button ui-button ui-state-default ui-corner-right ui-state-disabled",
+	"sPageJUINext": "ui-icon ui-icon-circle-arrow-e",
+	"sPageJUIPrev": "ui-icon ui-icon-circle-arrow-w",
+	
+	/* Full numbers paging buttons */
+	"sPageButton": "fg-button ui-button ui-state-default",
+	"sPageButtonActive": "fg-button ui-button ui-state-default ui-state-disabled",
+	"sPageButtonStaticDisabled": "fg-button ui-button ui-state-default ui-state-disabled",
+	"sPageFirst": "first ui-corner-tl ui-corner-bl",
+	"sPageLast": "last ui-corner-tr ui-corner-br",
+	
+	/* Features */
+	"sPaging": "dataTables_paginate fg-buttonset ui-buttonset fg-buttonset-multi "+
+		"ui-buttonset-multi paging_", /* Note that the type is postfixed */
+	
+	/* Sorting */
+	"sSortAsc": "ui-state-default",
+	"sSortDesc": "ui-state-default",
+	"sSortable": "ui-state-default",
+	"sSortableAsc": "ui-state-default",
+	"sSortableDesc": "ui-state-default",
+	"sSortableNone": "ui-state-default",
+	"sSortJUIAsc": "css_right ui-icon ui-icon-triangle-1-n",
+	"sSortJUIDesc": "css_right ui-icon ui-icon-triangle-1-s",
+	"sSortJUI": "css_right ui-icon ui-icon-carat-2-n-s",
+	"sSortJUIAscAllowed": "css_right ui-icon ui-icon-carat-1-n",
+	"sSortJUIDescAllowed": "css_right ui-icon ui-icon-carat-1-s",
+	"sSortJUIWrapper": "DataTables_sort_wrapper",
+	"sSortIcon": "DataTables_sort_icon",
+	
+	/* Scrolling */
+	"sScrollHead": "dataTables_scrollHead ui-state-default",
+	"sScrollFoot": "dataTables_scrollFoot ui-state-default",
+	
+	/* Misc */
+	"sFooterTH": "ui-state-default",
+	"sJUIHeader": "fg-toolbar ui-toolbar ui-widget-header ui-corner-tl ui-corner-tr ui-helper-clearfix",
+	"sJUIFooter": "fg-toolbar ui-toolbar ui-widget-header ui-corner-bl ui-corner-br ui-helper-clearfix"
+} );
+

data/lib/classiccms/public/admin/datatables/src/ext/ext.paging.js

@@ -0,0 +1,257 @@
+
+/*
+ * Variable: oPagination
+ * Purpose:  
+ * Scope:    jQuery.fn.dataTableExt
+ */
+$.extend( DataTable.ext.oPagination, {
+	/*
+	 * Variable: two_button
+	 * Purpose:  Standard two button (forward/back) pagination
+	 * Scope:    jQuery.fn.dataTableExt.oPagination
+	 */
+	"two_button": {
+		/*
+		 * Function: oPagination.two_button.fnInit
+		 * Purpose:  Initialise dom elements required for pagination with forward/back buttons only
+		 * Returns:  -
+		 * Inputs:   object:oSettings - dataTables settings object
+		 *           node:nPaging - the DIV which contains this pagination control
+		 *           function:fnCallbackDraw - draw function which must be called on update
+		 */
+		"fnInit": function ( oSettings, nPaging, fnCallbackDraw )
+		{
+			var oLang = oSettings.oLanguage.oPaginate;
+			var oClasses = oSettings.oClasses;
+			var fnClickHandler = function ( e ) {
+				if ( oSettings.oApi._fnPageChange( oSettings, e.data.action ) )
+				{
+					fnCallbackDraw( oSettings );
+				}
+			};
+
+			var sAppend = (!oSettings.bJUI) ?
+				'<a class="'+oSettings.oClasses.sPagePrevDisabled+'" tabindex="'+oSettings.iTabIndex+'" role="button">'+oLang.sPrevious+'</a>'+
+				'<a class="'+oSettings.oClasses.sPageNextDisabled+'" tabindex="'+oSettings.iTabIndex+'" role="button">'+oLang.sNext+'</a>'
+				:
+				'<a class="'+oSettings.oClasses.sPagePrevDisabled+'" tabindex="'+oSettings.iTabIndex+'" role="button"><span class="'+oSettings.oClasses.sPageJUIPrev+'"></span></a>'+
+				'<a class="'+oSettings.oClasses.sPageNextDisabled+'" tabindex="'+oSettings.iTabIndex+'" role="button"><span class="'+oSettings.oClasses.sPageJUINext+'"></span></a>';
+			$(nPaging).append( sAppend );
+			
+			var els = $('a', nPaging);
+			var nPrevious = els[0],
+				nNext = els[1];
+			
+			oSettings.oApi._fnBindAction( nPrevious, {action: "previous"}, fnClickHandler );
+			oSettings.oApi._fnBindAction( nNext,     {action: "next"},     fnClickHandler );
+			
+			/* ID the first elements only */
+			if ( !oSettings.aanFeatures.p )
+			{
+				nPaging.id = oSettings.sTableId+'_paginate';
+				nPrevious.id = oSettings.sTableId+'_previous';
+				nNext.id = oSettings.sTableId+'_next';
+
+				nPrevious.setAttribute('aria-controls', oSettings.sTableId);
+				nNext.setAttribute('aria-controls', oSettings.sTableId);
+			}
+		},
+		
+		/*
+		 * Function: oPagination.two_button.fnUpdate
+		 * Purpose:  Update the two button pagination at the end of the draw
+		 * Returns:  -
+		 * Inputs:   object:oSettings - dataTables settings object
+		 *           function:fnCallbackDraw - draw function to call on page change
+		 */
+		"fnUpdate": function ( oSettings, fnCallbackDraw )
+		{
+			if ( !oSettings.aanFeatures.p )
+			{
+				return;
+			}
+			
+			var oClasses = oSettings.oClasses;
+			var an = oSettings.aanFeatures.p;
+
+			/* Loop over each instance of the pager */
+			for ( var i=0, iLen=an.length ; i<iLen ; i++ )
+			{
+				if ( an[i].childNodes.length !== 0 )
+				{
+					an[i].childNodes[0].className = ( oSettings._iDisplayStart === 0 ) ? 
+						oClasses.sPagePrevDisabled : oClasses.sPagePrevEnabled;
+					
+					an[i].childNodes[1].className = ( oSettings.fnDisplayEnd() == oSettings.fnRecordsDisplay() ) ? 
+						oClasses.sPageNextDisabled : oClasses.sPageNextEnabled;
+				}
+			}
+		}
+	},
+	
+	
+	/*
+	 * Variable: iFullNumbersShowPages
+	 * Purpose:  Change the number of pages which can be seen
+	 * Scope:    jQuery.fn.dataTableExt.oPagination
+	 */
+	"iFullNumbersShowPages": 5,
+	
+	/*
+	 * Variable: full_numbers
+	 * Purpose:  Full numbers pagination
+	 * Scope:    jQuery.fn.dataTableExt.oPagination
+	 */
+	"full_numbers": {
+		/*
+		 * Function: oPagination.full_numbers.fnInit
+		 * Purpose:  Initialise dom elements required for pagination with a list of the pages
+		 * Returns:  -
+		 * Inputs:   object:oSettings - dataTables settings object
+		 *           node:nPaging - the DIV which contains this pagination control
+		 *           function:fnCallbackDraw - draw function which must be called on update
+		 */
+		"fnInit": function ( oSettings, nPaging, fnCallbackDraw )
+		{
+			var oLang = oSettings.oLanguage.oPaginate;
+			var oClasses = oSettings.oClasses;
+			var fnClickHandler = function ( e ) {
+				if ( oSettings.oApi._fnPageChange( oSettings, e.data.action ) )
+				{
+					fnCallbackDraw( oSettings );
+				}
+			};
+
+			$(nPaging).append(
+				'<a  tabindex="'+oSettings.iTabIndex+'" class="'+oClasses.sPageButton+" "+oClasses.sPageFirst+'">'+oLang.sFirst+'</a>'+
+				'<a  tabindex="'+oSettings.iTabIndex+'" class="'+oClasses.sPageButton+" "+oClasses.sPagePrevious+'">'+oLang.sPrevious+'</a>'+
+				'<span></span>'+
+				'<a tabindex="'+oSettings.iTabIndex+'" class="'+oClasses.sPageButton+" "+oClasses.sPageNext+'">'+oLang.sNext+'</a>'+
+				'<a tabindex="'+oSettings.iTabIndex+'" class="'+oClasses.sPageButton+" "+oClasses.sPageLast+'">'+oLang.sLast+'</a>'
+			);
+			var els = $('a', nPaging);
+			var nFirst = els[0],
+				nPrev = els[1],
+				nNext = els[2],
+				nLast = els[3];
+			
+			oSettings.oApi._fnBindAction( nFirst, {action: "first"},    fnClickHandler );
+			oSettings.oApi._fnBindAction( nPrev,  {action: "previous"}, fnClickHandler );
+			oSettings.oApi._fnBindAction( nNext,  {action: "next"},     fnClickHandler );
+			oSettings.oApi._fnBindAction( nLast,  {action: "last"},     fnClickHandler );
+			
+			/* ID the first elements only */
+			if ( !oSettings.aanFeatures.p )
+			{
+				nPaging.id = oSettings.sTableId+'_paginate';
+				nFirst.id =oSettings.sTableId+'_first';
+				nPrev.id =oSettings.sTableId+'_previous';
+				nNext.id =oSettings.sTableId+'_next';
+				nLast.id =oSettings.sTableId+'_last';
+			}
+		},
+		
+		/*
+		 * Function: oPagination.full_numbers.fnUpdate
+		 * Purpose:  Update the list of page buttons shows
+		 * Returns:  -
+		 * Inputs:   object:oSettings - dataTables settings object
+		 *           function:fnCallbackDraw - draw function to call on page change
+		 */
+		"fnUpdate": function ( oSettings, fnCallbackDraw )
+		{
+			if ( !oSettings.aanFeatures.p )
+			{
+				return;
+			}
+			
+			var iPageCount = DataTable.ext.oPagination.iFullNumbersShowPages;
+			var iPageCountHalf = Math.floor(iPageCount / 2);
+			var iPages = Math.ceil((oSettings.fnRecordsDisplay()) / oSettings._iDisplayLength);
+			var iCurrentPage = Math.ceil(oSettings._iDisplayStart / oSettings._iDisplayLength) + 1;
+			var sList = "";
+			var iStartButton, iEndButton, i, iLen;
+			var oClasses = oSettings.oClasses;
+			var anButtons, anStatic, nPaginateList;
+			var an = oSettings.aanFeatures.p;
+			var fnBind = function (j) {
+				oSettings.oApi._fnBindAction( this, {"page": j+iStartButton-1}, function(e) {
+					/* Use the information in the element to jump to the required page */
+					oSettings.oApi._fnPageChange( oSettings, e.data.page );
+					fnCallbackDraw( oSettings );
+					e.preventDefault();
+				} );
+			};
+			
+			/* Pages calculation */
+			if ( oSettings._iDisplayLength === -1 )
+			{
+				iStartButton = 1;
+				iEndButton = 1;
+				iCurrentPage = 1;
+			}
+			else if (iPages < iPageCount)
+			{
+				iStartButton = 1;
+				iEndButton = iPages;
+			}
+			else if (iCurrentPage <= iPageCountHalf)
+			{
+				iStartButton = 1;
+				iEndButton = iPageCount;
+			}
+			else if (iCurrentPage >= (iPages - iPageCountHalf))
+			{
+				iStartButton = iPages - iPageCount + 1;
+				iEndButton = iPages;
+			}
+			else
+			{
+				iStartButton = iCurrentPage - Math.ceil(iPageCount / 2) + 1;
+				iEndButton = iStartButton + iPageCount - 1;
+			}
+
+			
+			/* Build the dynamic list */
+			for ( i=iStartButton ; i<=iEndButton ; i++ )
+			{
+				sList += (iCurrentPage !== i) ?
+					'<a tabindex="'+oSettings.iTabIndex+'" class="'+oClasses.sPageButton+'">'+oSettings.fnFormatNumber(i)+'</a>' :
+					'<a tabindex="'+oSettings.iTabIndex+'" class="'+oClasses.sPageButtonActive+'">'+oSettings.fnFormatNumber(i)+'</a>';
+			}
+			
+			/* Loop over each instance of the pager */
+			for ( i=0, iLen=an.length ; i<iLen ; i++ )
+			{
+				if ( an[i].childNodes.length === 0 )
+				{
+					continue;
+				}
+				
+				/* Build up the dynamic list forst - html and listeners */
+				$('span:eq(0)', an[i])
+					.html( sList )
+					.children('a').each( fnBind );
+				
+				/* Update the premanent botton's classes */
+				anButtons = an[i].getElementsByTagName('a');
+				anStatic = [
+					anButtons[0], anButtons[1], 
+					anButtons[anButtons.length-2], anButtons[anButtons.length-1]
+				];
+
+				$(anStatic).removeClass( oClasses.sPageButton+" "+oClasses.sPageButtonActive+" "+oClasses.sPageButtonStaticDisabled );
+				$([anStatic[0], anStatic[1]]).addClass( 
+					(iCurrentPage==1) ?
+						oClasses.sPageButtonStaticDisabled :
+						oClasses.sPageButton
+				);
+				$([anStatic[2], anStatic[3]]).addClass(
+					(iPages===0 || iCurrentPage===iPages || oSettings._iDisplayLength===-1) ?
+						oClasses.sPageButtonStaticDisabled :
+						oClasses.sPageButton
+				);
+			}
+		}
+	}
+} );