EDIT

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/DataTables.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/api/api.internal.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/api/api.methods.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/api/api.static.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/core/core.ajax.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/core/core.columns.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/core/core.constructor.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/core/core.data.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/core/core.draw.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/core/core.filter.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/core/core.info.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/core/core.init.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/core/core.length.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/core/core.page.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/core/core.processing.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/core/core.scrolling.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/core/core.sizing.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/core/core.sort.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/core/core.state.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/core/core.support.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/ext/ext.classes.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/ext/ext.paging.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/ext/ext.sorting.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/ext/ext.types.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/model/model.column.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/model/model.defaults.columns.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/model/model.defaults.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/model/model.ext.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/model/model.row.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/model/model.search.js -text

7.x/modules/cdm_dataportal/js/DataTables-1.9.4/media/src/model/model.settings.js -text

/**

 * @summary     DataTables

 * @description Paginate, search and sort HTML tables

 * @version     1.9.4

 * @file        jquery.dataTables.js

 * @author      Allan Jardine (www.sprymedia.co.uk)

 * @contact     www.sprymedia.co.uk/contact

 *

 * @copyright Copyright 2008-2012 Allan Jardine, all rights reserved.

 *

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

 * BSD style license, available at:

 *   http://datatables.net/license_gpl2

 *   http://datatables.net/license_bsd

 * 

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

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

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

 * 

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

 */

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

/*globals $, jQuery,define,_fnExternApiFunc,_fnInitialise,_fnInitComplete,_fnLanguageCompat,_fnAddColumn,_fnColumnOptions,_fnAddData,_fnCreateTr,_fnGatherData,_fnBuildHead,_fnDrawHead,_fnDraw,_fnReDraw,_fnAjaxUpdate,_fnAjaxParameters,_fnAjaxUpdateDraw,_fnServerParams,_fnAddOptionsHtml,_fnFeatureHtmlTable,_fnScrollDraw,_fnAdjustColumnSizing,_fnFeatureHtmlFilter,_fnFilterComplete,_fnFilterCustom,_fnFilterColumn,_fnFilter,_fnBuildSearchArray,_fnBuildSearchRow,_fnFilterCreateSearch,_fnDataToSearch,_fnSort,_fnSortAttachListener,_fnSortingClasses,_fnFeatureHtmlPaginate,_fnPageChange,_fnFeatureHtmlInfo,_fnUpdateInfo,_fnFeatureHtmlLength,_fnFeatureHtmlProcessing,_fnProcessingDisplay,_fnVisibleToColumnIndex,_fnColumnIndexToVisible,_fnNodeToDataIndex,_fnVisbleColumns,_fnCalculateEnd,_fnConvertToWidth,_fnCalculateColumnWidths,_fnScrollingWidthAdjust,_fnGetWidestNode,_fnGetMaxLenString,_fnStringToCss,_fnDetectType,_fnSettingsFromNode,_fnGetDataMaster,_fnGetTrNodes,_fnGetTdNodes,_fnEscapeRegex,_fnDeleteIndex,_fnReOrderIndex,_fnColumnOrdering,_fnLog,_fnClearTable,_fnSaveState,_fnLoadState,_fnCreateCookie,_fnReadCookie,_fnDetectHeader,_fnGetUniqueThs,_fnScrollBarWidth,_fnApplyToChildren,_fnMap,_fnGetRowData,_fnGetCellData,_fnSetCellData,_fnGetObjectDataFn,_fnSetObjectDataFn,_fnApplyColumnDefs,_fnBindAction,_fnCallbackReg,_fnCallbackFire,_fnJsonString,_fnRender,_fnNodeToColumnIndex,_fnInfoMacros,_fnBrowserDetect,_fnGetColumns*/

