rooty/DataTables
1
0
Fork 0
mirror of https://github.com/DataTables/DataTables.git synced 2024-12-10 22:24:10 +01:00
Code Issues Releases Activity
c491f8a37f
DataTables/media/js/jquery.dataTables.js

9779 lines
288 KiB
JavaScript
Raw Normal View History

Dev fix: Remove the UTF8 BOM which had somehow found its way in. No need for it here and it was upsetting JSLint...
2011-09-09 20:39:21 +02:00
/*
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
* File: jquery.dataTables.js
Fix: Calculating the width of a table can be incorrect when the calculation table is hidden due to an issue with jQuery's width/outerWidth calculation (http://bugs.jquery.com/ticket/9945). This is a bit of a work around to get the css value and check if it is a percentage - this is not perfect (since other relative values aren't checked - although they are generally unlikely to be used), but it is effective for most cases.
2011-09-16 09:45:00 +02:00
* Version: 1.8.3.dev
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
* Description: Paginate, search and sort HTML tables
* Author: Allan Jardine (www.sprymedia.co.uk)
* Created: 28/3/2008
* Language: Javascript
* License: GPL v2 or BSD 3 point style
* Project: Mtaala
* Contact: allan.jardine@sprymedia.co.uk
*
Comment updates
2011-04-22 23:12:55 +02:00
* Copyright 2008-2011 Allan Jardine, all rights reserved.
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*
* This source file is free software, under either the GPL v2 license or a
* BSD style license, as supplied with this software.
*
* 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
*/
/*
Comment updates
2011-04-22 23:12:55 +02:00
* When considering jsLint, we need to allow eval() as it it is used for reading cookies
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
/*jslint evil: true, undef: true, browser: true */
New: fnServerParams callback function - this allows additional parameters to be added to the XHR for server-side processing or Ajax sourced, client-side processed data, with ease. Previously it was required to override the fnServerData method just to add a couple of parameters, but the built in fnServerData method is quite comperhensive and you don't want to have to reproduce all of that unless you need to. Now you don't need to :-). fnServerParams is called on each request, so it is ideal for adding extra parameters such as search parameters which can be updated by users.
2011-09-02 17:01:56 +02:00
/*globals $, jQuery,_fnExternApiFunc,_fnInitialise,_fnInitComplete,_fnLanguageProcess,_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,_fnArrayCmp,_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*/
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
(function($, window, document) {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var _oExt = {};
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Section - DataTables extensible objects
*
* The _oExt object is used to provide an area where user defined plugins can be
* added to DataTables. The following properties of the object are used:
* oApi - Plug-in API functions
* aTypes - Auto-detection of types
* oSort - Sorting functions used by DataTables (based on the type)
* oPagination - Pagination functions for different input styles
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
/*
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* Variable: sVersion
* Purpose: Version string for plug-ins to check compatibility
* Scope: jQuery.fn.dataTableExt
* Notes: 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
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
_oExt.sVersion = "1.8.3.dev";
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
/*
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* Variable: sErrMode
* Purpose: How should DataTables report an error. Can take the value 'alert' or 'throw'
* Scope: jQuery.fn.dataTableExt
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
_oExt.sErrMode = "alert";
/*
* Variable: iApiIndex
* Purpose: Index for what 'this' index API functions should use
* Scope: jQuery.fn.dataTableExt
*/
_oExt.iApiIndex = 0;
/*
* Variable: oApi
* Purpose: Container for plugin API functions
* Scope: jQuery.fn.dataTableExt
*/
_oExt.oApi = { };
/*
* Variable: aFiltering
* Purpose: Container for plugin filtering functions
* Scope: jQuery.fn.dataTableExt
*/
_oExt.afnFiltering = [ ];
/*
* Variable: aoFeatures
* Purpose: Container for plugin function functions
* Scope: jQuery.fn.dataTableExt
* Notes: Array of objects with the following parameters:
* fnInit: Function for initialisation of Feature. Takes oSettings and returns node
* cFeature: Character that will be matched in sDom - case sensitive
* sFeature: Feature name - just for completeness :-)
*/
_oExt.aoFeatures = [ ];
/*
* Variable: ofnSearch
* Purpose: Container for custom filtering functions
* Scope: jQuery.fn.dataTableExt
* Notes: This is an object (the name should match the type) for custom filtering function,
* which can be used for live DOM checking or formatted text filtering
*/
_oExt.ofnSearch = { };
/*
* Variable: afnSortData
* Purpose: Container for custom sorting data source functions
* Scope: jQuery.fn.dataTableExt
* Notes: Array (associative) of functions which is run prior to a column of this
* 'SortDataType' being sorted upon.
* Function input parameters:
* object:oSettings- DataTables settings object
* int:iColumn - Target column number
* Return value: Array of data which exactly matched the full data set size for the column to
* be sorted upon
*/
_oExt.afnSortData = [ ];
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
/**
* 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
*
* @example
* $(document).ready(function() {
* var oTable = $('#example').dataTable();
* alert( oTable.fnVersionCheck( '1.9.0' ) );
* } );
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
_oExt.fnVersionCheck = function( sVersion )
{
/* This is cheap, but very effective */
var fnZPad = function (Zpad, count)
{
while(Zpad.length < count) {
Zpad += '0';
}
return Zpad;
};
var aThis = _oExt.sVersion.split('.');
var aThat = sVersion.split('.');
var sThis = '', sThat = '';
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
for ( var i=0, iLen=aThat.length ; i<iLen ; i++ )
{
sThis += fnZPad( aThis[i], 3 );
sThat += fnZPad( aThat[i], 3 );
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return parseInt(sThis, 10) >= parseInt(sThat, 10);
};
/*
* Variable: _oExternConfig
* Purpose: Store information for DataTables to access globally about other instances
* Scope: jQuery.fn.dataTableExt
*/
_oExt._oExternConfig = {
/* int:iNextUnique - next unique number for an instance */
"iNextUnique": 0
};
/*
* Variable: oStdClasses
* Purpose: Storage for the various classes that DataTables uses
* Scope: jQuery.fn.dataTableExt
*/
_oExt.oStdClasses = {
/* Two buttons buttons */
"sPagePrevEnabled": "paginate_enabled_previous",
"sPagePrevDisabled": "paginate_disabled_previous",
"sPageNextEnabled": "paginate_enabled_next",
"sPageNextDisabled": "paginate_disabled_next",
"sPageJUINext": "",
"sPageJUIPrev": "",
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Full numbers paging buttons */
"sPageButton": "paginate_button",
"sPageButtonActive": "paginate_active",
"sPageButtonStaticDisabled": "paginate_button paginate_button_disabled",
"sPageFirst": "first",
"sPagePrevious": "previous",
"sPageNext": "next",
"sPageLast": "last",
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Striping classes */
"sStripeOdd": "odd",
"sStripeEven": "even",
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Empty row */
"sRowEmpty": "dataTables_empty",
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* 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",
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* 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": "",
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Scrolling */
"sScrollWrapper": "dataTables_scroll",
"sScrollHead": "dataTables_scrollHead",
"sScrollHeadInner": "dataTables_scrollHeadInner",
"sScrollBody": "dataTables_scrollBody",
"sScrollFoot": "dataTables_scrollFoot",
"sScrollFootInner": "dataTables_scrollFootInner",
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Misc */
"sFooterTH": ""
};
/*
* Variable: oJUIClasses
* Purpose: Storage for the various classes that DataTables uses - jQuery UI suitable
* Scope: jQuery.fn.dataTableExt
*/
_oExt.oJUIClasses = {
/* 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",
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* 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",
"sPagePrevious": "previous",
"sPageNext": "next",
"sPageLast": "last ui-corner-tr ui-corner-br",
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Striping classes */
"sStripeOdd": "odd",
"sStripeEven": "even",
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Empty row */
"sRowEmpty": "dataTables_empty",
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Features */
"sWrapper": "dataTables_wrapper",
"sFilter": "dataTables_filter",
"sInfo": "dataTables_info",
"sPaging": "dataTables_paginate fg-buttonset ui-buttonset fg-buttonset-multi "+
"ui-buttonset-multi paging_", /* Note that the type is postfixed */
"sLength": "dataTables_length",
"sProcessing": "dataTables_processing",
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* 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",
"sSortColumn": "sorting_", /* Note that an int is postfixed for the sorting order */
"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",
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Scrolling */
"sScrollWrapper": "dataTables_scroll",
"sScrollHead": "dataTables_scrollHead ui-state-default",
"sScrollHeadInner": "dataTables_scrollHeadInner",
"sScrollBody": "dataTables_scrollBody",
"sScrollFoot": "dataTables_scrollFoot ui-state-default",
"sScrollFootInner": "dataTables_scrollFootInner",
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Misc */
"sFooterTH": "ui-state-default"
};
/*
* Variable: oPagination
* Purpose: Container for the various type of pagination that dataTables supports
* Scope: jQuery.fn.dataTableExt
*/
_oExt.oPagination = {
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/*
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* Variable: two_button
* Purpose: Standard two button (forward/back) pagination
* Scope: jQuery.fn.dataTableExt.oPagination
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
"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 nPrevious, nNext, nPreviousInner, nNextInner;
var fnClickHandler = function ( e ) {
if ( oSettings.oApi._fnPageChange( oSettings, e.data.action ) )
{
fnCallbackDraw( oSettings );
}
};
/* Store the next and previous elements in the oSettings object as they can be very
* usful for automation - particularly testing
*/
if ( !oSettings.bJUI )
{
nPrevious = document.createElement( 'div' );
nNext = document.createElement( 'div' );
}
else
{
nPrevious = document.createElement( 'a' );
nNext = document.createElement( 'a' );
nNextInner = document.createElement('span');
nNextInner.className = oSettings.oClasses.sPageJUINext;
nNext.appendChild( nNextInner );
nPreviousInner = document.createElement('span');
nPreviousInner.className = oSettings.oClasses.sPageJUIPrev;
nPrevious.appendChild( nPreviousInner );
}
nPrevious.className = oSettings.oClasses.sPagePrevDisabled;
nNext.className = oSettings.oClasses.sPageNextDisabled;
nPrevious.title = oSettings.oLanguage.oPaginate.sPrevious;
nNext.title = oSettings.oLanguage.oPaginate.sNext;
nPaging.appendChild( nPrevious );
nPaging.appendChild( nNext );
$(nPrevious)
.bind( 'click.DT', { action: "previous" }, fnClickHandler )
.bind( 'selectstart.DT', function () { return false; } ); /* Take the brutal approach to cancelling text selection */
$(nNext)
.bind( 'click.DT', { action: "next" }, fnClickHandler )
.bind( 'selectstart.DT', function () { return false; } );
/* ID the first elements only */
if ( oSettings.sTableId !== '' && typeof oSettings.aanFeatures.p == "undefined" )
{
nPaging.setAttribute( 'id', oSettings.sTableId+'_paginate' );
nPrevious.setAttribute( 'id', oSettings.sTableId+'_previous' );
nNext.setAttribute( 'id', oSettings.sTableId+'_next' );
}
},
/*
* 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;
}
/* Loop over each instance of the pager */
var an = oSettings.aanFeatures.p;
for ( var i=0, iLen=an.length ; i<iLen ; i++ )
{
if ( an[i].childNodes.length !== 0 )
{
an[i].childNodes[0].className =
( oSettings._iDisplayStart === 0 ) ?
oSettings.oClasses.sPagePrevDisabled : oSettings.oClasses.sPagePrevEnabled;
an[i].childNodes[1].className =
( oSettings.fnDisplayEnd() == oSettings.fnRecordsDisplay() ) ?
oSettings.oClasses.sPageNextDisabled : oSettings.oClasses.sPageNextEnabled;
}
}
}
},
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/*
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* Variable: iFullNumbersShowPages
* Purpose: Change the number of pages which can be seen
* Scope: jQuery.fn.dataTableExt.oPagination
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
"iFullNumbersShowPages": 5,
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/*
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* Variable: full_numbers
* Purpose: Full numbers pagination
* Scope: jQuery.fn.dataTableExt.oPagination
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
"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 nFirst = document.createElement( 'span' );
var nPrevious = document.createElement( 'span' );
var nList = document.createElement( 'span' );
var nNext = document.createElement( 'span' );
var nLast = document.createElement( 'span' );
var fnClickHandler = function ( e ) {
if ( oSettings.oApi._fnPageChange( oSettings, e.data.action ) )
{
fnCallbackDraw( oSettings );
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
};
nFirst.innerHTML = oSettings.oLanguage.oPaginate.sFirst;
nPrevious.innerHTML = oSettings.oLanguage.oPaginate.sPrevious;
nNext.innerHTML = oSettings.oLanguage.oPaginate.sNext;
nLast.innerHTML = oSettings.oLanguage.oPaginate.sLast;
var oClasses = oSettings.oClasses;
nFirst.className = oClasses.sPageButton+" "+oClasses.sPageFirst;
nPrevious.className = oClasses.sPageButton+" "+oClasses.sPagePrevious;
nNext.className= oClasses.sPageButton+" "+oClasses.sPageNext;
nLast.className = oClasses.sPageButton+" "+oClasses.sPageLast;
nPaging.appendChild( nFirst );
nPaging.appendChild( nPrevious );
nPaging.appendChild( nList );
nPaging.appendChild( nNext );
nPaging.appendChild( nLast );
$(nFirst).bind( 'click.DT', { action: "first" }, fnClickHandler );
$(nPrevious).bind( 'click.DT', { action: "previous" }, fnClickHandler );
$(nNext).bind( 'click.DT', { action: "next" }, fnClickHandler );
$(nLast).bind( 'click.DT', { action: "last" }, fnClickHandler );
/* Take the brutal approach to cancelling text selection */
$('span', nPaging)
.bind( 'mousedown.DT', function () { return false; } )
.bind( 'selectstart.DT', function () { return false; } );
/* ID the first elements only */
if ( oSettings.sTableId !== '' && typeof oSettings.aanFeatures.p == "undefined" )
{
nPaging.setAttribute( 'id', oSettings.sTableId+'_paginate' );
nFirst.setAttribute( 'id', oSettings.sTableId+'_first' );
nPrevious.setAttribute( 'id', oSettings.sTableId+'_previous' );
nNext.setAttribute( 'id', oSettings.sTableId+'_next' );
nLast.setAttribute( 'id', oSettings.sTableId+'_last' );
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
},
/*
* 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 )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
if ( !oSettings.aanFeatures.p )
{
return;
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var iPageCount = _oExt.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;
/* Pages calculation */
if (iPages < iPageCount)
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
iStartButton = 1;
iEndButton = iPages;
}
else
{
if (iCurrentPage <= iPageCountHalf)
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
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++ )
{
if ( iCurrentPage != i )
{
sList += '<span class="'+oClasses.sPageButton+'">'+i+'</span>';
}
else
{
sList += '<span class="'+oClasses.sPageButtonActive+'">'+i+'</span>';
}
}
/* Loop over each instance of the pager */
var an = oSettings.aanFeatures.p;
var anButtons, anStatic, nPaginateList;
var fnClick = function(e) {
/* Use the information in the element to jump to the required page */
var iTarget = (this.innerHTML * 1) - 1;
oSettings._iDisplayStart = iTarget * oSettings._iDisplayLength;
fnCallbackDraw( oSettings );
e.preventDefault();
};
var fnFalse = function () { return false; };
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 */
var qjPaginateList = $('span:eq(2)', an[i]);
qjPaginateList.html( sList );
$('span', qjPaginateList).bind( 'click.DT', fnClick ).bind( 'mousedown.DT', fnFalse )
.bind( 'selectstart.DT', fnFalse );
/* Update the 'premanent botton's classes */
anButtons = an[i].getElementsByTagName('span');
anStatic = [
anButtons[0], anButtons[1],
anButtons[anButtons.length-2], anButtons[anButtons.length-1]
];
$(anStatic).removeClass( oClasses.sPageButton+" "+oClasses.sPageButtonActive+" "+oClasses.sPageButtonStaticDisabled );
if ( iCurrentPage == 1 )
{
anStatic[0].className += " "+oClasses.sPageButtonStaticDisabled;
anStatic[1].className += " "+oClasses.sPageButtonStaticDisabled;
}
else
{
anStatic[0].className += " "+oClasses.sPageButton;
anStatic[1].className += " "+oClasses.sPageButton;
}
if ( iPages === 0 || iCurrentPage == iPages || oSettings._iDisplayLength == -1 )
{
anStatic[2].className += " "+oClasses.sPageButtonStaticDisabled;
anStatic[3].className += " "+oClasses.sPageButtonStaticDisabled;
}
else
{
anStatic[2].className += " "+oClasses.sPageButton;
anStatic[3].className += " "+oClasses.sPageButton;
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
}
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
}
};
/*
* Variable: oSort
* Purpose: Wrapper for the sorting functions that can be used in DataTables
* Scope: jQuery.fn.dataTableExt
* Notes: The functions provided in this object are basically standard javascript sort
* functions - they expect two inputs which they then compare and then return a priority
* result. For each sort method added, two functions need to be defined, an ascending sort and
* a descending sort.
*/
_oExt.oSort = {
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/*
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* text sorting
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
"string-pre": function ( a )
{
if ( typeof a != 'string' ) { a = ''; }
return a.toLowerCase();
},
"string-asc": function ( x, y )
{
return ((x < y) ? -1 : ((x > y) ? 1 : 0));
},
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
"string-desc": function ( x, y )
{
return ((x < y) ? 1 : ((x > y) ? -1 : 0));
},
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/*
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* html sorting (ignore html tags)
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
"html-pre": function ( a )
{
return a.replace( /<.*?>/g, "" ).toLowerCase();
},
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
"html-asc": function ( x, y )
{
return ((x < y) ? -1 : ((x > y) ? 1 : 0));
},
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
"html-desc": function ( x, y )
{
return ((x < y) ? 1 : ((x > y) ? -1 : 0));
},
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/*
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* date sorting
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
"date-pre": function ( a )
{
var x = Date.parse( a );
if ( isNaN(x) || x==="" )
{
x = Date.parse( "01/01/1970 00:00:00" );
}
return x;
},
"date-asc": function ( x, y )
{
return x - y;
},
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
"date-desc": function ( x, y )
{
return y - x;
},
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/*
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* numerical sorting
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
"numeric-asc": function ( a )
{
return (a=="-" || a==="") ? 0 : a*1;
},
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
"numeric-asc": function ( x, y )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return x - y;
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
},
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
"numeric-desc": function ( x, y )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return y - x;
}
};
/*
* Variable: aTypes
* Purpose: Container for the various type of type detection that dataTables supports
* Scope: jQuery.fn.dataTableExt
* Notes: The functions in this array are expected to parse a string to see if it is a data
* type that it recognises. If so then the function should return the name of the type (a
* corresponding sort function should be defined!), if the type is not recognised then the
* function should return null such that the parser and move on to check the next type.
* Note that ordering is important in this array - the functions are processed linearly,
* starting at index 0.
* Note that the input for these functions is always a string! It cannot be any other data
* type
*/
_oExt.aTypes = [
/*
* Function: -
* Purpose: Check to see if a string is numeric
* Returns: string:'numeric' or null
* Inputs: mixed:sText - string to check
*/
function ( sData )
{
/* Allow zero length strings as a number */
if ( typeof sData == 'number' )
{
return 'numeric';
}
else if ( typeof sData != 'string' )
{
return null;
}
var sValidFirstChars = "0123456789-";
var sValidChars = "0123456789.";
var Char;
var bDecimal = false;
/* Check for a valid first char (no period and allow negatives) */
Char = sData.charAt(0);
if (sValidFirstChars.indexOf(Char) == -1)
{
return null;
}
/* Check all the other characters are valid */
for ( var i=1 ; i<sData.length ; i++ )
{
Char = sData.charAt(i);
if (sValidChars.indexOf(Char) == -1)
{
return null;
}
/* Only allowed one decimal place... */
if ( Char == "." )
{
if ( bDecimal )
{
return null;
}
bDecimal = true;
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return 'numeric';
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
},
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/*
* Function: -
* Purpose: Check to see if a string is actually a formatted date
* Returns: string:'date' or null
* Inputs: string:sText - string to check
*/
function ( sData )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var iParse = Date.parse(sData);
if ( (iParse !== null && !isNaN(iParse)) || (typeof sData == 'string' && sData.length === 0) )
{
return 'date';
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return null;
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
},
/*
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* Function: -
* Purpose: Check to see if a string should be treated as an HTML string
* Returns: string:'html' or null
* Inputs: string:sText - string to check
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
function ( sData )
{
if ( typeof sData == 'string' && sData.indexOf('<') != -1 && sData.indexOf('>') != -1 )
{
return 'html';
}
return null;
}
];
/**
* 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>.
* @class
* @constructor
* @param {object} [oInit={}] Configuration object for DataTables. Options
* are defined by {@link FixedColumns.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 )
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* 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
* @private
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
function _fnAddColumn( oSettings, nTh )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var iCol = oSettings.aoColumns.length;
var oCol = {
"sType": null,
"_bAutoType": true,
"bVisible": true,
"bSearchable": true,
"bSortable": true,
"asSorting": [ 'asc', 'desc' ],
"sSortingClass": oSettings.oClasses.sSortable,
"sSortingClassJUI": oSettings.oClasses.sSortJUI,
"sTitle": nTh ? nTh.innerHTML : '',
"sName": '',
"sWidth": null,
"sWidthOrig": null,
"sClass": null,
"fnRender": null,
"bUseRendered": true,
"aDataSort": [ iCol ],
"mDataProp": iCol,
"fnGetData": null,
"fnSetData": null,
"sSortDataType": 'std',
"sDefaultContent": null,
"sContentPadding": "",
"nTh": nTh ? nTh : document.createElement('th'),
"nTf": null
};
oSettings.aoColumns.push( oCol );
/* Add a column specific filter */
if ( typeof oSettings.aoPreSearchCols[ iCol ] == 'undefined' ||
oSettings.aoPreSearchCols[ iCol ] === null )
{
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
oSettings.aoPreSearchCols[ iCol ] = $.extend( {}, DataTable.models.oSearch );
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
else
{
/* Don't require that the user must specify bRegex and / or bSmart */
if ( typeof oSettings.aoPreSearchCols[ iCol ].bRegex == 'undefined' )
{
oSettings.aoPreSearchCols[ iCol ].bRegex = true;
}
if ( typeof oSettings.aoPreSearchCols[ iCol ].bSmart == 'undefined' )
{
oSettings.aoPreSearchCols[ iCol ].bSmart = true;
}
}
/* Use the column options function to initialise classes etc */
_fnColumnOptions( oSettings, iCol, null );
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* 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
* @private
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
function _fnColumnOptions( oSettings, iCol, oOptions )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var oCol = oSettings.aoColumns[ iCol ];
/* User specified column options */
if ( typeof oOptions != 'undefined' && oOptions !== null )
{
if ( typeof oOptions.sType != 'undefined' )
{
oCol.sType = oOptions.sType;
oCol._bAutoType = false;
}
_fnMap( oCol, oOptions, "bVisible" );
_fnMap( oCol, oOptions, "bSearchable" );
_fnMap( oCol, oOptions, "bSortable" );
_fnMap( oCol, oOptions, "sTitle" );
_fnMap( oCol, oOptions, "sName" );
_fnMap( oCol, oOptions, "sWidth" );
_fnMap( oCol, oOptions, "sWidth", "sWidthOrig" );
_fnMap( oCol, oOptions, "sClass" );
_fnMap( oCol, oOptions, "fnRender" );
_fnMap( oCol, oOptions, "bUseRendered" );
_fnMap( oCol, oOptions, "mDataProp" );
_fnMap( oCol, oOptions, "asSorting" );
_fnMap( oCol, oOptions, "sSortDataType" );
_fnMap( oCol, oOptions, "sDefaultContent" );
_fnMap( oCol, oOptions, "sContentPadding" );
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* iDataSort to be applied (backwards compatibility), but aDataSort will take
* priority if defined
*/
if ( typeof oOptions.iDataSort != 'undefined' )
{
oCol.aDataSort = [ oOptions.iDataSort ];
}
_fnMap( oCol, oOptions, "aDataSort" );
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* 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;
}
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* 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
* @private
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
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;
}
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* 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
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
function _fnVisibleToColumnIndex( oSettings, iMatch )
{
var iColumn = -1;
for ( var i=0 ; i<oSettings.aoColumns.length ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
if ( oSettings.aoColumns[i].bVisible === true )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
iColumn++;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
if ( iColumn == iMatch )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return i;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return null;
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Covert the index of an index in the data array and convert it to the visible
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* column index (take account of hidden columns)
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
* @param {int} iMatch Column index to lookup
* @param {object} oSettings dataTables settings object
* @returns {int} i the data index
* @private
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
function _fnColumnIndexToVisible( oSettings, iMatch )
{
var iVisible = -1;
for ( var i=0 ; i<oSettings.aoColumns.length ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
if ( oSettings.aoColumns[i].bVisible === true )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
iVisible++;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
if ( i == iMatch )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return oSettings.aoColumns[i].bVisible === true ? iVisible : null;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return null;
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Get the number of visible columns
* @returns {int} i the number of visible columns
* @param {object} oS dataTables settings object
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
function _fnVisbleColumns( oS )
{
var iVis = 0;
for ( var i=0 ; i<oS.aoColumns.length ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
if ( oS.aoColumns[i].bVisible === true )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
iVis++;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
}
return iVis;
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* 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)
* @private
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
function _fnDetectType( sData )
{
var aTypes = _oExt.aTypes;
var iLen = aTypes.length;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
for ( var i=0 ; i<iLen ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var sType = aTypes[i]( sData );
if ( sType !== null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return sType;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
}
return 'string';
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Figure out how to reorder a display list
* @param {object} oSettings dataTables settings object
* @returns array {int} aiReturn index list for reordering
* @private
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
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++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
if ( oSettings.aoColumns[i].sName == aColumns[j] )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
aiReturn.push( j );
break;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return aiReturn;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Get the column ordering that DataTables expects
* @param {object} oSettings dataTables settings object
* @returns {string} comma separated list of names
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
function _fnColumnOrdering ( oSettings )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var sNames = '';
for ( var i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
sNames += oSettings.aoColumns[i].sName+',';
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
if ( sNames.length == iLen )
{
return "";
}
return sNames.slice(0, -1);
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Add a data array to the table, creating DOM node etc. This is the parallel to
* _fnGatherData, but for adding rows from a Javascript source, rather than a
* DOM source.
* @param {object} oSettings dataTables settings object
* @param {array} aData data array to be added
* @returns {int} >=0 if successful (index of new aoData entry), -1 if failed
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
function _fnAddData ( oSettings, aDataSupplied )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var oCol;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Take an independent copy of the data source so we can bash it about as we wish */
var aDataIn = ($.isArray(aDataSupplied)) ?
aDataSupplied.slice() :
$.extend( true, {}, aDataSupplied );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Create the object for storing information about this new row */
var iRow = oSettings.aoData.length;
Document the row model and update the data methods to extend this model as the base for aoData
2011-11-26 15:04:58 +01:00
var oData = $.extend( true, {}, DataTable.models.oRow, {
"_aData": aDataIn
} );
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
oSettings.aoData.push( oData );
/* Create the cells */
var nTd, sThisType;
for ( var i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
oCol = oSettings.aoColumns[i];
/* Use rendered data for filtering/sorting */
if ( typeof oCol.fnRender == 'function' && oCol.bUseRendered && oCol.mDataProp !== null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
_fnSetCellData( oSettings, iRow, i, oCol.fnRender( {
"iDataRow": iRow,
"iDataColumn": i,
"aData": oData._aData,
"oSettings": oSettings
} ) );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* See if we should auto-detect the column type */
if ( oCol._bAutoType && oCol.sType != 'string' )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Attempt to auto detect the type - same as _fnGatherData() */
var sVarType = _fnGetCellData( oSettings, iRow, i, 'type' );
if ( sVarType !== null && sVarType !== '' )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
sThisType = _fnDetectType( sVarType );
if ( oCol.sType === null )
{
oCol.sType = sThisType;
}
else if ( oCol.sType != sThisType && oCol.sType != "html" )
{
/* String is always the 'fallback' option */
oCol.sType = 'string';
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Add to the display array */
oSettings.aiDisplayMaster.push( iRow );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Create the DOM imformation */
if ( !oSettings.oFeatures.bDeferRender )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
_fnCreateTr( oSettings, iRow );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return iRow;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Read in the data from the target table from the DOM
* @param {object} oSettings dataTables settings object
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
function _fnGatherData( oSettings )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var iLoop, i, iLen, j, jLen, jInner,
nTds, nTrs, nTd, aLocalData, iThisIndex,
iRow, iRows, iColumn, iColumns, sNodeName;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/*
* Process by row first
* Add the data object for the whole table - storing the tr node. Note - no point in getting
* DOM based data if we are going to go and replace it with Ajax source data.
*/
if ( oSettings.bDeferLoading || oSettings.sAjaxSource === null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
nTrs = oSettings.nTBody.childNodes;
for ( i=0, iLen=nTrs.length ; i<iLen ; i++ )
{
if ( nTrs[i].nodeName.toUpperCase() == "TR" )
{
iThisIndex = oSettings.aoData.length;
Document the row model and update the data methods to extend this model as the base for aoData
2011-11-26 15:04:58 +01:00
oSettings.aoData.push( $.extend( true, {}, DataTable.models.oRow, {
Drop "_iId" from the row model - its not used anywhere in DataTables these days. An old legacy property from the 1.3 days I think - can't imagine any third party plug-ins use this property either - its more or less useless these days.
2011-11-26 15:06:55 +01:00
"nTr": nTrs[i]
Document the row model and update the data methods to extend this model as the base for aoData
2011-11-26 15:04:58 +01:00
} ) );
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
oSettings.aiDisplayMaster.push( iThisIndex );
nTds = nTrs[i].childNodes;
jInner = 0;
for ( j=0, jLen=nTds.length ; j<jLen ; j++ )
{
sNodeName = nTds[j].nodeName.toUpperCase();
if ( sNodeName == "TD" || sNodeName == "TH" )
{
_fnSetCellData( oSettings, iThisIndex, jInner, $.trim(nTds[j].innerHTML) );
jInner++;
}
}
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Gather in the TD elements of the Table - note that this is basically the same as
* fnGetTdNodes, but that function takes account of hidden columns, which we haven't yet
* setup!
*/
nTrs = _fnGetTrNodes( oSettings );
nTds = [];
for ( i=0, iLen=nTrs.length ; i<iLen ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
for ( j=0, jLen=nTrs[i].childNodes.length ; j<jLen ; j++ )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
nTd = nTrs[i].childNodes[j];
sNodeName = nTd.nodeName.toUpperCase();
if ( sNodeName == "TD" || sNodeName == "TH" )
{
nTds.push( nTd );
}
}
}
/* Sanity check */
if ( nTds.length != nTrs.length * oSettings.aoColumns.length )
{
_fnLog( oSettings, 1, "Unexpected number of TD elements. Expected "+
(nTrs.length * oSettings.aoColumns.length)+" and got "+nTds.length+". DataTables does "+
"not support rowspan / colspan in the table body, and there must be one cell for each "+
"row/column combination." );
}
/* Now process by column */
for ( iColumn=0, iColumns=oSettings.aoColumns.length ; iColumn<iColumns ; iColumn++ )
{
/* Get the title of the column - unless there is a user set one */
if ( oSettings.aoColumns[iColumn].sTitle === null )
{
oSettings.aoColumns[iColumn].sTitle = oSettings.aoColumns[iColumn].nTh.innerHTML;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var
bAutoType = oSettings.aoColumns[iColumn]._bAutoType,
bRender = typeof oSettings.aoColumns[iColumn].fnRender == 'function',
bClass = oSettings.aoColumns[iColumn].sClass !== null,
bVisible = oSettings.aoColumns[iColumn].bVisible,
nCell, sThisType, sRendered, sValType;
/* A single loop to rule them all (and be more efficient) */
if ( bAutoType || bRender || bClass || !bVisible )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
for ( iRow=0, iRows=oSettings.aoData.length ; iRow<iRows ; iRow++ )
{
nCell = nTds[ (iRow*iColumns) + iColumn ];
/* Type detection */
if ( bAutoType && oSettings.aoColumns[iColumn].sType != 'string' )
{
sValType = _fnGetCellData( oSettings, iRow, iColumn, 'type' );
if ( sValType !== '' )
{
sThisType = _fnDetectType( sValType );
if ( oSettings.aoColumns[iColumn].sType === null )
{
oSettings.aoColumns[iColumn].sType = sThisType;
}
else if ( oSettings.aoColumns[iColumn].sType != sThisType &&
oSettings.aoColumns[iColumn].sType != "html" )
{
/* String is always the 'fallback' option */
oSettings.aoColumns[iColumn].sType = 'string';
}
}
}
/* Rendering */
if ( bRender )
{
sRendered = oSettings.aoColumns[iColumn].fnRender( {
"iDataRow": iRow,
"iDataColumn": iColumn,
"aData": oSettings.aoData[iRow]._aData,
"oSettings": oSettings
} );
nCell.innerHTML = sRendered;
if ( oSettings.aoColumns[iColumn].bUseRendered )
{
/* Use the rendered data for filtering/sorting */
_fnSetCellData( oSettings, iRow, iColumn, sRendered );
}
}
/* Classes */
if ( bClass )
{
nCell.className += ' '+oSettings.aoColumns[iColumn].sClass;
}
/* Column visability */
if ( !bVisible )
{
oSettings.aoData[iRow]._anHidden[iColumn] = nCell;
nCell.parentNode.removeChild( nCell );
}
else
{
oSettings.aoData[iRow]._anHidden[iColumn] = null;
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
}
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Take a TR element and convert it to an index in aoData
* @param {object} s dataTables settings object
* @param {node} n the TR element to find
* @returns {int} index if found, null if not
* @private
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
function _fnNodeToDataIndex( s, n )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var i, iLen;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Optimisation - see if the nodes which are currently visible match, since that is
* the most likely node to be asked for (a selector or event for example)
*/
for ( i=s._iDisplayStart, iLen=s._iDisplayEnd ; i<iLen ; i++ )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
if ( s.aoData[ s.aiDisplay[i] ].nTr == n )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return s.aiDisplay[i];
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Otherwise we are in for a slog through the whole data cache */
for ( i=0, iLen=s.aoData.length ; i<iLen ; i++ )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
if ( s.aoData[i].nTr == n )
{
return i;
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return null;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Get an array of data for a given row from the internal data cache
* @param {object} oSettings dataTables settings object
* @param {int} iRow aoData row id
* @param {string} sSpecific data get type ('type' 'filter' 'sort')
* @returns {array} Data array
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
function _fnGetRowData( oSettings, iRow, sSpecific )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var out = [];
for ( var i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
out.push( _fnGetCellData( oSettings, iRow, i, sSpecific ) );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return out;
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Get the data for a given cell from the internal cache, taking into account data mapping
* @param {object} oSettings dataTables settings object
* @param {int} iRow aoData row id
* @param {int} iCol Column index
* @param {string} sSpecific data get type ('display', 'type' 'filter' 'sort')
* @returns {*} Cell data
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
function _fnGetCellData( oSettings, iRow, iCol, sSpecific )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var sData;
var oCol = oSettings.aoColumns[iCol];
var oData = oSettings.aoData[iRow]._aData;
if ( (sData=oCol.fnGetData( oData, sSpecific )) === undefined )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
if ( oSettings.iDrawError != oSettings.iDraw && oCol.sDefaultContent === null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
_fnLog( oSettings, 0, "Requested unknown parameter '"+oCol.mDataProp+
"' from the data source for row "+iRow );
oSettings.iDrawError = oSettings.iDraw;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return oCol.sDefaultContent;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* When the data source is null, we can use default column data */
if ( sData === null && oCol.sDefaultContent !== null )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
sData = oCol.sDefaultContent;
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
else if ( typeof sData == 'function' )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* If the data source is a function, then we run it and use the return */
return sData();
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
if ( sSpecific == 'display' && sData === null )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return '';
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return sData;
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Set the value for a specific cell, into the internal data cache
* @param {object} oSettings dataTables settings object
* @param {int} iRow aoData row id
* @param {int} iCol Column index
* @param {*} val Value to set
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
function _fnSetCellData( oSettings, iRow, iCol, val )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var oCol = oSettings.aoColumns[iCol];
var oData = oSettings.aoData[iRow]._aData;
oCol.fnSetData( oData, val );
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Return a function that can be used to get data from a source object, taking
* into account the ability to use nested objects as a source
* @param {string|int|function} mSource The data source for the object
* @returns {function} Data get function
* @private
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
function _fnGetObjectDataFn( mSource )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
if ( mSource === null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Give an empty string for rendering / sorting etc */
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
return function (data, type) {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return null;
};
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
else if ( typeof mSource == 'function' )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return function (data, type) {
return mSource( data, type );
};
}
else if ( typeof mSource == 'string' && mSource.indexOf('.') != -1 )
{
/* If there is a . in the source string then the data source is in a nested object
* we provide two 'quick' functions for the look up to speed up the most common
* operation, and a generalised one for when it is needed
*/
var a = mSource.split('.');
if ( a.length == 2 )
{
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
return function (data, type) {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return data[ a[0] ][ a[1] ];
};
}
else if ( a.length == 3 )
{
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
return function (data, type) {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return data[ a[0] ][ a[1] ][ a[2] ];
};
}
else
{
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
return function (data, type) {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
for ( var i=0, iLen=a.length ; i<iLen ; i++ )
{
data = data[ a[i] ];
}
return data;
};
}
}
else
{
/* Array or flat object mapping */
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
return function (data, type) {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return data[mSource];
};
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Return a function that can be used to set data from a source object, taking
* into account the ability to use nested objects as a source
* @param {string|int|function} mSource The data source for the object
* @returns {function} Data set function
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
function _fnSetObjectDataFn( mSource )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
if ( mSource === null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Nothing to do when the data source is null */
return function (data, val) {};
}
else if ( typeof mSource == 'function' )
{
return function (data, val) {
return mSource( data, val );
};
}
else if ( typeof mSource == 'string' && mSource.indexOf('.') != -1 )
{
/* Like the get, we need to get data from a nested object. Again two fast lookup
* functions are provided, and a generalised one.
*/
var a = mSource.split('.');
if ( a.length == 2 )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return function (data, val) {
data[ a[0] ][ a[1] ] = val;
};
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
else if ( a.length == 3 )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return function (data, val) {
data[ a[0] ][ a[1] ][ a[2] ] = val;
};
}
else
{
return function (data, val) {
for ( var i=0, iLen=a.length-1 ; i<iLen ; i++ )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
data = data[ a[i] ];
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
data[ a[a.length-1] ] = val;
};
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
else
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Array or flat object mapping */
return function (data, val) {
data[mSource] = val;
};
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Return an array with the full table data
* @param {object} oSettings dataTables settings object
* @returns array {array} aData Master data array
* @private
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
function _fnGetDataMaster ( oSettings )
{
var aData = [];
var iLen = oSettings.aoData.length;
for ( var i=0 ; i<iLen; i++ )
{
aData.push( oSettings.aoData[i]._aData );
}
return aData;
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Nuke the table
* @param {object} oSettings dataTables settings object
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
function _fnClearTable( oSettings )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
oSettings.aoData.splice( 0, oSettings.aoData.length );
oSettings.aiDisplayMaster.splice( 0, oSettings.aiDisplayMaster.length );
oSettings.aiDisplay.splice( 0, oSettings.aiDisplay.length );
_fnCalculateEnd( oSettings );
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Take an array of integers (index array) and remove a target integer (value - not
* the key!)
* @param {array} a Index array to target
* @param {int} iTarget value to find
* @private
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
function _fnDeleteIndex( a, iTarget )
{
var iTargetIndex = -1;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
for ( var i=0, iLen=a.length ; i<iLen ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
if ( a[i] == iTarget )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
iTargetIndex = i;
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
else if ( a[i] > iTarget )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
a[i]--;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
if ( iTargetIndex != -1 )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
a.splice( iTargetIndex, 1 );
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Create a new TR element (and it's TD children) for a row
* @param {object} oSettings dataTables settings object
* @param {int} iRow Row to consider
* @private
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
function _fnCreateTr ( oSettings, iRow )
{
var oData = oSettings.aoData[iRow];
var nTd;
if ( oData.nTr === null )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
oData.nTr = document.createElement('tr');
/* Special parameters can be given by the data source to be used on the row */
if ( typeof oData._aData.DT_RowId != 'undefined' )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
oData.nTr.setAttribute( 'id', oData._aData.DT_RowId );
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
if ( typeof oData._aData.DT_RowClass != 'undefined' )
New: fnGetData now has a second parameter (optionally) to get the column data used by DataTables based on mDataSource
2011-04-20 19:55:21 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
$(oData.nTr).addClass( oData._aData.DT_RowClass );
}
/* Process each column */
for ( var i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
{
var oCol = oSettings.aoColumns[i];
nTd = document.createElement('td');
/* Render if needed - if bUseRendered is true then we already have the rendered
* value in the data source - so can just use that
*/
if ( typeof oCol.fnRender == 'function' && (!oCol.bUseRendered || oCol.mDataProp === null) )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
nTd.innerHTML = oCol.fnRender( {
"iDataRow": iRow,
"iDataColumn": i,
"aData": oData._aData,
"oSettings": oSettings
} );
}
else
{
nTd.innerHTML = _fnGetCellData( oSettings, iRow, i, 'display' );
}
/* Add user defined class */
if ( oCol.sClass !== null )
{
nTd.className = oCol.sClass;
}
if ( oCol.bVisible )
{
oData.nTr.appendChild( nTd );
oData._anHidden[i] = null;
}
else
{
oData._anHidden[i] = nTd;
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
New: fnGetData now has a second parameter (optionally) to get the column data used by DataTables based on mDataSource
2011-04-20 19:55:21 +02:00
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Create the HTML header for the table
* @param {object} oSettings dataTables settings object
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
function _fnBuildHead( oSettings )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var i, nTh, iLen, j, jLen;
var anTr = oSettings.nTHead.getElementsByTagName('tr');
var iThs = oSettings.nTHead.getElementsByTagName('th').length;
var iCorrector = 0;
var jqChildren;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* If there is a header in place - then use it - otherwise it's going to get nuked... */
if ( iThs !== 0 )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* We've got a thead from the DOM, so remove hidden columns and apply width to vis cols */
for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
nTh = oSettings.aoColumns[i].nTh;
if ( oSettings.aoColumns[i].sClass !== null )
{
$(nTh).addClass( oSettings.aoColumns[i].sClass );
}
/* Set the title of the column if it is user defined (not what was auto detected) */
if ( oSettings.aoColumns[i].sTitle != nTh.innerHTML )
{
nTh.innerHTML = oSettings.aoColumns[i].sTitle;
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
else
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* We don't have a header in the DOM - so we are going to have to create one */
var nTr = document.createElement( "tr" );
for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
nTh = oSettings.aoColumns[i].nTh;
nTh.innerHTML = oSettings.aoColumns[i].sTitle;
if ( oSettings.aoColumns[i].sClass !== null )
{
$(nTh).addClass( oSettings.aoColumns[i].sClass );
}
nTr.appendChild( nTh );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
$(oSettings.nTHead).html( '' )[0].appendChild( nTr );
_fnDetectHeader( oSettings.aoHeader, oSettings.nTHead );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Add the extra markup needed by jQuery UI's themes */
if ( oSettings.bJUI )
New: fnUpdate has been updated (oh the irony) to accept either an individual value, an array or an object as the first parameter passed to it. The individual and array options behave exactly as they did before this change - the new option is the object being passed in. This allows fnupdate to be given a data object which is identical to data objects used by the table when using complex objects and mDataProp. How fnUpdate itself actually operates has also changed to be self calling, which makes the multipe column updates for arrays and objects much easier. Fix: fnUpdate now works with TH elements in the body as well as TD elements
2011-05-14 11:35:57 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
New: fnUpdate has been updated (oh the irony) to accept either an individual value, an array or an object as the first parameter passed to it. The individual and array options behave exactly as they did before this change - the new option is the object being passed in. This allows fnupdate to be given a data object which is identical to data objects used by the table when using complex objects and mDataProp. How fnUpdate itself actually operates has also changed to be self calling, which makes the multipe column updates for arrays and objects much easier. Fix: fnUpdate now works with TH elements in the body as well as TD elements
2011-05-14 11:35:57 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
nTh = oSettings.aoColumns[i].nTh;
var nDiv = document.createElement('div');
nDiv.className = oSettings.oClasses.sSortJUIWrapper;
$(nTh).contents().appendTo(nDiv);
var nSpan = document.createElement('span');
nSpan.className = oSettings.oClasses.sSortIcon;
nDiv.appendChild( nSpan );
nTh.appendChild( nDiv );
New: fnUpdate has been updated (oh the irony) to accept either an individual value, an array or an object as the first parameter passed to it. The individual and array options behave exactly as they did before this change - the new option is the object being passed in. This allows fnupdate to be given a data object which is identical to data objects used by the table when using complex objects and mDataProp. How fnUpdate itself actually operates has also changed to be self calling, which makes the multipe column updates for arrays and objects much easier. Fix: fnUpdate now works with TH elements in the body as well as TD elements
2011-05-14 11:35:57 +02:00
}
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Add sort listener */
var fnNoSelect = function (e) {
this.onselectstart = function() { return false; };
return false;
};
if ( oSettings.oFeatures.bSort )
New: fnUpdate has been updated (oh the irony) to accept either an individual value, an array or an object as the first parameter passed to it. The individual and array options behave exactly as they did before this change - the new option is the object being passed in. This allows fnupdate to be given a data object which is identical to data objects used by the table when using complex objects and mDataProp. How fnUpdate itself actually operates has also changed to be self calling, which makes the multipe column updates for arrays and objects much easier. Fix: fnUpdate now works with TH elements in the body as well as TD elements
2011-05-14 11:35:57 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
for ( i=0 ; i<oSettings.aoColumns.length ; i++ )
{
if ( oSettings.aoColumns[i].bSortable !== false )
{
_fnSortAttachListener( oSettings, oSettings.aoColumns[i].nTh, i );
/* Take the brutal approach to cancelling text selection in header */
$(oSettings.aoColumns[i].nTh).bind( 'mousedown.DT', fnNoSelect );
}
else
{
$(oSettings.aoColumns[i].nTh).addClass( oSettings.oClasses.sSortableNone );
}
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Deal with the footer - add classes if required */
if ( oSettings.oClasses.sFooterTH !== "" )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
$(oSettings.nTFoot).children('tr').children('th').addClass( oSettings.oClasses.sFooterTH );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Cache the footer elements */
if ( oSettings.nTFoot !== null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var anCells = _fnGetUniqueThs( oSettings, null, oSettings.aoFooter );
for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
{
if ( typeof anCells[i] != 'undefined' )
{
oSettings.aoColumns[i].nTf = anCells[i];
}
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Draw the header (or footer) element based on the column visibility states. The
* methodology here is to use the layout array from _fnDetectHeader, modified for
* the instantaneous column visibility, to construct the new layout. The grid is
* traversed over cell at a time in a rows x columns grid fashion, although each
* cell insert can cover multiple elements in the grid - which is tracks using the
* aApplied array. Cell inserts in the grid will only occur where there isn't
* already a cell in that position.
* @param {object} oSettings dataTables settings object
* @param array {objects} aoSource Layout array from _fnDetectHeader
* @param {boolean} [bIncludeHidden=false] If true then include the hidden columns in the calc,
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
function _fnDrawHead( oSettings, aoSource, bIncludeHidden )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var i, iLen, j, jLen, k, kLen;
var aoLocal = [];
var aApplied = [];
var iColumns = oSettings.aoColumns.length;
var iRowspan, iColspan;
if ( typeof bIncludeHidden == 'undefined' )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
bIncludeHidden = false;
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Make a copy of the master layout array, but without the visible columns in it */
for ( i=0, iLen=aoSource.length ; i<iLen ; i++ )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
aoLocal[i] = aoSource[i].slice();
aoLocal[i].nTr = aoSource[i].nTr;
/* Remove any columns which are currently hidden */
for ( j=iColumns-1 ; j>=0 ; j-- )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
if ( !oSettings.aoColumns[j].bVisible && !bIncludeHidden )
{
aoLocal[i].splice( j, 1 );
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Prep the applied array - it needs an element for each row */
aApplied.push( [] );
}
for ( i=0, iLen=aoLocal.length ; i<iLen ; i++ )
{
/* All cells are going to be replaced, so empty out the row */
if ( aoLocal[i].nTr )
Dev fix: The insertBefore for column visibility was incorrect if the next column was hidden as well. Need to 'fast-forward' to the next visible column to get the insert point.
2011-05-13 07:38:56 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
for ( k=0, kLen=aoLocal[i].nTr.childNodes.length ; k<kLen ; k++ )
{
aoLocal[i].nTr.removeChild( aoLocal[i].nTr.childNodes[0] );
}
Dev fix: The insertBefore for column visibility was incorrect if the next column was hidden as well. Need to 'fast-forward' to the next visible column to get the insert point.
2011-05-13 07:38:56 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
for ( j=0, jLen=aoLocal[i].length ; j<jLen ; j++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
iRowspan = 1;
iColspan = 1;
/* Check to see if there is already a cell (row/colspan) covering our target
* insert point. If there is, then there is nothing to do.
*/
if ( typeof aApplied[i][j] == 'undefined' )
{
aoLocal[i].nTr.appendChild( aoLocal[i][j].cell );
aApplied[i][j] = 1;
/* Expand the cell to cover as many rows as needed */
while ( typeof aoLocal[i+iRowspan] != 'undefined' &&
aoLocal[i][j].cell == aoLocal[i+iRowspan][j].cell )
New: Creation of TR/TD elements when using an Ajax or JS source for the table can be defered until draw time, when the rows are actually needed now - 4739. This is enabled by setting bDeferRender to true at initialisation time. It provides major benefits for speed in IE when dealing with large tables. However do note that if you are using fnGetNodes() with this enabled, then you will only get nodes which have been rendered. New: Unit tests for delayed rendering. Now up to 2500+ unit tests :-)
2011-04-22 20:51:06 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
aApplied[i+iRowspan][j] = 1;
iRowspan++;
New: Creation of TR/TD elements when using an Ajax or JS source for the table can be defered until draw time, when the rows are actually needed now - 4739. This is enabled by setting bDeferRender to true at initialisation time. It provides major benefits for speed in IE when dealing with large tables. However do note that if you are using fnGetNodes() with this enabled, then you will only get nodes which have been rendered. New: Unit tests for delayed rendering. Now up to 2500+ unit tests :-)
2011-04-22 20:51:06 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Expand the cell to cover as many columns as needed */
while ( typeof aoLocal[i][j+iColspan] != 'undefined' &&
aoLocal[i][j].cell == aoLocal[i][j+iColspan].cell )
{
/* Must update the applied array over the rows for the columns */
for ( k=0 ; k<iRowspan ; k++ )
{
aApplied[i+k][j+iColspan] = 1;
}
iColspan++;
}
/* Do the actual expansion in the DOM */
aoLocal[i][j].cell.rowSpan = iRowspan;
aoLocal[i][j].cell.colSpan = iColspan;
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Insert the required TR nodes into the table for display
* @param {object} oSettings dataTables settings object
* @private
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
function _fnDraw( oSettings )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var i, iLen;
var anRows = [];
var iRowCount = 0;
var bRowError = false;
var iStripes = oSettings.asStripeClasses.length;
var iOpenRows = oSettings.aoOpenRows.length;
/* Provide a pre-callback function which can be used to cancel the draw is false is returned */
if ( oSettings.fnPreDrawCallback !== null &&
oSettings.fnPreDrawCallback.call( oSettings.oInstance, oSettings ) === false )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return;
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
oSettings.bDrawing = true;
/* Check and see if we have an initial draw position from state saving */
if ( typeof oSettings.iInitDisplayStart != 'undefined' && oSettings.iInitDisplayStart != -1 )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
if ( oSettings.oFeatures.bServerSide )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
oSettings._iDisplayStart = oSettings.iInitDisplayStart;
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
else
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
oSettings._iDisplayStart = (oSettings.iInitDisplayStart >= oSettings.fnRecordsDisplay()) ?
0 : oSettings.iInitDisplayStart;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
oSettings.iInitDisplayStart = -1;
_fnCalculateEnd( oSettings );
New: Column visibilty will now work great with rowspan / colspan in the header and footer! The way this is done is by creating a stored grid of the header/footer information - a grid of rows x columns - which contains information about the cell that should be at each point - regardless of rowspan / colspan. From that information it is then possible to draw the header / footer, minus any column (or row, although that is not used here) as needed. The initialisation and column visibility functions have been updated to account for this. This allows ColVis and the other plug-ins to 'just work' with complex headers. New: Initialisation parameter: bSortCellsTop. This parameter allows control over whether DataTables should use the top (true) unique cell that is found for a single column, or the bottom (false - default). This is useful when using complex headers. Removed: From the column definiations array (aoColumns) there is now no longer any need for anThExtra, anTfExtra or nTf. These have now been removed and will cause compatibilty issues for any plug-ins which use them. Fix: Tidy up spaces where there should be tabs
2011-04-10 20:15:09 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Server-side processing draw intercept */
if ( oSettings.bDeferLoading )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
oSettings.bDeferLoading = false;
oSettings.iDraw++;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
else if ( !oSettings.oFeatures.bServerSide )
New: fnSetColumnVis now has the option to cancel the redraw by passing the third parameter to the function as false (default is true).
2010-10-30 07:39:48 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
oSettings.iDraw++;
New: fnSetColumnVis now has the option to cancel the redraw by passing the third parameter to the function as false (default is true).
2010-10-30 07:39:48 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
else if ( !oSettings.bDestroying && !_fnAjaxUpdate( oSettings ) )
Fixed: fnDestroy didn't restore columns which had been hidden by DataTables, resulting in these columns being completely lost - 2569
2010-08-22 09:47:06 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return;
Fixed: fnDestroy didn't restore columns which had been hidden by DataTables, resulting in these columns being completely lost - 2569
2010-08-22 09:47:06 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
if ( oSettings.aiDisplay.length !== 0 )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var iStart = oSettings._iDisplayStart;
var iEnd = oSettings._iDisplayEnd;
if ( oSettings.oFeatures.bServerSide )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
iStart = 0;
iEnd = oSettings.aoData.length;
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
for ( var j=iStart ; j<iEnd ; j++ )
{
var aoData = oSettings.aoData[ oSettings.aiDisplay[j] ];
if ( aoData.nTr === null )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
_fnCreateTr( oSettings, oSettings.aiDisplay[j] );
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var nRow = aoData.nTr;
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Remove the old striping classes and then add the new one */
if ( iStripes !== 0 )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var sStripe = oSettings.asStripeClasses[ iRowCount % iStripes ];
if ( aoData._sRowStripe != sStripe )
{
$(nRow).removeClass( aoData._sRowStripe ).addClass( sStripe );
aoData._sRowStripe = sStripe;
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Custom row callback function - might want to manipule the row */
if ( typeof oSettings.fnRowCallback == "function" )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
nRow = oSettings.fnRowCallback.call( oSettings.oInstance, nRow,
oSettings.aoData[ oSettings.aiDisplay[j] ]._aData, iRowCount, j );
if ( !nRow && !bRowError )
{
_fnLog( oSettings, 0, "A node was not returned by fnRowCallback" );
bRowError = true;
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
anRows.push( nRow );
iRowCount++;
/* If there is an open row - and it is attached to this parent - attach it on redraw */
if ( iOpenRows !== 0 )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
for ( var k=0 ; k<iOpenRows ; k++ )
{
if ( nRow == oSettings.aoOpenRows[k].nParent )
{
anRows.push( oSettings.aoOpenRows[k].nTr );
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
}
Fix: fnDestory would put the table back into the DOM in the wrong place if the table wasn't the the only (or last) element in the parent (i.e. it was just doing an append) - 4751
2011-04-23 09:58:58 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
else
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Table is empty - create a row with an empty message in it */
anRows[ 0 ] = document.createElement( 'tr' );
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
if ( typeof oSettings.asStripeClasses[0] != 'undefined' )
New: Creation of TR/TD elements when using an Ajax or JS source for the table can be defered until draw time, when the rows are actually needed now - 4739. This is enabled by setting bDeferRender to true at initialisation time. It provides major benefits for speed in IE when dealing with large tables. However do note that if you are using fnGetNodes() with this enabled, then you will only get nodes which have been rendered. New: Unit tests for delayed rendering. Now up to 2500+ unit tests :-)
2011-04-22 20:51:06 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
anRows[ 0 ].className = oSettings.asStripeClasses[0];
New: Creation of TR/TD elements when using an Ajax or JS source for the table can be defered until draw time, when the rows are actually needed now - 4739. This is enabled by setting bDeferRender to true at initialisation time. It provides major benefits for speed in IE when dealing with large tables. However do note that if you are using fnGetNodes() with this enabled, then you will only get nodes which have been rendered. New: Unit tests for delayed rendering. Now up to 2500+ unit tests :-)
2011-04-22 20:51:06 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var sZero = oSettings.oLanguage.sZeroRecords.replace(
'_MAX_', oSettings.fnFormatNumber(oSettings.fnRecordsTotal()) );
if ( oSettings.iDraw == 1 && oSettings.sAjaxSource !== null && !oSettings.oFeatures.bServerSide )
{
sZero = oSettings.oLanguage.sLoadingRecords;
}
else if ( typeof oSettings.oLanguage.sEmptyTable != 'undefined' &&
oSettings.fnRecordsTotal() === 0 )
{
sZero = oSettings.oLanguage.sEmptyTable;
}
var nTd = document.createElement( 'td' );
nTd.setAttribute( 'valign', "top" );
nTd.colSpan = _fnVisbleColumns( oSettings );
nTd.className = oSettings.oClasses.sRowEmpty;
nTd.innerHTML = sZero;
anRows[ iRowCount ].appendChild( nTd );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Callback the header and footer custom funcation if there is one */
if ( typeof oSettings.fnHeaderCallback == 'function' )
Fix: The table width is not set when auto width is disabled so we should not set it when destroying the table - 5220
2011-06-20 19:08:10 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
oSettings.fnHeaderCallback.call( oSettings.oInstance, $(oSettings.nTHead).children('tr')[0],
_fnGetDataMaster( oSettings ), oSettings._iDisplayStart, oSettings.fnDisplayEnd(),
oSettings.aiDisplay );
Fix: The table width is not set when auto width is disabled so we should not set it when destroying the table - 5220
2011-06-20 19:08:10 +02:00
}
Fixed: Now restore the width of the original table on fnDestory. This is needed for when using sScrollXInner, and on other occasions where using DataTables will force the table to be wider than it otherwise would be - 2840
2010-09-30 23:06:41 +02:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
if ( typeof oSettings.fnFooterCallback == 'function' )
{
oSettings.fnFooterCallback.call( oSettings.oInstance, $(oSettings.nTFoot).children('tr')[0],
_fnGetDataMaster( oSettings ), oSettings._iDisplayStart, oSettings.fnDisplayEnd(),
oSettings.aiDisplay );
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/*
* Need to remove any old row from the display - note we can't just empty the tbody using
* $().html('') since this will unbind the jQuery event handlers (even although the node
* still exists!) - equally we can't use innerHTML, since IE throws an exception.
*/
var
nAddFrag = document.createDocumentFragment(),
nRemoveFrag = document.createDocumentFragment(),
nBodyPar, nTrs;
if ( oSettings.nTBody )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
nBodyPar = oSettings.nTBody.parentNode;
nRemoveFrag.appendChild( oSettings.nTBody );
/* When doing infinite scrolling, only remove child rows when sorting, filtering or start
* up. When not infinite scroll, always do it.
*/
if ( !oSettings.oScroll.bInfinite || !oSettings._bInitComplete ||
oSettings.bSorted || oSettings.bFiltered )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
nTrs = oSettings.nTBody.childNodes;
for ( i=nTrs.length-1 ; i>=0 ; i-- )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
nTrs[i].parentNode.removeChild( nTrs[i] );
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Put the draw table into the dom */
for ( i=0, iLen=anRows.length ; i<iLen ; i++ )
{
nAddFrag.appendChild( anRows[i] );
}
oSettings.nTBody.appendChild( nAddFrag );
if ( nBodyPar !== null )
{
nBodyPar.appendChild( oSettings.nTBody );
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Call all required callback functions for the end of a draw */
for ( i=oSettings.aoDrawCallback.length-1 ; i>=0 ; i-- )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
oSettings.aoDrawCallback[i].fn.call( oSettings.oInstance, oSettings );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
$(oSettings.oInstance).trigger('draw', oSettings);
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Draw is complete, sorting and filtering must be as well */
oSettings.bSorted = false;
oSettings.bFiltered = false;
oSettings.bDrawing = false;
if ( oSettings.oFeatures.bServerSide )
Updated: fnAdjustColumnSizing when called with 'false' as the first (and only) parameter will now apply the calculated column sizes to the table when scrolling is being used. This allows a non-Ajax update to occur if using server-side processing. Thanks to Cat Weismann for this patch.
2010-11-18 22:55:36 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
_fnProcessingDisplay( oSettings, false );
if ( typeof oSettings._bInitComplete == 'undefined' )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
_fnInitComplete( oSettings );
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
Updated: fnAdjustColumnSizing when called with 'false' as the first (and only) parameter will now apply the calculated column sizes to the table when scrolling is being used. This allows a non-Ajax update to occur if using server-side processing. Thanks to Cat Weismann for this patch.
2010-11-18 22:55:36 +01:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
New: New API method '$' which will perform a jQuery selector action on the TR elements from the table's TBODY, regardless of paging. For example: oTable.$('#allan').css('background-color', 'red') will find the element (TR, TD or anything else) which has an ID of 'allan' and perform the css action on it. This is potentially a much nicer interface than needing to use fnGetNodes. Still more to be done, such as options to take column visibility, ordering and filtering into account, but this might be the tipping point for calling it 1.9 :-)
2011-11-09 09:58:24 +01:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Redraw the table - taking account of the various features which are enabled
* @param {object} oSettings dataTables settings object
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
function _fnReDraw( oSettings )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
if ( oSettings.oFeatures.bSort )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Sorting will refilter and draw for us */
_fnSort( oSettings, oSettings.oPreviousSearch );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
else if ( oSettings.oFeatures.bFilter )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Filtering will redraw for us */
_fnFilterComplete( oSettings, oSettings.oPreviousSearch );
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
else
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
_fnCalculateEnd( oSettings );
_fnDraw( oSettings );
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Update the table using an Ajax call
* @param {object} oSettings dataTables settings object
* @returns {boolean} Block the table drawing or not
* @private
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
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;
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* 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
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
function _fnAjaxParameters( oSettings )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var iColumns = oSettings.aoColumns.length;
var aoData = [], mDataProp;
var i;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
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++ )
New: Column visibilty will now work great with rowspan / colspan in the header and footer! The way this is done is by creating a stored grid of the header/footer information - a grid of rows x columns - which contains information about the cell that should be at each point - regardless of rowspan / colspan. From that information it is then possible to draw the header / footer, minus any column (or row, although that is not used here) as needed. The initialisation and column visibility functions have been updated to account for this. This allows ColVis and the other plug-ins to 'just work' with complex headers. New: Initialisation parameter: bSortCellsTop. This parameter allows control over whether DataTables should use the top (true) unique cell that is found for a single column, or the bottom (false - default). This is useful when using complex headers. Removed: From the column definiations array (aoColumns) there is now no longer any need for anThExtra, anTfExtra or nTf. These have now been removed and will cause compatibilty issues for any plug-ins which use them. Fix: Tidy up spaces where there should be tabs
2011-04-10 20:15:09 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
mDataProp = oSettings.aoColumns[i].mDataProp;
aoData.push( { "name": "mDataProp_"+i, "value": typeof(mDataProp)=="function" ? 'function' : mDataProp } );
New: Column visibilty will now work great with rowspan / colspan in the header and footer! The way this is done is by creating a stored grid of the header/footer information - a grid of rows x columns - which contains information about the cell that should be at each point - regardless of rowspan / colspan. From that information it is then possible to draw the header / footer, minus any column (or row, although that is not used here) as needed. The initialisation and column visibility functions have been updated to account for this. This allows ColVis and the other plug-ins to 'just work' with complex headers. New: Initialisation parameter: bSortCellsTop. This parameter allows control over whether DataTables should use the top (true) unique cell that is found for a single column, or the bottom (false - default). This is useful when using complex headers. Removed: From the column definiations array (aoColumns) there is now no longer any need for anThExtra, anTfExtra or nTf. These have now been removed and will cause compatibilty issues for any plug-ins which use them. Fix: Tidy up spaces where there should be tabs
2011-04-10 20:15:09 +02:00
}
Fixed: Processing indicator wasn't being shown during initialisation for non-Ajax sourced data, if it was enabled
2010-10-16 19:10:25 +02:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Filtering */
if ( oSettings.oFeatures.bFilter !== false )
Fixed: Column widths we being calculated by not applied. Due to the column width calculation now being done after the header is drawn, the widths need to be likewise done afterwards.
2010-09-07 19:21:05 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
aoData.push( { "name": "sSearch", "value": oSettings.oPreviousSearch.sSearch } );
aoData.push( { "name": "bRegex", "value": oSettings.oPreviousSearch.bRegex } );
for ( i=0 ; i<iColumns ; i++ )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
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 } );
Fixed: Column widths we being calculated by not applied. Due to the column width calculation now being done after the header is drawn, the widths need to be likewise done afterwards.
2010-09-07 19:21:05 +02:00
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Sorting */
if ( oSettings.oFeatures.bSort !== false )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var iFixed = oSettings.aaSortingFixed !== null ? oSettings.aaSortingFixed.length : 0;
var iUser = oSettings.aaSorting.length;
aoData.push( { "name": "iSortingCols", "value": iFixed+iUser } );
for ( i=0 ; i<iFixed ; i++ )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
aoData.push( { "name": "iSortCol_"+i, "value": oSettings.aaSortingFixed[i][0] } );
aoData.push( { "name": "sSortDir_"+i, "value": oSettings.aaSortingFixed[i][1] } );
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
for ( i=0 ; i<iUser ; i++ )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
aoData.push( { "name": "iSortCol_"+(i+iFixed), "value": oSettings.aaSorting[i][0] } );
aoData.push( { "name": "sSortDir_"+(i+iFixed), "value": oSettings.aaSorting[i][1] } );
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
for ( i=0 ; i<iColumns ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
aoData.push( { "name": "bSortable_"+i, "value": oSettings.aoColumns[i].bSortable } );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
}
return aoData;
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Add Ajax parameters from plugins
* @param {object} oSettings dataTables settings object
* @param array {objects} aoData name/value pairs to send to the server
* @private
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
function _fnServerParams( oSettings, aoData )
{
for ( var i=0, iLen=oSettings.aoServerParams.length ; i<iLen ; i++ )
{
oSettings.aoServerParams[i].fn.call( oSettings.oInstance, aoData );
}
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* 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 {object} json.sEcho Tracking flag for DataTables to match requests
* @param {object} json.iTotalRecords Number of records in the data set, not accounting for filtering
* @param {object} json.iTotalDisplayRecords Number of records in the data set, accounting for filtering
* @param {object} json.aaData The data to display on this page
* @param {object} [json.sColumns] Column ordering (sName, comma separated)
* @private
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
function _fnAjaxUpdateDraw ( oSettings, json )
{
if ( typeof 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 )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
return;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
else
New: aDataSort parameter for columns - this allows a column's sorting to take multiple columns into account when doing a sort. For example first name / last name columns make sense to do a multi-column sort. Previously in DataTables you would need to have the user do a multi-column sort themselves (with shift), but now you can define aDataSort (for example aDataSort: [ 0, 1 ]) to do effectively a multi column sort. Note that this is not shown to the end user that this was a multi-column sort in the same way that iDataSort wouldn't indicate that it could sort on a different column (if that was configured). Also note that iDataSort is still available for use and has not been modified externally, but if aDataSort is defined it will be given priority over any iDataSort parameter.
2011-11-18 17:21:44 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
oSettings.iDraw = json.sEcho * 1;
New: aDataSort parameter for columns - this allows a column's sorting to take multiple columns into account when doing a sort. For example first name / last name columns make sense to do a multi-column sort. Previously in DataTables you would need to have the user do a multi-column sort themselves (with shift), but now you can define aDataSort (for example aDataSort: [ 0, 1 ]) to do effectively a multi column sort. Note that this is not shown to the end user that this was a multi-column sort in the same way that iDataSort wouldn't indicate that it could sort on a different column (if that was configured). Also note that iDataSort is still available for use and has not been modified externally, but if aDataSort is defined it will be given priority over any iDataSort parameter.
2011-11-18 17:21:44 +01:00
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
if ( !oSettings.oScroll.bInfinite ||
(oSettings.oScroll.bInfinite && (oSettings.bSorted || oSettings.bFiltered)) )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
_fnClearTable( oSettings );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
oSettings._iRecordsTotal = json.iTotalRecords;
oSettings._iRecordsDisplay = json.iTotalDisplayRecords;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Determine if reordering is required */
var sOrdering = _fnColumnOrdering(oSettings);
var bReOrder = (typeof json.sColumns != 'undefined' && sOrdering !== "" && json.sColumns != sOrdering );
if ( bReOrder )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var aiIndex = _fnReOrderIndex( oSettings, json.sColumns );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var aData = _fnGetObjectDataFn( oSettings.sAjaxDataProp )( json );
for ( var i=0, iLen=aData.length ; i<iLen ; i++ )
Fix: HTML column type could sometimes be overridden by the string sorting type. If a cell was found to have just a string and no HTML in it then the whole column would be treated as a string column, even if other cells had HTML. Now put a check in place to ensure that string can't overrule html type. Unit test added.
2011-09-09 20:32:59 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
if ( bReOrder )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* 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++ )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
aDataSorted.push( aData[i][ aiIndex[j] ] );
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
_fnAddData( oSettings, aDataSorted );
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
else
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* No re-order required, sever got it "right" - just straight add */
_fnAddData( oSettings, aData[i] );
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
Fix: HTML column type could sometimes be overridden by the string sorting type. If a cell was found to have just a string and no HTML in it then the whole column would be treated as a string column, even if other cells had HTML. Now put a check in place to ensure that string can't overrule html type. Unit test added.
2011-09-09 20:32:59 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
oSettings.bAjaxDataGet = false;
_fnDraw( oSettings );
oSettings.bAjaxDataGet = true;
_fnProcessingDisplay( oSettings, false );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Add the options to the page HTML for the table
* @param {object} oSettings dataTables settings object
* @private
New: Column visibilty will now work great with rowspan / colspan in the header and footer! The way this is done is by creating a stored grid of the header/footer information - a grid of rows x columns - which contains information about the cell that should be at each point - regardless of rowspan / colspan. From that information it is then possible to draw the header / footer, minus any column (or row, although that is not used here) as needed. The initialisation and column visibility functions have been updated to account for this. This allows ColVis and the other plug-ins to 'just work' with complex headers. New: Initialisation parameter: bSortCellsTop. This parameter allows control over whether DataTables should use the top (true) unique cell that is found for a single column, or the bottom (false - default). This is useful when using complex headers. Removed: From the column definiations array (aoColumns) there is now no longer any need for anThExtra, anTfExtra or nTf. These have now been removed and will cause compatibilty issues for any plug-ins which use them. Fix: Tidy up spaces where there should be tabs
2011-04-10 20:15:09 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnAddOptionsHtml ( oSettings )
New: Column visibilty will now work great with rowspan / colspan in the header and footer! The way this is done is by creating a stored grid of the header/footer information - a grid of rows x columns - which contains information about the cell that should be at each point - regardless of rowspan / colspan. From that information it is then possible to draw the header / footer, minus any column (or row, although that is not used here) as needed. The initialisation and column visibility functions have been updated to account for this. This allows ColVis and the other plug-ins to 'just work' with complex headers. New: Initialisation parameter: bSortCellsTop. This parameter allows control over whether DataTables should use the top (true) unique cell that is found for a single column, or the bottom (false - default). This is useful when using complex headers. Removed: From the column definiations array (aoColumns) there is now no longer any need for anThExtra, anTfExtra or nTf. These have now been removed and will cause compatibilty issues for any plug-ins which use them. Fix: Tidy up spaces where there should be tabs
2011-04-10 20:15:09 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/*
* Create a temporary, empty, div which we can later on replace with what we have generated
* we do it this way to rendering the 'options' html offline - speed :-)
*/
var nHolding = document.createElement( 'div' );
oSettings.nTable.parentNode.insertBefore( nHolding, oSettings.nTable );
/*
* All DataTables are wrapped in a div
*/
oSettings.nTableWrapper = document.createElement( 'div' );
oSettings.nTableWrapper.className = oSettings.oClasses.sWrapper;
if ( oSettings.sTableId !== '' )
Dev fix: Clean up the calls to _fnDrawHead
2011-04-27 20:18:08 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
oSettings.nTableWrapper.setAttribute( 'id', oSettings.sTableId+'_wrapper' );
Dev fix: Clean up the calls to _fnDrawHead
2011-04-27 20:18:08 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
oSettings.nTableReinsertBefore = oSettings.nTable.nextSibling;
/* Track where we want to insert the option */
var nInsertNode = oSettings.nTableWrapper;
/* Loop over the user set positioning and place the elements as needed */
var aDom = oSettings.sDom.split('');
var nTmp, iPushFeature, cOption, nNewNode, cNext, sAttr, j;
for ( var i=0 ; i<aDom.length ; i++ )
New: Column visibilty will now work great with rowspan / colspan in the header and footer! The way this is done is by creating a stored grid of the header/footer information - a grid of rows x columns - which contains information about the cell that should be at each point - regardless of rowspan / colspan. From that information it is then possible to draw the header / footer, minus any column (or row, although that is not used here) as needed. The initialisation and column visibility functions have been updated to account for this. This allows ColVis and the other plug-ins to 'just work' with complex headers. New: Initialisation parameter: bSortCellsTop. This parameter allows control over whether DataTables should use the top (true) unique cell that is found for a single column, or the bottom (false - default). This is useful when using complex headers. Removed: From the column definiations array (aoColumns) there is now no longer any need for anThExtra, anTfExtra or nTf. These have now been removed and will cause compatibilty issues for any plug-ins which use them. Fix: Tidy up spaces where there should be tabs
2011-04-10 20:15:09 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
iPushFeature = 0;
cOption = aDom[i];
if ( cOption == '<' )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* New container div */
nNewNode = document.createElement( 'div' );
/* Check to see if we should append an id and/or a class name to the container */
cNext = aDom[i+1];
if ( cNext == "'" || cNext == '"' )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
sAttr = "";
j = 2;
while ( aDom[i+j] != cNext )
{
sAttr += aDom[i+j];
j++;
}
/* Replace jQuery UI constants */
if ( sAttr == "H" )
{
sAttr = "fg-toolbar ui-toolbar ui-widget-header ui-corner-tl ui-corner-tr ui-helper-clearfix";
}
else if ( sAttr == "F" )
{
sAttr = "fg-toolbar ui-toolbar ui-widget-header ui-corner-bl ui-corner-br ui-helper-clearfix";
}
/* The attribute can be in the format of "#id.class", "#id" or "class" This logic
* breaks the string into parts and applies them as needed
*/
if ( sAttr.indexOf('.') != -1 )
{
var aSplit = sAttr.split('.');
nNewNode.setAttribute('id', aSplit[0].substr(1, aSplit[0].length-1) );
nNewNode.className = aSplit[1];
}
else if ( sAttr.charAt(0) == "#" )
{
nNewNode.setAttribute('id', sAttr.substr(1, sAttr.length-1) );
}
else
{
nNewNode.className = sAttr;
}
i += j; /* Move along the position array */
New: Column visibilty will now work great with rowspan / colspan in the header and footer! The way this is done is by creating a stored grid of the header/footer information - a grid of rows x columns - which contains information about the cell that should be at each point - regardless of rowspan / colspan. From that information it is then possible to draw the header / footer, minus any column (or row, although that is not used here) as needed. The initialisation and column visibility functions have been updated to account for this. This allows ColVis and the other plug-ins to 'just work' with complex headers. New: Initialisation parameter: bSortCellsTop. This parameter allows control over whether DataTables should use the top (true) unique cell that is found for a single column, or the bottom (false - default). This is useful when using complex headers. Removed: From the column definiations array (aoColumns) there is now no longer any need for anThExtra, anTfExtra or nTf. These have now been removed and will cause compatibilty issues for any plug-ins which use them. Fix: Tidy up spaces where there should be tabs
2011-04-10 20:15:09 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nInsertNode.appendChild( nNewNode );
nInsertNode = nNewNode;
New: Column visibilty will now work great with rowspan / colspan in the header and footer! The way this is done is by creating a stored grid of the header/footer information - a grid of rows x columns - which contains information about the cell that should be at each point - regardless of rowspan / colspan. From that information it is then possible to draw the header / footer, minus any column (or row, although that is not used here) as needed. The initialisation and column visibility functions have been updated to account for this. This allows ColVis and the other plug-ins to 'just work' with complex headers. New: Initialisation parameter: bSortCellsTop. This parameter allows control over whether DataTables should use the top (true) unique cell that is found for a single column, or the bottom (false - default). This is useful when using complex headers. Removed: From the column definiations array (aoColumns) there is now no longer any need for anThExtra, anTfExtra or nTf. These have now been removed and will cause compatibilty issues for any plug-ins which use them. Fix: Tidy up spaces where there should be tabs
2011-04-10 20:15:09 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
else if ( cOption == '>' )
New: Complex headers will now work as would be expected when giving a custom width (sWidth) to a specific column. Fix: $().empty() removes events was well as removing the child elements, so it was removing the sorting events when drawing the header. Now just manually remove them using DOM - was introduced in the last commit
2011-04-12 20:36:07 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* End container div */
nInsertNode = nInsertNode.parentNode;
New: Complex headers will now work as would be expected when giving a custom width (sWidth) to a specific column. Fix: $().empty() removes events was well as removing the child elements, so it was removing the sorting events when drawing the header. Now just manually remove them using DOM - was introduced in the last commit
2011-04-12 20:36:07 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
else if ( cOption == 'l' && oSettings.oFeatures.bPaginate && oSettings.oFeatures.bLengthChange )
New: Column visibilty will now work great with rowspan / colspan in the header and footer! The way this is done is by creating a stored grid of the header/footer information - a grid of rows x columns - which contains information about the cell that should be at each point - regardless of rowspan / colspan. From that information it is then possible to draw the header / footer, minus any column (or row, although that is not used here) as needed. The initialisation and column visibility functions have been updated to account for this. This allows ColVis and the other plug-ins to 'just work' with complex headers. New: Initialisation parameter: bSortCellsTop. This parameter allows control over whether DataTables should use the top (true) unique cell that is found for a single column, or the bottom (false - default). This is useful when using complex headers. Removed: From the column definiations array (aoColumns) there is now no longer any need for anThExtra, anTfExtra or nTf. These have now been removed and will cause compatibilty issues for any plug-ins which use them. Fix: Tidy up spaces where there should be tabs
2011-04-10 20:15:09 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Length */
nTmp = _fnFeatureHtmlLength( oSettings );
iPushFeature = 1;
}
else if ( cOption == 'f' && oSettings.oFeatures.bFilter )
{
/* Filter */
nTmp = _fnFeatureHtmlFilter( oSettings );
iPushFeature = 1;
}
else if ( cOption == 'r' && oSettings.oFeatures.bProcessing )
{
/* pRocessing */
nTmp = _fnFeatureHtmlProcessing( oSettings );
iPushFeature = 1;
}
else if ( cOption == 't' )
{
/* Table */
nTmp = _fnFeatureHtmlTable( oSettings );
iPushFeature = 1;
}
else if ( cOption == 'i' && oSettings.oFeatures.bInfo )
{
/* Info */
nTmp = _fnFeatureHtmlInfo( oSettings );
iPushFeature = 1;
}
else if ( cOption == 'p' && oSettings.oFeatures.bPaginate )
{
/* Pagination */
nTmp = _fnFeatureHtmlPaginate( oSettings );
iPushFeature = 1;
}
else if ( _oExt.aoFeatures.length !== 0 )
{
/* Plug-in features */
var aoFeatures = _oExt.aoFeatures;
for ( var k=0, kLen=aoFeatures.length ; k<kLen ; k++ )
New: Column visibilty will now work great with rowspan / colspan in the header and footer! The way this is done is by creating a stored grid of the header/footer information - a grid of rows x columns - which contains information about the cell that should be at each point - regardless of rowspan / colspan. From that information it is then possible to draw the header / footer, minus any column (or row, although that is not used here) as needed. The initialisation and column visibility functions have been updated to account for this. This allows ColVis and the other plug-ins to 'just work' with complex headers. New: Initialisation parameter: bSortCellsTop. This parameter allows control over whether DataTables should use the top (true) unique cell that is found for a single column, or the bottom (false - default). This is useful when using complex headers. Removed: From the column definiations array (aoColumns) there is now no longer any need for anThExtra, anTfExtra or nTf. These have now been removed and will cause compatibilty issues for any plug-ins which use them. Fix: Tidy up spaces where there should be tabs
2011-04-10 20:15:09 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( cOption == aoFeatures[k].cFeature )
New: Column visibility options in DataTables (bVisible and fnSetColumnVis) now take into account more than one row in THEAD and TFOOT. Please note that colspan and rowspan are NOT supported when using column visibility options in the header and footer, and will very likely have effects which are not at all desirable. As such there are conditions on this use (note that if you only have one row in the header / footer, then this has no impact), specifically the number of cells in the header / footer much be equal to the columns * rows (in each one). This way DataTables can accurately add and remove the cells as needed. The cells may be either TH or TD elements, but DataTables still requires at least one TH element for each column. Updated: Previously when multiple cells were detected as unique to a column the last one would be given priority (i.e. sorting event handler etc). This is now no longer the case and the first will take priority.
2010-11-02 19:25:00 +01:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nTmp = aoFeatures[k].fnInit( oSettings );
if ( nTmp )
New: Column visibility options in DataTables (bVisible and fnSetColumnVis) now take into account more than one row in THEAD and TFOOT. Please note that colspan and rowspan are NOT supported when using column visibility options in the header and footer, and will very likely have effects which are not at all desirable. As such there are conditions on this use (note that if you only have one row in the header / footer, then this has no impact), specifically the number of cells in the header / footer much be equal to the columns * rows (in each one). This way DataTables can accurately add and remove the cells as needed. The cells may be either TH or TD elements, but DataTables still requires at least one TH element for each column. Updated: Previously when multiple cells were detected as unique to a column the last one would be given priority (i.e. sorting event handler etc). This is now no longer the case and the first will take priority.
2010-11-02 19:25:00 +01:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
iPushFeature = 1;
New: Column visibility options in DataTables (bVisible and fnSetColumnVis) now take into account more than one row in THEAD and TFOOT. Please note that colspan and rowspan are NOT supported when using column visibility options in the header and footer, and will very likely have effects which are not at all desirable. As such there are conditions on this use (note that if you only have one row in the header / footer, then this has no impact), specifically the number of cells in the header / footer much be equal to the columns * rows (in each one). This way DataTables can accurately add and remove the cells as needed. The cells may be either TH or TD elements, but DataTables still requires at least one TH element for each column. Updated: Previously when multiple cells were detected as unique to a column the last one would be given priority (i.e. sorting event handler etc). This is now no longer the case and the first will take priority.
2010-11-02 19:25:00 +01:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
break;
New: Column visibility options in DataTables (bVisible and fnSetColumnVis) now take into account more than one row in THEAD and TFOOT. Please note that colspan and rowspan are NOT supported when using column visibility options in the header and footer, and will very likely have effects which are not at all desirable. As such there are conditions on this use (note that if you only have one row in the header / footer, then this has no impact), specifically the number of cells in the header / footer much be equal to the columns * rows (in each one). This way DataTables can accurately add and remove the cells as needed. The cells may be either TH or TD elements, but DataTables still requires at least one TH element for each column. Updated: Previously when multiple cells were detected as unique to a column the last one would be given priority (i.e. sorting event handler etc). This is now no longer the case and the first will take priority.
2010-11-02 19:25:00 +01:00
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Add to the 2D features array */
if ( iPushFeature == 1 && nTmp !== null )
{
if ( typeof oSettings.aanFeatures[cOption] != 'object' )
{
oSettings.aanFeatures[cOption] = [];
}
oSettings.aanFeatures[cOption].push( nTmp );
nInsertNode.appendChild( nTmp );
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Built our DOM structure - replace the holding div with what we want */
nHolding.parentNode.replaceChild( oSettings.nTableWrapper, nHolding );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Use the DOM source to create up an array of header cells. The idea here is to
* create a layout grid (array) of rows x columns, which contains a reference
* to the cell that that point in the grid (regardless of col/rowspan), such that
* any column / row could be removed and the new grid constructed
* @param array {object} aLayout Array to store the calculated layout in
* @param {node} nThead The header/footer element for the table
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnDetectHeader ( aLayout, nThead )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var nTrs = $(nThead).children('tr');
var nCell;
var i, j, k, l, iLen, jLen, iColShifted;
var fnShiftCol = function ( a, i, j ) {
while ( typeof a[i][j] != 'undefined' ) {
j++;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return j;
};
aLayout.splice( 0, aLayout.length );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* We know how many rows there are in the layout - so prep it */
for ( i=0, iLen=nTrs.length ; i<iLen ; i++ )
New: Defered loading feature for server-side processing. With this feature enabled (controlled by the new initialisation parameter iDeferLoading) DataTables will not make a request to the server for the first page draw - rather it will use the data already on the page (no sorting etc will be applied to it). iDeferLoading is used to indicate that defered loading is required, but it is also used to tell DataTables how many records there are in the full table (allowing the information element and pagination to be displayed correctly). The intention of this feature is to improve the progressive enhancement foundation and accessibility of DataTables.
2011-03-06 15:54:54 +01:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
aLayout.push( [] );
New: Defered loading feature for server-side processing. With this feature enabled (controlled by the new initialisation parameter iDeferLoading) DataTables will not make a request to the server for the first page draw - rather it will use the data already on the page (no sorting etc will be applied to it). iDeferLoading is used to indicate that defered loading is required, but it is also used to tell DataTables how many records there are in the full table (allowing the information element and pagination to be displayed correctly). The intention of this feature is to improve the progressive enhancement foundation and accessibility of DataTables.
2011-03-06 15:54:54 +01:00
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Calculate a layout array */
for ( i=0, iLen=nTrs.length ; i<iLen ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var iColumn = 0;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* For every cell in the row... */
for ( j=0, jLen=nTrs[i].childNodes.length ; j<jLen ; j++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nCell = nTrs[i].childNodes[j];
if ( nCell.nodeName.toUpperCase() == "TD" ||
nCell.nodeName.toUpperCase() == "TH" )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Get the col and rowspan attributes from the DOM and sanitise them */
var iColspan = nCell.getAttribute('colspan') * 1;
var iRowspan = nCell.getAttribute('rowspan') * 1;
iColspan = (!iColspan || iColspan===0 || iColspan===1) ? 1 : iColspan;
iRowspan = (!iRowspan || iRowspan===0 || iRowspan===1) ? 1 : iRowspan;
/* There might be colspan cells already in this row, so shift our target
* accordingly
*/
iColShifted = fnShiftCol( aLayout, i, iColumn );
/* If there is col / rowspan, copy the information into the layout grid */
for ( l=0 ; l<iColspan ; l++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
for ( k=0 ; k<iRowspan ; k++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
aLayout[i+k][iColShifted+l] = {
"cell": nCell,
"unique": iColspan == 1 ? true : false
};
aLayout[i+k].nTr = nTrs[i];
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
}
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Get an array of unique th elements, one for each column
* @param {object} oSettings dataTables settings object
* @param {node} nHeader automatically detect the layout from this node - optional
* @param {array} aLayout thead/tfoot layout from _fnDetectHeader - optional
* @returns array {node} aReturn list of unique ths
* @private
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
function _fnGetUniqueThs ( oSettings, nHeader, aLayout )
{
var aReturn = [];
if ( typeof aLayout == 'undefined' )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
aLayout = oSettings.aoHeader;
if ( typeof nHeader != 'undefined' )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
aLayout = [];
_fnDetectHeader( aLayout, nHeader );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
for ( var i=0, iLen=aLayout.length ; i<iLen ; i++ )
{
for ( var j=0, jLen=aLayout[i].length ; j<jLen ; j++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( aLayout[i][j].unique &&
(typeof aReturn[j] == 'undefined' || !oSettings.bSortCellsTop) )
{
aReturn[j] = aLayout[i][j].cell;
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return aReturn;
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Generate the node required for filtering text
* @returns {node} Filter control element
* @param {object} oSettings dataTables settings object
* @private
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
function _fnFeatureHtmlFilter ( oSettings )
{
var sSearchStr = oSettings.oLanguage.sSearch;
sSearchStr = (sSearchStr.indexOf('_INPUT_') !== -1) ?
sSearchStr.replace('_INPUT_', '<input type="text" />') :
sSearchStr==="" ? '<input type="text" />' : sSearchStr+' <input type="text" />';
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var nFilter = document.createElement( 'div' );
nFilter.className = oSettings.oClasses.sFilter;
nFilter.innerHTML = '<label>'+sSearchStr+'</label>';
if ( oSettings.sTableId !== '' && typeof oSettings.aanFeatures.f == "undefined" )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nFilter.setAttribute( 'id', oSettings.sTableId+'_filter' );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var jqFilter = $("input", nFilter);
jqFilter.val( oSettings.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;
for ( var i=0, iLen=n.length ; i<iLen ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( n[i] != $(this).parents('div.dataTables_filter')[0] )
New: Infinite scrolling! Building on the scrolling feature set that was introduced with 1.7, you can now have DataTables do infinite scrolling (bScrollInfinite: true), where data is loaded dynamically as and when needed by the user's interaction with scrolling. Infinite scrolling can be used by all DataTables' supported data sources without modification. New: The distance from the end of the current scrolling container before new data is added (with infinite scrolling) can be controlled with iScrollLoadGap (which is a numeric value in pixels). New: Example (basic_init/scrolling_y_infinite.html) to show how infinite scrolling can be used. Fixed: iDraw was not being incremented for a draw that did not use server-side processing.
2010-09-05 11:21:26 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
$('input', n[i]).val( this.value );
New: Infinite scrolling! Building on the scrolling feature set that was introduced with 1.7, you can now have DataTables do infinite scrolling (bScrollInfinite: true), where data is loaded dynamically as and when needed by the user's interaction with scrolling. Infinite scrolling can be used by all DataTables' supported data sources without modification. New: The distance from the end of the current scrolling container before new data is added (with infinite scrolling) can be controlled with iScrollLoadGap (which is a numeric value in pixels). New: Example (basic_init/scrolling_y_infinite.html) to show how infinite scrolling can be used. Fixed: iDraw was not being incremented for a draw that did not use server-side processing.
2010-09-05 11:21:26 +02:00
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Now do the filter */
if ( this.value != oSettings.oPreviousSearch.sSearch )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
_fnFilterComplete( oSettings, {
"sSearch": this.value,
"bRegex": oSettings.oPreviousSearch.bRegex,
"bSmart": oSettings.oPreviousSearch.bSmart
} );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
} );
jqFilter.bind( 'keypress.DT', function(e) {
/* Prevent default */
if ( e.keyCode == 13 )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return false;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
} );
return nFilter;
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* 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)
* @private
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
function _fnFilterComplete ( oSettings, oInput, iForce )
{
/* Filter on everything */
_fnFilter( oSettings, oInput.sSearch, iForce, oInput.bRegex, oInput.bSmart );
/* Now do the individual column filter */
for ( var i=0 ; i<oSettings.aoPreSearchCols.length ; i++ )
{
_fnFilterColumn( oSettings, oSettings.aoPreSearchCols[i].sSearch, i,
oSettings.aoPreSearchCols[i].bRegex, oSettings.aoPreSearchCols[i].bSmart );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Custom filtering */
if ( _oExt.afnFiltering.length !== 0 )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
_fnFilterCustom( oSettings );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Tell the draw function we have been filtering */
oSettings.bFiltered = true;
$(oSettings.oInstance).trigger('filter', oSettings);
Fixed: fnInitComplete was not the last thing to be executed when using DOM source. IT was possible that you could set sAjaxSource in fnInitComplete which would then trigger DataTables to do an Ajax call incorrectly.
2010-12-15 22:23:24 +01:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Redraw the table */
oSettings._iDisplayStart = 0;
_fnCalculateEnd( oSettings );
_fnDraw( oSettings );
/* Rebuild search array 'offline' */
_fnBuildSearchArray( oSettings, 0 );
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Apply custom filtering functions
* @param {object} oSettings dataTables settings object
* @private
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
function _fnFilterCustom( oSettings )
{
var afnFilters = _oExt.afnFiltering;
for ( var i=0, iLen=afnFilters.length ; i<iLen ; i++ )
Fixed: Destroying a scrolling table was not correctly reassembling the table from it's component parts which are split up for scrolling.
2010-09-08 21:40:18 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var iCorrector = 0;
for ( var j=0, jLen=oSettings.aiDisplay.length ; j<jLen ; j++ )
Fixed: Destroying a scrolling table was not correctly reassembling the table from it's component parts which are split up for scrolling.
2010-09-08 21:40:18 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
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++;
}
Fixed: Destroying a scrolling table was not correctly reassembling the table from it's component parts which are split up for scrolling.
2010-09-08 21:40:18 +02:00
}
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* 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
* @private
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
function _fnFilterColumn ( oSettings, sInput, iColumn, bRegex, bSmart )
{
if ( sInput === "" )
{
return;
}
var iIndexCorrector = 0;
var rpSearch = _fnFilterCreateSearch( sInput, bRegex, bSmart );
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++;
}
}
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* 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
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnFilter( oSettings, sInput, iForce, bRegex, bSmart )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var i;
var rpSearch = _fnFilterCreateSearch( sInput, bRegex, bSmart );
/* Check if we are forcing or not - optional parameter */
if ( typeof iForce == 'undefined' || iForce === null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
iForce = 0;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Need to take account of custom filtering functions - always filter */
if ( _oExt.afnFiltering.length !== 0 )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
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();
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
else
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/*
* 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 ||
oSettings.oPreviousSearch.sSearch.length > sInput.length || iForce == 1 ||
sInput.indexOf(oSettings.oPreviousSearch.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++;
}
}
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
oSettings.oPreviousSearch.sSearch = sInput;
oSettings.oPreviousSearch.bRegex = bRegex;
oSettings.oPreviousSearch.bSmart = bSmart;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Create an array which can be quickly search through
* @param {object} oSettings dataTables settings object
* @param {int} iMaster use the master data array - optional
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnBuildSearchArray ( oSettings, iMaster )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( !oSettings.oFeatures.bServerSide )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Clear out the old data */
oSettings.asDataSearch.splice( 0, oSettings.asDataSearch.length );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var aArray = (typeof iMaster != 'undefined' && 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' ) );
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* 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
* @private
Start 1.8.2 development Updated: Split the Ajax parameter building into it's own function (_fnAjaxParameters) so it can be called through the oApi parameter. The intention is that external programs such as TableTools can build up the same parameter set as TableTools uses.
2011-06-27 18:23:43 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnBuildSearchRow( oSettings, aData )
Start 1.8.2 development Updated: Split the Ajax parameter building into it's own function (_fnAjaxParameters) so it can be called through the oApi parameter. The intention is that external programs such as TableTools can build up the same parameter set as TableTools uses.
2011-06-27 18:23:43 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var sSearch = '';
if ( typeof oSettings.__nTmpFilter == 'undefined' ) {
oSettings.__nTmpFilter = document.createElement('div');
Start 1.8.2 development Updated: Split the Ajax parameter building into it's own function (_fnAjaxParameters) so it can be called through the oApi parameter. The intention is that external programs such as TableTools can build up the same parameter set as TableTools uses.
2011-06-27 18:23:43 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var nTmp = oSettings.__nTmpFilter;
Start 1.8.2 development Updated: Split the Ajax parameter building into it's own function (_fnAjaxParameters) so it can be called through the oApi parameter. The intention is that external programs such as TableTools can build up the same parameter set as TableTools uses.
2011-06-27 18:23:43 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
for ( var j=0, jLen=oSettings.aoColumns.length ; j<jLen ; j++ )
Start 1.8.2 development Updated: Split the Ajax parameter building into it's own function (_fnAjaxParameters) so it can be called through the oApi parameter. The intention is that external programs such as TableTools can build up the same parameter set as TableTools uses.
2011-06-27 18:23:43 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.aoColumns[j].bSearchable )
Start 1.8.2 development Updated: Split the Ajax parameter building into it's own function (_fnAjaxParameters) so it can be called through the oApi parameter. The intention is that external programs such as TableTools can build up the same parameter set as TableTools uses.
2011-06-27 18:23:43 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var sData = aData[j];
sSearch += _fnDataToSearch( sData, oSettings.aoColumns[j].sType )+' ';
Start 1.8.2 development Updated: Split the Ajax parameter building into it's own function (_fnAjaxParameters) so it can be called through the oApi parameter. The intention is that external programs such as TableTools can build up the same parameter set as TableTools uses.
2011-06-27 18:23:43 +02:00
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* If it looks like there is an HTML entity in the string, attempt to decode it */
if ( sSearch.indexOf('&') !== -1 )
Start 1.8.2 development Updated: Split the Ajax parameter building into it's own function (_fnAjaxParameters) so it can be called through the oApi parameter. The intention is that external programs such as TableTools can build up the same parameter set as TableTools uses.
2011-06-27 18:23:43 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nTmp.innerHTML = sSearch;
sSearch = nTmp.textContent ? nTmp.textContent : nTmp.innerText;
Start 1.8.2 development Updated: Split the Ajax parameter building into it's own function (_fnAjaxParameters) so it can be called through the oApi parameter. The intention is that external programs such as TableTools can build up the same parameter set as TableTools uses.
2011-06-27 18:23:43 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* IE and Opera appear to put an newline where there is a <br> tag - remove it */
sSearch = sSearch.replace(/\n/g," ").replace(/\r/g,"");
Start 1.8.2 development Updated: Split the Ajax parameter building into it's own function (_fnAjaxParameters) so it can be called through the oApi parameter. The intention is that external programs such as TableTools can build up the same parameter set as TableTools uses.
2011-06-27 18:23:43 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return sSearch;
Start 1.8.2 development Updated: Split the Ajax parameter building into it's own function (_fnAjaxParameters) so it can be called through the oApi parameter. The intention is that external programs such as TableTools can build up the same parameter set as TableTools uses.
2011-06-27 18:23:43 +02:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* 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
* @returns {RegExp} constructed object
* @private
New: fnServerParams callback function - this allows additional parameters to be added to the XHR for server-side processing or Ajax sourced, client-side processed data, with ease. Previously it was required to override the fnServerData method just to add a couple of parameters, but the built in fnServerData method is quite comperhensive and you don't want to have to reproduce all of that unless you need to. Now you don't need to :-). fnServerParams is called on each request, so it is ideal for adding extra parameters such as search parameters which can be updated by users.
2011-09-02 17:01:56 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnFilterCreateSearch( sSearch, bRegex, bSmart )
New: fnServerParams callback function - this allows additional parameters to be added to the XHR for server-side processing or Ajax sourced, client-side processed data, with ease. Previously it was required to override the fnServerData method just to add a couple of parameters, but the built in fnServerData method is quite comperhensive and you don't want to have to reproduce all of that unless you need to. Now you don't need to :-). fnServerParams is called on each request, so it is ideal for adding extra parameters such as search parameters which can be updated by users.
2011-09-02 17:01:56 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var asSearch, sRegExpString;
if ( bSmart )
New: fnServerParams callback function - this allows additional parameters to be added to the XHR for server-side processing or Ajax sourced, client-side processed data, with ease. Previously it was required to override the fnServerData method just to add a couple of parameters, but the built in fnServerData method is quite comperhensive and you don't want to have to reproduce all of that unless you need to. Now you don't need to :-). fnServerParams is called on each request, so it is ideal for adding extra parameters such as search parameters which can be updated by users.
2011-09-02 17:01:56 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* 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, "i" );
}
else
{
sSearch = bRegex ? sSearch : _fnEscapeRegex( sSearch );
return new RegExp( sSearch, "i" );
New: fnServerParams callback function - this allows additional parameters to be added to the XHR for server-side processing or Ajax sourced, client-side processed data, with ease. Previously it was required to override the fnServerData method just to add a couple of parameters, but the built in fnServerData method is quite comperhensive and you don't want to have to reproduce all of that unless you need to. Now you don't need to :-). fnServerParams is called on each request, so it is ideal for adding extra parameters such as search parameters which can be updated by users.
2011-09-02 17:01:56 +02:00
}
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* 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
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnDataToSearch ( sData, sType )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( typeof _oExt.ofnSearch[sType] == "function" )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return _oExt.ofnSearch[sType]( sData );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
else if ( sType == "html" )
Fixed: When infinite scrolling, DataTables would clear it's internal cache of rows on every draw, when server-side processing was being used. This could result in fnGetNodes giving only a subset of the nodes which are visible, rather than the full set (which it now does).
2010-09-15 11:29:03 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return sData.replace(/[\r\n]/g," ").replace( /<.*?>/g, "" );
Fixed: When infinite scrolling, DataTables would clear it's internal cache of rows on every draw, when server-side processing was being used. This could result in fnGetNodes giving only a subset of the nodes which are visible, rather than the full set (which it now does).
2010-09-15 11:29:03 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
else if ( typeof sData == "string" )
{
return sData.replace(/[\r\n]/g," ");
}
else if ( sData === null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return '';
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return sData;
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* scape a string stuch that it can be used in a regular expression
* @param {string} sVal string to escape
* @returns {string} escaped string
* @private
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
function _fnEscapeRegex ( sVal )
{
var acEscape = [ '/', '.', '*', '+', '?', '|', '(', ')', '[', ']', '{', '}', '\\', '$', '^' ];
var reReplace = new RegExp( '(\\' + acEscape.join('|\\') + ')', 'g' );
return sVal.replace(reReplace, '\\$1');
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Generate the node required for the info display
* @param {object} oSettings dataTables settings object
* @returns {node} Information element
* @private
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
function _fnFeatureHtmlInfo ( oSettings )
{
var nInfo = document.createElement( 'div' );
nInfo.className = oSettings.oClasses.sInfo;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Actions that are to be taken once only for this feature */
if ( typeof oSettings.aanFeatures.i == "undefined" )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Add draw callback */
oSettings.aoDrawCallback.push( {
"fn": _fnUpdateInfo,
"sName": "information"
} );
/* Add id */
if ( oSettings.sTableId !== '' )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nInfo.setAttribute( 'id', oSettings.sTableId+'_info' );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return nInfo;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Update the information elements in the display
* @param {object} oSettings dataTables settings object
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnUpdateInfo ( oSettings )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Show information about the table */
if ( !oSettings.oFeatures.bInfo || oSettings.aanFeatures.i.length === 0 )
{
return;
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var
iStart = oSettings._iDisplayStart+1, iEnd = oSettings.fnDisplayEnd(),
iMax = oSettings.fnRecordsTotal(), iTotal = oSettings.fnRecordsDisplay(),
sStart = oSettings.fnFormatNumber( iStart ), sEnd = oSettings.fnFormatNumber( iEnd ),
sMax = oSettings.fnFormatNumber( iMax ), sTotal = oSettings.fnFormatNumber( iTotal ),
sOut;
/* When infinite scrolling, we are always starting at 1. _iDisplayStart is used only
* internally
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.oScroll.bInfinite )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
sStart = oSettings.fnFormatNumber( 1 );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.fnRecordsDisplay() === 0 &&
oSettings.fnRecordsDisplay() == oSettings.fnRecordsTotal() )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Empty record set */
sOut = oSettings.oLanguage.sInfoEmpty+ oSettings.oLanguage.sInfoPostFix;
}
else if ( oSettings.fnRecordsDisplay() === 0 )
{
/* Rmpty record set after filtering */
sOut = oSettings.oLanguage.sInfoEmpty +' '+
oSettings.oLanguage.sInfoFiltered.replace('_MAX_', sMax)+
oSettings.oLanguage.sInfoPostFix;
}
else if ( oSettings.fnRecordsDisplay() == oSettings.fnRecordsTotal() )
{
/* Normal record set */
sOut = oSettings.oLanguage.sInfo.
replace('_START_', sStart).
replace('_END_', sEnd).
replace('_TOTAL_', sTotal)+
oSettings.oLanguage.sInfoPostFix;
}
else
{
/* Record set after filtering */
sOut = oSettings.oLanguage.sInfo.
replace('_START_', sStart).
replace('_END_', sEnd).
replace('_TOTAL_', sTotal) +' '+
oSettings.oLanguage.sInfoFiltered.replace('_MAX_',
oSettings.fnFormatNumber(oSettings.fnRecordsTotal()))+
oSettings.oLanguage.sInfoPostFix;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.oLanguage.fnInfoCallback !== null )
{
sOut = oSettings.oLanguage.fnInfoCallback( 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 );
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Draw the table for the first time, adding all required features
* @param {object} oSettings dataTables settings object
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnInitialise ( oSettings )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var i, iLen, iAjaxStart=oSettings.iInitDisplayStart;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Ensure that the table data is fully initialised */
if ( oSettings.bInitialised === false )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
setTimeout( function(){ _fnInitialise( oSettings ); }, 200 );
return;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Show the display HTML options */
_fnAddOptionsHtml( oSettings );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Build and draw the header / footer for the table */
_fnBuildHead( oSettings );
_fnDrawHead( oSettings, oSettings.aoHeader );
if ( oSettings.nTFoot )
New: Add bScrollAutoCss option (default true). This allows you to control the scrolling styles with CSS, where as normally DataTables will set (and override) the styles itself. This is useful for if you want to have a scroll bar showing at all times (normally auto).
2010-11-04 19:17:34 +01:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
_fnDrawHead( oSettings, oSettings.aoFooter );
New: Add bScrollAutoCss option (default true). This allows you to control the scrolling styles with CSS, where as normally DataTables will set (and override) the styles itself. This is useful for if you want to have a scroll bar showing at all times (normally auto).
2010-11-04 19:17:34 +01:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Okay to show that something is going on now */
_fnProcessingDisplay( oSettings, true );
New: Add bScrollAutoCss option (default true). This allows you to control the scrolling styles with CSS, where as normally DataTables will set (and override) the styles itself. This is useful for if you want to have a scroll bar showing at all times (normally auto).
2010-11-04 19:17:34 +01:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Calculate sizes for columns */
if ( oSettings.oFeatures.bAutoWidth )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
_fnCalculateColumnWidths( oSettings );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.aoColumns[i].sWidth !== null )
{
oSettings.aoColumns[i].nTh.style.width = _fnStringToCss( oSettings.aoColumns[i].sWidth );
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* 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)
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.oFeatures.bSort )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
_fnSort( oSettings );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
else if ( oSettings.oFeatures.bFilter )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
_fnFilterComplete( oSettings, oSettings.oPreviousSearch );
}
else
{
oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
_fnCalculateEnd( oSettings );
_fnDraw( oSettings );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* if there is an ajax source load the data */
if ( oSettings.sAjaxSource !== null && !oSettings.oFeatures.bServerSide )
New: Infinite scrolling! Building on the scrolling feature set that was introduced with 1.7, you can now have DataTables do infinite scrolling (bScrollInfinite: true), where data is loaded dynamically as and when needed by the user's interaction with scrolling. Infinite scrolling can be used by all DataTables' supported data sources without modification. New: The distance from the end of the current scrolling container before new data is added (with infinite scrolling) can be controlled with iScrollLoadGap (which is a numeric value in pixels). New: Example (basic_init/scrolling_y_infinite.html) to show how infinite scrolling can be used. Fixed: iDraw was not being incremented for a draw that did not use server-side processing.
2010-09-05 11:21:26 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
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++ )
New: Infinite scrolling! Building on the scrolling feature set that was introduced with 1.7, you can now have DataTables do infinite scrolling (bScrollInfinite: true), where data is loaded dynamically as and when needed by the user's interaction with scrolling. Infinite scrolling can be used by all DataTables' supported data sources without modification. New: The distance from the end of the current scrolling container before new data is added (with infinite scrolling) can be controlled with iScrollLoadGap (which is a numeric value in pixels). New: Example (basic_init/scrolling_y_infinite.html) to show how infinite scrolling can be used. Fixed: iDraw was not being incremented for a draw that did not use server-side processing.
2010-09-05 11:21:26 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
_fnAddData( oSettings, aData[i] );
New: Infinite scrolling! Building on the scrolling feature set that was introduced with 1.7, you can now have DataTables do infinite scrolling (bScrollInfinite: true), where data is loaded dynamically as and when needed by the user's interaction with scrolling. Infinite scrolling can be used by all DataTables' supported data sources without modification. New: The distance from the end of the current scrolling container before new data is added (with infinite scrolling) can be controlled with iScrollLoadGap (which is a numeric value in pixels). New: Example (basic_init/scrolling_y_infinite.html) to show how infinite scrolling can be used. Fixed: iDraw was not being incremented for a draw that did not use server-side processing.
2010-09-05 11:21:26 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* 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;
New: Infinite scrolling! Building on the scrolling feature set that was introduced with 1.7, you can now have DataTables do infinite scrolling (bScrollInfinite: true), where data is loaded dynamically as and when needed by the user's interaction with scrolling. Infinite scrolling can be used by all DataTables' supported data sources without modification. New: The distance from the end of the current scrolling container before new data is added (with infinite scrolling) can be controlled with iScrollLoadGap (which is a numeric value in pixels). New: Example (basic_init/scrolling_y_infinite.html) to show how infinite scrolling can be used. Fixed: iDraw was not being incremented for a draw that did not use server-side processing.
2010-09-05 11:21:26 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Server-side processing initialisation complete is done at the end of _fnDraw */
if ( !oSettings.oFeatures.bServerSide )
{
_fnProcessingDisplay( oSettings, false );
_fnInitComplete( oSettings );
}
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Draw the table for the first time, adding all required features
* @param {object} oSettings dataTables settings object
* @private
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
function _fnInitComplete ( oSettings, json )
{
oSettings._bInitComplete = true;
if ( typeof oSettings.fnInitComplete == 'function' )
{
if ( typeof json != 'undefined' )
{
oSettings.fnInitComplete.call( oSettings.oInstance, oSettings, json );
}
else
{
oSettings.fnInitComplete.call( oSettings.oInstance, oSettings );
}
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Copy language variables from remote object to a local one
* @param {object} oSettings dataTables settings object
* @param {object} oLanguage Language information
* @param {bool} bInit init once complete
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnLanguageProcess( oSettings, oLanguage, bInit )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
oSettings.oLanguage = $.extend( true, oSettings.oLanguage, oLanguage );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Backwards compatibility - if there is no sEmptyTable given, then use the same as
* sZeroRecords - assuming that is given.
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( typeof oLanguage.sEmptyTable == 'undefined' &&
typeof oLanguage.sZeroRecords != 'undefined' )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
_fnMap( oSettings.oLanguage, oLanguage, 'sZeroRecords', 'sEmptyTable' );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Likewise with loading records */
if ( typeof oLanguage.sLoadingRecords == 'undefined' &&
typeof oLanguage.sZeroRecords != 'undefined' )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
_fnMap( oSettings.oLanguage, oLanguage, 'sZeroRecords', 'sLoadingRecords' );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( bInit )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
_fnInitialise( oSettings );
}
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Generate the node required for user display length changing
* @param {object} oSettings dataTables settings object
* @returns {node} Display length feature node
* @private
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
function _fnFeatureHtmlLength ( oSettings )
{
if ( oSettings.oScroll.bInfinite )
{
return null;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* This can be overruled by not using the _MENU_ var/macro in the language variable */
var sName = (oSettings.sTableId === "") ? "" : 'name="'+oSettings.sTableId+'_length"';
var sStdMenu = '<select size="1" '+sName+'>';
var i, iLen;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.aLengthMenu.length == 2 && typeof oSettings.aLengthMenu[0] == 'object' &&
typeof oSettings.aLengthMenu[1] == 'object' )
Fix: Row alignment with x-scrolling disabled and the table too small to draw fully. Previously DataTables would emit an error about the columns not aligning in this case, and then try its best to draw the table, but this would end up looking quite bad. The fix is to not allow the table to draw smaller than it can possibly be when x-scrolling is disabled. This effects dynamically resizable tables - 5232
2011-06-25 16:29:07 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
for ( i=0, iLen=oSettings.aLengthMenu[0].length ; i<iLen ; i++ )
{
sStdMenu += '<option value="'+oSettings.aLengthMenu[0][i]+'">'+
oSettings.aLengthMenu[1][i]+'</option>';
}
Fix: Row alignment with x-scrolling disabled and the table too small to draw fully. Previously DataTables would emit an error about the columns not aligning in this case, and then try its best to draw the table, but this would end up looking quite bad. The fix is to not allow the table to draw smaller than it can possibly be when x-scrolling is disabled. This effects dynamically resizable tables - 5232
2011-06-25 16:29:07 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
else
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
for ( i=0, iLen=oSettings.aLengthMenu.length ; i<iLen ; i++ )
{
sStdMenu += '<option value="'+oSettings.aLengthMenu[i]+'">'+
oSettings.aLengthMenu[i]+'</option>';
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
sStdMenu += '</select>';
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var nLength = document.createElement( 'div' );
if ( oSettings.sTableId !== '' && typeof oSettings.aanFeatures.l == "undefined" )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nLength.setAttribute( 'id', oSettings.sTableId+'_length' );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nLength.className = oSettings.oClasses.sLength;
nLength.innerHTML = '<label>'+oSettings.oLanguage.sLengthMenu.replace( '_MENU_', sStdMenu )+'</label>';
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/*
* Set the length to the current display length - thanks to Andrea Pavlovic for this fix,
* and Stefan Skopnik for fixing the fix!
*/
$('select option[value="'+oSettings._iDisplayLength+'"]',nLength).attr("selected",true);
$('select', nLength).bind( 'change.DT', function(e) {
var iVal = $(this).val();
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Update all other length options for the new display */
var n = oSettings.aanFeatures.l;
for ( i=0, iLen=n.length ; i<iLen ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( n[i] != this.parentNode )
{
$('select', n[i]).val( iVal );
}
}
/* Redraw the table */
oSettings._iDisplayLength = parseInt(iVal, 10);
_fnCalculateEnd( oSettings );
/* If we have space to show extra rows (backing up from the end point - then do so */
if ( oSettings.fnDisplayEnd() == oSettings.fnRecordsDisplay() )
{
oSettings._iDisplayStart = oSettings.fnDisplayEnd() - oSettings._iDisplayLength;
if ( oSettings._iDisplayStart < 0 )
{
oSettings._iDisplayStart = 0;
}
}
if ( oSettings._iDisplayLength == -1 )
{
oSettings._iDisplayStart = 0;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
_fnDraw( oSettings );
} );
return nLength;
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Rcalculate the end point based on the start point
* @param {object} oSettings dataTables settings object
* @private
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
function _fnCalculateEnd( oSettings )
{
if ( oSettings.oFeatures.bPaginate === false )
{
oSettings._iDisplayEnd = oSettings.aiDisplay.length;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
else
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Set the end point of the display - based on how many elements there are
* still to display
*/
if ( oSettings._iDisplayStart + oSettings._iDisplayLength > oSettings.aiDisplay.length ||
oSettings._iDisplayLength == -1 )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
oSettings._iDisplayEnd = oSettings.aiDisplay.length;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
else
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
oSettings._iDisplayEnd = oSettings._iDisplayStart + oSettings._iDisplayLength;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
* Note that most of the paging logic is done in
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
* _oExt.oPagination
*/
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Generate the node required for default pagination
* @param {object} oSettings dataTables settings object
* @returns {node} Pagination feature node
* @private
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
function _fnFeatureHtmlPaginate ( oSettings )
{
if ( oSettings.oScroll.bInfinite )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return null;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var nPaginate = document.createElement( 'div' );
nPaginate.className = oSettings.oClasses.sPaging+oSettings.sPaginationType;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
_oExt.oPagination[ oSettings.sPaginationType ].fnInit( oSettings, nPaginate,
function( oSettings ) {
_fnCalculateEnd( oSettings );
_fnDraw( oSettings );
}
);
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Add a draw callback for the pagination on first instance, to update the paging display */
if ( typeof oSettings.aanFeatures.p == "undefined" )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
oSettings.aoDrawCallback.push( {
"fn": function( oSettings ) {
_oExt.oPagination[ oSettings.sPaginationType ].fnUpdate( oSettings, function( oSettings ) {
_fnCalculateEnd( oSettings );
_fnDraw( oSettings );
} );
},
"sName": "pagination"
} );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return nPaginate;
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Alter the display settings to change the page
* @param {object} oSettings dataTables settings object
* @param {string} sAction paging action to take: "first", "previous", "next" or "last"
* @returns {bool} true page has changed, false - no change (no effect) eg 'first' on page 1
* @private
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
function _fnPageChange ( oSettings, sAction )
{
var iOldStart = oSettings._iDisplayStart;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( sAction == "first" )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
oSettings._iDisplayStart = 0;
}
else if ( sAction == "previous" )
{
oSettings._iDisplayStart = oSettings._iDisplayLength>=0 ?
oSettings._iDisplayStart - oSettings._iDisplayLength :
0;
Fix: Table width issues with y-scrolling enabled. Some of the caluclations which were introduced into 1.8.1 to stop the table getting smaller than it can be were wrong under certain conditions. This changes should address this but further testing is required due to the number of variations. Fix: IE6/7 when y-scrolling was filtered to a list without y-scrolling would lose the width of the scrollbar (i.e. not expand to fill the empty space). The IE6/7 specific calcuation needs to be done only when the element is overflowing.
2011-08-14 16:00:10 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Correct for underrun */
if ( oSettings._iDisplayStart < 0 )
Fix: Table width issues with y-scrolling enabled. Some of the caluclations which were introduced into 1.8.1 to stop the table getting smaller than it can be were wrong under certain conditions. This changes should address this but further testing is required due to the number of variations. Fix: IE6/7 when y-scrolling was filtered to a list without y-scrolling would lose the width of the scrollbar (i.e. not expand to fill the empty space). The IE6/7 specific calcuation needs to be done only when the element is overflowing.
2011-08-14 16:00:10 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
oSettings._iDisplayStart = 0;
Fix: Table width issues with y-scrolling enabled. Some of the caluclations which were introduced into 1.8.1 to stop the table getting smaller than it can be were wrong under certain conditions. This changes should address this but further testing is required due to the number of variations. Fix: IE6/7 when y-scrolling was filtered to a list without y-scrolling would lose the width of the scrollbar (i.e. not expand to fill the empty space). The IE6/7 specific calcuation needs to be done only when the element is overflowing.
2011-08-14 16:00:10 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
else if ( sAction == "next" )
{
if ( oSettings._iDisplayLength >= 0 )
Fix: Table width issues with y-scrolling enabled. Some of the caluclations which were introduced into 1.8.1 to stop the table getting smaller than it can be were wrong under certain conditions. This changes should address this but further testing is required due to the number of variations. Fix: IE6/7 when y-scrolling was filtered to a list without y-scrolling would lose the width of the scrollbar (i.e. not expand to fill the empty space). The IE6/7 specific calcuation needs to be done only when the element is overflowing.
2011-08-14 16:00:10 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Make sure we are not over running the display array */
if ( oSettings._iDisplayStart + oSettings._iDisplayLength < oSettings.fnRecordsDisplay() )
{
oSettings._iDisplayStart += oSettings._iDisplayLength;
}
Fix: Table width issues with y-scrolling enabled. Some of the caluclations which were introduced into 1.8.1 to stop the table getting smaller than it can be were wrong under certain conditions. This changes should address this but further testing is required due to the number of variations. Fix: IE6/7 when y-scrolling was filtered to a list without y-scrolling would lose the width of the scrollbar (i.e. not expand to fill the empty space). The IE6/7 specific calcuation needs to be done only when the element is overflowing.
2011-08-14 16:00:10 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
else
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
oSettings._iDisplayStart = 0;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
else if ( sAction == "last" )
{
if ( oSettings._iDisplayLength >= 0 )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var iPages = parseInt( (oSettings.fnRecordsDisplay()-1) / oSettings._iDisplayLength, 10 ) + 1;
oSettings._iDisplayStart = (iPages-1) * oSettings._iDisplayLength;
}
else
{
oSettings._iDisplayStart = 0;
Fix: Table width issues with y-scrolling enabled. Some of the caluclations which were introduced into 1.8.1 to stop the table getting smaller than it can be were wrong under certain conditions. This changes should address this but further testing is required due to the number of variations. Fix: IE6/7 when y-scrolling was filtered to a list without y-scrolling would lose the width of the scrollbar (i.e. not expand to fill the empty space). The IE6/7 specific calcuation needs to be done only when the element is overflowing.
2011-08-14 16:00:10 +02:00
}
}
else
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
_fnLog( oSettings, 0, "Unknown paging action: "+sAction );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
$(oSettings.oInstance).trigger('page', oSettings);
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return iOldStart != oSettings._iDisplayStart;
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Generate the node required for the processing node
* @param {object} oSettings dataTables settings object
* @returns {node} Processing element
* @private
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
function _fnFeatureHtmlProcessing ( oSettings )
{
var nProcessing = document.createElement( 'div' );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.sTableId !== '' && typeof oSettings.aanFeatures.r == "undefined" )
{
nProcessing.setAttribute( 'id', oSettings.sTableId+'_processing' );
}
nProcessing.innerHTML = oSettings.oLanguage.sProcessing;
nProcessing.className = oSettings.oClasses.sProcessing;
oSettings.nTable.parentNode.insertBefore( nProcessing, oSettings.nTable );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return nProcessing;
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Display or hide the processing indicator
* @param {object} oSettings dataTables settings object
* @param {bool} bShow Show the processing indicator (true) or not (false)
* @private
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
function _fnProcessingDisplay ( oSettings, bShow )
{
if ( oSettings.oFeatures.bProcessing )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var an = oSettings.aanFeatures.r;
for ( var i=0, iLen=an.length ; i<iLen ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
an[i].style.visibility = bShow ? "visible" : "hidden";
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Add any control elements for the table - specifically scrolling
* @param {object} oSettings dataTables settings object
* @returns {node} Node to add to the DOM
* @private
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
function _fnFeatureHtmlTable ( oSettings )
{
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/* Check if scrolling is enabled or not - if not then leave the DOM unaltered */
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.oScroll.sX === "" && oSettings.oScroll.sY === "" )
{
return oSettings.nTable;
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/*
* The HTML structure that we want to generate in this function is:
* div - nScroller
* div - nScrollHead
* div - nScrollHeadInner
* table - nScrollHeadTable
* thead - nThead
* div - nScrollBody
* table - oSettings.nTable
* thead - nTheadSize
* tbody - nTbody
* div - nScrollFoot
* div - nScrollFootInner
* table - nScrollFootTable
* tfoot - nTfoot
*/
var
nScroller = document.createElement('div'),
nScrollHead = document.createElement('div'),
nScrollHeadInner = document.createElement('div'),
nScrollBody = document.createElement('div'),
nScrollFoot = document.createElement('div'),
nScrollFootInner = document.createElement('div'),
nScrollHeadTable = oSettings.nTable.cloneNode(false),
nScrollFootTable = oSettings.nTable.cloneNode(false),
nThead = oSettings.nTable.getElementsByTagName('thead')[0],
nTfoot = oSettings.nTable.getElementsByTagName('tfoot').length === 0 ? null :
oSettings.nTable.getElementsByTagName('tfoot')[0],
oClasses = (typeof oInit.bJQueryUI != 'undefined' && oInit.bJQueryUI) ?
_oExt.oJUIClasses : _oExt.oStdClasses;
nScrollHead.appendChild( nScrollHeadInner );
nScrollFoot.appendChild( nScrollFootInner );
nScrollBody.appendChild( oSettings.nTable );
nScroller.appendChild( nScrollHead );
nScroller.appendChild( nScrollBody );
nScrollHeadInner.appendChild( nScrollHeadTable );
nScrollHeadTable.appendChild( nThead );
if ( nTfoot !== null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nScroller.appendChild( nScrollFoot );
nScrollFootInner.appendChild( nScrollFootTable );
nScrollFootTable.appendChild( nTfoot );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nScroller.className = oClasses.sScrollWrapper;
nScrollHead.className = oClasses.sScrollHead;
nScrollHeadInner.className = oClasses.sScrollHeadInner;
nScrollBody.className = oClasses.sScrollBody;
nScrollFoot.className = oClasses.sScrollFoot;
nScrollFootInner.className = oClasses.sScrollFootInner;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.oScroll.bAutoCss )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nScrollHead.style.overflow = "hidden";
nScrollHead.style.position = "relative";
nScrollFoot.style.overflow = "hidden";
nScrollBody.style.overflow = "auto";
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
New: Infinite scrolling! Building on the scrolling feature set that was introduced with 1.7, you can now have DataTables do infinite scrolling (bScrollInfinite: true), where data is loaded dynamically as and when needed by the user's interaction with scrolling. Infinite scrolling can be used by all DataTables' supported data sources without modification. New: The distance from the end of the current scrolling container before new data is added (with infinite scrolling) can be controlled with iScrollLoadGap (which is a numeric value in pixels). New: Example (basic_init/scrolling_y_infinite.html) to show how infinite scrolling can be used. Fixed: iDraw was not being incremented for a draw that did not use server-side processing.
2010-09-05 11:21:26 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nScrollHead.style.border = "0";
nScrollHead.style.width = "100%";
nScrollFoot.style.border = "0";
nScrollHeadInner.style.width = "150%"; /* will be overwritten */
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Modify attributes to respect the clones */
nScrollHeadTable.removeAttribute('id');
nScrollHeadTable.style.marginLeft = "0";
oSettings.nTable.style.marginLeft = "0";
if ( nTfoot !== null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nScrollFootTable.removeAttribute('id');
nScrollFootTable.style.marginLeft = "0";
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
New: Accessability features - the length changing control and filtering control are now wrapped in <label> tags (an explicit relationship to their input elements) to aid accessability. You can see this immediately by simply clicking on the "Search:" text now - it will focus the input of the text box, while for screen readers it will give the label text from the label. New: The filtering input language string (oLanguage.sSearch) now has the "macro" _INPUT_ in it to allow the input element to be positioned anywhere in the string. For example if you gave "sSearch": "Data_INPUT_Tables" the output for the filter would be "Data<input.../>Tables". This is optional - if _INPUT_ is not given, then as before will will tack the input element on to the end of the given (or default) text string.
2011-06-21 22:48:28 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Move any caption elements from the body to the header */
var nCaptions = $(oSettings.nTable).children('caption');
for ( var i=0, iLen=nCaptions.length ; i<iLen ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nScrollHeadTable.appendChild( nCaptions[i] );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/*
* Sizing
*/
/* When xscrolling add the width and a scroller to move the header with the body */
if ( oSettings.oScroll.sX !== "" )
{
nScrollHead.style.width = _fnStringToCss( oSettings.oScroll.sX );
nScrollBody.style.width = _fnStringToCss( oSettings.oScroll.sX );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( nTfoot !== null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nScrollFoot.style.width = _fnStringToCss( oSettings.oScroll.sX );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* When the body is scrolled, then we also want to scroll the headers */
$(nScrollBody).scroll( function (e) {
nScrollHead.scrollLeft = this.scrollLeft;
if ( nTfoot !== null )
{
nScrollFoot.scrollLeft = this.scrollLeft;
}
} );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* When yscrolling, add the height */
if ( oSettings.oScroll.sY !== "" )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nScrollBody.style.height = _fnStringToCss( oSettings.oScroll.sY );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Redraw - align columns across the tables */
oSettings.aoDrawCallback.push( {
"fn": _fnScrollDraw,
"sName": "scrolling"
} );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Infinite scrolling event handlers */
if ( oSettings.oScroll.bInfinite )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
$(nScrollBody).scroll( function() {
/* Use a blocker to stop scrolling from loading more data while other data is still loading */
if ( !oSettings.bDrawing )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Check if we should load the next data set */
if ( $(this).scrollTop() + $(this).height() >
$(oSettings.nTable).height() - oSettings.oScroll.iLoadGap )
{
/* Only do the redraw if we have to - we might be at the end of the data */
if ( oSettings.fnDisplayEnd() < oSettings.fnRecordsDisplay() )
{
_fnPageChange( oSettings, 'next' );
_fnCalculateEnd( oSettings );
_fnDraw( oSettings );
}
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
} );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
oSettings.nScrollHead = nScrollHead;
oSettings.nScrollFoot = nScrollFoot;
return nScroller;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Update the various tables for resizing. It's a bit of a pig this function, but
* basically the idea to:
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
* 1. Re-create the table inside the scrolling div
* 2. Take live measurements from the DOM
* 3. Apply the measurements
* 4. Clean up
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
* @param {object} o dataTables settings object
* @returns {node} Node to add to the DOM
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnScrollDraw ( o )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var
nScrollHeadInner = o.nScrollHead.getElementsByTagName('div')[0],
nScrollHeadTable = nScrollHeadInner.getElementsByTagName('table')[0],
nScrollBody = o.nTable.parentNode,
i, iLen, j, jLen, anHeadToSize, anHeadSizers, anFootSizers, anFootToSize, oStyle, iVis,
iWidth, aApplied=[], iSanityWidth,
nScrollFootInner = (o.nTFoot !== null) ? o.nScrollFoot.getElementsByTagName('div')[0] : null,
nScrollFootTable = (o.nTFoot !== null) ? nScrollFootInner.getElementsByTagName('table')[0] : null,
ie67 = $.browser.msie && $.browser.version <= 7;
/*
* 1. Re-create the table inside the scrolling div
*/
/* Remove the old minimised thead and tfoot elements in the inner table */
var nTheadSize = o.nTable.getElementsByTagName('thead');
if ( nTheadSize.length > 0 )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
o.nTable.removeChild( nTheadSize[0] );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( o.nTFoot !== null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Remove the old minimised footer element in the cloned header */
var nTfootSize = o.nTable.getElementsByTagName('tfoot');
if ( nTfootSize.length > 0 )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
o.nTable.removeChild( nTfootSize[0] );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Clone the current header and footer elements and then place it into the inner table */
nTheadSize = o.nTHead.cloneNode(true);
o.nTable.insertBefore( nTheadSize, o.nTable.childNodes[0] );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( o.nTFoot !== null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nTfootSize = o.nTFoot.cloneNode(true);
o.nTable.insertBefore( nTfootSize, o.nTable.childNodes[1] );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
/*
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
* 2. Take live measurements from the DOM - do not alter the DOM itself!
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Remove old sizing and apply the calculated column widths
* Get the unique column headers in the newly created (cloned) header. We want to apply the
* calclated sizes to this header
*/
if ( o.oScroll.sX === "" )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nScrollBody.style.width = '100%';
nScrollHeadInner.parentNode.style.width = '100%';
}
var nThs = _fnGetUniqueThs( o, nTheadSize );
for ( i=0, iLen=nThs.length ; i<iLen ; i++ )
{
iVis = _fnVisibleToColumnIndex( o, i );
nThs[i].style.width = o.aoColumns[iVis].sWidth;
}
if ( o.nTFoot !== null )
{
_fnApplyToChildren( function(n) {
n.style.width = "";
}, nTfootSize.getElementsByTagName('tr') );
}
/* Size the table as a whole */
iSanityWidth = $(o.nTable).outerWidth();
if ( o.oScroll.sX === "" )
{
/* No x scrolling */
o.nTable.style.width = "100%";
/* I know this is rubbish - but IE7 will make the width of the table when 100% include
* the scrollbar - which is shouldn't. When there is a scrollbar we need to take this
* into account.
*/
if ( ie67 && (nScrollBody.scrollHeight >
nScrollBody.offsetHeight || $(nScrollBody).css('overflow-y') == "scroll") )
{
o.nTable.style.width = _fnStringToCss( $(o.nTable).outerWidth()-o.oScroll.iBarWidth );
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
else
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( o.oScroll.sXInner !== "" )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* x scroll inner has been given - use it */
o.nTable.style.width = _fnStringToCss(o.oScroll.sXInner);
}
else if ( iSanityWidth == $(nScrollBody).width() &&
$(nScrollBody).height() < $(o.nTable).height() )
{
/* There is y-scrolling - try to take account of the y scroll bar */
o.nTable.style.width = _fnStringToCss( iSanityWidth-o.oScroll.iBarWidth );
if ( $(o.nTable).outerWidth() > iSanityWidth-o.oScroll.iBarWidth )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Not possible to take account of it */
o.nTable.style.width = _fnStringToCss( iSanityWidth );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
else
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* All else fails */
o.nTable.style.width = _fnStringToCss( iSanityWidth );
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Recalculate the sanity width - now that we've applied the required width, before it was
* a temporary variable. This is required because the column width calculation is done
* before this table DOM is created.
*/
iSanityWidth = $(o.nTable).outerWidth();
/* We want the hidden header to have zero height, so remove padding and borders. Then
* set the width based on the real headers
*/
anHeadToSize = o.nTHead.getElementsByTagName('tr');
anHeadSizers = nTheadSize.getElementsByTagName('tr');
_fnApplyToChildren( function(nSizer, nToSize) {
oStyle = nSizer.style;
oStyle.paddingTop = "0";
oStyle.paddingBottom = "0";
oStyle.borderTopWidth = "0";
oStyle.borderBottomWidth = "0";
oStyle.height = 0;
iWidth = $(nSizer).width();
nToSize.style.width = _fnStringToCss( iWidth );
aApplied.push( iWidth );
}, anHeadSizers, anHeadToSize );
$(anHeadSizers).height(0);
if ( o.nTFoot !== null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Clone the current footer and then place it into the body table as a "hidden header" */
anFootSizers = nTfootSize.getElementsByTagName('tr');
anFootToSize = o.nTFoot.getElementsByTagName('tr');
Fix: Don't rebuild the client-side search array when using server-side processing since it isn't used! - 5742
2011-08-13 13:40:08 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
_fnApplyToChildren( function(nSizer, nToSize) {
oStyle = nSizer.style;
oStyle.paddingTop = "0";
oStyle.paddingBottom = "0";
oStyle.borderTopWidth = "0";
oStyle.borderBottomWidth = "0";
oStyle.height = 0;
iWidth = $(nSizer).width();
nToSize.style.width = _fnStringToCss( iWidth );
aApplied.push( iWidth );
}, anFootSizers, anFootToSize );
$(anFootSizers).height(0);
}
/*
* 3. Apply the measurements
*/
/* "Hide" the header and footer that we used for the sizing. We want to also fix their width
* to what they currently are
*/
_fnApplyToChildren( function(nSizer) {
nSizer.innerHTML = "";
nSizer.style.width = _fnStringToCss( aApplied.shift() );
}, anHeadSizers );
if ( o.nTFoot !== null )
{
_fnApplyToChildren( function(nSizer) {
nSizer.innerHTML = "";
nSizer.style.width = _fnStringToCss( aApplied.shift() );
}, anFootSizers );
}
/* Sanity check that the table is of a sensible width. If not then we are going to get
* misalignment - try to prevent this by not allowing the table to shrink below its min width
*/
if ( $(o.nTable).outerWidth() < iSanityWidth )
{
/* The min width depends upon if we have a vertical scrollbar visible or not */
var iCorrection = ((nScrollBody.scrollHeight > nScrollBody.offsetHeight ||
$(nScrollBody).css('overflow-y') == "scroll")) ?
iSanityWidth+o.oScroll.iBarWidth : iSanityWidth;
/* IE6/7 are a law unto themselves... */
if ( ie67 && (nScrollBody.scrollHeight >
nScrollBody.offsetHeight || $(nScrollBody).css('overflow-y') == "scroll") )
{
o.nTable.style.width = _fnStringToCss( iCorrection-o.oScroll.iBarWidth );
}
/* Apply the calculated minimum width to the table wrappers */
nScrollBody.style.width = _fnStringToCss( iCorrection );
nScrollHeadInner.parentNode.style.width = _fnStringToCss( iCorrection );
if ( o.nTFoot !== null )
{
nScrollFootInner.parentNode.style.width = _fnStringToCss( iCorrection );
}
Fix: Don't rebuild the client-side search array when using server-side processing since it isn't used! - 5742
2011-08-13 13:40:08 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* And give the user a warning that we've stopped the table getting too small */
if ( o.oScroll.sX === "" )
Fix: Don't rebuild the client-side search array when using server-side processing since it isn't used! - 5742
2011-08-13 13:40:08 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
_fnLog( o, 1, "The table cannot fit into the current element which will cause column"+
" misalignment. The table has been drawn at its minimum possible width." );
}
else if ( o.oScroll.sXInner !== "" )
{
_fnLog( o, 1, "The table cannot fit into the current element which will cause column"+
" misalignment. Increase the sScrollXInner value or remove it to allow automatic"+
" calculation" );
Fix: Don't rebuild the client-side search array when using server-side processing since it isn't used! - 5742
2011-08-13 13:40:08 +02:00
}
Updated: Optimisation on fnDeleteRow to simply remove the search array entry, rather than rebuilding the whole array, also on fnUpdate to only rebuild the single row, rather than the entire thing, and finally fnAddData - allow the redraw to update the search array.
2010-10-16 11:06:49 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
else
{
nScrollBody.style.width = _fnStringToCss( '100%' );
nScrollHeadInner.parentNode.style.width = _fnStringToCss( '100%' );
if ( o.nTFoot !== null )
{
nScrollFootInner.parentNode.style.width = _fnStringToCss( '100%' );
}
Fix: Allow non string and numeric data types in the data source (including null and boolean etc). Add suitable unit tests to sanity check this.
2011-05-04 20:21:41 +02:00
}
Updated: Optimisation on fnDeleteRow to simply remove the search array entry, rather than rebuilding the whole array, also on fnUpdate to only rebuild the single row, rather than the entire thing, and finally fnAddData - allow the redraw to update the search array.
2010-10-16 11:06:49 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/*
* 4. Clean up
*/
if ( o.oScroll.sY === "" )
Updated: Optimisation on fnDeleteRow to simply remove the search array entry, rather than rebuilding the whole array, also on fnUpdate to only rebuild the single row, rather than the entire thing, and finally fnAddData - allow the redraw to update the search array.
2010-10-16 11:06:49 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* IE7< puts a vertical scrollbar in place (when it shouldn't be) due to subtracting
* the scrollbar height from the visible display, rather than adding it on. We need to
* set the height in order to sort this. Don't want to do it in any other browsers.
*/
if ( ie67 )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nScrollBody.style.height = _fnStringToCss( o.nTable.offsetHeight+o.oScroll.iBarWidth );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Updated: Optimisation on fnDeleteRow to simply remove the search array entry, rather than rebuilding the whole array, also on fnUpdate to only rebuild the single row, rather than the entire thing, and finally fnAddData - allow the redraw to update the search array.
2010-10-16 11:06:49 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( o.oScroll.sY !== "" && o.oScroll.bCollapse )
Updated: Optimisation on fnDeleteRow to simply remove the search array entry, rather than rebuilding the whole array, also on fnUpdate to only rebuild the single row, rather than the entire thing, and finally fnAddData - allow the redraw to update the search array.
2010-10-16 11:06:49 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nScrollBody.style.height = _fnStringToCss( o.oScroll.sY );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var iExtra = (o.oScroll.sX !== "" && o.nTable.offsetWidth > nScrollBody.offsetWidth) ?
o.oScroll.iBarWidth : 0;
if ( o.nTable.offsetHeight < nScrollBody.offsetHeight )
{
nScrollBody.style.height = _fnStringToCss( $(o.nTable).height()+iExtra );
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Updated: Optimisation on fnDeleteRow to simply remove the search array entry, rather than rebuilding the whole array, also on fnUpdate to only rebuild the single row, rather than the entire thing, and finally fnAddData - allow the redraw to update the search array.
2010-10-16 11:06:49 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Finally set the width's of the header and footer tables */
var iOuterWidth = $(o.nTable).outerWidth();
nScrollHeadTable.style.width = _fnStringToCss( iOuterWidth );
nScrollHeadInner.style.width = _fnStringToCss( iOuterWidth+o.oScroll.iBarWidth );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( o.nTFoot !== null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nScrollFootInner.style.width = _fnStringToCss( o.nTable.offsetWidth+o.oScroll.iBarWidth );
nScrollFootTable.style.width = _fnStringToCss( o.nTable.offsetWidth );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/* If sorting or filtering has occurred, jump the scrolling back to the top */
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( o.bSorted || o.bFiltered )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nScrollBody.scrollTop = 0;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Apply a given function to the display child nodes of an element array (typically
* TD children of TR rows
* @param {function} fn Method to apply to the objects
* @param array {nodes} an1 List of elements to look through for display children
* @param array {nodes} an2 Another list (identical structure to the first) - optional
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnApplyToChildren( fn, an1, an2 )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
for ( var i=0, iLen=an1.length ; i<iLen ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
for ( var j=0, jLen=an1[i].childNodes.length ; j<jLen ; j++ )
{
if ( an1[i].childNodes[j].nodeType == 1 )
{
if ( typeof an2 != 'undefined' )
{
fn( an1[i].childNodes[j], an2[i].childNodes[j] );
}
else
{
fn( an1[i].childNodes[j] );
}
}
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Convert a CSS unit width to pixels (e.g. 2em)
* @param {string} sWidth width to be converted
* @param {node} nParent parent to get the with for (required for relative widths) - optional
* @returns {int} iWidth width in pixels
* @private
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
function _fnConvertToWidth ( sWidth, nParent )
{
if ( !sWidth || sWidth === null || sWidth === '' )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return 0;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( typeof nParent == "undefined" )
Fix: Allow non string and numeric data types in the data source (including null and boolean etc). Add suitable unit tests to sanity check this.
2011-05-04 20:21:41 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nParent = document.getElementsByTagName('body')[0];
Fix: Allow non string and numeric data types in the data source (including null and boolean etc). Add suitable unit tests to sanity check this.
2011-05-04 20:21:41 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var iWidth;
var nTmp = document.createElement( "div" );
nTmp.style.width = _fnStringToCss( sWidth );
nParent.appendChild( nTmp );
iWidth = nTmp.offsetWidth;
nParent.removeChild( nTmp );
return ( iWidth );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Calculate the width of columns for the table
* @param {object} oSettings dataTables settings object
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnCalculateColumnWidths ( oSettings )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var iTableWidth = oSettings.nTable.offsetWidth;
var iUserInputs = 0;
var iTmpWidth;
var iVisibleColumns = 0;
var iColums = oSettings.aoColumns.length;
var i, iIndex, iCorrector, iWidth;
var oHeaders = $('th', oSettings.nTHead);
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Convert any user input sizes into pixel sizes */
for ( i=0 ; i<iColums ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.aoColumns[i].bVisible )
{
iVisibleColumns++;
if ( oSettings.aoColumns[i].sWidth !== null )
{
iTmpWidth = _fnConvertToWidth( oSettings.aoColumns[i].sWidthOrig,
oSettings.nTable.parentNode );
if ( iTmpWidth !== null )
{
oSettings.aoColumns[i].sWidth = _fnStringToCss( iTmpWidth );
}
iUserInputs++;
}
}
}
/* If the number of columns in the DOM equals the number that we have to process in
* DataTables, then we can use the offsets that are created by the web-browser. No custom
* sizes can be set in order for this to happen, nor scrolling used
*/
if ( iColums == oHeaders.length && iUserInputs === 0 && iVisibleColumns == iColums &&
oSettings.oScroll.sX === "" && oSettings.oScroll.sY === "" )
{
for ( i=0 ; i<oSettings.aoColumns.length ; i++ )
{
iTmpWidth = $(oHeaders[i]).width();
if ( iTmpWidth !== null )
{
oSettings.aoColumns[i].sWidth = _fnStringToCss( iTmpWidth );
}
}
}
else
{
/* Otherwise we are going to have to do some calculations to get the width of each column.
* Construct a 1 row table with the widest node in the data, and any user defined widths,
* then insert it into the DOM and allow the browser to do all the hard work of
* calculating table widths.
*/
var
nCalcTmp = oSettings.nTable.cloneNode( false ),
nTheadClone = oSettings.nTHead.cloneNode(true),
nBody = document.createElement( 'tbody' ),
nTr = document.createElement( 'tr' ),
nDivSizing;
nCalcTmp.removeAttribute( "id" );
nCalcTmp.appendChild( nTheadClone );
if ( oSettings.nTFoot !== null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nCalcTmp.appendChild( oSettings.nTFoot.cloneNode(true) );
_fnApplyToChildren( function(n) {
n.style.width = "";
}, nCalcTmp.getElementsByTagName('tr') );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nCalcTmp.appendChild( nBody );
nBody.appendChild( nTr );
/* Remove any sizing that was previously applied by the styles */
var jqColSizing = $('thead th', nCalcTmp);
if ( jqColSizing.length === 0 )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
jqColSizing = $('tbody tr:eq(0)>td', nCalcTmp);
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Apply custom sizing to the cloned header */
var nThs = _fnGetUniqueThs( oSettings, nTheadClone );
iCorrector = 0;
for ( i=0 ; i<iColums ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var oColumn = oSettings.aoColumns[i];
if ( oColumn.bVisible && oColumn.sWidthOrig !== null && oColumn.sWidthOrig !== "" )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nThs[i-iCorrector].style.width = _fnStringToCss( oColumn.sWidthOrig );
}
else if ( oColumn.bVisible )
{
nThs[i-iCorrector].style.width = "";
}
else
{
iCorrector++;
}
}
/* Find the biggest td for each column and put it into the table */
for ( i=0 ; i<iColums ; i++ )
{
if ( oSettings.aoColumns[i].bVisible )
{
var nTd = _fnGetWidestNode( oSettings, i );
if ( nTd !== null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nTd = nTd.cloneNode(true);
if ( oSettings.aoColumns[i].sContentPadding !== "" )
{
nTd.innerHTML += oSettings.aoColumns[i].sContentPadding;
}
nTr.appendChild( nTd );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Build the table and 'display' it */
var nWrapper = oSettings.nTable.parentNode;
nWrapper.appendChild( nCalcTmp );
/* When scrolling (X or Y) we want to set the width of the table as appropriate. However,
* when not scrolling leave the table width as it is. This results in slightly different,
* but I think correct behaviour
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.oScroll.sX !== "" && oSettings.oScroll.sXInner !== "" )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nCalcTmp.style.width = _fnStringToCss(oSettings.oScroll.sXInner);
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
else if ( oSettings.oScroll.sX !== "" )
New: Optimisation for sorting - when the sorting runs it will execute the sorting function a lot, particularly for large tables, so we want these functions to be as fast as possible. As it stood, each time the function ran it would prep the data and then do the required comparison - and it would do that data prep every time. This is pointless since toLowerCase (for example) is always going to give the same result when using the same input - so now introduced a third sorting function type (in addition to 'asc' and 'desc') called 'pre', which will pre-format the data to be sorted, only once for each item to be sorted, allowing the sorting comparison function itself to be really fast (simply just the comparison). This is also backwards compatible, if the sorting type doesn't have a 'pre'-formatting method then it will just use the two sorting functions as normal.
2011-11-19 10:53:11 +01:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nCalcTmp.style.width = "";
if ( $(nCalcTmp).width() < nWrapper.offsetWidth )
New: Optimisation for sorting - when the sorting runs it will execute the sorting function a lot, particularly for large tables, so we want these functions to be as fast as possible. As it stood, each time the function ran it would prep the data and then do the required comparison - and it would do that data prep every time. This is pointless since toLowerCase (for example) is always going to give the same result when using the same input - so now introduced a third sorting function type (in addition to 'asc' and 'desc') called 'pre', which will pre-format the data to be sorted, only once for each item to be sorted, allowing the sorting comparison function itself to be really fast (simply just the comparison). This is also backwards compatible, if the sorting type doesn't have a 'pre'-formatting method then it will just use the two sorting functions as normal.
2011-11-19 10:53:11 +01:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nCalcTmp.style.width = _fnStringToCss( nWrapper.offsetWidth );
New: Optimisation for sorting - when the sorting runs it will execute the sorting function a lot, particularly for large tables, so we want these functions to be as fast as possible. As it stood, each time the function ran it would prep the data and then do the required comparison - and it would do that data prep every time. This is pointless since toLowerCase (for example) is always going to give the same result when using the same input - so now introduced a third sorting function type (in addition to 'asc' and 'desc') called 'pre', which will pre-format the data to be sorted, only once for each item to be sorted, allowing the sorting comparison function itself to be really fast (simply just the comparison). This is also backwards compatible, if the sorting type doesn't have a 'pre'-formatting method then it will just use the two sorting functions as normal.
2011-11-19 10:53:11 +01:00
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
else if ( oSettings.oScroll.sY !== "" )
{
nCalcTmp.style.width = _fnStringToCss( nWrapper.offsetWidth );
}
nCalcTmp.style.visibility = "hidden";
Performance: Re-written the sorting implementation so it doesn't use either eval() of $.inArray(). inArray was found to have a serious negative effect on IE which counts operations to give the 'script is running slow' error message - the new implemention uses a value / key reverse mapping to make the look up as fast as a single object parameter retreival. Furthermore, I've done some optimisation and feature completeness work on the non-eval version of the sorting (previously the AIR sorting method) and I've found this to be at least as good (faster in some cases) than the old eval() sort, so this is now the default and only sorting method DataTables provides - 2922
2010-11-28 15:42:38 +01:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Scrolling considerations */
_fnScrollingWidthAdjust( oSettings, nCalcTmp );
/* Read the width's calculated by the browser and store them for use by the caller. We
* first of all try to use the elements in the body, but it is possible that there are
* no elements there, under which circumstances we use the header elements
Performance: Re-written the sorting implementation so it doesn't use either eval() of $.inArray(). inArray was found to have a serious negative effect on IE which counts operations to give the 'script is running slow' error message - the new implemention uses a value / key reverse mapping to make the look up as fast as a single object parameter retreival. Furthermore, I've done some optimisation and feature completeness work on the non-eval version of the sorting (previously the AIR sorting method) and I've found this to be at least as good (faster in some cases) than the old eval() sort, so this is now the default and only sorting method DataTables provides - 2922
2010-11-28 15:42:38 +01:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var oNodes = $("tbody tr:eq(0)", nCalcTmp).children();
if ( oNodes.length === 0 )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
oNodes = _fnGetUniqueThs( oSettings, $('thead', nCalcTmp)[0] );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Browsers need a bit of a hand when a width is assigned to any columns when
* x-scrolling as they tend to collapse the table to the min-width, even if
* we sent the column widths. So we need to keep track of what the table width
* should be by summing the user given values, and the automatic values
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.oScroll.sX !== "" )
{
var iTotal = 0;
iCorrector = 0;
for ( i=0 ; i<oSettings.aoColumns.length ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.aoColumns[i].bVisible )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.aoColumns[i].sWidthOrig === null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
iTotal += $(oNodes[iCorrector]).outerWidth();
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
else
{
iTotal += parseInt(oSettings.aoColumns[i].sWidth.replace('px',''), 10) +
($(oNodes[iCorrector]).outerWidth() - $(oNodes[iCorrector]).width());
}
iCorrector++;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nCalcTmp.style.width = _fnStringToCss( iTotal );
oSettings.nTable.style.width = _fnStringToCss( iTotal );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
iCorrector = 0;
for ( i=0 ; i<oSettings.aoColumns.length ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.aoColumns[i].bVisible )
{
iWidth = $(oNodes[iCorrector]).width();
if ( iWidth !== null && iWidth > 0 )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
oSettings.aoColumns[i].sWidth = _fnStringToCss( iWidth );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
iCorrector++;
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var cssWidth = $(nCalcTmp).css('width');
oSettings.nTable.style.width = (cssWidth.indexOf('%') !== -1) ?
cssWidth : _fnStringToCss( $(nCalcTmp).outerWidth() );
nCalcTmp.parentNode.removeChild( nCalcTmp );
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Adjust a table's width to take account of scrolling
* @param {object} oSettings dataTables settings object
* @param {node} n table node
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnScrollingWidthAdjust ( oSettings, n )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.oScroll.sX === "" && oSettings.oScroll.sY !== "" )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* When y-scrolling only, we want to remove the width of the scroll bar so the table
* + scroll bar will fit into the area avaialble.
*/
var iOrigWidth = $(n).width();
n.style.width = _fnStringToCss( $(n).outerWidth()-oSettings.oScroll.iBarWidth );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
else if ( oSettings.oScroll.sX !== "" )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* When x-scrolling both ways, fix the table at it's current size, without adjusting */
n.style.width = _fnStringToCss( $(n).outerWidth() );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Get the widest node
* @param {object} oSettings dataTables settings object
* @param {int} iCol column of interest
* @returns {string} max strlens for each column
* @private
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
function _fnGetWidestNode( oSettings, iCol )
{
var iMaxIndex = _fnGetMaxLenString( oSettings, iCol );
if ( iMaxIndex < 0 )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return null;
}
if ( oSettings.aoData[iMaxIndex].nTr === null )
{
var n = document.createElement('td');
n.innerHTML = _fnGetCellData( oSettings, iMaxIndex, iCol, '' );
return n;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return _fnGetTdNodes(oSettings, iMaxIndex)[iCol];
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Get the maximum strlen for each data column
* @param {object} oSettings dataTables settings object
* @param {int} iCol column of interest
* @returns {string} max strlens for each column
* @private
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
function _fnGetMaxLenString( oSettings, iCol )
{
var iMax = -1;
var iMaxIndex = -1;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
for ( var i=0 ; i<oSettings.aoData.length ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var s = _fnGetCellData( oSettings, i, iCol, 'display' )+"";
s = s.replace( /<.*?>/g, "" );
if ( s.length > iMax )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
iMax = s.length;
iMaxIndex = i;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return iMaxIndex;
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Append a CSS unit (only if required) to a string
* @param {array} aArray1 first array
* @param {array} aArray2 second array
* @returns {int} 0 if match, 1 if length is different, 2 if no match
* @private
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
function _fnStringToCss( s )
{
if ( s === null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return "0px";
}
if ( typeof s == 'number' )
{
if ( s < 0 )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return "0px";
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return s+"px";
}
/* Check if the last character is not 0-9 */
var c = s.charCodeAt( s.length-1 );
if (c < 0x30 || c > 0x39)
{
return s;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return s+"px";
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Get the width of a scroll bar in this browser being used
* @returns {int} width in pixels
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnScrollBarWidth ()
{
var inner = document.createElement('p');
var style = inner.style;
style.width = "100%";
style.height = "200px";
style.padding = "0px";
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var outer = document.createElement('div');
style = outer.style;
style.position = "absolute";
style.top = "0px";
style.left = "0px";
style.visibility = "hidden";
style.width = "200px";
style.height = "150px";
style.padding = "0px";
style.overflow = "hidden";
outer.appendChild(inner);
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
document.body.appendChild(outer);
var w1 = inner.offsetWidth;
outer.style.overflow = 'scroll';
var w2 = inner.offsetWidth;
if ( w1 == w2 )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
w2 = outer.clientWidth;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
document.body.removeChild(outer);
return (w1 - w2);
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Change the order of the table
* @param {object} oSettings dataTables settings object
* @param {bool} bApplyClasses optional - should we apply classes or not
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnSort ( oSettings, bApplyClasses )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var
i, iLen, j, jLen, k, kLen,
aaSort = [],
aiOrig = [],
oSort = _oExt.oSort,
aoData = oSettings.aoData,
aoColumns = oSettings.aoColumns;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* No sorting required if server-side or no sorting array */
if ( !oSettings.oFeatures.bServerSide &&
(oSettings.aaSorting.length !== 0 || oSettings.aaSortingFixed !== null) )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.aaSortingFixed !== null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
aaSort = oSettings.aaSortingFixed.concat( oSettings.aaSorting );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
else
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
aaSort = oSettings.aaSorting.slice();
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* If there is a sorting data type, and a fuction belonging to it, then we need to
* get the data from the developer's function and apply it for this column
*/
for ( i=0 ; i<aaSort.length ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var iColumn = aaSort[i][0];
var iVisColumn = _fnColumnIndexToVisible( oSettings, iColumn );
var sDataType = oSettings.aoColumns[ iColumn ].sSortDataType;
if ( typeof _oExt.afnSortData[sDataType] != 'undefined' )
{
var aData = _oExt.afnSortData[sDataType]( oSettings, iColumn, iVisColumn );
for ( j=0, jLen=aoData.length ; j<jLen ; j++ )
{
_fnSetCellData( oSettings, j, iColumn, aData[j] );
}
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Create a value - key array of the current row positions such that we can use their
* current position during the sort, if values match, in order to perform stable sorting
*/
for ( i=0, iLen=oSettings.aiDisplayMaster.length ; i<iLen ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
aiOrig[ oSettings.aiDisplayMaster[i] ] = i;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Build an internal data array which is specific to the sort, so we can get and prep
* the data to be sorted only once, rather than needing to do it every time the sorting
* function runs. This make the sorting function a very simple comparison
*/
var iSortLen = aaSort.length;
var fnSortFormat;
for ( i=0, iLen=aoData.length ; i<iLen ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
for ( j=0 ; j<iSortLen ; j++ )
{
aDataSort = aoColumns[ aaSort[j][0] ].aDataSort;
for ( k=0, kLen=aDataSort.length ; k<kLen ; k++ )
{
sDataType = aoColumns[ aDataSort[k] ].sType;
fnSortFormat = oSort[ (sDataType ? sDataType : 'string')+"-pre" ];
aoData[i]._aSortData[ aDataSort[k] ] = fnSortFormat ?
fnSortFormat( _fnGetCellData( oSettings, i, aDataSort[k], 'sort' ) ) :
_fnGetCellData( oSettings, i, aDataSort[k], 'sort' );
}
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Do the sort - here we want multi-column sorting based on a given data source (column)
* and sorting function (from oSort) in a certain direction. It's reasonably complex to
* follow on it's own, but this is what we want (example two column sorting):
* fnLocalSorting = function(a,b){
* var iTest;
* iTest = oSort['string-asc']('data11', 'data12');
* if (iTest !== 0)
* return iTest;
* iTest = oSort['numeric-desc']('data21', 'data22');
* if (iTest !== 0)
* return iTest;
* return oSort['numeric-asc']( aiOrig[a], aiOrig[b] );
* }
* Basically we have a test for each sorting column, if the data in that column is equal,
* test the next column. If all columns match, then we use a numeric sort on the row
* positions in the original data array to provide a stable sort.
*/
oSettings.aiDisplayMaster.sort( function ( a, b ) {
var k, l, lLen, iTest, aDataSort, sDataType;
for ( k=0 ; k<iSortLen ; k++ )
{
aDataSort = aoColumns[ aaSort[k][0] ].aDataSort;
for ( l=0, lLen=aDataSort.length ; l<lLen ; l++ )
{
sDataType = aoColumns[ aDataSort[l] ].sType;
iTest = oSort[ (sDataType ? sDataType : 'string')+"-"+aaSort[k][1] ](
aoData[a]._aSortData[ aDataSort[l] ],
aoData[b]._aSortData[ aDataSort[l] ]
);
if ( iTest !== 0 )
{
return iTest;
}
}
}
return oSort['numeric-asc']( aiOrig[a], aiOrig[b] );
} );
}
/* Alter the sorting classes to take account of the changes */
if ( (typeof bApplyClasses == 'undefined' || bApplyClasses) && !oSettings.oFeatures.bDeferRender )
{
_fnSortingClasses( oSettings );
}
/* Tell the draw function that we have sorted the data */
oSettings.bSorted = true;
$(oSettings.oInstance).trigger('sort', oSettings);
/* Copy the master data into the draw array and re-draw */
if ( oSettings.oFeatures.bFilter )
{
/* _fnFilter() will redraw the table for us */
_fnFilterComplete( oSettings, oSettings.oPreviousSearch, 1 );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
else
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
oSettings._iDisplayStart = 0; /* reset display back to page 0 */
_fnCalculateEnd( oSettings );
_fnDraw( oSettings );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Attach a sort handler (click) to a node
* @param {object} oSettings dataTables settings object
* @param {node} nNode node to attach the handler to
* @param {int} iDataIndex column sorting index
* @param {function} [fnCallback] callback function
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnSortAttachListener ( oSettings, nNode, iDataIndex, fnCallback )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
$(nNode).bind( 'click.DT', function (e) {
/* If the column is not sortable - don't to anything */
if ( oSettings.aoColumns[iDataIndex].bSortable === false )
{
return;
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/*
* This is a little bit odd I admit... I declare a temporary function inside the scope of
* _fnBuildHead and the click handler in order that the code presented here can be used
* twice - once for when bProcessing is enabled, and another time for when it is
* disabled, as we need to perform slightly different actions.
* Basically the issue here is that the Javascript engine in modern browsers don't
* appear to allow the rendering engine to update the display while it is still excuting
* it's thread (well - it does but only after long intervals). This means that the
* 'processing' display doesn't appear for a table sort. To break the js thread up a bit
* I force an execution break by using setTimeout - but this breaks the expected
* thread continuation for the end-developer's point of view (their code would execute
* too early), so we on;y do it when we absolutely have to.
*/
var fnInnerSorting = function () {
var iColumn, iNextSort;
/* If the shift key is pressed then we are multipe column sorting */
if ( e.shiftKey )
{
/* Are we already doing some kind of sort on this column? */
var bFound = false;
for ( var i=0 ; i<oSettings.aaSorting.length ; i++ )
{
if ( oSettings.aaSorting[i][0] == iDataIndex )
{
bFound = true;
iColumn = oSettings.aaSorting[i][0];
iNextSort = oSettings.aaSorting[i][2]+1;
if ( typeof oSettings.aoColumns[iColumn].asSorting[iNextSort] == 'undefined' )
{
/* Reached the end of the sorting options, remove from multi-col sort */
oSettings.aaSorting.splice( i, 1 );
}
else
{
/* Move onto next sorting direction */
oSettings.aaSorting[i][1] = oSettings.aoColumns[iColumn].asSorting[iNextSort];
oSettings.aaSorting[i][2] = iNextSort;
}
break;
}
}
/* No sort yet - add it in */
if ( bFound === false )
{
oSettings.aaSorting.push( [ iDataIndex,
oSettings.aoColumns[iDataIndex].asSorting[0], 0 ] );
}
}
else
{
/* If no shift key then single column sort */
if ( oSettings.aaSorting.length == 1 && oSettings.aaSorting[0][0] == iDataIndex )
{
iColumn = oSettings.aaSorting[0][0];
iNextSort = oSettings.aaSorting[0][2]+1;
if ( typeof oSettings.aoColumns[iColumn].asSorting[iNextSort] == 'undefined' )
{
iNextSort = 0;
}
oSettings.aaSorting[0][1] = oSettings.aoColumns[iColumn].asSorting[iNextSort];
oSettings.aaSorting[0][2] = iNextSort;
}
else
{
oSettings.aaSorting.splice( 0, oSettings.aaSorting.length );
oSettings.aaSorting.push( [ iDataIndex,
oSettings.aoColumns[iDataIndex].asSorting[0], 0 ] );
}
}
/* Run the sort */
_fnSort( oSettings );
}; /* /fnInnerSorting */
if ( !oSettings.oFeatures.bProcessing )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
fnInnerSorting();
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
else
{
_fnProcessingDisplay( oSettings, true );
setTimeout( function() {
fnInnerSorting();
if ( !oSettings.oFeatures.bServerSide )
{
_fnProcessingDisplay( oSettings, false );
}
}, 0 );
}
/* Call the user specified callback function - used for async user interaction */
if ( typeof fnCallback == 'function' )
{
fnCallback( oSettings );
}
} );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Set the sorting classes on the header, Note: it is safe to call this function
* when bSort and bSortClasses are false
* @param {object} oSettings dataTables settings object
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnSortingClasses( oSettings )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var i, iLen, j, jLen, iFound;
var aaSort, sClass;
var iColumns = oSettings.aoColumns.length;
var oClasses = oSettings.oClasses;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
for ( i=0 ; i<iColumns ; i++ )
New: Infinite scrolling! Building on the scrolling feature set that was introduced with 1.7, you can now have DataTables do infinite scrolling (bScrollInfinite: true), where data is loaded dynamically as and when needed by the user's interaction with scrolling. Infinite scrolling can be used by all DataTables' supported data sources without modification. New: The distance from the end of the current scrolling container before new data is added (with infinite scrolling) can be controlled with iScrollLoadGap (which is a numeric value in pixels). New: Example (basic_init/scrolling_y_infinite.html) to show how infinite scrolling can be used. Fixed: iDraw was not being incremented for a draw that did not use server-side processing.
2010-09-05 11:21:26 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.aoColumns[i].bSortable )
{
$(oSettings.aoColumns[i].nTh).removeClass( oClasses.sSortAsc +" "+ oClasses.sSortDesc +
" "+ oSettings.aoColumns[i].sSortingClass );
}
New: Infinite scrolling! Building on the scrolling feature set that was introduced with 1.7, you can now have DataTables do infinite scrolling (bScrollInfinite: true), where data is loaded dynamically as and when needed by the user's interaction with scrolling. Infinite scrolling can be used by all DataTables' supported data sources without modification. New: The distance from the end of the current scrolling container before new data is added (with infinite scrolling) can be controlled with iScrollLoadGap (which is a numeric value in pixels). New: Example (basic_init/scrolling_y_infinite.html) to show how infinite scrolling can be used. Fixed: iDraw was not being incremented for a draw that did not use server-side processing.
2010-09-05 11:21:26 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.aaSortingFixed !== null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
aaSort = oSettings.aaSortingFixed.concat( oSettings.aaSorting );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
else
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
aaSort = oSettings.aaSorting.slice();
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Apply the required classes to the header */
for ( i=0 ; i<oSettings.aoColumns.length ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.aoColumns[i].bSortable )
{
sClass = oSettings.aoColumns[i].sSortingClass;
iFound = -1;
for ( j=0 ; j<aaSort.length ; j++ )
{
if ( aaSort[j][0] == i )
{
sClass = ( aaSort[j][1] == "asc" ) ?
oClasses.sSortAsc : oClasses.sSortDesc;
iFound = j;
break;
}
}
$(oSettings.aoColumns[i].nTh).addClass( sClass );
if ( oSettings.bJUI )
{
/* jQuery UI uses extra markup */
var jqSpan = $("span", oSettings.aoColumns[i].nTh);
jqSpan.removeClass(oClasses.sSortJUIAsc +" "+ oClasses.sSortJUIDesc +" "+
oClasses.sSortJUI +" "+ oClasses.sSortJUIAscAllowed +" "+ oClasses.sSortJUIDescAllowed );
var sSpanClass;
if ( iFound == -1 )
{
sSpanClass = oSettings.aoColumns[i].sSortingClassJUI;
}
else if ( aaSort[iFound][1] == "asc" )
{
sSpanClass = oClasses.sSortJUIAsc;
}
else
{
sSpanClass = oClasses.sSortJUIDesc;
}
jqSpan.addClass( sSpanClass );
}
}
else
{
/* No sorting on this column, so add the base class. This will have been assigned by
* _fnAddColumn
*/
$(oSettings.aoColumns[i].nTh).addClass( oSettings.aoColumns[i].sSortingClass );
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/*
* Apply the required classes to the table body
* Note that this is given as a feature switch since it can significantly slow down a sort
* on large data sets (adding and removing of classes is always slow at the best of times..)
* Further to this, note that this code is admitadly fairly ugly. It could be made a lot
* simpiler using jQuery selectors and add/removeClass, but that is significantly slower
* (on the order of 5 times slower) - hence the direct DOM manipulation here.
* Note that for defered drawing we do use jQuery - the reason being that taking the first
* row found to see if the whole column needs processed can miss classes since the first
* column might be new.
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
sClass = oClasses.sSortColumn;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.oFeatures.bSort && oSettings.oFeatures.bSortClasses )
{
var nTds = _fnGetTdNodes( oSettings );
/* Remove the old classes */
if ( oSettings.oFeatures.bDeferRender )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
$(nTds).removeClass(sClass+'1 '+sClass+'2 '+sClass+'3');
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
else if ( nTds.length >= iColumns )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
for ( i=0 ; i<iColumns ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( nTds[i].className.indexOf(sClass+"1") != -1 )
{
for ( j=0, jLen=(nTds.length/iColumns) ; j<jLen ; j++ )
{
nTds[(iColumns*j)+i].className =
$.trim( nTds[(iColumns*j)+i].className.replace( sClass+"1", "" ) );
}
}
else if ( nTds[i].className.indexOf(sClass+"2") != -1 )
{
for ( j=0, jLen=(nTds.length/iColumns) ; j<jLen ; j++ )
{
nTds[(iColumns*j)+i].className =
$.trim( nTds[(iColumns*j)+i].className.replace( sClass+"2", "" ) );
}
}
else if ( nTds[i].className.indexOf(sClass+"3") != -1 )
{
for ( j=0, jLen=(nTds.length/iColumns) ; j<jLen ; j++ )
{
nTds[(iColumns*j)+i].className =
$.trim( nTds[(iColumns*j)+i].className.replace( " "+sClass+"3", "" ) );
}
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Add the new classes to the table */
var iClass = 1, iTargetCol;
for ( i=0 ; i<aaSort.length ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
iTargetCol = parseInt( aaSort[i][0], 10 );
for ( j=0, jLen=(nTds.length/iColumns) ; j<jLen ; j++ )
{
nTds[(iColumns*j)+iTargetCol].className += " "+sClass+iClass;
}
if ( iClass < 3 )
{
iClass++;
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Save the state of a table in a cookie such that the page can be reloaded
* @param {object} oSettings dataTables settings object
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnSaveState ( oSettings )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( !oSettings.oFeatures.bStateSave || typeof oSettings.bDestroying != 'undefined' )
{
return;
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Store the interesting variables */
var i, iLen, sTmp;
var sValue = "{";
sValue += '"iCreate":'+ new Date().getTime()+',';
sValue += '"iStart":'+ (oSettings.oScroll.bInfinite ? 0 : oSettings._iDisplayStart)+',';
sValue += '"iEnd":'+ (oSettings.oScroll.bInfinite ? oSettings._iDisplayLength : oSettings._iDisplayEnd)+',';
sValue += '"iLength":'+ oSettings._iDisplayLength+',';
sValue += '"sFilter":"'+ encodeURIComponent(oSettings.oPreviousSearch.sSearch)+'",';
sValue += '"sFilterEsc":'+ !oSettings.oPreviousSearch.bRegex+',';
sValue += '"aaSorting":[ ';
for ( i=0 ; i<oSettings.aaSorting.length ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
sValue += '['+oSettings.aaSorting[i][0]+',"'+oSettings.aaSorting[i][1]+'"],';
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
sValue = sValue.substring(0, sValue.length-1);
sValue += "],";
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
sValue += '"aaSearchCols":[ ';
for ( i=0 ; i<oSettings.aoPreSearchCols.length ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
sValue += '["'+encodeURIComponent(oSettings.aoPreSearchCols[i].sSearch)+
'",'+!oSettings.aoPreSearchCols[i].bRegex+'],';
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
sValue = sValue.substring(0, sValue.length-1);
sValue += "],";
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
sValue += '"abVisCols":[ ';
for ( i=0 ; i<oSettings.aoColumns.length ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
sValue += oSettings.aoColumns[i].bVisible+",";
}
sValue = sValue.substring(0, sValue.length-1);
sValue += "]";
/* Save state from any plug-ins */
for ( i=0, iLen=oSettings.aoStateSave.length ; i<iLen ; i++ )
{
sTmp = oSettings.aoStateSave[i].fn( oSettings, sValue );
if ( sTmp !== "" )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
sValue = sTmp;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
sValue += "}";
_fnCreateCookie( oSettings.sCookiePrefix+oSettings.sInstance, sValue,
oSettings.iCookieDuration, oSettings.sCookiePrefix, oSettings.fnCookieCallback );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Attempt to load a saved table state from a cookie
* @param {object} oSettings dataTables settings object
* @param {object} oInit DataTables init object so we can override settings
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnLoadState ( oSettings, oInit )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( !oSettings.oFeatures.bStateSave )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return;
}
var oData, i, iLen;
var sData = _fnReadCookie( oSettings.sCookiePrefix+oSettings.sInstance );
if ( sData !== null && sData !== '' )
{
/* Try/catch the JSON eval - if it is bad then we ignore it - note that 1.7.0 and before
* incorrectly used single quotes for some strings - hence the replace below
*/
try
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
oData = (typeof $.parseJSON == 'function') ?
$.parseJSON( sData.replace(/'/g, '"') ) : eval( '('+sData+')' );
}
catch( e )
{
return;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Allow custom and plug-in manipulation functions to alter the data set which was
* saved, and also reject any saved state by returning false
*/
for ( i=0, iLen=oSettings.aoStateLoad.length ; i<iLen ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( !oSettings.aoStateLoad[i].fn( oSettings, oData ) )
{
return;
}
}
/* Store the saved state so it might be accessed at any time (particualrly a plug-in */
oSettings.oLoadedState = $.extend( true, {}, oData );
/* Restore key features */
oSettings._iDisplayStart = oData.iStart;
oSettings.iInitDisplayStart = oData.iStart;
oSettings._iDisplayEnd = oData.iEnd;
oSettings._iDisplayLength = oData.iLength;
oSettings.oPreviousSearch.sSearch = decodeURIComponent(oData.sFilter);
oSettings.aaSorting = oData.aaSorting.slice();
oSettings.saved_aaSorting = oData.aaSorting.slice();
/*
* Search filtering - global reference added in 1.4.1
* Note that we use a 'not' for the value of the regular expression indicator to maintain
* compatibility with pre 1.7 versions, where this was basically inverted. Added in 1.7.0
*/
if ( typeof oData.sFilterEsc != 'undefined' )
{
oSettings.oPreviousSearch.bRegex = !oData.sFilterEsc;
}
/* Column filtering - added in 1.5.0 beta 6 */
if ( typeof oData.aaSearchCols != 'undefined' )
{
for ( i=0 ; i<oData.aaSearchCols.length ; i++ )
{
oSettings.aoPreSearchCols[i] = {
"sSearch": decodeURIComponent(oData.aaSearchCols[i][0]),
"bRegex": !oData.aaSearchCols[i][1]
};
}
}
/* Column visibility state - added in 1.5.0 beta 10 */
if ( typeof oData.abVisCols != 'undefined' )
{
/* Pass back visibiliy settings to the init handler, but to do not here override
* the init object that the user might have passed in
*/
oInit.saved_aoColumns = [];
for ( i=0 ; i<oData.abVisCols.length ; i++ )
{
oInit.saved_aoColumns[i] = {};
oInit.saved_aoColumns[i].bVisible = oData.abVisCols[i];
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Create a new cookie with a value to store the state of a table
* @param {string} sName name of the cookie to create
* @param {string} sValue the value the cookie should take
* @param {int} iSecs duration of the cookie
* @param {string} sBaseName sName is made up of the base + file name - this is the base
* @param {function} fnCallback User definable function to modify the cookie
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnCreateCookie ( sName, sValue, iSecs, sBaseName, fnCallback )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var date = new Date();
date.setTime( date.getTime()+(iSecs*1000) );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/*
* Shocking but true - it would appear IE has major issues with having the path not having
* a trailing slash on it. We need the cookie to be available based on the path, so we
* have to append the file name to the cookie name. Appalling. Thanks to vex for adding the
* patch to use at least some of the path
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var aParts = window.location.pathname.split('/');
var sNameFile = sName + '_' + aParts.pop().replace(/[\/:]/g,"").toLowerCase();
var sFullCookie, oData;
if ( fnCallback !== null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
oData = (typeof $.parseJSON == 'function') ?
$.parseJSON( sValue ) : eval( '('+sValue+')' );
sFullCookie = fnCallback( sNameFile, oData, date.toGMTString(),
aParts.join('/')+"/" );
}
else
{
sFullCookie = sNameFile + "=" + encodeURIComponent(sValue) +
"; expires=" + date.toGMTString() +"; path=" + aParts.join('/')+"/";
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Are we going to go over the cookie limit of 4KiB? If so, try to delete a cookies
* belonging to DataTables. This is FAR from bullet proof
*/
var sOldName="", iOldTime=9999999999999;
var iLength = _fnReadCookie( sNameFile )!==null ? document.cookie.length :
sFullCookie.length + document.cookie.length;
if ( iLength+10 > 4096 ) /* Magic 10 for padding */
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var aCookies =document.cookie.split(';');
for ( var i=0, iLen=aCookies.length ; i<iLen ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( aCookies[i].indexOf( sBaseName ) != -1 )
{
/* It's a DataTables cookie, so eval it and check the time stamp */
var aSplitCookie = aCookies[i].split('=');
try { oData = eval( '('+decodeURIComponent(aSplitCookie[1])+')' ); }
catch( e ) { continue; }
if ( typeof oData.iCreate != 'undefined' && oData.iCreate < iOldTime )
{
sOldName = aSplitCookie[0];
iOldTime = oData.iCreate;
}
}
}
if ( sOldName !== "" )
{
document.cookie = sOldName+"=; expires=Thu, 01-Jan-1970 00:00:01 GMT; path="+
aParts.join('/') + "/";
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
document.cookie = sFullCookie;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Read an old cookie to get a cookie with an old table state
* @param {string} sName name of the cookie to read
* @returns {string} contents of the cookie - or null if no cookie with that name found
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnReadCookie ( sName )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var
aParts = window.location.pathname.split('/'),
sNameEQ = sName + '_' + aParts[aParts.length-1].replace(/[\/:]/g,"").toLowerCase() + '=',
sCookieContents = document.cookie.split(';');
for( var i=0 ; i<sCookieContents.length ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var c = sCookieContents[i];
while (c.charAt(0)==' ')
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
c = c.substring(1,c.length);
}
if (c.indexOf(sNameEQ) === 0)
{
return decodeURIComponent( c.substring(sNameEQ.length,c.length) );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return null;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Compare two arrays
* @param {array} aArray1 first array
* @param {array} aArray2 second array
* @returns {int} 0 if match, 1 if length is different, 2 if no match
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnArrayCmp( aArray1, aArray2 )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( aArray1.length != aArray2.length )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return 1;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
for ( var i=0 ; i<aArray1.length ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( aArray1[i] != aArray2[i] )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return 2;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return 0;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* 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
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnSettingsFromNode ( nTable )
{
for ( var i=0 ; i<_aoSettings.length ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( _aoSettings[i].nTable == nTable )
{
return _aoSettings[i];
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return null;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Return an array with the TR nodes for the table
* @param {object} oSettings dataTables settings object
* @returns {array} TR array
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnGetTrNodes ( oSettings )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var aNodes = [];
for ( var i=0, iLen=oSettings.aoData.length ; i<iLen ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.aoData[i].nTr !== null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
aNodes.push( oSettings.aoData[i].nTr );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return aNodes;
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* 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
* @private
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
function _fnGetTdNodes ( oSettings, iIndividualRow )
{
var anReturn = [];
var iCorrector;
var anTds;
var iRow, iRows=oSettings.aoData.length,
iColumn, iColumns, oData, sNodeName, iStart=0, iEnd=iRows;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Allow the collection to be limited to just one row */
if ( typeof iIndividualRow != 'undefined' )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
iStart = iIndividualRow;
iEnd = iIndividualRow+1;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
for ( iRow=iStart ; iRow<iEnd ; iRow++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
oData = oSettings.aoData[iRow];
if ( oData.nTr !== null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* get the TD child nodes - taking into account text etc nodes */
anTds = [];
for ( iColumn=0, iColumns=oData.nTr.childNodes.length ; iColumn<iColumns ; iColumn++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
sNodeName = oData.nTr.childNodes[iColumn].nodeName.toLowerCase();
if ( sNodeName == 'td' || sNodeName == 'th' )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
anTds.push( oData.nTr.childNodes[iColumn] );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
Fix: New algorithim for calculating the column widths for a table when x-scrolling is enabled. Basically browsers need a bit of a hand when a width is assigned to any columns when x-scrolling as they tend to collapse the table to the min-width, even if we sent the column widths. So we need to keep track of what the table width should be by summing the user given values, and the automatic values
2011-05-12 21:32:18 +02:00
iCorrector = 0;
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
for ( iColumn=0, iColumns=oSettings.aoColumns.length ; iColumn<iColumns ; iColumn++ )
Fix: New algorithim for calculating the column widths for a table when x-scrolling is enabled. Basically browsers need a bit of a hand when a width is assigned to any columns when x-scrolling as they tend to collapse the table to the min-width, even if we sent the column widths. So we need to keep track of what the table width should be by summing the user given values, and the automatic values
2011-05-12 21:32:18 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.aoColumns[iColumn].bVisible )
Fix: New algorithim for calculating the column widths for a table when x-scrolling is enabled. Basically browsers need a bit of a hand when a width is assigned to any columns when x-scrolling as they tend to collapse the table to the min-width, even if we sent the column widths. So we need to keep track of what the table width should be by summing the user given values, and the automatic values
2011-05-12 21:32:18 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
anReturn.push( anTds[iColumn-iCorrector] );
Fix: New algorithim for calculating the column widths for a table when x-scrolling is enabled. Basically browsers need a bit of a hand when a width is assigned to any columns when x-scrolling as they tend to collapse the table to the min-width, even if we sent the column widths. So we need to keep track of what the table width should be by summing the user given values, and the automatic values
2011-05-12 21:32:18 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
else
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
anReturn.push( oData._anHidden[iColumn] );
iCorrector++;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return anReturn;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Log an error message
* @param {int} iLevel log error messages, or display them to the user
* @param {string} sMesg error message
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnLog( oSettings, iLevel, sMesg )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var sAlert = oSettings.sTableId === "" ?
"DataTables warning: " +sMesg :
"DataTables warning (table id = '"+oSettings.sTableId+"'): " +sMesg;
if ( iLevel === 0 )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( _oExt.sErrMode == 'alert' )
{
alert( sAlert );
}
else
{
throw sAlert;
}
return;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
else if ( typeof console != 'undefined' && typeof console.log != 'undefined' )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
console.log( sAlert );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* 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
* @private
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
function _fnMap( oRet, oSrc, sName, sMappedName )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( typeof sMappedName == 'undefined' )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
sMappedName = sName;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( typeof oSrc[sName] != 'undefined' )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
oRet[sMappedName] = oSrc[sName];
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
* Perform a jQuery selector action on the table's TR elements (from the tbody) and
* return the resulting expression
* @param {string} sSelector jQuery selector
* @returns {object} jQuery object
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
this.$ = function ( sSelector )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
// xxx - filtering, sorting, column visibility options
var oSettings = _fnSettingsFromNode(this[_oExt.iApiIndex]);
return $(this.oApi._fnGetTrNodes(oSettings)).filter(sSelector);
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
};
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* 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>mDataProp</i></li>
* <li>array of objects - multiple data objects when using <i>mDataProp</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.
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
*
* @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++;
* }
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
this.fnAddData = function( mData, bRedraw )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( mData.length === 0 )
Fix: When a column of only TH elements is used in the table it would cause indexing problems for the width calculation due to a getElementsByTagName('td'). Now use the _fnGetTdNodes (slightly modified) to do this.
2011-05-07 11:37:22 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return [];
Fix: When a column of only TH elements is used in the table it would cause indexing problems for the width calculation due to a getElementsByTagName('td'). Now use the _fnGetTdNodes (slightly modified) to do this.
2011-05-07 11:37:22 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var aiReturn = [];
var iTest;
/* Find settings from table node */
var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
/* Check if we want to add multiple rows or not */
if ( typeof mData[0] == "object" )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
for ( var i=0 ; i<mData.length ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
iTest = _fnAddData( oSettings, mData[i] );
if ( iTest == -1 )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return aiReturn;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
aiReturn.push( iTest );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
else
{
iTest = _fnAddData( oSettings, mData );
if ( iTest == -1 )
{
return aiReturn;
}
aiReturn.push( iTest );
}
oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
if ( typeof bRedraw == 'undefined' || bRedraw )
{
_fnReDraw( oSettings );
}
return aiReturn;
};
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
/**
* 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
*
* @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[_oExt.iApiIndex]);
_fnAdjustColumnSizing( oSettings );
if ( typeof 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
*
* @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[_oExt.iApiIndex] );
_fnClearTable( oSettings );
if ( typeof 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)
*
* @example
* $(document).ready(function() {
* var oTable;
*
* // 'open' an information row when a row is clicked on
* $('#example tbody tr').click( function () {
* var that = this;
* oTable.fnOpen( this, "Temporary row opened", "info_row" );
*
* // Then when the info row is clicked upon - close it
* $('#example .info_row').click( function () {
* oTable.fnClose(that);
* } );
* } );
*
* oTable = $('#example').dataTable();
* } );
*/
this.fnClose = function( nTr )
{
/* Find settings from table node */
var oSettings = _fnSettingsFromNode( this[_oExt.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;
};
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* 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
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
*
* @example
* $(document).ready(function() {
* var oTable = $('#example').dataTable();
*
* // Immediately remove the first row
* oTable.fnDeleteRow( 0 );
* } );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
this.fnDeleteRow = function( mTarget, fnCallBack, bRedraw )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Find settings from table node */
var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
var i, iAODataIndex;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
iAODataIndex = (typeof mTarget == 'object') ?
_fnNodeToDataIndex(oSettings, mTarget) : mTarget;
/* Return the data array from this row */
var oData = oSettings.aoData.splice( iAODataIndex, 1 );
/* 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" )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
fnCallBack.call( this, oSettings, oData );
}
/* Check for an 'overflow' they case for dislaying the table */
if ( oSettings._iDisplayStart >= oSettings.aiDisplay.length )
{
oSettings._iDisplayStart -= oSettings._iDisplayLength;
if ( oSettings._iDisplayStart < 0 )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
oSettings._iDisplayStart = 0;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( typeof bRedraw == 'undefined' || bRedraw )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
_fnCalculateEnd( oSettings );
_fnDraw( oSettings );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return oData;
};
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
* 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.
*
* @example
* $(document).ready(function() {
* // This example is fairly pointless in reality, but shows how fnDestroy can be used
* var oTable = $('#example').dataTable();
* oTable.fnDestroy();
* } );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
this.fnDestroy = function ( )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
var nOrig = oSettings.nTableWrapper.parentNode;
var nBody = oSettings.nTBody;
var i, iLen;
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
/* Flag to note that the table is currently being destroyed - no action should be taken */
oSettings.bDestroying = true;
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
/* Restore hidden columns */
for ( i=0, iLen=oSettings.aoDestroyCallback.length ; i<iLen ; i++ ) {
oSettings.aoDestroyCallback[i].fn();
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
/* Restore hidden columns */
for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
if ( oSettings.aoColumns[i].bVisible === false )
{
this.fnSetColumnVis( i, true );
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
/* 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 )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
$(oSettings.nTable).children('thead').remove();
oSettings.nTable.appendChild( oSettings.nTHead );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
if ( oSettings.nTFoot && oSettings.nTable != oSettings.nTFoot.parentNode )
{
$(oSettings.nTable).children('tfoot').remove();
oSettings.nTable.appendChild( oSettings.nTFoot );
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
/* 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(' ') );
if ( !oSettings.bJUI )
{
$('th', oSettings.nTHead).removeClass( [ _oExt.oStdClasses.sSortable,
_oExt.oStdClasses.sSortableAsc,
_oExt.oStdClasses.sSortableDesc,
_oExt.oStdClasses.sSortableNone ].join(' ')
);
}
else
{
$('th, td', oSettings.nTHead).removeClass( [ _oExt.oStdClasses.sSortable,
_oExt.oJUIClasses.sSortableAsc,
_oExt.oJUIClasses.sSortableDesc,
_oExt.oJUIClasses.sSortableNone ].join(' ')
);
$('th span.'+_oExt.oJUIClasses.sSortIcon
+ ', td span.'+_oExt.oJUIClasses.sSortIcon, oSettings.nTHead).remove();
$('th, td', oSettings.nTHead).each( function () {
var jqWrapper = $('div.'+_oExt.oJUIClasses.sSortJUIWrapper, this);
var kids = jqWrapper.contents();
$(this).append( kids );
jqWrapper.remove();
} );
}
/* Add the TR elements back into the table in their original order */
if ( oSettings.nTableReinsertBefore )
{
nOrig.insertBefore( oSettings.nTable, oSettings.nTableReinsertBefore );
}
else
{
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 odd/even type classes - then we add them back here. Note
* this is not fool proof (for example if not all rows as odd/even classes - but
* it's a good effort without getting carried away
*/
$(nBody).children('tr:even').addClass( oSettings.asDestroyStripes[0] );
$(nBody).children('tr:odd').addClass( oSettings.asDestroyStripes[1] );
/* Remove the settings object from the settings array */
for ( i=0, iLen=_aoSettings.length ; i<iLen ; i++ )
{
if ( _aoSettings[i] == oSettings )
{
_aoSettings.splice( i, 1 );
}
}
/* End it all */
oSettings = null;
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
};
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
* Redraw the table
* @param {bool} [bComplete=true] Re-filter and resort (if enabled) the table before the draw.
*
* @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();
* } );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
this.fnDraw = function( bComplete )
{
var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
if ( typeof bComplete != 'undefined' && 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)
*
* @example
* $(document).ready(function() {
* var oTable = $('#example').dataTable();
*
* // Sometime later - filter...
* oTable.fnFilter( 'test string' );
* } );
*/
this.fnFilter = function( sInput, iColumn, bRegex, bSmart, bShowGlobal )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
if ( !oSettings.oFeatures.bFilter )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
return;
}
if ( typeof bRegex == 'undefined' )
{
bRegex = false;
}
if ( typeof bSmart == 'undefined' )
{
bSmart = true;
}
if ( typeof bShowGlobal == 'undefined' )
{
bShowGlobal = true;
}
if ( typeof iColumn == "undefined" || iColumn === null )
{
/* Global filter */
_fnFilterComplete( oSettings, {
"sSearch":sInput,
"bRegex": bRegex,
"bSmart": bSmart
}, 1 );
if ( bShowGlobal && typeof oSettings.aanFeatures.f != 'undefined' )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
var n = oSettings.aanFeatures.f;
for ( var i=0, iLen=n.length ; i<iLen ; i++ )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
$('input', n[i]).val( sInput );
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
else
{
/* Single column filter */
oSettings.aoPreSearchCols[ iColumn ].sSearch = sInput;
oSettings.aoPreSearchCols[ iColumn ].bRegex = bRegex;
oSettings.aoPreSearchCols[ iColumn ].bSmart = bSmart;
_fnFilterComplete( oSettings, oSettings.oPreviousSearch, 1 );
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
};
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Return an array with the data which is used to make up the table
* or string if both row and column are given
* @param {mixed} [mRow] The TR row element to get the data for, or the aoData
* internal index (mapped to the TR element)
* @param {int} [iCol] Optional column index that you want the data of
* @returns {array|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.
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
*
* @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( this.parentNode );
*
* // Update the data array and return the value
* aData[ aPos[1] ] = 'clicked';
* this.innerHTML = 'clicked';
* } );
*
* // Init DataTables
* oTable = $('#example').dataTable();
* } );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
this.fnGetData = function( mRow, iCol )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
if ( typeof mRow != 'undefined' )
{
var iRow = (typeof mRow == 'object') ?
_fnNodeToDataIndex(oSettings, mRow) : mRow;
if ( typeof iCol != 'undefined' )
{
return _fnGetCellData( oSettings, iRow, iCol, '' );
}
return (typeof oSettings.aoData[iRow] != 'undefined') ?
oSettings.aoData[iRow]._aData : null;
}
return _fnGetDataMaster( oSettings );
};
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* The the TR nodes that are used in the table's body
* @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.
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
*
* @example
* $(document).ready(function() {
* var oTable = $('#example').dataTable();
*
* // Get the nodes from the table
* var nNodes = oTable.fnGetNodes( );
* } );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
this.fnGetNodes = function( iRow )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( typeof iRow != 'undefined' )
New: Addtinoal ability to control state saving through two new initialisation parameters "fnStateLoadCallback" and "fnStateSaveCallback". Documentation to be updated on datatables.net at 1.7.4 release time. Basically now you can add parameters to be save, and override parameters whic have been saved. Also useful for plug-ins which need to save state.
2010-10-28 23:03:41 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return (typeof oSettings.aoData[iRow] != 'undefined') ? oSettings.aoData[iRow].nTr : null;
New: Addtinoal ability to control state saving through two new initialisation parameters "fnStateLoadCallback" and "fnStateSaveCallback". Documentation to be updated on datatables.net at 1.7.4 release time. Basically now you can add parameters to be save, and override parameters whic have been saved. Also useful for plug-ins which need to save state.
2010-10-28 23:03:41 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return _fnGetTrNodes( oSettings );
};
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* 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)] is given.
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
*
* @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();
* } );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
this.fnGetPosition = function( nNode )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
var sNodeName = nNode.nodeName.toUpperCase();
if ( sNodeName == "TR" )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return _fnNodeToDataIndex(oSettings, nNode);
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
else if ( sNodeName == "TD" || sNodeName == "TH" )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var iDataIndex = _fnNodeToDataIndex(oSettings, nNode.parentNode);
var anCells = _fnGetTdNodes( oSettings, iDataIndex );
for ( var i=0 ; i<oSettings.aoColumns.length ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( anCells[i] == nNode )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return [ iDataIndex, _fnColumnIndexToVisible(oSettings, i ), i ];
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return null;
};
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
* 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
*
* @example
* $(document).ready(function() {
* var oTable;
*
* // 'open' an information row when a row is clicked on
* $('#example tbody tr').click( function () {
* var that = this;
* oTable.fnOpen( this, "Temporary row opened", "info_row" );
*
* // Then when the info row is clicked upon - close it
* $('#example .info_row').click( function () {
* oTable.fnClose(that);
* } );
* } );
*
* oTable = $('#example').dataTable();
* } );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
this.fnOpen = function( nTr, mHtml, sClass )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
/* Find settings from table node */
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
New: Cookie callback function (can be passed as an initialisation parameter) called fnCookieCallback, which allows the developer to modify the information stored in the cookie. Takes four arguments (sName, oData, sExpires, sPath) and expects a complete cookie string to be returned (with name, value, expires and path correctly formatted). Updated: Now use jQuery's JSON parse function (in jQuery 1.4) rather than JSON.js Fixed: State saving cookie used single quote strings in places (in correct JSON). This has now been addressed, and a work around in place (replace) until a sufficient period has passed
2010-08-20 19:52:16 +02:00
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
/* 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.jquery != 'undefined' || typeof mHtml == "object" )
New: Cookie callback function (can be passed as an initialisation parameter) called fnCookieCallback, which allows the developer to modify the information stored in the cookie. Takes four arguments (sName, oData, sExpires, sPath) and expects a complete cookie string to be returned (with name, value, expires and path correctly formatted). Updated: Now use jQuery's JSON parse function (in jQuery 1.4) rather than JSON.js Fixed: State saving cookie used single quote strings in places (in correct JSON). This has now been addressed, and a work around in place (replace) until a sufficient period has passed
2010-08-20 19:52:16 +02:00
{
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
nNewCell.appendChild( mHtml );
New: Cookie callback function (can be passed as an initialisation parameter) called fnCookieCallback, which allows the developer to modify the information stored in the cookie. Takes four arguments (sName, oData, sExpires, sPath) and expects a complete cookie string to be returned (with name, value, expires and path correctly formatted). Updated: Now use jQuery's JSON parse function (in jQuery 1.4) rather than JSON.js Fixed: State saving cookie used single quote strings in places (in correct JSON). This has now been addressed, and a work around in place (replace) until a sufficient period has passed
2010-08-20 19:52:16 +02:00
}
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
else
New: Cookie callback function (can be passed as an initialisation parameter) called fnCookieCallback, which allows the developer to modify the information stored in the cookie. Takes four arguments (sName, oData, sExpires, sPath) and expects a complete cookie string to be returned (with name, value, expires and path correctly formatted). Updated: Now use jQuery's JSON parse function (in jQuery 1.4) rather than JSON.js Fixed: State saving cookie used single quote strings in places (in correct JSON). This has now been addressed, and a work around in place (replace) until a sufficient period has passed
2010-08-20 19:52:16 +02:00
{
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
nNewCell.innerHTML = mHtml;
New: Cookie callback function (can be passed as an initialisation parameter) called fnCookieCallback, which allows the developer to modify the information stored in the cookie. Takes four arguments (sName, oData, sExpires, sPath) and expects a complete cookie string to be returned (with name, value, expires and path correctly formatted). Updated: Now use jQuery's JSON parse function (in jQuery 1.4) rather than JSON.js Fixed: State saving cookie used single quote strings in places (in correct JSON). This has now been addressed, and a work around in place (replace) until a sufficient period has passed
2010-08-20 19:52:16 +02:00
}
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
/* 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 )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
$(nNewRow).insertAfter(nTr);
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
oSettings.aoOpenRows.push( {
"nTr": nNewRow,
"nParent": nTr
} );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
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} sAction Paging action to take: "first", "previous", "next" or "last"
* @param {bool} [bRedraw=true] Redraw the table or not
*
* @example
* $(document).ready(function() {
* var oTable = $('#example').dataTable();
* oTable.fnPageChange( 'next' );
* } );
*/
this.fnPageChange = function ( sAction, bRedraw )
{
var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
_fnPageChange( oSettings, sAction );
_fnCalculateEnd( oSettings );
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( typeof bRedraw == 'undefined' || bRedraw )
{
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
_fnDraw( oSettings );
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
};
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* 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
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
*
* @example
* $(document).ready(function() {
* var oTable = $('#example').dataTable();
*
* // Hide the second column after initialisation
* oTable.fnSetColumnVis( 1, false );
* } );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
this.fnSetColumnVis = function ( iCol, bShow, bRedraw )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
var i, iLen;
var iColumns = oSettings.aoColumns.length;
var nTd, nCell, anTrs, jqChildren, bAppend, iBefore;
New: Column visibilty will now work great with rowspan / colspan in the header and footer! The way this is done is by creating a stored grid of the header/footer information - a grid of rows x columns - which contains information about the cell that should be at each point - regardless of rowspan / colspan. From that information it is then possible to draw the header / footer, minus any column (or row, although that is not used here) as needed. The initialisation and column visibility functions have been updated to account for this. This allows ColVis and the other plug-ins to 'just work' with complex headers. New: Initialisation parameter: bSortCellsTop. This parameter allows control over whether DataTables should use the top (true) unique cell that is found for a single column, or the bottom (false - default). This is useful when using complex headers. Removed: From the column definiations array (aoColumns) there is now no longer any need for anThExtra, anTfExtra or nTf. These have now been removed and will cause compatibilty issues for any plug-ins which use them. Fix: Tidy up spaces where there should be tabs
2011-04-10 20:15:09 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* No point in doing anything if we are requesting what is already true */
if ( oSettings.aoColumns[iCol].bVisible == bShow )
New: Column visibilty will now work great with rowspan / colspan in the header and footer! The way this is done is by creating a stored grid of the header/footer information - a grid of rows x columns - which contains information about the cell that should be at each point - regardless of rowspan / colspan. From that information it is then possible to draw the header / footer, minus any column (or row, although that is not used here) as needed. The initialisation and column visibility functions have been updated to account for this. This allows ColVis and the other plug-ins to 'just work' with complex headers. New: Initialisation parameter: bSortCellsTop. This parameter allows control over whether DataTables should use the top (true) unique cell that is found for a single column, or the bottom (false - default). This is useful when using complex headers. Removed: From the column definiations array (aoColumns) there is now no longer any need for anThExtra, anTfExtra or nTf. These have now been removed and will cause compatibilty issues for any plug-ins which use them. Fix: Tidy up spaces where there should be tabs
2011-04-10 20:15:09 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return;
New: Column visibilty will now work great with rowspan / colspan in the header and footer! The way this is done is by creating a stored grid of the header/footer information - a grid of rows x columns - which contains information about the cell that should be at each point - regardless of rowspan / colspan. From that information it is then possible to draw the header / footer, minus any column (or row, although that is not used here) as needed. The initialisation and column visibility functions have been updated to account for this. This allows ColVis and the other plug-ins to 'just work' with complex headers. New: Initialisation parameter: bSortCellsTop. This parameter allows control over whether DataTables should use the top (true) unique cell that is found for a single column, or the bottom (false - default). This is useful when using complex headers. Removed: From the column definiations array (aoColumns) there is now no longer any need for anThExtra, anTfExtra or nTf. These have now been removed and will cause compatibilty issues for any plug-ins which use them. Fix: Tidy up spaces where there should be tabs
2011-04-10 20:15:09 +02:00
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Show the column */
if ( bShow )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var iInsert = 0;
for ( i=0 ; i<iCol ; i++ )
{
if ( oSettings.aoColumns[i].bVisible )
{
iInsert++;
}
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Need to decide if we should use appendChild or insertBefore */
bAppend = (iInsert >= _fnVisbleColumns( oSettings ));
/* Which coloumn should we be inserting before? */
if ( !bAppend )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
for ( i=iCol ; i<iColumns ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.aoColumns[i].bVisible )
{
iBefore = i;
break;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
}
New: Column visibilty will now work great with rowspan / colspan in the header and footer! The way this is done is by creating a stored grid of the header/footer information - a grid of rows x columns - which contains information about the cell that should be at each point - regardless of rowspan / colspan. From that information it is then possible to draw the header / footer, minus any column (or row, although that is not used here) as needed. The initialisation and column visibility functions have been updated to account for this. This allows ColVis and the other plug-ins to 'just work' with complex headers. New: Initialisation parameter: bSortCellsTop. This parameter allows control over whether DataTables should use the top (true) unique cell that is found for a single column, or the bottom (false - default). This is useful when using complex headers. Removed: From the column definiations array (aoColumns) there is now no longer any need for anThExtra, anTfExtra or nTf. These have now been removed and will cause compatibilty issues for any plug-ins which use them. Fix: Tidy up spaces where there should be tabs
2011-04-10 20:15:09 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
for ( i=0, iLen=oSettings.aoData.length ; i<iLen ; i++ )
Dev change: Put nTf back into aoColumns - it's actually quite useful! It is not maniditory that there need be a cell for every column however - the footer is a lot more relaxed than the header
2011-04-27 19:06:29 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.aoData[i].nTr !== null )
{
if ( bAppend )
{
oSettings.aoData[i].nTr.appendChild(
oSettings.aoData[i]._anHidden[iCol]
);
}
else
{
oSettings.aoData[i].nTr.insertBefore(
oSettings.aoData[i]._anHidden[iCol],
_fnGetTdNodes( oSettings, i )[iBefore] );
}
}
Dev change: Put nTf back into aoColumns - it's actually quite useful! It is not maniditory that there need be a cell for every column however - the footer is a lot more relaxed than the header
2011-04-27 19:06:29 +02:00
}
New: Complex headers will now work as would be expected when giving a custom width (sWidth) to a specific column. Fix: $().empty() removes events was well as removing the child elements, so it was removing the sorting events when drawing the header. Now just manually remove them using DOM - was introduced in the last commit
2011-04-12 20:36:07 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
else
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Remove a column from display */
for ( i=0, iLen=oSettings.aoData.length ; i<iLen ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( oSettings.aoData[i].nTr !== null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
nTd = _fnGetTdNodes( oSettings, i )[iCol];
oSettings.aoData[i]._anHidden[iCol] = nTd;
nTd.parentNode.removeChild( nTd );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Clear to set the visible flag */
oSettings.aoColumns[iCol].bVisible = bShow;
/* Redraw the header and footer based on the new column visibility */
_fnDrawHead( oSettings, oSettings.aoHeader );
if ( oSettings.nTFoot )
{
_fnDrawHead( oSettings, oSettings.aoFooter );
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* If there are any 'open' rows, then we need to alter the colspan for this col change */
for ( i=0, iLen=oSettings.aoOpenRows.length ; i<iLen ; i++ )
{
oSettings.aoOpenRows[i].nTr.colSpan = _fnVisbleColumns( oSettings );
}
Fix: The scrollbar width calculation could sometimes be wrong when trying to calculate the size of the bar due to CSS styles. The inner P element could be given padding for example which would result in the scrollbar width being wrong and thus any calculations later on witht he scrollbar width would be incorrect.
2011-08-07 15:57:06 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
/* Do a redraw incase anything depending on the table columns needs it
* (built-in: scrolling)
*/
if ( typeof bRedraw == 'undefined' || bRedraw )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
_fnAdjustColumnSizing( oSettings );
_fnDraw( oSettings );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
_fnSaveState( oSettings );
};
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
* Get the settings for a particular table for external manipulation
* @returns {object} DataTables settings object. See
* {@link DataTable.models.oSettings}
*
* @example
* $(document).ready(function() {
* var oTable = $('#example').dataTable();
* var oSettings = oTable.fnSettings();
*
* // Show an example parameter from the settings
* alert( oSettings._iDisplayStart );
* } );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
this.fnSettings = function()
{
return _fnSettingsFromNode( this[_oExt.iApiIndex] );
};
/**
* Sort the table by a particular row
* @param {int} iCol the data index to sort on. Note that this will not match the
* 'display index' if you have hidden data entries
*
* @example
* $(document).ready(function() {
* var oTable = $('#example').dataTable();
*
* // Sort immediately with columns 0 and 1
* oTable.fnSort( [ [0,'asc'], [1,'asc'] ] );
* } );
*/
this.fnSort = function( aaSort )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
oSettings.aaSorting = aaSort;
_fnSort( oSettings );
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
};
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
* Attach a sort listener to an element for a given column
* @param {node} nNode the element to attach the sort listener to
* @param {int} iColumn the column that a click on this node will sort on
* @param {function} [fnCallback] callback function when sort is run
*
* @example
* $(document).ready(function() {
* var oTable = $('#example').dataTable();
*
* // Sort on column 1, when 'sorter' is clicked on
* oTable.fnSortListener( document.getElementById('sorter'), 1 );
* } );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
this.fnSortListener = function( nNode, iColumn, fnCallback )
{
_fnSortAttachListener( _fnSettingsFromNode( this[_oExt.iApiIndex] ), nNode, iColumn,
fnCallback );
};
/**
* Update a table cell or row - this method will accept either a single value to
* update the cell with, an array of values with one element for each column or
* an object in the same format as the original data source. The function is
* self-referencing in order to make the multi column updates easier.
* @param {object|array|string} mData Data to update the cell/row with
* @param {node|int} mRow TR element you want to update or the aoData index
* @param {int} [iColumn] The column to update (not used of mData is an array or object)
* @param {bool} [bRedraw=true] Redraw the table or not
* @param {bool} [bAction=true] Perform predraw actions or not
* @returns {int} 0 on success, 1 on error
*
* @example
* $(document).ready(function() {
* var oTable = $('#example').dataTable();
* oTable.fnUpdate( 'Example update', 0, 0 ); // Single cell
* oTable.fnUpdate( ['a', 'b', 'c', 'd', 'e'], 1, 0 ); // Row
* } );
*/
this.fnUpdate = function( mData, mRow, iColumn, bRedraw, bAction )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
var oSettings = _fnSettingsFromNode( this[_oExt.iApiIndex] );
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
var iVisibleColumn, i, iLen, sDisplay;
var iRow = (typeof mRow == 'object') ?
_fnNodeToDataIndex(oSettings, mRow) : mRow;
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
if ( typeof oSettings.__fnUpdateDeep == 'undefined' && $.isArray(mData) && typeof mData == 'object' )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
/* Array update - update the whole row */
oSettings.aoData[iRow]._aData = mData.slice();
/* Flag to the function that we are recursing */
oSettings.__fnUpdateDeep = true;
for ( i=0 ; i<oSettings.aoColumns.length ; i++ )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
this.fnUpdate( _fnGetCellData( oSettings, iRow, i ), iRow, i, false, false );
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
oSettings.__fnUpdateDeep = undefined;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
else if ( typeof oSettings.__fnUpdateDeep == 'undefined' && mData !== null && typeof mData == 'object' )
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
{
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
/* Object update - update the whole row - assume the developer gets the object right */
oSettings.aoData[iRow]._aData = $.extend( true, {}, mData );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
oSettings.__fnUpdateDeep = true;
for ( i=0 ; i<oSettings.aoColumns.length ; i++ )
{
this.fnUpdate( _fnGetCellData( oSettings, iRow, i ), iRow, i, false, false );
}
oSettings.__fnUpdateDeep = undefined;
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
else
New: Significant change to how data is handled by DataTables. DataTables now has the ability to deal with complex objects as data sourced, which is particularly useful for dealing with Ajax data, and other data which doesn't belong in the visible table (db IDs for example). See the examples/ajax/ files that are in this commit for examples on how this works. More unit tests and further tidy up to come. Detailed examples will also be added in future - the current examples are mainly for testing
2011-04-19 20:35:33 +02:00
{
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
/* Individual cell update */
sDisplay = mData;
_fnSetCellData( oSettings, iRow, iColumn, sDisplay );
if ( oSettings.aoColumns[iColumn].fnRender !== null )
New: Significant change to how data is handled by DataTables. DataTables now has the ability to deal with complex objects as data sourced, which is particularly useful for dealing with Ajax data, and other data which doesn't belong in the visible table (db IDs for example). See the examples/ajax/ files that are in this commit for examples on how this works. More unit tests and further tidy up to come. Detailed examples will also be added in future - the current examples are mainly for testing
2011-04-19 20:35:33 +02:00
{
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
sDisplay = oSettings.aoColumns[iColumn].fnRender( {
"iDataRow": iRow,
"iDataColumn": iColumn,
"aData": oSettings.aoData[iRow]._aData,
"oSettings": oSettings
} );
if ( oSettings.aoColumns[iColumn].bUseRendered )
{
_fnSetCellData( oSettings, iRow, iColumn, sDisplay );
}
}
if ( oSettings.aoData[iRow].nTr !== null )
{
/* Do the actual HTML update */
_fnGetTdNodes( oSettings, iRow )[iColumn].innerHTML = sDisplay;
New: Significant change to how data is handled by DataTables. DataTables now has the ability to deal with complex objects as data sourced, which is particularly useful for dealing with Ajax data, and other data which doesn't belong in the visible table (db IDs for example). See the examples/ajax/ files that are in this commit for examples on how this works. More unit tests and further tidy up to come. Detailed examples will also be added in future - the current examples are mainly for testing
2011-04-19 20:35:33 +02:00
}
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
/* Modify the search index for this row (strictly this is likely not needed, since fnReDraw
* will rebuild the search array - however, the redraw might be disabled by the user)
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
*/
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
var iDisplayIndex = $.inArray( iRow, oSettings.aiDisplay );
oSettings.asDataSearch[iDisplayIndex] = _fnBuildSearchRow( oSettings,
_fnGetRowData( oSettings, iRow, 'filter' ) );
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
/* Perform pre-draw actions */
if ( typeof bAction == 'undefined' || bAction )
New: If a data source is found to be a function, then the function is executed and the return used for the cell display (+sorting, filtering etc). This is useful for integration with knockout.js and backbone.js etc.
2011-09-10 10:12:23 +02:00
{
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
_fnAdjustColumnSizing( oSettings );
New: If a data source is found to be a function, then the function is executed and the return used for the cell display (+sorting, filtering etc). This is useful for integration with knockout.js and backbone.js etc.
2011-09-10 10:12:23 +02:00
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
/* Redraw the table */
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
if ( typeof bRedraw == 'undefined' || bRedraw )
New: sDefaultContent property for aoColumns / aoColumDefs. This new property allows a default value to be given for a column's data, and will be used whenever a null data source is encountered (this can be because mDataProp is set to null, or because the data source itself is null). In addition to this, when set if the mDataProp value is undefined, the default will be used instead (and no error given). If sDefaultContent is not set (default is null), and the mDataProp value is undefined, an error will be given as it currently is.
2011-05-09 20:07:16 +02:00
{
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
_fnReDraw( oSettings );
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
}
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
return 0;
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
};
New: Significant change to how data is handled by DataTables. DataTables now has the ability to deal with complex objects as data sourced, which is particularly useful for dealing with Ajax data, and other data which doesn't belong in the visible table (db IDs for example). See the examples/ajax/ files that are in this commit for examples on how this works. More unit tests and further tidy up to come. Detailed examples will also be added in future - the current examples are mainly for testing
2011-04-19 20:35:33 +02:00
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
* 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
*
* @example
* $(document).ready(function() {
* var oTable = $('#example').dataTable();
* alert( oTable.fnVersionCheck( '1.9.0' ) );
* } );
New: Significant change to how data is handled by DataTables. DataTables now has the ability to deal with complex objects as data sourced, which is particularly useful for dealing with Ajax data, and other data which doesn't belong in the visible table (db IDs for example). See the examples/ajax/ files that are in this commit for examples on how this works. More unit tests and further tidy up to come. Detailed examples will also be added in future - the current examples are mainly for testing
2011-04-19 20:35:33 +02:00
*/
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
this.fnVersionCheck = _oExt.fnVersionCheck;
New: Significant change to how data is handled by DataTables. DataTables now has the ability to deal with complex objects as data sourced, which is particularly useful for dealing with Ajax data, and other data which doesn't belong in the visible table (db IDs for example). See the examples/ajax/ files that are in this commit for examples on how this works. More unit tests and further tidy up to come. Detailed examples will also be added in future - the current examples are mainly for testing
2011-04-19 20:35:33 +02:00
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
/*
* This is really a good bit rubbish this method of exposing the internal methods
* publically... - To be fixed in 2.0 using methods on the prototype
*/
New: Significant change to how data is handled by DataTables. DataTables now has the ability to deal with complex objects as data sourced, which is particularly useful for dealing with Ajax data, and other data which doesn't belong in the visible table (db IDs for example). See the examples/ajax/ files that are in this commit for examples on how this works. More unit tests and further tidy up to come. Detailed examples will also be added in future - the current examples are mainly for testing
2011-04-19 20:35:33 +02:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/*
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
* Variable: oApi
* Purpose: Container for publicly exposed 'private' functions
* Scope: jQuery.dataTable
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
Add examples to API methods and tidy up the way oApi is generated a little
2011-12-01 20:47:40 +01:00
this.oApi = {
"_fnExternApiFunc": _fnExternApiFunc,
"_fnInitialise": _fnInitialise,
"_fnInitComplete": _fnInitComplete,
"_fnLanguageProcess": _fnLanguageProcess,
"_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,
"_fnArrayCmp": _fnArrayCmp,
"_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
};
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Internal and API methods now use JSDoc comments rather than my old system
2011-12-01 18:53:59 +01:00
/**
* Create a wrapper function for exporting an internal functions to an external API.
* @param {string} sFunc API function name
* @returns {function} wrapped function
* @private
*/
function _fnExternApiFunc (sFunc)
{
return function() {
var aArgs = [_fnSettingsFromNode(this[_oExt.iApiIndex])].concat(
Array.prototype.slice.call(arguments) );
return _oExt.oApi[sFunc].apply( this, aArgs );
};
}
for ( var sFunc in _oExt.oApi )
{
if ( sFunc )
{
this[sFunc] = _fnExternApiFunc(sFunc);
}
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
var _that = this;
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
return this.each(function() {
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
var i=0, iLen, j, jLen, k, kLen;
more spelling fixes
2011-06-30 22:23:27 +02:00
/* Check to see if we are re-initialising a table */
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
for ( i=0, iLen=_aoSettings.length ; i<iLen ; i++ )
{
/* Base check on table node */
if ( _aoSettings[i].nTable == this )
{
Tidy up the constructor to take account of the fact that we now have every possible property in the initalisation objects, since it is being extended from the details - i.e. no need to check for 'undefined' any more.
2011-11-26 14:34:51 +01:00
if ( typeof oInit == 'undefined' || oInit.bRetrieve )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
return _aoSettings[i].oInstance;
}
Tidy up the constructor to take account of the fact that we now have every possible property in the initalisation objects, since it is being extended from the details - i.e. no need to check for 'undefined' any more.
2011-11-26 14:34:51 +01:00
else if ( oInit.bDestroy )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
_aoSettings[i].oInstance.fnDestroy();
break;
}
else
{
_fnLog( _aoSettings[i], 0, "Cannot reinitialise DataTable.\n\n"+
"To retrieve the DataTables object for this table, please pass either no arguments "+
Fix typo 'destory' -> 'destroy'.
2011-11-07 09:55:01 +01:00
"to the dataTable() function, or set bRetrieve to true. Alternatively, to destroy "+
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
"the old table and create a new one, set bDestroy to true (note that a lot of "+
"changes to the configuration can be made through the API which is usually much "+
"faster)." );
return;
}
}
/* If the element we are initialising has the same ID as a table which was previously
Fix typo 'destory' -> 'destroy'.
2011-11-07 09:55:01 +01:00
* initialised, but the table nodes don't match (from before) then we destroy the old
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
* instance by simply deleting it. This is under the assumption that the table has been
* destroyed by other methods. Anyone using non-id selectors will need to do this manually
*/
if ( _aoSettings[i].sTableId !== "" && _aoSettings[i].sTableId == this.getAttribute('id') )
{
_aoSettings.splice( i, 1 );
break;
}
}
/* Make a complete and independent copy of the settings object */
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
var oSettings = $.extend( true, {}, DataTable.models.oSettings );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
_aoSettings.push( oSettings );
var bInitHandedOff = false;
var bUsePassedData = false;
/* Set the id */
var sId = this.getAttribute( 'id' );
if ( sId !== null )
{
oSettings.sTableId = sId;
oSettings.sInstance = sId;
}
else
{
oSettings.sInstance = _oExt._oExternConfig.iNextUnique ++;
}
Fixed: Add a sanity check to ensure that the node given to DataTables is in fact a table - 2343
2010-09-30 09:58:12 +02:00
/* Sanity check */
if ( this.nodeName.toLowerCase() != 'table' )
{
_fnLog( oSettings, 0, "Attempted to initialise DataTables on a node which is not a "+
"table: "+this.nodeName );
return;
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
/* Set the table node */
oSettings.nTable = this;
Fixed: The instance that is stored (oSettings.oInstance) could contain muliple tables in a single instance, when tables are created with a selector that includes multiple tables. This could make API access a bit more tricky (3963) so now store a unique instance of the DataTables object for each individual instance.
2011-01-29 09:53:42 +01:00
/* Keep a reference to the 'this' instance for the table. Note that if this table is being
* created with others, we retrieve a unique instance to ease API access.
*/
oSettings.oInstance = _that.length == 1 ? _that : $(this).dataTable();
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
/* Bind the API functions to the settings, so we can perform actions whenever oSettings is
* available
*/
oSettings.oApi = _that.oApi;
Fixed: Now restore the width of the original table on fnDestory. This is needed for when using sScrollXInner, and on other occasions where using DataTables will force the table to be wider than it otherwise would be - 2840
2010-09-30 23:06:41 +02:00
/* State the table's width for if a destroy is called at a later time */
oSettings.sDestroyWidth = $(this).width();
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Store the initialisation object that was passed in, useful for debugging */
oSettings.oInit = oInit;
oInit = (typeof oInit === 'undefined' || oInit === null) ?
Tidy up the constructor to take account of the fact that we now have every possible property in the initalisation objects, since it is being extended from the details - i.e. no need to check for 'undefined' any more.
2011-11-26 14:34:51 +01:00
$.extend( true, {}, DataTable.models.oInit ) :
$.extend( true, {}, DataTable.models.oInit, oInit );
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
_fnMap( oSettings.oFeatures, oInit, "bPaginate" );
_fnMap( oSettings.oFeatures, oInit, "bLengthChange" );
_fnMap( oSettings.oFeatures, oInit, "bFilter" );
_fnMap( oSettings.oFeatures, oInit, "bSort" );
_fnMap( oSettings.oFeatures, oInit, "bInfo" );
_fnMap( oSettings.oFeatures, oInit, "bProcessing" );
_fnMap( oSettings.oFeatures, oInit, "bAutoWidth" );
_fnMap( oSettings.oFeatures, oInit, "bSortClasses" );
_fnMap( oSettings.oFeatures, oInit, "bServerSide" );
_fnMap( oSettings.oFeatures, oInit, "bDeferRender" );
_fnMap( oSettings.oScroll, oInit, "sScrollX", "sX" );
_fnMap( oSettings.oScroll, oInit, "sScrollXInner", "sXInner" );
_fnMap( oSettings.oScroll, oInit, "sScrollY", "sY" );
_fnMap( oSettings.oScroll, oInit, "bScrollCollapse", "bCollapse" );
_fnMap( oSettings.oScroll, oInit, "bScrollInfinite", "bInfinite" );
_fnMap( oSettings.oScroll, oInit, "iScrollLoadGap", "iLoadGap" );
_fnMap( oSettings.oScroll, oInit, "bScrollAutoCss", "bAutoCss" );
_fnMap( oSettings, oInit, "asStripClasses", "asStripeClasses" ); // legacy
_fnMap( oSettings, oInit, "asStripeClasses" );
_fnMap( oSettings, oInit, "fnPreDrawCallback" );
_fnMap( oSettings, oInit, "fnRowCallback" );
_fnMap( oSettings, oInit, "fnHeaderCallback" );
_fnMap( oSettings, oInit, "fnFooterCallback" );
_fnMap( oSettings, oInit, "fnCookieCallback" );
_fnMap( oSettings, oInit, "fnInitComplete" );
_fnMap( oSettings, oInit, "fnServerData" );
_fnMap( oSettings, oInit, "sServerMethod" );
_fnMap( oSettings, oInit, "fnFormatNumber" );
_fnMap( oSettings, oInit, "aaSorting" );
_fnMap( oSettings, oInit, "aaSortingFixed" );
_fnMap( oSettings, oInit, "aLengthMenu" );
_fnMap( oSettings, oInit, "sPaginationType" );
_fnMap( oSettings, oInit, "sAjaxSource" );
_fnMap( oSettings, oInit, "sAjaxDataProp" );
_fnMap( oSettings, oInit, "iCookieDuration" );
_fnMap( oSettings, oInit, "sCookiePrefix" );
_fnMap( oSettings, oInit, "sDom" );
_fnMap( oSettings, oInit, "bSortCellsTop" );
_fnMap( oSettings, oInit, "oSearch", "oPreviousSearch" );
_fnMap( oSettings, oInit, "aoSearchCols", "aoPreSearchCols" );
_fnMap( oSettings, oInit, "iDisplayLength", "_iDisplayLength" );
_fnMap( oSettings, oInit, "bJQueryUI", "bJUI" );
_fnMap( oSettings.oLanguage, oInit, "fnInfoCallback" );
/* Callback functions which are array driven */
if ( typeof oInit.fnDrawCallback == 'function' )
{
oSettings.aoDrawCallback.push( {
"fn": oInit.fnDrawCallback,
"sName": "user"
} );
}
/* Ajax additional variables are array driven */
if ( typeof oInit.fnServerParams == 'function' )
{
oSettings.aoServerParams.push( {
"fn": oInit.fnServerParams,
"sName": "user"
} );
}
if ( typeof oInit.fnStateSaveCallback == 'function' )
{
oSettings.aoStateSave.push( {
"fn": oInit.fnStateSaveCallback,
"sName": "user"
} );
}
if ( typeof oInit.fnStateLoadCallback == 'function' )
{
oSettings.aoStateLoad.push( {
"fn": oInit.fnStateLoadCallback,
"sName": "user"
} );
}
if ( oSettings.oFeatures.bServerSide && oSettings.oFeatures.bSort &&
oSettings.oFeatures.bSortClasses )
{
/* Enable sort classes for server-side processing. Safe to do it here, since server-side
* processing must be enabled by the developer
*/
oSettings.aoDrawCallback.push( {
"fn": _fnSortingClasses,
"sName": "server_side_sort_classes"
} );
}
else if ( oSettings.oFeatures.bDeferRender )
{
oSettings.aoDrawCallback.push( {
"fn": _fnSortingClasses,
"sName": "defer_sort_classes"
} );
}
Tidy up the constructor to take account of the fact that we now have every possible property in the initalisation objects, since it is being extended from the details - i.e. no need to check for 'undefined' any more.
2011-11-26 14:34:51 +01:00
if ( oInit.bJQueryUI )
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
{
/* Use the JUI classes object for display. You could clone the oStdClasses object if
* you want to have multiple tables with multiple independent classes
*/
oSettings.oClasses = _oExt.oJUIClasses;
New: Addtinoal ability to control state saving through two new initialisation parameters "fnStateLoadCallback" and "fnStateSaveCallback". Documentation to be updated on datatables.net at 1.7.4 release time. Basically now you can add parameters to be save, and override parameters whic have been saved. Also useful for plug-ins which need to save state.
2010-10-28 23:03:41 +02:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
if ( typeof oInit.sDom == 'undefined' )
New: Addtinoal ability to control state saving through two new initialisation parameters "fnStateLoadCallback" and "fnStateSaveCallback". Documentation to be updated on datatables.net at 1.7.4 release time. Basically now you can add parameters to be save, and override parameters whic have been saved. Also useful for plug-ins which need to save state.
2010-10-28 23:03:41 +02:00
{
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Set the DOM to use a layout suitable for jQuery UI's theming */
oSettings.sDom = '<"H"lfr>t<"F"ip>';
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
}
else
{
oSettings.oClasses = _oExt.oStdClasses;
}
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Calculate the scroll bar width and cache it for use later on */
if ( oSettings.oScroll.sX !== "" || oSettings.oScroll.sY !== "" )
{
oSettings.oScroll.iBarWidth = _fnScrollBarWidth();
}
Tidy up the constructor to take account of the fact that we now have every possible property in the initalisation objects, since it is being extended from the details - i.e. no need to check for 'undefined' any more.
2011-11-26 14:34:51 +01:00
if ( typeof oSettings.iInitDisplayStart == 'undefined' )
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
{
/* Display start point, taking into account the save saving */
oSettings.iInitDisplayStart = oInit.iDisplayStart;
oSettings._iDisplayStart = oInit.iDisplayStart;
}
/* Must be done after everything which can be overridden by a cookie! */
Tidy up the constructor to take account of the fact that we now have every possible property in the initalisation objects, since it is being extended from the details - i.e. no need to check for 'undefined' any more.
2011-11-26 14:34:51 +01:00
if ( oInit.bStateSave )
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
{
Tidy up the constructor to take account of the fact that we now have every possible property in the initalisation objects, since it is being extended from the details - i.e. no need to check for 'undefined' any more.
2011-11-26 14:34:51 +01:00
oSettings.oFeatures.bStateSave = true;
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
_fnLoadState( oSettings, oInit );
oSettings.aoDrawCallback.push( {
"fn": _fnSaveState,
"sName": "state_save"
} );
}
Tidy up the constructor to take account of the fact that we now have every possible property in the initalisation objects, since it is being extended from the details - i.e. no need to check for 'undefined' any more.
2011-11-26 14:34:51 +01:00
if ( oInit.iDeferLoading !== null )
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
{
oSettings.bDeferLoading = true;
oSettings._iRecordsTotal = oInit.iDeferLoading;
oSettings._iRecordsDisplay = oInit.iDeferLoading;
}
Tidy up the constructor to take account of the fact that we now have every possible property in the initalisation objects, since it is being extended from the details - i.e. no need to check for 'undefined' any more.
2011-11-26 14:34:51 +01:00
if ( oInit.aaData !== null )
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
{
bUsePassedData = true;
}
Tidy up the constructor to take account of the fact that we now have every possible property in the initalisation objects, since it is being extended from the details - i.e. no need to check for 'undefined' any more.
2011-11-26 14:34:51 +01:00
/* Language definitions */
if ( oInit.oLanguage.sUrl !== "" )
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
{
Tidy up the constructor to take account of the fact that we now have every possible property in the initalisation objects, since it is being extended from the details - i.e. no need to check for 'undefined' any more.
2011-11-26 14:34:51 +01:00
/* Get the language definitions from a file */
oSettings.oLanguage.sUrl = oInit.oLanguage.sUrl;
$.getJSON( oSettings.oLanguage.sUrl, null, function( json ) {
_fnLanguageProcess( oSettings, json, true ); } );
bInitHandedOff = true;
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
}
Tidy up the constructor to take account of the fact that we now have every possible property in the initalisation objects, since it is being extended from the details - i.e. no need to check for 'undefined' any more.
2011-11-26 14:34:51 +01:00
else
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
{
Tidy up the constructor to take account of the fact that we now have every possible property in the initalisation objects, since it is being extended from the details - i.e. no need to check for 'undefined' any more.
2011-11-26 14:34:51 +01:00
_fnLanguageProcess( oSettings, oInit.oLanguage, false );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Warning: The _fnLanguageProcess function is async to the remainder of this function due
* to the XHR. We use _bInitialised in _fnLanguageProcess() to check this the processing
* below is complete. The reason for spliting it like this is optimisation - we can fire
* off the XHR (if needed) and then continue processing the data.
*/
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
/*
* Stripes
*/
/* Remove row stripe classes if they are already on the table row */
var bStripeRemove = false;
Dev fix: Can't use '>' in the children() method for jQuery since it would try to match on the wrong elements. Need to add another 'children' call.
2011-09-09 09:44:52 +02:00
var anRows = $(this).children('tbody').children('tr');
correct "stripe" spelling
2011-09-02 17:33:10 +02:00
for ( i=0, iLen=oSettings.asStripeClasses.length ; i<iLen ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
correct "stripe" spelling
2011-09-02 17:33:10 +02:00
if ( anRows.filter(":lt(2)").hasClass( oSettings.asStripeClasses[i]) )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
bStripeRemove = true;
break;
}
}
if ( bStripeRemove )
{
Fix typo 'destory' -> 'destroy'.
2011-11-07 09:55:01 +01:00
/* Store the classes which we are about to remove so they can be readded on destroy */
correct "stripe" spelling
2011-09-02 17:33:10 +02:00
oSettings.asDestroyStripes = [ '', '' ];
if ( $(anRows[0]).hasClass(oSettings.oClasses.sStripeOdd) )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
correct "stripe" spelling
2011-09-02 17:33:10 +02:00
oSettings.asDestroyStripes[0] += oSettings.oClasses.sStripeOdd+" ";
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
correct "stripe" spelling
2011-09-02 17:33:10 +02:00
if ( $(anRows[0]).hasClass(oSettings.oClasses.sStripeEven) )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
correct "stripe" spelling
2011-09-02 17:33:10 +02:00
oSettings.asDestroyStripes[0] += oSettings.oClasses.sStripeEven;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
correct "stripe" spelling
2011-09-02 17:33:10 +02:00
if ( $(anRows[1]).hasClass(oSettings.oClasses.sStripeOdd) )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
correct "stripe" spelling
2011-09-02 17:33:10 +02:00
oSettings.asDestroyStripes[1] += oSettings.oClasses.sStripeOdd+" ";
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
correct "stripe" spelling
2011-09-02 17:33:10 +02:00
if ( $(anRows[1]).hasClass(oSettings.oClasses.sStripeEven) )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
correct "stripe" spelling
2011-09-02 17:33:10 +02:00
oSettings.asDestroyStripes[1] += oSettings.oClasses.sStripeEven;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
correct "stripe" spelling
2011-09-02 17:33:10 +02:00
anRows.removeClass( oSettings.asStripeClasses.join(' ') );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Tidy up the constructor to take account of the fact that we now have every possible property in the initalisation objects, since it is being extended from the details - i.e. no need to check for 'undefined' any more.
2011-11-26 14:34:51 +01:00
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
/*
* Columns
Fixed: Column visibility was not being saved when calling fnSetColumnVis. It would require another draw to save the state before - 2635. Fixed: Column visibility was not be restored from the state saving cookie. A small tidy up of the column creation code as well - 2635.
2010-09-14 20:43:04 +02:00
* See if we should load columns automatically or use defined ones
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
*/
New: Column visibilty will now work great with rowspan / colspan in the header and footer! The way this is done is by creating a stored grid of the header/footer information - a grid of rows x columns - which contains information about the cell that should be at each point - regardless of rowspan / colspan. From that information it is then possible to draw the header / footer, minus any column (or row, although that is not used here) as needed. The initialisation and column visibility functions have been updated to account for this. This allows ColVis and the other plug-ins to 'just work' with complex headers. New: Initialisation parameter: bSortCellsTop. This parameter allows control over whether DataTables should use the top (true) unique cell that is found for a single column, or the bottom (false - default). This is useful when using complex headers. Removed: From the column definiations array (aoColumns) there is now no longer any need for anThExtra, anTfExtra or nTf. These have now been removed and will cause compatibilty issues for any plug-ins which use them. Fix: Tidy up spaces where there should be tabs
2011-04-10 20:15:09 +02:00
var anThs = [];
Fixed: When initialising multiple tables it was possible (no aoColumns given, and different number of columns) for DataTables to get confused and think one table's columns belong to another (due to a non-unique array in the initialisation object which was being wrongly used).
2010-09-20 14:15:06 +02:00
var aoColumnsInit;
New: Column visibilty will now work great with rowspan / colspan in the header and footer! The way this is done is by creating a stored grid of the header/footer information - a grid of rows x columns - which contains information about the cell that should be at each point - regardless of rowspan / colspan. From that information it is then possible to draw the header / footer, minus any column (or row, although that is not used here) as needed. The initialisation and column visibility functions have been updated to account for this. This allows ColVis and the other plug-ins to 'just work' with complex headers. New: Initialisation parameter: bSortCellsTop. This parameter allows control over whether DataTables should use the top (true) unique cell that is found for a single column, or the bottom (false - default). This is useful when using complex headers. Removed: From the column definiations array (aoColumns) there is now no longer any need for anThExtra, anTfExtra or nTf. These have now been removed and will cause compatibilty issues for any plug-ins which use them. Fix: Tidy up spaces where there should be tabs
2011-04-10 20:15:09 +02:00
var nThead = this.getElementsByTagName('thead');
if ( nThead.length !== 0 )
{
_fnDetectHeader( oSettings.aoHeader, nThead[0] );
anThs = _fnGetUniqueThs( oSettings );
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
Fixed: Column visibility was not being saved when calling fnSetColumnVis. It would require another draw to save the state before - 2635. Fixed: Column visibility was not be restored from the state saving cookie. A small tidy up of the column creation code as well - 2635.
2010-09-14 20:43:04 +02:00
/* If not given a column array, generate one with nulls */
Tidy up the constructor to take account of the fact that we now have every possible property in the initalisation objects, since it is being extended from the details - i.e. no need to check for 'undefined' any more.
2011-11-26 14:34:51 +01:00
if ( oInit.aoColumns === null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Fixed: When initialising multiple tables it was possible (no aoColumns given, and different number of columns) for DataTables to get confused and think one table's columns belong to another (due to a non-unique array in the initialisation object which was being wrongly used).
2010-09-20 14:15:06 +02:00
aoColumnsInit = [];
Fixed: Column visibility was not being saved when calling fnSetColumnVis. It would require another draw to save the state before - 2635. Fixed: Column visibility was not be restored from the state saving cookie. A small tidy up of the column creation code as well - 2635.
2010-09-14 20:43:04 +02:00
for ( i=0, iLen=anThs.length ; i<iLen ; i++ )
{
Fixed: When initialising multiple tables it was possible (no aoColumns given, and different number of columns) for DataTables to get confused and think one table's columns belong to another (due to a non-unique array in the initialisation object which was being wrongly used).
2010-09-20 14:15:06 +02:00
aoColumnsInit.push( null );
Fixed: Column visibility was not being saved when calling fnSetColumnVis. It would require another draw to save the state before - 2635. Fixed: Column visibility was not be restored from the state saving cookie. A small tidy up of the column creation code as well - 2635.
2010-09-14 20:43:04 +02:00
}
}
Fixed: When initialising multiple tables it was possible (no aoColumns given, and different number of columns) for DataTables to get confused and think one table's columns belong to another (due to a non-unique array in the initialisation object which was being wrongly used).
2010-09-20 14:15:06 +02:00
else
{
aoColumnsInit = oInit.aoColumns;
}
Fixed: Column visibility was not being saved when calling fnSetColumnVis. It would require another draw to save the state before - 2635. Fixed: Column visibility was not be restored from the state saving cookie. A small tidy up of the column creation code as well - 2635.
2010-09-14 20:43:04 +02:00
/* Add the columns */
Fixed: When initialising multiple tables it was possible (no aoColumns given, and different number of columns) for DataTables to get confused and think one table's columns belong to another (due to a non-unique array in the initialisation object which was being wrongly used).
2010-09-20 14:15:06 +02:00
for ( i=0, iLen=aoColumnsInit.length ; i<iLen ; i++ )
Fixed: Column visibility was not being saved when calling fnSetColumnVis. It would require another draw to save the state before - 2635. Fixed: Column visibility was not be restored from the state saving cookie. A small tidy up of the column creation code as well - 2635.
2010-09-14 20:43:04 +02:00
{
/* Check if we have column visibilty state to restore */
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
if ( typeof oInit.saved_aoColumns != 'undefined' && oInit.saved_aoColumns.length == iLen )
{
Fixed: When initialising multiple tables it was possible (no aoColumns given, and different number of columns) for DataTables to get confused and think one table's columns belong to another (due to a non-unique array in the initialisation object which was being wrongly used).
2010-09-20 14:15:06 +02:00
if ( aoColumnsInit[i] === null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Fixed: When initialising multiple tables it was possible (no aoColumns given, and different number of columns) for DataTables to get confused and think one table's columns belong to another (due to a non-unique array in the initialisation object which was being wrongly used).
2010-09-20 14:15:06 +02:00
aoColumnsInit[i] = {};
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Fixed: When initialising multiple tables it was possible (no aoColumns given, and different number of columns) for DataTables to get confused and think one table's columns belong to another (due to a non-unique array in the initialisation object which was being wrongly used).
2010-09-20 14:15:06 +02:00
aoColumnsInit[i].bVisible = oInit.saved_aoColumns[i].bVisible;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
Fixed: Column visibility was not being saved when calling fnSetColumnVis. It would require another draw to save the state before - 2635. Fixed: Column visibility was not be restored from the state saving cookie. A small tidy up of the column creation code as well - 2635.
2010-09-14 20:43:04 +02:00
_fnAddColumn( oSettings, anThs ? anThs[i] : null );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
/* Add options from column definations */
Tidy up the constructor to take account of the fact that we now have every possible property in the initalisation objects, since it is being extended from the details - i.e. no need to check for 'undefined' any more.
2011-11-26 14:34:51 +01:00
if ( oInit.aoColumnDefs !== null )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
/* Loop over the column defs array - loop in reverse so first instace has priority */
for ( i=oInit.aoColumnDefs.length-1 ; i>=0 ; i-- )
{
/* Each column def can target multiple columns, as it is an array */
var aTargets = oInit.aoColumnDefs[i].aTargets;
Updated: A warning is now given if you pass in aTargets (for aoColumnDefs) as something other than an array (since this is not valid).
2010-10-30 07:44:34 +02:00
if ( !$.isArray( aTargets ) )
{
_fnLog( oSettings, 1, 'aTargets must be an array of targets, not a '+(typeof aTargets) );
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
for ( j=0, jLen=aTargets.length ; j<jLen ; j++ )
{
if ( typeof aTargets[j] == 'number' && aTargets[j] >= 0 )
{
/* 0+ integer, left to right column counting. We add columns which are unknown
* automatically. Is this the right behaviour for this? We should at least
* log it in future. We cannot do this for the negative or class targets, only here.
*/
while( oSettings.aoColumns.length <= aTargets[j] )
{
_fnAddColumn( oSettings );
}
_fnColumnOptions( oSettings, aTargets[j], oInit.aoColumnDefs[i] );
}
else if ( typeof aTargets[j] == 'number' && aTargets[j] < 0 )
{
/* Negative integer, right to left column counting */
_fnColumnOptions( oSettings, oSettings.aoColumns.length+aTargets[j],
oInit.aoColumnDefs[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" ||
Fix: Column defs with a string would incorrectly match on a substring class - 4793
2011-04-21 17:45:39 +02:00
$(oSettings.aoColumns[k].nTh).hasClass( aTargets[j] ) )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
_fnColumnOptions( oSettings, k, oInit.aoColumnDefs[i] );
}
}
}
}
}
}
/* Add options from column array - after the defs array so this has priority */
Fixed: When initialising multiple tables it was possible (no aoColumns given, and different number of columns) for DataTables to get confused and think one table's columns belong to another (due to a non-unique array in the initialisation object which was being wrongly used).
2010-09-20 14:15:06 +02:00
if ( typeof aoColumnsInit != 'undefined' )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Fixed: When initialising multiple tables it was possible (no aoColumns given, and different number of columns) for DataTables to get confused and think one table's columns belong to another (due to a non-unique array in the initialisation object which was being wrongly used).
2010-09-20 14:15:06 +02:00
for ( i=0, iLen=aoColumnsInit.length ; i<iLen ; i++ )
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
{
Fixed: When initialising multiple tables it was possible (no aoColumns given, and different number of columns) for DataTables to get confused and think one table's columns belong to another (due to a non-unique array in the initialisation object which was being wrongly used).
2010-09-20 14:15:06 +02:00
_fnColumnOptions( oSettings, i, aoColumnsInit[i] );
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
}
}
Tidy up the constructor to take account of the fact that we now have every possible property in the initalisation objects, since it is being extended from the details - i.e. no need to check for 'undefined' any more.
2011-11-26 14:34:51 +01:00
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
/*
* Sorting
* Check the aaSorting array
*/
for ( i=0, iLen=oSettings.aaSorting.length ; i<iLen ; i++ )
{
Fixed: When state saving, it was possible to have a situation where by a table would contain 'n' columns, the user would sort on the last column and then the html is modifed to only have 'n-1' columns. This resulted in a JS error when DataTables tried to restore sorting on the removed column. Now do a sanity check to ensure the sorting column is present, and if not add sorting on column 0.
2010-10-30 07:54:10 +02:00
if ( oSettings.aaSorting[i][0] >= oSettings.aoColumns.length )
{
oSettings.aaSorting[i][0] = 0;
}
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
var oColumn = oSettings.aoColumns[ oSettings.aaSorting[i][0] ];
/* Add a default sorting index */
if ( typeof oSettings.aaSorting[i][2] == 'undefined' )
{
oSettings.aaSorting[i][2] = 0;
}
/* If aaSorting is not defined, then we use the first indicator in asSorting */
if ( typeof oInit.aaSorting == "undefined" &&
typeof oSettings.saved_aaSorting == "undefined" )
{
oSettings.aaSorting[i][1] = oColumn.asSorting[0];
}
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/* Set the current sorting index based on aoColumns.asSorting */
for ( j=0, jLen=oColumn.asSorting.length ; j<jLen ; j++ )
{
if ( oSettings.aaSorting[i][1] == oColumn.asSorting[j] )
{
oSettings.aaSorting[i][2] = j;
break;
}
}
}
/* Do a first pass on the sorting classes (allows any size changes to be taken into
* account, and also will apply sorting disabled classes if disabled
*/
_fnSortingClasses( oSettings );
Tidy up the constructor to take account of the fact that we now have every possible property in the initalisation objects, since it is being extended from the details - i.e. no need to check for 'undefined' any more.
2011-11-26 14:34:51 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/*
* Final init
* Cache the header, body and footer as required, creating them if needed
*/
var thead = $(this).children('thead');
if ( thead.length === 0 )
{
thead = [ document.createElement( 'thead' ) ];
this.appendChild( thead[0] );
}
oSettings.nTHead = thead[0];
var tbody = $(this).children('tbody');
if ( tbody.length === 0 )
{
tbody = [ document.createElement( 'tbody' ) ];
this.appendChild( tbody[0] );
}
oSettings.nTBody = tbody[0];
var tfoot = $(this).children('tfoot');
if ( tfoot.length > 0 )
{
oSettings.nTFoot = tfoot[0];
_fnDetectHeader( oSettings.aoFooter, oSettings.nTFoot );
}
/* Check if there is data passing into the constructor */
if ( bUsePassedData )
{
for ( i=0 ; i<oInit.aaData.length ; i++ )
{
_fnAddData( oSettings, oInit.aaData[ i ] );
}
}
else
{
/* Grab the data from the page */
_fnGatherData( oSettings );
}
/* Copy the data index array */
oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
/* Initialisation complete - table can be drawn */
oSettings.bInitialised = true;
/* Check if we need to initialise the table (it might not have been handed off to the
* language processor)
*/
if ( bInitHandedOff === false )
{
_fnInitialise( oSettings );
}
} );
};
DataTable.models = {};
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Template object for the way in which DataTables holds information about
* search information for the global filter and individual column filters.
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* @namespace
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
DataTable.models.oSearch = {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Applied search term
* @type string
* @default <i>Empty string</i>
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"sSearch": "",
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Flag to indicate if the search term should be interpreted as a
* regular expression (true) or not (false) and therefore and special
* regex characters escaped.
* @type boolean
* @default false
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"bRegex": false,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Flag to indicate if DataTables is to use its smart filtering or not.
* @type boolean
* @default true
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"bSmart": true
};
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
/**
* Template object for the way in which DataTables holds information about
* each individual row. This is the object format used for the settings
* aoData array.
* @namespace
*/
DataTable.models.oRow = {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* TR element for the row
* @type node
* @default null
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"nTr": null,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Data object from the original data source for the row. This is either
* an array if using the traditional form of DataTables, or an object if
* using mDataProp options. The exact type will depend on the passed in
* data from the data source, or will be an array if using DOM a data
* source.
* @type array|object
* @default []
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"_aData": [],
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Sorting data cache - this array is ostensibly the same length as the
* number of columns (although each index is generated only as it is
* needed), and holds the data that is used for sorting each column in the
* row. We do this cache generation at the start of the sort in order that
* the formatting of the sort data need be done only once for each cell
* per sort. This array should not be read from or written to by anything
* other than the master sorting methods.
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* @type array
Tidy up the constructor to take account of the fact that we now have every possible property in the initalisation objects, since it is being extended from the details - i.e. no need to check for 'undefined' any more.
2011-11-26 14:34:51 +01:00
* @default []
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* @private
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"_aSortData": [],
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
/**
* Array of TD elements that are cached for hidden rows, so they can be
* reinserted into the table if a column is made visible again (or to act
* as a store if a column is made hidden). Only hidden columns have a
* reference in the array. For non-hidden columns the value is either
* undefined or null.
* @type array nodes
* @default []
* @private
*/
"_anHidden": [],
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Cache of the class name that DataTables has applied to the row, so we
* can quickly look at this variable rather than needing to do a DOM check
* on className for the nTr property.
* @type string
* @default <i>Empty string</i>
* @private
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"_sRowStripe": ""
};
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
/**
* Template object for the column information object in DataTables. This object
* is held in the settings aoColumns array and contains all the information that
* DataTables needs about each individual column.
*
* Note that this object is related to {@link DataTable.models.oInitColumns}
* but this one is the internal data store for DataTables's cache of columns.
* It should NOT be manipulated outside of DataTables. Any configuration should
* be done through the initialisation options.
* @namespace
*/
DataTable.models.oColumn = {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* A list of the columns that sorting should occur on when this column
* is sorted. That this property is an array allows multi-column sorting
* to be defined for a column (for example first name / last name columns
* would benefit from this). The values are integers pointing to the
* columns to be sorted on (typically it will be a single integer pointing
* at itself, but that doesn't need to be the case).
* @type array
* @default []
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"aDataSort": [],
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Define the sorting directions that are applied to the column, in sequence
* as the column is repeatedly sorted upon - i.e. the first value is used
* as the sorting direction when the column if first sorted (clicked on).
* Sort it again (click again) and it will move on to the next index.
* Repeat until loop.
* @type array
* @default ['asc', 'desc']
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"asSorting": ['asc', 'desc'],
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Flag to indicate if the column is searchable, and thus should be included
* in the filtering or not.
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* @type boolean
* @default true
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"bSearchable": true,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Flag to indicate if the column is sortable or not.
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* @type boolean
* @default true
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"bSortable": true,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* When using fnRender, you have two options for what to do with the data,
* and this property serves as the switch. Firstly, you can have the sorting
* and filtering use the rendered value (true - default), or you can have
* the sorting and filtering us the original value (false).
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* *NOTE* It is it is advisable now to use mDataProp as a function and make
* use of the 'type' that it gives, allowing (potentially) different data to
* be used for sorting, filtering, display and type detection.
* @type boolean
* @default true
* @deprecated
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"bUseRendered": true,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Flag to indicate if the column is currently visible in the table or not
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* @type boolean
* @default true
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"bVisible": true,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Flag to indicate to the type detection method if the automatic type
* detection should be used, or if a column type (sType) has been specified
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* @type boolean
* @default true
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* @private
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"_bAutoType": true,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Function to get data from a cell in a column. You should <b>never</b>
* access data directly through _aData internally in DataTables - always use
* the method attached to this property. It allows mDataProp to function as
* required. This function is automatically assigned by the column
* initialisation method
* @type function
* @param {array|object} oData The data array/object for the array
* (i.e. aoData[]._aData)
* @param {string} sSpecific The specific data type you want to get -
* 'display', 'type' 'filter' 'sort'
* @returns {*} The data for the cell from the given row's data
* @default null
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"fnGetData": null,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Custom display function that will be called for the display of each cell
* in this column.
* @type function
* @param {object} o Object with the following parameters:
* @param {int} o.iDataRow The row in aoData
* @param {int} o.iDataColumn The column in question
* @param {array o.aData The data for the row in question
* @param {object} o.oSettings The settings object for this DataTables instance
* @returns {string} The string you which to use in the display
* @default null
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"fnRender": null,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Function to set data for a cell in the column. You should <b>never</b>
* set the data directly to _aData internally in DataTables - always use
* this method. It allows mDataProp to function as required. This function
* is automatically assigned by the column initialisation method
* @type function
* @param {array|object} oData The data array/object for the array
* (i.e. aoData[]._aData)
* @param {*} sValue Value to set
* @default null
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"fnSetData": null,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Property to read the value for the cells in the column from the data
* source array / object. If null, then the default content is used, if a
* function is given then the return from the function is used.
* @type function|int|string|null
* @default null
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"mDataProp": null,
/**
* Unique header TH/TD element for this column - this is what the sorting
* listener is attached to (if sorting is enabled.)
* @type node
* @default null
*/
"nTh": null,
/**
* Unique footer TH/TD element for this column (if there is one). Not used
* in DataTables as such, but can be used for plug-ins to reference the
* footer for each column.
* @type node
* @default null
*/
"nTf": null,
/**
* The class to apply to all TD elements in the table's TBODY for the column
* @type string
* @default null
*/
"sClass": null,
/**
* When DataTables calculates the column widths to assign to each column,
* it finds the longest string in each column and then constructs a
* temporary table and reads the widths from that. The problem with this
* is that "mmm" is much wider then "iiii", but the latter is a longer
* string - thus the calculation can go wrong (doing it properly and putting
* it into an DOM object and measuring that is horribly(!) slow). Thus as
* a "work around" we provide this option. It will append its value to the
* text that is found to be the longest string for the column - i.e. padding.
* @type string
* @default <i>Empty string<i>
*/
"sContentPadding": "",
/**
* Allows a default value to be given for a column's data, and will be used
* whenever a null data source is encountered (this can be because mDataProp
* is set to null, or because the data source itself is null).
* @type string
* @default null
*/
"sDefaultContent": null,
/**
* Name for the column, allowing reference to the column by name as well as
* by index (needs a lookup to work by name).
* @type string
* @default <i>Empty string<i>
*/
"sName": '',
/**
* Custom sorting data type - defines which of the available plug-ins in
* afnSortData the custom sorting will use - if any is defined.
* @type string
* @default std
*/
"sSortDataType": 'std',
/**
* Class to be applied to the header element when sorting on this column
* @type string
* @default null
*/
"sSortingClass": null,
/**
* Class to be applied to the header element when sorting on this column -
* when jQuery UI theming is used.
* @type string
* @default null
*/
"sSortingClassJUI": null,
/**
* Title of the column - what is seen in the TH element (nTh).
* @type string
* @default <i>Empty string - automatically detected<i>
*/
"sTitle": '',
/**
* Column sorting and filtering type
* @type string
* @default null
*/
"sType": null,
/**
* Width of the column
* @type string
* @default null
*/
"sWidth": null,
/**
* Width of the column when it was first "encountered"
* @type string
* @default null
*/
"sWidthOrig": null
};
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
/**
* Initialisation options that can be given to DataTables at initialisation
* time.
* @namespace
*/
DataTable.models.oInit = {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* An array of data to use for the table, passed in at initialisation which
* will be used in preference to any data which is already in the DOM. This is
* particularly useful for constructing tables purely in Javascript, for
* example with a custom Ajax call.
* @type array
* @default null
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* // Using a 2D array data source
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* $(document).ready( function () {
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "aaData": [
* ['Trident', 'Internet Explorer 4.0', 'Win 95+', 4, 'X'],
* ['Trident', 'Internet Explorer 5.0', 'Win 95+', 5, 'C'],
* ],
* "aoColumns": [
* { "sTitle": "Engine" },
* { "sTitle": "Browser" },
* { "sTitle": "Platform" },
* { "sTitle": "Version" },
* { "sTitle": "Grade" }
* ]
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
* } );
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
*
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* @example
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* // Using an array of objects as a data source (mDataProp)
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* $(document).ready( function () {
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "aaData": [
* {
* "engine": "Trident",
* "browser": "Internet Explorer 4.0",
* "platform": "Win 95+",
* "version": 4,
* "grade": "X"
* },
* {
* "engine": "Trident",
* "browser": "Internet Explorer 5.0",
* "platform": "Win 95+",
* "version": 5,
* "grade": "C"
* }
* ],
* "aoColumns": [
* { "sTitle": "Engine", "mDataProp": "engine" },
* { "sTitle": "Browser", "mDataProp": "browser" },
* { "sTitle": "Platform", "mDataProp": "platform" },
* { "sTitle": "Version", "mDataProp": "version" },
* { "sTitle": "Grade", "mDataProp": "grade" }
* ]
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
* } );
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"aaData": null,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* If sorting is enabled, then DataTables will perform a first pass sort on
* initialisation. You can define which column(s) the sort is performed upon,
* and the sorting direction, with this variable. The aaSorting array should
* contain an array for each column to be sorted initially containing the
* column's index and a direction string ('asc' or 'desc').
* @type array
* @default [[0,'asc']]
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* // Sort by 3rd column first, and then 4th column
* $(document).ready( function() {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "aaSorting": [[2,'asc'], [3,'desc']]
* } );
* } );
*
* // No initial sorting
* $(document).ready( function() {
* $('#example').dataTable( {
* "aaSorting": []
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
* } );
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"aaSorting": [[0,'asc']],
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* This parameter is basically identical to the aaSorting parameter, but
* cannot be overridden by user interaction with the table. What this means
* is that you could have a column (visible or hidden) which the sorting will
* always be forced on first - any sorting after that (from the user) will
* then be performed as required. This can be useful for grouping rows
* together.
* @type array
* @default null
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* $(document).ready( function() {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "aaSortingFixed": [[0,'asc']]
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* } )
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"aaSortingFixed": null,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* This parameter allows you to readily specify the entries in the length drop
* down menu that DataTables shows when pagination is enabled. It can be
* either a 1D array of options which will be used for both the displayed
* option and the value, or a 2D array which will use the array in the first
* position as the value, and the array in the second position as the
* displayed options (useful for language strings such as 'All').
* @type array
* @default [ 10, 25, 50, 100 ]
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* $(document).ready(function() {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "aLengthMenu": [[10, 25, 50, -1], [10, 25, 50, "All"]]
* } );
* } );
*
* @example
* // Setting the default display length as well as length menu
* // This is likely to be wanted if you remove the '10' option which
* // is the iDisplayLength default.
* $(document).ready(function() {
* $('#example').dataTable( {
* "iDisplayLength": 25,
* "aLengthMenu": [[25, 50, 100, -1], [25, 50, 100, "All"]]
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
* } );
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"aLengthMenu": [ 10, 25, 50, 100 ],
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* The aoColumns option in the initialisation parameter allows you to define
* details about the way individual columns behave. For a full list of
* column options that can be set, please see
* {@link DataTable.models.oInitColumns}. Note that if you use aoColumns to
* define your columns, you must have an entry in the array for every single
* column that you have in your table (these can be null if you don't which
* to specify any options).
* @namespace
*/
"aoColumns": null,
/**
* Very similar to aoColumns, aoColumnDefs allows you to target a specific
* column, multiple columns, or all columns, using the aTargets property of
* each object in the array. This allows great flexibility when creating
* tables, as the aoColumnDefs arrays can be of any length, targeting the
* columns you specifically want. aoColumnDefs may use any of the column
* options available: {@link DataTable.models.oInitColumns}, but it _must_
* have aTargets defined in each object in the array. Values in the aTargets
* array may be:
* <ul>
* <li>a string - class name will be matched on the TH for the column</li>
* <li>0 or a positive integer - column index counting from the left</li>
* <li>a negative integer - column index counting from the right</li>
* <li>the string "_all" - all columns (i.e. assign a default)</li>
* </ul>
* @namespace
*/
"aoColumnDefs": null,
/**
* Basically the same as oSearch, this parameter defines the individual column
* filtering state at initialisation time. The array must be of the same size
* as the number of columns, and each element be an object with the parameters
* "sSearch" and "bEscapeRegex" (the latter is optional). 'null' is also
* accepted and the default will be used.
* @type array
* @default []
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* $(document).ready( function() {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "aoSearchCols": [
* null,
* { "sSearch": "My filter" },
* null,
* { "sSearch": "^[0-9]", "bEscapeRegex": false }
* ]
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* } )
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"aoSearchCols": [],
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* An array of CSS classes that should be applied to displayed rows. This
* array may be of any length, and DataTables will apply each class
* sequentially, looping when required.
* @type array
* @default [ 'odd', 'even' ]
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
* $(document).ready( function() {
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "asStripeClasses": [ 'strip1', 'strip2', 'strip3' ]
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* } )
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"asStripeClasses": [ 'odd', 'even' ],
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Enable or disable automatic column width calculation. This can be disabled
* as an optimisation (it takes some time to calculate the widths) if the
* tables widths are passed in using aoColumns.
* @type boolean
* @default true
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* $(document).ready( function () {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "bAutoWidth": false
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* } );
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"bAutoWidth": true,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Deferred rendering can provide DataTables with a huge speed boost when you
* are using an Ajax or JS data source for the table. This option, when set to
* true, will cause DataTables to defer the creation of the table elements for
* each row until they are needed for a draw - saving a significant amount of
* time.
* @type boolean
* @default false
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
* $(document).ready(function() {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* var oTable = $('#example').dataTable( {
* "sAjaxSource": "sources/arrays.txt",
* "bDeferRender": true
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
* } );
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"bDeferRender": false,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Replace a DataTable which matches the given selector and replace it with
* one which has the properties of the new initialisation object passed. If no
* table matches the selector, then the new DataTable will be constructed as
* per normal.
* @type boolean
* @default false
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* $(document).ready(function() {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "sScrollY": "200px",
* "bPaginate": false
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
*
* // Some time later....
* $('#example').dataTable( {
* "bFilter": false,
* "bDestroy": true
* } );
* } );
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"bDestroy": false,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Enable or disable filtering of data. Filtering in DataTables is "smart" in
* that it allows the end user to input multiple words (space separated) and
* will match a row containing those words, even if not in the order that was
* specified (this allow matching across multiple columns). Note that if you
* wish to use filtering in DataTables this must remain 'true' - to remove the
* default filtering input box and retain filtering abilities, please use
* @ref{sDom}.
* @type boolean
* @default true
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* $(document).ready( function () {
* $('#example').dataTable( {
* "bFilter": false
* } );
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"bFilter": true,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Enable or disable the table information display. This shows information
* about the data that is currently visible on the page, including information
* about filtered data if that action is being performed.
* @type boolean
* @default true
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* $(document).ready( function () {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "bInfo": false
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* } );
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"bInfo": true,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Enable jQuery UI ThemeRoller support (required as ThemeRoller requires some
* slightly different and additional mark-up from what DataTables has
* traditionally used).
* @type boolean
* @default false
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
* $(document).ready( function() {
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "bJQueryUI": true
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
* } );
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"bJQueryUI": false,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Allows the end user to select the size of a formatted page from a select
* menu (sizes are 10, 25, 50 and 100). Requires pagination (bPaginate).
* @type boolean
* @default true
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* $(document).ready( function () {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "bLengthChange": false
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
* } );
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"bLengthChange": true,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Enable or disable pagination.
* @type boolean
* @default true
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* $(document).ready( function () {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "bPaginate": false
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
* } );
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"bPaginate": true,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Enable or disable the display of a 'processing' indicator when the table is
* being processed (e.g. a sort). This is particularly useful for tables with
* large amounts of data where it can take a noticeable amount of time to sort
* the entries.
* @type boolean
* @default false
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* $(document).ready( function () {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "bProcessing": true
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
* } );
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"bProcessing": false,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Retrieve the DataTables object for the given selector. Note that if the
* table has already been initialised, this parameter will cause DataTables
* to simply return the object that has already been set up - it will not take
* account of any changes you might have made to the initialisation object
* passed to DataTables (setting this parameter to true is an acknowledgement
* that you understand this). bDestroy can be used to reinitialise a table if
* you need.
* @type boolean
* @default false
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* $(document).ready(function() {
* initTable();
* tableActions();
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
*
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* function initTable ()
* {
* return $('#example').dataTable( {
* "sScrollY": "200px",
* "bPaginate": false,
* "bRetrieve": true
* } );
* }
*
* function tableActions ()
* {
* var oTable = initTable();
* // perform API operations with oTable
* }
*/
"bRetrieve": false,
/**
* When vertical (y) scrolling is enabled, DataTables will force the height of
* the table's viewport to the given height at all times (useful for layout).
* However, this can look odd when filtering data down to a small data set,
* and the footer is left "floating" further down. This parameter (when
* enabled) will cause DataTables to collapse the table's viewport down when
* the result set will fit within the given Y height.
* @type boolean
* @default false
*
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* @example
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* $(document).ready(function() {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "sScrollY": "200",
* "bScrollCollapse": true
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
* } );
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"bScrollCollapse": false,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Enable infinite scrolling for DataTables (to be used in combination with
* sScrollY). Infinite scrolling means that DataTables will continually load
* data as a user scrolls through a table, which is very useful for large
* dataset. This cannot be used with pagination, which is automatically
* disabled.
* @type boolean
* @default false
*
* @example
* $(document).ready(function() {
* $('#example').dataTable( {
* "bScrollInfinite": true,
* "bScrollCollapse": true,
* "sScrollY": "200px"
* } );
* } );
*/
"bScrollInfinite": false,
/**
* Configure DataTables to use server-side processing. Note that the
* sAjaxSource parameter must also be given in order to give DataTables a
* source to obtain the required data for each draw.
* @type boolean
* @default false
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
* $(document).ready( function () {
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "bServerSide": true,
* "sAjaxSource": "xhr.php"
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
* } );
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
*/
"bServerSide": false,
/**
* Enable or disable sorting of columns. Sorting of individual columns can be
* disabled by the "bSortable" option for each column.
* @type boolean
* @default true
*
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* @example
* $(document).ready( function () {
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "bSort": false
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
* } );
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
*/
"bSort": true,
/**
* Allows control over whether DataTables should use the top (true) unique
* cell that is found for a single column, or the bottom (false - default).
* This is useful when using complex headers.
* @type boolean
* @default false
*
* @example
* $(document).ready(function() {
* $('#example').dataTable( {
* "bSortCellsTop": true
* } );
* } );
*/
"bSortCellsTop": false,
/**
* Enable or disable the addition of the classes 'sorting_1', 'sorting_2' and
* 'sorting_3' to the columns which are currently being sorted on. This is
* presented as a feature switch as it can increase processing time (while
* classes are removed and added) so for large data sets you might want to
* turn this off.
* @type boolean
* @default true
*
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* @example
* $(document).ready( function () {
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "bSortClasses": false
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
* } );
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"bSortClasses": true,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Enable or disable state saving. When enabled a cookie will be used to save
* table display information such as pagination information, display length,
* filtering and sorting. As such when the end user reloads the page the
* display display will match what thy had previously set up.
* @type boolean
* @default false
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* $(document).ready( function () {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "bStateSave": true
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* } );
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"bStateSave": false,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Customise the cookie and / or the parameters being stored when using
* DataTables with state saving enabled. This function is called whenever
* the cookie is modified, and it expects a fully formed cookie string to be
* returned. Note that the data object passed in is a Javascript object which
* must be converted to a string (JSON.stringify for example).
* @type function
* @param {string} sName Name of the cookie defined by DataTables
* @param {object} oData Data to be stored in the cookie
* @param {string} sExpires Cookie expires string
* @param {string} sPath Path of the cookie to set
* @returns {string} Cookie formatted string (which should be encoded by
* using encodeURIComponent())
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* $(document).ready( function () {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "fnCookieCallback": function (sName, oData, sExpires, sPath) {
* // Customise oData or sName or whatever else here
* return sName + "="+JSON.stringify(oData)+"; expires=" + sExpires +"; path=" + sPath;
* }
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
* } );
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"fnCookieCallback": null,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* This function is called on every 'draw' event, and allows you to
* dynamically modify any aspect you want about the created DOM.
* @type function
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
* $(document).ready( function() {
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "fnDrawCallback": function() {
* alert( 'DataTables has redrawn the table' );
* }
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* } );
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"fnDrawCallback": null,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Identical to fnHeaderCallback() but for the table footer this function
* allows you to modify the table footer on every 'draw' even.
* @type function
* @param {node} nFoot "TR" element for the footer
* @param {array} aData Full table data (as derived from the original HTML)
* @param {int} iStart Index for the current display starting point in the
* display array
* @param {int} iEnd Index for the current display ending point in the
* display array
* @param {array int} aiDisplay Index array to translate the visual position
* to the full data array
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
* $(document).ready( function() {
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "fnFooterCallback": function( nFoot, aData, iStart, iEnd, aiDisplay ) {
* nFoot.getElementsByTagName('th')[0].innerHTML = "Starting index is "+iStart;
* }
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
* } )
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"fnFooterCallback": null,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* When rendering large numbers in the information element for the table
* (i.e. "Showing 1 to 10 of 57 entries") DataTables will render large numbers
* to have a comma separator for the 'thousands' units (e.g. 1 million is
* rendered as "1,000,000") to help readability for the end user. This
* function will override the default method DataTables uses.
* @type function
* @param {int} iIn number to be formatted
* @returns {string} formatted string for DataTables to show the number
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
* $(document).ready(function() {
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "fnFormatNumber": function ( iIn ) {
* if ( iIn &lt; 1000 ) {
* return iIn;
* } else {
* var
* s=(iIn+""),
* a=s.split(""), out="",
* iLen=s.length;
*
* for ( var i=0 ; i&lt;iLen ; i++ ) {
* if ( i%3 === 0 &amp;&amp; i !== 0 ) {
* out = "'"+out;
* }
* out = a[iLen-i-1]+out;
* }
* }
* return out;
* };
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
* } );
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"fnFormatNumber": function ( iIn ) {
if ( iIn < 1000 )
{
// A small optimisation for what is likely to be the majority of use cases
return iIn;
}
else
{
var s=(iIn+""), a=s.split(""), out="", iLen=s.length;
for ( var i=0 ; i<iLen ; i++ )
{
if ( i%3 === 0 && i !== 0 )
{
out = this.oLanguage.sInfoThousands+out;
}
out = a[iLen-i-1]+out;
}
}
return out;
},
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* This function is called on every 'draw' event, and allows you to
* dynamically modify the header row. This can be used to calculate and
* display useful information about the table.
* @type function
* @param {node} nHead "TR" element for the header
* @param {array} aData Full table data (as derived from the original HTML)
* @param {int} iStart Index for the current display starting point in the
* display array
* @param {int} iEnd Index for the current display ending point in the
* display array
* @param {array int} aiDisplay Index array to translate the visual position
* to the full data array
*
* @example
* $(document).ready( function() {
* $('#example').dataTable( {
* "fnHeaderCallback": function( nHead, aData, iStart, iEnd, aiDisplay ) {
* nHead.getElementsByTagName('th')[0].innerHTML = "Displaying "+(iEnd-iStart)+" records";
* }
* } );
* } )
*/
"fnHeaderCallback": null,
/**
* The information element can be used to convey information about the current
* state of the table. Although the internationalisation options presented by
* DataTables are quite capable of dealing with most customisations, there may
* be times where you wish to customise the string further. This callback
* allows you to do exactly that.
* @type function
* @param {object} oSettings DataTables settings object
* @param {int} iStart Starting position in data for the draw
* @param {int} iEnd End position in data for the draw
* @param {int} iMax Total number of rows in the table (regardless of
* filtering)
* @param {int} iTotal Total number of rows in the data set, after filtering
* @param {string} sPre The string that DataTables has formatted using it's
* own rules
* @returns {string} The string to be displayed in the information element.
*
* @example
* $('#example').dataTable( {
* "fnInfoCallback": function( oSettings, iStart, iEnd, iMax, iTotal, sPre ) {
* return iStart +" to "+ iEnd;
* }
* } );
*/
"fnInfoCallback": null,
/**
* Called when the table has been initialised. Normally DataTables will
* initialise sequentially and there will be no need for this function,
* however, this does not hold true when using external language information
* since that is obtained using an async XHR call.
* @type function
* @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>
*
* @example
* $(document).ready( function() {
* $('#example').dataTable( {
* "fnInitComplete": function(oSettings, json) {
* alert( 'DataTables has finished its initialisation.' );
* }
* } );
* } )
*/
"fnInitComplete": null,
/**
* Called at the very start of each table draw and can be used to cancel the
* draw by returning false, any other return (including undefined) results in
* the full draw occurring).
* @type function
* @param {object} oSettings DataTables settings object
* @returns {boolean} False will cancel the draw, anything else (including no
* return) will allow it to complete.
*
* @example
* $(document).ready( function() {
* $('#example').dataTable( {
* "fnPreDrawCallback": function( oSettings ) {
* if ( $('#test').val() == 1 ) {
* return false;
* }
* }
* } );
* } );
*/
"fnPreDrawCallback": null,
/**
* This function allows you to 'post process' each row after it have been
* generated for each table draw, but before it is rendered on screen. This
* function might be used for setting the row class name etc.
* @type function
* @param {node} nRow "TR" element for the current row
* @param {array} aData Raw data array for this row
* @param {int} iDisplayIndex The display index for the current table draw
* @param {int} iDisplayIndexFull The index of the data in the full list of
* rows (after filtering)
* @returns {node} "TR" element for the current row
*
* @example
* $(document).ready(function() {
* $('#example').dataTable( {
* "fnRowCallback": function( nRow, aData, iDisplayIndex, iDisplayIndexFull ) {
* // Bold the grade for all 'A' grade browsers
* if ( aData[4] == "A" )
* {
* $('td:eq(4)', nRow).html( '<b>A</b>' );
* }
* return nRow;
* }
* } );
* } );
*/
"fnRowCallback": null,
/**
* This parameter allows you to override the default function which obtains
* the data from the server ($.getJSON) so something more suitable for your
* application. For example you could use POST data, or pull information from
* a Gears or AIR database.
* @type function
* @param {string} sSource HTTP source to obtain the data from (sAjaxSource)
* @param {array} aoData A key/value pair object containing the data to send
* to the server
* @param {function} fnCallback to be called on completion of the data get
* process that will draw the data on the page.
* @param {object} oSettings DataTables settings object
*
* @example
* // POST data to server
* $(document).ready(function() {
* $('#example').dataTable( {
* "bProcessing": true,
* "bServerSide": true,
* "sAjaxSource": "xhr.php",
* "fnServerData": function ( sSource, aoData, fnCallback ) {
* $.ajax( {
* "dataType": 'json',
* "type": "POST",
* "url": sSource,
* "data": aoData,
* "success": fnCallback
* } );
* }
* } );
* } );
*/
"fnServerData": function ( sUrl, aoData, fnCallback, oSettings ) {
oSettings.jqXHR = $.ajax( {
"url": sUrl,
"data": aoData,
"success": function (json) {
$(oSettings.oInstance).trigger('xhr', oSettings);
fnCallback( json );
},
"dataType": "json",
"cache": false,
"type": oSettings.sServerMethod,
"error": function (xhr, error, thrown) {
if ( error == "parsererror" ) {
alert( "DataTables warning: JSON data from server could not be parsed. "+
"This is caused by a JSON formatting error." );
}
}
} );
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
},
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* It is often useful to send extra data to the server when making an Ajax
* request - for example custom filtering information, and this callback
* function makes it trivial to send extra information to the server. The
* passed in parameter is the data set that has been constructed by
* DataTables, and you can add to this or modify it as you require.
* @type function
* @param {array} aoData Data array (array of objects which are name/value
* pairs) that has been constructed by DataTables and will be sent to the
* server. In the case of Ajax sourced data with server-side processing
* this will be an empty array, for server-side processing there will be a
* significant number of parameters!
* @returns {undefined} Ensure that you modify the aoData array passed in,
* as this is passed by reference.
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* $(document).ready(function() {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "bProcessing": true,
* "bServerSide": true,
* "sAjaxSource": "scripts/server_processing.php",
* "fnServerParams": function ( aoData ) {
* aoData.push( { "name": "more_data", "value": "my_value" } );
* }
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* } );
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"fnServerParams": null,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* State saving in DataTables is very useful, but it does a blanket save on
* all properties that the user can modify, so the table is restored. This
* callback method can be used to modify the saved properties as you require,
* just prior to them being loaded. This method can also be used to override
* the state loading altogether by returning false.
* @type function
* @param {object} oSettings DataTables settings object
* @param {object} oData Object containing information retrieved from the
* state saving cookie which should be restored. For the exact properties
* please refer to the DataTables code.
* @returns {boolean} false if the state should not be loaded, true otherwise
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* // Remove a previously saved filter
* $(document).ready( function () {
* $('#example').dataTable( {
* "bStateSave": true,
* "fnStateLoadCallback": function ( oSettings, oData ) {
* oData.sFilter = "";
* return true;
* }
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
* } );
*
* @example
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* // Override state loading
* $(document).ready( function () {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "bStateSave": true,
* "fnStateLoadCallback": function ( oSettings, oData ) {
* return false;
* }
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* } );
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"fnStateLoadCallback": null,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* When using state saving it can be useful to store your own custom
* parameters in the state saving cookie that DataTables uses, or to modify
* the settings that DataTables uses. Note that this function can be quite
* involved to use since it uses JSON notation in a string, given that jQuery
* does not provide a "stringify" option for JSON objects.
* @type function
* @param {object} oSettings DataTables settings object
* @param {string} sValue a JSON string (without the final closing brace)
* which should be stored in the state saving cookie.
* @returns {string} The full string that should be used to save the state
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* // Add a custom parameter
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* $(document).ready( function () {
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "bStateSave": true,
* "fnStateSaveCallback": function ( oSettings, sValue ) {
* sValue += ',"myCustomParameter": "myValue"';
* return sValue;
* }
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
* } );
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
*
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* @example
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* // Modify saved filter to be blank
* $(document).ready( function () {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "bStateSave": true,
* "fnStateSaveCallback": function ( oSettings, sValue ) {
* sValue = sValue.replace( /"sFilter":".*?"/, '"sFilter":""' );
* return sValue;
* }
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
* } );
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
*
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* @example
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* // Modify saved filter to be blank - using JSON2.js
* $(document).ready( function () {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "bStateSave": true,
* "fnStateSaveCallback": function ( oSettings, sValue ) {
* var oData = JSON.parse( sValue+"}" );
* oData.sFilter = "";
* return JSON.stringify( oData ).slice( 0, -1 );
* }
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
* } );
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"fnStateSaveCallback": null,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Duration of the cookie which is used for storing session information. This
* value is given in seconds.
* @type int
* @default 7200 <i>(2 hours)</i>
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
* $(document).ready( function() {
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "iCookieDuration": 60*60*24 // 1 day
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
* } )
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"iCookieDuration": 7200,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* When enabled DataTables will not make a request to the server for the first
* page draw - rather it will use the data already on the page (no sorting etc
* will be applied to it), thus saving on an XHR at load time. iDeferLoading
* is used to indicate that deferred loading is required, but it is also used
* to tell DataTables how many records there are in the full table (allowing
* the information element and pagination to be displayed correctly).
* @type int
* @default null
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
* $(document).ready(function() {
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "bServerSide": true,
* "sAjaxSource": "scripts/server_processing.php",
* "iDeferLoading": 57
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
* } );
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"iDeferLoading": null,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Number of rows to display on a single page when using pagination. If
* feature enabled (bLengthChange) then the end user will be able to override
* this to a custom setting using a pop-up menu.
* @type int
* @default 10
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* $(document).ready( function() {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "iDisplayLength": 50
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* } )
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"iDisplayLength": 10,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Add defaults for aDataSort and sServerMethod (the two new parameters that have been introduced since the last release)
2011-11-26 14:45:08 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Define the starting point for data display when using DataTables with
* pagination. Note that this parameter is the number of records, rather than
* the page number, so if you have 10 records per page and want to start on
* the third page, it should be "20".
* @type int
* @default 0
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*
* @example
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* $(document).ready( function() {
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "iDisplayStart": 20
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
* } );
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* } )
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"iDisplayStart": 0,
Add defaults for aDataSort and sServerMethod (the two new parameters that have been introduced since the last release)
2011-11-26 14:45:08 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* The scroll gap is the amount of scrolling that is left to go before
* DataTables will load the next 'page' of data automatically. You typically
* want a gap which is big enough that the scrolling will be smooth for the
* user, while not so large that it will load more data than need.
* @type int
* @default 100
Add defaults for aDataSort and sServerMethod (the two new parameters that have been introduced since the last release)
2011-11-26 14:45:08 +01:00
*
* @example
* $(document).ready(function() {
* $('#example').dataTable( {
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* "bScrollInfinite": true,
* "bScrollCollapse": true,
* "sScrollY": "200px",
* "iScrollLoadGap": 50
Add defaults for aDataSort and sServerMethod (the two new parameters that have been introduced since the last release)
2011-11-26 14:45:08 +01:00
* } );
* } );
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"iScrollLoadGap": 100,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* All strings that DataTables uses in the user interface that it creates
* are defined in this object, allowing you to modified them individually or
* completely replace them all as required.
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
* @namespace
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"oLanguage": {
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Pnagation string used by DataTables for the two built-in pagination
* control types ("two_button" and "full_numbers")
* @namespace
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"oPaginate": {
/**
* Text to use when using the 'full_numbers' type of pagination for the
* button
* to take the user to the first page.
* @type string
* @default First
*
* @example
* $(document).ready(function() {
* $('#example').dataTable( {
* "oLanguage": {
* "oPaginate": {
* "sFirst": "First page"
* }
* }
* } );
* } );
*/
"sFirst": "First",
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
/**
* Text to use when using the 'full_numbers' type of pagination for the
* button to take the user to the last page.
* @type string
* @default Last
*
* @example
* $(document).ready(function() {
* $('#example').dataTable( {
* "oLanguage": {
* "oPaginate": {
* "sLast": "Last page"
* }
* }
* } );
* } );
*/
"sLast": "Last",
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
/**
* Text to use when using the 'full_numbers' type of pagination for the
* button to take the user to the next page.
* @type string
* @default Next
*
* @example
* $(document).ready(function() {
* $('#example').dataTable( {
* "oLanguage": {
* "oPaginate": {
* "sNext": "Next page"
* }
* }
* } );
* } );
*/
"sNext": "Next",
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
/**
* Text to use when using the 'full_numbers' type of pagination for the
* button to take the user to the previous page.
* @type string
* @default Previous
*
* @example
* $(document).ready(function() {
* $('#example').dataTable( {
* "oLanguage": {
* "oPaginate": {
* "sPrevious": "Previous page"
* }
* }
* } );
* } );
*/
"sPrevious": "Previous",
},
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* This string is shown in preference to sZeroRecords when the table is
* empty of data (regardless of filtering). Note that this is an optional
* parameter - if it is not given, the value of sZeroRecords will be used
* instead (either the default or given value).
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
* @type string
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* @default No data available in table
*
* @example
* $(document).ready(function() {
* $('#example').dataTable( {
* "oLanguage": {
* "sEmptyTable": "No data available in table"
* }
* } );
* } );
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"sEmptyTable": "No data available in table",
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* This string gives information to the end user about the information that
* is current on display on the page. The _START_, _END_ and _TOTAL_
* variables are all dynamically replaced as the table display updates, and
* can be freely moved or removed as the language requirements change.
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
* @type string
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* @default Showing _START_ to _END_ of _TOTAL_ entries
*
* @example
* $(document).ready(function() {
* $('#example').dataTable( {
* "oLanguage": {
* "sInfo": "Got a total of _TOTAL_ entries to show (_START_ to _END_)"
* }
* } );
* } );
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"sInfo": "Showing _START_ to _END_ of _TOTAL_ entries",
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Display information string for when the table is empty. Typically the
* format of this string should match sInfo.
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
* @type string
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* @default Showing 0 to 0 of 0 entries
*
* @example
* $(document).ready(function() {
* $('#example').dataTable( {
* "oLanguage": {
* "sInfoEmpty": "No entries to show"
* }
* } );
* } );
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"sInfoEmpty": "Showing 0 to 0 of 0 entries",
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* When a user filters the information in a table, this string is appended
* to the information (sInfo) to give an idea of how strong the filtering
* is. The variable _MAX_ is dynamically updated.
* @type string
* @default (filtered from _MAX_ total entries)
*
* @example
* $(document).ready(function() {
* $('#example').dataTable( {
* "oLanguage": {
* "sInfoFiltered": " - filtering from _MAX_ records"
* }
* } );
* } );
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"sInfoFiltered": "(filtered from _MAX_ total entries)",
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
/**
* If can be useful to append extra information to the info string at times,
* and this variable does exactly that. This information will be appended to
* the sInfo (sInfoEmpty and sInfoFiltered in whatever combination they are
* being used) at all times.
* @type string
* @default <i>Empty string</i>
*
* @example
* $(document).ready(function() {
* $('#example').dataTable( {
* "oLanguage": {
* "sInfoPostFix": "All records shown are derived from real information."
* }
* } );
* } );
*/
"sInfoPostFix": "",
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
/**
* DataTables has a build in number formatter (fnFormatNumber) which is used
* to format large numbers that are used in the table information. By
* default a comma is used, but this can be trivially changed to any
* character you wish with this parameter.
* @type string
* @default ,
*
* @example
* $(document).ready(function() {
* $('#example').dataTable( {
* "oLanguage": {
* "sInfoThousands": "'"
* }
* } );
* } );
*/
"sInfoThousands": ",",
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
/**
* Detail the action that will be taken when the drop down menu for the
* pagination length option is changed. The '_MENU_' variable is replaced
* with a default select list of 10, 25, 50 and 100, and can be replaced
* with a custom select box if required.
* @type string
* @default Show _MENU_ entries
*
* @example
* // Language change only
* $(document).ready(function() {
* $('#example').dataTable( {
* "oLanguage": {
* "sLengthMenu": "Display _MENU_ records"
* }
* } );
* } );
*
* @example
* // Language and options change
* $(document).ready(function() {
* $('#example').dataTable( {
* "oLanguage": {
* "sLengthMenu": 'Display <select>'+
* '<option value="10">10</option>'+
* '<option value="20">20</option>'+
* '<option value="30">30</option>'+
* '<option value="40">40</option>'+
* '<option value="50">50</option>'+
* '<option value="-1">All</option>'+
* '</select> records'
* }
* } );
* } );
*/
"sLengthMenu": "Show _MENU_ entries",
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
/**
* When using Ajax sourced data and during the first draw when DataTables is
* gathering the data, this message is shown in an empty row in the table to
* indicate to the end user the the data is being loaded. Note that this
* parameter is not used when loading data by server-side processing, just
* Ajax sourced data with client-side processing.
* @type string
* @default Loading...
*
* @example
* $(document).ready( function() {
* $('#example').dataTable( {
* "oLanguage": {
* "sLoadingRecords": "Please wait - loading..."
* }
* } );
* } );
*/
"sLoadingRecords": "Loading...",
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
/**
* Text which is displayed when the table is processing a user action
* (usually a sort command or similar).
* @type string
* @default Processing...
*
* @example
* $(document).ready(function() {
* $('#example').dataTable( {
* "oLanguage": {
* "sProcessing": "DataTables is currently busy"
* }
* } );
* } );
*/
"sProcessing": "Processing...",
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
/**
* Details the actions that will be taken when the user types into the
* filtering input text box. The variable "_INPUT_", if used in the string,
* is replaced with the HTML text box for the filtering input allowing
* control over where it appears in the string. If "_INPUT_" is not given
* then the input box is appended to the string automatically.
* @type string
* @default Search:
*
* @example
* // Input text box will be appended at the end automatically
* $(document).ready(function() {
* $('#example').dataTable( {
* "oLanguage": {
* "sSearch": "Filter records:"
* }
* } );
* } );
*
* @example
* // Specify where the filter should appear
* $(document).ready(function() {
* $('#example').dataTable( {
* "oLanguage": {
* "sSearch": "Apply filter _INPUT_ to table"
* }
* } );
* } );
*/
"sSearch": "Search:",
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
/**
* All of the language information can be stored in a file on the
* server-side, which DataTables will look up if this parameter is passed.
* It must store the URL of the language file, which is in a JSON format,
* and the object has the same properties as the oLanguage object in the
* initialiser object (i.e. the above parameters). Please refer to one of
* the example language files to see how this works in action.
* @type string
* @default <i>Empty string - i.e. disabled</i>
*
* @example
* $(document).ready(function() {
* $('#example').dataTable( {
* "oLanguage": {
* "sUrl": "http://www.sprymedia.co.uk/dataTables/lang.txt"
* }
* } );
* } );
*/
"sUrl": "",
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
/**
* Text shown inside the table records when the is no information to be
* displayed after filtering. sEmptyTable is shown when there is simply no
* information in the table at all (regardless of filtering).
* @type string
* @default No matching records found
*
* @example
* $(document).ready(function() {
* $('#example').dataTable( {
* "oLanguage": {
* "sZeroRecords": "No records to display"
* }
* } );
* } );
*/
"sZeroRecords": "No matching records found",
},
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* This parameter allows you to have define the global filtering state at
* initialisation time. As an object the "sSearch" parameter must be
* defined, but the "bRegex" and "bSmart" parameters are optional. When
* "bRegex" is true, the search string will be treated as a regular
* expression, when false (default) it will be treated as a straight string.
* When "bSmart" DataTables will use it's smart filtering methods (to word
* match at any point in the data), when false this will not be done.
* @type object
* @extends DataTable.models.oSearch
*
* @example
* $(document).ready( function() {
* $('#example').dataTable( {
* "oSearch": {"sSearch": "Initial search"}
* } );
* } )
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"oSearch": $.extend( {}, DataTable.models.oSearch ),
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* By default DataTables will look for the property 'aaData' when obtaining
* data from an Ajax source or for server-side processing - this parameter
* allows that property to be changed. You can use Javascript dotted object
* notation to get a data source for multiple levels of nesting.
* @type string
* @default aaData
*
* @example
* // Get data from { "data": [...] }
* $(document).ready(function() {
* var oTable = $('#example').dataTable( {
* "sAjaxSource": "sources/data.txt",
* "sAjaxDataProp": "data"
* } );
* } );
*
* @example
* // Get data from { "data": { "inner": [...] } }
* $(document).ready(function() {
* var oTable = $('#example').dataTable( {
* "sAjaxSource": "sources/data.txt",
* "sAjaxDataProp": "data.inner"
* } );
* } );
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"sAjaxDataProp": "aaData",
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* You can instruct DataTables to load data from an external source using this
* parameter (use aData if you want to pass data in you already have). Simply
* provide a url a JSON object can be obtained from. This object must include
* the parameter 'aaData' which is a 2D array with the source data.
* @type string
* @default null
*
* @example
* $(document).ready( function() {
* $('#example').dataTable( {
* "sAjaxSource": "http://www.sprymedia.co.uk/dataTables/json.php"
* } );
* } )
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"sAjaxSource": null,
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Address from which DataTables should load the remote data from when using
* server-side processing. Note that sAjaxSource can also be used without
* server-side processing to indicate a "one time get" of JSON formatted data.
* @type string
* @default null
*
* @example
* $(document).ready( function () {
* $('#example').dataTable( {
* "bProcessing": false,
* "sAjaxSource": "xhr.php"
* } );
* } );
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"sAjaxSource": null,
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* This parameter can be used to override the default prefix that DataTables
* assigns to a cookie when state saving is enabled.
* @type string
* @default SpryMedia_DataTables_
*
* @example
* $(document).ready(function() {
* $('#example').dataTable( {
* "sCookiePrefix": "my_datatable_",
* } );
* } );
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"sCookiePrefix": "SpryMedia_DataTables_",
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* This initialisation variable allows you to specify exactly where in the
* DOM you want DataTables to inject the various controls it adds to the page
* (for example you might want the pagination controls at the top of the
* table). DIV elements (with or without a custom class) can also be added to
* aid styling. The follow syntax is used:
* <ul>
* <li>The following options are allowed:
* <ul>
* <li>'l' - Length changing</li
* <li>'f' - Filtering input</li>
* <li>'t' - The table!</li>
* <li>'i' - Information</li>
* <li>'p' - Pagination</li>
* <li>'r' - pRocessing</li>
* </ul>
* </li>
* <li>The following constants are allowed:
* <ul>
* <li>'H' - jQueryUI theme "header" classes ('fg-toolbar ui-widget-header ui-corner-tl ui-corner-tr ui-helper-clearfix')</li>
* <li>'F' - jQueryUI theme "footer" classes ('fg-toolbar ui-widget-header ui-corner-bl ui-corner-br ui-helper-clearfix')</li>
* </ul>
* </li>
* <li>The following syntax is expected:
* <ul>
* <li>'&lt;' and '&gt;' - div elements</li>
* <li>'&lt;"class" and '&gt;' - div with a class</li>
* <li>'&lt;"#id" and '&gt;' - div with an ID</li>
* </ul>
* </li>
* <li>Examples:
* <ul>
* <li>'&lt;"wrapper"flipt&gt;'</li>
* <li>'&lt;lf&lt;t&gt;ip&gt;'</li>
* </ul>
* </li>
* </ul>
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
* @type string
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* @default lfrtip <i>(when bJQueryUI is false)</i> <b>or</b>
* <"H"lfr>t<"F"ip> <i>(when bJQueryUI is true)</i>
*
* @example
* $(document).ready(function() {
* $('#example').dataTable( {
* "sDom": '&lt;"top"i&gt;rt&lt;"bottom"flp&gt;&lt;"clear"&lgt;'
* } );
* } );
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"sDom": "lfrtip",
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* DataTables features two different built-in pagination interaction methods
* ('two_button' or 'full_numbers') which present different page controls to
* the end user. Further methods can be added using the API (see below).
* @type string
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
* @default two_button
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
*
* @example
* $(document).ready( function() {
* $('#example').dataTable( {
* "sPaginationType": "full_numbers"
* } );
* } )
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
"sPaginationType": "two_button",
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Enable horizontal scrolling. When a table is too wide to fit into a certain
* layout, or you have a large number of columns in the table, you can enable
* x-scrolling to show the table in a viewport, which can be scrolled. This
* property can by any CSS unit, or a number (in which case it will be treated
* as a pixel measurement).
* @type string
* @default <i>blank string - i.e. disabled</i>
*
* @example
* $(document).ready(function() {
* $('#example').dataTable( {
* "sScrollX": "100%",
* "bScrollCollapse": true
* } );
* } );
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"sScrollX": "",
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* This property can be used to force a DataTable to use more width than it
* might otherwise do when x-scrolling is enabled. For example if you have a
* table which requires to be well spaced, this parameter is useful for
* "over-sizing" the table, and thus forcing scrolling. This property can by
* any CSS unit, or a number (in which case it will be treated as a pixel
* measurement).
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
* @type string
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* @default <i>blank string - i.e. disabled</i>
*
* @example
* $(document).ready(function() {
* $('#example').dataTable( {
* "sScrollX": "100%",
* "sScrollXInner": "110%"
* } );
* } );
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"sScrollXInner": "",
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Enable vertical scrolling. Vertical scrolling will constrain the DataTable
* to the given height, an enable scrolling for any data which overflows the
* current viewport. This can be used as an alternative to paging to display
* a lot of data in a small area (although paging and scrolling can both be
* enabled at the same time). This property can by any CSS unit, or a number
* (in which case it will be treated as a pixel measurement).
* @type string
* @default <i>blank string - i.e. disabled</i>
*
* @example
* $(document).ready(function() {
* $('#example').dataTable( {
* "sScrollY": "200px",
* "bPaginate": false
* } );
* } );
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"sScrollY": "",
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Set the HTTP method that is used to make the Ajax call for server-side
* processing or Ajax sourced data.
* @type string
* @default GET
*
* @example
* $(document).ready(function() {
* $('#example').dataTable( {
* "bServerSide": true,
* "sAjaxSource": "scripts/post.php",
* "sServerMethod": "POST"
* } );
* } );
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"sServerMethod": "GET"
};
/*
* Variable: dataTableSettings
* Purpose: Store the settings for each dataTables instance
* Scope: jQuery.fn
*/
var _aoSettings = [];
/**
* DataTables settings object - this holds all the information needed for a
* given table, including configuration, data and current application of the
* table options. DataTables does not have a single instance for each DataTable
* with the settings attached to that instance, but rather instances of the
* DataTable "class" are created on-the-fly as needed (typically by a
* $().dataTable() call) and the settings object is then applied to that
* instance.
*
* Note that this object is related to {@link DataTable.models.oInit} but this
* one is the internal data store for DataTables's cache of columns. It should
* NOT be manipulated outside of DataTables. Any configuration should be done
* through the initialisation options.
* @namespace
* @todo Really should attach the settings object to individual instances so we
* don't need to create new instances on each $().dataTable() call (if the
* table already exists). It would also save passing oSettings around and
* into every single function. However, this is a very significant
* architecture change for DataTables and will almost certainly break
* backwards compatibility with older installations. This is something that
* will be done in 2.0.
*/
DataTable.models.oSettings = {
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Primary features of DataTables and their enablement state.
* @namespace
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"oFeatures": {
/**
* Flag to say if DataTables should automatically try to calculate the
* optimum table and columns widths (true) or not (false).
* @type boolean
* @default true
*/
"bAutoWidth": true,
/**
* Delay the creation of TR and TD elements until they are actually
* needed by a driven page draw. This can give a significant speed
* increase for Ajax source and Javascript source data, but makes no
* difference at all fro DOM and server-side processing tables.
* @type boolean
* @default false
*/
"bDeferRender": false,
/**
* Enable filtering on the table or not. Note that if this is disabled
* then there is no filtering at all on the table, including fnFilter.
* To just remove the filtering input use sDom and remove the 'f' option
* @type boolean
* @default true
*/
"bFilter": true,
/**
* Table information element (the 'Showing x of y records' div) enable
* flag
* @type boolean
* @default true
*/
"bInfo": true,
/**
* Present a user control allowing the end user to change the page size
* when pagination is enabled.
* @type boolean
* @default true
*/
"bLengthChange": true,
/**
* Pagination enabled or not. Note that if this is disabled then length
* changing must also be disabled.
* @type boolean
* @default true
*/
"bPaginate": true,
/**
* Processing indicator enable flag whenever DataTables is enacting a
* user request - typically an Ajax request for server-side processing.
* @type boolean
* @default false
*/
"bProcessing": false,
/**
* Server-side processing enabled flag - when enabled DataTables will
* get all data from the server for every draw - there is no filtering,
* sorting or paging done on the client-side.
* @type boolean
* @default false
*/
"bServerSide": false,
/**
* Sorting enablement flag.
* @type boolean
* @default true
*/
"bSort": true,
/**
* Apply a class to the columns which are being sorted to provide a
* visual highlight or not. This can slow things down when enabled since
* there is a lot of DOM interaction.
* @type boolean
* @default true
*/
"bSortClasses": true,
/**
* State saving enablement flag.
* @type boolean
* @default false
*/
"bStateSave": false
},
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Scrolling settings for a table.
* @namespace
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"oScroll": {
/**
* Indicate if DataTables should be allowed to set the padding / margin
* etc for the scrolling header elements or not. Typically you will want
* this.
* @type boolean
* @default true
*/
"bAutoCss": true,
/**
* When the table is shorter in height than sScrollY, collapse the
* table container down to the height of the table (when true)
* @type boolean
* @default false
*/
"bCollapse": false,
/**
* Infinite scrolling enablement flag. Now deprecated in favour of
* using the Scroller plug-in.
* @type boolean
* @default false
* @deprecated
*/
"bInfinite": false,
/**
* Width of the scrollbar for the web-browser's platform. Calculated
* during table initialisation.
* @type int
* @default 0
*/
"iBarWidth": 0,
/**
* Space (in pixels) between the bottom of the scrolling container and
* the bottom of the scrolling viewport before the next page is loaded
* when using infinite scrolling.
* @type int
* @default 100
* @deprecated
*/
"iLoadGap": 100,
/**
* Viewport width for horizontal scrolling. Horizontal scrolling is
* disabled if an empty string.
* @type string
* @default <i>Empty string</i>
*/
"sX": "",
/**
* Width to expand the table to when using x-scrolling. Typically you
* should not need to use this.
* @type string
* @default <i>Empty string</i>
* @deprecated
*/
"sXInner": "",
/**
* Viewport height for vertical scrolling. Vertical scrolling is disabled
* if an empty string.
* @type string
* @default <i>Empty string</i>
*/
"sY": ""
},
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Language information for the table.
* @namespace
* @extends DataTable.models.oInit.oLanguage
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"oLanguage": {
/**
* Information callback function. See
* {@link DataTable.models.oInit.fnInfoCallback}
* @type function
* @default
*/
"fnInfoCallback": null
},
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Array referencing the nodes which are used for the features. The
* parameters of this object match what is allowed by sDom - i.e.
* <ul>
* <li>'l' - Length changing</li>
* <li>'f' - Filtering input</li>
* <li>'t' - The table!</li>
* <li>'i' - Information</li>
* <li>'p' - Pagination</li>
* <li>'r' - pRocessing</li>
* </ul>
* @type array
* @default []
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"aanFeatures": [],
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Store data information - see {@link DataTable.models.oRow} for detailed
* information.
* @type array
* @default []
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"aoData": [],
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Array of indexes which are in the current display (after filtering etc)
* @type array
* @default []
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"aiDisplay": [],
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Array of indexes for display - no filtering
* @type array
* @default []
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"aiDisplayMaster": [],
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Store information about each column that is in use
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
* @type array
* @default []
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"aoColumns": [],
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Store information about the table's header
* @type array
* @default []
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"aoHeader": [],
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Store information about the table's footer
* @type array
* @default []
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"aoFooter": [],
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Search data array for regular expression searching
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
* @type array
* @default []
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"asDataSearch": [],
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Store the applied global search information in case we want to force a
* research or compare the old search to a new one
* @namespace
* @extends DataTable.models.oSearch
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"oPreviousSearch": {},
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Store the applied search for each column - see
* {@link DataTable.models.oSearch} for the format that is used for the
* filtering information for each column.
* @type array
* @default []
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"aoPreSearchCols": [],
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Sorting that is applied to the table. Note that the inner arrays are
* used in the following manner:
* <ul>
* <li>Index 0 - column number</li>
* <li>Index 1 - current sorting direction</li>
* <li>Index 2 - index of asSorting for this column</li>
* </ul>
* @type array
* @default [[0, 'asc', 0]]
* @todo These inner arrays should really be objects
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"aaSorting": [[0, 'asc', 0]],
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Sorting that is always applied to the table (i.e. prefixed in front of
* aaSorting).
* @type array|null
* @default null
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"aaSortingFixed": null,
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Classes to use for the striping of a table
* @type array
* @default []
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"asStripeClasses": [],
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* If restoring a table - we should restore its striping classes as well
* @type array
* @default []
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"asDestroyStripes": [],
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* If restoring a table - we should restore its width
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
* @type int
* @default 0
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"sDestroyWidth": 0,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Call this function every time a row is inserted (draw)
* @type function
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
* @default null
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* @todo Make into an array so plug-ins can hook in
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"fnRowCallback": null,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Callback function for the header on each draw
* @type function
* @default null
* @todo Make into an array so plug-ins can hook in
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"fnHeaderCallback": null,
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Callback function for the footer on each draw
* @type function
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
* @default null
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* @todo Make into an array so plug-ins can hook in
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"fnFooterCallback": null,
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Array of callback functions for draw callback functions
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
* @type array
* @default []
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"aoDrawCallback": [],
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Callback function for just before the table is redrawn. A return of
* false will be used to cancel the draw.
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
* @type function
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* @default null
* @todo Make into an array so plug-ins can hook in
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"fnPreDrawCallback": null,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Callback function for when the table has been initialised
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
* @type function
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* @default null
* @todo Make into an array so plug-ins can hook in
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"fnInitComplete": null,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Cache the table ID for quick access
* @type string
* @default <i>Empty string</i>
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"sTableId": "",
/**
* The TABLE node for the main table
* @type node
* @default null
*/
"nTable": null,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Permanent ref to the thead element
* @type node
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
* @default null
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"nTHead": null,
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Permanent ref to the tfoot element - if it exists
* @type node
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
* @default null
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"nTFoot": null,
Document the row model and update the data methods to extend this model as the base for aoData
2011-11-26 15:04:58 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Permanent ref to the tbody element
Document the row model and update the data methods to extend this model as the base for aoData
2011-11-26 15:04:58 +01:00
* @type node
* @default null
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"nTBody": null,
Document the row model and update the data methods to extend this model as the base for aoData
2011-11-26 15:04:58 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Cache the wrapper node (contains all DataTables controlled elements)
* @type node
* @default null
Document the row model and update the data methods to extend this model as the base for aoData
2011-11-26 15:04:58 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"nTableWrapper": null,
Document the row model and update the data methods to extend this model as the base for aoData
2011-11-26 15:04:58 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Indicate if when using server-side processing the loading of data
* should be deferred until the second draw
* @type boolean
* @default false
*/
"bDeferLoading": false,
/**
* Indicate if all required information has been read in
* @type boolean
* @default false
*/
"bInitialised": false,
/**
* Information about open rows. Each object in the array has the parameters
* 'nTr' and 'nParent'
Document the row model and update the data methods to extend this model as the base for aoData
2011-11-26 15:04:58 +01:00
* @type array
* @default []
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"aoOpenRows": [],
Document the row model and update the data methods to extend this model as the base for aoData
2011-11-26 15:04:58 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Dictate the positioning of DataTables' control elements - see
* {@link DataTable.model.oInit.sDom}.
* @type string
* @default null
Document the row model and update the data methods to extend this model as the base for aoData
2011-11-26 15:04:58 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"sDom": null,
Document the row model and update the data methods to extend this model as the base for aoData
2011-11-26 15:04:58 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Which type of pagination should be used
* @type string
* @default two_button
*/
"sPaginationType": "two_button",
/**
* The cookie duration (for bStateSave) in seconds
* @type int
* @default 0
*/
"iCookieDuration": 0,
/**
* The cookie name prefix
Document the row model and update the data methods to extend this model as the base for aoData
2011-11-26 15:04:58 +01:00
* @type string
* @default <i>Empty string</i>
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"sCookiePrefix": "",
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Callback function for cookie creation
* @type function
* @default null
*/
"fnCookieCallback": null,
/**
* Array of callback functions for state saving. Each array element is an
* object with the following parameters:
* <ul>
* <li>function:fn - function to call. Takes two parameters, oSettings
* and the JSON string to save that has been thus far created. Returns
* a JSON string to be inserted into a json object
* (i.e. '"param": [ 0, 1, 2]')</li>
* <li>string:sName - name of callback</li>
* </ul>
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
* @type array
* @default []
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"aoStateSave": [],
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Array of callback functions for state loading. Each array element is an
* object with the following parameters:
* <ul>
* <li>function:fn - function to call. Takes two parameters, oSettings
* and the object stored. May return false to cancel state loading</li>
* <li>string:sName - name of callback</li>
* </ul>
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
* @type array
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* @default []
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"aoStateLoad": [],
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* State that was loaded from the cookie. Useful for back reference
* @type object
* @default null
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"oLoadedState": null,
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Source url for AJAX data for the table
* @type string
* @default null
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"sAjaxSource": null,
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Property from a given object from which to read the table data from. This
* can be an empty string (when not server-side processing), in which case
* it is assumed an an array is given directly.
* @type string
* @default aaData
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"sAjaxDataProp": 'aaData',
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Note if draw should be blocked while getting data
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
* @type boolean
* @default true
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"bAjaxDataGet": true,
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* The last jQuery XHR object that was used for server-side data gathering.
* This can be used for working with the XHR information in one of the
* callbacks
* @type object
* @default null
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"jqXHR": null,
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Function to get the server-side data
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
* @type function
* @default null
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"fnServerData": null,
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Functions which are called prior to sending an Ajax request so extra
* parameters can easily be sent to the server
* @type array
* @default []
*/
"aoServerParams": [],
/**
* Send the XHR HTTP method - GET or POST (could be PUT or DELETE if
* required)
* @type string
* @default GET
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"sServerMethod": "GET",
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Format numbers for display
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
* @type function
* @default null
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"fnFormatNumber": null,
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* List of options that can be used for the user selectable length menu
* @type array
* @default []
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"aLengthMenu": [],
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Counter for the draws that the table does. Also used as a tracker for
* server-side processing
* @type int
* @default 0
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"iDraw": 0,
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Indicate if a redraw is being done - useful for Ajax
* @type boolean
* @default false
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"bDrawing": false,
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Draw index (iDraw) of the last error when parsing the returned data
* @type int
* @default -1
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"iDrawError": -1,
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Paging display length
* @type int
* @default 10
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"_iDisplayLength": 10,
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Paging start point - aiDisplay index
* @type int
* @default 0
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"_iDisplayStart": 0,
/**
* Paging end point - aiDisplay index. Use fnDisplayEnd rather than
* this property to get the end point
* @type int
* @default 10
* @private
*/
"_iDisplayEnd": 10,
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Server-side processing - number of records in the result set
* (i.e. before filtering), Use fnRecordsTotal rather than
* this property to get the value of the number of records, regardless of
* the server-side processing setting.
* @type int
* @default 0
* @private
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"_iRecordsTotal": 0,
/**
* Server-side processing - number of records in the current display set
* (i.e. after filtering). Use fnRecordsDisplay rather than
* this property to get the value of the number of records, regardless of
* the server-side processing setting.
* @type boolean
* @default 0
* @private
*/
"_iRecordsDisplay": 0,
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Flag to indicate if jQuery UI marking and classes should be used
* @type boolean
* @default false
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"bJUI": false,
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* The classes to use for the table
* @type object
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
* @default null
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"oClasses": null,
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Flag attached to the settings object so you can check in the draw
* callback if filtering has been done in the draw. Deprecated in favour of
* events.
* @type boolean
* @default false
* @deprecated
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"bFiltered": false,
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Flag attached to the settings object so you can check in the draw
* callback if sorting has been done in the draw. Deprecated in favour of
* events.
* @type boolean
* @default false
* @deprecated
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"bSorted": false,
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Indicate that if multiple rows are in the header and there is more than
* one unique cell per column, if the top one (true) or bottom one (false)
* should be used for sorting / title by DataTables
* @type boolean
* @default false
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"bSortCellsTop": false,
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Initialisation object that is used for the table
* @type object
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
* @default null
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"oInit": null,
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Destroy callback functions - for plug-ins to attach themselves to the
* destroy so they can clean up markup and events.
* @type array
* @default []
Fix various comment spelling mistakes
2011-11-26 19:51:45 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"aoDestroyCallback": [],
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Get the number of records in the current record set, before filtering
* @type function
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"fnRecordsTotal": function ()
{
if ( this.oFeatures.bServerSide ) {
return parseInt(this._iRecordsTotal, 10);
} else {
return this.aiDisplayMaster.length;
}
},
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Get the number of records in the current record set, after filtering
* @type function
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"fnRecordsDisplay": function ()
{
if ( this.oFeatures.bServerSide ) {
return parseInt(this._iRecordsDisplay, 10);
} else {
return this.aiDisplay.length;
}
},
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
/**
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
* Set the display end point - aiDisplay index
* @type function
* @todo Should do away with _iDisplayEnd and calculate it on-the-fly here
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
*/
Use the oSearch model for the default initialisation and column initialisation
2011-11-27 19:51:56 +01:00
"fnDisplayEnd": function ()
{
if ( this.oFeatures.bServerSide ) {
if ( this.oFeatures.bPaginate === false || this._iDisplayLength == -1 ) {
return this._iDisplayStart+this.aiDisplay.length;
} else {
return Math.min( this._iDisplayStart+this._iDisplayLength,
this._iRecordsDisplay );
}
} else {
return this._iDisplayEnd;
}
},
/**
* The DataTables object for this table
* @type object
* @default null
*/
"oInstance": null,
/**
* Unique identifier for each instance of the DataTables object. If there
* is an ID on the table node, then it takes that value, otherwise an
* incrementing internal counter is used.
* @type string
* @default null
*/
"sInstance": null
Add JSDoc comments for the DataTables settings object
2011-11-27 18:50:06 +01:00
};
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
First pass are using $.extend for the settings and initialsation objects. Back into a state where the zero config will work
2011-11-25 18:08:21 +01:00
DataTable.ext = {};
Big change to how DataTables constructed in the file system - breaking the various parts of DataTables seperate files. This is probably the biggest individual change to DataTables since it was first written, but the code itself is more or less the same - just split out into different files. The one big change to the code thus far is to change the function classSettings into an object that is extended. More work is required on this to complete the alteration, but for now DataTables is building into the same workable form as before using the new make.sh file.
2011-11-24 15:05:22 +01:00
// jQuery aliases
$.fn.dataTable = DataTable;
$.fn.dataTableSettings = _aoSettings;
$.fn.dataTableExt = _oExt;
Initial commit - DataTables 1.7.0
2010-08-17 09:42:13 +02:00
})(jQuery, window, document);
Reference in New Issue Copy Permalink