classiccms 0.5.5 → 0.5.6

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

@@ -0,0 +1,405 @@
+
+
+/**
+ * Generate the node required for filtering text
+ *  @returns {node} Filter control element
+ *  @param {object} oSettings dataTables settings object
+ *  @memberof DataTable#oApi
+ */
+function _fnFeatureHtmlFilter ( oSettings )
+{
+	var oPreviousSearch = oSettings.oPreviousSearch;
+	
+	var sSearchStr = oSettings.oLanguage.sSearch;
+	sSearchStr = (sSearchStr.indexOf('_INPUT_') !== -1) ?
+	  sSearchStr.replace('_INPUT_', '<input type="text" />') :
+	  sSearchStr==="" ? '<input type="text" />' : sSearchStr+' <input type="text" />';
+	
+	var nFilter = document.createElement( 'div' );
+	nFilter.className = oSettings.oClasses.sFilter;
+	nFilter.innerHTML = '<label>'+sSearchStr+'</label>';
+	if ( !oSettings.aanFeatures.f )
+	{
+		nFilter.id = oSettings.sTableId+'_filter';
+	}
+	
+	var jqFilter = $('input[type="text"]', nFilter);
+
+	// Store a reference to the input element, so other input elements could be
+	// added to the filter wrapper if needed (submit button for example)
+	nFilter._DT_Input = jqFilter[0];
+
+	jqFilter.val( oPreviousSearch.sSearch.replace('"','&quot;') );
+	jqFilter.bind( 'keyup.DT', function(e) {
+		/* Update all other filter input elements for the new display */
+		var n = oSettings.aanFeatures.f;
+		var val = this.value==="" ? "" : this.value; // mental IE8 fix :-(
+
+		for ( var i=0, iLen=n.length ; i<iLen ; i++ )
+		{
+			if ( n[i] != $(this).parents('div.dataTables_filter')[0] )
+			{
+				$(n[i]._DT_Input).val( val );
+			}
+		}
+		
+		/* Now do the filter */
+		if ( val != oPreviousSearch.sSearch )
+		{
+			_fnFilterComplete( oSettings, { 
+				"sSearch": val, 
+				"bRegex": oPreviousSearch.bRegex,
+				"bSmart": oPreviousSearch.bSmart ,
+				"bCaseInsensitive": oPreviousSearch.bCaseInsensitive 
+			} );
+		}
+	} );
+
+	jqFilter
+		.attr('aria-controls', oSettings.sTableId)
+		.bind( 'keypress.DT', function(e) {
+			/* Prevent form submission */
+			if ( e.keyCode == 13 )
+			{
+				return false;
+			}
+		}
+	);
+	
+	return nFilter;
+}
+
+
+/**
+ * Filter the table using both the global filter and column based filtering
+ *  @param {object} oSettings dataTables settings object
+ *  @param {object} oSearch search information
+ *  @param {int} [iForce] force a research of the master array (1) or not (undefined or 0)
+ *  @memberof DataTable#oApi
+ */
+function _fnFilterComplete ( oSettings, oInput, iForce )
+{
+	var oPrevSearch = oSettings.oPreviousSearch;
+	var aoPrevSearch = oSettings.aoPreSearchCols;
+	var fnSaveFilter = function ( oFilter ) {
+		/* Save the filtering values */
+		oPrevSearch.sSearch = oFilter.sSearch;
+		oPrevSearch.bRegex = oFilter.bRegex;
+		oPrevSearch.bSmart = oFilter.bSmart;
+		oPrevSearch.bCaseInsensitive = oFilter.bCaseInsensitive;
+	};
+
+	/* In server-side processing all filtering is done by the server, so no point hanging around here */
+	if ( !oSettings.oFeatures.bServerSide )
+	{
+		/* Global filter */
+		_fnFilter( oSettings, oInput.sSearch, iForce, oInput.bRegex, oInput.bSmart, oInput.bCaseInsensitive );
+		fnSaveFilter( oInput );
+
+		/* Now do the individual column filter */
+		for ( var i=0 ; i<oSettings.aoPreSearchCols.length ; i++ )
+		{
+			_fnFilterColumn( oSettings, aoPrevSearch[i].sSearch, i, aoPrevSearch[i].bRegex, 
+				aoPrevSearch[i].bSmart, aoPrevSearch[i].bCaseInsensitive );
+		}
+		
+		/* Custom filtering */
+		_fnFilterCustom( oSettings );
+	}
+	else
+	{
+		fnSaveFilter( oInput );
+	}
+	
+	/* Tell the draw function we have been filtering */
+	oSettings.bFiltered = true;
+	$(oSettings.oInstance).trigger('filter', oSettings);
+	
+	/* Redraw the table */
+	oSettings._iDisplayStart = 0;
+	_fnCalculateEnd( oSettings );
+	_fnDraw( oSettings );
+	
+	/* Rebuild search array 'offline' */
+	_fnBuildSearchArray( oSettings, 0 );
+}
+
+
+/**
+ * Apply custom filtering functions
+ *  @param {object} oSettings dataTables settings object
+ *  @memberof DataTable#oApi
+ */
+function _fnFilterCustom( oSettings )
+{
+	var afnFilters = DataTable.ext.afnFiltering;
+	for ( var i=0, iLen=afnFilters.length ; i<iLen ; i++ )
+	{
+		var iCorrector = 0;
+		for ( var j=0, jLen=oSettings.aiDisplay.length ; j<jLen ; j++ )
+		{
+			var iDisIndex = oSettings.aiDisplay[j-iCorrector];
+			
+			/* Check if we should use this row based on the filtering function */
+			if ( !afnFilters[i]( oSettings, _fnGetRowData( oSettings, iDisIndex, 'filter' ), iDisIndex ) )
+			{
+				oSettings.aiDisplay.splice( j-iCorrector, 1 );
+				iCorrector++;
+			}
+		}
+	}
+}
+
+
+/**
+ * Filter the table on a per-column basis
+ *  @param {object} oSettings dataTables settings object
+ *  @param {string} sInput string to filter on
+ *  @param {int} iColumn column to filter
+ *  @param {bool} bRegex treat search string as a regular expression or not
+ *  @param {bool} bSmart use smart filtering or not
+ *  @param {bool} bCaseInsensitive Do case insenstive matching or not
+ *  @memberof DataTable#oApi
+ */
+function _fnFilterColumn ( oSettings, sInput, iColumn, bRegex, bSmart, bCaseInsensitive )
+{
+	if ( sInput === "" )
+	{
+		return;
+	}
+	
+	var iIndexCorrector = 0;
+	var rpSearch = _fnFilterCreateSearch( sInput, bRegex, bSmart, bCaseInsensitive );
+	
+	for ( var i=oSettings.aiDisplay.length-1 ; i>=0 ; i-- )
+	{
+		var sData = _fnDataToSearch( _fnGetCellData( oSettings, oSettings.aiDisplay[i], iColumn, 'filter' ),
+			oSettings.aoColumns[iColumn].sType );
+		if ( ! rpSearch.test( sData ) )
+		{
+			oSettings.aiDisplay.splice( i, 1 );
+			iIndexCorrector++;
+		}
+	}
+}
+
+
+/**
+ * Filter the data table based on user input and draw the table
+ *  @param {object} oSettings dataTables settings object
+ *  @param {string} sInput string to filter on
+ *  @param {int} iForce optional - force a research of the master array (1) or not (undefined or 0)
+ *  @param {bool} bRegex treat as a regular expression or not
+ *  @param {bool} bSmart perform smart filtering or not
+ *  @param {bool} bCaseInsensitive Do case insenstive matching or not
+ *  @memberof DataTable#oApi
+ */
+function _fnFilter( oSettings, sInput, iForce, bRegex, bSmart, bCaseInsensitive )
+{
+	var i;
+	var rpSearch = _fnFilterCreateSearch( sInput, bRegex, bSmart, bCaseInsensitive );
+	var oPrevSearch = oSettings.oPreviousSearch;
+	
+	/* Check if we are forcing or not - optional parameter */
+	if ( !iForce )
+	{
+		iForce = 0;
+	}
+	
+	/* Need to take account of custom filtering functions - always filter */
+	if ( DataTable.ext.afnFiltering.length !== 0 )
+	{
+		iForce = 1;
+	}
+	
+	/*
+	 * If the input is blank - we want the full data set
+	 */
+	if ( sInput.length <= 0 )
+	{
+		oSettings.aiDisplay.splice( 0, oSettings.aiDisplay.length);
+		oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
+	}
+	else
+	{
+		/*
+		 * We are starting a new search or the new search string is smaller 
+		 * then the old one (i.e. delete). Search from the master array
+	 	 */
+		if ( oSettings.aiDisplay.length == oSettings.aiDisplayMaster.length ||
+			   oPrevSearch.sSearch.length > sInput.length || iForce == 1 ||
+			   sInput.indexOf(oPrevSearch.sSearch) !== 0 )
+		{
+			/* Nuke the old display array - we are going to rebuild it */
+			oSettings.aiDisplay.splice( 0, oSettings.aiDisplay.length);
+			
+			/* Force a rebuild of the search array */
+			_fnBuildSearchArray( oSettings, 1 );
+			
+			/* Search through all records to populate the search array
+			 * The the oSettings.aiDisplayMaster and asDataSearch arrays have 1 to 1 
+			 * mapping
+			 */
+			for ( i=0 ; i<oSettings.aiDisplayMaster.length ; i++ )
+			{
+				if ( rpSearch.test(oSettings.asDataSearch[i]) )
+				{
+					oSettings.aiDisplay.push( oSettings.aiDisplayMaster[i] );
+				}
+			}
+	  }
+	  else
+		{
+	  	/* Using old search array - refine it - do it this way for speed
+	  	 * Don't have to search the whole master array again
+			 */
+	  	var iIndexCorrector = 0;
+	  	
+	  	/* Search the current results */
+	  	for ( i=0 ; i<oSettings.asDataSearch.length ; i++ )
+			{
+	  		if ( ! rpSearch.test(oSettings.asDataSearch[i]) )
+				{
+	  			oSettings.aiDisplay.splice( i-iIndexCorrector, 1 );
+	  			iIndexCorrector++;
+	  		}
+	  	}
+	  }
+	}
+}
+
+
+/**
+ * Create an array which can be quickly search through
+ *  @param {object} oSettings dataTables settings object
+ *  @param {int} iMaster use the master data array - optional
+ *  @memberof DataTable#oApi
+ */
+function _fnBuildSearchArray ( oSettings, iMaster )
+{
+	if ( !oSettings.oFeatures.bServerSide )
+	{
+		/* Clear out the old data */
+		oSettings.asDataSearch.splice( 0, oSettings.asDataSearch.length );
+		
+		var aArray = (iMaster && iMaster===1) ?
+		 	oSettings.aiDisplayMaster : oSettings.aiDisplay;
+		
+		for ( var i=0, iLen=aArray.length ; i<iLen ; i++ )
+		{
+			oSettings.asDataSearch[i] = _fnBuildSearchRow( oSettings,
+				_fnGetRowData( oSettings, aArray[i], 'filter' ) );
+		}
+	}
+}
+
+
+/**
+ * Create a searchable string from a single data row
+ *  @param {object} oSettings dataTables settings object
+ *  @param {array} aData Row data array to use for the data to search
+ *  @memberof DataTable#oApi
+ */
+function _fnBuildSearchRow( oSettings, aData )
+{
+	var sSearch = '';
+	if ( oSettings.__nTmpFilter === undefined )
+	{
+		oSettings.__nTmpFilter = document.createElement('div');
+	}
+	var nTmp = oSettings.__nTmpFilter;
+	
+	for ( var j=0, jLen=oSettings.aoColumns.length ; j<jLen ; j++ )
+	{
+		if ( oSettings.aoColumns[j].bSearchable )
+		{
+			var sData = aData[j];
+			sSearch += _fnDataToSearch( sData, oSettings.aoColumns[j].sType )+'  ';
+		}
+	}
+	
+	/* If it looks like there is an HTML entity in the string, attempt to decode it */
+	if ( sSearch.indexOf('&') !== -1 )
+	{
+		nTmp.innerHTML = sSearch;
+		sSearch = nTmp.textContent ? nTmp.textContent : nTmp.innerText;
+		
+		/* IE and Opera appear to put an newline where there is a <br> tag - remove it */
+		sSearch = sSearch.replace(/\n/g," ").replace(/\r/g,"");
+	}
+	
+	return sSearch;
+}
+
+/**
+ * Build a regular expression object suitable for searching a table
+ *  @param {string} sSearch string to search for
+ *  @param {bool} bRegex treat as a regular expression or not
+ *  @param {bool} bSmart perform smart filtering or not
+ *  @param {bool} bCaseInsensitive Do case insenstive matching or not
+ *  @returns {RegExp} constructed object
+ *  @memberof DataTable#oApi
+ */
+function _fnFilterCreateSearch( sSearch, bRegex, bSmart, bCaseInsensitive )
+{
+	var asSearch, sRegExpString;
+	
+	if ( bSmart )
+	{
+		/* Generate the regular expression to use. Something along the lines of:
+		 * ^(?=.*?\bone\b)(?=.*?\btwo\b)(?=.*?\bthree\b).*$
+		 */
+		asSearch = bRegex ? sSearch.split( ' ' ) : _fnEscapeRegex( sSearch ).split( ' ' );
+		sRegExpString = '^(?=.*?'+asSearch.join( ')(?=.*?' )+').*$';
+		return new RegExp( sRegExpString, bCaseInsensitive ? "i" : "" );
+	}
+	else
+	{
+		sSearch = bRegex ? sSearch : _fnEscapeRegex( sSearch );
+		return new RegExp( sSearch, bCaseInsensitive ? "i" : "" );
+	}
+}
+
+
+/**
+ * Convert raw data into something that the user can search on
+ *  @param {string} sData data to be modified
+ *  @param {string} sType data type
+ *  @returns {string} search string
+ *  @memberof DataTable#oApi
+ */
+function _fnDataToSearch ( sData, sType )
+{
+	if ( typeof DataTable.ext.ofnSearch[sType] === "function" )
+	{
+		return DataTable.ext.ofnSearch[sType]( sData );
+	}
+	else if ( sData === null )
+	{
+		return '';
+	}
+	else if ( sType == "html" )
+	{
+		return sData.replace(/[\r\n]/g," ").replace( /<.*?>/g, "" );
+	}
+	else if ( typeof sData === "string" )
+	{
+		return sData.replace(/[\r\n]/g," ");
+	}
+	return sData;
+}
+
+
+/**
+ * scape a string stuch that it can be used in a regular expression
+ *  @param {string} sVal string to escape
+ *  @returns {string} escaped string
+ *  @memberof DataTable#oApi
+ */
+function _fnEscapeRegex ( sVal )
+{
+	var acEscape = [ '/', '.', '*', '+', '?', '|', '(', ')', '[', ']', '{', '}', '\\', '$', '^', '-' ];
+	var reReplace = new RegExp( '(\\' + acEscape.join('|\\') + ')', 'g' );
+	return sVal.replace(reReplace, '\\$1');
+}
+

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