(/** @lends <global> */function( window, document, undefined ) {

(function( factory ) {

	"use strict";

	// Define as an AMD module if possible

	if ( typeof define === 'function' && define.amd )

	{

		define( ['jquery'], factory );

	}

	/* Define using browser globals otherwise

	 * Prevent multiple instantiations if the script is loaded twice

	 */

	else if ( jQuery && !jQuery.fn.dataTable )

	{

		factory( jQuery );

	}

}

(/** @lends <global> */function( $ ) {

	"use strict";

	/** 

	 * DataTables is a plug-in for the jQuery Javascript library. It is a 

	 * highly flexible tool, based upon the foundations of progressive 

	 * enhancement, which will add advanced interaction controls to any 

	 * HTML table. For a full list of features please refer to

	 * <a href="http://datatables.net">DataTables.net</a>.

	 *

	 * Note that the <i>DataTable</i> object is not a global variable but is

	 * aliased to <i>jQuery.fn.DataTable</i> and <i>jQuery.fn.dataTable</i> through which 

	 * it may be  accessed.

	 *

	 *  @class

	 *  @param {object} [oInit={}] Configuration object for DataTables. Options

	 *    are defined by {@link DataTable.defaults}

	 *  @requires jQuery 1.3+

	 * 

	 *  @example

	 *    // Basic initialisation

	 *    $(document).ready( function {

	 *      $('#example').dataTable();

	 *    } );

	 *  

	 *  @example

	 *    // Initialisation with configuration options - in this case, disable

	 *    // pagination and sorting.

	 *    $(document).ready( function {

	 *      $('#example').dataTable( {

	 *        "bPaginate": false,

	 *        "bSort": false 

	 *      } );

	 *    } );

	 */

	var DataTable = function( oInit )

	{

		require('core.columns.js');

		require('core.data.js');

		require('core.draw.js');

		require('core.ajax.js');

		require('core.filter.js');

		require('core.info.js');

		require('core.init.js');

		require('core.length.js');

		require('core.page.js');

		require('core.processing.js');

		require('core.scrolling.js');

		require('core.sizing.js');

		require('core.sort.js');

		require('core.state.js');

		require('core.support.js');

		require('api.methods.js');

		require('api.internal.js');

		var _that = this;

		this.each(function() {

			require('core.constructor.js');

		} );

		_that = null;

		return this;

	};

	require('api.static.js');

	/**

	 * Version string for plug-ins to check compatibility. Allowed format is

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

	 * e are optional

	 *  @member

	 *  @type string

	 *  @default Version number

	 */

	DataTable.version = "1.9.4";

	/**

	 * Private data store, containing all of the settings objects that are created for the

	 * tables on a given page.

	 * 

	 * Note that the <i>DataTable.settings</i> object is aliased to <i>jQuery.fn.dataTableExt</i> 

	 * through which it may be accessed and manipulated, or <i>jQuery.fn.dataTable.settings</i>.

	 *  @member

	 *  @type array

	 *  @default []

	 *  @private

	 */

	DataTable.settings = [];

	/**

	 * Object models container, for the various models that DataTables has available

	 * to it. These models define the objects that are used to hold the active state 

	 * and configuration of the table.

	 *  @namespace

	 */

	DataTable.models = {};

	require('model.ext.js');

	require('model.search.js');

	require('model.row.js');

	require('model.column.js');

	require('model.defaults.js');

	require('model.defaults.columns.js');

	require('model.settings.js');

	/**

	 * Extension object for DataTables that is used to provide all extension options.

	 * 

	 * Note that the <i>DataTable.ext</i> object is available through

	 * <i>jQuery.fn.dataTable.ext</i> where it may be accessed and manipulated. It is

	 * also aliased to <i>jQuery.fn.dataTableExt</i> for historic reasons.

	 *  @namespace

	 *  @extends DataTable.models.ext

	 */

	DataTable.ext = $.extend( true, {}, DataTable.models.ext );

	require('ext.classes.js');

	require('ext.paging.js');

	require('ext.sorting.js');

	require('ext.types.js');

	// jQuery aliases

	$.fn.DataTable = DataTable;

	$.fn.dataTable = DataTable;

	$.fn.dataTableSettings = DataTable.settings;

	$.fn.dataTableExt = DataTable.ext;

	// Information about events fired by DataTables - for documentation.

	/**

	 * Draw event, fired whenever the table is redrawn on the page, at the same point as

	 * fnDrawCallback. This may be useful for binding events or performing calculations when

	 * the table is altered at all.

	 *  @name DataTable#draw

	 *  @event

	 *  @param {event} e jQuery event object

	 *  @param {object} o DataTables settings object {@link DataTable.models.oSettings}

	 */

	/**

	 * Filter event, fired when the filtering applied to the table (using the build in global

	 * global filter, or column filters) is altered.

	 *  @name DataTable#filter

	 *  @event

	 *  @param {event} e jQuery event object

	 *  @param {object} o DataTables settings object {@link DataTable.models.oSettings}

	 */

	/**

	 * Page change event, fired when the paging of the table is altered.

	 *  @name DataTable#page

	 *  @event

	 *  @param {event} e jQuery event object

	 *  @param {object} o DataTables settings object {@link DataTable.models.oSettings}

	 */

	/**

	 * Sort event, fired when the sorting applied to the table is altered.

	 *  @name DataTable#sort

	 *  @event

	 *  @param {event} e jQuery event object

	 *  @param {object} o DataTables settings object {@link DataTable.models.oSettings}

	 */

	/**

	 * DataTables initialisation complete event, fired when the table is fully drawn,

	 * including Ajax data loaded, if Ajax data is required.

	 *  @name DataTable#init

	 *  @event

	 *  @param {event} e jQuery event object

	 *  @param {object} oSettings DataTables settings object

	 *  @param {object} json The JSON object request from the server - only

	 *    present if client-side Ajax sourced data is used</li></ol>

	 */

	/**

	 * State save event, fired when the table has changed state a new state save is required.

	 * This method allows modification of the state saving object prior to actually doing the

	 * save, including addition or other state properties (for plug-ins) or modification

	 * of a DataTables core property.

	 *  @name DataTable#stateSaveParams

	 *  @event

	 *  @param {event} e jQuery event object

	 *  @param {object} oSettings DataTables settings object

	 *  @param {object} json The state information to be saved

	 */

	/**

	 * State load event, fired when the table is loading state from the stored data, but

	 * prior to the settings object being modified by the saved state - allowing modification

	 * of the saved state is required or loading of state for a plug-in.

	 *  @name DataTable#stateLoadParams

	 *  @event

	 *  @param {event} e jQuery event object

	 *  @param {object} oSettings DataTables settings object

	 *  @param {object} json The saved state information

	 */

	/**

	 * State loaded event, fired when state has been loaded from stored data and the settings

	 * object has been modified by the loaded data.

	 *  @name DataTable#stateLoaded

	 *  @event

	 *  @param {event} e jQuery event object

	 *  @param {object} oSettings DataTables settings object

	 *  @param {object} json The saved state information

	 */

	/**

	 * Processing event, fired when DataTables is doing some kind of processing (be it,

	 * sort, filter or anything else). Can be used to indicate to the end user that

	 * there is something happening, or that something has finished.

	 *  @name DataTable#processing

	 *  @event

	 *  @param {event} e jQuery event object

	 *  @param {object} oSettings DataTables settings object

	 *  @param {boolean} bShow Flag for if DataTables is doing processing or not

	 */

	/**

	 * Ajax (XHR) event, fired whenever an Ajax request is completed from a request to 

	 * made to the server for new data (note that this trigger is called in fnServerData,

	 * if you override fnServerData and which to use this event, you need to trigger it in

	 * you success function).

	 *  @name DataTable#xhr

	 *  @event

	 *  @param {event} e jQuery event object

	 *  @param {object} o DataTables settings object {@link DataTable.models.oSettings}

	 *  @param {object} json JSON returned from the server

	 */

	/**

	 * Destroy event, fired when the DataTable is destroyed by calling fnDestroy or passing

	 * the bDestroy:true parameter in the initialisation object. This can be used to remove

	 * bound events, added DOM nodes, etc.

	 *  @name DataTable#destroy

	 *  @event

	 *  @param {event} e jQuery event object

	 *  @param {object} o DataTables settings object {@link DataTable.models.oSettings}

	 */

}));

}(window, document));

/*

 * This is really a good bit rubbish this method of exposing the internal methods

 * publicly... - To be fixed in 2.0 using methods on the prototype

 */

/**

 * Create a wrapper function for exporting an internal functions to an external API.

 *  @param {string} sFunc API function name

 *  @returns {function} wrapped function

 *  @memberof DataTable#oApi

 */

function _fnExternApiFunc (sFunc)

{

	return function() {

		var aArgs = [_fnSettingsFromNode(this[DataTable.ext.iApiIndex])].concat( 

			Array.prototype.slice.call(arguments) );

		return DataTable.ext.oApi[sFunc].apply( this, aArgs );

	};

}

/**

 * Reference to internal functions for use by plug-in developers. Note that these

 * methods are references to internal functions and are considered to be private.

 * If you use these methods, be aware that they are liable to change between versions

 * (check the upgrade notes).

 *  @namespace

 */

