classiccms 0.5.5 → 0.5.6

data/lib/classiccms/public/admin/datatables/src/api/api.static.js

@@ -0,0 +1,98 @@
+
+
+/**
+ * Provide a common method for plug-ins to check the version of DataTables being used, in order
+ * to ensure compatibility.
+ *  @param {string} sVersion Version string to check for, in the format "X.Y.Z". Note that the
+ *    formats "X" and "X.Y" are also acceptable.
+ *  @returns {boolean} true if this version of DataTables is greater or equal to the required
+ *    version, or false if this version of DataTales is not suitable
+ *  @static
+ *  @dtopt API-Static
+ *
+ *  @example
+ *    alert( $.fn.dataTable.fnVersionCheck( '1.9.0' ) );
+ */
+DataTable.fnVersionCheck = function( sVersion )
+{
+	/* This is cheap, but effective */
+	var fnZPad = function (Zpad, count)
+	{
+		while(Zpad.length < count) {
+			Zpad += '0';
+		}
+		return Zpad;
+	};
+	var aThis = DataTable.ext.sVersion.split('.');
+	var aThat = sVersion.split('.');
+	var sThis = '', sThat = '';
+	
+	for ( var i=0, iLen=aThat.length ; i<iLen ; i++ )
+	{
+		sThis += fnZPad( aThis[i], 3 );
+		sThat += fnZPad( aThat[i], 3 );
+	}
+	
+	return parseInt(sThis, 10) >= parseInt(sThat, 10);
+};
+
+
+/**
+ * Check if a TABLE node is a DataTable table already or not.
+ *  @param {node} nTable The TABLE node to check if it is a DataTable or not (note that other
+ *    node types can be passed in, but will always return false).
+ *  @returns {boolean} true the table given is a DataTable, or false otherwise
+ *  @static
+ *  @dtopt API-Static
+ *
+ *  @example
+ *    var ex = document.getElementById('example');
+ *    if ( ! $.fn.DataTable.fnIsDataTable( ex ) ) {
+ *      $(ex).dataTable();
+ *    }
+ */
+DataTable.fnIsDataTable = function ( nTable )
+{
+	var o = DataTable.settings;
+
+	for ( var i=0 ; i<o.length ; i++ )
+	{
+		if ( o[i].nTable === nTable || o[i].nScrollHead === nTable || o[i].nScrollFoot === nTable )
+		{
+			return true;
+		}
+	}
+
+	return false;
+};
+
+
+/**
+ * Get all DataTable tables that have been initialised - optionally you can select to
+ * get only currently visible tables.
+ *  @param {boolean} [bVisible=false] Flag to indicate if you want all (default) or 
+ *    visible tables only.
+ *  @returns {array} Array of TABLE nodes (not DataTable instances) which are DataTables
+ *  @static
+ *  @dtopt API-Static
+ *
+ *  @example
+ *    var table = $.fn.dataTable.fnTables(true);
+ *    if ( table.length > 0 ) {
+ *      $(table).dataTable().fnAdjustColumnSizing();
+ *    }
+ */
+DataTable.fnTables = function ( bVisible )
+{
+	var out = [];
+
+	jQuery.each( DataTable.settings, function (i, o) {
+		if ( !bVisible || (bVisible === true && $(o.nTable).is(':visible')) )
+		{
+			out.push( o.nTable );
+		}
+	} );
+
+	return out;
+};
+

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