@@ -0,0 +1,117 @@
+
+
+/**
+ * Generate the node required for the info display
+ *  @param {object} oSettings dataTables settings object
+ *  @returns {node} Information element
+ *  @memberof DataTable#oApi
+ */
+function _fnFeatureHtmlInfo ( oSettings )
+{
+	var nInfo = document.createElement( 'div' );
+	nInfo.className = oSettings.oClasses.sInfo;
+	
+	/* Actions that are to be taken once only for this feature */
+	if ( !oSettings.aanFeatures.i )
+	{
+		/* Add draw callback */
+		oSettings.aoDrawCallback.push( {
+			"fn": _fnUpdateInfo,
+			"sName": "information"
+		} );
+		
+		/* Add id */
+		nInfo.id = oSettings.sTableId+'_info';
+	}
+	oSettings.nTable.setAttribute( 'aria-describedby', oSettings.sTableId+'_info' );
+	
+	return nInfo;
+}
+
+
+/**
+ * Update the information elements in the display
+ *  @param {object} oSettings dataTables settings object
+ *  @memberof DataTable#oApi
+ */
+function _fnUpdateInfo ( oSettings )
+{
+	/* Show information about the table */
+	if ( !oSettings.oFeatures.bInfo || oSettings.aanFeatures.i.length === 0 )
+	{
+		return;
+	}
+	
+	var
+		oLang = oSettings.oLanguage,
+		iStart = oSettings._iDisplayStart+1,
+		iEnd = oSettings.fnDisplayEnd(),
+		iMax = oSettings.fnRecordsTotal(),
+		iTotal = oSettings.fnRecordsDisplay(),
+		sOut;
+	
+	if ( iTotal === 0 && iTotal == iMax )
+	{
+		/* Empty record set */
+		sOut = oLang.sInfoEmpty;
+	}
+	else if ( iTotal === 0 )
+	{
+		/* Empty record set after filtering */
+		sOut = oLang.sInfoEmpty +' '+ oLang.sInfoFiltered;
+	}
+	else if ( iTotal == iMax )
+	{
+		/* Normal record set */
+		sOut = oLang.sInfo;
+	}
+	else
+	{
+		/* Record set after filtering */
+		sOut = oLang.sInfo +' '+ oLang.sInfoFiltered;
+	}
+
+	// Convert the macros
+	sOut += oLang.sInfoPostFix;
+	sOut = _fnInfoMacros( oSettings, sOut );
+	
+	if ( oLang.fnInfoCallback !== null )
+	{
+		sOut = oLang.fnInfoCallback.call( oSettings.oInstance, 
+			oSettings, iStart, iEnd, iMax, iTotal, sOut );
+	}
+	
+	var n = oSettings.aanFeatures.i;
+	for ( var i=0, iLen=n.length ; i<iLen ; i++ )
+	{
+		$(n[i]).html( sOut );
+	}
+}
+
+
+function _fnInfoMacros ( oSettings, str )
+{
+	var
+		iStart = oSettings._iDisplayStart+1,
+		sStart = oSettings.fnFormatNumber( iStart ),
+		iEnd = oSettings.fnDisplayEnd(),
+		sEnd = oSettings.fnFormatNumber( iEnd ),
+		iTotal = oSettings.fnRecordsDisplay(),
+		sTotal = oSettings.fnFormatNumber( iTotal ),
+		iMax = oSettings.fnRecordsTotal(),
+		sMax = oSettings.fnFormatNumber( iMax );
+
+	// When infinite scrolling, we are always starting at 1. _iDisplayStart is used only
+	// internally
+	if ( oSettings.oScroll.bInfinite )
+	{
+		sStart = oSettings.fnFormatNumber( 1 );
+	}
+
+	return str.
+		replace('_START_', sStart).
+		replace('_END_',   sEnd).
+		replace('_TOTAL_', sTotal).
+		replace('_MAX_',   sMax);
+}
+

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