this.oApi = {

	"_fnExternApiFunc": _fnExternApiFunc,

	"_fnInitialise": _fnInitialise,

	"_fnInitComplete": _fnInitComplete,

	"_fnLanguageCompat": _fnLanguageCompat,

	"_fnAddColumn": _fnAddColumn,

	"_fnColumnOptions": _fnColumnOptions,

	"_fnAddData": _fnAddData,

	"_fnCreateTr": _fnCreateTr,

	"_fnGatherData": _fnGatherData,

	"_fnBuildHead": _fnBuildHead,

	"_fnDrawHead": _fnDrawHead,

	"_fnDraw": _fnDraw,

	"_fnReDraw": _fnReDraw,

	"_fnAjaxUpdate": _fnAjaxUpdate,

	"_fnAjaxParameters": _fnAjaxParameters,

	"_fnAjaxUpdateDraw": _fnAjaxUpdateDraw,

	"_fnServerParams": _fnServerParams,

	"_fnAddOptionsHtml": _fnAddOptionsHtml,

	"_fnFeatureHtmlTable": _fnFeatureHtmlTable,

	"_fnScrollDraw": _fnScrollDraw,

	"_fnAdjustColumnSizing": _fnAdjustColumnSizing,

	"_fnFeatureHtmlFilter": _fnFeatureHtmlFilter,

	"_fnFilterComplete": _fnFilterComplete,

	"_fnFilterCustom": _fnFilterCustom,

	"_fnFilterColumn": _fnFilterColumn,

	"_fnFilter": _fnFilter,

	"_fnBuildSearchArray": _fnBuildSearchArray,

	"_fnBuildSearchRow": _fnBuildSearchRow,

	"_fnFilterCreateSearch": _fnFilterCreateSearch,

	"_fnDataToSearch": _fnDataToSearch,

	"_fnSort": _fnSort,

	"_fnSortAttachListener": _fnSortAttachListener,

	"_fnSortingClasses": _fnSortingClasses,

	"_fnFeatureHtmlPaginate": _fnFeatureHtmlPaginate,

	"_fnPageChange": _fnPageChange,

	"_fnFeatureHtmlInfo": _fnFeatureHtmlInfo,

	"_fnUpdateInfo": _fnUpdateInfo,

	"_fnFeatureHtmlLength": _fnFeatureHtmlLength,

	"_fnFeatureHtmlProcessing": _fnFeatureHtmlProcessing,

	"_fnProcessingDisplay": _fnProcessingDisplay,

	"_fnVisibleToColumnIndex": _fnVisibleToColumnIndex,

	"_fnColumnIndexToVisible": _fnColumnIndexToVisible,

	"_fnNodeToDataIndex": _fnNodeToDataIndex,

	"_fnVisbleColumns": _fnVisbleColumns,

	"_fnCalculateEnd": _fnCalculateEnd,

	"_fnConvertToWidth": _fnConvertToWidth,

	"_fnCalculateColumnWidths": _fnCalculateColumnWidths,

	"_fnScrollingWidthAdjust": _fnScrollingWidthAdjust,

	"_fnGetWidestNode": _fnGetWidestNode,

	"_fnGetMaxLenString": _fnGetMaxLenString,

	"_fnStringToCss": _fnStringToCss,

	"_fnDetectType": _fnDetectType,

	"_fnSettingsFromNode": _fnSettingsFromNode,

	"_fnGetDataMaster": _fnGetDataMaster,

	"_fnGetTrNodes": _fnGetTrNodes,

	"_fnGetTdNodes": _fnGetTdNodes,

	"_fnEscapeRegex": _fnEscapeRegex,

	"_fnDeleteIndex": _fnDeleteIndex,

	"_fnReOrderIndex": _fnReOrderIndex,

	"_fnColumnOrdering": _fnColumnOrdering,

	"_fnLog": _fnLog,

	"_fnClearTable": _fnClearTable,

	"_fnSaveState": _fnSaveState,

	"_fnLoadState": _fnLoadState,

	"_fnCreateCookie": _fnCreateCookie,

	"_fnReadCookie": _fnReadCookie,

	"_fnDetectHeader": _fnDetectHeader,

	"_fnGetUniqueThs": _fnGetUniqueThs,

	"_fnScrollBarWidth": _fnScrollBarWidth,

	"_fnApplyToChildren": _fnApplyToChildren,

	"_fnMap": _fnMap,

	"_fnGetRowData": _fnGetRowData,

	"_fnGetCellData": _fnGetCellData,

	"_fnSetCellData": _fnSetCellData,

	"_fnGetObjectDataFn": _fnGetObjectDataFn,

	"_fnSetObjectDataFn": _fnSetObjectDataFn,

	"_fnApplyColumnDefs": _fnApplyColumnDefs,

	"_fnBindAction": _fnBindAction,

	"_fnExtend": _fnExtend,

	"_fnCallbackReg": _fnCallbackReg,

	"_fnCallbackFire": _fnCallbackFire,

	"_fnJsonString": _fnJsonString,

	"_fnRender": _fnRender,

	"_fnNodeToColumnIndex": _fnNodeToColumnIndex,

	"_fnInfoMacros": _fnInfoMacros,

	"_fnBrowserDetect": _fnBrowserDetect,

	"_fnGetColumns": _fnGetColumns

};

$.extend( DataTable.ext.oApi, this.oApi );

for ( var sFunc in DataTable.ext.oApi )

{

	if ( sFunc )

	{

		this[sFunc] = _fnExternApiFunc(sFunc);

	}

}

/**

 * Perform a jQuery selector action on the table's TR elements (from the tbody) and

 * return the resulting jQuery object.

 *  @param {string|node|jQuery} sSelector jQuery selector or node collection to act on

 *  @param {object} [oOpts] Optional parameters for modifying the rows to be included

 *  @param {string} [oOpts.filter=none] Select TR elements that meet the current filter

 *    criterion ("applied") or all TR elements (i.e. no filter).

 *  @param {string} [oOpts.order=current] Order of the TR elements in the processed array.

 *    Can be either 'current', whereby the current sorting of the table is used, or

 *    'original' whereby the original order the data was read into the table is used.

 *  @param {string} [oOpts.page=all] Limit the selection to the currently displayed page

 *    ("current") or not ("all"). If 'current' is given, then order is assumed to be 

 *    'current' and filter is 'applied', regardless of what they might be given as.

 *  @returns {object} jQuery object, filtered by the given selector.

 *  @dtopt API

 *

 *  @example

 *    $(document).ready(function() {

 *      var oTable = $('#example').dataTable();

 *

 *      // Highlight every second row

 *      oTable.$('tr:odd').css('backgroundColor', 'blue');

 *    } );

 *

 *  @example

 *    $(document).ready(function() {

 *      var oTable = $('#example').dataTable();

 *

 *      // Filter to rows with 'Webkit' in them, add a background colour and then

 *      // remove the filter, thus highlighting the 'Webkit' rows only.

 *      oTable.fnFilter('Webkit');

 *      oTable.$('tr', {"filter": "applied"}).css('backgroundColor', 'blue');

 *      oTable.fnFilter('');

 *    } );

 */