@@ -0,0 +1,185 @@
+
+
+/**
+ * Update the table using an Ajax call
+ *  @param {object} oSettings dataTables settings object
+ *  @returns {boolean} Block the table drawing or not
+ *  @memberof DataTable#oApi
+ */
+function _fnAjaxUpdate( oSettings )
+{
+	if ( oSettings.bAjaxDataGet )
+	{
+		oSettings.iDraw++;
+		_fnProcessingDisplay( oSettings, true );
+		var iColumns = oSettings.aoColumns.length;
+		var aoData = _fnAjaxParameters( oSettings );
+		_fnServerParams( oSettings, aoData );
+		
+		oSettings.fnServerData.call( oSettings.oInstance, oSettings.sAjaxSource, aoData,
+			function(json) {
+				_fnAjaxUpdateDraw( oSettings, json );
+			}, oSettings );
+		return false;
+	}
+	else
+	{
+		return true;
+	}
+}
+
+
+/**
+ * Build up the parameters in an object needed for a server-side processing request
+ *  @param {object} oSettings dataTables settings object
+ *  @returns {bool} block the table drawing or not
+ *  @memberof DataTable#oApi
+ */
+function _fnAjaxParameters( oSettings )
+{
+	var iColumns = oSettings.aoColumns.length;
+	var aoData = [], mDataProp, aaSort, aDataSort;
+	var i, j;
+	
+	aoData.push( { "name": "sEcho",          "value": oSettings.iDraw } );
+	aoData.push( { "name": "iColumns",       "value": iColumns } );
+	aoData.push( { "name": "sColumns",       "value": _fnColumnOrdering(oSettings) } );
+	aoData.push( { "name": "iDisplayStart",  "value": oSettings._iDisplayStart } );
+	aoData.push( { "name": "iDisplayLength", "value": oSettings.oFeatures.bPaginate !== false ?
+		oSettings._iDisplayLength : -1 } );
+		
+	for ( i=0 ; i<iColumns ; i++ )
+	{
+	  mDataProp = oSettings.aoColumns[i].mDataProp;
+		aoData.push( { "name": "mDataProp_"+i, "value": typeof(mDataProp)==="function" ? 'function' : mDataProp } );
+	}
+	
+	/* Filtering */
+	if ( oSettings.oFeatures.bFilter !== false )
+	{
+		aoData.push( { "name": "sSearch", "value": oSettings.oPreviousSearch.sSearch } );
+		aoData.push( { "name": "bRegex",  "value": oSettings.oPreviousSearch.bRegex } );
+		for ( i=0 ; i<iColumns ; i++ )
+		{
+			aoData.push( { "name": "sSearch_"+i,     "value": oSettings.aoPreSearchCols[i].sSearch } );
+			aoData.push( { "name": "bRegex_"+i,      "value": oSettings.aoPreSearchCols[i].bRegex } );
+			aoData.push( { "name": "bSearchable_"+i, "value": oSettings.aoColumns[i].bSearchable } );
+		}
+	}
+	
+	/* Sorting */
+	if ( oSettings.oFeatures.bSort !== false )
+	{
+		var iCounter = 0;
+
+		aaSort = ( oSettings.aaSortingFixed !== null ) ?
+			oSettings.aaSortingFixed.concat( oSettings.aaSorting ) :
+			oSettings.aaSorting.slice();
+		
+		for ( i=0 ; i<aaSort.length ; i++ )
+		{
+			aDataSort = oSettings.aoColumns[ aaSort[i][0] ].aDataSort;
+			
+			for ( j=0 ; j<aDataSort.length ; j++ )
+			{
+				aoData.push( { "name": "iSortCol_"+iCounter,  "value": aDataSort[j] } );
+				aoData.push( { "name": "sSortDir_"+iCounter,  "value": aaSort[i][1] } );
+				iCounter++;
+			}
+		}
+		aoData.push( { "name": "iSortingCols",   "value": iCounter } );
+		
+		for ( i=0 ; i<iColumns ; i++ )
+		{
+			aoData.push( { "name": "bSortable_"+i,  "value": oSettings.aoColumns[i].bSortable } );
+		}
+	}
+	
+	return aoData;
+}
+
+
+/**
+ * Add Ajax parameters from plugins
+ *  @param {object} oSettings dataTables settings object
+ *  @param array {objects} aoData name/value pairs to send to the server
+ *  @memberof DataTable#oApi
+ */
+function _fnServerParams( oSettings, aoData )
+{
+	_fnCallbackFire( oSettings, 'aoServerParams', 'serverParams', [aoData] );
+}
+
+
+/**
+ * Data the data from the server (nuking the old) and redraw the table
+ *  @param {object} oSettings dataTables settings object
+ *  @param {object} json json data return from the server.
+ *  @param {string} json.sEcho Tracking flag for DataTables to match requests
+ *  @param {int} json.iTotalRecords Number of records in the data set, not accounting for filtering
+ *  @param {int} json.iTotalDisplayRecords Number of records in the data set, accounting for filtering
+ *  @param {array} json.aaData The data to display on this page
+ *  @param {string} [json.sColumns] Column ordering (sName, comma separated)
+ *  @memberof DataTable#oApi
+ */
+function _fnAjaxUpdateDraw ( oSettings, json )
+{
+	if ( json.sEcho !== undefined )
+	{
+		/* Protect against old returns over-writing a new one. Possible when you get
+		 * very fast interaction, and later queires are completed much faster
+		 */
+		if ( json.sEcho*1 < oSettings.iDraw )
+		{
+			return;
+		}
+		else
+		{
+			oSettings.iDraw = json.sEcho * 1;
+		}
+	}
+	
+	if ( !oSettings.oScroll.bInfinite ||
+		   (oSettings.oScroll.bInfinite && (oSettings.bSorted || oSettings.bFiltered)) )
+	{
+		_fnClearTable( oSettings );
+	}
+	oSettings._iRecordsTotal = parseInt(json.iTotalRecords, 10);
+	oSettings._iRecordsDisplay = parseInt(json.iTotalDisplayRecords, 10);
+	
+	/* Determine if reordering is required */
+	var sOrdering = _fnColumnOrdering(oSettings);
+	var bReOrder = (json.sColumns !== undefined && sOrdering !== "" && json.sColumns != sOrdering );
+	var aiIndex;
+	if ( bReOrder )
+	{
+		aiIndex = _fnReOrderIndex( oSettings, json.sColumns );
+	}
+	
+	var aData = _fnGetObjectDataFn( oSettings.sAjaxDataProp )( json );
+	for ( var i=0, iLen=aData.length ; i<iLen ; i++ )
+	{
+		if ( bReOrder )
+		{
+			/* If we need to re-order, then create a new array with the correct order and add it */
+			var aDataSorted = [];
+			for ( var j=0, jLen=oSettings.aoColumns.length ; j<jLen ; j++ )
+			{
+				aDataSorted.push( aData[i][ aiIndex[j] ] );
+			}
+			_fnAddData( oSettings, aDataSorted );
+		}
+		else
+		{
+			/* No re-order required, sever got it "right" - just straight add */
+			_fnAddData( oSettings, aData[i] );
+		}
+	}
+	oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
+	
+	oSettings.bAjaxDataGet = false;
+	_fnDraw( oSettings );
+	oSettings.bAjaxDataGet = true;
+	_fnProcessingDisplay( oSettings, false );
+}
+

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