@@ -0,0 +1,153 @@
+
+
+/**
+ * Draw the table for the first time, adding all required features
+ *  @param {object} oSettings dataTables settings object
+ *  @memberof DataTable#oApi
+ */
+function _fnInitialise ( oSettings )
+{
+	var i, iLen, iAjaxStart=oSettings.iInitDisplayStart;
+	
+	/* Ensure that the table data is fully initialised */
+	if ( oSettings.bInitialised === false )
+	{
+		setTimeout( function(){ _fnInitialise( oSettings ); }, 200 );
+		return;
+	}
+	
+	/* Show the display HTML options */
+	_fnAddOptionsHtml( oSettings );
+	
+	/* Build and draw the header / footer for the table */
+	_fnBuildHead( oSettings );
+	_fnDrawHead( oSettings, oSettings.aoHeader );
+	if ( oSettings.nTFoot )
+	{
+		_fnDrawHead( oSettings, oSettings.aoFooter );
+	}
+
+	/* Okay to show that something is going on now */
+	_fnProcessingDisplay( oSettings, true );
+	
+	/* Calculate sizes for columns */
+	if ( oSettings.oFeatures.bAutoWidth )
+	{
+		_fnCalculateColumnWidths( oSettings );
+	}
+	
+	for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
+	{
+		if ( oSettings.aoColumns[i].sWidth !== null )
+		{
+			oSettings.aoColumns[i].nTh.style.width = _fnStringToCss( oSettings.aoColumns[i].sWidth );
+		}
+	}
+	
+	/* If there is default sorting required - let's do it. The sort function will do the
+	 * drawing for us. Otherwise we draw the table regardless of the Ajax source - this allows
+	 * the table to look initialised for Ajax sourcing data (show 'loading' message possibly)
+	 */
+	if ( oSettings.oFeatures.bSort )
+	{
+		_fnSort( oSettings );
+	}
+	else if ( oSettings.oFeatures.bFilter )
+	{
+		_fnFilterComplete( oSettings, oSettings.oPreviousSearch );
+	}
+	else
+	{
+		oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
+		_fnCalculateEnd( oSettings );
+		_fnDraw( oSettings );
+	}
+	
+	/* if there is an ajax source load the data */
+	if ( oSettings.sAjaxSource !== null && !oSettings.oFeatures.bServerSide )
+	{
+		var aoData = [];
+		_fnServerParams( oSettings, aoData );
+		oSettings.fnServerData.call( oSettings.oInstance, oSettings.sAjaxSource, aoData, function(json) {
+			var aData = (oSettings.sAjaxDataProp !== "") ?
+			 	_fnGetObjectDataFn( oSettings.sAjaxDataProp )(json) : json;
+
+			/* Got the data - add it to the table */
+			for ( i=0 ; i<aData.length ; i++ )
+			{
+				_fnAddData( oSettings, aData[i] );
+			}
+			
+			/* Reset the init display for cookie saving. We've already done a filter, and
+			 * therefore cleared it before. So we need to make it appear 'fresh'
+			 */
+			oSettings.iInitDisplayStart = iAjaxStart;
+			
+			if ( oSettings.oFeatures.bSort )
+			{
+				_fnSort( oSettings );
+			}
+			else
+			{
+				oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
+				_fnCalculateEnd( oSettings );
+				_fnDraw( oSettings );
+			}
+			
+			_fnProcessingDisplay( oSettings, false );
+			_fnInitComplete( oSettings, json );
+		}, oSettings );
+		return;
+	}
+	
+	/* Server-side processing initialisation complete is done at the end of _fnDraw */
+	if ( !oSettings.oFeatures.bServerSide )
+	{
+		_fnProcessingDisplay( oSettings, false );
+		_fnInitComplete( oSettings );
+	}
+}
+
+
+/**
+ * Draw the table for the first time, adding all required features
+ *  @param {object} oSettings dataTables settings object
+ *  @param {object} [json] JSON from the server that completed the table, if using Ajax source
+ *    with client-side processing (optional)
+ *  @memberof DataTable#oApi
+ */
+function _fnInitComplete ( oSettings, json )
+{
+	oSettings._bInitComplete = true;
+	_fnCallbackFire( oSettings, 'aoInitComplete', 'init', [oSettings, json] );
+}
+
+
+/**
+ * Language compatibility - when certain options are given, and others aren't, we
+ * need to duplicate the values over, in order to provide backwards compatibility
+ * with older language files.
+ *  @param {object} oSettings dataTables settings object
+ *  @memberof DataTable#oApi
+ */
+function _fnLanguageCompat( oLanguage )
+{
+	var oDefaults = DataTable.defaults.oLanguage;
+
+	/* Backwards compatibility - if there is no sEmptyTable given, then use the same as
+	 * sZeroRecords - assuming that is given.
+	 */
+	if ( !oLanguage.sEmptyTable && oLanguage.sZeroRecords &&
+		oDefaults.sEmptyTable === "No data available in table" )
+	{
+		_fnMap( oLanguage, oLanguage, 'sZeroRecords', 'sEmptyTable' );
+	}
+
+	/* Likewise with loading records */
+	if ( !oLanguage.sLoadingRecords && oLanguage.sZeroRecords &&
+		oDefaults.sLoadingRecords === "Loading..." )
+	{
+		_fnMap( oLanguage, oLanguage, 'sZeroRecords', 'sLoadingRecords' );
+	}
+}
+