this.$ = function ( sSelector, oOpts )

{

	var i, iLen, a = [], tr;

	var oSettings = _fnSettingsFromNode( this[DataTable.ext.iApiIndex] );

	var aoData = oSettings.aoData;

	var aiDisplay = oSettings.aiDisplay;

	var aiDisplayMaster = oSettings.aiDisplayMaster;

	if ( !oOpts )

	{

		oOpts = {};

	}

	oOpts = $.extend( {}, {

		"filter": "none", // applied

		"order": "current", // "original"

		"page": "all" // current

	}, oOpts );

	// Current page implies that order=current and fitler=applied, since it is fairly

	// senseless otherwise

	if ( oOpts.page == 'current' )

	{

		for ( i=oSettings._iDisplayStart, iLen=oSettings.fnDisplayEnd() ; i<iLen ; i++ )

		{

			tr = aoData[ aiDisplay[i] ].nTr;

			if ( tr )

			{

				a.push( tr );

			}

		}

	}

	else if ( oOpts.order == "current" && oOpts.filter == "none" )

	{

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

		{

			tr = aoData[ aiDisplayMaster[i] ].nTr;

			if ( tr )

			{

				a.push( tr );

			}

		}

	}

	else if ( oOpts.order == "current" && oOpts.filter == "applied" )

	{

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

		{

			tr = aoData[ aiDisplay[i] ].nTr;

			if ( tr )

			{

				a.push( tr );

			}

		}

	}

	else if ( oOpts.order == "original" && oOpts.filter == "none" )

	{

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

		{

			tr = aoData[ i ].nTr ;

			if ( tr )

			{

				a.push( tr );

			}

		}

	}

	else if ( oOpts.order == "original" && oOpts.filter == "applied" )

	{

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

		{

			tr = aoData[ i ].nTr;

			if ( $.inArray( i, aiDisplay ) !== -1 && tr )

			{

				a.push( tr );

			}

		}

	}

	else

	{

		_fnLog( oSettings, 1, "Unknown selection options" );

	}

	/* We need to filter on the TR elements and also 'find' in their descendants

	 * to make the selector act like it would in a full table - so we need

	 * to build both results and then combine them together

	 */

	var jqA = $(a);

	var jqTRs = jqA.filter( sSelector );

	var jqDescendants = jqA.find( sSelector );

	return $( [].concat($.makeArray(jqTRs), $.makeArray(jqDescendants)) );

};

/**

 * Almost identical to $ in operation, but in this case returns the data for the matched

 * rows - as such, the jQuery selector used should match TR row nodes or TD/TH cell nodes

 * rather than any descendants, so the data can be obtained for the row/cell. If matching

 * rows are found, the data returned is the original data array/object that was used to  

 * create the row (or a generated array if from a DOM source).

 *

 * This method is often useful in-combination with $ where both functions are given the

 * same parameters and the array indexes will match identically.

 *  @param {string|node|jQuery} sSelector jQuery selector or node collection to act on

 *  @param {object} [oOpts] Optional parameters for modifying the rows to be included

 *  @param {string} [oOpts.filter=none] Select elements that meet the current filter

 *    criterion ("applied") or all elements (i.e. no filter).

 *  @param {string} [oOpts.order=current] Order of the data in the processed array.

 *    Can be either 'current', whereby the current sorting of the table is used, or

 *    'original' whereby the original order the data was read into the table is used.

 *  @param {string} [oOpts.page=all] Limit the selection to the currently displayed page

 *    ("current") or not ("all"). If 'current' is given, then order is assumed to be 

 *    'current' and filter is 'applied', regardless of what they might be given as.

 *  @returns {array} Data for the matched elements. If any elements, as a result of the

 *    selector, were not TR, TD or TH elements in the DataTable, they will have a null 

 *    entry in the array.

 *  @dtopt API

 *

 *  @example

 *    $(document).ready(function() {

 *      var oTable = $('#example').dataTable();

 *

 *      // Get the data from the first row in the table

 *      var data = oTable._('tr:first');

 *

 *      // Do something useful with the data

 *      alert( "First cell is: "+data[0] );

 *    } );

 *

 *  @example

 *    $(document).ready(function() {

 *      var oTable = $('#example').dataTable();

 *

 *      // Filter to 'Webkit' and get all data for 

 *      oTable.fnFilter('Webkit');

 *      var data = oTable._('tr', {"filter": "applied"});

 *      

 *      // Do something with the data

 *      alert( data.length+" rows matched the filter" );

 *    } );

 */

this._ = function ( sSelector, oOpts )

{

	var aOut = [];

	var i, iLen, iIndex;

	var aTrs = this.$( sSelector, oOpts );

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

	{

		aOut.push( this.fnGetData(aTrs[i]) );

	}

	return aOut;

};

/**

 * Add a single new row or multiple rows of data to the table. Please note

 * that this is suitable for client-side processing only - if you are using 

 * server-side processing (i.e. "bServerSide": true), then to add data, you

 * must add it to the data source, i.e. the server-side, through an Ajax call.

 *  @param {array|object} mData The data to be added to the table. This can be:

 *    <ul>

 *      <li>1D array of data - add a single row with the data provided</li>

 *      <li>2D array of arrays - add multiple rows in a single call</li>

 *      <li>object - data object when using <i>mData</i></li>

 *      <li>array of objects - multiple data objects when using <i>mData</i></li>

 *    </ul>

 *  @param {bool} [bRedraw=true] redraw the table or not

 *  @returns {array} An array of integers, representing the list of indexes in 

 *    <i>aoData</i> ({@link DataTable.models.oSettings}) that have been added to 

 *    the table.

 *  @dtopt API

 *

 *  @example

 *    // Global var for counter

 *    var giCount = 2;

 *    

 *    $(document).ready(function() {

 *      $('#example').dataTable();

 *    } );

 *    

 *    function fnClickAddRow() {

 *      $('#example').dataTable().fnAddData( [

 *        giCount+".1",

 *        giCount+".2",

 *        giCount+".3",

 *        giCount+".4" ]

 *      );

 *        

 *      giCount++;

 *    }

 */