@@ -0,0 +1,365 @@
+
+
+/**
+ * Add a column to the list used for the table with default values
+ *  @param {object} oSettings dataTables settings object
+ *  @param {node} nTh The th element for this column
+ *  @memberof DataTable#oApi
+ */
+function _fnAddColumn( oSettings, nTh )
+{
+	var oDefaults = DataTable.defaults.columns;
+	var iCol = oSettings.aoColumns.length;
+	var oCol = $.extend( {}, DataTable.models.oColumn, oDefaults, {
+		"sSortingClass": oSettings.oClasses.sSortable,
+		"sSortingClassJUI": oSettings.oClasses.sSortJUI,
+		"nTh": nTh ? nTh : document.createElement('th'),
+		"sTitle":    oDefaults.sTitle    ? oDefaults.sTitle    : nTh ? nTh.innerHTML : '',
+		"aDataSort": oDefaults.aDataSort ? oDefaults.aDataSort : [iCol],
+		"mDataProp": oDefaults.mDataProp ? oDefaults.oDefaults : iCol
+	} );
+	oSettings.aoColumns.push( oCol );
+	
+	/* Add a column specific filter */
+	if ( oSettings.aoPreSearchCols[ iCol ] === undefined || oSettings.aoPreSearchCols[ iCol ] === null )
+	{
+		oSettings.aoPreSearchCols[ iCol ] = $.extend( {}, DataTable.models.oSearch );
+	}
+	else
+	{
+		var oPre = oSettings.aoPreSearchCols[ iCol ];
+		
+		/* Don't require that the user must specify bRegex, bSmart or bCaseInsensitive */
+		if ( oPre.bRegex === undefined )
+		{
+			oPre.bRegex = true;
+		}
+		
+		if ( oPre.bSmart === undefined )
+		{
+			oPre.bSmart = true;
+		}
+		
+		if ( oPre.bCaseInsensitive === undefined )
+		{
+			oPre.bCaseInsensitive = true;
+		}
+	}
+	
+	/* Use the column options function to initialise classes etc */
+	_fnColumnOptions( oSettings, iCol, null );
+}
+
+
+/**
+ * Apply options for a column
+ *  @param {object} oSettings dataTables settings object
+ *  @param {int} iCol column index to consider
+ *  @param {object} oOptions object with sType, bVisible and bSearchable
+ *  @memberof DataTable#oApi
+ */
+function _fnColumnOptions( oSettings, iCol, oOptions )
+{
+	var oCol = oSettings.aoColumns[ iCol ];
+	
+	/* User specified column options */
+	if ( oOptions !== undefined && oOptions !== null )
+	{
+		if ( oOptions.sType !== undefined )
+		{
+			oCol.sType = oOptions.sType;
+			oCol._bAutoType = false;
+		}
+		
+		$.extend( oCol, oOptions );
+		_fnMap( oCol, oOptions, "sWidth", "sWidthOrig" );
+
+		/* iDataSort to be applied (backwards compatibility), but aDataSort will take
+		 * priority if defined
+		 */
+		if ( oOptions.iDataSort !== undefined )
+		{
+			oCol.aDataSort = [ oOptions.iDataSort ];
+		}
+		_fnMap( oCol, oOptions, "aDataSort" );
+	}
+
+	/* Cache the data get and set functions for speed */
+	oCol.fnGetData = _fnGetObjectDataFn( oCol.mDataProp );
+	oCol.fnSetData = _fnSetObjectDataFn( oCol.mDataProp );
+	
+	/* Feature sorting overrides column specific when off */
+	if ( !oSettings.oFeatures.bSort )
+	{
+		oCol.bSortable = false;
+	}
+	
+	/* Check that the class assignment is correct for sorting */
+	if ( !oCol.bSortable ||
+		 ($.inArray('asc', oCol.asSorting) == -1 && $.inArray('desc', oCol.asSorting) == -1) )
+	{
+		oCol.sSortingClass = oSettings.oClasses.sSortableNone;
+		oCol.sSortingClassJUI = "";
+	}
+	else if ( oCol.bSortable ||
+	          ($.inArray('asc', oCol.asSorting) == -1 && $.inArray('desc', oCol.asSorting) == -1) )
+	{
+	  oCol.sSortingClass = oSettings.oClasses.sSortable;
+	  oCol.sSortingClassJUI = oSettings.oClasses.sSortJUI;
+	}
+	else if ( $.inArray('asc', oCol.asSorting) != -1 && $.inArray('desc', oCol.asSorting) == -1 )
+	{
+		oCol.sSortingClass = oSettings.oClasses.sSortableAsc;
+		oCol.sSortingClassJUI = oSettings.oClasses.sSortJUIAscAllowed;
+	}
+	else if ( $.inArray('asc', oCol.asSorting) == -1 && $.inArray('desc', oCol.asSorting) != -1 )
+	{
+		oCol.sSortingClass = oSettings.oClasses.sSortableDesc;
+		oCol.sSortingClassJUI = oSettings.oClasses.sSortJUIDescAllowed;
+	}
+}
+
+
+/**
+ * Adjust the table column widths for new data. Note: you would probably want to 
+ * do a redraw after calling this function!
+ *  @param {object} oSettings dataTables settings object
+ *  @memberof DataTable#oApi
+ */
+function _fnAdjustColumnSizing ( oSettings )
+{
+	/* Not interested in doing column width calculation if autowidth is disabled */
+	if ( oSettings.oFeatures.bAutoWidth === false )
+	{
+		return false;
+	}
+	
+	_fnCalculateColumnWidths( oSettings );
+	for ( var i=0 , iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
+	{
+		oSettings.aoColumns[i].nTh.style.width = oSettings.aoColumns[i].sWidth;
+	}
+}
+
+
+/**
+ * Covert the index of a visible column to the index in the data array (take account
+ * of hidden columns)
+ *  @param {object} oSettings dataTables settings object
+ *  @param {int} iMatch Visible column index to lookup
+ *  @returns {int} i the data index
+ *  @memberof DataTable#oApi
+ */
+function _fnVisibleToColumnIndex( oSettings, iMatch )
+{
+	var iColumn = -1;
+	
+	for ( var i=0 ; i<oSettings.aoColumns.length ; i++ )
+	{
+		if ( oSettings.aoColumns[i].bVisible === true )
+		{
+			iColumn++;
+		}
+		
+		if ( iColumn == iMatch )
+		{
+			return i;
+		}
+	}
+	
+	return null;
+}
+
+
+/**
+ * Covert the index of an index in the data array and convert it to the visible
+ *   column index (take account of hidden columns)
+ *  @param {int} iMatch Column index to lookup
+ *  @param {object} oSettings dataTables settings object
+ *  @returns {int} i the data index
+ *  @memberof DataTable#oApi
+ */
+function _fnColumnIndexToVisible( oSettings, iMatch )
+{
+	var iVisible = -1;
+	for ( var i=0 ; i<oSettings.aoColumns.length ; i++ )
+	{
+		if ( oSettings.aoColumns[i].bVisible === true )
+		{
+			iVisible++;
+		}
+		
+		if ( i == iMatch )
+		{
+			return oSettings.aoColumns[i].bVisible === true ? iVisible : null;
+		}
+	}
+	
+	return null;
+}
+
+
+/**
+ * Get the number of visible columns
+ *  @returns {int} i the number of visible columns
+ *  @param {object} oS dataTables settings object
+ *  @memberof DataTable#oApi
+ */
+function _fnVisbleColumns( oS )
+{
+	var iVis = 0;
+	for ( var i=0 ; i<oS.aoColumns.length ; i++ )
+	{
+		if ( oS.aoColumns[i].bVisible === true )
+		{
+			iVis++;
+		}
+	}
+	return iVis;
+}
+
+
+/**
+ * Get the sort type based on an input string
+ *  @param {string} sData data we wish to know the type of
+ *  @returns {string} type (defaults to 'string' if no type can be detected)
+ *  @memberof DataTable#oApi
+ */
+function _fnDetectType( sData )
+{
+	var aTypes = DataTable.ext.aTypes;
+	var iLen = aTypes.length;
+	
+	for ( var i=0 ; i<iLen ; i++ )
+	{
+		var sType = aTypes[i]( sData );
+		if ( sType !== null )
+		{
+			return sType;
+		}
+	}
+	
+	return 'string';
+}
+
+
+/**
+ * Figure out how to reorder a display list
+ *  @param {object} oSettings dataTables settings object
+ *  @returns array {int} aiReturn index list for reordering
+ *  @memberof DataTable#oApi
+ */
+function _fnReOrderIndex ( oSettings, sColumns )
+{
+	var aColumns = sColumns.split(',');
+	var aiReturn = [];
+	
+	for ( var i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
+	{
+		for ( var j=0 ; j<iLen ; j++ )
+		{
+			if ( oSettings.aoColumns[i].sName == aColumns[j] )
+			{
+				aiReturn.push( j );
+				break;
+			}
+		}
+	}
+	
+	return aiReturn;
+}
+
+
+/**
+ * Get the column ordering that DataTables expects
+ *  @param {object} oSettings dataTables settings object
+ *  @returns {string} comma separated list of names
+ *  @memberof DataTable#oApi
+ */
+function _fnColumnOrdering ( oSettings )
+{
+	var sNames = '';
+	for ( var i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
+	{
+		sNames += oSettings.aoColumns[i].sName+',';
+	}
+	if ( sNames.length == iLen )
+	{
+		return "";
+	}
+	return sNames.slice(0, -1);
+}
+
+
+/**
+ * Take the column definitions and static columns arrays and calculate how
+ * they relate to column indexes. The callback function will then apply the
+ * definition found for a column to a suitable configuration object.
+ *  @param {object} oSettings dataTables settings object
+ *  @param {array} aoColDefs The aoColumnDefs array that is to be applied
+ *  @param {array} aoCols The aoColumns array that defines columns individually
+ *  @param {function} fn Callback function - takes two parameters, the calculated
+ *    column index and the definition for that column.
+ *  @memberof DataTable#oApi
+ */
+function _fnApplyColumnDefs( oSettings, aoColDefs, aoCols, fn )
+{
+	var i, iLen, j, jLen, k, kLen;
+
+	// Column definitions with aTargets
+	if ( aoColDefs )
+	{
+		/* Loop over the definitions array - loop in reverse so first instance has priority */
+		for ( i=aoColDefs.length-1 ; i>=0 ; i-- )
+		{
+			/* Each definition can target multiple columns, as it is an array */
+			var aTargets = aoColDefs[i].aTargets;
+			if ( !$.isArray( aTargets ) )
+			{
+				_fnLog( oSettings, 1, 'aTargets must be an array of targets, not a '+(typeof aTargets) );
+			}
+
+			for ( j=0, jLen=aTargets.length ; j<jLen ; j++ )
+			{
+				if ( typeof aTargets[j] === 'number' && aTargets[j] >= 0 )
+				{
+					/* Add columns that we don't yet know about */
+					while( oSettings.aoColumns.length <= aTargets[j] )
+					{
+						_fnAddColumn( oSettings );
+					}
+
+					/* Integer, basic index */
+					fn( aTargets[j], aoColDefs[i] );
+				}
+				else if ( typeof aTargets[j] === 'number' && aTargets[j] < 0 )
+				{
+					/* Negative integer, right to left column counting */
+					fn( oSettings.aoColumns.length+aTargets[j], aoColDefs[i] );
+				}
+				else if ( typeof aTargets[j] === 'string' )
+				{
+					/* Class name matching on TH element */
+					for ( k=0, kLen=oSettings.aoColumns.length ; k<kLen ; k++ )
+					{
+						if ( aTargets[j] == "_all" ||
+						     $(oSettings.aoColumns[k].nTh).hasClass( aTargets[j] ) )
+						{
+							fn( k, aoColDefs[i] );
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// Statically defined columns array
+	if ( aoCols )
+	{
+		for ( i=0, iLen=aoCols.length ; i<iLen ; i++ )
+		{
+			fn( i, aoCols[i] );
+		}
+	}
+}
+