this.fnAddData = function( mData, bRedraw )

{

	if ( mData.length === 0 )

	{

		return [];

	}

	var aiReturn = [];

	var iTest;

	/* Find settings from table node */

	var oSettings = _fnSettingsFromNode( this[DataTable.ext.iApiIndex] );

	/* Check if we want to add multiple rows or not */

	if ( typeof mData[0] === "object" && mData[0] !== null )

	{

		for ( var i=0 ; i<mData.length ; i++ )

		{

			iTest = _fnAddData( oSettings, mData[i] );

			if ( iTest == -1 )

			{

				return aiReturn;

			}

			aiReturn.push( iTest );

		}

	}

	else

	{

		iTest = _fnAddData( oSettings, mData );

		if ( iTest == -1 )

		{

			return aiReturn;

		}

		aiReturn.push( iTest );

	}

	oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();

	if ( bRedraw === undefined || bRedraw )

	{

		_fnReDraw( oSettings );

	}

	return aiReturn;

};

/**

 * This function will make DataTables recalculate the column sizes, based on the data 

 * contained in the table and the sizes applied to the columns (in the DOM, CSS or 

 * through the sWidth parameter). This can be useful when the width of the table's 

 * parent element changes (for example a window resize).

 *  @param {boolean} [bRedraw=true] Redraw the table or not, you will typically want to

 *  @dtopt API

 *

 *  @example

 *    $(document).ready(function() {

 *      var oTable = $('#example').dataTable( {

 *        "sScrollY": "200px",

 *        "bPaginate": false

 *      } );

 *      

 *      $(window).bind('resize', function () {

 *        oTable.fnAdjustColumnSizing();

 *      } );

 *    } );

 */

this.fnAdjustColumnSizing = function ( bRedraw )

{

	var oSettings = _fnSettingsFromNode(this[DataTable.ext.iApiIndex]);

	_fnAdjustColumnSizing( oSettings );

	if ( bRedraw === undefined || bRedraw )

	{

		this.fnDraw( false );

	}

	else if ( oSettings.oScroll.sX !== "" || oSettings.oScroll.sY !== "" )

	{

		/* If not redrawing, but scrolling, we want to apply the new column sizes anyway */

		this.oApi._fnScrollDraw(oSettings);

	}

};

/**

 * Quickly and simply clear a table

 *  @param {bool} [bRedraw=true] redraw the table or not

 *  @dtopt API

 *

 *  @example

 *    $(document).ready(function() {

 *      var oTable = $('#example').dataTable();

 *      

 *      // Immediately 'nuke' the current rows (perhaps waiting for an Ajax callback...)

 *      oTable.fnClearTable();

 *    } );

 */

this.fnClearTable = function( bRedraw )

{

	/* Find settings from table node */

	var oSettings = _fnSettingsFromNode( this[DataTable.ext.iApiIndex] );

	_fnClearTable( oSettings );

	if ( bRedraw === undefined || bRedraw )

	{

		_fnDraw( oSettings );

	}

};

/**

 * The exact opposite of 'opening' a row, this function will close any rows which 

 * are currently 'open'.

 *  @param {node} nTr the table row to 'close'

 *  @returns {int} 0 on success, or 1 if failed (can't find the row)

 *  @dtopt API

 *

 *  @example

 *    $(document).ready(function() {

 *      var oTable;

 *      

 *      // 'open' an information row when a row is clicked on

 *      $('#example tbody tr').click( function () {

 *        if ( oTable.fnIsOpen(this) ) {

 *          oTable.fnClose( this );

 *        } else {

 *          oTable.fnOpen( this, "Temporary row opened", "info_row" );

 *        }

 *      } );

 *      

 *      oTable = $('#example').dataTable();

 *    } );

 */

this.fnClose = function( nTr )

{

	/* Find settings from table node */

	var oSettings = _fnSettingsFromNode( this[DataTable.ext.iApiIndex] );

	for ( var i=0 ; i<oSettings.aoOpenRows.length ; i++ )

	{

		if ( oSettings.aoOpenRows[i].nParent == nTr )

		{

			var nTrParent = oSettings.aoOpenRows[i].nTr.parentNode;

			if ( nTrParent )

			{

				/* Remove it if it is currently on display */

				nTrParent.removeChild( oSettings.aoOpenRows[i].nTr );

			}

			oSettings.aoOpenRows.splice( i, 1 );

			return 0;

		}

	}

	return 1;

};

/**

 * Remove a row for the table

 *  @param {mixed} mTarget The index of the row from aoData to be deleted, or

 *    the TR element you want to delete

 *  @param {function|null} [fnCallBack] Callback function

 *  @param {bool} [bRedraw=true] Redraw the table or not

 *  @returns {array} The row that was deleted

 *  @dtopt API

 *

 *  @example

 *    $(document).ready(function() {

 *      var oTable = $('#example').dataTable();

 *      

 *      // Immediately remove the first row

 *      oTable.fnDeleteRow( 0 );

 *    } );

 */

this.fnDeleteRow = function( mTarget, fnCallBack, bRedraw )

{

	/* Find settings from table node */

	var oSettings = _fnSettingsFromNode( this[DataTable.ext.iApiIndex] );

	var i, iLen, iAODataIndex;

	iAODataIndex = (typeof mTarget === 'object') ? 

		_fnNodeToDataIndex(oSettings, mTarget) : mTarget;

	/* Return the data array from this row */

	var oData = oSettings.aoData.splice( iAODataIndex, 1 );

	/* Update the _DT_RowIndex parameter */

	for ( i=0, iLen=oSettings.aoData.length ; i<iLen ; i++ )

	{

		if ( oSettings.aoData[i].nTr !== null )

		{

			oSettings.aoData[i].nTr._DT_RowIndex = i;

		}

	}

	/* Remove the target row from the search array */

	var iDisplayIndex = $.inArray( iAODataIndex, oSettings.aiDisplay );

	oSettings.asDataSearch.splice( iDisplayIndex, 1 );

	/* Delete from the display arrays */

	_fnDeleteIndex( oSettings.aiDisplayMaster, iAODataIndex );

	_fnDeleteIndex( oSettings.aiDisplay, iAODataIndex );

	/* If there is a user callback function - call it */

	if ( typeof fnCallBack === "function" )

	{

		fnCallBack.call( this, oSettings, oData );

	}

	/* Check for an 'overflow' they case for displaying the table */

	if ( oSettings._iDisplayStart >= oSettings.fnRecordsDisplay() )

	{

		oSettings._iDisplayStart -= oSettings._iDisplayLength;

		if ( oSettings._iDisplayStart < 0 )

		{

			oSettings._iDisplayStart = 0;

		}

	}

	if ( bRedraw === undefined || bRedraw )

	{

		_fnCalculateEnd( oSettings );

		_fnDraw( oSettings );

	}

	return oData;

};

/**

 * Restore the table to it's original state in the DOM by removing all of DataTables 

 * enhancements, alterations to the DOM structure of the table and event listeners.

 *  @param {boolean} [bRemove=false] Completely remove the table from the DOM

 *  @dtopt API

 *

 *  @example

 *    $(document).ready(function() {

 *      // This example is fairly pointless in reality, but shows how fnDestroy can be used

 *      var oTable = $('#example').dataTable();

 *      oTable.fnDestroy();

 *    } );

 */

this.fnDestroy = function ( bRemove )

{

	var oSettings = _fnSettingsFromNode( this[DataTable.ext.iApiIndex] );

	var nOrig = oSettings.nTableWrapper.parentNode;

	var nBody = oSettings.nTBody;

	var i, iLen;

	bRemove = (bRemove===undefined) ? false : bRemove;

	/* Flag to note that the table is currently being destroyed - no action should be taken */

	oSettings.bDestroying = true;

	/* Fire off the destroy callbacks for plug-ins etc */

	_fnCallbackFire( oSettings, "aoDestroyCallback", "destroy", [oSettings] );

	/* If the table is not being removed, restore the hidden columns */

	if ( !bRemove )

	{

		for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )

		{

			if ( oSettings.aoColumns[i].bVisible === false )

			{

				this.fnSetColumnVis( i, true );

			}

		}

	}

	/* Blitz all DT events */

	$(oSettings.nTableWrapper).find('*').andSelf().unbind('.DT');

	/* If there is an 'empty' indicator row, remove it */

	$('tbody>tr>td.'+oSettings.oClasses.sRowEmpty, oSettings.nTable).parent().remove();

	/* When scrolling we had to break the table up - restore it */

	if ( oSettings.nTable != oSettings.nTHead.parentNode )

	{

		$(oSettings.nTable).children('thead').remove();

		oSettings.nTable.appendChild( oSettings.nTHead );

	}

	if ( oSettings.nTFoot && oSettings.nTable != oSettings.nTFoot.parentNode )

	{

		$(oSettings.nTable).children('tfoot').remove();

		oSettings.nTable.appendChild( oSettings.nTFoot );

	}

	/* Remove the DataTables generated nodes, events and classes */

	oSettings.nTable.parentNode.removeChild( oSettings.nTable );

	$(oSettings.nTableWrapper).remove();

	oSettings.aaSorting = [];

	oSettings.aaSortingFixed = [];

	_fnSortingClasses( oSettings );

	$(_fnGetTrNodes( oSettings )).removeClass( oSettings.asStripeClasses.join(' ') );

	$('th, td', oSettings.nTHead).removeClass( [

		oSettings.oClasses.sSortable,

		oSettings.oClasses.sSortableAsc,

		oSettings.oClasses.sSortableDesc,

		oSettings.oClasses.sSortableNone ].join(' ')

	);

	if ( oSettings.bJUI )

	{

		$('th span.'+oSettings.oClasses.sSortIcon

			+ ', td span.'+oSettings.oClasses.sSortIcon, oSettings.nTHead).remove();

		$('th, td', oSettings.nTHead).each( function () {

			var jqWrapper = $('div.'+oSettings.oClasses.sSortJUIWrapper, this);

			var kids = jqWrapper.contents();

			$(this).append( kids );

			jqWrapper.remove();

		} );

	}

	/* Add the TR elements back into the table in their original order */

	if ( !bRemove && oSettings.nTableReinsertBefore )

	{

		nOrig.insertBefore( oSettings.nTable, oSettings.nTableReinsertBefore );

	}

	else if ( !bRemove )

	{

		nOrig.appendChild( oSettings.nTable );

	}

	for ( i=0, iLen=oSettings.aoData.length ; i<iLen ; i++ )

	{

		if ( oSettings.aoData[i].nTr !== null )

		{

			nBody.appendChild( oSettings.aoData[i].nTr );

		}

	}

	/* Restore the width of the original table */

	if ( oSettings.oFeatures.bAutoWidth === true )

	{

	  oSettings.nTable.style.width = _fnStringToCss(oSettings.sDestroyWidth);

	}

	/* If the were originally stripe classes - then we add them back here. Note

	 * this is not fool proof (for example if not all rows had stripe classes - but

	 * it's a good effort without getting carried away

	 */

	iLen = oSettings.asDestroyStripes.length;

	if (iLen)

	{

		var anRows = $(nBody).children('tr');

		for ( i=0 ; i<iLen ; i++ )

		{

			anRows.filter(':nth-child(' + iLen + 'n + ' + i + ')').addClass( oSettings.asDestroyStripes[i] );

		}

	}

	/* Remove the settings object from the settings array */

	for ( i=0, iLen=DataTable.settings.length ; i<iLen ; i++ )

	{

		if ( DataTable.settings[i] == oSettings )

		{

			DataTable.settings.splice( i, 1 );

		}

	}

	/* End it all */

	oSettings = null;

	oInit = null;

};

/**

 * Redraw the table

 *  @param {bool} [bComplete=true] Re-filter and resort (if enabled) the table before the draw.

 *  @dtopt API

 *

 *  @example

 *    $(document).ready(function() {

 *      var oTable = $('#example').dataTable();

 *      

 *      // Re-draw the table - you wouldn't want to do it here, but it's an example :-)

 *      oTable.fnDraw();

 *    } );

 */

this.fnDraw = function( bComplete )

{

	var oSettings = _fnSettingsFromNode( this[DataTable.ext.iApiIndex] );

	if ( bComplete === false )

	{

		_fnCalculateEnd( oSettings );

		_fnDraw( oSettings );

	}

	else

	{

		_fnReDraw( oSettings );

	}

};

/**

 * Filter the input based on data

 *  @param {string} sInput String to filter the table on

 *  @param {int|null} [iColumn] Column to limit filtering to

 *  @param {bool} [bRegex=false] Treat as regular expression or not

 *  @param {bool} [bSmart=true] Perform smart filtering or not

 *  @param {bool} [bShowGlobal=true] Show the input global filter in it's input box(es)

 *  @param {bool} [bCaseInsensitive=true] Do case-insensitive matching (true) or not (false)

 *  @dtopt API

 *

 *  @example

 *    $(document).ready(function() {

 *      var oTable = $('#example').dataTable();

 *      

 *      // Sometime later - filter...

 *      oTable.fnFilter( 'test string' );

 *    } );

 */

this.fnFilter = function( sInput, iColumn, bRegex, bSmart, bShowGlobal, bCaseInsensitive )

{

	var oSettings = _fnSettingsFromNode( this[DataTable.ext.iApiIndex] );

	if ( !oSettings.oFeatures.bFilter )

	{

		return;

	}

	if ( bRegex === undefined || bRegex === null )

	{

		bRegex = false;

	}

	if ( bSmart === undefined || bSmart === null )

	{

		bSmart = true;

	}

	if ( bShowGlobal === undefined || bShowGlobal === null )

	{

		bShowGlobal = true;

	}

	if ( bCaseInsensitive === undefined || bCaseInsensitive === null )

	{

		bCaseInsensitive = true;

	}

	if ( iColumn === undefined || iColumn === null )

	{

		/* Global filter */

		_fnFilterComplete( oSettings, {

			"sSearch":sInput+"",

			"bRegex": bRegex,

			"bSmart": bSmart,

			"bCaseInsensitive": bCaseInsensitive

		}, 1 );

		if ( bShowGlobal && oSettings.aanFeatures.f )

		{

			var n = oSettings.aanFeatures.f;

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

			{

				// IE9 throws an 'unknown error' if document.activeElement is used

				// inside an iframe or frame...

				try {

					if ( n[i]._DT_Input != document.activeElement )

					{

						$(n[i]._DT_Input).val( sInput );

					}

				}

				catch ( e ) {

					$(n[i]._DT_Input).val( sInput );

				}

			}

		}

	}

	else

	{

		/* Single column filter */

		$.extend( oSettings.aoPreSearchCols[ iColumn ], {

			"sSearch": sInput+"",

			"bRegex": bRegex,

			"bSmart": bSmart,

			"bCaseInsensitive": bCaseInsensitive

		} );

		_fnFilterComplete( oSettings, oSettings.oPreviousSearch, 1 );

	}

};

/**

 * Get the data for the whole table, an individual row or an individual cell based on the 

 * provided parameters.

 *  @param {int|node} [mRow] A TR row node, TD/TH cell node or an integer. If given as

 *    a TR node then the data source for the whole row will be returned. If given as a

 *    TD/TH cell node then iCol will be automatically calculated and the data for the

 *    cell returned. If given as an integer, then this is treated as the aoData internal

 *    data index for the row (see fnGetPosition) and the data for that row used.

 *  @param {int} [iCol] Optional column index that you want the data of.

 *  @returns {array|object|string} If mRow is undefined, then the data for all rows is

 *    returned. If mRow is defined, just data for that row, and is iCol is

 *    defined, only data for the designated cell is returned.

 *  @dtopt API

 *

 *  @example

 *    // Row data

 *    $(document).ready(function() {

 *      oTable = $('#example').dataTable();

 *

 *      oTable.$('tr').click( function () {

 *        var data = oTable.fnGetData( this );

 *        // ... do something with the array / object of data for the row

 *      } );

 *    } );

 *

 *  @example

 *    // Individual cell data

 *    $(document).ready(function() {

 *      oTable = $('#example').dataTable();

 *

 *      oTable.$('td').click( function () {

 *        var sData = oTable.fnGetData( this );

 *        alert( 'The cell clicked on had the value of '+sData );

 *      } );

 *    } );

 */

this.fnGetData = function( mRow, iCol )

{

	var oSettings = _fnSettingsFromNode( this[DataTable.ext.iApiIndex] );

	if ( mRow !== undefined )

	{

		var iRow = mRow;

		if ( typeof mRow === 'object' )

		{

			var sNode = mRow.nodeName.toLowerCase();

			if (sNode === "tr" )

			{

				iRow = _fnNodeToDataIndex(oSettings, mRow);

			}

			else if ( sNode === "td" )

			{

				iRow = _fnNodeToDataIndex(oSettings, mRow.parentNode);

				iCol = _fnNodeToColumnIndex( oSettings, iRow, mRow );

			}

		}

		if ( iCol !== undefined )

		{

			return _fnGetCellData( oSettings, iRow, iCol, '' );

		}

		return (oSettings.aoData[iRow]!==undefined) ?

			oSettings.aoData[iRow]._aData : null;

	}

	return _fnGetDataMaster( oSettings );

};

/**

 * Get an array of the TR nodes that are used in the table's body. Note that you will 

 * typically want to use the '$' API method in preference to this as it is more 

 * flexible.

 *  @param {int} [iRow] Optional row index for the TR element you want

 *  @returns {array|node} If iRow is undefined, returns an array of all TR elements

 *    in the table's body, or iRow is defined, just the TR element requested.

 *  @dtopt API

 *

 *  @example

 *    $(document).ready(function() {

 *      var oTable = $('#example').dataTable();

 *      

 *      // Get the nodes from the table

 *      var nNodes = oTable.fnGetNodes( );

 *    } );

 */

this.fnGetNodes = function( iRow )

{

	var oSettings = _fnSettingsFromNode( this[DataTable.ext.iApiIndex] );

	if ( iRow !== undefined ) {

		return (oSettings.aoData[iRow]!==undefined) ?

			oSettings.aoData[iRow].nTr : null;

	}

	return _fnGetTrNodes( oSettings );

};

/**

 * Get the array indexes of a particular cell from it's DOM element

 * and column index including hidden columns

 *  @param {node} nNode this can either be a TR, TD or TH in the table's body

 *  @returns {int} If nNode is given as a TR, then a single index is returned, or

 *    if given as a cell, an array of [row index, column index (visible), 

 *    column index (all)] is given.

 *  @dtopt API

 *

 *  @example

 *    $(document).ready(function() {

 *      $('#example tbody td').click( function () {

 *        // Get the position of the current data from the node

 *        var aPos = oTable.fnGetPosition( this );

 *        

 *        // Get the data array for this row

 *        var aData = oTable.fnGetData( aPos[0] );

 *        

 *        // Update the data array and return the value

 *        aData[ aPos[1] ] = 'clicked';

 *        this.innerHTML = 'clicked';

 *      } );

 *      

 *      // Init DataTables

 *      oTable = $('#example').dataTable();

 *    } );

 */

this.fnGetPosition = function( nNode )

{

	var oSettings = _fnSettingsFromNode( this[DataTable.ext.iApiIndex] );

	var sNodeName = nNode.nodeName.toUpperCase();

	if ( sNodeName == "TR" )

	{

		return _fnNodeToDataIndex(oSettings, nNode);

	}

	else if ( sNodeName == "TD" || sNodeName == "TH" )

	{

		var iDataIndex = _fnNodeToDataIndex( oSettings, nNode.parentNode );

		var iColumnIndex = _fnNodeToColumnIndex( oSettings, iDataIndex, nNode );

		return [ iDataIndex, _fnColumnIndexToVisible(oSettings, iColumnIndex ), iColumnIndex ];

	}

	return null;

};

/**

 * Check to see if a row is 'open' or not.

 *  @param {node} nTr the table row to check

 *  @returns {boolean} true if the row is currently open, false otherwise

 *  @dtopt API

 *

 *  @example

 *    $(document).ready(function() {

 *      var oTable;

 *      

 *      // 'open' an information row when a row is clicked on

 *      $('#example tbody tr').click( function () {

 *        if ( oTable.fnIsOpen(this) ) {

 *          oTable.fnClose( this );

 *        } else {

 *          oTable.fnOpen( this, "Temporary row opened", "info_row" );

 *        }

 *      } );

 *      

 *      oTable = $('#example').dataTable();

 *    } );

 */

this.fnIsOpen = function( nTr )

{

	var oSettings = _fnSettingsFromNode( this[DataTable.ext.iApiIndex] );

	var aoOpenRows = oSettings.aoOpenRows;

	for ( var i=0 ; i<oSettings.aoOpenRows.length ; i++ )

	{

		if ( oSettings.aoOpenRows[i].nParent == nTr )

		{

			return true;

		}

	}

	return false;

};

/**

 * This function will place a new row directly after a row which is currently 

 * on display on the page, with the HTML contents that is passed into the 

 * function. This can be used, for example, to ask for confirmation that a 

 * particular record should be deleted.

 *  @param {node} nTr The table row to 'open'

 *  @param {string|node|jQuery} mHtml The HTML to put into the row

 *  @param {string} sClass Class to give the new TD cell

 *  @returns {node} The row opened. Note that if the table row passed in as the

 *    first parameter, is not found in the table, this method will silently

 *    return.

 *  @dtopt API

 *

 *  @example

 *    $(document).ready(function() {

 *      var oTable;

 *      

 *      // 'open' an information row when a row is clicked on

 *      $('#example tbody tr').click( function () {

 *        if ( oTable.fnIsOpen(this) ) {

 *          oTable.fnClose( this );

 *        } else {

 *          oTable.fnOpen( this, "Temporary row opened", "info_row" );

 *        }

 *      } );

 *      

 *      oTable = $('#example').dataTable();

 *    } );

 */

this.fnOpen = function( nTr, mHtml, sClass )

{

	/* Find settings from table node */

	var oSettings = _fnSettingsFromNode( this[DataTable.ext.iApiIndex] );

	/* Check that the row given is in the table */

	var nTableRows = _fnGetTrNodes( oSettings );

	if ( $.inArray(nTr, nTableRows) === -1 )

	{

		return;

	}

	/* the old open one if there is one */

	this.fnClose( nTr );

	var nNewRow = document.createElement("tr");

	var nNewCell = document.createElement("td");

	nNewRow.appendChild( nNewCell );

	nNewCell.className = sClass;

	nNewCell.colSpan = _fnVisbleColumns( oSettings );

	if (typeof mHtml === "string")

	{

		nNewCell.innerHTML = mHtml;

	}

	else

	{

		$(nNewCell).html( mHtml );

	}

	/* If the nTr isn't on the page at the moment - then we don't insert at the moment */

	var nTrs = $('tr', oSettings.nTBody);

	if ( $.inArray(nTr, nTrs) != -1  )

	{

		$(nNewRow).insertAfter(nTr);

	}

	oSettings.aoOpenRows.push( {

		"nTr": nNewRow,

		"nParent": nTr

	} );

	return nNewRow;

};

/**

 * Change the pagination - provides the internal logic for pagination in a simple API 

 * function. With this function you can have a DataTables table go to the next, 

 * previous, first or last pages.

 *  @param {string|int} mAction Paging action to take: "first", "previous", "next" or "last"

 *    or page number to jump to (integer), note that page 0 is the first page.

 *  @param {bool} [bRedraw=true] Redraw the table or not

 *  @dtopt API

 *

 *  @example

 *    $(document).ready(function() {

 *      var oTable = $('#example').dataTable();

 *      oTable.fnPageChange( 'next' );

 *    } );

 */

this.fnPageChange = function ( mAction, bRedraw )

{

	var oSettings = _fnSettingsFromNode( this[DataTable.ext.iApiIndex] );

	_fnPageChange( oSettings, mAction );

	_fnCalculateEnd( oSettings );

	if ( bRedraw === undefined || bRedraw )

	{

		_fnDraw( oSettings );

	}

};

/**

 * Show a particular column

 *  @param {int} iCol The column whose display should be changed

 *  @param {bool} bShow Show (true) or hide (false) the column

 *  @param {bool} [bRedraw=true] Redraw the table or not

 *  @dtopt API

 *

 *  @example

 *    $(document).ready(function() {

 *      var oTable = $('#example').dataTable();

 *      

 *      // Hide the second column after initialisation

 *      oTable.fnSetColumnVis( 1, false );

 *    } );

 */

this.fnSetColumnVis = function ( iCol, bShow, bRedraw )

{

	var oSettings = _fnSettingsFromNode( this[DataTable.ext.iApiIndex] );

	var i, iLen;

	var aoColumns = oSettings.aoColumns;

	var aoData = oSettings.aoData;

	var nTd, bAppend, iBefore;

	/* No point in doing anything if we are requesting what is already true */