| blob | 5b032aeec272270510b8608e62c1080280a8c560 |
1 /*! DataTables 1.10.12
2 * ©2008-2015 SpryMedia Ltd - datatables.net/license
3 */
5 /**
6 * @summary DataTables
7 * @description Paginate, search and order HTML tables
8 * @version 1.10.12
9 * @file jquery.dataTables.js
10 * @author SpryMedia Ltd (www.sprymedia.co.uk)
11 * @contact www.sprymedia.co.uk/contact
12 * @copyright Copyright 2008-2015 SpryMedia Ltd.
13 *
14 * This source file is free software, available under the following license:
15 * MIT license - http://datatables.net/license
16 *
17 * This source file is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
19 * or FITNESS FOR A PARTICULAR PURPOSE. See the license files for details.
20 *
21 * For details please refer to: http://www.datatables.net
22 */
24 /*jslint evil: true, undef: true, browser: true */
25 /*globals $,require,jQuery,define,_selector_run,_selector_opts,_selector_first,_selector_row_indexes,_ext,_Api,_api_register,_api_registerPlural,_re_new_lines,_re_html,_re_formatted_numeric,_re_escape_regex,_empty,_intVal,_numToDecimal,_isNumber,_isHtml,_htmlNumeric,_pluck,_pluck_order,_range,_stripHtml,_unique,_fnBuildAjax,_fnAjaxUpdate,_fnAjaxParameters,_fnAjaxUpdateDraw,_fnAjaxDataSrc,_fnAddColumn,_fnColumnOptions,_fnAdjustColumnSizing,_fnVisibleToColumnIndex,_fnColumnIndexToVisible,_fnVisbleColumns,_fnGetColumns,_fnColumnTypes,_fnApplyColumnDefs,_fnHungarianMap,_fnCamelToHungarian,_fnLanguageCompat,_fnBrowserDetect,_fnAddData,_fnAddTr,_fnNodeToDataIndex,_fnNodeToColumnIndex,_fnGetCellData,_fnSetCellData,_fnSplitObjNotation,_fnGetObjectDataFn,_fnSetObjectDataFn,_fnGetDataMaster,_fnClearTable,_fnDeleteIndex,_fnInvalidate,_fnGetRowElements,_fnCreateTr,_fnBuildHead,_fnDrawHead,_fnDraw,_fnReDraw,_fnAddOptionsHtml,_fnDetectHeader,_fnGetUniqueThs,_fnFeatureHtmlFilter,_fnFilterComplete,_fnFilterCustom,_fnFilterColumn,_fnFilter,_fnFilterCreateSearch,_fnEscapeRegex,_fnFilterData,_fnFeatureHtmlInfo,_fnUpdateInfo,_fnInfoMacros,_fnInitialise,_fnInitComplete,_fnLengthChange,_fnFeatureHtmlLength,_fnFeatureHtmlPaginate,_fnPageChange,_fnFeatureHtmlProcessing,_fnProcessingDisplay,_fnFeatureHtmlTable,_fnScrollDraw,_fnApplyToChildren,_fnCalculateColumnWidths,_fnThrottle,_fnConvertToWidth,_fnGetWidestNode,_fnGetMaxLenString,_fnStringToCss,_fnSortFlatten,_fnSort,_fnSortAria,_fnSortListener,_fnSortAttachListener,_fnSortingClasses,_fnSortData,_fnSaveState,_fnLoadState,_fnSettingsFromNode,_fnLog,_fnMap,_fnBindAction,_fnCallbackReg,_fnCallbackFire,_fnLengthOverflow,_fnRenderer,_fnDataSource,_fnRowAttributes*/
27 (function( factory ) {
28 "use strict";
30 if ( typeof define === 'function' && define.amd ) {
31 // AMD
32 define( ['jquery'], function ( $ ) {
33 return factory( $, window, document );
34 } );
35 }
36 else if ( typeof exports === 'object' ) {
37 // CommonJS
38 module.exports = function (root, $) {
39 if ( ! root ) {
40 // CommonJS environments without a window global must pass a
41 // root. This will give an error otherwise
42 root = window;
43 }
45 if ( ! $ ) {
46 $ = typeof window !== 'undefined' ? // jQuery's factory checks for a global window
47 require('jquery') :
48 require('jquery')( root );
49 }
51 return factory( $, root, root.document );
52 };
53 }
54 else {
55 // Browser
56 factory( jQuery, window, document );
57 }
58 }
59 (function( $, window, document, undefined ) {
60 "use strict";
62 /**
63 * DataTables is a plug-in for the jQuery Javascript library. It is a highly
64 * flexible tool, based upon the foundations of progressive enhancement,
65 * which will add advanced interaction controls to any HTML table. For a
66 * full list of features please refer to
67 * [DataTables.net](href="http://datatables.net).
68 *
69 * Note that the `DataTable` object is not a global variable but is aliased
70 * to `jQuery.fn.DataTable` and `jQuery.fn.dataTable` through which it may
71 * be accessed.
72 *
73 * @class
74 * @param {object} [init={}] Configuration object for DataTables. Options
75 * are defined by {@link DataTable.defaults}
76 * @requires jQuery 1.7+
77 *
78 * @example
79 * // Basic initialisation
80 * $(document).ready( function {
81 * $('#example').dataTable();
82 * } );
83 *
84 * @example
85 * // Initialisation with configuration options - in this case, disable
86 * // pagination and sorting.
87 * $(document).ready( function {
88 * $('#example').dataTable( {
89 * "paginate": false,
90 * "sort": false
91 * } );
92 * } );
93 */
94 var DataTable = function ( options )
95 {
96 /**
97 * Perform a jQuery selector action on the table's TR elements (from the tbody) and
98 * return the resulting jQuery object.
99 * @param {string|node|jQuery} sSelector jQuery selector or node collection to act on
100 * @param {object} [oOpts] Optional parameters for modifying the rows to be included
101 * @param {string} [oOpts.filter=none] Select TR elements that meet the current filter
102 * criterion ("applied") or all TR elements (i.e. no filter).
103 * @param {string} [oOpts.order=current] Order of the TR elements in the processed array.
104 * Can be either 'current', whereby the current sorting of the table is used, or
105 * 'original' whereby the original order the data was read into the table is used.
106 * @param {string} [oOpts.page=all] Limit the selection to the currently displayed page
107 * ("current") or not ("all"). If 'current' is given, then order is assumed to be
108 * 'current' and filter is 'applied', regardless of what they might be given as.
109 * @returns {object} jQuery object, filtered by the given selector.
110 * @dtopt API
111 * @deprecated Since v1.10
112 *
113 * @example
114 * $(document).ready(function() {
115 * var oTable = $('#example').dataTable();
116 *
117 * // Highlight every second row
118 * oTable.$('tr:odd').css('backgroundColor', 'blue');
119 * } );
120 *
121 * @example
122 * $(document).ready(function() {
123 * var oTable = $('#example').dataTable();
124 *
125 * // Filter to rows with 'Webkit' in them, add a background colour and then
126 * // remove the filter, thus highlighting the 'Webkit' rows only.
127 * oTable.fnFilter('Webkit');
128 * oTable.$('tr', {"search": "applied"}).css('backgroundColor', 'blue');
129 * oTable.fnFilter('');
130 * } );
131 */
132 this.$ = function ( sSelector, oOpts )
133 {
134 return this.api(true).$( sSelector, oOpts );
135 };
138 /**
139 * Almost identical to $ in operation, but in this case returns the data for the matched
140 * rows - as such, the jQuery selector used should match TR row nodes or TD/TH cell nodes
141 * rather than any descendants, so the data can be obtained for the row/cell. If matching
142 * rows are found, the data returned is the original data array/object that was used to
143 * create the row (or a generated array if from a DOM source).
144 *
145 * This method is often useful in-combination with $ where both functions are given the
146 * same parameters and the array indexes will match identically.
147 * @param {string|node|jQuery} sSelector jQuery selector or node collection to act on
148 * @param {object} [oOpts] Optional parameters for modifying the rows to be included
149 * @param {string} [oOpts.filter=none] Select elements that meet the current filter
150 * criterion ("applied") or all elements (i.e. no filter).
151 * @param {string} [oOpts.order=current] Order of the data in the processed array.
152 * Can be either 'current', whereby the current sorting of the table is used, or
153 * 'original' whereby the original order the data was read into the table is used.
154 * @param {string} [oOpts.page=all] Limit the selection to the currently displayed page
155 * ("current") or not ("all"). If 'current' is given, then order is assumed to be
156 * 'current' and filter is 'applied', regardless of what they might be given as.
157 * @returns {array} Data for the matched elements. If any elements, as a result of the
158 * selector, were not TR, TD or TH elements in the DataTable, they will have a null
159 * entry in the array.
160 * @dtopt API
161 * @deprecated Since v1.10
162 *
163 * @example
164 * $(document).ready(function() {
165 * var oTable = $('#example').dataTable();
166 *
167 * // Get the data from the first row in the table
168 * var data = oTable._('tr:first');
169 *
170 * // Do something useful with the data
171 * alert( "First cell is: "+data[0] );
172 * } );
173 *
174 * @example
175 * $(document).ready(function() {
176 * var oTable = $('#example').dataTable();
177 *
178 * // Filter to 'Webkit' and get all data for
179 * oTable.fnFilter('Webkit');
180 * var data = oTable._('tr', {"search": "applied"});
181 *
182 * // Do something with the data
183 * alert( data.length+" rows matched the search" );
184 * } );
185 */
186 this._ = function ( sSelector, oOpts )
187 {
188 return this.api(true).rows( sSelector, oOpts ).data();
189 };
192 /**
193 * Create a DataTables Api instance, with the currently selected tables for
194 * the Api's context.
195 * @param {boolean} [traditional=false] Set the API instance's context to be
196 * only the table referred to by the `DataTable.ext.iApiIndex` option, as was
197 * used in the API presented by DataTables 1.9- (i.e. the traditional mode),
198 * or if all tables captured in the jQuery object should be used.
199 * @return {DataTables.Api}
200 */
201 this.api = function ( traditional )
202 {
203 return traditional ?
204 new _Api(
205 _fnSettingsFromNode( this[ _ext.iApiIndex ] )
206 ) :
207 new _Api( this );
208 };
211 /**
212 * Add a single new row or multiple rows of data to the table. Please note
213 * that this is suitable for client-side processing only - if you are using
214 * server-side processing (i.e. "bServerSide": true), then to add data, you
215 * must add it to the data source, i.e. the server-side, through an Ajax call.
216 * @param {array|object} data The data to be added to the table. This can be:
217 * <ul>
218 * <li>1D array of data - add a single row with the data provided</li>
219 * <li>2D array of arrays - add multiple rows in a single call</li>
220 * <li>object - data object when using <i>mData</i></li>
221 * <li>array of objects - multiple data objects when using <i>mData</i></li>
222 * </ul>
223 * @param {bool} [redraw=true] redraw the table or not
224 * @returns {array} An array of integers, representing the list of indexes in
225 * <i>aoData</i> ({@link DataTable.models.oSettings}) that have been added to
226 * the table.
227 * @dtopt API
228 * @deprecated Since v1.10
229 *
230 * @example
231 * // Global var for counter
232 * var giCount = 2;
233 *
234 * $(document).ready(function() {
235 * $('#example').dataTable();
236 * } );
237 *
238 * function fnClickAddRow() {
239 * $('#example').dataTable().fnAddData( [
240 * giCount+".1",
241 * giCount+".2",
242 * giCount+".3",
243 * giCount+".4" ]
244 * );
245 *
246 * giCount++;
247 * }
248 */
249 this.fnAddData = function( data, redraw )
250 {
251 var api = this.api( true );
253 /* Check if we want to add multiple rows or not */
254 var rows = $.isArray(data) && ( $.isArray(data[0]) || $.isPlainObject(data[0]) ) ?
255 api.rows.add( data ) :
256 api.row.add( data );
258 if ( redraw === undefined || redraw ) {
259 api.draw();
260 }
262 return rows.flatten().toArray();
263 };
266 /**
267 * This function will make DataTables recalculate the column sizes, based on the data
268 * contained in the table and the sizes applied to the columns (in the DOM, CSS or
269 * through the sWidth parameter). This can be useful when the width of the table's
270 * parent element changes (for example a window resize).
271 * @param {boolean} [bRedraw=true] Redraw the table or not, you will typically want to
272 * @dtopt API
273 * @deprecated Since v1.10
274 *
275 * @example
276 * $(document).ready(function() {
277 * var oTable = $('#example').dataTable( {
278 * "sScrollY": "200px",
279 * "bPaginate": false
280 * } );
281 *
282 * $(window).bind('resize', function () {
283 * oTable.fnAdjustColumnSizing();
284 * } );
285 * } );
286 */
287 this.fnAdjustColumnSizing = function ( bRedraw )
288 {
289 var api = this.api( true ).columns.adjust();
290 var settings = api.settings()[0];
291 var scroll = settings.oScroll;
293 if ( bRedraw === undefined || bRedraw ) {
294 api.draw( false );
295 }
296 else if ( scroll.sX !== "" || scroll.sY !== "" ) {
297 /* If not redrawing, but scrolling, we want to apply the new column sizes anyway */
298 _fnScrollDraw( settings );
299 }
300 };
303 /**
304 * Quickly and simply clear a table
305 * @param {bool} [bRedraw=true] redraw the table or not
306 * @dtopt API
307 * @deprecated Since v1.10
308 *
309 * @example
310 * $(document).ready(function() {
311 * var oTable = $('#example').dataTable();
312 *
313 * // Immediately 'nuke' the current rows (perhaps waiting for an Ajax callback...)
314 * oTable.fnClearTable();
315 * } );
316 */
317 this.fnClearTable = function( bRedraw )
318 {
319 var api = this.api( true ).clear();
321 if ( bRedraw === undefined || bRedraw ) {
322 api.draw();
323 }
324 };
327 /**
328 * The exact opposite of 'opening' a row, this function will close any rows which
329 * are currently 'open'.
330 * @param {node} nTr the table row to 'close'
331 * @returns {int} 0 on success, or 1 if failed (can't find the row)
332 * @dtopt API
333 * @deprecated Since v1.10
334 *
335 * @example
336 * $(document).ready(function() {
337 * var oTable;
338 *
339 * // 'open' an information row when a row is clicked on
340 * $('#example tbody tr').click( function () {
341 * if ( oTable.fnIsOpen(this) ) {
342 * oTable.fnClose( this );
343 * } else {
344 * oTable.fnOpen( this, "Temporary row opened", "info_row" );
345 * }
346 * } );
347 *
348 * oTable = $('#example').dataTable();
349 * } );
350 */
351 this.fnClose = function( nTr )
352 {
353 this.api( true ).row( nTr ).child.hide();
354 };
357 /**
358 * Remove a row for the table
359 * @param {mixed} target The index of the row from aoData to be deleted, or
360 * the TR element you want to delete
361 * @param {function|null} [callBack] Callback function
362 * @param {bool} [redraw=true] Redraw the table or not
363 * @returns {array} The row that was deleted
364 * @dtopt API
365 * @deprecated Since v1.10
366 *
367 * @example
368 * $(document).ready(function() {
369 * var oTable = $('#example').dataTable();
370 *
371 * // Immediately remove the first row
372 * oTable.fnDeleteRow( 0 );
373 * } );
374 */
375 this.fnDeleteRow = function( target, callback, redraw )
376 {
377 var api = this.api( true );
378 var rows = api.rows( target );
379 var settings = rows.settings()[0];
380 var data = settings.aoData[ rows[0][0] ];
382 rows.remove();
384 if ( callback ) {
385 callback.call( this, settings, data );
386 }
388 if ( redraw === undefined || redraw ) {
389 api.draw();
390 }
392 return data;
393 };
396 /**
397 * Restore the table to it's original state in the DOM by removing all of DataTables
398 * enhancements, alterations to the DOM structure of the table and event listeners.
399 * @param {boolean} [remove=false] Completely remove the table from the DOM
400 * @dtopt API
401 * @deprecated Since v1.10
402 *
403 * @example
404 * $(document).ready(function() {
405 * // This example is fairly pointless in reality, but shows how fnDestroy can be used
406 * var oTable = $('#example').dataTable();
407 * oTable.fnDestroy();
408 * } );
409 */
410 this.fnDestroy = function ( remove )
411 {
412 this.api( true ).destroy( remove );
413 };
416 /**
417 * Redraw the table
418 * @param {bool} [complete=true] Re-filter and resort (if enabled) the table before the draw.
419 * @dtopt API
420 * @deprecated Since v1.10
421 *
422 * @example
423 * $(document).ready(function() {
424 * var oTable = $('#example').dataTable();
425 *
426 * // Re-draw the table - you wouldn't want to do it here, but it's an example :-)
427 * oTable.fnDraw();
428 * } );
429 */
430 this.fnDraw = function( complete )
431 {
432 // Note that this isn't an exact match to the old call to _fnDraw - it takes
433 // into account the new data, but can hold position.
434 this.api( true ).draw( complete );
435 };
438 /**
439 * Filter the input based on data
440 * @param {string} sInput String to filter the table on
441 * @param {int|null} [iColumn] Column to limit filtering to
442 * @param {bool} [bRegex=false] Treat as regular expression or not
443 * @param {bool} [bSmart=true] Perform smart filtering or not
444 * @param {bool} [bShowGlobal=true] Show the input global filter in it's input box(es)
445 * @param {bool} [bCaseInsensitive=true] Do case-insensitive matching (true) or not (false)
446 * @dtopt API
447 * @deprecated Since v1.10
448 *
449 * @example
450 * $(document).ready(function() {
451 * var oTable = $('#example').dataTable();
452 *
453 * // Sometime later - filter...
454 * oTable.fnFilter( 'test string' );
455 * } );
456 */
457 this.fnFilter = function( sInput, iColumn, bRegex, bSmart, bShowGlobal, bCaseInsensitive )
458 {
459 var api = this.api( true );
461 if ( iColumn === null || iColumn === undefined ) {
462 api.search( sInput, bRegex, bSmart, bCaseInsensitive );
463 }
464 else {
465 api.column( iColumn ).search( sInput, bRegex, bSmart, bCaseInsensitive );
466 }
468 api.draw();
469 };
472 /**
473 * Get the data for the whole table, an individual row or an individual cell based on the
474 * provided parameters.
475 * @param {int|node} [src] A TR row node, TD/TH cell node or an integer. If given as
476 * a TR node then the data source for the whole row will be returned. If given as a
477 * TD/TH cell node then iCol will be automatically calculated and the data for the
478 * cell returned. If given as an integer, then this is treated as the aoData internal
479 * data index for the row (see fnGetPosition) and the data for that row used.
480 * @param {int} [col] Optional column index that you want the data of.
481 * @returns {array|object|string} If mRow is undefined, then the data for all rows is
482 * returned. If mRow is defined, just data for that row, and is iCol is
483 * defined, only data for the designated cell is returned.
484 * @dtopt API
485 * @deprecated Since v1.10
486 *
487 * @example
488 * // Row data
489 * $(document).ready(function() {
490 * oTable = $('#example').dataTable();
491 *
492 * oTable.$('tr').click( function () {
493 * var data = oTable.fnGetData( this );
494 * // ... do something with the array / object of data for the row
495 * } );
496 * } );
497 *
498 * @example
499 * // Individual cell data
500 * $(document).ready(function() {
501 * oTable = $('#example').dataTable();
502 *
503 * oTable.$('td').click( function () {
504 * var sData = oTable.fnGetData( this );
505 * alert( 'The cell clicked on had the value of '+sData );
506 * } );
507 * } );
508 */
509 this.fnGetData = function( src, col )
510 {
511 var api = this.api( true );
513 if ( src !== undefined ) {
514 var type = src.nodeName ? src.nodeName.toLowerCase() : '';
516 return col !== undefined || type == 'td' || type == 'th' ?
517 api.cell( src, col ).data() :
518 api.row( src ).data() || null;
519 }
521 return api.data().toArray();
522 };
525 /**
526 * Get an array of the TR nodes that are used in the table's body. Note that you will
527 * typically want to use the '$' API method in preference to this as it is more
528 * flexible.
529 * @param {int} [iRow] Optional row index for the TR element you want
530 * @returns {array|node} If iRow is undefined, returns an array of all TR elements
531 * in the table's body, or iRow is defined, just the TR element requested.
532 * @dtopt API
533 * @deprecated Since v1.10
534 *
535 * @example
536 * $(document).ready(function() {
537 * var oTable = $('#example').dataTable();
538 *
539 * // Get the nodes from the table
540 * var nNodes = oTable.fnGetNodes( );
541 * } );
542 */
543 this.fnGetNodes = function( iRow )
544 {
545 var api = this.api( true );
547 return iRow !== undefined ?
548 api.row( iRow ).node() :
549 api.rows().nodes().flatten().toArray();
550 };
553 /**
554 * Get the array indexes of a particular cell from it's DOM element
555 * and column index including hidden columns
556 * @param {node} node this can either be a TR, TD or TH in the table's body
557 * @returns {int} If nNode is given as a TR, then a single index is returned, or
558 * if given as a cell, an array of [row index, column index (visible),
559 * column index (all)] is given.
560 * @dtopt API
561 * @deprecated Since v1.10
562 *
563 * @example
564 * $(document).ready(function() {
565 * $('#example tbody td').click( function () {
566 * // Get the position of the current data from the node
567 * var aPos = oTable.fnGetPosition( this );
568 *
569 * // Get the data array for this row
570 * var aData = oTable.fnGetData( aPos[0] );
571 *
572 * // Update the data array and return the value
573 * aData[ aPos[1] ] = 'clicked';
574 * this.innerHTML = 'clicked';
575 * } );
576 *
577 * // Init DataTables
578 * oTable = $('#example').dataTable();
579 * } );
580 */
581 this.fnGetPosition = function( node )
582 {
583 var api = this.api( true );
584 var nodeName = node.nodeName.toUpperCase();
586 if ( nodeName == 'TR' ) {
587 return api.row( node ).index();
588 }
589 else if ( nodeName == 'TD' || nodeName == 'TH' ) {
590 var cell = api.cell( node ).index();
592 return [
593 cell.row,
594 cell.columnVisible,
595 cell.column
596 ];
597 }
598 return null;
599 };
602 /**
603 * Check to see if a row is 'open' or not.
604 * @param {node} nTr the table row to check
605 * @returns {boolean} true if the row is currently open, false otherwise
606 * @dtopt API
607 * @deprecated Since v1.10
608 *
609 * @example
610 * $(document).ready(function() {
611 * var oTable;
612 *
613 * // 'open' an information row when a row is clicked on
614 * $('#example tbody tr').click( function () {
615 * if ( oTable.fnIsOpen(this) ) {
616 * oTable.fnClose( this );
617 * } else {
618 * oTable.fnOpen( this, "Temporary row opened", "info_row" );
619 * }
620 * } );
621 *
622 * oTable = $('#example').dataTable();
623 * } );
624 */
625 this.fnIsOpen = function( nTr )
626 {
627 return this.api( true ).row( nTr ).child.isShown();
628 };
631 /**
632 * This function will place a new row directly after a row which is currently
633 * on display on the page, with the HTML contents that is passed into the
634 * function. This can be used, for example, to ask for confirmation that a
635 * particular record should be deleted.
636 * @param {node} nTr The table row to 'open'
637 * @param {string|node|jQuery} mHtml The HTML to put into the row
638 * @param {string} sClass Class to give the new TD cell
639 * @returns {node} The row opened. Note that if the table row passed in as the
640 * first parameter, is not found in the table, this method will silently
641 * return.
642 * @dtopt API
643 * @deprecated Since v1.10
644 *
645 * @example
646 * $(document).ready(function() {
647 * var oTable;
648 *
649 * // 'open' an information row when a row is clicked on
650 * $('#example tbody tr').click( function () {
651 * if ( oTable.fnIsOpen(this) ) {
652 * oTable.fnClose( this );
653 * } else {
654 * oTable.fnOpen( this, "Temporary row opened", "info_row" );
655 * }
656 * } );
657 *
658 * oTable = $('#example').dataTable();
659 * } );
660 */
661 this.fnOpen = function( nTr, mHtml, sClass )
662 {
663 return this.api( true )
664 .row( nTr )
665 .child( mHtml, sClass )
666 .show()
667 .child()[0];
668 };
671 /**
672 * Change the pagination - provides the internal logic for pagination in a simple API
673 * function. With this function you can have a DataTables table go to the next,
674 * previous, first or last pages.
675 * @param {string|int} mAction Paging action to take: "first", "previous", "next" or "last"
676 * or page number to jump to (integer), note that page 0 is the first page.
677 * @param {bool} [bRedraw=true] Redraw the table or not
678 * @dtopt API
679 * @deprecated Since v1.10
680 *
681 * @example
682 * $(document).ready(function() {
683 * var oTable = $('#example').dataTable();
684 * oTable.fnPageChange( 'next' );
685 * } );
686 */
687 this.fnPageChange = function ( mAction, bRedraw )
688 {
689 var api = this.api( true ).page( mAction );
691 if ( bRedraw === undefined || bRedraw ) {
692 api.draw(false);
693 }
694 };
697 /**
698 * Show a particular column
699 * @param {int} iCol The column whose display should be changed
700 * @param {bool} bShow Show (true) or hide (false) the column
701 * @param {bool} [bRedraw=true] Redraw the table or not
702 * @dtopt API
703 * @deprecated Since v1.10
704 *
705 * @example
706 * $(document).ready(function() {
707 * var oTable = $('#example').dataTable();
708 *
709 * // Hide the second column after initialisation
710 * oTable.fnSetColumnVis( 1, false );
711 * } );
712 */
713 this.fnSetColumnVis = function ( iCol, bShow, bRedraw )
714 {
715 var api = this.api( true ).column( iCol ).visible( bShow );
717 if ( bRedraw === undefined || bRedraw ) {
718 api.columns.adjust().draw();
719 }
720 };
723 /**
724 * Get the settings for a particular table for external manipulation
725 * @returns {object} DataTables settings object. See
726 * {@link DataTable.models.oSettings}
727 * @dtopt API
728 * @deprecated Since v1.10
729 *
730 * @example
731 * $(document).ready(function() {
732 * var oTable = $('#example').dataTable();
733 * var oSettings = oTable.fnSettings();
734 *
735 * // Show an example parameter from the settings
736 * alert( oSettings._iDisplayStart );
737 * } );
738 */
739 this.fnSettings = function()
740 {
741 return _fnSettingsFromNode( this[_ext.iApiIndex] );
742 };
745 /**
746 * Sort the table by a particular column
747 * @param {int} iCol the data index to sort on. Note that this will not match the
748 * 'display index' if you have hidden data entries
749 * @dtopt API
750 * @deprecated Since v1.10
751 *
752 * @example
753 * $(document).ready(function() {
754 * var oTable = $('#example').dataTable();
755 *
756 * // Sort immediately with columns 0 and 1
757 * oTable.fnSort( [ [0,'asc'], [1,'asc'] ] );
758 * } );
759 */
760 this.fnSort = function( aaSort )
761 {
762 this.api( true ).order( aaSort ).draw();
763 };
766 /**
767 * Attach a sort listener to an element for a given column
768 * @param {node} nNode the element to attach the sort listener to
769 * @param {int} iColumn the column that a click on this node will sort on
770 * @param {function} [fnCallback] callback function when sort is run
771 * @dtopt API
772 * @deprecated Since v1.10
773 *
774 * @example
775 * $(document).ready(function() {
776 * var oTable = $('#example').dataTable();
777 *
778 * // Sort on column 1, when 'sorter' is clicked on
779 * oTable.fnSortListener( document.getElementById('sorter'), 1 );
780 * } );
781 */
782 this.fnSortListener = function( nNode, iColumn, fnCallback )
783 {
784 this.api( true ).order.listener( nNode, iColumn, fnCallback );
785 };
788 /**
789 * Update a table cell or row - this method will accept either a single value to
790 * update the cell with, an array of values with one element for each column or
791 * an object in the same format as the original data source. The function is
792 * self-referencing in order to make the multi column updates easier.
793 * @param {object|array|string} mData Data to update the cell/row with
794 * @param {node|int} mRow TR element you want to update or the aoData index
795 * @param {int} [iColumn] The column to update, give as null or undefined to
796 * update a whole row.
797 * @param {bool} [bRedraw=true] Redraw the table or not
798 * @param {bool} [bAction=true] Perform pre-draw actions or not
799 * @returns {int} 0 on success, 1 on error
800 * @dtopt API
801 * @deprecated Since v1.10
802 *
803 * @example
804 * $(document).ready(function() {
805 * var oTable = $('#example').dataTable();
806 * oTable.fnUpdate( 'Example update', 0, 0 ); // Single cell
807 * oTable.fnUpdate( ['a', 'b', 'c', 'd', 'e'], $('tbody tr')[0] ); // Row
808 * } );
809 */
810 this.fnUpdate = function( mData, mRow, iColumn, bRedraw, bAction )
811 {
812 var api = this.api( true );
814 if ( iColumn === undefined || iColumn === null ) {
815 api.row( mRow ).data( mData );
816 }
817 else {
818 api.cell( mRow, iColumn ).data( mData );
819 }
821 if ( bAction === undefined || bAction ) {
822 api.columns.adjust();
823 }
825 if ( bRedraw === undefined || bRedraw ) {
826 api.draw();
827 }
828 return 0;
829 };
832 /**
833 * Provide a common method for plug-ins to check the version of DataTables being used, in order
834 * to ensure compatibility.
835 * @param {string} sVersion Version string to check for, in the format "X.Y.Z". Note that the
836 * formats "X" and "X.Y" are also acceptable.
837 * @returns {boolean} true if this version of DataTables is greater or equal to the required
838 * version, or false if this version of DataTales is not suitable
839 * @method
840 * @dtopt API
841 * @deprecated Since v1.10
842 *
843 * @example
844 * $(document).ready(function() {
845 * var oTable = $('#example').dataTable();
846 * alert( oTable.fnVersionCheck( '1.9.0' ) );
847 * } );
848 */
849 this.fnVersionCheck = _ext.fnVersionCheck;
852 var _that = this;
853 var emptyInit = options === undefined;
854 var len = this.length;
856 if ( emptyInit ) {
857 options = {};
858 }
860 this.oApi = this.internal = _ext.internal;
862 // Extend with old style plug-in API methods
863 for ( var fn in DataTable.ext.internal ) {
864 if ( fn ) {
865 this[fn] = _fnExternApiFunc(fn);
866 }
867 }
869 this.each(function() {
870 // For each initialisation we want to give it a clean initialisation
871 // object that can be bashed around
872 var o = {};
873 var oInit = len > 1 ? // optimisation for single table case
874 _fnExtend( o, options, true ) :
875 options;
877 /*global oInit,_that,emptyInit*/
878 var i=0, iLen, j, jLen, k, kLen;
879 var sId = this.getAttribute( 'id' );
880 var bInitHandedOff = false;
881 var defaults = DataTable.defaults;
882 var $this = $(this);
885 /* Sanity check */
886 if ( this.nodeName.toLowerCase() != 'table' )
887 {
888 _fnLog( null, 0, 'Non-table node initialisation ('+this.nodeName+')', 2 );
889 return;
890 }
892 /* Backwards compatibility for the defaults */
893 _fnCompatOpts( defaults );
894 _fnCompatCols( defaults.column );
896 /* Convert the camel-case defaults to Hungarian */
897 _fnCamelToHungarian( defaults, defaults, true );
898 _fnCamelToHungarian( defaults.column, defaults.column, true );
900 /* Setting up the initialisation object */
901 _fnCamelToHungarian( defaults, $.extend( oInit, $this.data() ) );
905 /* Check to see if we are re-initialising a table */
906 var allSettings = DataTable.settings;
907 for ( i=0, iLen=allSettings.length ; i<iLen ; i++ )
908 {
909 var s = allSettings[i];
911 /* Base check on table node */
912 if ( s.nTable == this || s.nTHead.parentNode == this || (s.nTFoot && s.nTFoot.parentNode == this) )
913 {
914 var bRetrieve = oInit.bRetrieve !== undefined ? oInit.bRetrieve : defaults.bRetrieve;
915 var bDestroy = oInit.bDestroy !== undefined ? oInit.bDestroy : defaults.bDestroy;
917 if ( emptyInit || bRetrieve )
918 {
919 return s.oInstance;
920 }
921 else if ( bDestroy )
922 {
923 s.oInstance.fnDestroy();
924 break;
925 }
926 else
927 {
928 _fnLog( s, 0, 'Cannot reinitialise DataTable', 3 );
929 return;
930 }
931 }
933 /* If the element we are initialising has the same ID as a table which was previously
934 * initialised, but the table nodes don't match (from before) then we destroy the old
935 * instance by simply deleting it. This is under the assumption that the table has been
936 * destroyed by other methods. Anyone using non-id selectors will need to do this manually
937 */
938 if ( s.sTableId == this.id )
939 {
940 allSettings.splice( i, 1 );
941 break;
942 }
943 }
945 /* Ensure the table has an ID - required for accessibility */
946 if ( sId === null || sId === "" )
947 {
948 sId = "DataTables_Table_"+(DataTable.ext._unique++);
949 this.id = sId;
950 }
952 /* Create the settings object for this table and set some of the default parameters */
953 var oSettings = $.extend( true, {}, DataTable.models.oSettings, {
954 "sDestroyWidth": $this[0].style.width,
955 "sInstance": sId,
956 "sTableId": sId
957 } );
958 oSettings.nTable = this;
959 oSettings.oApi = _that.internal;
960 oSettings.oInit = oInit;
962 allSettings.push( oSettings );
964 // Need to add the instance after the instance after the settings object has been added
965 // to the settings array, so we can self reference the table instance if more than one
966 oSettings.oInstance = (_that.length===1) ? _that : $this.dataTable();
968 // Backwards compatibility, before we apply all the defaults
969 _fnCompatOpts( oInit );
971 if ( oInit.oLanguage )
972 {
973 _fnLanguageCompat( oInit.oLanguage );
974 }
976 // If the length menu is given, but the init display length is not, use the length menu
977 if ( oInit.aLengthMenu && ! oInit.iDisplayLength )
978 {
979 oInit.iDisplayLength = $.isArray( oInit.aLengthMenu[0] ) ?
980 oInit.aLengthMenu[0][0] : oInit.aLengthMenu[0];
981 }
983 // Apply the defaults and init options to make a single init object will all
984 // options defined from defaults and instance options.
985 oInit = _fnExtend( $.extend( true, {}, defaults ), oInit );
988 // Map the initialisation options onto the settings object
989 _fnMap( oSettings.oFeatures, oInit, [
990 "bPaginate",
991 "bLengthChange",
992 "bFilter",
993 "bSort",
994 "bSortMulti",
995 "bInfo",
996 "bProcessing",
997 "bAutoWidth",
998 "bSortClasses",
999 "bServerSide",
1000 "bDeferRender"
1001 ] );
1002 _fnMap( oSettings, oInit, [
1003 "asStripeClasses",
1004 "ajax",
1005 "fnServerData",
1006 "fnFormatNumber",
1007 "sServerMethod",
1008 "aaSorting",
1009 "aaSortingFixed",
1010 "aLengthMenu",
1011 "sPaginationType",
1012 "sAjaxSource",
1013 "sAjaxDataProp",
1014 "iStateDuration",
1015 "sDom",
1016 "bSortCellsTop",
1017 "iTabIndex",
1018 "fnStateLoadCallback",
1019 "fnStateSaveCallback",
1020 "renderer",
1021 "searchDelay",
1022 "rowId",
1023 [ "iCookieDuration", "iStateDuration" ], // backwards compat
1024 [ "oSearch", "oPreviousSearch" ],
1025 [ "aoSearchCols", "aoPreSearchCols" ],
1026 [ "iDisplayLength", "_iDisplayLength" ],
1027 [ "bJQueryUI", "bJUI" ]
1028 ] );
1029 _fnMap( oSettings.oScroll, oInit, [
1030 [ "sScrollX", "sX" ],
1031 [ "sScrollXInner", "sXInner" ],
1032 [ "sScrollY", "sY" ],
1033 [ "bScrollCollapse", "bCollapse" ]
1034 ] );
1035 _fnMap( oSettings.oLanguage, oInit, "fnInfoCallback" );
1037 /* Callback functions which are array driven */
1038 _fnCallbackReg( oSettings, 'aoDrawCallback', oInit.fnDrawCallback, 'user' );
1039 _fnCallbackReg( oSettings, 'aoServerParams', oInit.fnServerParams, 'user' );
1040 _fnCallbackReg( oSettings, 'aoStateSaveParams', oInit.fnStateSaveParams, 'user' );
1041 _fnCallbackReg( oSettings, 'aoStateLoadParams', oInit.fnStateLoadParams, 'user' );
1042 _fnCallbackReg( oSettings, 'aoStateLoaded', oInit.fnStateLoaded, 'user' );
1043 _fnCallbackReg( oSettings, 'aoRowCallback', oInit.fnRowCallback, 'user' );
1044 _fnCallbackReg( oSettings, 'aoRowCreatedCallback', oInit.fnCreatedRow, 'user' );
1045 _fnCallbackReg( oSettings, 'aoHeaderCallback', oInit.fnHeaderCallback, 'user' );
1046 _fnCallbackReg( oSettings, 'aoFooterCallback', oInit.fnFooterCallback, 'user' );
1047 _fnCallbackReg( oSettings, 'aoInitComplete', oInit.fnInitComplete, 'user' );
1048 _fnCallbackReg( oSettings, 'aoPreDrawCallback', oInit.fnPreDrawCallback, 'user' );
1050 oSettings.rowIdFn = _fnGetObjectDataFn( oInit.rowId );
1052 /* Browser support detection */
1053 _fnBrowserDetect( oSettings );
1055 var oClasses = oSettings.oClasses;
1057 // @todo Remove in 1.11
1058 if ( oInit.bJQueryUI )
1059 {
1060 /* Use the JUI classes object for display. You could clone the oStdClasses object if
1061 * you want to have multiple tables with multiple independent classes
1062 */
1063 $.extend( oClasses, DataTable.ext.oJUIClasses, oInit.oClasses );
1065 if ( oInit.sDom === defaults.sDom && defaults.sDom === "lfrtip" )
1066 {
1067 /* Set the DOM to use a layout suitable for jQuery UI's theming */
1068 oSettings.sDom = '<"H"lfr>t<"F"ip>';
1069 }
1071 if ( ! oSettings.renderer ) {
1072 oSettings.renderer = 'jqueryui';
1073 }
1074 else if ( $.isPlainObject( oSettings.renderer ) && ! oSettings.renderer.header ) {
1075 oSettings.renderer.header = 'jqueryui';
1076 }
1077 }
1078 else
1079 {
1080 $.extend( oClasses, DataTable.ext.classes, oInit.oClasses );
1081 }
1082 $this.addClass( oClasses.sTable );
1085 if ( oSettings.iInitDisplayStart === undefined )
1086 {
1087 /* Display start point, taking into account the save saving */
1088 oSettings.iInitDisplayStart = oInit.iDisplayStart;
1089 oSettings._iDisplayStart = oInit.iDisplayStart;
1090 }
1092 if ( oInit.iDeferLoading !== null )
1093 {
1094 oSettings.bDeferLoading = true;
1095 var tmp = $.isArray( oInit.iDeferLoading );
1096 oSettings._iRecordsDisplay = tmp ? oInit.iDeferLoading[0] : oInit.iDeferLoading;
1097 oSettings._iRecordsTotal = tmp ? oInit.iDeferLoading[1] : oInit.iDeferLoading;
1098 }
1100 /* Language definitions */
1101 var oLanguage = oSettings.oLanguage;
1102 $.extend( true, oLanguage, oInit.oLanguage );
1104 if ( oLanguage.sUrl !== "" )
1105 {
1106 /* Get the language definitions from a file - because this Ajax call makes the language
1107 * get async to the remainder of this function we use bInitHandedOff to indicate that
1108 * _fnInitialise will be fired by the returned Ajax handler, rather than the constructor
1109 */
1110 $.ajax( {
1111 dataType: 'json',
1112 url: oLanguage.sUrl,
1113 success: function ( json ) {
1114 _fnLanguageCompat( json );
1115 _fnCamelToHungarian( defaults.oLanguage, json );
1116 $.extend( true, oLanguage, json );
1117 _fnInitialise( oSettings );
1118 },
1119 error: function () {
1120 // Error occurred loading language file, continue on as best we can
1121 _fnInitialise( oSettings );
1122 }
1123 } );
1124 bInitHandedOff = true;
1125 }
1127 /*
1128 * Stripes
1129 */
1130 if ( oInit.asStripeClasses === null )
1131 {
1132 oSettings.asStripeClasses =[
1133 oClasses.sStripeOdd,
1134 oClasses.sStripeEven
1135 ];
1136 }
1138 /* Remove row stripe classes if they are already on the table row */
1139 var stripeClasses = oSettings.asStripeClasses;
1140 var rowOne = $this.children('tbody').find('tr').eq(0);
1141 if ( $.inArray( true, $.map( stripeClasses, function(el, i) {
1142 return rowOne.hasClass(el);
1143 } ) ) !== -1 ) {
1144 $('tbody tr', this).removeClass( stripeClasses.join(' ') );
1145 oSettings.asDestroyStripes = stripeClasses.slice();
1146 }
1148 /*
1149 * Columns
1150 * See if we should load columns automatically or use defined ones
1151 */
1152 var anThs = [];
1153 var aoColumnsInit;
1154 var nThead = this.getElementsByTagName('thead');
1155 if ( nThead.length !== 0 )
1156 {
1157 _fnDetectHeader( oSettings.aoHeader, nThead[0] );
1158 anThs = _fnGetUniqueThs( oSettings );
1159 }
1161 /* If not given a column array, generate one with nulls */
1162 if ( oInit.aoColumns === null )
1163 {
1164 aoColumnsInit = [];
1165 for ( i=0, iLen=anThs.length ; i<iLen ; i++ )
1166 {
1167 aoColumnsInit.push( null );
1168 }
1169 }
1170 else
1171 {
1172 aoColumnsInit = oInit.aoColumns;
1173 }
1175 /* Add the columns */
1176 for ( i=0, iLen=aoColumnsInit.length ; i<iLen ; i++ )
1177 {
1178 _fnAddColumn( oSettings, anThs ? anThs[i] : null );
1179 }
1181 /* Apply the column definitions */
1182 _fnApplyColumnDefs( oSettings, oInit.aoColumnDefs, aoColumnsInit, function (iCol, oDef) {
1183 _fnColumnOptions( oSettings, iCol, oDef );
1184 } );
1186 /* HTML5 attribute detection - build an mData object automatically if the
1187 * attributes are found
1188 */
1189 if ( rowOne.length ) {
1190 var a = function ( cell, name ) {
1191 return cell.getAttribute( 'data-'+name ) !== null ? name : null;
1192 };
1194 $( rowOne[0] ).children('th, td').each( function (i, cell) {
1195 var col = oSettings.aoColumns[i];
1197 if ( col.mData === i ) {
1198 var sort = a( cell, 'sort' ) || a( cell, 'order' );
1199 var filter = a( cell, 'filter' ) || a( cell, 'search' );
1201 if ( sort !== null || filter !== null ) {
1202 col.mData = {
1203 _: i+'.display',
1204 sort: sort !== null ? i+'.@data-'+sort : undefined,
1205 type: sort !== null ? i+'.@data-'+sort : undefined,
1206 filter: filter !== null ? i+'.@data-'+filter : undefined
1207 };
1209 _fnColumnOptions( oSettings, i );
1210 }
1211 }
1212 } );
1213 }
1215 var features = oSettings.oFeatures;
1217 /* Must be done after everything which can be overridden by the state saving! */
1218 if ( oInit.bStateSave )
1219 {
1220 features.bStateSave = true;
1221 _fnLoadState( oSettings, oInit );
1222 _fnCallbackReg( oSettings, 'aoDrawCallback', _fnSaveState, 'state_save' );
1223 }
1226 /*
1227 * Sorting
1228 * @todo For modularisation (1.11) this needs to do into a sort start up handler
1229 */
1231 // If aaSorting is not defined, then we use the first indicator in asSorting
1232 // in case that has been altered, so the default sort reflects that option
1233 if ( oInit.aaSorting === undefined )
1234 {
1235 var sorting = oSettings.aaSorting;
1236 for ( i=0, iLen=sorting.length ; i<iLen ; i++ )
1237 {
1238 sorting[i][1] = oSettings.aoColumns[ i ].asSorting[0];
1239 }
1240 }
1242 /* Do a first pass on the sorting classes (allows any size changes to be taken into
1243 * account, and also will apply sorting disabled classes if disabled
1244 */
1245 _fnSortingClasses( oSettings );
1247 if ( features.bSort )
1248 {
1249 _fnCallbackReg( oSettings, 'aoDrawCallback', function () {
1250 if ( oSettings.bSorted ) {
1251 var aSort = _fnSortFlatten( oSettings );
1252 var sortedColumns = {};
1254 $.each( aSort, function (i, val) {
1255 sortedColumns[ val.src ] = val.dir;
1256 } );
1258 _fnCallbackFire( oSettings, null, 'order', [oSettings, aSort, sortedColumns] );
1259 _fnSortAria( oSettings );
1260 }
1261 } );
1262 }
1264 _fnCallbackReg( oSettings, 'aoDrawCallback', function () {
1265 if ( oSettings.bSorted || _fnDataSource( oSettings ) === 'ssp' || features.bDeferRender ) {
1266 _fnSortingClasses( oSettings );
1267 }
1268 }, 'sc' );
1271 /*
1272 * Final init
1273 * Cache the header, body and footer as required, creating them if needed
1274 */
1276 // Work around for Webkit bug 83867 - store the caption-side before removing from doc
1277 var captions = $this.children('caption').each( function () {
1278 this._captionSide = $this.css('caption-side');
1279 } );
1281 var thead = $this.children('thead');
1282 if ( thead.length === 0 )
1283 {
1284 thead = $('<thead/>').appendTo(this);
1285 }
1286 oSettings.nTHead = thead[0];
1288 var tbody = $this.children('tbody');
1289 if ( tbody.length === 0 )
1290 {
1291 tbody = $('<tbody/>').appendTo(this);
1292 }
1293 oSettings.nTBody = tbody[0];
1295 var tfoot = $this.children('tfoot');
1296 if ( tfoot.length === 0 && captions.length > 0 && (oSettings.oScroll.sX !== "" || oSettings.oScroll.sY !== "") )
1297 {
1298 // If we are a scrolling table, and no footer has been given, then we need to create
1299 // a tfoot element for the caption element to be appended to
1300 tfoot = $('<tfoot/>').appendTo(this);
1301 }
1303 if ( tfoot.length === 0 || tfoot.children().length === 0 ) {
1304 $this.addClass( oClasses.sNoFooter );
1305 }
1306 else if ( tfoot.length > 0 ) {
1307 oSettings.nTFoot = tfoot[0];
1308 _fnDetectHeader( oSettings.aoFooter, oSettings.nTFoot );
1309 }
1311 /* Check if there is data passing into the constructor */
1312 if ( oInit.aaData )
1313 {
1314 for ( i=0 ; i<oInit.aaData.length ; i++ )
1315 {
1316 _fnAddData( oSettings, oInit.aaData[ i ] );
1317 }
1318 }
1319 else if ( oSettings.bDeferLoading || _fnDataSource( oSettings ) == 'dom' )
1320 {
1321 /* Grab the data from the page - only do this when deferred loading or no Ajax
1322 * source since there is no point in reading the DOM data if we are then going
1323 * to replace it with Ajax data
1324 */
1325 _fnAddTr( oSettings, $(oSettings.nTBody).children('tr') );
1326 }
1328 /* Copy the data index array */
1329 oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
1331 /* Initialisation complete - table can be drawn */
1332 oSettings.bInitialised = true;
1334 /* Check if we need to initialise the table (it might not have been handed off to the
1335 * language processor)
1336 */
1337 if ( bInitHandedOff === false )
1338 {
1339 _fnInitialise( oSettings );
1340 }
1341 } );
1342 _that = null;
1343 return this;
1344 };
1347 /*
1348 * It is useful to have variables which are scoped locally so only the
1349 * DataTables functions can access them and they don't leak into global space.
1350 * At the same time these functions are often useful over multiple files in the
1351 * core and API, so we list, or at least document, all variables which are used
1352 * by DataTables as private variables here. This also ensures that there is no
1353 * clashing of variable names and that they can easily referenced for reuse.
1354 */
1357 // Defined else where
1358 // _selector_run
1359 // _selector_opts
1360 // _selector_first
1361 // _selector_row_indexes
1363 var _ext; // DataTable.ext
1364 var _Api; // DataTable.Api
1365 var _api_register; // DataTable.Api.register
1366 var _api_registerPlural; // DataTable.Api.registerPlural
1368 var _re_dic = {};
1369 var _re_new_lines = /[\r\n]/g;
1370 var _re_html = /<.*?>/g;
1371 var _re_date_start = /^[\w\+\-]/;
1372 var _re_date_end = /[\w\+\-]$/;
1374 // Escape regular expression special characters
1375 var _re_escape_regex = new RegExp( '(\\' + [ '/', '.', '*', '+', '?', '|', '(', ')', '[', ']', '{', '}', '\\', '$', '^', '-' ].join('|\\') + ')', 'g' );
1377 // http://en.wikipedia.org/wiki/Foreign_exchange_market
1378 // - \u20BD - Russian ruble.
1379 // - \u20a9 - South Korean Won
1380 // - \u20BA - Turkish Lira
1381 // - \u20B9 - Indian Rupee
1382 // - R - Brazil (R$) and South Africa
1383 // - fr - Swiss Franc
1384 // - kr - Swedish krona, Norwegian krone and Danish krone
1385 // - \u2009 is thin space and \u202F is narrow no-break space, both used in many
1386 // standards as thousands separators.
1387 var _re_formatted_numeric = /[',$£€¥%\u2009\u202F\u20BD\u20a9\u20BArfk]/gi;
1390 var _empty = function ( d ) {
1391 return !d || d === true || d === '-' ? true : false;
1392 };
1395 var _intVal = function ( s ) {
1396 var integer = parseInt( s, 10 );
1397 return !isNaN(integer) && isFinite(s) ? integer : null;
1398 };
1400 // Convert from a formatted number with characters other than `.` as the
1401 // decimal place, to a Javascript number
1402 var _numToDecimal = function ( num, decimalPoint ) {
1403 // Cache created regular expressions for speed as this function is called often
1404 if ( ! _re_dic[ decimalPoint ] ) {
1405 _re_dic[ decimalPoint ] = new RegExp( _fnEscapeRegex( decimalPoint ), 'g' );
1406 }
1407 return typeof num === 'string' && decimalPoint !== '.' ?
1408 num.replace( /\./g, '' ).replace( _re_dic[ decimalPoint ], '.' ) :
1409 num;
1410 };
1413 var _isNumber = function ( d, decimalPoint, formatted ) {
1414 var strType = typeof d === 'string';
1416 // If empty return immediately so there must be a number if it is a
1417 // formatted string (this stops the string "k", or "kr", etc being detected
1418 // as a formatted number for currency
1419 if ( _empty( d ) ) {
1420 return true;
1421 }
1423 if ( decimalPoint && strType ) {
1424 d = _numToDecimal( d, decimalPoint );
1425 }
1427 if ( formatted && strType ) {
1428 d = d.replace( _re_formatted_numeric, '' );
1429 }
1431 return !isNaN( parseFloat(d) ) && isFinite( d );
1432 };
1435 // A string without HTML in it can be considered to be HTML still
1436 var _isHtml = function ( d ) {
1437 return _empty( d ) || typeof d === 'string';
1438 };
1441 var _htmlNumeric = function ( d, decimalPoint, formatted ) {
1442 if ( _empty( d ) ) {
1443 return true;
1444 }
1446 var html = _isHtml( d );
1447 return ! html ?
1448 null :
1449 _isNumber( _stripHtml( d ), decimalPoint, formatted ) ?
1450 true :
1451 null;
1452 };
1455 var _pluck = function ( a, prop, prop2 ) {
1456 var out = [];
1457 var i=0, ien=a.length;
1459 // Could have the test in the loop for slightly smaller code, but speed
1460 // is essential here
1461 if ( prop2 !== undefined ) {
1462 for ( ; i<ien ; i++ ) {
1463 if ( a[i] && a[i][ prop ] ) {
1464 out.push( a[i][ prop ][ prop2 ] );
1465 }
1466 }
1467 }
1468 else {
1469 for ( ; i<ien ; i++ ) {
1470 if ( a[i] ) {
1471 out.push( a[i][ prop ] );
1472 }
1473 }
1474 }
1476 return out;
1477 };
1480 // Basically the same as _pluck, but rather than looping over `a` we use `order`
1481 // as the indexes to pick from `a`
1482 var _pluck_order = function ( a, order, prop, prop2 )
1483 {
1484 var out = [];
1485 var i=0, ien=order.length;
1487 // Could have the test in the loop for slightly smaller code, but speed
1488 // is essential here
1489 if ( prop2 !== undefined ) {
1490 for ( ; i<ien ; i++ ) {
1491 if ( a[ order[i] ][ prop ] ) {
1492 out.push( a[ order[i] ][ prop ][ prop2 ] );
1493 }
1494 }
1495 }
1496 else {
1497 for ( ; i<ien ; i++ ) {
1498 out.push( a[ order[i] ][ prop ] );
1499 }
1500 }
1502 return out;
1503 };
1506 var _range = function ( len, start )
1507 {
1508 var out = [];
1509 var end;
1511 if ( start === undefined ) {
1512 start = 0;
1513 end = len;
1514 }
1515 else {
1516 end = start;
1517 start = len;
1518 }
1520 for ( var i=start ; i<end ; i++ ) {
1521 out.push( i );
1522 }
1524 return out;
1525 };
1528 var _removeEmpty = function ( a )
1529 {
1530 var out = [];
1532 for ( var i=0, ien=a.length ; i<ien ; i++ ) {
1533 if ( a[i] ) { // careful - will remove all falsy values!
1534 out.push( a[i] );
1535 }
1536 }
1538 return out;
1539 };
1542 var _stripHtml = function ( d ) {
1543 return d.replace( _re_html, '' );
1544 };
1547 /**
1548 * Find the unique elements in a source array.
1549 *
1550 * @param {array} src Source array
1551 * @return {array} Array of unique items
1552 * @ignore
1553 */
1554 var _unique = function ( src )
1555 {
1556 // A faster unique method is to use object keys to identify used values,
1557 // but this doesn't work with arrays or objects, which we must also
1558 // consider. See jsperf.com/compare-array-unique-versions/4 for more
1559 // information.
1560 var
1561 out = [],
1562 val,
1563 i, ien=src.length,
1564 j, k=0;
1566 again: for ( i=0 ; i<ien ; i++ ) {
1567 val = src[i];
1569 for ( j=0 ; j<k ; j++ ) {
1570 if ( out[j] === val ) {
1571 continue again;
1572 }
1573 }
1575 out.push( val );
1576 k++;
1577 }
1579 return out;
1580 };
1583 /**
1584 * DataTables utility methods
1585 *
1586 * This namespace provides helper methods that DataTables uses internally to
1587 * create a DataTable, but which are not exclusively used only for DataTables.
1588 * These methods can be used by extension authors to save the duplication of
1589 * code.
1590 *
1591 * @namespace
1592 */
1593 DataTable.util = {
1594 /**
1595 * Throttle the calls to a function. Arguments and context are maintained
1596 * for the throttled function.
1597 *
1598 * @param {function} fn Function to be called
1599 * @param {integer} freq Call frequency in mS
1600 * @return {function} Wrapped function
1601 */
1602 throttle: function ( fn, freq ) {
1603 var
1604 frequency = freq !== undefined ? freq : 200,
1605 last,
1606 timer;
1608 return function () {
1609 var
1610 that = this,
1611 now = +new Date(),
1612 args = arguments;
1614 if ( last && now < last + frequency ) {
1615 clearTimeout( timer );
1617 timer = setTimeout( function () {
1618 last = undefined;
1619 fn.apply( that, args );
1620 }, frequency );
1621 }
1622 else {
1623 last = now;
1624 fn.apply( that, args );
1625 }
1626 };
1627 },
1630 /**
1631 * Escape a string such that it can be used in a regular expression
1632 *
1633 * @param {string} val string to escape
1634 * @returns {string} escaped string
1635 */
1636 escapeRegex: function ( val ) {
1637 return val.replace( _re_escape_regex, '\\$1' );
1638 }
1639 };
1643 /**
1644 * Create a mapping object that allows camel case parameters to be looked up
1645 * for their Hungarian counterparts. The mapping is stored in a private
1646 * parameter called `_hungarianMap` which can be accessed on the source object.
1647 * @param {object} o
1648 * @memberof DataTable#oApi
1649 */
1650 function _fnHungarianMap ( o )
1651 {
1652 var
1653 hungarian = 'a aa ai ao as b fn i m o s ',
1654 match,
1655 newKey,
1656 map = {};
1658 $.each( o, function (key, val) {
1659 match = key.match(/^([^A-Z]+?)([A-Z])/);
1661 if ( match && hungarian.indexOf(match[1]+' ') !== -1 )
1662 {
1663 newKey = key.replace( match[0], match[2].toLowerCase() );
1664 map[ newKey ] = key;
1666 if ( match[1] === 'o' )
1667 {
1668 _fnHungarianMap( o[key] );
1669 }
1670 }
1671 } );
1673 o._hungarianMap = map;
1674 }
1677 /**
1678 * Convert from camel case parameters to Hungarian, based on a Hungarian map
1679 * created by _fnHungarianMap.
1680 * @param {object} src The model object which holds all parameters that can be
1681 * mapped.
1682 * @param {object} user The object to convert from camel case to Hungarian.
1683 * @param {boolean} force When set to `true`, properties which already have a
1684 * Hungarian value in the `user` object will be overwritten. Otherwise they
1685 * won't be.
1686 * @memberof DataTable#oApi
1687 */
1688 function _fnCamelToHungarian ( src, user, force )
1689 {
1690 if ( ! src._hungarianMap ) {
1691 _fnHungarianMap( src );
1692 }
1694 var hungarianKey;
1696 $.each( user, function (key, val) {
1697 hungarianKey = src._hungarianMap[ key ];
1699 if ( hungarianKey !== undefined && (force || user[hungarianKey] === undefined) )
1700 {
1701 // For objects, we need to buzz down into the object to copy parameters
1702 if ( hungarianKey.charAt(0) === 'o' )
1703 {
1704 // Copy the camelCase options over to the hungarian
1705 if ( ! user[ hungarianKey ] ) {
1706 user[ hungarianKey ] = {};
1707 }
1708 $.extend( true, user[hungarianKey], user[key] );
1710 _fnCamelToHungarian( src[hungarianKey], user[hungarianKey], force );
1711 }
1712 else {
1713 user[hungarianKey] = user[ key ];
1714 }
1715 }
1716 } );
1717 }
1720 /**
1721 * Language compatibility - when certain options are given, and others aren't, we
1722 * need to duplicate the values over, in order to provide backwards compatibility
1723 * with older language files.
1724 * @param {object} oSettings dataTables settings object
1725 * @memberof DataTable#oApi
1726 */
1727 function _fnLanguageCompat( lang )
1728 {
1729 var defaults = DataTable.defaults.oLanguage;
1730 var zeroRecords = lang.sZeroRecords;
1732 /* Backwards compatibility - if there is no sEmptyTable given, then use the same as
1733 * sZeroRecords - assuming that is given.
1734 */
1735 if ( ! lang.sEmptyTable && zeroRecords &&
1736 defaults.sEmptyTable === "No data available in table" )
1737 {
1738 _fnMap( lang, lang, 'sZeroRecords', 'sEmptyTable' );
1739 }
1741 /* Likewise with loading records */
1742 if ( ! lang.sLoadingRecords && zeroRecords &&
1743 defaults.sLoadingRecords === "Loading..." )
1744 {
1745 _fnMap( lang, lang, 'sZeroRecords', 'sLoadingRecords' );
1746 }
1748 // Old parameter name of the thousands separator mapped onto the new
1749 if ( lang.sInfoThousands ) {
1750 lang.sThousands = lang.sInfoThousands;
1751 }
1753 var decimal = lang.sDecimal;
1754 if ( decimal ) {
1755 _addNumericSort( decimal );
1756 }
1757 }
1760 /**
1761 * Map one parameter onto another
1762 * @param {object} o Object to map
1763 * @param {*} knew The new parameter name
1764 * @param {*} old The old parameter name
1765 */
1766 var _fnCompatMap = function ( o, knew, old ) {
1767 if ( o[ knew ] !== undefined ) {
1768 o[ old ] = o[ knew ];
1769 }
1770 };
1773 /**
1774 * Provide backwards compatibility for the main DT options. Note that the new
1775 * options are mapped onto the old parameters, so this is an external interface
1776 * change only.
1777 * @param {object} init Object to map
1778 */
1779 function _fnCompatOpts ( init )
1780 {
1781 _fnCompatMap( init, 'ordering', 'bSort' );
1782 _fnCompatMap( init, 'orderMulti', 'bSortMulti' );
1783 _fnCompatMap( init, 'orderClasses', 'bSortClasses' );
1784 _fnCompatMap( init, 'orderCellsTop', 'bSortCellsTop' );
1785 _fnCompatMap( init, 'order', 'aaSorting' );
1786 _fnCompatMap( init, 'orderFixed', 'aaSortingFixed' );
1787 _fnCompatMap( init, 'paging', 'bPaginate' );
1788 _fnCompatMap( init, 'pagingType', 'sPaginationType' );
1789 _fnCompatMap( init, 'pageLength', 'iDisplayLength' );
1790 _fnCompatMap( init, 'searching', 'bFilter' );
1792 // Boolean initialisation of x-scrolling
1793 if ( typeof init.sScrollX === 'boolean' ) {
1794 init.sScrollX = init.sScrollX ? '100%' : '';
1795 }
1796 if ( typeof init.scrollX === 'boolean' ) {
1797 init.scrollX = init.scrollX ? '100%' : '';
1798 }
1800 // Column search objects are in an array, so it needs to be converted
1801 // element by element
1802 var searchCols = init.aoSearchCols;
1804 if ( searchCols ) {
1805 for ( var i=0, ien=searchCols.length ; i<ien ; i++ ) {
1806 if ( searchCols[i] ) {
1807 _fnCamelToHungarian( DataTable.models.oSearch, searchCols[i] );
1808 }
1809 }
1810 }
1811 }
1814 /**
1815 * Provide backwards compatibility for column options. Note that the new options
1816 * are mapped onto the old parameters, so this is an external interface change
1817 * only.
1818 * @param {object} init Object to map
1819 */
1820 function _fnCompatCols ( init )
1821 {
1822 _fnCompatMap( init, 'orderable', 'bSortable' );
1823 _fnCompatMap( init, 'orderData', 'aDataSort' );
1824 _fnCompatMap( init, 'orderSequence', 'asSorting' );
1825 _fnCompatMap( init, 'orderDataType', 'sortDataType' );
1827 // orderData can be given as an integer
1828 var dataSort = init.aDataSort;
1829 if ( dataSort && ! $.isArray( dataSort ) ) {
1830 init.aDataSort = [ dataSort ];
1831 }
1832 }
1835 /**
1836 * Browser feature detection for capabilities, quirks
1837 * @param {object} settings dataTables settings object
1838 * @memberof DataTable#oApi
1839 */
1840 function _fnBrowserDetect( settings )
1841 {
1842 // We don't need to do this every time DataTables is constructed, the values
1843 // calculated are specific to the browser and OS configuration which we
1844 // don't expect to change between initialisations
1845 if ( ! DataTable.__browser ) {
1846 var browser = {};
1847 DataTable.__browser = browser;
1849 // Scrolling feature / quirks detection
1850 var n = $('<div/>')
1851 .css( {
1852 position: 'fixed',
1853 top: 0,
1854 left: 0,
1855 height: 1,
1856 width: 1,
1857 overflow: 'hidden'
1858 } )
1859 .append(
1860 $('<div/>')
1861 .css( {
1862 position: 'absolute',
1863 top: 1,
1864 left: 1,
1865 width: 100,
1866 overflow: 'scroll'
1867 } )
1868 .append(
1869 $('<div/>')
1870 .css( {
1871 width: '100%',
1872 height: 10
1873 } )
1874 )
1875 )
1876 .appendTo( 'body' );
1878 var outer = n.children();
1879 var inner = outer.children();
1881 // Numbers below, in order, are:
1882 // inner.offsetWidth, inner.clientWidth, outer.offsetWidth, outer.clientWidth
1883 //
1884 // IE6 XP: 100 100 100 83
1885 // IE7 Vista: 100 100 100 83
1886 // IE 8+ Windows: 83 83 100 83
1887 // Evergreen Windows: 83 83 100 83
1888 // Evergreen Mac with scrollbars: 85 85 100 85
1889 // Evergreen Mac without scrollbars: 100 100 100 100
1891 // Get scrollbar width
1892 browser.barWidth = outer[0].offsetWidth - outer[0].clientWidth;
1894 // IE6/7 will oversize a width 100% element inside a scrolling element, to
1895 // include the width of the scrollbar, while other browsers ensure the inner
1896 // element is contained without forcing scrolling
1897 browser.bScrollOversize = inner[0].offsetWidth === 100 && outer[0].clientWidth !== 100;
1899 // In rtl text layout, some browsers (most, but not all) will place the
1900 // scrollbar on the left, rather than the right.
1901 browser.bScrollbarLeft = Math.round( inner.offset().left ) !== 1;
1903 // IE8- don't provide height and width for getBoundingClientRect
1904 browser.bBounding = n[0].getBoundingClientRect().width ? true : false;
1906 n.remove();
1907 }
1909 $.extend( settings.oBrowser, DataTable.__browser );
1910 settings.oScroll.iBarWidth = DataTable.__browser.barWidth;
1911 }
1914 /**
1915 * Array.prototype reduce[Right] method, used for browsers which don't support
1916 * JS 1.6. Done this way to reduce code size, since we iterate either way
1917 * @param {object} settings dataTables settings object
1918 * @memberof DataTable#oApi
1919 */
1920 function _fnReduce ( that, fn, init, start, end, inc )
1921 {
1922 var
1923 i = start,
1924 value,
1925 isSet = false;
1927 if ( init !== undefined ) {
1928 value = init;
1929 isSet = true;
1930 }
1932 while ( i !== end ) {
1933 if ( ! that.hasOwnProperty(i) ) {
1934 continue;
1935 }
1937 value = isSet ?
1938 fn( value, that[i], i, that ) :
1939 that[i];
1941 isSet = true;
1942 i += inc;
1943 }
1945 return value;
1946 }
1948 /**
1949 * Add a column to the list used for the table with default values
1950 * @param {object} oSettings dataTables settings object
1951 * @param {node} nTh The th element for this column
1952 * @memberof DataTable#oApi
1953 */
1954 function _fnAddColumn( oSettings, nTh )
1955 {
1956 // Add column to aoColumns array
1957 var oDefaults = DataTable.defaults.column;
1958 var iCol = oSettings.aoColumns.length;
1959 var oCol = $.extend( {}, DataTable.models.oColumn, oDefaults, {
1960 "nTh": nTh ? nTh : document.createElement('th'),
1961 "sTitle": oDefaults.sTitle ? oDefaults.sTitle : nTh ? nTh.innerHTML : '',
1962 "aDataSort": oDefaults.aDataSort ? oDefaults.aDataSort : [iCol],
1963 "mData": oDefaults.mData ? oDefaults.mData : iCol,
1964 idx: iCol
1965 } );
1966 oSettings.aoColumns.push( oCol );
1968 // Add search object for column specific search. Note that the `searchCols[ iCol ]`
1969 // passed into extend can be undefined. This allows the user to give a default
1970 // with only some of the parameters defined, and also not give a default
1971 var searchCols = oSettings.aoPreSearchCols;
1972 searchCols[ iCol ] = $.extend( {}, DataTable.models.oSearch, searchCols[ iCol ] );
1974 // Use the default column options function to initialise classes etc
1975 _fnColumnOptions( oSettings, iCol, $(nTh).data() );
1976 }
1979 /**
1980 * Apply options for a column
1981 * @param {object} oSettings dataTables settings object
1982 * @param {int} iCol column index to consider
1983 * @param {object} oOptions object with sType, bVisible and bSearchable etc
1984 * @memberof DataTable#oApi
1985 */
1986 function _fnColumnOptions( oSettings, iCol, oOptions )
1987 {
1988 var oCol = oSettings.aoColumns[ iCol ];
1989 var oClasses = oSettings.oClasses;
1990 var th = $(oCol.nTh);
1992 // Try to get width information from the DOM. We can't get it from CSS
1993 // as we'd need to parse the CSS stylesheet. `width` option can override
1994 if ( ! oCol.sWidthOrig ) {
1995 // Width attribute
1996 oCol.sWidthOrig = th.attr('width') || null;
1998 // Style attribute
1999 var t = (th.attr('style') || '').match(/width:\s*(\d+[pxem%]+)/);
2000 if ( t ) {
2001 oCol.sWidthOrig = t[1];
2002 }
2003 }
2005 /* User specified column options */
2006 if ( oOptions !== undefined && oOptions !== null )
2007 {
2008 // Backwards compatibility
2009 _fnCompatCols( oOptions );
2011 // Map camel case parameters to their Hungarian counterparts
2012 _fnCamelToHungarian( DataTable.defaults.column, oOptions );
2014 /* Backwards compatibility for mDataProp */
2015 if ( oOptions.mDataProp !== undefined && !oOptions.mData )
2016 {
2017 oOptions.mData = oOptions.mDataProp;
2018 }
2020 if ( oOptions.sType )
2021 {
2022 oCol._sManualType = oOptions.sType;
2023 }
2025 // `class` is a reserved word in Javascript, so we need to provide
2026 // the ability to use a valid name for the camel case input
2027 if ( oOptions.className && ! oOptions.sClass )
2028 {
2029 oOptions.sClass = oOptions.className;
2030 }
2032 $.extend( oCol, oOptions );
2033 _fnMap( oCol, oOptions, "sWidth", "sWidthOrig" );
2035 /* iDataSort to be applied (backwards compatibility), but aDataSort will take
2036 * priority if defined
2037 */
2038 if ( oOptions.iDataSort !== undefined )
2039 {
2040 oCol.aDataSort = [ oOptions.iDataSort ];
2041 }
2042 _fnMap( oCol, oOptions, "aDataSort" );
2043 }
2045 /* Cache the data get and set functions for speed */
2046 var mDataSrc = oCol.mData;
2047 var mData = _fnGetObjectDataFn( mDataSrc );
2048 var mRender = oCol.mRender ? _fnGetObjectDataFn( oCol.mRender ) : null;
2050 var attrTest = function( src ) {
2051 return typeof src === 'string' && src.indexOf('@') !== -1;
2052 };
2053 oCol._bAttrSrc = $.isPlainObject( mDataSrc ) && (
2054 attrTest(mDataSrc.sort) || attrTest(mDataSrc.type) || attrTest(mDataSrc.filter)
2055 );
2056 oCol._setter = null;
2058 oCol.fnGetData = function (rowData, type, meta) {
2059 var innerData = mData( rowData, type, undefined, meta );
2061 return mRender && type ?
2062 mRender( innerData, type, rowData, meta ) :
2063 innerData;
2064 };
2065 oCol.fnSetData = function ( rowData, val, meta ) {
2066 return _fnSetObjectDataFn( mDataSrc )( rowData, val, meta );
2067 };
2069 // Indicate if DataTables should read DOM data as an object or array
2070 // Used in _fnGetRowElements
2071 if ( typeof mDataSrc !== 'number' ) {
2072 oSettings._rowReadObject = true;
2073 }
2075 /* Feature sorting overrides column specific when off */
2076 if ( !oSettings.oFeatures.bSort )
2077 {
2078 oCol.bSortable = false;
2079 th.addClass( oClasses.sSortableNone ); // Have to add class here as order event isn't called
2080 }
2082 /* Check that the class assignment is correct for sorting */
2083 var bAsc = $.inArray('asc', oCol.asSorting) !== -1;
2084 var bDesc = $.inArray('desc', oCol.asSorting) !== -1;
2085 if ( !oCol.bSortable || (!bAsc && !bDesc) )
2086 {
2087 oCol.sSortingClass = oClasses.sSortableNone;
2088 oCol.sSortingClassJUI = "";
2089 }
2090 else if ( bAsc && !bDesc )
2091 {
2092 oCol.sSortingClass = oClasses.sSortableAsc;
2093 oCol.sSortingClassJUI = oClasses.sSortJUIAscAllowed;
2094 }
2095 else if ( !bAsc && bDesc )
2096 {
2097 oCol.sSortingClass = oClasses.sSortableDesc;
2098 oCol.sSortingClassJUI = oClasses.sSortJUIDescAllowed;
2099 }
2100 else
2101 {
2102 oCol.sSortingClass = oClasses.sSortable;
2103 oCol.sSortingClassJUI = oClasses.sSortJUI;
2104 }
2105 }
2108 /**
2109 * Adjust the table column widths for new data. Note: you would probably want to
2110 * do a redraw after calling this function!
2111 * @param {object} settings dataTables settings object
2112 * @memberof DataTable#oApi
2113 */
2114 function _fnAdjustColumnSizing ( settings )
2115 {
2116 /* Not interested in doing column width calculation if auto-width is disabled */
2117 if ( settings.oFeatures.bAutoWidth !== false )
2118 {
2119 var columns = settings.aoColumns;
2121 _fnCalculateColumnWidths( settings );
2122 for ( var i=0 , iLen=columns.length ; i<iLen ; i++ )
2123 {
2124 columns[i].nTh.style.width = columns[i].sWidth;
2125 }
2126 }
2128 var scroll = settings.oScroll;
2129 if ( scroll.sY !== '' || scroll.sX !== '')
2130 {
2131 _fnScrollDraw( settings );
2132 }
2134 _fnCallbackFire( settings, null, 'column-sizing', [settings] );
2135 }
2138 /**
2139 * Covert the index of a visible column to the index in the data array (take account
2140 * of hidden columns)
2141 * @param {object} oSettings dataTables settings object
2142 * @param {int} iMatch Visible column index to lookup
2143 * @returns {int} i the data index
2144 * @memberof DataTable#oApi
2145 */
2146 function _fnVisibleToColumnIndex( oSettings, iMatch )
2147 {
2148 var aiVis = _fnGetColumns( oSettings, 'bVisible' );
2150 return typeof aiVis[iMatch] === 'number' ?
2151 aiVis[iMatch] :
2152 null;
2153 }
2156 /**
2157 * Covert the index of an index in the data array and convert it to the visible
2158 * column index (take account of hidden columns)
2159 * @param {int} iMatch Column index to lookup
2160 * @param {object} oSettings dataTables settings object
2161 * @returns {int} i the data index
2162 * @memberof DataTable#oApi
2163 */
2164 function _fnColumnIndexToVisible( oSettings, iMatch )
2165 {
2166 var aiVis = _fnGetColumns( oSettings, 'bVisible' );
2167 var iPos = $.inArray( iMatch, aiVis );
2169 return iPos !== -1 ? iPos : null;
2170 }
2173 /**
2174 * Get the number of visible columns
2175 * @param {object} oSettings dataTables settings object
2176 * @returns {int} i the number of visible columns
2177 * @memberof DataTable#oApi
2178 */
2179 function _fnVisbleColumns( oSettings )
2180 {
2181 var vis = 0;
2183 // No reduce in IE8, use a loop for now
2184 $.each( oSettings.aoColumns, function ( i, col ) {
2185 if ( col.bVisible && $(col.nTh).css('display') !== 'none' ) {
2186 vis++;
2187 }
2188 } );
2190 return vis;
2191 }
2194 /**
2195 * Get an array of column indexes that match a given property
2196 * @param {object} oSettings dataTables settings object
2197 * @param {string} sParam Parameter in aoColumns to look for - typically
2198 * bVisible or bSearchable
2199 * @returns {array} Array of indexes with matched properties
2200 * @memberof DataTable#oApi
2201 */
2202 function _fnGetColumns( oSettings, sParam )
2203 {
2204 var a = [];
2206 $.map( oSettings.aoColumns, function(val, i) {
2207 if ( val[sParam] ) {
2208 a.push( i );
2209 }
2210 } );
2212 return a;
2213 }
2216 /**
2217 * Calculate the 'type' of a column
2218 * @param {object} settings dataTables settings object
2219 * @memberof DataTable#oApi
2220 */
2221 function _fnColumnTypes ( settings )
2222 {
2223 var columns = settings.aoColumns;
2224 var data = settings.aoData;
2225 var types = DataTable.ext.type.detect;
2226 var i, ien, j, jen, k, ken;
2227 var col, cell, detectedType, cache;
2229 // For each column, spin over the
2230 for ( i=0, ien=columns.length ; i<ien ; i++ ) {
2231 col = columns[i];
2232 cache = [];
2234 if ( ! col.sType && col._sManualType ) {
2235 col.sType = col._sManualType;
2236 }
2237 else if ( ! col.sType ) {
2238 for ( j=0, jen=types.length ; j<jen ; j++ ) {
2239 for ( k=0, ken=data.length ; k<ken ; k++ ) {
2240 // Use a cache array so we only need to get the type data
2241 // from the formatter once (when using multiple detectors)
2242 if ( cache[k] === undefined ) {
2243 cache[k] = _fnGetCellData( settings, k, i, 'type' );
2244 }
2246 detectedType = types[j]( cache[k], settings );
2248 // If null, then this type can't apply to this column, so
2249 // rather than testing all cells, break out. There is an
2250 // exception for the last type which is `html`. We need to
2251 // scan all rows since it is possible to mix string and HTML
2252 // types
2253 if ( ! detectedType && j !== types.length-1 ) {
2254 break;
2255 }
2257 // Only a single match is needed for html type since it is
2258 // bottom of the pile and very similar to string
2259 if ( detectedType === 'html' ) {
2260 break;
2261 }
2262 }
2264 // Type is valid for all data points in the column - use this
2265 // type
2266 if ( detectedType ) {
2267 col.sType = detectedType;
2268 break;
2269 }
2270 }
2272 // Fall back - if no type was detected, always use string
2273 if ( ! col.sType ) {
2274 col.sType = 'string';
2275 }
2276 }
2277 }
2278 }
2281 /**
2282 * Take the column definitions and static columns arrays and calculate how
2283 * they relate to column indexes. The callback function will then apply the
2284 * definition found for a column to a suitable configuration object.
2285 * @param {object} oSettings dataTables settings object
2286 * @param {array} aoColDefs The aoColumnDefs array that is to be applied
2287 * @param {array} aoCols The aoColumns array that defines columns individually
2288 * @param {function} fn Callback function - takes two parameters, the calculated
2289 * column index and the definition for that column.
2290 * @memberof DataTable#oApi
2291 */
2292 function _fnApplyColumnDefs( oSettings, aoColDefs, aoCols, fn )
2293 {
2294 var i, iLen, j, jLen, k, kLen, def;
2295 var columns = oSettings.aoColumns;
2297 // Column definitions with aTargets
2298 if ( aoColDefs )
2299 {
2300 /* Loop over the definitions array - loop in reverse so first instance has priority */
2301 for ( i=aoColDefs.length-1 ; i>=0 ; i-- )
2302 {
2303 def = aoColDefs[i];
2305 /* Each definition can target multiple columns, as it is an array */
2306 var aTargets = def.targets !== undefined ?
2307 def.targets :
2308 def.aTargets;
2310 if ( ! $.isArray( aTargets ) )
2311 {
2312 aTargets = [ aTargets ];
2313 }
2315 for ( j=0, jLen=aTargets.length ; j<jLen ; j++ )
2316 {
2317 if ( typeof aTargets[j] === 'number' && aTargets[j] >= 0 )
2318 {
2319 /* Add columns that we don't yet know about */
2320 while( columns.length <= aTargets[j] )
2321 {
2322 _fnAddColumn( oSettings );
2323 }
2325 /* Integer, basic index */
2326 fn( aTargets[j], def );
2327 }
2328 else if ( typeof aTargets[j] === 'number' && aTargets[j] < 0 )
2329 {
2330 /* Negative integer, right to left column counting */
2331 fn( columns.length+aTargets[j], def );
2332 }
2333 else if ( typeof aTargets[j] === 'string' )
2334 {
2335 /* Class name matching on TH element */
2336 for ( k=0, kLen=columns.length ; k<kLen ; k++ )
2337 {
2338 if ( aTargets[j] == "_all" ||
2339 $(columns[k].nTh).hasClass( aTargets[j] ) )
2340 {
2341 fn( k, def );
2342 }
2343 }
2344 }
2345 }
2346 }
2347 }
2349 // Statically defined columns array
2350 if ( aoCols )
2351 {
2352 for ( i=0, iLen=aoCols.length ; i<iLen ; i++ )
2353 {
2354 fn( i, aoCols[i] );
2355 }
2356 }
2357 }
2359 /**
2360 * Add a data array to the table, creating DOM node etc. This is the parallel to
2361 * _fnGatherData, but for adding rows from a Javascript source, rather than a
2362 * DOM source.
2363 * @param {object} oSettings dataTables settings object
2364 * @param {array} aData data array to be added
2365 * @param {node} [nTr] TR element to add to the table - optional. If not given,
2366 * DataTables will create a row automatically
2367 * @param {array} [anTds] Array of TD|TH elements for the row - must be given
2368 * if nTr is.
2369 * @returns {int} >=0 if successful (index of new aoData entry), -1 if failed
2370 * @memberof DataTable#oApi
2371 */
2372 function _fnAddData ( oSettings, aDataIn, nTr, anTds )
2373 {
2374 /* Create the object for storing information about this new row */
2375 var iRow = oSettings.aoData.length;
2376 var oData = $.extend( true, {}, DataTable.models.oRow, {
2377 src: nTr ? 'dom' : 'data',
2378 idx: iRow
2379 } );
2381 oData._aData = aDataIn;
2382 oSettings.aoData.push( oData );
2384 /* Create the cells */
2385 var nTd, sThisType;
2386 var columns = oSettings.aoColumns;
2388 // Invalidate the column types as the new data needs to be revalidated
2389 for ( var i=0, iLen=columns.length ; i<iLen ; i++ )
2390 {
2391 columns[i].sType = null;
2392 }
2394 /* Add to the display array */
2395 oSettings.aiDisplayMaster.push( iRow );
2397 var id = oSettings.rowIdFn( aDataIn );
2398 if ( id !== undefined ) {
2399 oSettings.aIds[ id ] = oData;
2400 }
2402 /* Create the DOM information, or register it if already present */
2403 if ( nTr || ! oSettings.oFeatures.bDeferRender )
2404 {
2405 _fnCreateTr( oSettings, iRow, nTr, anTds );
2406 }
2408 return iRow;
2409 }
2412 /**
2413 * Add one or more TR elements to the table. Generally we'd expect to
2414 * use this for reading data from a DOM sourced table, but it could be
2415 * used for an TR element. Note that if a TR is given, it is used (i.e.
2416 * it is not cloned).
2417 * @param {object} settings dataTables settings object
2418 * @param {array|node|jQuery} trs The TR element(s) to add to the table
2419 * @returns {array} Array of indexes for the added rows
2420 * @memberof DataTable#oApi
2421 */
2422 function _fnAddTr( settings, trs )
2423 {
2424 var row;
2426 // Allow an individual node to be passed in
2427 if ( ! (trs instanceof $) ) {
2428 trs = $(trs);
2429 }
2431 return trs.map( function (i, el) {
2432 row = _fnGetRowElements( settings, el );
2433 return _fnAddData( settings, row.data, el, row.cells );
2434 } );
2435 }
2438 /**
2439 * Take a TR element and convert it to an index in aoData
2440 * @param {object} oSettings dataTables settings object
2441 * @param {node} n the TR element to find
2442 * @returns {int} index if the node is found, null if not
2443 * @memberof DataTable#oApi
2444 */
2445 function _fnNodeToDataIndex( oSettings, n )
2446 {
2447 return (n._DT_RowIndex!==undefined) ? n._DT_RowIndex : null;
2448 }
2451 /**
2452 * Take a TD element and convert it into a column data index (not the visible index)
2453 * @param {object} oSettings dataTables settings object
2454 * @param {int} iRow The row number the TD/TH can be found in
2455 * @param {node} n The TD/TH element to find
2456 * @returns {int} index if the node is found, -1 if not
2457 * @memberof DataTable#oApi
2458 */
2459 function _fnNodeToColumnIndex( oSettings, iRow, n )
2460 {
2461 return $.inArray( n, oSettings.aoData[ iRow ].anCells );
2462 }
2465 /**
2466 * Get the data for a given cell from the internal cache, taking into account data mapping
2467 * @param {object} settings dataTables settings object
2468 * @param {int} rowIdx aoData row id
2469 * @param {int} colIdx Column index
2470 * @param {string} type data get type ('display', 'type' 'filter' 'sort')
2471 * @returns {*} Cell data
2472 * @memberof DataTable#oApi
2473 */
2474 function _fnGetCellData( settings, rowIdx, colIdx, type )
2475 {
2476 var draw = settings.iDraw;
2477 var col = settings.aoColumns[colIdx];
2478 var rowData = settings.aoData[rowIdx]._aData;
2479 var defaultContent = col.sDefaultContent;
2480 var cellData = col.fnGetData( rowData, type, {
2481 settings: settings,
2482 row: rowIdx,
2483 col: colIdx
2484 } );
2486 if ( cellData === undefined ) {
2487 if ( settings.iDrawError != draw && defaultContent === null ) {
2488 _fnLog( settings, 0, "Requested unknown parameter "+
2489 (typeof col.mData=='function' ? '{function}' : "'"+col.mData+"'")+
2490 " for row "+rowIdx+", column "+colIdx, 4 );
2491 settings.iDrawError = draw;
2492 }
2493 return defaultContent;
2494 }
2496 // When the data source is null and a specific data type is requested (i.e.
2497 // not the original data), we can use default column data
2498 if ( (cellData === rowData || cellData === null) && defaultContent !== null && type !== undefined ) {
2499 cellData = defaultContent;
2500 }
2501 else if ( typeof cellData === 'function' ) {
2502 // If the data source is a function, then we run it and use the return,
2503 // executing in the scope of the data object (for instances)
2504 return cellData.call( rowData );
2505 }
2507 if ( cellData === null && type == 'display' ) {
2508 return '';
2509 }
2510 return cellData;
2511 }
2514 /**
2515 * Set the value for a specific cell, into the internal data cache
2516 * @param {object} settings dataTables settings object
2517 * @param {int} rowIdx aoData row id
2518 * @param {int} colIdx Column index
2519 * @param {*} val Value to set
2520 * @memberof DataTable#oApi
2521 */
2522 function _fnSetCellData( settings, rowIdx, colIdx, val )
2523 {
2524 var col = settings.aoColumns[colIdx];
2525 var rowData = settings.aoData[rowIdx]._aData;
2527 col.fnSetData( rowData, val, {
2528 settings: settings,
2529 row: rowIdx,
2530 col: colIdx
2531 } );
2532 }
2535 // Private variable that is used to match action syntax in the data property object
2536 var __reArray = /\[.*?\]$/;
2537 var __reFn = /\(\)$/;
2539 /**
2540 * Split string on periods, taking into account escaped periods
2541 * @param {string} str String to split
2542 * @return {array} Split string
2543 */
2544 function _fnSplitObjNotation( str )
2545 {
2546 return $.map( str.match(/(\\.|[^\.])+/g) || [''], function ( s ) {
2547 return s.replace(/\\./g, '.');
2548 } );
2549 }
2552 /**
2553 * Return a function that can be used to get data from a source object, taking
2554 * into account the ability to use nested objects as a source
2555 * @param {string|int|function} mSource The data source for the object
2556 * @returns {function} Data get function
2557 * @memberof DataTable#oApi
2558 */
2559 function _fnGetObjectDataFn( mSource )
2560 {
2561 if ( $.isPlainObject( mSource ) )
2562 {
2563 /* Build an object of get functions, and wrap them in a single call */
2564 var o = {};
2565 $.each( mSource, function (key, val) {
2566 if ( val ) {
2567 o[key] = _fnGetObjectDataFn( val );
2568 }
2569 } );
2571 return function (data, type, row, meta) {
2572 var t = o[type] || o._;
2573 return t !== undefined ?
2574 t(data, type, row, meta) :
2575 data;
2576 };
2577 }
2578 else if ( mSource === null )
2579 {
2580 /* Give an empty string for rendering / sorting etc */
2581 return function (data) { // type, row and meta also passed, but not used
2582 return data;
2583 };
2584 }
2585 else if ( typeof mSource === 'function' )
2586 {
2587 return function (data, type, row, meta) {
2588 return mSource( data, type, row, meta );
2589 };
2590 }
2591 else if ( typeof mSource === 'string' && (mSource.indexOf('.') !== -1 ||
2592 mSource.indexOf('[') !== -1 || mSource.indexOf('(') !== -1) )
2593 {
2594 /* If there is a . in the source string then the data source is in a
2595 * nested object so we loop over the data for each level to get the next
2596 * level down. On each loop we test for undefined, and if found immediately
2597 * return. This allows entire objects to be missing and sDefaultContent to
2598 * be used if defined, rather than throwing an error
2599 */
2600 var fetchData = function (data, type, src) {
2601 var arrayNotation, funcNotation, out, innerSrc;
2603 if ( src !== "" )
2604 {
2605 var a = _fnSplitObjNotation( src );
2607 for ( var i=0, iLen=a.length ; i<iLen ; i++ )
2608 {
2609 // Check if we are dealing with special notation
2610 arrayNotation = a[i].match(__reArray);
2611 funcNotation = a[i].match(__reFn);
2613 if ( arrayNotation )
2614 {
2615 // Array notation
2616 a[i] = a[i].replace(__reArray, '');
2618 // Condition allows simply [] to be passed in
2619 if ( a[i] !== "" ) {
2620 data = data[ a[i] ];
2621 }
2622 out = [];
2624 // Get the remainder of the nested object to get
2625 a.splice( 0, i+1 );
2626 innerSrc = a.join('.');
2628 // Traverse each entry in the array getting the properties requested
2629 if ( $.isArray( data ) ) {
2630 for ( var j=0, jLen=data.length ; j<jLen ; j++ ) {
2631 out.push( fetchData( data[j], type, innerSrc ) );
2632 }
2633 }
2635 // If a string is given in between the array notation indicators, that
2636 // is used to join the strings together, otherwise an array is returned
2637 var join = arrayNotation[0].substring(1, arrayNotation[0].length-1);
2638 data = (join==="") ? out : out.join(join);
2640 // The inner call to fetchData has already traversed through the remainder
2641 // of the source requested, so we exit from the loop
2642 break;
2643 }
2644 else if ( funcNotation )
2645 {
2646 // Function call
2647 a[i] = a[i].replace(__reFn, '');
2648 data = data[ a[i] ]();
2649 continue;
2650 }
2652 if ( data === null || data[ a[i] ] === undefined )
2653 {
2654 return undefined;
2655 }
2656 data = data[ a[i] ];
2657 }
2658 }
2660 return data;
2661 };
2663 return function (data, type) { // row and meta also passed, but not used
2664 return fetchData( data, type, mSource );
2665 };
2666 }
2667 else
2668 {
2669 /* Array or flat object mapping */
2670 return function (data, type) { // row and meta also passed, but not used
2671 return data[mSource];
2672 };
2673 }
2674 }
2677 /**
2678 * Return a function that can be used to set data from a source object, taking
2679 * into account the ability to use nested objects as a source
2680 * @param {string|int|function} mSource The data source for the object
2681 * @returns {function} Data set function
2682 * @memberof DataTable#oApi
2683 */
2684 function _fnSetObjectDataFn( mSource )
2685 {
2686 if ( $.isPlainObject( mSource ) )
2687 {
2688 /* Unlike get, only the underscore (global) option is used for for
2689 * setting data since we don't know the type here. This is why an object
2690 * option is not documented for `mData` (which is read/write), but it is
2691 * for `mRender` which is read only.
2692 */
2693 return _fnSetObjectDataFn( mSource._ );
2694 }
2695 else if ( mSource === null )
2696 {
2697 /* Nothing to do when the data source is null */
2698 return function () {};
2699 }
2700 else if ( typeof mSource === 'function' )
2701 {
2702 return function (data, val, meta) {
2703 mSource( data, 'set', val, meta );
2704 };
2705 }
2706 else if ( typeof mSource === 'string' && (mSource.indexOf('.') !== -1 ||
2707 mSource.indexOf('[') !== -1 || mSource.indexOf('(') !== -1) )
2708 {
2709 /* Like the get, we need to get data from a nested object */
2710 var setData = function (data, val, src) {
2711 var a = _fnSplitObjNotation( src ), b;
2712 var aLast = a[a.length-1];
2713 var arrayNotation, funcNotation, o, innerSrc;
2715 for ( var i=0, iLen=a.length-1 ; i<iLen ; i++ )
2716 {
2717 // Check if we are dealing with an array notation request
2718 arrayNotation = a[i].match(__reArray);
2719 funcNotation = a[i].match(__reFn);
2721 if ( arrayNotation )
2722 {
2723 a[i] = a[i].replace(__reArray, '');
2724 data[ a[i] ] = [];
2726 // Get the remainder of the nested object to set so we can recurse
2727 b = a.slice();
2728 b.splice( 0, i+1 );
2729 innerSrc = b.join('.');
2731 // Traverse each entry in the array setting the properties requested
2732 if ( $.isArray( val ) )
2733 {
2734 for ( var j=0, jLen=val.length ; j<jLen ; j++ )
2735 {
2736 o = {};
2737 setData( o, val[j], innerSrc );
2738 data[ a[i] ].push( o );
2739 }
2740 }
2741 else
2742 {
2743 // We've been asked to save data to an array, but it
2744 // isn't array data to be saved. Best that can be done
2745 // is to just save the value.
2746 data[ a[i] ] = val;
2747 }
2749 // The inner call to setData has already traversed through the remainder
2750 // of the source and has set the data, thus we can exit here
2751 return;
2752 }
2753 else if ( funcNotation )
2754 {
2755 // Function call
2756 a[i] = a[i].replace(__reFn, '');
2757 data = data[ a[i] ]( val );
2758 }
2760 // If the nested object doesn't currently exist - since we are
2761 // trying to set the value - create it
2762 if ( data[ a[i] ] === null || data[ a[i] ] === undefined )
2763 {
2764 data[ a[i] ] = {};
2765 }
2766 data = data[ a[i] ];
2767 }
2769 // Last item in the input - i.e, the actual set
2770 if ( aLast.match(__reFn ) )
2771 {
2772 // Function call
2773 data = data[ aLast.replace(__reFn, '') ]( val );
2774 }
2775 else
2776 {
2777 // If array notation is used, we just want to strip it and use the property name
2778 // and assign the value. If it isn't used, then we get the result we want anyway
2779 data[ aLast.replace(__reArray, '') ] = val;
2780 }
2781 };
2783 return function (data, val) { // meta is also passed in, but not used
2784 return setData( data, val, mSource );
2785 };
2786 }
2787 else
2788 {
2789 /* Array or flat object mapping */
2790 return function (data, val) { // meta is also passed in, but not used
2791 data[mSource] = val;
2792 };
2793 }
2794 }
2797 /**
2798 * Return an array with the full table data
2799 * @param {object} oSettings dataTables settings object
2800 * @returns array {array} aData Master data array
2801 * @memberof DataTable#oApi
2802 */
2803 function _fnGetDataMaster ( settings )
2804 {
2805 return _pluck( settings.aoData, '_aData' );
2806 }
2809 /**
2810 * Nuke the table
2811 * @param {object} oSettings dataTables settings object
2812 * @memberof DataTable#oApi
2813 */
2814 function _fnClearTable( settings )
2815 {
2816 settings.aoData.length = 0;
2817 settings.aiDisplayMaster.length = 0;
2818 settings.aiDisplay.length = 0;
2819 settings.aIds = {};
2820 }
2823 /**
2824 * Take an array of integers (index array) and remove a target integer (value - not
2825 * the key!)
2826 * @param {array} a Index array to target
2827 * @param {int} iTarget value to find
2828 * @memberof DataTable#oApi
2829 */
2830 function _fnDeleteIndex( a, iTarget, splice )
2831 {
2832 var iTargetIndex = -1;
2834 for ( var i=0, iLen=a.length ; i<iLen ; i++ )
2835 {
2836 if ( a[i] == iTarget )
2837 {
2838 iTargetIndex = i;
2839 }
2840 else if ( a[i] > iTarget )
2841 {
2842 a[i]--;
2843 }
2844 }
2846 if ( iTargetIndex != -1 && splice === undefined )
2847 {
2848 a.splice( iTargetIndex, 1 );
2849 }
2850 }
2853 /**
2854 * Mark cached data as invalid such that a re-read of the data will occur when
2855 * the cached data is next requested. Also update from the data source object.
2856 *
2857 * @param {object} settings DataTables settings object
2858 * @param {int} rowIdx Row index to invalidate
2859 * @param {string} [src] Source to invalidate from: undefined, 'auto', 'dom'
2860 * or 'data'
2861 * @param {int} [colIdx] Column index to invalidate. If undefined the whole
2862 * row will be invalidated
2863 * @memberof DataTable#oApi
2864 *
2865 * @todo For the modularisation of v1.11 this will need to become a callback, so
2866 * the sort and filter methods can subscribe to it. That will required
2867 * initialisation options for sorting, which is why it is not already baked in
2868 */
2869 function _fnInvalidate( settings, rowIdx, src, colIdx )
2870 {
2871 var row = settings.aoData[ rowIdx ];
2872 var i, ien;
2873 var cellWrite = function ( cell, col ) {
2874 // This is very frustrating, but in IE if you just write directly
2875 // to innerHTML, and elements that are overwritten are GC'ed,
2876 // even if there is a reference to them elsewhere
2877 while ( cell.childNodes.length ) {
2878 cell.removeChild( cell.firstChild );
2879 }
2881 cell.innerHTML = _fnGetCellData( settings, rowIdx, col, 'display' );
2882 };
2884 // Are we reading last data from DOM or the data object?
2885 if ( src === 'dom' || ((! src || src === 'auto') && row.src === 'dom') ) {
2886 // Read the data from the DOM
2887 row._aData = _fnGetRowElements(
2888 settings, row, colIdx, colIdx === undefined ? undefined : row._aData
2889 )
2890 .data;
2891 }
2892 else {
2893 // Reading from data object, update the DOM
2894 var cells = row.anCells;
2896 if ( cells ) {
2897 if ( colIdx !== undefined ) {
2898 cellWrite( cells[colIdx], colIdx );
2899 }
2900 else {
2901 for ( i=0, ien=cells.length ; i<ien ; i++ ) {
2902 cellWrite( cells[i], i );
2903 }
2904 }
2905 }
2906 }
2908 // For both row and cell invalidation, the cached data for sorting and
2909 // filtering is nulled out
2910 row._aSortData = null;
2911 row._aFilterData = null;
2913 // Invalidate the type for a specific column (if given) or all columns since
2914 // the data might have changed
2915 var cols = settings.aoColumns;
2916 if ( colIdx !== undefined ) {
2917 cols[ colIdx ].sType = null;
2918 }
2919 else {
2920 for ( i=0, ien=cols.length ; i<ien ; i++ ) {
2921 cols[i].sType = null;
2922 }
2924 // Update DataTables special `DT_*` attributes for the row
2925 _fnRowAttributes( settings, row );
2926 }
2927 }
2930 /**
2931 * Build a data source object from an HTML row, reading the contents of the
2932 * cells that are in the row.
2933 *
2934 * @param {object} settings DataTables settings object
2935 * @param {node|object} TR element from which to read data or existing row
2936 * object from which to re-read the data from the cells
2937 * @param {int} [colIdx] Optional column index
2938 * @param {array|object} [d] Data source object. If `colIdx` is given then this
2939 * parameter should also be given and will be used to write the data into.
2940 * Only the column in question will be written
2941 * @returns {object} Object with two parameters: `data` the data read, in
2942 * document order, and `cells` and array of nodes (they can be useful to the
2943 * caller, so rather than needing a second traversal to get them, just return
2944 * them from here).
2945 * @memberof DataTable#oApi
2946 */
2947 function _fnGetRowElements( settings, row, colIdx, d )
2948 {
2949 var
2950 tds = [],
2951 td = row.firstChild,
2952 name, col, o, i=0, contents,
2953 columns = settings.aoColumns,
2954 objectRead = settings._rowReadObject;
2956 // Allow the data object to be passed in, or construct
2957 d = d !== undefined ?
2958 d :
2959 objectRead ?
2960 {} :
2961 [];
2963 var attr = function ( str, td ) {
2964 if ( typeof str === 'string' ) {
2965 var idx = str.indexOf('@');
2967 if ( idx !== -1 ) {
2968 var attr = str.substring( idx+1 );
2969 var setter = _fnSetObjectDataFn( str );
2970 setter( d, td.getAttribute( attr ) );
2971 }
2972 }
2973 };
2975 // Read data from a cell and store into the data object
2976 var cellProcess = function ( cell ) {
2977 if ( colIdx === undefined || colIdx === i ) {
2978 col = columns[i];
2979 contents = $.trim(cell.innerHTML);
2981 if ( col && col._bAttrSrc ) {
2982 var setter = _fnSetObjectDataFn( col.mData._ );
2983 setter( d, contents );
2985 attr( col.mData.sort, cell );
2986 attr( col.mData.type, cell );
2987 attr( col.mData.filter, cell );
2988 }
2989 else {
2990 // Depending on the `data` option for the columns the data can
2991 // be read to either an object or an array.
2992 if ( objectRead ) {
2993 if ( ! col._setter ) {
2994 // Cache the setter function
2995 col._setter = _fnSetObjectDataFn( col.mData );
2996 }
2997 col._setter( d, contents );
2998 }
2999 else {
3000 d[i] = contents;
3001 }
3002 }
3003 }
3005 i++;
3006 };
3008 if ( td ) {
3009 // `tr` element was passed in
3010 while ( td ) {
3011 name = td.nodeName.toUpperCase();
3013 if ( name == "TD" || name == "TH" ) {
3014 cellProcess( td );
3015 tds.push( td );
3016 }
3018 td = td.nextSibling;
3019 }
3020 }
3021 else {
3022 // Existing row object passed in
3023 tds = row.anCells;
3025 for ( var j=0, jen=tds.length ; j<jen ; j++ ) {
3026 cellProcess( tds[j] );
3027 }
3028 }
3030 // Read the ID from the DOM if present
3031 var rowNode = row.firstChild ? row : row.nTr;
3033 if ( rowNode ) {
3034 var id = rowNode.getAttribute( 'id' );
3036 if ( id ) {
3037 _fnSetObjectDataFn( settings.rowId )( d, id );
3038 }
3039 }
3041 return {
3042 data: d,
3043 cells: tds
3044 };
3045 }
3046 /**
3047 * Create a new TR element (and it's TD children) for a row
3048 * @param {object} oSettings dataTables settings object
3049 * @param {int} iRow Row to consider
3050 * @param {node} [nTrIn] TR element to add to the table - optional. If not given,
3051 * DataTables will create a row automatically
3052 * @param {array} [anTds] Array of TD|TH elements for the row - must be given
3053 * if nTr is.
3054 * @memberof DataTable#oApi
3055 */
3056 function _fnCreateTr ( oSettings, iRow, nTrIn, anTds )
3057 {
3058 var
3059 row = oSettings.aoData[iRow],
3060 rowData = row._aData,
3061 cells = [],
3062 nTr, nTd, oCol,
3063 i, iLen;
3065 if ( row.nTr === null )
3066 {
3067 nTr = nTrIn || document.createElement('tr');
3069 row.nTr = nTr;
3070 row.anCells = cells;
3072 /* Use a private property on the node to allow reserve mapping from the node
3073 * to the aoData array for fast look up
3074 */
3075 nTr._DT_RowIndex = iRow;
3077 /* Special parameters can be given by the data source to be used on the row */
3078 _fnRowAttributes( oSettings, row );
3080 /* Process each column */
3081 for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
3082 {
3083 oCol = oSettings.aoColumns[i];
3085 nTd = nTrIn ? anTds[i] : document.createElement( oCol.sCellType );
3086 nTd._DT_CellIndex = {
3087 row: iRow,
3088 column: i
3089 };
3091 cells.push( nTd );
3093 // Need to create the HTML if new, or if a rendering function is defined
3094 if ( (!nTrIn || oCol.mRender || oCol.mData !== i) &&
3095 (!$.isPlainObject(oCol.mData) || oCol.mData._ !== i+'.display')
3096 ) {
3097 nTd.innerHTML = _fnGetCellData( oSettings, iRow, i, 'display' );
3098 }
3100 /* Add user defined class */
3101 if ( oCol.sClass )
3102 {
3103 nTd.className += ' '+oCol.sClass;
3104 }
3106 // Visibility - add or remove as required
3107 if ( oCol.bVisible && ! nTrIn )
3108 {
3109 nTr.appendChild( nTd );
3110 }
3111 else if ( ! oCol.bVisible && nTrIn )
3112 {
3113 nTd.parentNode.removeChild( nTd );
3114 }
3116 if ( oCol.fnCreatedCell )
3117 {
3118 oCol.fnCreatedCell.call( oSettings.oInstance,
3119 nTd, _fnGetCellData( oSettings, iRow, i ), rowData, iRow, i
3120 );
3121 }
3122 }
3124 _fnCallbackFire( oSettings, 'aoRowCreatedCallback', null, [nTr, rowData, iRow] );
3125 }
3127 // Remove once webkit bug 131819 and Chromium bug 365619 have been resolved
3128 // and deployed
3129 row.nTr.setAttribute( 'role', 'row' );
3130 }
3133 /**
3134 * Add attributes to a row based on the special `DT_*` parameters in a data
3135 * source object.
3136 * @param {object} settings DataTables settings object
3137 * @param {object} DataTables row object for the row to be modified
3138 * @memberof DataTable#oApi
3139 */
3140 function _fnRowAttributes( settings, row )
3141 {
3142 var tr = row.nTr;
3143 var data = row._aData;
3145 if ( tr ) {
3146 var id = settings.rowIdFn( data );
3148 if ( id ) {
3149 tr.id = id;
3150 }
3152 if ( data.DT_RowClass ) {
3153 // Remove any classes added by DT_RowClass before
3154 var a = data.DT_RowClass.split(' ');
3155 row.__rowc = row.__rowc ?
3156 _unique( row.__rowc.concat( a ) ) :
3157 a;
3159 $(tr)
3160 .removeClass( row.__rowc.join(' ') )
3161 .addClass( data.DT_RowClass );
3162 }
3164 if ( data.DT_RowAttr ) {
3165 $(tr).attr( data.DT_RowAttr );
3166 }
3168 if ( data.DT_RowData ) {
3169 $(tr).data( data.DT_RowData );
3170 }
3171 }
3172 }
3175 /**
3176 * Create the HTML header for the table
3177 * @param {object} oSettings dataTables settings object
3178 * @memberof DataTable#oApi
3179 */
3180 function _fnBuildHead( oSettings )
3181 {
3182 var i, ien, cell, row, column;
3183 var thead = oSettings.nTHead;
3184 var tfoot = oSettings.nTFoot;
3185 var createHeader = $('th, td', thead).length === 0;
3186 var classes = oSettings.oClasses;
3187 var columns = oSettings.aoColumns;
3189 if ( createHeader ) {
3190 row = $('<tr/>').appendTo( thead );
3191 }
3193 for ( i=0, ien=columns.length ; i<ien ; i++ ) {
3194 column = columns[i];
3195 cell = $( column.nTh ).addClass( column.sClass );
3197 if ( createHeader ) {
3198 cell.appendTo( row );
3199 }
3201 // 1.11 move into sorting
3202 if ( oSettings.oFeatures.bSort ) {
3203 cell.addClass( column.sSortingClass );
3205 if ( column.bSortable !== false ) {
3206 cell
3207 .attr( 'tabindex', oSettings.iTabIndex )
3208 .attr( 'aria-controls', oSettings.sTableId );
3210 _fnSortAttachListener( oSettings, column.nTh, i );
3211 }
3212 }
3214 if ( column.sTitle != cell[0].innerHTML ) {
3215 cell.html( column.sTitle );
3216 }
3218 _fnRenderer( oSettings, 'header' )(
3219 oSettings, cell, column, classes
3220 );
3221 }
3223 if ( createHeader ) {
3224 _fnDetectHeader( oSettings.aoHeader, thead );
3225 }
3227 /* ARIA role for the rows */
3228 $(thead).find('>tr').attr('role', 'row');
3230 /* Deal with the footer - add classes if required */
3231 $(thead).find('>tr>th, >tr>td').addClass( classes.sHeaderTH );
3232 $(tfoot).find('>tr>th, >tr>td').addClass( classes.sFooterTH );
3234 // Cache the footer cells. Note that we only take the cells from the first
3235 // row in the footer. If there is more than one row the user wants to
3236 // interact with, they need to use the table().foot() method. Note also this
3237 // allows cells to be used for multiple columns using colspan
3238 if ( tfoot !== null ) {
3239 var cells = oSettings.aoFooter[0];
3241 for ( i=0, ien=cells.length ; i<ien ; i++ ) {
3242 column = columns[i];
3243 column.nTf = cells[i].cell;
3245 if ( column.sClass ) {
3246 $(column.nTf).addClass( column.sClass );
3247 }
3248 }
3249 }
3250 }
3253 /**
3254 * Draw the header (or footer) element based on the column visibility states. The
3255 * methodology here is to use the layout array from _fnDetectHeader, modified for
3256 * the instantaneous column visibility, to construct the new layout. The grid is
3257 * traversed over cell at a time in a rows x columns grid fashion, although each
3258 * cell insert can cover multiple elements in the grid - which is tracks using the
3259 * aApplied array. Cell inserts in the grid will only occur where there isn't
3260 * already a cell in that position.
3261 * @param {object} oSettings dataTables settings object
3262 * @param array {objects} aoSource Layout array from _fnDetectHeader
3263 * @param {boolean} [bIncludeHidden=false] If true then include the hidden columns in the calc,
3264 * @memberof DataTable#oApi
3265 */
3266 function _fnDrawHead( oSettings, aoSource, bIncludeHidden )
3267 {
3268 var i, iLen, j, jLen, k, kLen, n, nLocalTr;
3269 var aoLocal = [];
3270 var aApplied = [];
3271 var iColumns = oSettings.aoColumns.length;
3272 var iRowspan, iColspan;
3274 if ( ! aoSource )
3275 {
3276 return;
3277 }
3279 if ( bIncludeHidden === undefined )
3280 {
3281 bIncludeHidden = false;
3282 }
3284 /* Make a copy of the master layout array, but without the visible columns in it */
3285 for ( i=0, iLen=aoSource.length ; i<iLen ; i++ )
3286 {
3287 aoLocal[i] = aoSource[i].slice();
3288 aoLocal[i].nTr = aoSource[i].nTr;
3290 /* Remove any columns which are currently hidden */
3291 for ( j=iColumns-1 ; j>=0 ; j-- )
3292 {
3293 if ( !oSettings.aoColumns[j].bVisible && !bIncludeHidden )
3294 {
3295 aoLocal[i].splice( j, 1 );
3296 }
3297 }
3299 /* Prep the applied array - it needs an element for each row */
3300 aApplied.push( [] );
3301 }
3303 for ( i=0, iLen=aoLocal.length ; i<iLen ; i++ )
3304 {
3305 nLocalTr = aoLocal[i].nTr;
3307 /* All cells are going to be replaced, so empty out the row */
3308 if ( nLocalTr )
3309 {
3310 while( (n = nLocalTr.firstChild) )
3311 {
3312 nLocalTr.removeChild( n );
3313 }
3314 }
3316 for ( j=0, jLen=aoLocal[i].length ; j<jLen ; j++ )
3317 {
3318 iRowspan = 1;
3319 iColspan = 1;
3321 /* Check to see if there is already a cell (row/colspan) covering our target
3322 * insert point. If there is, then there is nothing to do.
3323 */
3324 if ( aApplied[i][j] === undefined )
3325 {
3326 nLocalTr.appendChild( aoLocal[i][j].cell );
3327 aApplied[i][j] = 1;
3329 /* Expand the cell to cover as many rows as needed */
3330 while ( aoLocal[i+iRowspan] !== undefined &&
3331 aoLocal[i][j].cell == aoLocal[i+iRowspan][j].cell )
3332 {
3333 aApplied[i+iRowspan][j] = 1;
3334 iRowspan++;
3335 }
3337 /* Expand the cell to cover as many columns as needed */
3338 while ( aoLocal[i][j+iColspan] !== undefined &&
3339 aoLocal[i][j].cell == aoLocal[i][j+iColspan].cell )
3340 {
3341 /* Must update the applied array over the rows for the columns */
3342 for ( k=0 ; k<iRowspan ; k++ )
3343 {
3344 aApplied[i+k][j+iColspan] = 1;
3345 }
3346 iColspan++;
3347 }
3349 /* Do the actual expansion in the DOM */
3350 $(aoLocal[i][j].cell)
3351 .attr('rowspan', iRowspan)
3352 .attr('colspan', iColspan);
3353 }
3354 }
3355 }
3356 }
3359 /**
3360 * Insert the required TR nodes into the table for display
3361 * @param {object} oSettings dataTables settings object
3362 * @memberof DataTable#oApi
3363 */
3364 function _fnDraw( oSettings )
3365 {
3366 /* Provide a pre-callback function which can be used to cancel the draw is false is returned */
3367 var aPreDraw = _fnCallbackFire( oSettings, 'aoPreDrawCallback', 'preDraw', [oSettings] );
3368 if ( $.inArray( false, aPreDraw ) !== -1 )
3369 {
3370 _fnProcessingDisplay( oSettings, false );
3371 return;
3372 }
3374 var i, iLen, n;
3375 var anRows = [];
3376 var iRowCount = 0;
3377 var asStripeClasses = oSettings.asStripeClasses;
3378 var iStripes = asStripeClasses.length;
3379 var iOpenRows = oSettings.aoOpenRows.length;
3380 var oLang = oSettings.oLanguage;
3381 var iInitDisplayStart = oSettings.iInitDisplayStart;
3382 var bServerSide = _fnDataSource( oSettings ) == 'ssp';
3383 var aiDisplay = oSettings.aiDisplay;
3385 oSettings.bDrawing = true;
3387 /* Check and see if we have an initial draw position from state saving */
3388 if ( iInitDisplayStart !== undefined && iInitDisplayStart !== -1 )
3389 {
3390 oSettings._iDisplayStart = bServerSide ?
3391 iInitDisplayStart :
3392 iInitDisplayStart >= oSettings.fnRecordsDisplay() ?
3393 0 :
3394 iInitDisplayStart;
3396 oSettings.iInitDisplayStart = -1;
3397 }
3399 var iDisplayStart = oSettings._iDisplayStart;
3400 var iDisplayEnd = oSettings.fnDisplayEnd();
3402 /* Server-side processing draw intercept */
3403 if ( oSettings.bDeferLoading )
3404 {
3405 oSettings.bDeferLoading = false;
3406 oSettings.iDraw++;
3407 _fnProcessingDisplay( oSettings, false );
3408 }
3409 else if ( !bServerSide )
3410 {
3411 oSettings.iDraw++;
3412 }
3413 else if ( !oSettings.bDestroying && !_fnAjaxUpdate( oSettings ) )
3414 {
3415 return;
3416 }
3418 if ( aiDisplay.length !== 0 )
3419 {
3420 var iStart = bServerSide ? 0 : iDisplayStart;
3421 var iEnd = bServerSide ? oSettings.aoData.length : iDisplayEnd;
3423 for ( var j=iStart ; j<iEnd ; j++ )
3424 {
3425 var iDataIndex = aiDisplay[j];
3426 var aoData = oSettings.aoData[ iDataIndex ];
3427 if ( aoData.nTr === null )
3428 {
3429 _fnCreateTr( oSettings, iDataIndex );
3430 }
3432 var nRow = aoData.nTr;
3434 /* Remove the old striping classes and then add the new one */
3435 if ( iStripes !== 0 )
3436 {
3437 var sStripe = asStripeClasses[ iRowCount % iStripes ];
3438 if ( aoData._sRowStripe != sStripe )
3439 {
3440 $(nRow).removeClass( aoData._sRowStripe ).addClass( sStripe );
3441 aoData._sRowStripe = sStripe;
3442 }
3443 }
3445 // Row callback functions - might want to manipulate the row
3446 // iRowCount and j are not currently documented. Are they at all
3447 // useful?
3448 _fnCallbackFire( oSettings, 'aoRowCallback', null,
3449 [nRow, aoData._aData, iRowCount, j] );
3451 anRows.push( nRow );
3452 iRowCount++;
3453 }
3454 }
3455 else
3456 {
3457 /* Table is empty - create a row with an empty message in it */
3458 var sZero = oLang.sZeroRecords;
3459 if ( oSettings.iDraw == 1 && _fnDataSource( oSettings ) == 'ajax' )
3460 {
3461 sZero = oLang.sLoadingRecords;
3462 }
3463 else if ( oLang.sEmptyTable && oSettings.fnRecordsTotal() === 0 )
3464 {
3465 sZero = oLang.sEmptyTable;
3466 }
3468 anRows[ 0 ] = $( '<tr/>', { 'class': iStripes ? asStripeClasses[0] : '' } )
3469 .append( $('<td />', {
3470 'valign': 'top',
3471 'colSpan': _fnVisbleColumns( oSettings ),
3472 'class': oSettings.oClasses.sRowEmpty
3473 } ).html( sZero ) )[0];
3474 }
3476 /* Header and footer callbacks */
3477 _fnCallbackFire( oSettings, 'aoHeaderCallback', 'header', [ $(oSettings.nTHead).children('tr')[0],
3478 _fnGetDataMaster( oSettings ), iDisplayStart, iDisplayEnd, aiDisplay ] );
3480 _fnCallbackFire( oSettings, 'aoFooterCallback', 'footer', [ $(oSettings.nTFoot).children('tr')[0],
3481 _fnGetDataMaster( oSettings ), iDisplayStart, iDisplayEnd, aiDisplay ] );
3483 var body = $(oSettings.nTBody);
3485 body.children().detach();
3486 body.append( $(anRows) );
3488 /* Call all required callback functions for the end of a draw */
3489 _fnCallbackFire( oSettings, 'aoDrawCallback', 'draw', [oSettings] );
3491 /* Draw is complete, sorting and filtering must be as well */
3492 oSettings.bSorted = false;
3493 oSettings.bFiltered = false;
3494 oSettings.bDrawing = false;
3495 }
3498 /**
3499 * Redraw the table - taking account of the various features which are enabled
3500 * @param {object} oSettings dataTables settings object
3501 * @param {boolean} [holdPosition] Keep the current paging position. By default
3502 * the paging is reset to the first page
3503 * @memberof DataTable#oApi
3504 */
3505 function _fnReDraw( settings, holdPosition )
3506 {
3507 var
3508 features = settings.oFeatures,
3509 sort = features.bSort,
3510 filter = features.bFilter;
3512 if ( sort ) {
3513 _fnSort( settings );
3514 }
3516 if ( filter ) {
3517 _fnFilterComplete( settings, settings.oPreviousSearch );
3518 }
3519 else {
3520 // No filtering, so we want to just use the display master
3521 settings.aiDisplay = settings.aiDisplayMaster.slice();
3522 }
3524 if ( holdPosition !== true ) {
3525 settings._iDisplayStart = 0;
3526 }
3528 // Let any modules know about the draw hold position state (used by
3529 // scrolling internally)
3530 settings._drawHold = holdPosition;
3532 _fnDraw( settings );
3534 settings._drawHold = false;
3535 }
3538 /**
3539 * Add the options to the page HTML for the table
3540 * @param {object} oSettings dataTables settings object
3541 * @memberof DataTable#oApi
3542 */
3543 function _fnAddOptionsHtml ( oSettings )
3544 {
3545 var classes = oSettings.oClasses;
3546 var table = $(oSettings.nTable);
3547 var holding = $('<div/>').insertBefore( table ); // Holding element for speed
3548 var features = oSettings.oFeatures;
3550 // All DataTables are wrapped in a div
3551 var insert = $('<div/>', {
3552 id: oSettings.sTableId+'_wrapper',
3553 'class': classes.sWrapper + (oSettings.nTFoot ? '' : ' '+classes.sNoFooter)
3554 } );
3556 oSettings.nHolding = holding[0];
3557 oSettings.nTableWrapper = insert[0];
3558 oSettings.nTableReinsertBefore = oSettings.nTable.nextSibling;
3560 /* Loop over the user set positioning and place the elements as needed */
3561 var aDom = oSettings.sDom.split('');
3562 var featureNode, cOption, nNewNode, cNext, sAttr, j;
3563 for ( var i=0 ; i<aDom.length ; i++ )
3564 {
3565 featureNode = null;
3566 cOption = aDom[i];
3568 if ( cOption == '<' )
3569 {
3570 /* New container div */
3571 nNewNode = $('<div/>')[0];
3573 /* Check to see if we should append an id and/or a class name to the container */
3574 cNext = aDom[i+1];
3575 if ( cNext == "'" || cNext == '"' )
3576 {
3577 sAttr = "";
3578 j = 2;
3579 while ( aDom[i+j] != cNext )
3580 {
3581 sAttr += aDom[i+j];
3582 j++;
3583 }
3585 /* Replace jQuery UI constants @todo depreciated */
3586 if ( sAttr == "H" )
3587 {
3588 sAttr = classes.sJUIHeader;
3589 }
3590 else if ( sAttr == "F" )
3591 {
3592 sAttr = classes.sJUIFooter;
3593 }
3595 /* The attribute can be in the format of "#id.class", "#id" or "class" This logic
3596 * breaks the string into parts and applies them as needed
3597 */
3598 if ( sAttr.indexOf('.') != -1 )
3599 {
3600 var aSplit = sAttr.split('.');
3601 nNewNode.id = aSplit[0].substr(1, aSplit[0].length-1);
3602 nNewNode.className = aSplit[1];
3603 }
3604 else if ( sAttr.charAt(0) == "#" )
3605 {
3606 nNewNode.id = sAttr.substr(1, sAttr.length-1);
3607 }
3608 else
3609 {
3610 nNewNode.className = sAttr;
3611 }
3613 i += j; /* Move along the position array */
3614 }
3616 insert.append( nNewNode );
3617 insert = $(nNewNode);
3618 }
3619 else if ( cOption == '>' )
3620 {
3621 /* End container div */
3622 insert = insert.parent();
3623 }
3624 // @todo Move options into their own plugins?
3625 else if ( cOption == 'l' && features.bPaginate && features.bLengthChange )
3626 {
3627 /* Length */
3628 featureNode = _fnFeatureHtmlLength( oSettings );
3629 }
3630 else if ( cOption == 'f' && features.bFilter )
3631 {
3632 /* Filter */
3633 featureNode = _fnFeatureHtmlFilter( oSettings );
3634 }
3635 else if ( cOption == 'r' && features.bProcessing )
3636 {
3637 /* pRocessing */
3638 featureNode = _fnFeatureHtmlProcessing( oSettings );
3639 }
3640 else if ( cOption == 't' )
3641 {
3642 /* Table */
3643 featureNode = _fnFeatureHtmlTable( oSettings );
3644 }
3645 else if ( cOption == 'i' && features.bInfo )
3646 {
3647 /* Info */
3648 featureNode = _fnFeatureHtmlInfo( oSettings );
3649 }
3650 else if ( cOption == 'p' && features.bPaginate )
3651 {
3652 /* Pagination */
3653 featureNode = _fnFeatureHtmlPaginate( oSettings );
3654 }
3655 else if ( DataTable.ext.feature.length !== 0 )
3656 {
3657 /* Plug-in features */
3658 var aoFeatures = DataTable.ext.feature;
3659 for ( var k=0, kLen=aoFeatures.length ; k<kLen ; k++ )
3660 {
3661 if ( cOption == aoFeatures[k].cFeature )
3662 {
3663 featureNode = aoFeatures[k].fnInit( oSettings );
3664 break;
3665 }
3666 }
3667 }
3669 /* Add to the 2D features array */
3670 if ( featureNode )
3671 {
3672 var aanFeatures = oSettings.aanFeatures;
3674 if ( ! aanFeatures[cOption] )
3675 {
3676 aanFeatures[cOption] = [];
3677 }
3679 aanFeatures[cOption].push( featureNode );
3680 insert.append( featureNode );
3681 }
3682 }
3684 /* Built our DOM structure - replace the holding div with what we want */
3685 holding.replaceWith( insert );
3686 oSettings.nHolding = null;
3687 }
3690 /**
3691 * Use the DOM source to create up an array of header cells. The idea here is to
3692 * create a layout grid (array) of rows x columns, which contains a reference
3693 * to the cell that that point in the grid (regardless of col/rowspan), such that
3694 * any column / row could be removed and the new grid constructed
3695 * @param array {object} aLayout Array to store the calculated layout in
3696 * @param {node} nThead The header/footer element for the table
3697 * @memberof DataTable#oApi
3698 */
3699 function _fnDetectHeader ( aLayout, nThead )
3700 {
3701 var nTrs = $(nThead).children('tr');
3702 var nTr, nCell;
3703 var i, k, l, iLen, jLen, iColShifted, iColumn, iColspan, iRowspan;
3704 var bUnique;
3705 var fnShiftCol = function ( a, i, j ) {
3706 var k = a[i];
3707 while ( k[j] ) {
3708 j++;
3709 }
3710 return j;
3711 };
3713 aLayout.splice( 0, aLayout.length );
3715 /* We know how many rows there are in the layout - so prep it */
3716 for ( i=0, iLen=nTrs.length ; i<iLen ; i++ )
3717 {
3718 aLayout.push( [] );
3719 }
3721 /* Calculate a layout array */
3722 for ( i=0, iLen=nTrs.length ; i<iLen ; i++ )
3723 {
3724 nTr = nTrs[i];
3725 iColumn = 0;
3727 /* For every cell in the row... */
3728 nCell = nTr.firstChild;
3729 while ( nCell ) {
3730 if ( nCell.nodeName.toUpperCase() == "TD" ||
3731 nCell.nodeName.toUpperCase() == "TH" )
3732 {
3733 /* Get the col and rowspan attributes from the DOM and sanitise them */
3734 iColspan = nCell.getAttribute('colspan') * 1;
3735 iRowspan = nCell.getAttribute('rowspan') * 1;
3736 iColspan = (!iColspan || iColspan===0 || iColspan===1) ? 1 : iColspan;
3737 iRowspan = (!iRowspan || iRowspan===0 || iRowspan===1) ? 1 : iRowspan;
3739 /* There might be colspan cells already in this row, so shift our target
3740 * accordingly
3741 */
3742 iColShifted = fnShiftCol( aLayout, i, iColumn );
3744 /* Cache calculation for unique columns */
3745 bUnique = iColspan === 1 ? true : false;
3747 /* If there is col / rowspan, copy the information into the layout grid */
3748 for ( l=0 ; l<iColspan ; l++ )
3749 {
3750 for ( k=0 ; k<iRowspan ; k++ )
3751 {
3752 aLayout[i+k][iColShifted+l] = {
3753 "cell": nCell,
3754 "unique": bUnique
3755 };
3756 aLayout[i+k].nTr = nTr;
3757 }
3758 }
3759 }
3760 nCell = nCell.nextSibling;
3761 }
3762 }
3763 }
3766 /**
3767 * Get an array of unique th elements, one for each column
3768 * @param {object} oSettings dataTables settings object
3769 * @param {node} nHeader automatically detect the layout from this node - optional
3770 * @param {array} aLayout thead/tfoot layout from _fnDetectHeader - optional
3771 * @returns array {node} aReturn list of unique th's
3772 * @memberof DataTable#oApi
3773 */
3774 function _fnGetUniqueThs ( oSettings, nHeader, aLayout )
3775 {
3776 var aReturn = [];
3777 if ( !aLayout )
3778 {
3779 aLayout = oSettings.aoHeader;
3780 if ( nHeader )
3781 {
3782 aLayout = [];
3783 _fnDetectHeader( aLayout, nHeader );
3784 }
3785 }
3787 for ( var i=0, iLen=aLayout.length ; i<iLen ; i++ )
3788 {
3789 for ( var j=0, jLen=aLayout[i].length ; j<jLen ; j++ )
3790 {
3791 if ( aLayout[i][j].unique &&
3792 (!aReturn[j] || !oSettings.bSortCellsTop) )
3793 {
3794 aReturn[j] = aLayout[i][j].cell;
3795 }
3796 }
3797 }
3799 return aReturn;
3800 }
3802 /**
3803 * Create an Ajax call based on the table's settings, taking into account that
3804 * parameters can have multiple forms, and backwards compatibility.
3805 *
3806 * @param {object} oSettings dataTables settings object
3807 * @param {array} data Data to send to the server, required by
3808 * DataTables - may be augmented by developer callbacks
3809 * @param {function} fn Callback function to run when data is obtained
3810 */
3811 function _fnBuildAjax( oSettings, data, fn )
3812 {
3813 // Compatibility with 1.9-, allow fnServerData and event to manipulate
3814 _fnCallbackFire( oSettings, 'aoServerParams', 'serverParams', [data] );
3816 // Convert to object based for 1.10+ if using the old array scheme which can
3817 // come from server-side processing or serverParams
3818 if ( data && $.isArray(data) ) {
3819 var tmp = {};
3820 var rbracket = /(.*?)\[\]$/;
3822 $.each( data, function (key, val) {
3823 var match = val.name.match(rbracket);
3825 if ( match ) {
3826 // Support for arrays
3827 var name = match[0];
3829 if ( ! tmp[ name ] ) {
3830 tmp[ name ] = [];
3831 }
3832 tmp[ name ].push( val.value );
3833 }
3834 else {
3835 tmp[val.name] = val.value;
3836 }
3837 } );
3838 data = tmp;
3839 }
3841 var ajaxData;
3842 var ajax = oSettings.ajax;
3843 var instance = oSettings.oInstance;
3844 var callback = function ( json ) {
3845 _fnCallbackFire( oSettings, null, 'xhr', [oSettings, json, oSettings.jqXHR] );
3846 fn( json );
3847 };
3849 if ( $.isPlainObject( ajax ) && ajax.data )
3850 {
3851 ajaxData = ajax.data;
3853 var newData = $.isFunction( ajaxData ) ?
3854 ajaxData( data, oSettings ) : // fn can manipulate data or return
3855 ajaxData; // an object object or array to merge
3857 // If the function returned something, use that alone
3858 data = $.isFunction( ajaxData ) && newData ?
3859 newData :
3860 $.extend( true, data, newData );
3862 // Remove the data property as we've resolved it already and don't want
3863 // jQuery to do it again (it is restored at the end of the function)
3864 delete ajax.data;
3865 }
3867 var baseAjax = {
3868 "data": data,
3869 "success": function (json) {
3870 var error = json.error || json.sError;
3871 if ( error ) {
3872 _fnLog( oSettings, 0, error );
3873 }
3875 oSettings.json = json;
3876 callback( json );
3877 },
3878 "dataType": "json",
3879 "cache": false,
3880 "type": oSettings.sServerMethod,
3881 "error": function (xhr, error, thrown) {
3882 var ret = _fnCallbackFire( oSettings, null, 'xhr', [oSettings, null, oSettings.jqXHR] );
3884 if ( $.inArray( true, ret ) === -1 ) {
3885 if ( error == "parsererror" ) {
3886 _fnLog( oSettings, 0, 'Invalid JSON response', 1 );
3887 }
3888 else if ( xhr.readyState === 4 ) {
3889 _fnLog( oSettings, 0, 'Ajax error', 7 );
3890 }
3891 }
3893 _fnProcessingDisplay( oSettings, false );
3894 }
3895 };
3897 // Store the data submitted for the API
3898 oSettings.oAjaxData = data;
3900 // Allow plug-ins and external processes to modify the data
3901 _fnCallbackFire( oSettings, null, 'preXhr', [oSettings, data] );
3903 if ( oSettings.fnServerData )
3904 {
3905 // DataTables 1.9- compatibility
3906 oSettings.fnServerData.call( instance,
3907 oSettings.sAjaxSource,
3908 $.map( data, function (val, key) { // Need to convert back to 1.9 trad format
3909 return { name: key, value: val };
3910 } ),
3911 callback,
3912 oSettings
3913 );
3914 }
3915 else if ( oSettings.sAjaxSource || typeof ajax === 'string' )
3916 {
3917 // DataTables 1.9- compatibility
3918 oSettings.jqXHR = $.ajax( $.extend( baseAjax, {
3919 url: ajax || oSettings.sAjaxSource
3920 } ) );
3921 }
3922 else if ( $.isFunction( ajax ) )
3923 {
3924 // Is a function - let the caller define what needs to be done
3925 oSettings.jqXHR = ajax.call( instance, data, callback, oSettings );
3926 }
3927 else
3928 {
3929 // Object to extend the base settings
3930 oSettings.jqXHR = $.ajax( $.extend( baseAjax, ajax ) );
3932 // Restore for next time around
3933 ajax.data = ajaxData;
3934 }
3935 }
3938 /**
3939 * Update the table using an Ajax call
3940 * @param {object} settings dataTables settings object
3941 * @returns {boolean} Block the table drawing or not
3942 * @memberof DataTable#oApi
3943 */
3944 function _fnAjaxUpdate( settings )
3945 {
3946 if ( settings.bAjaxDataGet ) {
3947 settings.iDraw++;
3948 _fnProcessingDisplay( settings, true );
3950 _fnBuildAjax(
3951 settings,
3952 _fnAjaxParameters( settings ),
3953 function(json) {
3954 _fnAjaxUpdateDraw( settings, json );
3955 }
3956 );
3958 return false;
3959 }
3960 return true;
3961 }
3964 /**
3965 * Build up the parameters in an object needed for a server-side processing
3966 * request. Note that this is basically done twice, is different ways - a modern
3967 * method which is used by default in DataTables 1.10 which uses objects and
3968 * arrays, or the 1.9- method with is name / value pairs. 1.9 method is used if
3969 * the sAjaxSource option is used in the initialisation, or the legacyAjax
3970 * option is set.
3971 * @param {object} oSettings dataTables settings object
3972 * @returns {bool} block the table drawing or not
3973 * @memberof DataTable#oApi
3974 */
3975 function _fnAjaxParameters( settings )
3976 {
3977 var
3978 columns = settings.aoColumns,
3979 columnCount = columns.length,
3980 features = settings.oFeatures,
3981 preSearch = settings.oPreviousSearch,
3982 preColSearch = settings.aoPreSearchCols,
3983 i, data = [], dataProp, column, columnSearch,
3984 sort = _fnSortFlatten( settings ),
3985 displayStart = settings._iDisplayStart,
3986 displayLength = features.bPaginate !== false ?
3987 settings._iDisplayLength :
3988 -1;
3990 var param = function ( name, value ) {
3991 data.push( { 'name': name, 'value': value } );
3992 };
3994 // DataTables 1.9- compatible method
3995 param( 'sEcho', settings.iDraw );
3996 param( 'iColumns', columnCount );
3997 param( 'sColumns', _pluck( columns, 'sName' ).join(',') );
3998 param( 'iDisplayStart', displayStart );
3999 param( 'iDisplayLength', displayLength );
4001 // DataTables 1.10+ method
4002 var d = {
4003 draw: settings.iDraw,
4004 columns: [],
4005 order: [],
4006 start: displayStart,
4007 length: displayLength,
4008 search: {
4009 value: preSearch.sSearch,
4010 regex: preSearch.bRegex
4011 }
4012 };
4014 for ( i=0 ; i<columnCount ; i++ ) {
4015 column = columns[i];
4016 columnSearch = preColSearch[i];
4017 dataProp = typeof column.mData=="function" ? 'function' : column.mData ;
4019 d.columns.push( {
4020 data: dataProp,
4021 name: column.sName,
4022 searchable: column.bSearchable,
4023 orderable: column.bSortable,
4024 search: {
4025 value: columnSearch.sSearch,
4026 regex: columnSearch.bRegex
4027 }
4028 } );
4030 param( "mDataProp_"+i, dataProp );
4032 if ( features.bFilter ) {
4033 param( 'sSearch_'+i, columnSearch.sSearch );
4034 param( 'bRegex_'+i, columnSearch.bRegex );
4035 param( 'bSearchable_'+i, column.bSearchable );
4036 }
4038 if ( features.bSort ) {
4039 param( 'bSortable_'+i, column.bSortable );
4040 }
4041 }
4043 if ( features.bFilter ) {
4044 param( 'sSearch', preSearch.sSearch );
4045 param( 'bRegex', preSearch.bRegex );
4046 }
4048 if ( features.bSort ) {
4049 $.each( sort, function ( i, val ) {
4050 d.order.push( { column: val.col, dir: val.dir } );
4052 param( 'iSortCol_'+i, val.col );
4053 param( 'sSortDir_'+i, val.dir );
4054 } );
4056 param( 'iSortingCols', sort.length );
4057 }
4059 // If the legacy.ajax parameter is null, then we automatically decide which
4060 // form to use, based on sAjaxSource
4061 var legacy = DataTable.ext.legacy.ajax;
4062 if ( legacy === null ) {
4063 return settings.sAjaxSource ? data : d;
4064 }
4066 // Otherwise, if legacy has been specified then we use that to decide on the
4067 // form
4068 return legacy ? data : d;
4069 }
4072 /**
4073 * Data the data from the server (nuking the old) and redraw the table
4074 * @param {object} oSettings dataTables settings object
4075 * @param {object} json json data return from the server.
4076 * @param {string} json.sEcho Tracking flag for DataTables to match requests
4077 * @param {int} json.iTotalRecords Number of records in the data set, not accounting for filtering
4078 * @param {int} json.iTotalDisplayRecords Number of records in the data set, accounting for filtering
4079 * @param {array} json.aaData The data to display on this page
4080 * @param {string} [json.sColumns] Column ordering (sName, comma separated)
4081 * @memberof DataTable#oApi
4082 */
4083 function _fnAjaxUpdateDraw ( settings, json )
4084 {
4085 // v1.10 uses camelCase variables, while 1.9 uses Hungarian notation.
4086 // Support both
4087 var compat = function ( old, modern ) {
4088 return json[old] !== undefined ? json[old] : json[modern];
4089 };
4091 var data = _fnAjaxDataSrc( settings, json );
4092 var draw = compat( 'sEcho', 'draw' );
4093 var recordsTotal = compat( 'iTotalRecords', 'recordsTotal' );
4094 var recordsFiltered = compat( 'iTotalDisplayRecords', 'recordsFiltered' );
4096 if ( draw ) {
4097 // Protect against out of sequence returns
4098 if ( draw*1 < settings.iDraw ) {
4099 return;
4100 }
4101 settings.iDraw = draw * 1;
4102 }
4104 _fnClearTable( settings );
4105 settings._iRecordsTotal = parseInt(recordsTotal, 10);
4106 settings._iRecordsDisplay = parseInt(recordsFiltered, 10);
4108 for ( var i=0, ien=data.length ; i<ien ; i++ ) {
4109 _fnAddData( settings, data[i] );
4110 }
4111 settings.aiDisplay = settings.aiDisplayMaster.slice();
4113 settings.bAjaxDataGet = false;
4114 _fnDraw( settings );
4116 if ( ! settings._bInitComplete ) {
4117 _fnInitComplete( settings, json );
4118 }
4120 settings.bAjaxDataGet = true;
4121 _fnProcessingDisplay( settings, false );
4122 }
4125 /**
4126 * Get the data from the JSON data source to use for drawing a table. Using
4127 * `_fnGetObjectDataFn` allows the data to be sourced from a property of the
4128 * source object, or from a processing function.
4129 * @param {object} oSettings dataTables settings object
4130 * @param {object} json Data source object / array from the server
4131 * @return {array} Array of data to use
4132 */
4133 function _fnAjaxDataSrc ( oSettings, json )
4134 {
4135 var dataSrc = $.isPlainObject( oSettings.ajax ) && oSettings.ajax.dataSrc !== undefined ?
4136 oSettings.ajax.dataSrc :
4137 oSettings.sAjaxDataProp; // Compatibility with 1.9-.
4139 // Compatibility with 1.9-. In order to read from aaData, check if the
4140 // default has been changed, if not, check for aaData
4141 if ( dataSrc === 'data' ) {
4142 return json.aaData || json[dataSrc];
4143 }
4145 return dataSrc !== "" ?
4146 _fnGetObjectDataFn( dataSrc )( json ) :
4147 json;
4148 }
4150 /**
4151 * Generate the node required for filtering text
4152 * @returns {node} Filter control element
4153 * @param {object} oSettings dataTables settings object
4154 * @memberof DataTable#oApi
4155 */
4156 function _fnFeatureHtmlFilter ( settings )
4157 {
4158 var classes = settings.oClasses;
4159 var tableId = settings.sTableId;
4160 var language = settings.oLanguage;
4161 var previousSearch = settings.oPreviousSearch;
4162 var features = settings.aanFeatures;
4163 var input = '<input type="search" class="'+classes.sFilterInput+'"/>';
4165 var str = language.sSearch;
4166 str = str.match(/_INPUT_/) ?
4167 str.replace('_INPUT_', input) :
4168 str+input;
4170 var filter = $('<div/>', {
4171 'id': ! features.f ? tableId+'_filter' : null,
4172 'class': classes.sFilter
4173 } )
4174 .append( $('<label/>' ).append( str ) );
4176 var searchFn = function() {
4177 /* Update all other filter input elements for the new display */
4178 var n = features.f;
4179 var val = !this.value ? "" : this.value; // mental IE8 fix :-(
4181 /* Now do the filter */
4182 if ( val != previousSearch.sSearch ) {
4183 _fnFilterComplete( settings, {
4184 "sSearch": val,
4185 "bRegex": previousSearch.bRegex,
4186 "bSmart": previousSearch.bSmart ,
4187 "bCaseInsensitive": previousSearch.bCaseInsensitive
4188 } );
4190 // Need to redraw, without resorting
4191 settings._iDisplayStart = 0;
4192 _fnDraw( settings );
4193 }
4194 };
4196 var searchDelay = settings.searchDelay !== null ?
4197 settings.searchDelay :
4198 _fnDataSource( settings ) === 'ssp' ?
4199 400 :
4200 0;
4202 var jqFilter = $('input', filter)
4203 .val( previousSearch.sSearch )
4204 .attr( 'placeholder', language.sSearchPlaceholder )
4205 .bind(
4206 'keyup.DT search.DT input.DT paste.DT cut.DT',
4207 searchDelay ?
4208 _fnThrottle( searchFn, searchDelay ) :
4209 searchFn
4210 )
4211 .bind( 'keypress.DT', function(e) {
4212 /* Prevent form submission */
4213 if ( e.keyCode == 13 ) {
4214 return false;
4215 }
4216 } )
4217 .attr('aria-controls', tableId);
4219 // Update the input elements whenever the table is filtered
4220 $(settings.nTable).on( 'search.dt.DT', function ( ev, s ) {
4221 if ( settings === s ) {
4222 // IE9 throws an 'unknown error' if document.activeElement is used
4223 // inside an iframe or frame...
4224 try {
4225 if ( jqFilter[0] !== document.activeElement ) {
4226 jqFilter.val( previousSearch.sSearch );
4227 }
4228 }
4229 catch ( e ) {}
4230 }
4231 } );
4233 return filter[0];
4234 }
4237 /**
4238 * Filter the table using both the global filter and column based filtering
4239 * @param {object} oSettings dataTables settings object
4240 * @param {object} oSearch search information
4241 * @param {int} [iForce] force a research of the master array (1) or not (undefined or 0)
4242 * @memberof DataTable#oApi
4243 */
4244 function _fnFilterComplete ( oSettings, oInput, iForce )
4245 {
4246 var oPrevSearch = oSettings.oPreviousSearch;
4247 var aoPrevSearch = oSettings.aoPreSearchCols;
4248 var fnSaveFilter = function ( oFilter ) {
4249 /* Save the filtering values */
4250 oPrevSearch.sSearch = oFilter.sSearch;
4251 oPrevSearch.bRegex = oFilter.bRegex;
4252 oPrevSearch.bSmart = oFilter.bSmart;
4253 oPrevSearch.bCaseInsensitive = oFilter.bCaseInsensitive;
4254 };
4255 var fnRegex = function ( o ) {
4256 // Backwards compatibility with the bEscapeRegex option
4257 return o.bEscapeRegex !== undefined ? !o.bEscapeRegex : o.bRegex;
4258 };
4260 // Resolve any column types that are unknown due to addition or invalidation
4261 // @todo As per sort - can this be moved into an event handler?
4262 _fnColumnTypes( oSettings );
4264 /* In server-side processing all filtering is done by the server, so no point hanging around here */
4265 if ( _fnDataSource( oSettings ) != 'ssp' )
4266 {
4267 /* Global filter */
4268 _fnFilter( oSettings, oInput.sSearch, iForce, fnRegex(oInput), oInput.bSmart, oInput.bCaseInsensitive );
4269 fnSaveFilter( oInput );
4271 /* Now do the individual column filter */
4272 for ( var i=0 ; i<aoPrevSearch.length ; i++ )
4273 {
4274 _fnFilterColumn( oSettings, aoPrevSearch[i].sSearch, i, fnRegex(aoPrevSearch[i]),
4275 aoPrevSearch[i].bSmart, aoPrevSearch[i].bCaseInsensitive );
4276 }
4278 /* Custom filtering */
4279 _fnFilterCustom( oSettings );
4280 }
4281 else
4282 {
4283 fnSaveFilter( oInput );
4284 }
4286 /* Tell the draw function we have been filtering */
4287 oSettings.bFiltered = true;
4288 _fnCallbackFire( oSettings, null, 'search', [oSettings] );
4289 }
4292 /**
4293 * Apply custom filtering functions
4294 * @param {object} oSettings dataTables settings object
4295 * @memberof DataTable#oApi
4296 */
4297 function _fnFilterCustom( settings )
4298 {
4299 var filters = DataTable.ext.search;
4300 var displayRows = settings.aiDisplay;
4301 var row, rowIdx;
4303 for ( var i=0, ien=filters.length ; i<ien ; i++ ) {
4304 var rows = [];
4306 // Loop over each row and see if it should be included
4307 for ( var j=0, jen=displayRows.length ; j<jen ; j++ ) {
4308 rowIdx = displayRows[ j ];
4309 row = settings.aoData[ rowIdx ];
4311 if ( filters[i]( settings, row._aFilterData, rowIdx, row._aData, j ) ) {
4312 rows.push( rowIdx );
4313 }
4314 }
4316 // So the array reference doesn't break set the results into the
4317 // existing array
4318 displayRows.length = 0;
4319 $.merge( displayRows, rows );
4320 }
4321 }
4324 /**
4325 * Filter the table on a per-column basis
4326 * @param {object} oSettings dataTables settings object
4327 * @param {string} sInput string to filter on
4328 * @param {int} iColumn column to filter
4329 * @param {bool} bRegex treat search string as a regular expression or not
4330 * @param {bool} bSmart use smart filtering or not
4331 * @param {bool} bCaseInsensitive Do case insenstive matching or not
4332 * @memberof DataTable#oApi
4333 */
4334 function _fnFilterColumn ( settings, searchStr, colIdx, regex, smart, caseInsensitive )
4335 {
4336 if ( searchStr === '' ) {
4337 return;
4338 }
4340 var data;
4341 var display = settings.aiDisplay;
4342 var rpSearch = _fnFilterCreateSearch( searchStr, regex, smart, caseInsensitive );
4344 for ( var i=display.length-1 ; i>=0 ; i-- ) {
4345 data = settings.aoData[ display[i] ]._aFilterData[ colIdx ];
4347 if ( ! rpSearch.test( data ) ) {
4348 display.splice( i, 1 );
4349 }
4350 }
4351 }
4354 /**
4355 * Filter the data table based on user input and draw the table
4356 * @param {object} settings dataTables settings object
4357 * @param {string} input string to filter on
4358 * @param {int} force optional - force a research of the master array (1) or not (undefined or 0)
4359 * @param {bool} regex treat as a regular expression or not
4360 * @param {bool} smart perform smart filtering or not
4361 * @param {bool} caseInsensitive Do case insenstive matching or not
4362 * @memberof DataTable#oApi
4363 */
4364 function _fnFilter( settings, input, force, regex, smart, caseInsensitive )
4365 {
4366 var rpSearch = _fnFilterCreateSearch( input, regex, smart, caseInsensitive );
4367 var prevSearch = settings.oPreviousSearch.sSearch;
4368 var displayMaster = settings.aiDisplayMaster;
4369 var display, invalidated, i;
4371 // Need to take account of custom filtering functions - always filter
4372 if ( DataTable.ext.search.length !== 0 ) {
4373 force = true;
4374 }
4376 // Check if any of the rows were invalidated
4377 invalidated = _fnFilterData( settings );
4379 // If the input is blank - we just want the full data set
4380 if ( input.length <= 0 ) {
4381 settings.aiDisplay = displayMaster.slice();
4382 }
4383 else {
4384 // New search - start from the master array
4385 if ( invalidated ||
4386 force ||
4387 prevSearch.length > input.length ||
4388 input.indexOf(prevSearch) !== 0 ||
4389 settings.bSorted // On resort, the display master needs to be
4390 // re-filtered since indexes will have changed
4391 ) {
4392 settings.aiDisplay = displayMaster.slice();
4393 }
4395 // Search the display array
4396 display = settings.aiDisplay;
4398 for ( i=display.length-1 ; i>=0 ; i-- ) {
4399 if ( ! rpSearch.test( settings.aoData[ display[i] ]._sFilterRow ) ) {
4400 display.splice( i, 1 );
4401 }
4402 }
4403 }
4404 }
4407 /**
4408 * Build a regular expression object suitable for searching a table
4409 * @param {string} sSearch string to search for
4410 * @param {bool} bRegex treat as a regular expression or not
4411 * @param {bool} bSmart perform smart filtering or not
4412 * @param {bool} bCaseInsensitive Do case insensitive matching or not
4413 * @returns {RegExp} constructed object
4414 * @memberof DataTable#oApi
4415 */
4416 function _fnFilterCreateSearch( search, regex, smart, caseInsensitive )
4417 {
4418 search = regex ?
4419 search :
4420 _fnEscapeRegex( search );
4422 if ( smart ) {
4423 /* For smart filtering we want to allow the search to work regardless of
4424 * word order. We also want double quoted text to be preserved, so word
4425 * order is important - a la google. So this is what we want to
4426 * generate:
4427 *
4428 * ^(?=.*?\bone\b)(?=.*?\btwo three\b)(?=.*?\bfour\b).*$
4429 */
4430 var a = $.map( search.match( /"[^"]+"|[^ ]+/g ) || [''], function ( word ) {
4431 if ( word.charAt(0) === '"' ) {
4432 var m = word.match( /^"(.*)"$/ );
4433 word = m ? m[1] : word;
4434 }
4436 return word.replace('"', '');
4437 } );
4439 search = '^(?=.*?'+a.join( ')(?=.*?' )+').*$';
4440 }
4442 return new RegExp( search, caseInsensitive ? 'i' : '' );
4443 }
4446 /**
4447 * Escape a string such that it can be used in a regular expression
4448 * @param {string} sVal string to escape
4449 * @returns {string} escaped string
4450 * @memberof DataTable#oApi
4451 */
4452 var _fnEscapeRegex = DataTable.util.escapeRegex;
4454 var __filter_div = $('<div>')[0];
4455 var __filter_div_textContent = __filter_div.textContent !== undefined;
4457 // Update the filtering data for each row if needed (by invalidation or first run)
4458 function _fnFilterData ( settings )
4459 {
4460 var columns = settings.aoColumns;
4461 var column;
4462 var i, j, ien, jen, filterData, cellData, row;
4463 var fomatters = DataTable.ext.type.search;
4464 var wasInvalidated = false;
4466 for ( i=0, ien=settings.aoData.length ; i<ien ; i++ ) {
4467 row = settings.aoData[i];
4469 if ( ! row._aFilterData ) {
4470 filterData = [];
4472 for ( j=0, jen=columns.length ; j<jen ; j++ ) {
4473 column = columns[j];
4475 if ( column.bSearchable ) {
4476 cellData = _fnGetCellData( settings, i, j, 'filter' );
4478 if ( fomatters[ column.sType ] ) {
4479 cellData = fomatters[ column.sType ]( cellData );
4480 }
4482 // Search in DataTables 1.10 is string based. In 1.11 this
4483 // should be altered to also allow strict type checking.
4484 if ( cellData === null ) {
4485 cellData = '';
4486 }
4488 if ( typeof cellData !== 'string' && cellData.toString ) {
4489 cellData = cellData.toString();
4490 }
4491 }
4492 else {
4493 cellData = '';
4494 }
4496 // If it looks like there is an HTML entity in the string,
4497 // attempt to decode it so sorting works as expected. Note that
4498 // we could use a single line of jQuery to do this, but the DOM
4499 // method used here is much faster http://jsperf.com/html-decode
4500 if ( cellData.indexOf && cellData.indexOf('&') !== -1 ) {
4501 __filter_div.innerHTML = cellData;
4502 cellData = __filter_div_textContent ?
4503 __filter_div.textContent :
4504 __filter_div.innerText;
4505 }
4507 if ( cellData.replace ) {
4508 cellData = cellData.replace(/[\r\n]/g, '');
4509 }
4511 filterData.push( cellData );
4512 }
4514 row._aFilterData = filterData;
4515 row._sFilterRow = filterData.join(' ');
4516 wasInvalidated = true;
4517 }
4518 }
4520 return wasInvalidated;
4521 }
4524 /**
4525 * Convert from the internal Hungarian notation to camelCase for external
4526 * interaction
4527 * @param {object} obj Object to convert
4528 * @returns {object} Inverted object
4529 * @memberof DataTable#oApi
4530 */
4531 function _fnSearchToCamel ( obj )
4532 {
4533 return {
4534 search: obj.sSearch,
4535 smart: obj.bSmart,
4536 regex: obj.bRegex,
4537 caseInsensitive: obj.bCaseInsensitive
4538 };
4539 }
4543 /**
4544 * Convert from camelCase notation to the internal Hungarian. We could use the
4545 * Hungarian convert function here, but this is cleaner
4546 * @param {object} obj Object to convert
4547 * @returns {object} Inverted object
4548 * @memberof DataTable#oApi
4549 */
4550 function _fnSearchToHung ( obj )
4551 {
4552 return {
4553 sSearch: obj.search,
4554 bSmart: obj.smart,
4555 bRegex: obj.regex,
4556 bCaseInsensitive: obj.caseInsensitive
4557 };
4558 }
4560 /**
4561 * Generate the node required for the info display
4562 * @param {object} oSettings dataTables settings object
4563 * @returns {node} Information element
4564 * @memberof DataTable#oApi
4565 */
4566 function _fnFeatureHtmlInfo ( settings )
4567 {
4568 var
4569 tid = settings.sTableId,
4570 nodes = settings.aanFeatures.i,
4571 n = $('<div/>', {
4572 'class': settings.oClasses.sInfo,
4573 'id': ! nodes ? tid+'_info' : null
4574 } );
4576 if ( ! nodes ) {
4577 // Update display on each draw
4578 settings.aoDrawCallback.push( {
4579 "fn": _fnUpdateInfo,
4580 "sName": "information"
4581 } );
4583 n
4584 .attr( 'role', 'status' )
4585 .attr( 'aria-live', 'polite' );
4587 // Table is described by our info div
4588 $(settings.nTable).attr( 'aria-describedby', tid+'_info' );
4589 }
4591 return n[0];
4592 }
4595 /**
4596 * Update the information elements in the display
4597 * @param {object} settings dataTables settings object
4598 * @memberof DataTable#oApi
4599 */
4600 function _fnUpdateInfo ( settings )
4601 {
4602 /* Show information about the table */
4603 var nodes = settings.aanFeatures.i;
4604 if ( nodes.length === 0 ) {
4605 return;
4606 }
4608 var
4609 lang = settings.oLanguage,
4610 start = settings._iDisplayStart+1,
4611 end = settings.fnDisplayEnd(),
4612 max = settings.fnRecordsTotal(),
4613 total = settings.fnRecordsDisplay(),
4614 out = total ?
4615 lang.sInfo :
4616 lang.sInfoEmpty;
4618 if ( total !== max ) {
4619 /* Record set after filtering */
4620 out += ' ' + lang.sInfoFiltered;
4621 }
4623 // Convert the macros
4624 out += lang.sInfoPostFix;
4625 out = _fnInfoMacros( settings, out );
4627 var callback = lang.fnInfoCallback;
4628 if ( callback !== null ) {
4629 out = callback.call( settings.oInstance,
4630 settings, start, end, max, total, out
4631 );
4632 }
4634 $(nodes).html( out );
4635 }
4638 function _fnInfoMacros ( settings, str )
4639 {
4640 // When infinite scrolling, we are always starting at 1. _iDisplayStart is used only
4641 // internally
4642 var
4643 formatter = settings.fnFormatNumber,
4644 start = settings._iDisplayStart+1,
4645 len = settings._iDisplayLength,
4646 vis = settings.fnRecordsDisplay(),
4647 all = len === -1;
4649 return str.
4650 replace(/_START_/g, formatter.call( settings, start ) ).
4651 replace(/_END_/g, formatter.call( settings, settings.fnDisplayEnd() ) ).
4652 replace(/_MAX_/g, formatter.call( settings, settings.fnRecordsTotal() ) ).
4653 replace(/_TOTAL_/g, formatter.call( settings, vis ) ).
4654 replace(/_PAGE_/g, formatter.call( settings, all ? 1 : Math.ceil( start / len ) ) ).
4655 replace(/_PAGES_/g, formatter.call( settings, all ? 1 : Math.ceil( vis / len ) ) );
4656 }
4660 /**
4661 * Draw the table for the first time, adding all required features
4662 * @param {object} settings dataTables settings object
4663 * @memberof DataTable#oApi
4664 */
4665 function _fnInitialise ( settings )
4666 {
4667 var i, iLen, iAjaxStart=settings.iInitDisplayStart;
4668 var columns = settings.aoColumns, column;
4669 var features = settings.oFeatures;
4670 var deferLoading = settings.bDeferLoading; // value modified by the draw
4672 /* Ensure that the table data is fully initialised */
4673 if ( ! settings.bInitialised ) {
4674 setTimeout( function(){ _fnInitialise( settings ); }, 200 );
4675 return;
4676 }
4678 /* Show the display HTML options */
4679 _fnAddOptionsHtml( settings );
4681 /* Build and draw the header / footer for the table */
4682 _fnBuildHead( settings );
4683 _fnDrawHead( settings, settings.aoHeader );
4684 _fnDrawHead( settings, settings.aoFooter );
4686 /* Okay to show that something is going on now */
4687 _fnProcessingDisplay( settings, true );
4689 /* Calculate sizes for columns */
4690 if ( features.bAutoWidth ) {
4691 _fnCalculateColumnWidths( settings );
4692 }
4694 for ( i=0, iLen=columns.length ; i<iLen ; i++ ) {
4695 column = columns[i];
4697 if ( column.sWidth ) {
4698 column.nTh.style.width = _fnStringToCss( column.sWidth );
4699 }
4700 }
4702 _fnCallbackFire( settings, null, 'preInit', [settings] );
4704 // If there is default sorting required - let's do it. The sort function
4705 // will do the drawing for us. Otherwise we draw the table regardless of the
4706 // Ajax source - this allows the table to look initialised for Ajax sourcing
4707 // data (show 'loading' message possibly)
4708 _fnReDraw( settings );
4710 // Server-side processing init complete is done by _fnAjaxUpdateDraw
4711 var dataSrc = _fnDataSource( settings );
4712 if ( dataSrc != 'ssp' || deferLoading ) {
4713 // if there is an ajax source load the data
4714 if ( dataSrc == 'ajax' ) {
4715 _fnBuildAjax( settings, [], function(json) {
4716 var aData = _fnAjaxDataSrc( settings, json );
4718 // Got the data - add it to the table
4719 for ( i=0 ; i<aData.length ; i++ ) {
4720 _fnAddData( settings, aData[i] );
4721 }
4723 // Reset the init display for cookie saving. We've already done
4724 // a filter, and therefore cleared it before. So we need to make
4725 // it appear 'fresh'
4726 settings.iInitDisplayStart = iAjaxStart;
4728 _fnReDraw( settings );
4730 _fnProcessingDisplay( settings, false );
4731 _fnInitComplete( settings, json );
4732 }, settings );
4733 }
4734 else {
4735 _fnProcessingDisplay( settings, false );
4736 _fnInitComplete( settings );
4737 }
4738 }
4739 }
4742 /**
4743 * Draw the table for the first time, adding all required features
4744 * @param {object} oSettings dataTables settings object
4745 * @param {object} [json] JSON from the server that completed the table, if using Ajax source
4746 * with client-side processing (optional)
4747 * @memberof DataTable#oApi
4748 */
4749 function _fnInitComplete ( settings, json )
4750 {
4751 settings._bInitComplete = true;
4753 // When data was added after the initialisation (data or Ajax) we need to
4754 // calculate the column sizing
4755 if ( json || settings.oInit.aaData ) {
4756 _fnAdjustColumnSizing( settings );
4757 }
4759 _fnCallbackFire( settings, null, 'plugin-init', [settings, json] );
4760 _fnCallbackFire( settings, 'aoInitComplete', 'init', [settings, json] );
4761 }
4764 function _fnLengthChange ( settings, val )
4765 {
4766 var len = parseInt( val, 10 );
4767 settings._iDisplayLength = len;
4769 _fnLengthOverflow( settings );
4771 // Fire length change event
4772 _fnCallbackFire( settings, null, 'length', [settings, len] );
4773 }
4776 /**
4777 * Generate the node required for user display length changing
4778 * @param {object} settings dataTables settings object
4779 * @returns {node} Display length feature node
4780 * @memberof DataTable#oApi
4781 */
4782 function _fnFeatureHtmlLength ( settings )
4783 {
4784 var
4785 classes = settings.oClasses,
4786 tableId = settings.sTableId,
4787 menu = settings.aLengthMenu,
4788 d2 = $.isArray( menu[0] ),
4789 lengths = d2 ? menu[0] : menu,
4790 language = d2 ? menu[1] : menu;
4792 var select = $('<select/>', {
4793 'name': tableId+'_length',
4794 'aria-controls': tableId,
4795 'class': classes.sLengthSelect
4796 } );
4798 for ( var i=0, ien=lengths.length ; i<ien ; i++ ) {
4799 select[0][ i ] = new Option( language[i], lengths[i] );
4800 }
4802 var div = $('<div><label/></div>').addClass( classes.sLength );
4803 if ( ! settings.aanFeatures.l ) {
4804 div[0].id = tableId+'_length';
4805 }
4807 div.children().append(
4808 settings.oLanguage.sLengthMenu.replace( '_MENU_', select[0].outerHTML )
4809 );
4811 // Can't use `select` variable as user might provide their own and the
4812 // reference is broken by the use of outerHTML
4813 $('select', div)
4814 .val( settings._iDisplayLength )
4815 .bind( 'change.DT', function(e) {
4816 _fnLengthChange( settings, $(this).val() );
4817 _fnDraw( settings );
4818 } );
4820 // Update node value whenever anything changes the table's length
4821 $(settings.nTable).bind( 'length.dt.DT', function (e, s, len) {
4822 if ( settings === s ) {
4823 $('select', div).val( len );
4824 }
4825 } );
4827 return div[0];
4828 }
4832 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
4833 * Note that most of the paging logic is done in
4834 * DataTable.ext.pager
4835 */
4837 /**
4838 * Generate the node required for default pagination
4839 * @param {object} oSettings dataTables settings object
4840 * @returns {node} Pagination feature node
4841 * @memberof DataTable#oApi
4842 */
4843 function _fnFeatureHtmlPaginate ( settings )
4844 {
4845 var
4846 type = settings.sPaginationType,
4847 plugin = DataTable.ext.pager[ type ],
4848 modern = typeof plugin === 'function',
4849 redraw = function( settings ) {
4850 _fnDraw( settings );
4851 },
4852 node = $('<div/>').addClass( settings.oClasses.sPaging + type )[0],
4853 features = settings.aanFeatures;
4855 if ( ! modern ) {
4856 plugin.fnInit( settings, node, redraw );
4857 }
4859 /* Add a draw callback for the pagination on first instance, to update the paging display */
4860 if ( ! features.p )
4861 {
4862 node.id = settings.sTableId+'_paginate';
4864 settings.aoDrawCallback.push( {
4865 "fn": function( settings ) {
4866 if ( modern ) {
4867 var
4868 start = settings._iDisplayStart,
4869 len = settings._iDisplayLength,
4870 visRecords = settings.fnRecordsDisplay(),
4871 all = len === -1,
4872 page = all ? 0 : Math.ceil( start / len ),
4873 pages = all ? 1 : Math.ceil( visRecords / len ),
4874 buttons = plugin(page, pages),
4875 i, ien;
4877 for ( i=0, ien=features.p.length ; i<ien ; i++ ) {
4878 _fnRenderer( settings, 'pageButton' )(
4879 settings, features.p[i], i, buttons, page, pages
4880 );
4881 }
4882 }
4883 else {
4884 plugin.fnUpdate( settings, redraw );
4885 }
4886 },
4887 "sName": "pagination"
4888 } );
4889 }
4891 return node;
4892 }
4895 /**
4896 * Alter the display settings to change the page
4897 * @param {object} settings DataTables settings object
4898 * @param {string|int} action Paging action to take: "first", "previous",
4899 * "next" or "last" or page number to jump to (integer)
4900 * @param [bool] redraw Automatically draw the update or not
4901 * @returns {bool} true page has changed, false - no change
4902 * @memberof DataTable#oApi
4903 */
4904 function _fnPageChange ( settings, action, redraw )
4905 {
4906 var
4907 start = settings._iDisplayStart,
4908 len = settings._iDisplayLength,
4909 records = settings.fnRecordsDisplay();
4911 if ( records === 0 || len === -1 )
4912 {
4913 start = 0;
4914 }
4915 else if ( typeof action === "number" )
4916 {
4917 start = action * len;
4919 if ( start > records )
4920 {
4921 start = 0;
4922 }
4923 }
4924 else if ( action == "first" )
4925 {
4926 start = 0;
4927 }
4928 else if ( action == "previous" )
4929 {
4930 start = len >= 0 ?
4931 start - len :
4932 0;
4934 if ( start < 0 )
4935 {
4936 start = 0;
4937 }
4938 }
4939 else if ( action == "next" )
4940 {
4941 if ( start + len < records )
4942 {
4943 start += len;
4944 }
4945 }
4946 else if ( action == "last" )
4947 {
4948 start = Math.floor( (records-1) / len) * len;
4949 }
4950 else
4951 {
4952 _fnLog( settings, 0, "Unknown paging action: "+action, 5 );
4953 }
4955 var changed = settings._iDisplayStart !== start;
4956 settings._iDisplayStart = start;
4958 if ( changed ) {
4959 _fnCallbackFire( settings, null, 'page', [settings] );
4961 if ( redraw ) {
4962 _fnDraw( settings );
4963 }
4964 }
4966 return changed;
4967 }
4971 /**
4972 * Generate the node required for the processing node
4973 * @param {object} settings dataTables settings object
4974 * @returns {node} Processing element
4975 * @memberof DataTable#oApi
4976 */
4977 function _fnFeatureHtmlProcessing ( settings )
4978 {
4979 return $('<div/>', {
4980 'id': ! settings.aanFeatures.r ? settings.sTableId+'_processing' : null,
4981 'class': settings.oClasses.sProcessing
4982 } )
4983 .html( settings.oLanguage.sProcessing )
4984 .insertBefore( settings.nTable )[0];
4985 }
4988 /**
4989 * Display or hide the processing indicator
4990 * @param {object} settings dataTables settings object
4991 * @param {bool} show Show the processing indicator (true) or not (false)
4992 * @memberof DataTable#oApi
4993 */
4994 function _fnProcessingDisplay ( settings, show )
4995 {
4996 if ( settings.oFeatures.bProcessing ) {
4997 $(settings.aanFeatures.r).css( 'display', show ? 'block' : 'none' );
4998 }
5000 _fnCallbackFire( settings, null, 'processing', [settings, show] );
5001 }
5003 /**
5004 * Add any control elements for the table - specifically scrolling
5005 * @param {object} settings dataTables settings object
5006 * @returns {node} Node to add to the DOM
5007 * @memberof DataTable#oApi
5008 */
5009 function _fnFeatureHtmlTable ( settings )
5010 {
5011 var table = $(settings.nTable);
5013 // Add the ARIA grid role to the table
5014 table.attr( 'role', 'grid' );
5016 // Scrolling from here on in
5017 var scroll = settings.oScroll;
5019 if ( scroll.sX === '' && scroll.sY === '' ) {
5020 return settings.nTable;
5021 }
5023 var scrollX = scroll.sX;
5024 var scrollY = scroll.sY;
5025 var classes = settings.oClasses;
5026 var caption = table.children('caption');
5027 var captionSide = caption.length ? caption[0]._captionSide : null;
5028 var headerClone = $( table[0].cloneNode(false) );
5029 var footerClone = $( table[0].cloneNode(false) );
5030 var footer = table.children('tfoot');
5031 var _div = '<div/>';
5032 var size = function ( s ) {
5033 return !s ? null : _fnStringToCss( s );
5034 };
5036 if ( ! footer.length ) {
5037 footer = null;
5038 }
5040 /*
5041 * The HTML structure that we want to generate in this function is:
5042 * div - scroller
5043 * div - scroll head
5044 * div - scroll head inner
5045 * table - scroll head table
5046 * thead - thead
5047 * div - scroll body
5048 * table - table (master table)
5049 * thead - thead clone for sizing
5050 * tbody - tbody
5051 * div - scroll foot
5052 * div - scroll foot inner
5053 * table - scroll foot table
5054 * tfoot - tfoot
5055 */
5056 var scroller = $( _div, { 'class': classes.sScrollWrapper } )
5057 .append(
5058 $(_div, { 'class': classes.sScrollHead } )
5059 .css( {
5060 overflow: 'hidden',
5061 position: 'relative',
5062 border: 0,
5063 width: scrollX ? size(scrollX) : '100%'
5064 } )
5065 .append(
5066 $(_div, { 'class': classes.sScrollHeadInner } )
5067 .css( {
5068 'box-sizing': 'content-box',
5069 width: scroll.sXInner || '100%'
5070 } )
5071 .append(
5072 headerClone
5073 .removeAttr('id')
5074 .css( 'margin-left', 0 )
5075 .append( captionSide === 'top' ? caption : null )
5076 .append(
5077 table.children('thead')
5078 )
5079 )
5080 )
5081 )
5082 .append(
5083 $(_div, { 'class': classes.sScrollBody } )
5084 .css( {
5085 position: 'relative',
5086 overflow: 'auto',
5087 width: size( scrollX )
5088 } )
5089 .append( table )
5090 );
5092 if ( footer ) {
5093 scroller.append(
5094 $(_div, { 'class': classes.sScrollFoot } )
5095 .css( {
5096 overflow: 'hidden',
5097 border: 0,
5098 width: scrollX ? size(scrollX) : '100%'
5099 } )
5100 .append(
5101 $(_div, { 'class': classes.sScrollFootInner } )
5102 .append(
5103 footerClone
5104 .removeAttr('id')
5105 .css( 'margin-left', 0 )
5106 .append( captionSide === 'bottom' ? caption : null )
5107 .append(
5108 table.children('tfoot')
5109 )
5110 )
5111 )
5112 );
5113 }
5115 var children = scroller.children();
5116 var scrollHead = children[0];
5117 var scrollBody = children[1];
5118 var scrollFoot = footer ? children[2] : null;
5120 // When the body is scrolled, then we also want to scroll the headers
5121 if ( scrollX ) {
5122 $(scrollBody).on( 'scroll.DT', function (e) {
5123 var scrollLeft = this.scrollLeft;
5125 scrollHead.scrollLeft = scrollLeft;
5127 if ( footer ) {
5128 scrollFoot.scrollLeft = scrollLeft;
5129 }
5130 } );
5131 }
5133 $(scrollBody).css(
5134 scrollY && scroll.bCollapse ? 'max-height' : 'height',
5135 scrollY
5136 );
5138 settings.nScrollHead = scrollHead;
5139 settings.nScrollBody = scrollBody;
5140 settings.nScrollFoot = scrollFoot;
5142 // On redraw - align columns
5143 settings.aoDrawCallback.push( {
5144 "fn": _fnScrollDraw,
5145 "sName": "scrolling"
5146 } );
5148 return scroller[0];
5149 }
5153 /**
5154 * Update the header, footer and body tables for resizing - i.e. column
5155 * alignment.
5156 *
5157 * Welcome to the most horrible function DataTables. The process that this
5158 * function follows is basically:
5159 * 1. Re-create the table inside the scrolling div
5160 * 2. Take live measurements from the DOM
5161 * 3. Apply the measurements to align the columns
5162 * 4. Clean up
5163 *
5164 * @param {object} settings dataTables settings object
5165 * @memberof DataTable#oApi
5166 */
5167 function _fnScrollDraw ( settings )
5168 {
5169 // Given that this is such a monster function, a lot of variables are use
5170 // to try and keep the minimised size as small as possible
5171 var
5172 scroll = settings.oScroll,
5173 scrollX = scroll.sX,
5174 scrollXInner = scroll.sXInner,
5175 scrollY = scroll.sY,
5176 barWidth = scroll.iBarWidth,
5177 divHeader = $(settings.nScrollHead),
5178 divHeaderStyle = divHeader[0].style,
5179 divHeaderInner = divHeader.children('div'),
5180 divHeaderInnerStyle = divHeaderInner[0].style,
5181 divHeaderTable = divHeaderInner.children('table'),
5182 divBodyEl = settings.nScrollBody,
5183 divBody = $(divBodyEl),
5184 divBodyStyle = divBodyEl.style,
5185 divFooter = $(settings.nScrollFoot),
5186 divFooterInner = divFooter.children('div'),
5187 divFooterTable = divFooterInner.children('table'),
5188 header = $(settings.nTHead),
5189 table = $(settings.nTable),
5190 tableEl = table[0],
5191 tableStyle = tableEl.style,
5192 footer = settings.nTFoot ? $(settings.nTFoot) : null,
5193 browser = settings.oBrowser,
5194 ie67 = browser.bScrollOversize,
5195 dtHeaderCells = _pluck( settings.aoColumns, 'nTh' ),
5196 headerTrgEls, footerTrgEls,
5197 headerSrcEls, footerSrcEls,
5198 headerCopy, footerCopy,
5199 headerWidths=[], footerWidths=[],
5200 headerContent=[], footerContent=[],
5201 idx, correction, sanityWidth,
5202 zeroOut = function(nSizer) {
5203 var style = nSizer.style;
5204 style.paddingTop = "0";
5205 style.paddingBottom = "0";
5206 style.borderTopWidth = "0";
5207 style.borderBottomWidth = "0";
5208 style.height = 0;
5209 };
5211 // If the scrollbar visibility has changed from the last draw, we need to
5212 // adjust the column sizes as the table width will have changed to account
5213 // for the scrollbar
5214 var scrollBarVis = divBodyEl.scrollHeight > divBodyEl.clientHeight;
5216 if ( settings.scrollBarVis !== scrollBarVis && settings.scrollBarVis !== undefined ) {
5217 settings.scrollBarVis = scrollBarVis;
5218 _fnAdjustColumnSizing( settings );
5219 return; // adjust column sizing will call this function again
5220 }
5221 else {
5222 settings.scrollBarVis = scrollBarVis;
5223 }
5225 /*
5226 * 1. Re-create the table inside the scrolling div
5227 */
5229 // Remove the old minimised thead and tfoot elements in the inner table
5230 table.children('thead, tfoot').remove();
5232 if ( footer ) {
5233 footerCopy = footer.clone().prependTo( table );
5234 footerTrgEls = footer.find('tr'); // the original tfoot is in its own table and must be sized
5235 footerSrcEls = footerCopy.find('tr');
5236 }
5238 // Clone the current header and footer elements and then place it into the inner table
5239 headerCopy = header.clone().prependTo( table );
5240 headerTrgEls = header.find('tr'); // original header is in its own table
5241 headerSrcEls = headerCopy.find('tr');
5242 headerCopy.find('th, td').removeAttr('tabindex');
5245 /*
5246 * 2. Take live measurements from the DOM - do not alter the DOM itself!
5247 */
5249 // Remove old sizing and apply the calculated column widths
5250 // Get the unique column headers in the newly created (cloned) header. We want to apply the
5251 // calculated sizes to this header
5252 if ( ! scrollX )
5253 {
5254 divBodyStyle.width = '100%';
5255 divHeader[0].style.width = '100%';
5256 }
5258 $.each( _fnGetUniqueThs( settings, headerCopy ), function ( i, el ) {
5259 idx = _fnVisibleToColumnIndex( settings, i );
5260 el.style.width = settings.aoColumns[idx].sWidth;
5261 } );
5263 if ( footer ) {
5264 _fnApplyToChildren( function(n) {
5265 n.style.width = "";
5266 }, footerSrcEls );
5267 }
5269 // Size the table as a whole
5270 sanityWidth = table.outerWidth();
5271 if ( scrollX === "" ) {
5272 // No x scrolling
5273 tableStyle.width = "100%";
5275 // IE7 will make the width of the table when 100% include the scrollbar
5276 // - which is shouldn't. When there is a scrollbar we need to take this
5277 // into account.
5278 if ( ie67 && (table.find('tbody').height() > divBodyEl.offsetHeight ||
5279 divBody.css('overflow-y') == "scroll")
5280 ) {
5281 tableStyle.width = _fnStringToCss( table.outerWidth() - barWidth);
5282 }
5284 // Recalculate the sanity width
5285 sanityWidth = table.outerWidth();
5286 }
5287 else if ( scrollXInner !== "" ) {
5288 // legacy x scroll inner has been given - use it
5289 tableStyle.width = _fnStringToCss(scrollXInner);
5291 // Recalculate the sanity width
5292 sanityWidth = table.outerWidth();
5293 }
5295 // Hidden header should have zero height, so remove padding and borders. Then
5296 // set the width based on the real headers
5298 // Apply all styles in one pass
5299 _fnApplyToChildren( zeroOut, headerSrcEls );
5301 // Read all widths in next pass
5302 _fnApplyToChildren( function(nSizer) {
5303 headerContent.push( nSizer.innerHTML );
5304 headerWidths.push( _fnStringToCss( $(nSizer).css('width') ) );
5305 }, headerSrcEls );
5307 // Apply all widths in final pass
5308 _fnApplyToChildren( function(nToSize, i) {
5309 // Only apply widths to the DataTables detected header cells - this
5310 // prevents complex headers from having contradictory sizes applied
5311 if ( $.inArray( nToSize, dtHeaderCells ) !== -1 ) {
5312 nToSize.style.width = headerWidths[i];
5313 }
5314 }, headerTrgEls );
5316 $(headerSrcEls).height(0);
5318 /* Same again with the footer if we have one */
5319 if ( footer )
5320 {
5321 _fnApplyToChildren( zeroOut, footerSrcEls );
5323 _fnApplyToChildren( function(nSizer) {
5324 footerContent.push( nSizer.innerHTML );
5325 footerWidths.push( _fnStringToCss( $(nSizer).css('width') ) );
5326 }, footerSrcEls );
5328 _fnApplyToChildren( function(nToSize, i) {
5329 nToSize.style.width = footerWidths[i];
5330 }, footerTrgEls );
5332 $(footerSrcEls).height(0);
5333 }
5336 /*
5337 * 3. Apply the measurements
5338 */
5340 // "Hide" the header and footer that we used for the sizing. We need to keep
5341 // the content of the cell so that the width applied to the header and body
5342 // both match, but we want to hide it completely. We want to also fix their
5343 // width to what they currently are
5344 _fnApplyToChildren( function(nSizer, i) {
5345 nSizer.innerHTML = '<div class="dataTables_sizing" style="height:0;overflow:hidden;">'+headerContent[i]+'</div>';
5346 nSizer.style.width = headerWidths[i];
5347 }, headerSrcEls );
5349 if ( footer )
5350 {
5351 _fnApplyToChildren( function(nSizer, i) {
5352 nSizer.innerHTML = '<div class="dataTables_sizing" style="height:0;overflow:hidden;">'+footerContent[i]+'</div>';
5353 nSizer.style.width = footerWidths[i];
5354 }, footerSrcEls );
5355 }
5357 // Sanity check that the table is of a sensible width. If not then we are going to get
5358 // misalignment - try to prevent this by not allowing the table to shrink below its min width
5359 if ( table.outerWidth() < sanityWidth )
5360 {
5361 // The min width depends upon if we have a vertical scrollbar visible or not */
5362 correction = ((divBodyEl.scrollHeight > divBodyEl.offsetHeight ||
5363 divBody.css('overflow-y') == "scroll")) ?
5364 sanityWidth+barWidth :
5365 sanityWidth;
5367 // IE6/7 are a law unto themselves...
5368 if ( ie67 && (divBodyEl.scrollHeight >
5369 divBodyEl.offsetHeight || divBody.css('overflow-y') == "scroll")
5370 ) {
5371 tableStyle.width = _fnStringToCss( correction-barWidth );
5372 }
5374 // And give the user a warning that we've stopped the table getting too small
5375 if ( scrollX === "" || scrollXInner !== "" ) {
5376 _fnLog( settings, 1, 'Possible column misalignment', 6 );
5377 }
5378 }
5379 else
5380 {
5381 correction = '100%';
5382 }
5384 // Apply to the container elements
5385 divBodyStyle.width = _fnStringToCss( correction );
5386 divHeaderStyle.width = _fnStringToCss( correction );
5388 if ( footer ) {
5389 settings.nScrollFoot.style.width = _fnStringToCss( correction );
5390 }
5393 /*
5394 * 4. Clean up
5395 */
5396 if ( ! scrollY ) {
5397 /* IE7< puts a vertical scrollbar in place (when it shouldn't be) due to subtracting
5398 * the scrollbar height from the visible display, rather than adding it on. We need to
5399 * set the height in order to sort this. Don't want to do it in any other browsers.
5400 */
5401 if ( ie67 ) {
5402 divBodyStyle.height = _fnStringToCss( tableEl.offsetHeight+barWidth );
5403 }
5404 }
5406 /* Finally set the width's of the header and footer tables */
5407 var iOuterWidth = table.outerWidth();
5408 divHeaderTable[0].style.width = _fnStringToCss( iOuterWidth );
5409 divHeaderInnerStyle.width = _fnStringToCss( iOuterWidth );
5411 // Figure out if there are scrollbar present - if so then we need a the header and footer to
5412 // provide a bit more space to allow "overflow" scrolling (i.e. past the scrollbar)
5413 var bScrolling = table.height() > divBodyEl.clientHeight || divBody.css('overflow-y') == "scroll";
5414 var padding = 'padding' + (browser.bScrollbarLeft ? 'Left' : 'Right' );
5415 divHeaderInnerStyle[ padding ] = bScrolling ? barWidth+"px" : "0px";
5417 if ( footer ) {
5418 divFooterTable[0].style.width = _fnStringToCss( iOuterWidth );
5419 divFooterInner[0].style.width = _fnStringToCss( iOuterWidth );
5420 divFooterInner[0].style[padding] = bScrolling ? barWidth+"px" : "0px";
5421 }
5423 // Correct DOM ordering for colgroup - comes before the thead
5424 table.children('colgroup').insertBefore( table.children('thead') );
5426 /* Adjust the position of the header in case we loose the y-scrollbar */
5427 divBody.scroll();
5429 // If sorting or filtering has occurred, jump the scrolling back to the top
5430 // only if we aren't holding the position
5431 if ( (settings.bSorted || settings.bFiltered) && ! settings._drawHold ) {
5432 divBodyEl.scrollTop = 0;
5433 }
5434 }
5438 /**
5439 * Apply a given function to the display child nodes of an element array (typically
5440 * TD children of TR rows
5441 * @param {function} fn Method to apply to the objects
5442 * @param array {nodes} an1 List of elements to look through for display children
5443 * @param array {nodes} an2 Another list (identical structure to the first) - optional
5444 * @memberof DataTable#oApi
5445 */
5446 function _fnApplyToChildren( fn, an1, an2 )
5447 {
5448 var index=0, i=0, iLen=an1.length;
5449 var nNode1, nNode2;
5451 while ( i < iLen ) {
5452 nNode1 = an1[i].firstChild;
5453 nNode2 = an2 ? an2[i].firstChild : null;
5455 while ( nNode1 ) {
5456 if ( nNode1.nodeType === 1 ) {
5457 if ( an2 ) {
5458 fn( nNode1, nNode2, index );
5459 }
5460 else {
5461 fn( nNode1, index );
5462 }
5464 index++;
5465 }
5467 nNode1 = nNode1.nextSibling;
5468 nNode2 = an2 ? nNode2.nextSibling : null;
5469 }
5471 i++;
5472 }
5473 }
5477 var __re_html_remove = /<.*?>/g;
5480 /**
5481 * Calculate the width of columns for the table
5482 * @param {object} oSettings dataTables settings object
5483 * @memberof DataTable#oApi
5484 */
5485 function _fnCalculateColumnWidths ( oSettings )
5486 {
5487 var
5488 table = oSettings.nTable,
5489 columns = oSettings.aoColumns,
5490 scroll = oSettings.oScroll,
5491 scrollY = scroll.sY,
5492 scrollX = scroll.sX,
5493 scrollXInner = scroll.sXInner,
5494 columnCount = columns.length,
5495 visibleColumns = _fnGetColumns( oSettings, 'bVisible' ),
5496 headerCells = $('th', oSettings.nTHead),
5497 tableWidthAttr = table.getAttribute('width'), // from DOM element
5498 tableContainer = table.parentNode,
5499 userInputs = false,
5500 i, column, columnIdx, width, outerWidth,
5501 browser = oSettings.oBrowser,
5502 ie67 = browser.bScrollOversize;
5504 var styleWidth = table.style.width;
5505 if ( styleWidth && styleWidth.indexOf('%') !== -1 ) {
5506 tableWidthAttr = styleWidth;
5507 }
5509 /* Convert any user input sizes into pixel sizes */
5510 for ( i=0 ; i<visibleColumns.length ; i++ ) {
5511 column = columns[ visibleColumns[i] ];
5513 if ( column.sWidth !== null ) {
5514 column.sWidth = _fnConvertToWidth( column.sWidthOrig, tableContainer );
5516 userInputs = true;
5517 }
5518 }
5520 /* If the number of columns in the DOM equals the number that we have to
5521 * process in DataTables, then we can use the offsets that are created by
5522 * the web- browser. No custom sizes can be set in order for this to happen,
5523 * nor scrolling used
5524 */
5525 if ( ie67 || ! userInputs && ! scrollX && ! scrollY &&
5526 columnCount == _fnVisbleColumns( oSettings ) &&
5527 columnCount == headerCells.length
5528 ) {
5529 for ( i=0 ; i<columnCount ; i++ ) {
5530 var colIdx = _fnVisibleToColumnIndex( oSettings, i );
5532 if ( colIdx !== null ) {
5533 columns[ colIdx ].sWidth = _fnStringToCss( headerCells.eq(i).width() );
5534 }
5535 }
5536 }
5537 else
5538 {
5539 // Otherwise construct a single row, worst case, table with the widest
5540 // node in the data, assign any user defined widths, then insert it into
5541 // the DOM and allow the browser to do all the hard work of calculating
5542 // table widths
5543 var tmpTable = $(table).clone() // don't use cloneNode - IE8 will remove events on the main table
5544 .css( 'visibility', 'hidden' )
5545 .removeAttr( 'id' );
5547 // Clean up the table body
5548 tmpTable.find('tbody tr').remove();
5549 var tr = $('<tr/>').appendTo( tmpTable.find('tbody') );
5551 // Clone the table header and footer - we can't use the header / footer
5552 // from the cloned table, since if scrolling is active, the table's
5553 // real header and footer are contained in different table tags
5554 tmpTable.find('thead, tfoot').remove();
5555 tmpTable
5556 .append( $(oSettings.nTHead).clone() )
5557 .append( $(oSettings.nTFoot).clone() );
5559 // Remove any assigned widths from the footer (from scrolling)
5560 tmpTable.find('tfoot th, tfoot td').css('width', '');
5562 // Apply custom sizing to the cloned header
5563 headerCells = _fnGetUniqueThs( oSettings, tmpTable.find('thead')[0] );
5565 for ( i=0 ; i<visibleColumns.length ; i++ ) {
5566 column = columns[ visibleColumns[i] ];
5568 headerCells[i].style.width = column.sWidthOrig !== null && column.sWidthOrig !== '' ?
5569 _fnStringToCss( column.sWidthOrig ) :
5570 '';
5572 // For scrollX we need to force the column width otherwise the
5573 // browser will collapse it. If this width is smaller than the
5574 // width the column requires, then it will have no effect
5575 if ( column.sWidthOrig && scrollX ) {
5576 $( headerCells[i] ).append( $('<div/>').css( {
5577 width: column.sWidthOrig,
5578 margin: 0,
5579 padding: 0,
5580 border: 0,
5581 height: 1
5582 } ) );
5583 }
5584 }
5586 // Find the widest cell for each column and put it into the table
5587 if ( oSettings.aoData.length ) {
5588 for ( i=0 ; i<visibleColumns.length ; i++ ) {
5589 columnIdx = visibleColumns[i];
5590 column = columns[ columnIdx ];
5592 $( _fnGetWidestNode( oSettings, columnIdx ) )
5593 .clone( false )
5594 .append( column.sContentPadding )
5595 .appendTo( tr );
5596 }
5597 }
5599 // Tidy the temporary table - remove name attributes so there aren't
5600 // duplicated in the dom (radio elements for example)
5601 $('[name]', tmpTable).removeAttr('name');
5603 // Table has been built, attach to the document so we can work with it.
5604 // A holding element is used, positioned at the top of the container
5605 // with minimal height, so it has no effect on if the container scrolls
5606 // or not. Otherwise it might trigger scrolling when it actually isn't
5607 // needed
5608 var holder = $('<div/>').css( scrollX || scrollY ?
5609 {
5610 position: 'absolute',
5611 top: 0,
5612 left: 0,
5613 height: 1,
5614 right: 0,
5615 overflow: 'hidden'
5616 } :
5617 {}
5618 )
5619 .append( tmpTable )
5620 .appendTo( tableContainer );
5622 // When scrolling (X or Y) we want to set the width of the table as
5623 // appropriate. However, when not scrolling leave the table width as it
5624 // is. This results in slightly different, but I think correct behaviour
5625 if ( scrollX && scrollXInner ) {
5626 tmpTable.width( scrollXInner );
5627 }
5628 else if ( scrollX ) {
5629 tmpTable.css( 'width', 'auto' );
5630 tmpTable.removeAttr('width');
5632 // If there is no width attribute or style, then allow the table to
5633 // collapse
5634 if ( tmpTable.width() < tableContainer.clientWidth && tableWidthAttr ) {
5635 tmpTable.width( tableContainer.clientWidth );
5636 }
5637 }
5638 else if ( scrollY ) {
5639 tmpTable.width( tableContainer.clientWidth );
5640 }
5641 else if ( tableWidthAttr ) {
5642 tmpTable.width( tableWidthAttr );
5643 }
5645 // Get the width of each column in the constructed table - we need to
5646 // know the inner width (so it can be assigned to the other table's
5647 // cells) and the outer width so we can calculate the full width of the
5648 // table. This is safe since DataTables requires a unique cell for each
5649 // column, but if ever a header can span multiple columns, this will
5650 // need to be modified.
5651 var total = 0;
5652 for ( i=0 ; i<visibleColumns.length ; i++ ) {
5653 var cell = $(headerCells[i]);
5654 var border = cell.outerWidth() - cell.width();
5656 // Use getBounding... where possible (not IE8-) because it can give
5657 // sub-pixel accuracy, which we then want to round up!
5658 var bounding = browser.bBounding ?
5659 Math.ceil( headerCells[i].getBoundingClientRect().width ) :
5660 cell.outerWidth();
5662 // Total is tracked to remove any sub-pixel errors as the outerWidth
5663 // of the table might not equal the total given here (IE!).
5664 total += bounding;
5666 // Width for each column to use
5667 columns[ visibleColumns[i] ].sWidth = _fnStringToCss( bounding - border );
5668 }
5670 table.style.width = _fnStringToCss( total );
5672 // Finished with the table - ditch it
5673 holder.remove();
5674 }
5676 // If there is a width attr, we want to attach an event listener which
5677 // allows the table sizing to automatically adjust when the window is
5678 // resized. Use the width attr rather than CSS, since we can't know if the
5679 // CSS is a relative value or absolute - DOM read is always px.
5680 if ( tableWidthAttr ) {
5681 table.style.width = _fnStringToCss( tableWidthAttr );
5682 }
5684 if ( (tableWidthAttr || scrollX) && ! oSettings._reszEvt ) {
5685 var bindResize = function () {
5686 $(window).bind('resize.DT-'+oSettings.sInstance, _fnThrottle( function () {
5687 _fnAdjustColumnSizing( oSettings );
5688 } ) );
5689 };
5691 // IE6/7 will crash if we bind a resize event handler on page load.
5692 // To be removed in 1.11 which drops IE6/7 support
5693 if ( ie67 ) {
5694 setTimeout( bindResize, 1000 );
5695 }
5696 else {
5697 bindResize();
5698 }
5700 oSettings._reszEvt = true;
5701 }
5702 }
5705 /**
5706 * Throttle the calls to a function. Arguments and context are maintained for
5707 * the throttled function
5708 * @param {function} fn Function to be called
5709 * @param {int} [freq=200] call frequency in mS
5710 * @returns {function} wrapped function
5711 * @memberof DataTable#oApi
5712 */
5713 var _fnThrottle = DataTable.util.throttle;
5716 /**
5717 * Convert a CSS unit width to pixels (e.g. 2em)
5718 * @param {string} width width to be converted
5719 * @param {node} parent parent to get the with for (required for relative widths) - optional
5720 * @returns {int} width in pixels
5721 * @memberof DataTable#oApi
5722 */
5723 function _fnConvertToWidth ( width, parent )
5724 {
5725 if ( ! width ) {
5726 return 0;
5727 }
5729 var n = $('<div/>')
5730 .css( 'width', _fnStringToCss( width ) )
5731 .appendTo( parent || document.body );
5733 var val = n[0].offsetWidth;
5734 n.remove();
5736 return val;
5737 }
5740 /**
5741 * Get the widest node
5742 * @param {object} settings dataTables settings object
5743 * @param {int} colIdx column of interest
5744 * @returns {node} widest table node
5745 * @memberof DataTable#oApi
5746 */
5747 function _fnGetWidestNode( settings, colIdx )
5748 {
5749 var idx = _fnGetMaxLenString( settings, colIdx );
5750 if ( idx < 0 ) {
5751 return null;
5752 }
5754 var data = settings.aoData[ idx ];
5755 return ! data.nTr ? // Might not have been created when deferred rendering
5756 $('<td/>').html( _fnGetCellData( settings, idx, colIdx, 'display' ) )[0] :
5757 data.anCells[ colIdx ];
5758 }
5761 /**
5762 * Get the maximum strlen for each data column
5763 * @param {object} settings dataTables settings object
5764 * @param {int} colIdx column of interest
5765 * @returns {string} max string length for each column
5766 * @memberof DataTable#oApi
5767 */
5768 function _fnGetMaxLenString( settings, colIdx )
5769 {
5770 var s, max=-1, maxIdx = -1;
5772 for ( var i=0, ien=settings.aoData.length ; i<ien ; i++ ) {
5773 s = _fnGetCellData( settings, i, colIdx, 'display' )+'';
5774 s = s.replace( __re_html_remove, '' );
5775 s = s.replace( / /g, ' ' );
5777 if ( s.length > max ) {
5778 max = s.length;
5779 maxIdx = i;
5780 }
5781 }
5783 return maxIdx;
5784 }
5787 /**
5788 * Append a CSS unit (only if required) to a string
5789 * @param {string} value to css-ify
5790 * @returns {string} value with css unit
5791 * @memberof DataTable#oApi
5792 */
5793 function _fnStringToCss( s )
5794 {
5795 if ( s === null ) {
5796 return '0px';
5797 }
5799 if ( typeof s == 'number' ) {
5800 return s < 0 ?
5801 '0px' :
5802 s+'px';
5803 }
5805 // Check it has a unit character already
5806 return s.match(/\d$/) ?
5807 s+'px' :
5808 s;
5809 }
5813 function _fnSortFlatten ( settings )
5814 {
5815 var
5816 i, iLen, k, kLen,
5817 aSort = [],
5818 aiOrig = [],
5819 aoColumns = settings.aoColumns,
5820 aDataSort, iCol, sType, srcCol,
5821 fixed = settings.aaSortingFixed,
5822 fixedObj = $.isPlainObject( fixed ),
5823 nestedSort = [],
5824 add = function ( a ) {
5825 if ( a.length && ! $.isArray( a[0] ) ) {
5826 // 1D array
5827 nestedSort.push( a );
5828 }
5829 else {
5830 // 2D array
5831 $.merge( nestedSort, a );
5832 }
5833 };
5835 // Build the sort array, with pre-fix and post-fix options if they have been
5836 // specified
5837 if ( $.isArray( fixed ) ) {
5838 add( fixed );
5839 }
5841 if ( fixedObj && fixed.pre ) {
5842 add( fixed.pre );
5843 }
5845 add( settings.aaSorting );
5847 if (fixedObj && fixed.post ) {
5848 add( fixed.post );
5849 }
5851 for ( i=0 ; i<nestedSort.length ; i++ )
5852 {
5853 srcCol = nestedSort[i][0];
5854 aDataSort = aoColumns[ srcCol ].aDataSort;
5856 for ( k=0, kLen=aDataSort.length ; k<kLen ; k++ )
5857 {
5858 iCol = aDataSort[k];
5859 sType = aoColumns[ iCol ].sType || 'string';
5861 if ( nestedSort[i]._idx === undefined ) {
5862 nestedSort[i]._idx = $.inArray( nestedSort[i][1], aoColumns[iCol].asSorting );
5863 }
5865 aSort.push( {
5866 src: srcCol,
5867 col: iCol,
5868 dir: nestedSort[i][1],
5869 index: nestedSort[i]._idx,
5870 type: sType,
5871 formatter: DataTable.ext.type.order[ sType+"-pre" ]
5872 } );
5873 }
5874 }
5876 return aSort;
5877 }
5879 /**
5880 * Change the order of the table
5881 * @param {object} oSettings dataTables settings object
5882 * @memberof DataTable#oApi
5883 * @todo This really needs split up!
5884 */
5885 function _fnSort ( oSettings )
5886 {
5887 var
5888 i, ien, iLen, j, jLen, k, kLen,
5889 sDataType, nTh,
5890 aiOrig = [],
5891 oExtSort = DataTable.ext.type.order,
5892 aoData = oSettings.aoData,
5893 aoColumns = oSettings.aoColumns,
5894 aDataSort, data, iCol, sType, oSort,
5895 formatters = 0,
5896 sortCol,
5897 displayMaster = oSettings.aiDisplayMaster,
5898 aSort;
5900 // Resolve any column types that are unknown due to addition or invalidation
5901 // @todo Can this be moved into a 'data-ready' handler which is called when
5902 // data is going to be used in the table?
5903 _fnColumnTypes( oSettings );
5905 aSort = _fnSortFlatten( oSettings );
5907 for ( i=0, ien=aSort.length ; i<ien ; i++ ) {
5908 sortCol = aSort[i];
5910 // Track if we can use the fast sort algorithm
5911 if ( sortCol.formatter ) {
5912 formatters++;
5913 }
5915 // Load the data needed for the sort, for each cell
5916 _fnSortData( oSettings, sortCol.col );
5917 }
5919 /* No sorting required if server-side or no sorting array */
5920 if ( _fnDataSource( oSettings ) != 'ssp' && aSort.length !== 0 )
5921 {
5922 // Create a value - key array of the current row positions such that we can use their
5923 // current position during the sort, if values match, in order to perform stable sorting
5924 for ( i=0, iLen=displayMaster.length ; i<iLen ; i++ ) {
5925 aiOrig[ displayMaster[i] ] = i;
5926 }
5928 /* Do the sort - here we want multi-column sorting based on a given data source (column)
5929 * and sorting function (from oSort) in a certain direction. It's reasonably complex to
5930 * follow on it's own, but this is what we want (example two column sorting):
5931 * fnLocalSorting = function(a,b){
5932 * var iTest;
5933 * iTest = oSort['string-asc']('data11', 'data12');
5934 * if (iTest !== 0)
5935 * return iTest;
5936 * iTest = oSort['numeric-desc']('data21', 'data22');
5937 * if (iTest !== 0)
5938 * return iTest;
5939 * return oSort['numeric-asc']( aiOrig[a], aiOrig[b] );
5940 * }
5941 * Basically we have a test for each sorting column, if the data in that column is equal,
5942 * test the next column. If all columns match, then we use a numeric sort on the row
5943 * positions in the original data array to provide a stable sort.
5944 *
5945 * Note - I know it seems excessive to have two sorting methods, but the first is around
5946 * 15% faster, so the second is only maintained for backwards compatibility with sorting
5947 * methods which do not have a pre-sort formatting function.
5948 */
5949 if ( formatters === aSort.length ) {
5950 // All sort types have formatting functions
5951 displayMaster.sort( function ( a, b ) {
5952 var
5953 x, y, k, test, sort,
5954 len=aSort.length,
5955 dataA = aoData[a]._aSortData,
5956 dataB = aoData[b]._aSortData;
5958 for ( k=0 ; k<len ; k++ ) {
5959 sort = aSort[k];
5961 x = dataA[ sort.col ];
5962 y = dataB[ sort.col ];
5964 test = x<y ? -1 : x>y ? 1 : 0;
5965 if ( test !== 0 ) {
5966 return sort.dir === 'asc' ? test : -test;
5967 }
5968 }
5970 x = aiOrig[a];
5971 y = aiOrig[b];
5972 return x<y ? -1 : x>y ? 1 : 0;
5973 } );
5974 }
5975 else {
5976 // Depreciated - remove in 1.11 (providing a plug-in option)
5977 // Not all sort types have formatting methods, so we have to call their sorting
5978 // methods.
5979 displayMaster.sort( function ( a, b ) {
5980 var
5981 x, y, k, l, test, sort, fn,
5982 len=aSort.length,
5983 dataA = aoData[a]._aSortData,
5984 dataB = aoData[b]._aSortData;
5986 for ( k=0 ; k<len ; k++ ) {
5987 sort = aSort[k];
5989 x = dataA[ sort.col ];
5990 y = dataB[ sort.col ];
5992 fn = oExtSort[ sort.type+"-"+sort.dir ] || oExtSort[ "string-"+sort.dir ];
5993 test = fn( x, y );
5994 if ( test !== 0 ) {
5995 return test;
5996 }
5997 }
5999 x = aiOrig[a];
6000 y = aiOrig[b];
6001 return x<y ? -1 : x>y ? 1 : 0;
6002 } );
6003 }
6004 }
6006 /* Tell the draw function that we have sorted the data */
6007 oSettings.bSorted = true;
6008 }
6011 function _fnSortAria ( settings )
6012 {
6013 var label;
6014 var nextSort;
6015 var columns = settings.aoColumns;
6016 var aSort = _fnSortFlatten( settings );
6017 var oAria = settings.oLanguage.oAria;
6019 // ARIA attributes - need to loop all columns, to update all (removing old
6020 // attributes as needed)
6021 for ( var i=0, iLen=columns.length ; i<iLen ; i++ )
6022 {
6023 var col = columns[i];
6024 var asSorting = col.asSorting;
6025 var sTitle = col.sTitle.replace( /<.*?>/g, "" );
6026 var th = col.nTh;
6028 // IE7 is throwing an error when setting these properties with jQuery's
6029 // attr() and removeAttr() methods...
6030 th.removeAttribute('aria-sort');
6032 /* In ARIA only the first sorting column can be marked as sorting - no multi-sort option */
6033 if ( col.bSortable ) {
6034 if ( aSort.length > 0 && aSort[0].col == i ) {
6035 th.setAttribute('aria-sort', aSort[0].dir=="asc" ? "ascending" : "descending" );
6036 nextSort = asSorting[ aSort[0].index+1 ] || asSorting[0];
6037 }
6038 else {
6039 nextSort = asSorting[0];
6040 }
6042 label = sTitle + ( nextSort === "asc" ?
6043 oAria.sSortAscending :
6044 oAria.sSortDescending
6045 );
6046 }
6047 else {
6048 label = sTitle;
6049 }
6051 th.setAttribute('aria-label', label);
6052 }
6053 }
6056 /**
6057 * Function to run on user sort request
6058 * @param {object} settings dataTables settings object
6059 * @param {node} attachTo node to attach the handler to
6060 * @param {int} colIdx column sorting index
6061 * @param {boolean} [append=false] Append the requested sort to the existing
6062 * sort if true (i.e. multi-column sort)
6063 * @param {function} [callback] callback function
6064 * @memberof DataTable#oApi
6065 */
6066 function _fnSortListener ( settings, colIdx, append, callback )
6067 {
6068 var col = settings.aoColumns[ colIdx ];
6069 var sorting = settings.aaSorting;
6070 var asSorting = col.asSorting;
6071 var nextSortIdx;
6072 var next = function ( a, overflow ) {
6073 var idx = a._idx;
6074 if ( idx === undefined ) {
6075 idx = $.inArray( a[1], asSorting );
6076 }
6078 return idx+1 < asSorting.length ?
6079 idx+1 :
6080 overflow ?
6081 null :
6082 0;
6083 };
6085 // Convert to 2D array if needed
6086 if ( typeof sorting[0] === 'number' ) {
6087 sorting = settings.aaSorting = [ sorting ];
6088 }
6090 // If appending the sort then we are multi-column sorting
6091 if ( append && settings.oFeatures.bSortMulti ) {
6092 // Are we already doing some kind of sort on this column?
6093 var sortIdx = $.inArray( colIdx, _pluck(sorting, '0') );
6095 if ( sortIdx !== -1 ) {
6096 // Yes, modify the sort
6097 nextSortIdx = next( sorting[sortIdx], true );
6099 if ( nextSortIdx === null && sorting.length === 1 ) {
6100 nextSortIdx = 0; // can't remove sorting completely
6101 }
6103 if ( nextSortIdx === null ) {
6104 sorting.splice( sortIdx, 1 );
6105 }
6106 else {
6107 sorting[sortIdx][1] = asSorting[ nextSortIdx ];
6108 sorting[sortIdx]._idx = nextSortIdx;
6109 }
6110 }
6111 else {
6112 // No sort on this column yet
6113 sorting.push( [ colIdx, asSorting[0], 0 ] );
6114 sorting[sorting.length-1]._idx = 0;
6115 }
6116 }
6117 else if ( sorting.length && sorting[0][0] == colIdx ) {
6118 // Single column - already sorting on this column, modify the sort
6119 nextSortIdx = next( sorting[0] );
6121 sorting.length = 1;
6122 sorting[0][1] = asSorting[ nextSortIdx ];
6123 sorting[0]._idx = nextSortIdx;
6124 }
6125 else {
6126 // Single column - sort only on this column
6127 sorting.length = 0;
6128 sorting.push( [ colIdx, asSorting[0] ] );
6129 sorting[0]._idx = 0;
6130 }
6132 // Run the sort by calling a full redraw
6133 _fnReDraw( settings );
6135 // callback used for async user interaction
6136 if ( typeof callback == 'function' ) {
6137 callback( settings );
6138 }
6139 }
6142 /**
6143 * Attach a sort handler (click) to a node
6144 * @param {object} settings dataTables settings object
6145 * @param {node} attachTo node to attach the handler to
6146 * @param {int} colIdx column sorting index
6147 * @param {function} [callback] callback function
6148 * @memberof DataTable#oApi
6149 */
6150 function _fnSortAttachListener ( settings, attachTo, colIdx, callback )
6151 {
6152 var col = settings.aoColumns[ colIdx ];
6154 _fnBindAction( attachTo, {}, function (e) {
6155 /* If the column is not sortable - don't to anything */
6156 if ( col.bSortable === false ) {
6157 return;
6158 }
6160 // If processing is enabled use a timeout to allow the processing
6161 // display to be shown - otherwise to it synchronously
6162 if ( settings.oFeatures.bProcessing ) {
6163 _fnProcessingDisplay( settings, true );
6165 setTimeout( function() {
6166 _fnSortListener( settings, colIdx, e.shiftKey, callback );
6168 // In server-side processing, the draw callback will remove the
6169 // processing display
6170 if ( _fnDataSource( settings ) !== 'ssp' ) {
6171 _fnProcessingDisplay( settings, false );
6172 }
6173 }, 0 );
6174 }
6175 else {
6176 _fnSortListener( settings, colIdx, e.shiftKey, callback );
6177 }
6178 } );
6179 }
6182 /**
6183 * Set the sorting classes on table's body, Note: it is safe to call this function
6184 * when bSort and bSortClasses are false
6185 * @param {object} oSettings dataTables settings object
6186 * @memberof DataTable#oApi
6187 */
6188 function _fnSortingClasses( settings )
6189 {
6190 var oldSort = settings.aLastSort;
6191 var sortClass = settings.oClasses.sSortColumn;
6192 var sort = _fnSortFlatten( settings );
6193 var features = settings.oFeatures;
6194 var i, ien, colIdx;
6196 if ( features.bSort && features.bSortClasses ) {
6197 // Remove old sorting classes
6198 for ( i=0, ien=oldSort.length ; i<ien ; i++ ) {
6199 colIdx = oldSort[i].src;
6201 // Remove column sorting
6202 $( _pluck( settings.aoData, 'anCells', colIdx ) )
6203 .removeClass( sortClass + (i<2 ? i+1 : 3) );
6204 }
6206 // Add new column sorting
6207 for ( i=0, ien=sort.length ; i<ien ; i++ ) {
6208 colIdx = sort[i].src;
6210 $( _pluck( settings.aoData, 'anCells', colIdx ) )
6211 .addClass( sortClass + (i<2 ? i+1 : 3) );
6212 }
6213 }
6215 settings.aLastSort = sort;
6216 }
6219 // Get the data to sort a column, be it from cache, fresh (populating the
6220 // cache), or from a sort formatter
6221 function _fnSortData( settings, idx )
6222 {
6223 // Custom sorting function - provided by the sort data type
6224 var column = settings.aoColumns[ idx ];
6225 var customSort = DataTable.ext.order[ column.sSortDataType ];
6226 var customData;
6228 if ( customSort ) {
6229 customData = customSort.call( settings.oInstance, settings, idx,
6230 _fnColumnIndexToVisible( settings, idx )
6231 );
6232 }
6234 // Use / populate cache
6235 var row, cellData;
6236 var formatter = DataTable.ext.type.order[ column.sType+"-pre" ];
6238 for ( var i=0, ien=settings.aoData.length ; i<ien ; i++ ) {
6239 row = settings.aoData[i];
6241 if ( ! row._aSortData ) {
6242 row._aSortData = [];
6243 }
6245 if ( ! row._aSortData[idx] || customSort ) {
6246 cellData = customSort ?
6247 customData[i] : // If there was a custom sort function, use data from there
6248 _fnGetCellData( settings, i, idx, 'sort' );
6250 row._aSortData[ idx ] = formatter ?
6251 formatter( cellData ) :
6252 cellData;
6253 }
6254 }
6255 }
6259 /**
6260 * Save the state of a table
6261 * @param {object} oSettings dataTables settings object
6262 * @memberof DataTable#oApi
6263 */
6264 function _fnSaveState ( settings )
6265 {
6266 if ( !settings.oFeatures.bStateSave || settings.bDestroying )
6267 {
6268 return;
6269 }
6271 /* Store the interesting variables */
6272 var state = {
6273 time: +new Date(),
6274 start: settings._iDisplayStart,
6275 length: settings._iDisplayLength,
6276 order: $.extend( true, [], settings.aaSorting ),
6277 search: _fnSearchToCamel( settings.oPreviousSearch ),
6278 columns: $.map( settings.aoColumns, function ( col, i ) {
6279 return {
6280 visible: col.bVisible,
6281 search: _fnSearchToCamel( settings.aoPreSearchCols[i] )
6282 };
6283 } )
6284 };
6286 _fnCallbackFire( settings, "aoStateSaveParams", 'stateSaveParams', [settings, state] );
6288 settings.oSavedState = state;
6289 settings.fnStateSaveCallback.call( settings.oInstance, settings, state );
6290 }
6293 /**
6294 * Attempt to load a saved table state
6295 * @param {object} oSettings dataTables settings object
6296 * @param {object} oInit DataTables init object so we can override settings
6297 * @memberof DataTable#oApi
6298 */
6299 function _fnLoadState ( settings, oInit )
6300 {
6301 var i, ien;
6302 var columns = settings.aoColumns;
6304 if ( ! settings.oFeatures.bStateSave ) {
6305 return;
6306 }
6308 var state = settings.fnStateLoadCallback.call( settings.oInstance, settings );
6309 if ( ! state || ! state.time ) {
6310 return;
6311 }
6313 /* Allow custom and plug-in manipulation functions to alter the saved data set and
6314 * cancelling of loading by returning false
6315 */
6316 var abStateLoad = _fnCallbackFire( settings, 'aoStateLoadParams', 'stateLoadParams', [settings, state] );
6317 if ( $.inArray( false, abStateLoad ) !== -1 ) {
6318 return;
6319 }
6321 /* Reject old data */
6322 var duration = settings.iStateDuration;
6323 if ( duration > 0 && state.time < +new Date() - (duration*1000) ) {
6324 return;
6325 }
6327 // Number of columns have changed - all bets are off, no restore of settings
6328 if ( columns.length !== state.columns.length ) {
6329 return;
6330 }
6332 // Store the saved state so it might be accessed at any time
6333 settings.oLoadedState = $.extend( true, {}, state );
6335 // Restore key features - todo - for 1.11 this needs to be done by
6336 // subscribed events
6337 if ( state.start !== undefined ) {
6338 settings._iDisplayStart = state.start;
6339 settings.iInitDisplayStart = state.start;
6340 }
6341 if ( state.length !== undefined ) {
6342 settings._iDisplayLength = state.length;
6343 }
6345 // Order
6346 if ( state.order !== undefined ) {
6347 settings.aaSorting = [];
6348 $.each( state.order, function ( i, col ) {
6349 settings.aaSorting.push( col[0] >= columns.length ?
6350 [ 0, col[1] ] :
6351 col
6352 );
6353 } );
6354 }
6356 // Search
6357 if ( state.search !== undefined ) {
6358 $.extend( settings.oPreviousSearch, _fnSearchToHung( state.search ) );
6359 }
6361 // Columns
6362 for ( i=0, ien=state.columns.length ; i<ien ; i++ ) {
6363 var col = state.columns[i];
6365 // Visibility
6366 if ( col.visible !== undefined ) {
6367 columns[i].bVisible = col.visible;
6368 }
6370 // Search
6371 if ( col.search !== undefined ) {
6372 $.extend( settings.aoPreSearchCols[i], _fnSearchToHung( col.search ) );
6373 }
6374 }
6376 _fnCallbackFire( settings, 'aoStateLoaded', 'stateLoaded', [settings, state] );
6377 }
6380 /**
6381 * Return the settings object for a particular table
6382 * @param {node} table table we are using as a dataTable
6383 * @returns {object} Settings object - or null if not found
6384 * @memberof DataTable#oApi
6385 */
6386 function _fnSettingsFromNode ( table )
6387 {
6388 var settings = DataTable.settings;
6389 var idx = $.inArray( table, _pluck( settings, 'nTable' ) );
6391 return idx !== -1 ?
6392 settings[ idx ] :
6393 null;
6394 }
6397 /**
6398 * Log an error message
6399 * @param {object} settings dataTables settings object
6400 * @param {int} level log error messages, or display them to the user
6401 * @param {string} msg error message
6402 * @param {int} tn Technical note id to get more information about the error.
6403 * @memberof DataTable#oApi
6404 */
6405 function _fnLog( settings, level, msg, tn )
6406 {
6407 msg = 'DataTables warning: '+
6408 (settings ? 'table id='+settings.sTableId+' - ' : '')+msg;
6410 if ( tn ) {
6411 msg += '. For more information about this error, please see '+
6412 'http://datatables.net/tn/'+tn;
6413 }
6415 if ( ! level ) {
6416 // Backwards compatibility pre 1.10
6417 var ext = DataTable.ext;
6418 var type = ext.sErrMode || ext.errMode;
6420 if ( settings ) {
6421 _fnCallbackFire( settings, null, 'error', [ settings, tn, msg ] );
6422 }
6424 if ( type == 'alert' ) {
6425 alert( msg );
6426 }
6427 else if ( type == 'throw' ) {
6428 throw new Error(msg);
6429 }
6430 else if ( typeof type == 'function' ) {
6431 type( settings, tn, msg );
6432 }
6433 }
6434 else if ( window.console && console.log ) {
6435 console.log( msg );
6436 }
6437 }
6440 /**
6441 * See if a property is defined on one object, if so assign it to the other object
6442 * @param {object} ret target object
6443 * @param {object} src source object
6444 * @param {string} name property
6445 * @param {string} [mappedName] name to map too - optional, name used if not given
6446 * @memberof DataTable#oApi
6447 */
6448 function _fnMap( ret, src, name, mappedName )
6449 {
6450 if ( $.isArray( name ) ) {
6451 $.each( name, function (i, val) {
6452 if ( $.isArray( val ) ) {
6453 _fnMap( ret, src, val[0], val[1] );
6454 }
6455 else {
6456 _fnMap( ret, src, val );
6457 }
6458 } );
6460 return;
6461 }
6463 if ( mappedName === undefined ) {
6464 mappedName = name;
6465 }
6467 if ( src[name] !== undefined ) {
6468 ret[mappedName] = src[name];
6469 }
6470 }
6473 /**
6474 * Extend objects - very similar to jQuery.extend, but deep copy objects, and
6475 * shallow copy arrays. The reason we need to do this, is that we don't want to
6476 * deep copy array init values (such as aaSorting) since the dev wouldn't be
6477 * able to override them, but we do want to deep copy arrays.
6478 * @param {object} out Object to extend
6479 * @param {object} extender Object from which the properties will be applied to
6480 * out
6481 * @param {boolean} breakRefs If true, then arrays will be sliced to take an
6482 * independent copy with the exception of the `data` or `aaData` parameters
6483 * if they are present. This is so you can pass in a collection to
6484 * DataTables and have that used as your data source without breaking the
6485 * references
6486 * @returns {object} out Reference, just for convenience - out === the return.
6487 * @memberof DataTable#oApi
6488 * @todo This doesn't take account of arrays inside the deep copied objects.
6489 */
6490 function _fnExtend( out, extender, breakRefs )
6491 {
6492 var val;
6494 for ( var prop in extender ) {
6495 if ( extender.hasOwnProperty(prop) ) {
6496 val = extender[prop];
6498 if ( $.isPlainObject( val ) ) {
6499 if ( ! $.isPlainObject( out[prop] ) ) {
6500 out[prop] = {};
6501 }
6502 $.extend( true, out[prop], val );
6503 }
6504 else if ( breakRefs && prop !== 'data' && prop !== 'aaData' && $.isArray(val) ) {
6505 out[prop] = val.slice();
6506 }
6507 else {
6508 out[prop] = val;
6509 }
6510 }
6511 }
6513 return out;
6514 }
6517 /**
6518 * Bind an event handers to allow a click or return key to activate the callback.
6519 * This is good for accessibility since a return on the keyboard will have the
6520 * same effect as a click, if the element has focus.
6521 * @param {element} n Element to bind the action to
6522 * @param {object} oData Data object to pass to the triggered function
6523 * @param {function} fn Callback function for when the event is triggered
6524 * @memberof DataTable#oApi
6525 */
6526 function _fnBindAction( n, oData, fn )
6527 {
6528 $(n)
6529 .bind( 'click.DT', oData, function (e) {
6530 n.blur(); // Remove focus outline for mouse users
6531 fn(e);
6532 } )
6533 .bind( 'keypress.DT', oData, function (e){
6534 if ( e.which === 13 ) {
6535 e.preventDefault();
6536 fn(e);
6537 }
6538 } )
6539 .bind( 'selectstart.DT', function () {
6540 /* Take the brutal approach to cancelling text selection */
6541 return false;
6542 } );
6543 }
6546 /**
6547 * Register a callback function. Easily allows a callback function to be added to
6548 * an array store of callback functions that can then all be called together.
6549 * @param {object} oSettings dataTables settings object
6550 * @param {string} sStore Name of the array storage for the callbacks in oSettings
6551 * @param {function} fn Function to be called back
6552 * @param {string} sName Identifying name for the callback (i.e. a label)
6553 * @memberof DataTable#oApi
6554 */
6555 function _fnCallbackReg( oSettings, sStore, fn, sName )
6556 {
6557 if ( fn )
6558 {
6559 oSettings[sStore].push( {
6560 "fn": fn,
6561 "sName": sName
6562 } );
6563 }
6564 }
6567 /**
6568 * Fire callback functions and trigger events. Note that the loop over the
6569 * callback array store is done backwards! Further note that you do not want to
6570 * fire off triggers in time sensitive applications (for example cell creation)
6571 * as its slow.
6572 * @param {object} settings dataTables settings object
6573 * @param {string} callbackArr Name of the array storage for the callbacks in
6574 * oSettings
6575 * @param {string} eventName Name of the jQuery custom event to trigger. If
6576 * null no trigger is fired
6577 * @param {array} args Array of arguments to pass to the callback function /
6578 * trigger
6579 * @memberof DataTable#oApi
6580 */
6581 function _fnCallbackFire( settings, callbackArr, eventName, args )
6582 {
6583 var ret = [];
6585 if ( callbackArr ) {
6586 ret = $.map( settings[callbackArr].slice().reverse(), function (val, i) {
6587 return val.fn.apply( settings.oInstance, args );
6588 } );
6589 }
6591 if ( eventName !== null ) {
6592 var e = $.Event( eventName+'.dt' );
6594 $(settings.nTable).trigger( e, args );
6596 ret.push( e.result );
6597 }
6599 return ret;
6600 }
6603 function _fnLengthOverflow ( settings )
6604 {
6605 var
6606 start = settings._iDisplayStart,
6607 end = settings.fnDisplayEnd(),
6608 len = settings._iDisplayLength;
6610 /* If we have space to show extra rows (backing up from the end point - then do so */
6611 if ( start >= end )
6612 {
6613 start = end - len;
6614 }
6616 // Keep the start record on the current page
6617 start -= (start % len);
6619 if ( len === -1 || start < 0 )
6620 {
6621 start = 0;
6622 }
6624 settings._iDisplayStart = start;
6625 }
6628 function _fnRenderer( settings, type )
6629 {
6630 var renderer = settings.renderer;
6631 var host = DataTable.ext.renderer[type];
6633 if ( $.isPlainObject( renderer ) && renderer[type] ) {
6634 // Specific renderer for this type. If available use it, otherwise use
6635 // the default.
6636 return host[renderer[type]] || host._;
6637 }
6638 else if ( typeof renderer === 'string' ) {
6639 // Common renderer - if there is one available for this type use it,
6640 // otherwise use the default
6641 return host[renderer] || host._;
6642 }
6644 // Use the default
6645 return host._;
6646 }
6649 /**
6650 * Detect the data source being used for the table. Used to simplify the code
6651 * a little (ajax) and to make it compress a little smaller.
6652 *
6653 * @param {object} settings dataTables settings object
6654 * @returns {string} Data source
6655 * @memberof DataTable#oApi
6656 */
6657 function _fnDataSource ( settings )
6658 {
6659 if ( settings.oFeatures.bServerSide ) {
6660 return 'ssp';
6661 }
6662 else if ( settings.ajax || settings.sAjaxSource ) {
6663 return 'ajax';
6664 }
6665 return 'dom';
6666 }
6671 /**
6672 * Computed structure of the DataTables API, defined by the options passed to
6673 * `DataTable.Api.register()` when building the API.
6674 *
6675 * The structure is built in order to speed creation and extension of the Api
6676 * objects since the extensions are effectively pre-parsed.
6677 *
6678 * The array is an array of objects with the following structure, where this
6679 * base array represents the Api prototype base:
6680 *
6681 * [
6682 * {
6683 * name: 'data' -- string - Property name
6684 * val: function () {}, -- function - Api method (or undefined if just an object
6685 * methodExt: [ ... ], -- array - Array of Api object definitions to extend the method result
6686 * propExt: [ ... ] -- array - Array of Api object definitions to extend the property
6687 * },
6688 * {
6689 * name: 'row'
6690 * val: {},
6691 * methodExt: [ ... ],
6692 * propExt: [
6693 * {
6694 * name: 'data'
6695 * val: function () {},
6696 * methodExt: [ ... ],
6697 * propExt: [ ... ]
6698 * },
6699 * ...
6700 * ]
6701 * }
6702 * ]
6703 *
6704 * @type {Array}
6705 * @ignore
6706 */
6707 var __apiStruct = [];
6710 /**
6711 * `Array.prototype` reference.
6712 *
6713 * @type object
6714 * @ignore
6715 */
6716 var __arrayProto = Array.prototype;
6719 /**
6720 * Abstraction for `context` parameter of the `Api` constructor to allow it to
6721 * take several different forms for ease of use.
6722 *
6723 * Each of the input parameter types will be converted to a DataTables settings
6724 * object where possible.
6725 *
6726 * @param {string|node|jQuery|object} mixed DataTable identifier. Can be one
6727 * of:
6728 *
6729 * * `string` - jQuery selector. Any DataTables' matching the given selector
6730 * with be found and used.
6731 * * `node` - `TABLE` node which has already been formed into a DataTable.
6732 * * `jQuery` - A jQuery object of `TABLE` nodes.
6733 * * `object` - DataTables settings object
6734 * * `DataTables.Api` - API instance
6735 * @return {array|null} Matching DataTables settings objects. `null` or
6736 * `undefined` is returned if no matching DataTable is found.
6737 * @ignore
6738 */
6739 var _toSettings = function ( mixed )
6740 {
6741 var idx, jq;
6742 var settings = DataTable.settings;
6743 var tables = $.map( settings, function (el, i) {
6744 return el.nTable;
6745 } );
6747 if ( ! mixed ) {
6748 return [];
6749 }
6750 else if ( mixed.nTable && mixed.oApi ) {
6751 // DataTables settings object
6752 return [ mixed ];
6753 }
6754 else if ( mixed.nodeName && mixed.nodeName.toLowerCase() === 'table' ) {
6755 // Table node
6756 idx = $.inArray( mixed, tables );
6757 return idx !== -1 ? [ settings[idx] ] : null;
6758 }
6759 else if ( mixed && typeof mixed.settings === 'function' ) {
6760 return mixed.settings().toArray();
6761 }
6762 else if ( typeof mixed === 'string' ) {
6763 // jQuery selector
6764 jq = $(mixed);
6765 }
6766 else if ( mixed instanceof $ ) {
6767 // jQuery object (also DataTables instance)
6768 jq = mixed;
6769 }
6771 if ( jq ) {
6772 return jq.map( function(i) {
6773 idx = $.inArray( this, tables );
6774 return idx !== -1 ? settings[idx] : null;
6775 } ).toArray();
6776 }
6777 };
6780 /**
6781 * DataTables API class - used to control and interface with one or more
6782 * DataTables enhanced tables.
6783 *
6784 * The API class is heavily based on jQuery, presenting a chainable interface
6785 * that you can use to interact with tables. Each instance of the API class has
6786 * a "context" - i.e. the tables that it will operate on. This could be a single
6787 * table, all tables on a page or a sub-set thereof.
6788 *
6789 * Additionally the API is designed to allow you to easily work with the data in
6790 * the tables, retrieving and manipulating it as required. This is done by
6791 * presenting the API class as an array like interface. The contents of the
6792 * array depend upon the actions requested by each method (for example
6793 * `rows().nodes()` will return an array of nodes, while `rows().data()` will
6794 * return an array of objects or arrays depending upon your table's
6795 * configuration). The API object has a number of array like methods (`push`,
6796 * `pop`, `reverse` etc) as well as additional helper methods (`each`, `pluck`,
6797 * `unique` etc) to assist your working with the data held in a table.
6798 *
6799 * Most methods (those which return an Api instance) are chainable, which means
6800 * the return from a method call also has all of the methods available that the
6801 * top level object had. For example, these two calls are equivalent:
6802 *
6803 * // Not chained
6804 * api.row.add( {...} );
6805 * api.draw();
6806 *
6807 * // Chained
6808 * api.row.add( {...} ).draw();
6809 *
6810 * @class DataTable.Api
6811 * @param {array|object|string|jQuery} context DataTable identifier. This is
6812 * used to define which DataTables enhanced tables this API will operate on.
6813 * Can be one of:
6814 *
6815 * * `string` - jQuery selector. Any DataTables' matching the given selector
6816 * with be found and used.
6817 * * `node` - `TABLE` node which has already been formed into a DataTable.
6818 * * `jQuery` - A jQuery object of `TABLE` nodes.
6819 * * `object` - DataTables settings object
6820 * @param {array} [data] Data to initialise the Api instance with.
6821 *
6822 * @example
6823 * // Direct initialisation during DataTables construction
6824 * var api = $('#example').DataTable();
6825 *
6826 * @example
6827 * // Initialisation using a DataTables jQuery object
6828 * var api = $('#example').dataTable().api();
6829 *
6830 * @example
6831 * // Initialisation as a constructor
6832 * var api = new $.fn.DataTable.Api( 'table.dataTable' );
6833 */
6834 _Api = function ( context, data )
6835 {
6836 if ( ! (this instanceof _Api) ) {
6837 return new _Api( context, data );
6838 }
6840 var settings = [];
6841 var ctxSettings = function ( o ) {
6842 var a = _toSettings( o );
6843 if ( a ) {
6844 settings = settings.concat( a );
6845 }
6846 };
6848 if ( $.isArray( context ) ) {
6849 for ( var i=0, ien=context.length ; i<ien ; i++ ) {
6850 ctxSettings( context[i] );
6851 }
6852 }
6853 else {
6854 ctxSettings( context );
6855 }
6857 // Remove duplicates
6858 this.context = _unique( settings );
6860 // Initial data
6861 if ( data ) {
6862 $.merge( this, data );
6863 }
6865 // selector
6866 this.selector = {
6867 rows: null,
6868 cols: null,
6869 opts: null
6870 };
6872 _Api.extend( this, this, __apiStruct );
6873 };
6875 DataTable.Api = _Api;
6877 // Don't destroy the existing prototype, just extend it. Required for jQuery 2's
6878 // isPlainObject.
6879 $.extend( _Api.prototype, {
6880 any: function ()
6881 {
6882 return this.count() !== 0;
6883 },
6886 concat: __arrayProto.concat,
6889 context: [], // array of table settings objects
6892 count: function ()
6893 {
6894 return this.flatten().length;
6895 },
6898 each: function ( fn )
6899 {
6900 for ( var i=0, ien=this.length ; i<ien; i++ ) {
6901 fn.call( this, this[i], i, this );
6902 }
6904 return this;
6905 },
6908 eq: function ( idx )
6909 {
6910 var ctx = this.context;
6912 return ctx.length > idx ?
6913 new _Api( ctx[idx], this[idx] ) :
6914 null;
6915 },
6918 filter: function ( fn )
6919 {
6920 var a = [];
6922 if ( __arrayProto.filter ) {
6923 a = __arrayProto.filter.call( this, fn, this );
6924 }
6925 else {
6926 // Compatibility for browsers without EMCA-252-5 (JS 1.6)
6927 for ( var i=0, ien=this.length ; i<ien ; i++ ) {
6928 if ( fn.call( this, this[i], i, this ) ) {
6929 a.push( this[i] );
6930 }
6931 }
6932 }
6934 return new _Api( this.context, a );
6935 },
6938 flatten: function ()
6939 {
6940 var a = [];
6941 return new _Api( this.context, a.concat.apply( a, this.toArray() ) );
6942 },
6945 join: __arrayProto.join,
6948 indexOf: __arrayProto.indexOf || function (obj, start)
6949 {
6950 for ( var i=(start || 0), ien=this.length ; i<ien ; i++ ) {
6951 if ( this[i] === obj ) {
6952 return i;
6953 }
6954 }
6955 return -1;
6956 },
6958 iterator: function ( flatten, type, fn, alwaysNew ) {
6959 var
6960 a = [], ret,
6961 i, ien, j, jen,
6962 context = this.context,
6963 rows, items, item,
6964 selector = this.selector;
6966 // Argument shifting
6967 if ( typeof flatten === 'string' ) {
6968 alwaysNew = fn;
6969 fn = type;
6970 type = flatten;
6971 flatten = false;
6972 }
6974 for ( i=0, ien=context.length ; i<ien ; i++ ) {
6975 var apiInst = new _Api( context[i] );
6977 if ( type === 'table' ) {
6978 ret = fn.call( apiInst, context[i], i );
6980 if ( ret !== undefined ) {
6981 a.push( ret );
6982 }
6983 }
6984 else if ( type === 'columns' || type === 'rows' ) {
6985 // this has same length as context - one entry for each table
6986 ret = fn.call( apiInst, context[i], this[i], i );
6988 if ( ret !== undefined ) {
6989 a.push( ret );
6990 }
6991 }
6992 else if ( type === 'column' || type === 'column-rows' || type === 'row' || type === 'cell' ) {
6993 // columns and rows share the same structure.
6994 // 'this' is an array of column indexes for each context
6995 items = this[i];
6997 if ( type === 'column-rows' ) {
6998 rows = _selector_row_indexes( context[i], selector.opts );
6999 }
7001 for ( j=0, jen=items.length ; j<jen ; j++ ) {
7002 item = items[j];
7004 if ( type === 'cell' ) {
7005 ret = fn.call( apiInst, context[i], item.row, item.column, i, j );
7006 }
7007 else {
7008 ret = fn.call( apiInst, context[i], item, i, j, rows );
7009 }
7011 if ( ret !== undefined ) {
7012 a.push( ret );
7013 }
7014 }
7015 }
7016 }
7018 if ( a.length || alwaysNew ) {
7019 var api = new _Api( context, flatten ? a.concat.apply( [], a ) : a );
7020 var apiSelector = api.selector;
7021 apiSelector.rows = selector.rows;
7022 apiSelector.cols = selector.cols;
7023 apiSelector.opts = selector.opts;
7024 return api;
7025 }
7026 return this;
7027 },
7030 lastIndexOf: __arrayProto.lastIndexOf || function (obj, start)
7031 {
7032 // Bit cheeky...
7033 return this.indexOf.apply( this.toArray.reverse(), arguments );
7034 },
7037 length: 0,
7040 map: function ( fn )
7041 {
7042 var a = [];
7044 if ( __arrayProto.map ) {
7045 a = __arrayProto.map.call( this, fn, this );
7046 }
7047 else {
7048 // Compatibility for browsers without EMCA-252-5 (JS 1.6)
7049 for ( var i=0, ien=this.length ; i<ien ; i++ ) {
7050 a.push( fn.call( this, this[i], i ) );
7051 }
7052 }
7054 return new _Api( this.context, a );
7055 },
7058 pluck: function ( prop )
7059 {
7060 return this.map( function ( el ) {
7061 return el[ prop ];
7062 } );
7063 },
7065 pop: __arrayProto.pop,
7068 push: __arrayProto.push,
7071 // Does not return an API instance
7072 reduce: __arrayProto.reduce || function ( fn, init )
7073 {
7074 return _fnReduce( this, fn, init, 0, this.length, 1 );
7075 },
7078 reduceRight: __arrayProto.reduceRight || function ( fn, init )
7079 {
7080 return _fnReduce( this, fn, init, this.length-1, -1, -1 );
7081 },
7084 reverse: __arrayProto.reverse,
7087 // Object with rows, columns and opts
7088 selector: null,
7091 shift: __arrayProto.shift,
7094 sort: __arrayProto.sort, // ? name - order?
7097 splice: __arrayProto.splice,
7100 toArray: function ()
7101 {
7102 return __arrayProto.slice.call( this );
7103 },
7106 to$: function ()
7107 {
7108 return $( this );
7109 },
7112 toJQuery: function ()
7113 {
7114 return $( this );
7115 },
7118 unique: function ()
7119 {
7120 return new _Api( this.context, _unique(this) );
7121 },
7124 unshift: __arrayProto.unshift
7125 } );
7128 _Api.extend = function ( scope, obj, ext )
7129 {
7130 // Only extend API instances and static properties of the API
7131 if ( ! ext.length || ! obj || ( ! (obj instanceof _Api) && ! obj.__dt_wrapper ) ) {
7132 return;
7133 }
7135 var
7136 i, ien,
7137 j, jen,
7138 struct, inner,
7139 methodScoping = function ( scope, fn, struc ) {
7140 return function () {
7141 var ret = fn.apply( scope, arguments );
7143 // Method extension
7144 _Api.extend( ret, ret, struc.methodExt );
7145 return ret;
7146 };
7147 };
7149 for ( i=0, ien=ext.length ; i<ien ; i++ ) {
7150 struct = ext[i];
7152 // Value
7153 obj[ struct.name ] = typeof struct.val === 'function' ?
7154 methodScoping( scope, struct.val, struct ) :
7155 $.isPlainObject( struct.val ) ?
7156 {} :
7157 struct.val;
7159 obj[ struct.name ].__dt_wrapper = true;
7161 // Property extension
7162 _Api.extend( scope, obj[ struct.name ], struct.propExt );
7163 }
7164 };
7167 // @todo - Is there need for an augment function?
7168 // _Api.augment = function ( inst, name )
7169 // {
7170 // // Find src object in the structure from the name
7171 // var parts = name.split('.');
7173 // _Api.extend( inst, obj );
7174 // };
7177 // [
7178 // {
7179 // name: 'data' -- string - Property name
7180 // val: function () {}, -- function - Api method (or undefined if just an object
7181 // methodExt: [ ... ], -- array - Array of Api object definitions to extend the method result
7182 // propExt: [ ... ] -- array - Array of Api object definitions to extend the property
7183 // },
7184 // {
7185 // name: 'row'
7186 // val: {},
7187 // methodExt: [ ... ],
7188 // propExt: [
7189 // {
7190 // name: 'data'
7191 // val: function () {},
7192 // methodExt: [ ... ],
7193 // propExt: [ ... ]
7194 // },
7195 // ...
7196 // ]
7197 // }
7198 // ]
7200 _Api.register = _api_register = function ( name, val )
7201 {
7202 if ( $.isArray( name ) ) {
7203 for ( var j=0, jen=name.length ; j<jen ; j++ ) {
7204 _Api.register( name[j], val );
7205 }
7206 return;
7207 }
7209 var
7210 i, ien,
7211 heir = name.split('.'),
7212 struct = __apiStruct,
7213 key, method;
7215 var find = function ( src, name ) {
7216 for ( var i=0, ien=src.length ; i<ien ; i++ ) {
7217 if ( src[i].name === name ) {
7218 return src[i];
7219 }
7220 }
7221 return null;
7222 };
7224 for ( i=0, ien=heir.length ; i<ien ; i++ ) {
7225 method = heir[i].indexOf('()') !== -1;
7226 key = method ?
7227 heir[i].replace('()', '') :
7228 heir[i];
7230 var src = find( struct, key );
7231 if ( ! src ) {
7232 src = {
7233 name: key,
7234 val: {},
7235 methodExt: [],
7236 propExt: []
7237 };
7238 struct.push( src );
7239 }
7241 if ( i === ien-1 ) {
7242 src.val = val;
7243 }
7244 else {
7245 struct = method ?
7246 src.methodExt :
7247 src.propExt;
7248 }
7249 }
7250 };
7253 _Api.registerPlural = _api_registerPlural = function ( pluralName, singularName, val ) {
7254 _Api.register( pluralName, val );
7256 _Api.register( singularName, function () {
7257 var ret = val.apply( this, arguments );
7259 if ( ret === this ) {
7260 // Returned item is the API instance that was passed in, return it
7261 return this;
7262 }
7263 else if ( ret instanceof _Api ) {
7264 // New API instance returned, want the value from the first item
7265 // in the returned array for the singular result.
7266 return ret.length ?
7267 $.isArray( ret[0] ) ?
7268 new _Api( ret.context, ret[0] ) : // Array results are 'enhanced'
7269 ret[0] :
7270 undefined;
7271 }
7273 // Non-API return - just fire it back
7274 return ret;
7275 } );
7276 };
7279 /**
7280 * Selector for HTML tables. Apply the given selector to the give array of
7281 * DataTables settings objects.
7282 *
7283 * @param {string|integer} [selector] jQuery selector string or integer
7284 * @param {array} Array of DataTables settings objects to be filtered
7285 * @return {array}
7286 * @ignore
7287 */
7288 var __table_selector = function ( selector, a )
7289 {
7290 // Integer is used to pick out a table by index
7291 if ( typeof selector === 'number' ) {
7292 return [ a[ selector ] ];
7293 }
7295 // Perform a jQuery selector on the table nodes
7296 var nodes = $.map( a, function (el, i) {
7297 return el.nTable;
7298 } );
7300 return $(nodes)
7301 .filter( selector )
7302 .map( function (i) {
7303 // Need to translate back from the table node to the settings
7304 var idx = $.inArray( this, nodes );
7305 return a[ idx ];
7306 } )
7307 .toArray();
7308 };
7312 /**
7313 * Context selector for the API's context (i.e. the tables the API instance
7314 * refers to.
7315 *
7316 * @name DataTable.Api#tables
7317 * @param {string|integer} [selector] Selector to pick which tables the iterator
7318 * should operate on. If not given, all tables in the current context are
7319 * used. This can be given as a jQuery selector (for example `':gt(0)'`) to
7320 * select multiple tables or as an integer to select a single table.
7321 * @returns {DataTable.Api} Returns a new API instance if a selector is given.
7322 */
7323 _api_register( 'tables()', function ( selector ) {
7324 // A new instance is created if there was a selector specified
7325 return selector ?
7326 new _Api( __table_selector( selector, this.context ) ) :
7327 this;
7328 } );
7331 _api_register( 'table()', function ( selector ) {
7332 var tables = this.tables( selector );
7333 var ctx = tables.context;
7335 // Truncate to the first matched table
7336 return ctx.length ?
7337 new _Api( ctx[0] ) :
7338 tables;
7339 } );
7342 _api_registerPlural( 'tables().nodes()', 'table().node()' , function () {
7343 return this.iterator( 'table', function ( ctx ) {
7344 return ctx.nTable;
7345 }, 1 );
7346 } );
7349 _api_registerPlural( 'tables().body()', 'table().body()' , function () {
7350 return this.iterator( 'table', function ( ctx ) {
7351 return ctx.nTBody;
7352 }, 1 );
7353 } );
7356 _api_registerPlural( 'tables().header()', 'table().header()' , function () {
7357 return this.iterator( 'table', function ( ctx ) {
7358 return ctx.nTHead;
7359 }, 1 );
7360 } );
7363 _api_registerPlural( 'tables().footer()', 'table().footer()' , function () {
7364 return this.iterator( 'table', function ( ctx ) {
7365 return ctx.nTFoot;
7366 }, 1 );
7367 } );
7370 _api_registerPlural( 'tables().containers()', 'table().container()' , function () {
7371 return this.iterator( 'table', function ( ctx ) {
7372 return ctx.nTableWrapper;
7373 }, 1 );
7374 } );
7378 /**
7379 * Redraw the tables in the current context.
7380 */
7381 _api_register( 'draw()', function ( paging ) {
7382 return this.iterator( 'table', function ( settings ) {
7383 if ( paging === 'page' ) {
7384 _fnDraw( settings );
7385 }
7386 else {
7387 if ( typeof paging === 'string' ) {
7388 paging = paging === 'full-hold' ?
7389 false :
7390 true;
7391 }
7393 _fnReDraw( settings, paging===false );
7394 }
7395 } );
7396 } );
7400 /**
7401 * Get the current page index.
7402 *
7403 * @return {integer} Current page index (zero based)
7404 *//**
7405 * Set the current page.
7406 *
7407 * Note that if you attempt to show a page which does not exist, DataTables will
7408 * not throw an error, but rather reset the paging.
7409 *
7410 * @param {integer|string} action The paging action to take. This can be one of:
7411 * * `integer` - The page index to jump to
7412 * * `string` - An action to take:
7413 * * `first` - Jump to first page.
7414 * * `next` - Jump to the next page
7415 * * `previous` - Jump to previous page
7416 * * `last` - Jump to the last page.
7417 * @returns {DataTables.Api} this
7418 */
7419 _api_register( 'page()', function ( action ) {
7420 if ( action === undefined ) {
7421 return this.page.info().page; // not an expensive call
7422 }
7424 // else, have an action to take on all tables
7425 return this.iterator( 'table', function ( settings ) {
7426 _fnPageChange( settings, action );
7427 } );
7428 } );
7431 /**
7432 * Paging information for the first table in the current context.
7433 *
7434 * If you require paging information for another table, use the `table()` method
7435 * with a suitable selector.
7436 *
7437 * @return {object} Object with the following properties set:
7438 * * `page` - Current page index (zero based - i.e. the first page is `0`)
7439 * * `pages` - Total number of pages
7440 * * `start` - Display index for the first record shown on the current page
7441 * * `end` - Display index for the last record shown on the current page
7442 * * `length` - Display length (number of records). Note that generally `start
7443 * + length = end`, but this is not always true, for example if there are
7444 * only 2 records to show on the final page, with a length of 10.
7445 * * `recordsTotal` - Full data set length
7446 * * `recordsDisplay` - Data set length once the current filtering criterion
7447 * are applied.
7448 */
7449 _api_register( 'page.info()', function ( action ) {
7450 if ( this.context.length === 0 ) {
7451 return undefined;
7452 }
7454 var
7455 settings = this.context[0],
7456 start = settings._iDisplayStart,
7457 len = settings.oFeatures.bPaginate ? settings._iDisplayLength : -1,
7458 visRecords = settings.fnRecordsDisplay(),
7459 all = len === -1;
7461 return {
7462 "page": all ? 0 : Math.floor( start / len ),
7463 "pages": all ? 1 : Math.ceil( visRecords / len ),
7464 "start": start,
7465 "end": settings.fnDisplayEnd(),
7466 "length": len,
7467 "recordsTotal": settings.fnRecordsTotal(),
7468 "recordsDisplay": visRecords,
7469 "serverSide": _fnDataSource( settings ) === 'ssp'
7470 };
7471 } );
7474 /**
7475 * Get the current page length.
7476 *
7477 * @return {integer} Current page length. Note `-1` indicates that all records
7478 * are to be shown.
7479 *//**
7480 * Set the current page length.
7481 *
7482 * @param {integer} Page length to set. Use `-1` to show all records.
7483 * @returns {DataTables.Api} this
7484 */
7485 _api_register( 'page.len()', function ( len ) {
7486 // Note that we can't call this function 'length()' because `length`
7487 // is a Javascript property of functions which defines how many arguments
7488 // the function expects.
7489 if ( len === undefined ) {
7490 return this.context.length !== 0 ?
7491 this.context[0]._iDisplayLength :
7492 undefined;
7493 }
7495 // else, set the page length
7496 return this.iterator( 'table', function ( settings ) {
7497 _fnLengthChange( settings, len );
7498 } );
7499 } );
7503 var __reload = function ( settings, holdPosition, callback ) {
7504 // Use the draw event to trigger a callback
7505 if ( callback ) {
7506 var api = new _Api( settings );
7508 api.one( 'draw', function () {
7509 callback( api.ajax.json() );
7510 } );
7511 }
7513 if ( _fnDataSource( settings ) == 'ssp' ) {
7514 _fnReDraw( settings, holdPosition );
7515 }
7516 else {
7517 _fnProcessingDisplay( settings, true );
7519 // Cancel an existing request
7520 var xhr = settings.jqXHR;
7521 if ( xhr && xhr.readyState !== 4 ) {
7522 xhr.abort();
7523 }
7525 // Trigger xhr
7526 _fnBuildAjax( settings, [], function( json ) {
7527 _fnClearTable( settings );
7529 var data = _fnAjaxDataSrc( settings, json );
7530 for ( var i=0, ien=data.length ; i<ien ; i++ ) {
7531 _fnAddData( settings, data[i] );
7532 }
7534 _fnReDraw( settings, holdPosition );
7535 _fnProcessingDisplay( settings, false );
7536 } );
7537 }
7538 };
7541 /**
7542 * Get the JSON response from the last Ajax request that DataTables made to the
7543 * server. Note that this returns the JSON from the first table in the current
7544 * context.
7545 *
7546 * @return {object} JSON received from the server.
7547 */
7548 _api_register( 'ajax.json()', function () {
7549 var ctx = this.context;
7551 if ( ctx.length > 0 ) {
7552 return ctx[0].json;
7553 }
7555 // else return undefined;
7556 } );
7559 /**
7560 * Get the data submitted in the last Ajax request
7561 */
7562 _api_register( 'ajax.params()', function () {
7563 var ctx = this.context;
7565 if ( ctx.length > 0 ) {
7566 return ctx[0].oAjaxData;
7567 }
7569 // else return undefined;
7570 } );
7573 /**
7574 * Reload tables from the Ajax data source. Note that this function will
7575 * automatically re-draw the table when the remote data has been loaded.
7576 *
7577 * @param {boolean} [reset=true] Reset (default) or hold the current paging
7578 * position. A full re-sort and re-filter is performed when this method is
7579 * called, which is why the pagination reset is the default action.
7580 * @returns {DataTables.Api} this
7581 */
7582 _api_register( 'ajax.reload()', function ( callback, resetPaging ) {
7583 return this.iterator( 'table', function (settings) {
7584 __reload( settings, resetPaging===false, callback );
7585 } );
7586 } );
7589 /**
7590 * Get the current Ajax URL. Note that this returns the URL from the first
7591 * table in the current context.
7592 *
7593 * @return {string} Current Ajax source URL
7594 *//**
7595 * Set the Ajax URL. Note that this will set the URL for all tables in the
7596 * current context.
7597 *
7598 * @param {string} url URL to set.
7599 * @returns {DataTables.Api} this
7600 */
7601 _api_register( 'ajax.url()', function ( url ) {
7602 var ctx = this.context;
7604 if ( url === undefined ) {
7605 // get
7606 if ( ctx.length === 0 ) {
7607 return undefined;
7608 }
7609 ctx = ctx[0];
7611 return ctx.ajax ?
7612 $.isPlainObject( ctx.ajax ) ?
7613 ctx.ajax.url :
7614 ctx.ajax :
7615 ctx.sAjaxSource;
7616 }
7618 // set
7619 return this.iterator( 'table', function ( settings ) {
7620 if ( $.isPlainObject( settings.ajax ) ) {
7621 settings.ajax.url = url;
7622 }
7623 else {
7624 settings.ajax = url;
7625 }
7626 // No need to consider sAjaxSource here since DataTables gives priority
7627 // to `ajax` over `sAjaxSource`. So setting `ajax` here, renders any
7628 // value of `sAjaxSource` redundant.
7629 } );
7630 } );
7633 /**
7634 * Load data from the newly set Ajax URL. Note that this method is only
7635 * available when `ajax.url()` is used to set a URL. Additionally, this method
7636 * has the same effect as calling `ajax.reload()` but is provided for
7637 * convenience when setting a new URL. Like `ajax.reload()` it will
7638 * automatically redraw the table once the remote data has been loaded.
7639 *
7640 * @returns {DataTables.Api} this
7641 */
7642 _api_register( 'ajax.url().load()', function ( callback, resetPaging ) {
7643 // Same as a reload, but makes sense to present it for easy access after a
7644 // url change
7645 return this.iterator( 'table', function ( ctx ) {
7646 __reload( ctx, resetPaging===false, callback );
7647 } );
7648 } );
7653 var _selector_run = function ( type, selector, selectFn, settings, opts )
7654 {
7655 var
7656 out = [], res,
7657 a, i, ien, j, jen,
7658 selectorType = typeof selector;
7660 // Can't just check for isArray here, as an API or jQuery instance might be
7661 // given with their array like look
7662 if ( ! selector || selectorType === 'string' || selectorType === 'function' || selector.length === undefined ) {
7663 selector = [ selector ];
7664 }
7666 for ( i=0, ien=selector.length ; i<ien ; i++ ) {
7667 a = selector[i] && selector[i].split ?
7668 selector[i].split(',') :
7669 [ selector[i] ];
7671 for ( j=0, jen=a.length ; j<jen ; j++ ) {
7672 res = selectFn( typeof a[j] === 'string' ? $.trim(a[j]) : a[j] );
7674 if ( res && res.length ) {
7675 out = out.concat( res );
7676 }
7677 }
7678 }
7680 // selector extensions
7681 var ext = _ext.selector[ type ];
7682 if ( ext.length ) {
7683 for ( i=0, ien=ext.length ; i<ien ; i++ ) {
7684 out = ext[i]( settings, opts, out );
7685 }
7686 }
7688 return _unique( out );
7689 };
7692 var _selector_opts = function ( opts )
7693 {
7694 if ( ! opts ) {
7695 opts = {};
7696 }
7698 // Backwards compatibility for 1.9- which used the terminology filter rather
7699 // than search
7700 if ( opts.filter && opts.search === undefined ) {
7701 opts.search = opts.filter;
7702 }
7704 return $.extend( {
7705 search: 'none',
7706 order: 'current',
7707 page: 'all'
7708 }, opts );
7709 };
7712 var _selector_first = function ( inst )
7713 {
7714 // Reduce the API instance to the first item found
7715 for ( var i=0, ien=inst.length ; i<ien ; i++ ) {
7716 if ( inst[i].length > 0 ) {
7717 // Assign the first element to the first item in the instance
7718 // and truncate the instance and context
7719 inst[0] = inst[i];
7720 inst[0].length = 1;
7721 inst.length = 1;
7722 inst.context = [ inst.context[i] ];
7724 return inst;
7725 }
7726 }
7728 // Not found - return an empty instance
7729 inst.length = 0;
7730 return inst;
7731 };
7734 var _selector_row_indexes = function ( settings, opts )
7735 {
7736 var
7737 i, ien, tmp, a=[],
7738 displayFiltered = settings.aiDisplay,
7739 displayMaster = settings.aiDisplayMaster;
7741 var
7742 search = opts.search, // none, applied, removed
7743 order = opts.order, // applied, current, index (original - compatibility with 1.9)
7744 page = opts.page; // all, current
7746 if ( _fnDataSource( settings ) == 'ssp' ) {
7747 // In server-side processing mode, most options are irrelevant since
7748 // rows not shown don't exist and the index order is the applied order
7749 // Removed is a special case - for consistency just return an empty
7750 // array
7751 return search === 'removed' ?
7752 [] :
7753 _range( 0, displayMaster.length );
7754 }
7755 else if ( page == 'current' ) {
7756 // Current page implies that order=current and fitler=applied, since it is
7757 // fairly senseless otherwise, regardless of what order and search actually
7758 // are
7759 for ( i=settings._iDisplayStart, ien=settings.fnDisplayEnd() ; i<ien ; i++ ) {
7760 a.push( displayFiltered[i] );
7761 }
7762 }
7763 else if ( order == 'current' || order == 'applied' ) {
7764 a = search == 'none' ?
7765 displayMaster.slice() : // no search
7766 search == 'applied' ?
7767 displayFiltered.slice() : // applied search
7768 $.map( displayMaster, function (el, i) { // removed search
7769 return $.inArray( el, displayFiltered ) === -1 ? el : null;
7770 } );
7771 }
7772 else if ( order == 'index' || order == 'original' ) {
7773 for ( i=0, ien=settings.aoData.length ; i<ien ; i++ ) {
7774 if ( search == 'none' ) {
7775 a.push( i );
7776 }
7777 else { // applied | removed
7778 tmp = $.inArray( i, displayFiltered );
7780 if ((tmp === -1 && search == 'removed') ||
7781 (tmp >= 0 && search == 'applied') )
7782 {
7783 a.push( i );
7784 }
7785 }
7786 }
7787 }
7789 return a;
7790 };
7793 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
7794 * Rows
7795 *
7796 * {} - no selector - use all available rows
7797 * {integer} - row aoData index
7798 * {node} - TR node
7799 * {string} - jQuery selector to apply to the TR elements
7800 * {array} - jQuery array of nodes, or simply an array of TR nodes
7801 *
7802 */
7805 var __row_selector = function ( settings, selector, opts )
7806 {
7807 var run = function ( sel ) {
7808 var selInt = _intVal( sel );
7809 var i, ien;
7811 // Short cut - selector is a number and no options provided (default is
7812 // all records, so no need to check if the index is in there, since it
7813 // must be - dev error if the index doesn't exist).
7814 if ( selInt !== null && ! opts ) {
7815 return [ selInt ];
7816 }
7818 var rows = _selector_row_indexes( settings, opts );
7820 if ( selInt !== null && $.inArray( selInt, rows ) !== -1 ) {
7821 // Selector - integer
7822 return [ selInt ];
7823 }
7824 else if ( ! sel ) {
7825 // Selector - none
7826 return rows;
7827 }
7829 // Selector - function
7830 if ( typeof sel === 'function' ) {
7831 return $.map( rows, function (idx) {
7832 var row = settings.aoData[ idx ];
7833 return sel( idx, row._aData, row.nTr ) ? idx : null;
7834 } );
7835 }
7837 // Get nodes in the order from the `rows` array with null values removed
7838 var nodes = _removeEmpty(
7839 _pluck_order( settings.aoData, rows, 'nTr' )
7840 );
7842 // Selector - node
7843 if ( sel.nodeName ) {
7844 if ( sel._DT_RowIndex !== undefined ) {
7845 return [ sel._DT_RowIndex ]; // Property added by DT for fast lookup
7846 }
7847 else if ( sel._DT_CellIndex ) {
7848 return [ sel._DT_CellIndex.row ];
7849 }
7850 else {
7851 var host = $(sel).closest('*[data-dt-row]');
7852 return host.length ?
7853 [ host.data('dt-row') ] :
7854 [];
7855 }
7856 }
7858 // ID selector. Want to always be able to select rows by id, regardless
7859 // of if the tr element has been created or not, so can't rely upon
7860 // jQuery here - hence a custom implementation. This does not match
7861 // Sizzle's fast selector or HTML4 - in HTML5 the ID can be anything,
7862 // but to select it using a CSS selector engine (like Sizzle or
7863 // querySelect) it would need to need to be escaped for some characters.
7864 // DataTables simplifies this for row selectors since you can select
7865 // only a row. A # indicates an id any anything that follows is the id -
7866 // unescaped.
7867 if ( typeof sel === 'string' && sel.charAt(0) === '#' ) {
7868 // get row index from id
7869 var rowObj = settings.aIds[ sel.replace( /^#/, '' ) ];
7870 if ( rowObj !== undefined ) {
7871 return [ rowObj.idx ];
7872 }
7874 // need to fall through to jQuery in case there is DOM id that
7875 // matches
7876 }
7878 // Selector - jQuery selector string, array of nodes or jQuery object/
7879 // As jQuery's .filter() allows jQuery objects to be passed in filter,
7880 // it also allows arrays, so this will cope with all three options
7881 return $(nodes)
7882 .filter( sel )
7883 .map( function () {
7884 return this._DT_RowIndex;
7885 } )
7886 .toArray();
7887 };
7889 return _selector_run( 'row', selector, run, settings, opts );
7890 };
7893 _api_register( 'rows()', function ( selector, opts ) {
7894 // argument shifting
7895 if ( selector === undefined ) {
7896 selector = '';
7897 }
7898 else if ( $.isPlainObject( selector ) ) {
7899 opts = selector;
7900 selector = '';
7901 }
7903 opts = _selector_opts( opts );
7905 var inst = this.iterator( 'table', function ( settings ) {
7906 return __row_selector( settings, selector, opts );
7907 }, 1 );
7909 // Want argument shifting here and in __row_selector?
7910 inst.selector.rows = selector;
7911 inst.selector.opts = opts;
7913 return inst;
7914 } );
7916 _api_register( 'rows().nodes()', function () {
7917 return this.iterator( 'row', function ( settings, row ) {
7918 return settings.aoData[ row ].nTr || undefined;
7919 }, 1 );
7920 } );
7922 _api_register( 'rows().data()', function () {
7923 return this.iterator( true, 'rows', function ( settings, rows ) {
7924 return _pluck_order( settings.aoData, rows, '_aData' );
7925 }, 1 );
7926 } );
7928 _api_registerPlural( 'rows().cache()', 'row().cache()', function ( type ) {
7929 return this.iterator( 'row', function ( settings, row ) {
7930 var r = settings.aoData[ row ];
7931 return type === 'search' ? r._aFilterData : r._aSortData;
7932 }, 1 );
7933 } );
7935 _api_registerPlural( 'rows().invalidate()', 'row().invalidate()', function ( src ) {
7936 return this.iterator( 'row', function ( settings, row ) {
7937 _fnInvalidate( settings, row, src );
7938 } );
7939 } );
7941 _api_registerPlural( 'rows().indexes()', 'row().index()', function () {
7942 return this.iterator( 'row', function ( settings, row ) {
7943 return row;
7944 }, 1 );
7945 } );
7947 _api_registerPlural( 'rows().ids()', 'row().id()', function ( hash ) {
7948 var a = [];
7949 var context = this.context;
7951 // `iterator` will drop undefined values, but in this case we want them
7952 for ( var i=0, ien=context.length ; i<ien ; i++ ) {
7953 for ( var j=0, jen=this[i].length ; j<jen ; j++ ) {
7954 var id = context[i].rowIdFn( context[i].aoData[ this[i][j] ]._aData );
7955 a.push( (hash === true ? '#' : '' )+ id );
7956 }
7957 }
7959 return new _Api( context, a );
7960 } );
7962 _api_registerPlural( 'rows().remove()', 'row().remove()', function () {
7963 var that = this;
7965 this.iterator( 'row', function ( settings, row, thatIdx ) {
7966 var data = settings.aoData;
7967 var rowData = data[ row ];
7968 var i, ien, j, jen;
7969 var loopRow, loopCells;
7971 data.splice( row, 1 );
7973 // Update the cached indexes
7974 for ( i=0, ien=data.length ; i<ien ; i++ ) {
7975 loopRow = data[i];
7976 loopCells = loopRow.anCells;
7978 // Rows
7979 if ( loopRow.nTr !== null ) {
7980 loopRow.nTr._DT_RowIndex = i;
7981 }
7983 // Cells
7984 if ( loopCells !== null ) {
7985 for ( j=0, jen=loopCells.length ; j<jen ; j++ ) {
7986 loopCells[j]._DT_CellIndex.row = i;
7987 }
7988 }
7989 }
7991 // Delete from the display arrays
7992 _fnDeleteIndex( settings.aiDisplayMaster, row );
7993 _fnDeleteIndex( settings.aiDisplay, row );
7994 _fnDeleteIndex( that[ thatIdx ], row, false ); // maintain local indexes
7996 // Check for an 'overflow' they case for displaying the table
7997 _fnLengthOverflow( settings );
7999 // Remove the row's ID reference if there is one
8000 var id = settings.rowIdFn( rowData._aData );
8001 if ( id !== undefined ) {
8002 delete settings.aIds[ id ];
8003 }
8004 } );
8006 this.iterator( 'table', function ( settings ) {
8007 for ( var i=0, ien=settings.aoData.length ; i<ien ; i++ ) {
8008 settings.aoData[i].idx = i;
8009 }
8010 } );
8012 return this;
8013 } );
8016 _api_register( 'rows.add()', function ( rows ) {
8017 var newRows = this.iterator( 'table', function ( settings ) {
8018 var row, i, ien;
8019 var out = [];
8021 for ( i=0, ien=rows.length ; i<ien ; i++ ) {
8022 row = rows[i];
8024 if ( row.nodeName && row.nodeName.toUpperCase() === 'TR' ) {
8025 out.push( _fnAddTr( settings, row )[0] );
8026 }
8027 else {
8028 out.push( _fnAddData( settings, row ) );
8029 }
8030 }
8032 return out;
8033 }, 1 );
8035 // Return an Api.rows() extended instance, so rows().nodes() etc can be used
8036 var modRows = this.rows( -1 );
8037 modRows.pop();
8038 $.merge( modRows, newRows );
8040 return modRows;
8041 } );
8047 /**
8048 *
8049 */
8050 _api_register( 'row()', function ( selector, opts ) {
8051 return _selector_first( this.rows( selector, opts ) );
8052 } );
8055 _api_register( 'row().data()', function ( data ) {
8056 var ctx = this.context;
8058 if ( data === undefined ) {
8059 // Get
8060 return ctx.length && this.length ?
8061 ctx[0].aoData[ this[0] ]._aData :
8062 undefined;
8063 }
8065 // Set
8066 ctx[0].aoData[ this[0] ]._aData = data;
8068 // Automatically invalidate
8069 _fnInvalidate( ctx[0], this[0], 'data' );
8071 return this;
8072 } );
8075 _api_register( 'row().node()', function () {
8076 var ctx = this.context;
8078 return ctx.length && this.length ?
8079 ctx[0].aoData[ this[0] ].nTr || null :
8080 null;
8081 } );
8084 _api_register( 'row.add()', function ( row ) {
8085 // Allow a jQuery object to be passed in - only a single row is added from
8086 // it though - the first element in the set
8087 if ( row instanceof $ && row.length ) {
8088 row = row[0];
8089 }
8091 var rows = this.iterator( 'table', function ( settings ) {
8092 if ( row.nodeName && row.nodeName.toUpperCase() === 'TR' ) {
8093 return _fnAddTr( settings, row )[0];
8094 }
8095 return _fnAddData( settings, row );
8096 } );
8098 // Return an Api.rows() extended instance, with the newly added row selected
8099 return this.row( rows[0] );
8100 } );
8104 var __details_add = function ( ctx, row, data, klass )
8105 {
8106 // Convert to array of TR elements
8107 var rows = [];
8108 var addRow = function ( r, k ) {
8109 // Recursion to allow for arrays of jQuery objects
8110 if ( $.isArray( r ) || r instanceof $ ) {
8111 for ( var i=0, ien=r.length ; i<ien ; i++ ) {
8112 addRow( r[i], k );
8113 }
8114 return;
8115 }
8117 // If we get a TR element, then just add it directly - up to the dev
8118 // to add the correct number of columns etc
8119 if ( r.nodeName && r.nodeName.toLowerCase() === 'tr' ) {
8120 rows.push( r );
8121 }
8122 else {
8123 // Otherwise create a row with a wrapper
8124 var created = $('<tr><td/></tr>').addClass( k );
8125 $('td', created)
8126 .addClass( k )
8127 .html( r )
8128 [0].colSpan = _fnVisbleColumns( ctx );
8130 rows.push( created[0] );
8131 }
8132 };
8134 addRow( data, klass );
8136 if ( row._details ) {
8137 row._details.remove();
8138 }
8140 row._details = $(rows);
8142 // If the children were already shown, that state should be retained
8143 if ( row._detailsShow ) {
8144 row._details.insertAfter( row.nTr );
8145 }
8146 };
8149 var __details_remove = function ( api, idx )
8150 {
8151 var ctx = api.context;
8153 if ( ctx.length ) {
8154 var row = ctx[0].aoData[ idx !== undefined ? idx : api[0] ];
8156 if ( row && row._details ) {
8157 row._details.remove();
8159 row._detailsShow = undefined;
8160 row._details = undefined;
8161 }
8162 }
8163 };
8166 var __details_display = function ( api, show ) {
8167 var ctx = api.context;
8169 if ( ctx.length && api.length ) {
8170 var row = ctx[0].aoData[ api[0] ];
8172 if ( row._details ) {
8173 row._detailsShow = show;
8175 if ( show ) {
8176 row._details.insertAfter( row.nTr );
8177 }
8178 else {
8179 row._details.detach();
8180 }
8182 __details_events( ctx[0] );
8183 }
8184 }
8185 };
8188 var __details_events = function ( settings )
8189 {
8190 var api = new _Api( settings );
8191 var namespace = '.dt.DT_details';
8192 var drawEvent = 'draw'+namespace;
8193 var colvisEvent = 'column-visibility'+namespace;
8194 var destroyEvent = 'destroy'+namespace;
8195 var data = settings.aoData;
8197 api.off( drawEvent +' '+ colvisEvent +' '+ destroyEvent );
8199 if ( _pluck( data, '_details' ).length > 0 ) {
8200 // On each draw, insert the required elements into the document
8201 api.on( drawEvent, function ( e, ctx ) {
8202 if ( settings !== ctx ) {
8203 return;
8204 }
8206 api.rows( {page:'current'} ).eq(0).each( function (idx) {
8207 // Internal data grab
8208 var row = data[ idx ];
8210 if ( row._detailsShow ) {
8211 row._details.insertAfter( row.nTr );
8212 }
8213 } );
8214 } );
8216 // Column visibility change - update the colspan
8217 api.on( colvisEvent, function ( e, ctx, idx, vis ) {
8218 if ( settings !== ctx ) {
8219 return;
8220 }
8222 // Update the colspan for the details rows (note, only if it already has
8223 // a colspan)
8224 var row, visible = _fnVisbleColumns( ctx );
8226 for ( var i=0, ien=data.length ; i<ien ; i++ ) {
8227 row = data[i];
8229 if ( row._details ) {
8230 row._details.children('td[colspan]').attr('colspan', visible );
8231 }
8232 }
8233 } );
8235 // Table destroyed - nuke any child rows
8236 api.on( destroyEvent, function ( e, ctx ) {
8237 if ( settings !== ctx ) {
8238 return;
8239 }
8241 for ( var i=0, ien=data.length ; i<ien ; i++ ) {
8242 if ( data[i]._details ) {
8243 __details_remove( api, i );
8244 }
8245 }
8246 } );
8247 }
8248 };
8250 // Strings for the method names to help minification
8251 var _emp = '';
8252 var _child_obj = _emp+'row().child';
8253 var _child_mth = _child_obj+'()';
8255 // data can be:
8256 // tr
8257 // string
8258 // jQuery or array of any of the above
8259 _api_register( _child_mth, function ( data, klass ) {
8260 var ctx = this.context;
8262 if ( data === undefined ) {
8263 // get
8264 return ctx.length && this.length ?
8265 ctx[0].aoData[ this[0] ]._details :
8266 undefined;
8267 }
8268 else if ( data === true ) {
8269 // show
8270 this.child.show();
8271 }
8272 else if ( data === false ) {
8273 // remove
8274 __details_remove( this );
8275 }
8276 else if ( ctx.length && this.length ) {
8277 // set
8278 __details_add( ctx[0], ctx[0].aoData[ this[0] ], data, klass );
8279 }
8281 return this;
8282 } );
8285 _api_register( [
8286 _child_obj+'.show()',
8287 _child_mth+'.show()' // only when `child()` was called with parameters (without
8288 ], function ( show ) { // it returns an object and this method is not executed)
8289 __details_display( this, true );
8290 return this;
8291 } );
8294 _api_register( [
8295 _child_obj+'.hide()',
8296 _child_mth+'.hide()' // only when `child()` was called with parameters (without
8297 ], function () { // it returns an object and this method is not executed)
8298 __details_display( this, false );
8299 return this;
8300 } );
8303 _api_register( [
8304 _child_obj+'.remove()',
8305 _child_mth+'.remove()' // only when `child()` was called with parameters (without
8306 ], function () { // it returns an object and this method is not executed)
8307 __details_remove( this );
8308 return this;
8309 } );
8312 _api_register( _child_obj+'.isShown()', function () {
8313 var ctx = this.context;
8315 if ( ctx.length && this.length ) {
8316 // _detailsShown as false or undefined will fall through to return false
8317 return ctx[0].aoData[ this[0] ]._detailsShow || false;
8318 }
8319 return false;
8320 } );
8324 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
8325 * Columns
8326 *
8327 * {integer} - column index (>=0 count from left, <0 count from right)
8328 * "{integer}:visIdx" - visible column index (i.e. translate to column index) (>=0 count from left, <0 count from right)
8329 * "{integer}:visible" - alias for {integer}:visIdx (>=0 count from left, <0 count from right)
8330 * "{string}:name" - column name
8331 * "{string}" - jQuery selector on column header nodes
8332 *
8333 */
8335 // can be an array of these items, comma separated list, or an array of comma
8336 // separated lists
8338 var __re_column_selector = /^(.+):(name|visIdx|visible)$/;
8341 // r1 and r2 are redundant - but it means that the parameters match for the
8342 // iterator callback in columns().data()
8343 var __columnData = function ( settings, column, r1, r2, rows ) {
8344 var a = [];
8345 for ( var row=0, ien=rows.length ; row<ien ; row++ ) {
8346 a.push( _fnGetCellData( settings, rows[row], column ) );
8347 }
8348 return a;
8349 };
8352 var __column_selector = function ( settings, selector, opts )
8353 {
8354 var
8355 columns = settings.aoColumns,
8356 names = _pluck( columns, 'sName' ),
8357 nodes = _pluck( columns, 'nTh' );
8359 var run = function ( s ) {
8360 var selInt = _intVal( s );
8362 // Selector - all
8363 if ( s === '' ) {
8364 return _range( columns.length );
8365 }
8367 // Selector - index
8368 if ( selInt !== null ) {
8369 return [ selInt >= 0 ?
8370 selInt : // Count from left
8371 columns.length + selInt // Count from right (+ because its a negative value)
8372 ];
8373 }
8375 // Selector = function
8376 if ( typeof s === 'function' ) {
8377 var rows = _selector_row_indexes( settings, opts );
8379 return $.map( columns, function (col, idx) {
8380 return s(
8381 idx,
8382 __columnData( settings, idx, 0, 0, rows ),
8383 nodes[ idx ]
8384 ) ? idx : null;
8385 } );
8386 }
8388 // jQuery or string selector
8389 var match = typeof s === 'string' ?
8390 s.match( __re_column_selector ) :
8391 '';
8393 if ( match ) {
8394 switch( match[2] ) {
8395 case 'visIdx':
8396 case 'visible':
8397 var idx = parseInt( match[1], 10 );
8398 // Visible index given, convert to column index
8399 if ( idx < 0 ) {
8400 // Counting from the right
8401 var visColumns = $.map( columns, function (col,i) {
8402 return col.bVisible ? i : null;
8403 } );
8404 return [ visColumns[ visColumns.length + idx ] ];
8405 }
8406 // Counting from the left
8407 return [ _fnVisibleToColumnIndex( settings, idx ) ];
8409 case 'name':
8410 // match by name. `names` is column index complete and in order
8411 return $.map( names, function (name, i) {
8412 return name === match[1] ? i : null;
8413 } );
8415 default:
8416 return [];
8417 }
8418 }
8420 // Cell in the table body
8421 if ( s.nodeName && s._DT_CellIndex ) {
8422 return [ s._DT_CellIndex.column ];
8423 }
8425 // jQuery selector on the TH elements for the columns
8426 var jqResult = $( nodes )
8427 .filter( s )
8428 .map( function () {
8429 return $.inArray( this, nodes ); // `nodes` is column index complete and in order
8430 } )
8431 .toArray();
8433 if ( jqResult.length || ! s.nodeName ) {
8434 return jqResult;
8435 }
8437 // Otherwise a node which might have a `dt-column` data attribute, or be
8438 // a child or such an element
8439 var host = $(s).closest('*[data-dt-column]');
8440 return host.length ?
8441 [ host.data('dt-column') ] :
8442 [];
8443 };
8445 return _selector_run( 'column', selector, run, settings, opts );
8446 };
8449 var __setColumnVis = function ( settings, column, vis ) {
8450 var
8451 cols = settings.aoColumns,
8452 col = cols[ column ],
8453 data = settings.aoData,
8454 row, cells, i, ien, tr;
8456 // Get
8457 if ( vis === undefined ) {
8458 return col.bVisible;
8459 }
8461 // Set
8462 // No change
8463 if ( col.bVisible === vis ) {
8464 return;
8465 }
8467 if ( vis ) {
8468 // Insert column
8469 // Need to decide if we should use appendChild or insertBefore
8470 var insertBefore = $.inArray( true, _pluck(cols, 'bVisible'), column+1 );
8472 for ( i=0, ien=data.length ; i<ien ; i++ ) {
8473 tr = data[i].nTr;
8474 cells = data[i].anCells;
8476 if ( tr ) {
8477 // insertBefore can act like appendChild if 2nd arg is null
8478 tr.insertBefore( cells[ column ], cells[ insertBefore ] || null );
8479 }
8480 }
8481 }
8482 else {
8483 // Remove column
8484 $( _pluck( settings.aoData, 'anCells', column ) ).detach();
8485 }
8487 // Common actions
8488 col.bVisible = vis;
8489 _fnDrawHead( settings, settings.aoHeader );
8490 _fnDrawHead( settings, settings.aoFooter );
8492 _fnSaveState( settings );
8493 };
8496 _api_register( 'columns()', function ( selector, opts ) {
8497 // argument shifting
8498 if ( selector === undefined ) {
8499 selector = '';
8500 }
8501 else if ( $.isPlainObject( selector ) ) {
8502 opts = selector;
8503 selector = '';
8504 }
8506 opts = _selector_opts( opts );
8508 var inst = this.iterator( 'table', function ( settings ) {
8509 return __column_selector( settings, selector, opts );
8510 }, 1 );
8512 // Want argument shifting here and in _row_selector?
8513 inst.selector.cols = selector;
8514 inst.selector.opts = opts;
8516 return inst;
8517 } );
8519 _api_registerPlural( 'columns().header()', 'column().header()', function ( selector, opts ) {
8520 return this.iterator( 'column', function ( settings, column ) {
8521 return settings.aoColumns[column].nTh;
8522 }, 1 );
8523 } );
8525 _api_registerPlural( 'columns().footer()', 'column().footer()', function ( selector, opts ) {
8526 return this.iterator( 'column', function ( settings, column ) {
8527 return settings.aoColumns[column].nTf;
8528 }, 1 );
8529 } );
8531 _api_registerPlural( 'columns().data()', 'column().data()', function () {
8532 return this.iterator( 'column-rows', __columnData, 1 );
8533 } );
8535 _api_registerPlural( 'columns().dataSrc()', 'column().dataSrc()', function () {
8536 return this.iterator( 'column', function ( settings, column ) {
8537 return settings.aoColumns[column].mData;
8538 }, 1 );
8539 } );
8541 _api_registerPlural( 'columns().cache()', 'column().cache()', function ( type ) {
8542 return this.iterator( 'column-rows', function ( settings, column, i, j, rows ) {
8543 return _pluck_order( settings.aoData, rows,
8544 type === 'search' ? '_aFilterData' : '_aSortData', column
8545 );
8546 }, 1 );
8547 } );
8549 _api_registerPlural( 'columns().nodes()', 'column().nodes()', function () {
8550 return this.iterator( 'column-rows', function ( settings, column, i, j, rows ) {
8551 return _pluck_order( settings.aoData, rows, 'anCells', column ) ;
8552 }, 1 );
8553 } );
8555 _api_registerPlural( 'columns().visible()', 'column().visible()', function ( vis, calc ) {
8556 var ret = this.iterator( 'column', function ( settings, column ) {
8557 if ( vis === undefined ) {
8558 return settings.aoColumns[ column ].bVisible;
8559 } // else
8560 __setColumnVis( settings, column, vis );
8561 } );
8563 // Group the column visibility changes
8564 if ( vis !== undefined ) {
8565 // Second loop once the first is done for events
8566 this.iterator( 'column', function ( settings, column ) {
8567 _fnCallbackFire( settings, null, 'column-visibility', [settings, column, vis, calc] );
8568 } );
8570 if ( calc === undefined || calc ) {
8571 this.columns.adjust();
8572 }
8573 }
8575 return ret;
8576 } );
8578 _api_registerPlural( 'columns().indexes()', 'column().index()', function ( type ) {
8579 return this.iterator( 'column', function ( settings, column ) {
8580 return type === 'visible' ?
8581 _fnColumnIndexToVisible( settings, column ) :
8582 column;
8583 }, 1 );
8584 } );
8586 _api_register( 'columns.adjust()', function () {
8587 return this.iterator( 'table', function ( settings ) {
8588 _fnAdjustColumnSizing( settings );
8589 }, 1 );
8590 } );
8592 _api_register( 'column.index()', function ( type, idx ) {
8593 if ( this.context.length !== 0 ) {
8594 var ctx = this.context[0];
8596 if ( type === 'fromVisible' || type === 'toData' ) {
8597 return _fnVisibleToColumnIndex( ctx, idx );
8598 }
8599 else if ( type === 'fromData' || type === 'toVisible' ) {
8600 return _fnColumnIndexToVisible( ctx, idx );
8601 }
8602 }
8603 } );
8605 _api_register( 'column()', function ( selector, opts ) {
8606 return _selector_first( this.columns( selector, opts ) );
8607 } );
8611 var __cell_selector = function ( settings, selector, opts )
8612 {
8613 var data = settings.aoData;
8614 var rows = _selector_row_indexes( settings, opts );
8615 var cells = _removeEmpty( _pluck_order( data, rows, 'anCells' ) );
8616 var allCells = $( [].concat.apply([], cells) );
8617 var row;
8618 var columns = settings.aoColumns.length;
8619 var a, i, ien, j, o, host;
8621 var run = function ( s ) {
8622 var fnSelector = typeof s === 'function';
8624 if ( s === null || s === undefined || fnSelector ) {
8625 // All cells and function selectors
8626 a = [];
8628 for ( i=0, ien=rows.length ; i<ien ; i++ ) {
8629 row = rows[i];
8631 for ( j=0 ; j<columns ; j++ ) {
8632 o = {
8633 row: row,
8634 column: j
8635 };
8637 if ( fnSelector ) {
8638 // Selector - function
8639 host = data[ row ];
8641 if ( s( o, _fnGetCellData(settings, row, j), host.anCells ? host.anCells[j] : null ) ) {
8642 a.push( o );
8643 }
8644 }
8645 else {
8646 // Selector - all
8647 a.push( o );
8648 }
8649 }
8650 }
8652 return a;
8653 }
8655 // Selector - index
8656 if ( $.isPlainObject( s ) ) {
8657 return [s];
8658 }
8660 // Selector - jQuery filtered cells
8661 var jqResult = allCells
8662 .filter( s )
8663 .map( function (i, el) {
8664 return { // use a new object, in case someone changes the values
8665 row: el._DT_CellIndex.row,
8666 column: el._DT_CellIndex.column
8667 };
8668 } )
8669 .toArray();
8671 if ( jqResult.length || ! s.nodeName ) {
8672 return jqResult;
8673 }
8675 // Otherwise the selector is a node, and there is one last option - the
8676 // element might be a child of an element which has dt-row and dt-column
8677 // data attributes
8678 host = $(s).closest('*[data-dt-row]');
8679 return host.length ?
8680 [ {
8681 row: host.data('dt-row'),
8682 column: host.data('dt-column')
8683 } ] :
8684 [];
8685 };
8687 return _selector_run( 'cell', selector, run, settings, opts );
8688 };
8693 _api_register( 'cells()', function ( rowSelector, columnSelector, opts ) {
8694 // Argument shifting
8695 if ( $.isPlainObject( rowSelector ) ) {
8696 // Indexes
8697 if ( rowSelector.row === undefined ) {
8698 // Selector options in first parameter
8699 opts = rowSelector;
8700 rowSelector = null;
8701 }
8702 else {
8703 // Cell index objects in first parameter
8704 opts = columnSelector;
8705 columnSelector = null;
8706 }
8707 }
8708 if ( $.isPlainObject( columnSelector ) ) {
8709 opts = columnSelector;
8710 columnSelector = null;
8711 }
8713 // Cell selector
8714 if ( columnSelector === null || columnSelector === undefined ) {
8715 return this.iterator( 'table', function ( settings ) {
8716 return __cell_selector( settings, rowSelector, _selector_opts( opts ) );
8717 } );
8718 }
8720 // Row + column selector
8721 var columns = this.columns( columnSelector, opts );
8722 var rows = this.rows( rowSelector, opts );
8723 var a, i, ien, j, jen;
8725 var cells = this.iterator( 'table', function ( settings, idx ) {
8726 a = [];
8728 for ( i=0, ien=rows[idx].length ; i<ien ; i++ ) {
8729 for ( j=0, jen=columns[idx].length ; j<jen ; j++ ) {
8730 a.push( {
8731 row: rows[idx][i],
8732 column: columns[idx][j]
8733 } );
8734 }
8735 }
8737 return a;
8738 }, 1 );
8740 $.extend( cells.selector, {
8741 cols: columnSelector,
8742 rows: rowSelector,
8743 opts: opts
8744 } );
8746 return cells;
8747 } );
8750 _api_registerPlural( 'cells().nodes()', 'cell().node()', function () {
8751 return this.iterator( 'cell', function ( settings, row, column ) {
8752 var data = settings.aoData[ row ];
8754 return data && data.anCells ?
8755 data.anCells[ column ] :
8756 undefined;
8757 }, 1 );
8758 } );
8761 _api_register( 'cells().data()', function () {
8762 return this.iterator( 'cell', function ( settings, row, column ) {
8763 return _fnGetCellData( settings, row, column );
8764 }, 1 );
8765 } );
8768 _api_registerPlural( 'cells().cache()', 'cell().cache()', function ( type ) {
8769 type = type === 'search' ? '_aFilterData' : '_aSortData';
8771 return this.iterator( 'cell', function ( settings, row, column ) {
8772 return settings.aoData[ row ][ type ][ column ];
8773 }, 1 );
8774 } );
8777 _api_registerPlural( 'cells().render()', 'cell().render()', function ( type ) {
8778 return this.iterator( 'cell', function ( settings, row, column ) {
8779 return _fnGetCellData( settings, row, column, type );
8780 }, 1 );
8781 } );
8784 _api_registerPlural( 'cells().indexes()', 'cell().index()', function () {
8785 return this.iterator( 'cell', function ( settings, row, column ) {
8786 return {
8787 row: row,
8788 column: column,
8789 columnVisible: _fnColumnIndexToVisible( settings, column )
8790 };
8791 }, 1 );
8792 } );
8795 _api_registerPlural( 'cells().invalidate()', 'cell().invalidate()', function ( src ) {
8796 return this.iterator( 'cell', function ( settings, row, column ) {
8797 _fnInvalidate( settings, row, src, column );
8798 } );
8799 } );
8803 _api_register( 'cell()', function ( rowSelector, columnSelector, opts ) {
8804 return _selector_first( this.cells( rowSelector, columnSelector, opts ) );
8805 } );
8808 _api_register( 'cell().data()', function ( data ) {
8809 var ctx = this.context;
8810 var cell = this[0];
8812 if ( data === undefined ) {
8813 // Get
8814 return ctx.length && cell.length ?
8815 _fnGetCellData( ctx[0], cell[0].row, cell[0].column ) :
8816 undefined;
8817 }
8819 // Set
8820 _fnSetCellData( ctx[0], cell[0].row, cell[0].column, data );
8821 _fnInvalidate( ctx[0], cell[0].row, 'data', cell[0].column );
8823 return this;
8824 } );
8828 /**
8829 * Get current ordering (sorting) that has been applied to the table.
8830 *
8831 * @returns {array} 2D array containing the sorting information for the first
8832 * table in the current context. Each element in the parent array represents
8833 * a column being sorted upon (i.e. multi-sorting with two columns would have
8834 * 2 inner arrays). The inner arrays may have 2 or 3 elements. The first is
8835 * the column index that the sorting condition applies to, the second is the
8836 * direction of the sort (`desc` or `asc`) and, optionally, the third is the
8837 * index of the sorting order from the `column.sorting` initialisation array.
8838 *//**
8839 * Set the ordering for the table.
8840 *
8841 * @param {integer} order Column index to sort upon.
8842 * @param {string} direction Direction of the sort to be applied (`asc` or `desc`)
8843 * @returns {DataTables.Api} this
8844 *//**
8845 * Set the ordering for the table.
8846 *
8847 * @param {array} order 1D array of sorting information to be applied.
8848 * @param {array} [...] Optional additional sorting conditions
8849 * @returns {DataTables.Api} this
8850 *//**
8851 * Set the ordering for the table.
8852 *
8853 * @param {array} order 2D array of sorting information to be applied.
8854 * @returns {DataTables.Api} this
8855 */
8856 _api_register( 'order()', function ( order, dir ) {
8857 var ctx = this.context;
8859 if ( order === undefined ) {
8860 // get
8861 return ctx.length !== 0 ?
8862 ctx[0].aaSorting :
8863 undefined;
8864 }
8866 // set
8867 if ( typeof order === 'number' ) {
8868 // Simple column / direction passed in
8869 order = [ [ order, dir ] ];
8870 }
8871 else if ( order.length && ! $.isArray( order[0] ) ) {
8872 // Arguments passed in (list of 1D arrays)
8873 order = Array.prototype.slice.call( arguments );
8874 }
8875 // otherwise a 2D array was passed in
8877 return this.iterator( 'table', function ( settings ) {
8878 settings.aaSorting = order.slice();
8879 } );
8880 } );
8883 /**
8884 * Attach a sort listener to an element for a given column
8885 *
8886 * @param {node|jQuery|string} node Identifier for the element(s) to attach the
8887 * listener to. This can take the form of a single DOM node, a jQuery
8888 * collection of nodes or a jQuery selector which will identify the node(s).
8889 * @param {integer} column the column that a click on this node will sort on
8890 * @param {function} [callback] callback function when sort is run
8891 * @returns {DataTables.Api} this
8892 */
8893 _api_register( 'order.listener()', function ( node, column, callback ) {
8894 return this.iterator( 'table', function ( settings ) {
8895 _fnSortAttachListener( settings, node, column, callback );
8896 } );
8897 } );
8900 _api_register( 'order.fixed()', function ( set ) {
8901 if ( ! set ) {
8902 var ctx = this.context;
8903 var fixed = ctx.length ?
8904 ctx[0].aaSortingFixed :
8905 undefined;
8907 return $.isArray( fixed ) ?
8908 { pre: fixed } :
8909 fixed;
8910 }
8912 return this.iterator( 'table', function ( settings ) {
8913 settings.aaSortingFixed = $.extend( true, {}, set );
8914 } );
8915 } );
8918 // Order by the selected column(s)
8919 _api_register( [
8920 'columns().order()',
8921 'column().order()'
8922 ], function ( dir ) {
8923 var that = this;
8925 return this.iterator( 'table', function ( settings, i ) {
8926 var sort = [];
8928 $.each( that[i], function (j, col) {
8929 sort.push( [ col, dir ] );
8930 } );
8932 settings.aaSorting = sort;
8933 } );
8934 } );
8938 _api_register( 'search()', function ( input, regex, smart, caseInsen ) {
8939 var ctx = this.context;
8941 if ( input === undefined ) {
8942 // get
8943 return ctx.length !== 0 ?
8944 ctx[0].oPreviousSearch.sSearch :
8945 undefined;
8946 }
8948 // set
8949 return this.iterator( 'table', function ( settings ) {
8950 if ( ! settings.oFeatures.bFilter ) {
8951 return;
8952 }
8954 _fnFilterComplete( settings, $.extend( {}, settings.oPreviousSearch, {
8955 "sSearch": input+"",
8956 "bRegex": regex === null ? false : regex,
8957 "bSmart": smart === null ? true : smart,
8958 "bCaseInsensitive": caseInsen === null ? true : caseInsen
8959 } ), 1 );
8960 } );
8961 } );
8964 _api_registerPlural(
8965 'columns().search()',
8966 'column().search()',
8967 function ( input, regex, smart, caseInsen ) {
8968 return this.iterator( 'column', function ( settings, column ) {
8969 var preSearch = settings.aoPreSearchCols;
8971 if ( input === undefined ) {
8972 // get
8973 return preSearch[ column ].sSearch;
8974 }
8976 // set
8977 if ( ! settings.oFeatures.bFilter ) {
8978 return;
8979 }
8981 $.extend( preSearch[ column ], {
8982 "sSearch": input+"",
8983 "bRegex": regex === null ? false : regex,
8984 "bSmart": smart === null ? true : smart,
8985 "bCaseInsensitive": caseInsen === null ? true : caseInsen
8986 } );
8988 _fnFilterComplete( settings, settings.oPreviousSearch, 1 );
8989 } );
8990 }
8991 );
8993 /*
8994 * State API methods
8995 */
8997 _api_register( 'state()', function () {
8998 return this.context.length ?
8999 this.context[0].oSavedState :
9000 null;
9001 } );
9004 _api_register( 'state.clear()', function () {
9005 return this.iterator( 'table', function ( settings ) {
9006 // Save an empty object
9007 settings.fnStateSaveCallback.call( settings.oInstance, settings, {} );
9008 } );
9009 } );
9012 _api_register( 'state.loaded()', function () {
9013 return this.context.length ?
9014 this.context[0].oLoadedState :
9015 null;
9016 } );
9019 _api_register( 'state.save()', function () {
9020 return this.iterator( 'table', function ( settings ) {
9021 _fnSaveState( settings );
9022 } );
9023 } );
9027 /**
9028 * Provide a common method for plug-ins to check the version of DataTables being
9029 * used, in order to ensure compatibility.
9030 *
9031 * @param {string} version Version string to check for, in the format "X.Y.Z".
9032 * Note that the formats "X" and "X.Y" are also acceptable.
9033 * @returns {boolean} true if this version of DataTables is greater or equal to
9034 * the required version, or false if this version of DataTales is not
9035 * suitable
9036 * @static
9037 * @dtopt API-Static
9038 *
9039 * @example
9040 * alert( $.fn.dataTable.versionCheck( '1.9.0' ) );
9041 */
9042 DataTable.versionCheck = DataTable.fnVersionCheck = function( version )
9043 {
9044 var aThis = DataTable.version.split('.');
9045 var aThat = version.split('.');
9046 var iThis, iThat;
9048 for ( var i=0, iLen=aThat.length ; i<iLen ; i++ ) {
9049 iThis = parseInt( aThis[i], 10 ) || 0;
9050 iThat = parseInt( aThat[i], 10 ) || 0;
9052 // Parts are the same, keep comparing
9053 if (iThis === iThat) {
9054 continue;
9055 }
9057 // Parts are different, return immediately
9058 return iThis > iThat;
9059 }
9061 return true;
9062 };
9065 /**
9066 * Check if a `<table>` node is a DataTable table already or not.
9067 *
9068 * @param {node|jquery|string} table Table node, jQuery object or jQuery
9069 * selector for the table to test. Note that if more than more than one
9070 * table is passed on, only the first will be checked
9071 * @returns {boolean} true the table given is a DataTable, or false otherwise
9072 * @static
9073 * @dtopt API-Static
9074 *
9075 * @example
9076 * if ( ! $.fn.DataTable.isDataTable( '#example' ) ) {
9077 * $('#example').dataTable();
9078 * }
9079 */
9080 DataTable.isDataTable = DataTable.fnIsDataTable = function ( table )
9081 {
9082 var t = $(table).get(0);
9083 var is = false;
9085 $.each( DataTable.settings, function (i, o) {
9086 var head = o.nScrollHead ? $('table', o.nScrollHead)[0] : null;
9087 var foot = o.nScrollFoot ? $('table', o.nScrollFoot)[0] : null;
9089 if ( o.nTable === t || head === t || foot === t ) {
9090 is = true;
9091 }
9092 } );
9094 return is;
9095 };
9098 /**
9099 * Get all DataTable tables that have been initialised - optionally you can
9100 * select to get only currently visible tables.
9101 *
9102 * @param {boolean} [visible=false] Flag to indicate if you want all (default)
9103 * or visible tables only.
9104 * @returns {array} Array of `table` nodes (not DataTable instances) which are
9105 * DataTables
9106 * @static
9107 * @dtopt API-Static
9108 *
9109 * @example
9110 * $.each( $.fn.dataTable.tables(true), function () {
9111 * $(table).DataTable().columns.adjust();
9112 * } );
9113 */
9114 DataTable.tables = DataTable.fnTables = function ( visible )
9115 {
9116 var api = false;
9118 if ( $.isPlainObject( visible ) ) {
9119 api = visible.api;
9120 visible = visible.visible;
9121 }
9123 var a = $.map( DataTable.settings, function (o) {
9124 if ( !visible || (visible && $(o.nTable).is(':visible')) ) {
9125 return o.nTable;
9126 }
9127 } );
9129 return api ?
9130 new _Api( a ) :
9131 a;
9132 };
9135 /**
9136 * Convert from camel case parameters to Hungarian notation. This is made public
9137 * for the extensions to provide the same ability as DataTables core to accept
9138 * either the 1.9 style Hungarian notation, or the 1.10+ style camelCase
9139 * parameters.
9140 *
9141 * @param {object} src The model object which holds all parameters that can be
9142 * mapped.
9143 * @param {object} user The object to convert from camel case to Hungarian.
9144 * @param {boolean} force When set to `true`, properties which already have a
9145 * Hungarian value in the `user` object will be overwritten. Otherwise they
9146 * won't be.
9147 */
9148 DataTable.camelToHungarian = _fnCamelToHungarian;
9152 /**
9153 *
9154 */
9155 _api_register( '$()', function ( selector, opts ) {
9156 var
9157 rows = this.rows( opts ).nodes(), // Get all rows
9158 jqRows = $(rows);
9160 return $( [].concat(
9161 jqRows.filter( selector ).toArray(),
9162 jqRows.find( selector ).toArray()
9163 ) );
9164 } );
9167 // jQuery functions to operate on the tables
9168 $.each( [ 'on', 'one', 'off' ], function (i, key) {
9169 _api_register( key+'()', function ( /* event, handler */ ) {
9170 var args = Array.prototype.slice.call(arguments);
9172 // Add the `dt` namespace automatically if it isn't already present
9173 if ( ! args[0].match(/\.dt\b/) ) {
9174 args[0] += '.dt';
9175 }
9177 var inst = $( this.tables().nodes() );
9178 inst[key].apply( inst, args );
9179 return this;
9180 } );
9181 } );
9184 _api_register( 'clear()', function () {
9185 return this.iterator( 'table', function ( settings ) {
9186 _fnClearTable( settings );
9187 } );
9188 } );
9191 _api_register( 'settings()', function () {
9192 return new _Api( this.context, this.context );
9193 } );
9196 _api_register( 'init()', function () {
9197 var ctx = this.context;
9198 return ctx.length ? ctx[0].oInit : null;
9199 } );
9202 _api_register( 'data()', function () {
9203 return this.iterator( 'table', function ( settings ) {
9204 return _pluck( settings.aoData, '_aData' );
9205 } ).flatten();
9206 } );
9209 _api_register( 'destroy()', function ( remove ) {
9210 remove = remove || false;
9212 return this.iterator( 'table', function ( settings ) {
9213 var orig = settings.nTableWrapper.parentNode;
9214 var classes = settings.oClasses;
9215 var table = settings.nTable;
9216 var tbody = settings.nTBody;
9217 var thead = settings.nTHead;
9218 var tfoot = settings.nTFoot;
9219 var jqTable = $(table);
9220 var jqTbody = $(tbody);
9221 var jqWrapper = $(settings.nTableWrapper);
9222 var rows = $.map( settings.aoData, function (r) { return r.nTr; } );
9223 var i, ien;
9225 // Flag to note that the table is currently being destroyed - no action
9226 // should be taken
9227 settings.bDestroying = true;
9229 // Fire off the destroy callbacks for plug-ins etc
9230 _fnCallbackFire( settings, "aoDestroyCallback", "destroy", [settings] );
9232 // If not being removed from the document, make all columns visible
9233 if ( ! remove ) {
9234 new _Api( settings ).columns().visible( true );
9235 }
9237 // Blitz all `DT` namespaced events (these are internal events, the
9238 // lowercase, `dt` events are user subscribed and they are responsible
9239 // for removing them
9240 jqWrapper.unbind('.DT').find(':not(tbody *)').unbind('.DT');
9241 $(window).unbind('.DT-'+settings.sInstance);
9243 // When scrolling we had to break the table up - restore it
9244 if ( table != thead.parentNode ) {
9245 jqTable.children('thead').detach();
9246 jqTable.append( thead );
9247 }
9249 if ( tfoot && table != tfoot.parentNode ) {
9250 jqTable.children('tfoot').detach();
9251 jqTable.append( tfoot );
9252 }
9254 settings.aaSorting = [];
9255 settings.aaSortingFixed = [];
9256 _fnSortingClasses( settings );
9258 $( rows ).removeClass( settings.asStripeClasses.join(' ') );
9260 $('th, td', thead).removeClass( classes.sSortable+' '+
9261 classes.sSortableAsc+' '+classes.sSortableDesc+' '+classes.sSortableNone
9262 );
9264 if ( settings.bJUI ) {
9265 $('th span.'+classes.sSortIcon+ ', td span.'+classes.sSortIcon, thead).detach();
9266 $('th, td', thead).each( function () {
9267 var wrapper = $('div.'+classes.sSortJUIWrapper, this);
9268 $(this).append( wrapper.contents() );
9269 wrapper.detach();
9270 } );
9271 }
9273 // Add the TR elements back into the table in their original order
9274 jqTbody.children().detach();
9275 jqTbody.append( rows );
9277 // Remove the DataTables generated nodes, events and classes
9278 var removedMethod = remove ? 'remove' : 'detach';
9279 jqTable[ removedMethod ]();
9280 jqWrapper[ removedMethod ]();
9282 // If we need to reattach the table to the document
9283 if ( ! remove && orig ) {
9284 // insertBefore acts like appendChild if !arg[1]
9285 orig.insertBefore( table, settings.nTableReinsertBefore );
9287 // Restore the width of the original table - was read from the style property,
9288 // so we can restore directly to that
9289 jqTable
9290 .css( 'width', settings.sDestroyWidth )
9291 .removeClass( classes.sTable );
9293 // If the were originally stripe classes - then we add them back here.
9294 // Note this is not fool proof (for example if not all rows had stripe
9295 // classes - but it's a good effort without getting carried away
9296 ien = settings.asDestroyStripes.length;
9298 if ( ien ) {
9299 jqTbody.children().each( function (i) {
9300 $(this).addClass( settings.asDestroyStripes[i % ien] );
9301 } );
9302 }
9303 }
9305 /* Remove the settings object from the settings array */
9306 var idx = $.inArray( settings, DataTable.settings );
9307 if ( idx !== -1 ) {
9308 DataTable.settings.splice( idx, 1 );
9309 }
9310 } );
9311 } );
9314 // Add the `every()` method for rows, columns and cells in a compact form
9315 $.each( [ 'column', 'row', 'cell' ], function ( i, type ) {
9316 _api_register( type+'s().every()', function ( fn ) {
9317 var opts = this.selector.opts;
9318 var api = this;
9320 return this.iterator( type, function ( settings, arg1, arg2, arg3, arg4 ) {
9321 // Rows and columns:
9322 // arg1 - index
9323 // arg2 - table counter
9324 // arg3 - loop counter
9325 // arg4 - undefined
9326 // Cells:
9327 // arg1 - row index
9328 // arg2 - column index
9329 // arg3 - table counter
9330 // arg4 - loop counter
9331 fn.call(
9332 api[ type ](
9333 arg1,
9334 type==='cell' ? arg2 : opts,
9335 type==='cell' ? opts : undefined
9336 ),
9337 arg1, arg2, arg3, arg4
9338 );
9339 } );
9340 } );
9341 } );
9344 // i18n method for extensions to be able to use the language object from the
9345 // DataTable
9346 _api_register( 'i18n()', function ( token, def, plural ) {
9347 var ctx = this.context[0];
9348 var resolved = _fnGetObjectDataFn( token )( ctx.oLanguage );
9350 if ( resolved === undefined ) {
9351 resolved = def;
9352 }
9354 if ( plural !== undefined && $.isPlainObject( resolved ) ) {
9355 resolved = resolved[ plural ] !== undefined ?
9356 resolved[ plural ] :
9357 resolved._;
9358 }
9360 return resolved.replace( '%d', plural ); // nb: plural might be undefined,
9361 } );
9363 /**
9364 * Version string for plug-ins to check compatibility. Allowed format is
9365 * `a.b.c-d` where: a:int, b:int, c:int, d:string(dev|beta|alpha). `d` is used
9366 * only for non-release builds. See http://semver.org/ for more information.
9367 * @member
9368 * @type string
9369 * @default Version number
9370 */
9371 DataTable.version = "1.10.12";
9373 /**
9374 * Private data store, containing all of the settings objects that are
9375 * created for the tables on a given page.
9376 *
9377 * Note that the `DataTable.settings` object is aliased to
9378 * `jQuery.fn.dataTableExt` through which it may be accessed and
9379 * manipulated, or `jQuery.fn.dataTable.settings`.
9380 * @member
9381 * @type array
9382 * @default []
9383 * @private
9384 */
9385 DataTable.settings = [];
9387 /**
9388 * Object models container, for the various models that DataTables has
9389 * available to it. These models define the objects that are used to hold
9390 * the active state and configuration of the table.
9391 * @namespace
9392 */
9393 DataTable.models = {};
9397 /**
9398 * Template object for the way in which DataTables holds information about
9399 * search information for the global filter and individual column filters.
9400 * @namespace
9401 */
9402 DataTable.models.oSearch = {
9403 /**
9404 * Flag to indicate if the filtering should be case insensitive or not
9405 * @type boolean
9406 * @default true
9407 */
9408 "bCaseInsensitive": true,
9410 /**
9411 * Applied search term
9412 * @type string
9413 * @default <i>Empty string</i>
9414 */
9415 "sSearch": "",
9417 /**
9418 * Flag to indicate if the search term should be interpreted as a
9419 * regular expression (true) or not (false) and therefore and special
9420 * regex characters escaped.
9421 * @type boolean
9422 * @default false
9423 */
9424 "bRegex": false,
9426 /**
9427 * Flag to indicate if DataTables is to use its smart filtering or not.
9428 * @type boolean
9429 * @default true
9430 */
9431 "bSmart": true
9432 };
9437 /**
9438 * Template object for the way in which DataTables holds information about
9439 * each individual row. This is the object format used for the settings
9440 * aoData array.
9441 * @namespace
9442 */
9443 DataTable.models.oRow = {
9444 /**
9445 * TR element for the row
9446 * @type node
9447 * @default null
9448 */
9449 "nTr": null,
9451 /**
9452 * Array of TD elements for each row. This is null until the row has been
9453 * created.
9454 * @type array nodes
9455 * @default []
9456 */
9457 "anCells": null,
9459 /**
9460 * Data object from the original data source for the row. This is either
9461 * an array if using the traditional form of DataTables, or an object if
9462 * using mData options. The exact type will depend on the passed in
9463 * data from the data source, or will be an array if using DOM a data
9464 * source.
9465 * @type array|object
9466 * @default []
9467 */
9468 "_aData": [],
9470 /**
9471 * Sorting data cache - this array is ostensibly the same length as the
9472 * number of columns (although each index is generated only as it is
9473 * needed), and holds the data that is used for sorting each column in the
9474 * row. We do this cache generation at the start of the sort in order that
9475 * the formatting of the sort data need be done only once for each cell
9476 * per sort. This array should not be read from or written to by anything
9477 * other than the master sorting methods.
9478 * @type array
9479 * @default null
9480 * @private
9481 */
9482 "_aSortData": null,
9484 /**
9485 * Per cell filtering data cache. As per the sort data cache, used to
9486 * increase the performance of the filtering in DataTables
9487 * @type array
9488 * @default null
9489 * @private
9490 */
9491 "_aFilterData": null,
9493 /**
9494 * Filtering data cache. This is the same as the cell filtering cache, but
9495 * in this case a string rather than an array. This is easily computed with
9496 * a join on `_aFilterData`, but is provided as a cache so the join isn't
9497 * needed on every search (memory traded for performance)
9498 * @type array
9499 * @default null
9500 * @private
9501 */
9502 "_sFilterRow": null,
9504 /**
9505 * Cache of the class name that DataTables has applied to the row, so we
9506 * can quickly look at this variable rather than needing to do a DOM check
9507 * on className for the nTr property.
9508 * @type string
9509 * @default <i>Empty string</i>
9510 * @private
9511 */
9512 "_sRowStripe": "",
9514 /**
9515 * Denote if the original data source was from the DOM, or the data source
9516 * object. This is used for invalidating data, so DataTables can
9517 * automatically read data from the original source, unless uninstructed
9518 * otherwise.
9519 * @type string
9520 * @default null
9521 * @private
9522 */
9523 "src": null,
9525 /**
9526 * Index in the aoData array. This saves an indexOf lookup when we have the
9527 * object, but want to know the index
9528 * @type integer
9529 * @default -1
9530 * @private
9531 */
9532 "idx": -1
9533 };
9536 /**
9537 * Template object for the column information object in DataTables. This object
9538 * is held in the settings aoColumns array and contains all the information that
9539 * DataTables needs about each individual column.
9540 *
9541 * Note that this object is related to {@link DataTable.defaults.column}
9542 * but this one is the internal data store for DataTables's cache of columns.
9543 * It should NOT be manipulated outside of DataTables. Any configuration should
9544 * be done through the initialisation options.
9545 * @namespace
9546 */
9547 DataTable.models.oColumn = {
9548 /**
9549 * Column index. This could be worked out on-the-fly with $.inArray, but it
9550 * is faster to just hold it as a variable
9551 * @type integer
9552 * @default null
9553 */
9554 "idx": null,
9556 /**
9557 * A list of the columns that sorting should occur on when this column
9558 * is sorted. That this property is an array allows multi-column sorting
9559 * to be defined for a column (for example first name / last name columns
9560 * would benefit from this). The values are integers pointing to the
9561 * columns to be sorted on (typically it will be a single integer pointing
9562 * at itself, but that doesn't need to be the case).
9563 * @type array
9564 */
9565 "aDataSort": null,
9567 /**
9568 * Define the sorting directions that are applied to the column, in sequence
9569 * as the column is repeatedly sorted upon - i.e. the first value is used
9570 * as the sorting direction when the column if first sorted (clicked on).
9571 * Sort it again (click again) and it will move on to the next index.
9572 * Repeat until loop.
9573 * @type array
9574 */
9575 "asSorting": null,
9577 /**
9578 * Flag to indicate if the column is searchable, and thus should be included
9579 * in the filtering or not.
9580 * @type boolean
9581 */
9582 "bSearchable": null,
9584 /**
9585 * Flag to indicate if the column is sortable or not.
9586 * @type boolean
9587 */
9588 "bSortable": null,
9590 /**
9591 * Flag to indicate if the column is currently visible in the table or not
9592 * @type boolean
9593 */
9594 "bVisible": null,
9596 /**
9597 * Store for manual type assignment using the `column.type` option. This
9598 * is held in store so we can manipulate the column's `sType` property.
9599 * @type string
9600 * @default null
9601 * @private
9602 */
9603 "_sManualType": null,
9605 /**
9606 * Flag to indicate if HTML5 data attributes should be used as the data
9607 * source for filtering or sorting. True is either are.
9608 * @type boolean
9609 * @default false
9610 * @private
9611 */
9612 "_bAttrSrc": false,
9614 /**
9615 * Developer definable function that is called whenever a cell is created (Ajax source,
9616 * etc) or processed for input (DOM source). This can be used as a compliment to mRender
9617 * allowing you to modify the DOM element (add background colour for example) when the
9618 * element is available.
9619 * @type function
9620 * @param {element} nTd The TD node that has been created
9621 * @param {*} sData The Data for the cell
9622 * @param {array|object} oData The data for the whole row
9623 * @param {int} iRow The row index for the aoData data store
9624 * @default null
9625 */
9626 "fnCreatedCell": null,
9628 /**
9629 * Function to get data from a cell in a column. You should <b>never</b>
9630 * access data directly through _aData internally in DataTables - always use
9631 * the method attached to this property. It allows mData to function as
9632 * required. This function is automatically assigned by the column
9633 * initialisation method
9634 * @type function
9635 * @param {array|object} oData The data array/object for the array
9636 * (i.e. aoData[]._aData)
9637 * @param {string} sSpecific The specific data type you want to get -
9638 * 'display', 'type' 'filter' 'sort'
9639 * @returns {*} The data for the cell from the given row's data
9640 * @default null
9641 */
9642 "fnGetData": null,
9644 /**
9645 * Function to set data for a cell in the column. You should <b>never</b>
9646 * set the data directly to _aData internally in DataTables - always use
9647 * this method. It allows mData to function as required. This function
9648 * is automatically assigned by the column initialisation method
9649 * @type function
9650 * @param {array|object} oData The data array/object for the array
9651 * (i.e. aoData[]._aData)
9652 * @param {*} sValue Value to set
9653 * @default null
9654 */
9655 "fnSetData": null,
9657 /**
9658 * Property to read the value for the cells in the column from the data
9659 * source array / object. If null, then the default content is used, if a
9660 * function is given then the return from the function is used.
9661 * @type function|int|string|null
9662 * @default null
9663 */
9664 "mData": null,
9666 /**
9667 * Partner property to mData which is used (only when defined) to get
9668 * the data - i.e. it is basically the same as mData, but without the
9669 * 'set' option, and also the data fed to it is the result from mData.
9670 * This is the rendering method to match the data method of mData.
9671 * @type function|int|string|null
9672 * @default null
9673 */
9674 "mRender": null,
9676 /**
9677 * Unique header TH/TD element for this column - this is what the sorting
9678 * listener is attached to (if sorting is enabled.)
9679 * @type node
9680 * @default null
9681 */
9682 "nTh": null,
9684 /**
9685 * Unique footer TH/TD element for this column (if there is one). Not used
9686 * in DataTables as such, but can be used for plug-ins to reference the
9687 * footer for each column.
9688 * @type node
9689 * @default null
9690 */
9691 "nTf": null,
9693 /**
9694 * The class to apply to all TD elements in the table's TBODY for the column
9695 * @type string
9696 * @default null
9697 */
9698 "sClass": null,
9700 /**
9701 * When DataTables calculates the column widths to assign to each column,
9702 * it finds the longest string in each column and then constructs a
9703 * temporary table and reads the widths from that. The problem with this
9704 * is that "mmm" is much wider then "iiii", but the latter is a longer
9705 * string - thus the calculation can go wrong (doing it properly and putting
9706 * it into an DOM object and measuring that is horribly(!) slow). Thus as
9707 * a "work around" we provide this option. It will append its value to the
9708 * text that is found to be the longest string for the column - i.e. padding.
9709 * @type string
9710 */
9711 "sContentPadding": null,
9713 /**
9714 * Allows a default value to be given for a column's data, and will be used
9715 * whenever a null data source is encountered (this can be because mData
9716 * is set to null, or because the data source itself is null).
9717 * @type string
9718 * @default null
9719 */
9720 "sDefaultContent": null,
9722 /**
9723 * Name for the column, allowing reference to the column by name as well as
9724 * by index (needs a lookup to work by name).
9725 * @type string
9726 */
9727 "sName": null,
9729 /**
9730 * Custom sorting data type - defines which of the available plug-ins in
9731 * afnSortData the custom sorting will use - if any is defined.
9732 * @type string
9733 * @default std
9734 */
9735 "sSortDataType": 'std',
9737 /**
9738 * Class to be applied to the header element when sorting on this column
9739 * @type string
9740 * @default null
9741 */
9742 "sSortingClass": null,
9744 /**
9745 * Class to be applied to the header element when sorting on this column -
9746 * when jQuery UI theming is used.
9747 * @type string
9748 * @default null
9749 */
9750 "sSortingClassJUI": null,
9752 /**
9753 * Title of the column - what is seen in the TH element (nTh).
9754 * @type string
9755 */
9756 "sTitle": null,
9758 /**
9759 * Column sorting and filtering type
9760 * @type string
9761 * @default null
9762 */
9763 "sType": null,
9765 /**
9766 * Width of the column
9767 * @type string
9768 * @default null
9769 */
9770 "sWidth": null,
9772 /**
9773 * Width of the column when it was first "encountered"
9774 * @type string
9775 * @default null
9776 */
9777 "sWidthOrig": null
9778 };
9781 /*
9782 * Developer note: The properties of the object below are given in Hungarian
9783 * notation, that was used as the interface for DataTables prior to v1.10, however
9784 * from v1.10 onwards the primary interface is camel case. In order to avoid
9785 * breaking backwards compatibility utterly with this change, the Hungarian
9786 * version is still, internally the primary interface, but is is not documented
9787 * - hence the @name tags in each doc comment. This allows a Javascript function
9788 * to create a map from Hungarian notation to camel case (going the other direction
9789 * would require each property to be listed, which would at around 3K to the size
9790 * of DataTables, while this method is about a 0.5K hit.
9791 *
9792 * Ultimately this does pave the way for Hungarian notation to be dropped
9793 * completely, but that is a massive amount of work and will break current
9794 * installs (therefore is on-hold until v2).
9795 */
9797 /**
9798 * Initialisation options that can be given to DataTables at initialisation
9799 * time.
9800 * @namespace
9801 */
9802 DataTable.defaults = {
9803 /**
9804 * An array of data to use for the table, passed in at initialisation which
9805 * will be used in preference to any data which is already in the DOM. This is
9806 * particularly useful for constructing tables purely in Javascript, for
9807 * example with a custom Ajax call.
9808 * @type array
9809 * @default null
9810 *
9811 * @dtopt Option
9812 * @name DataTable.defaults.data
9813 *
9814 * @example
9815 * // Using a 2D array data source
9816 * $(document).ready( function () {
9817 * $('#example').dataTable( {
9818 * "data": [
9819 * ['Trident', 'Internet Explorer 4.0', 'Win 95+', 4, 'X'],
9820 * ['Trident', 'Internet Explorer 5.0', 'Win 95+', 5, 'C'],
9821 * ],
9822 * "columns": [
9823 * { "title": "Engine" },
9824 * { "title": "Browser" },
9825 * { "title": "Platform" },
9826 * { "title": "Version" },
9827 * { "title": "Grade" }
9828 * ]
9829 * } );
9830 * } );
9831 *
9832 * @example
9833 * // Using an array of objects as a data source (`data`)
9834 * $(document).ready( function () {
9835 * $('#example').dataTable( {
9836 * "data": [
9837 * {
9838 * "engine": "Trident",
9839 * "browser": "Internet Explorer 4.0",
9840 * "platform": "Win 95+",
9841 * "version": 4,
9842 * "grade": "X"
9843 * },
9844 * {
9845 * "engine": "Trident",
9846 * "browser": "Internet Explorer 5.0",
9847 * "platform": "Win 95+",
9848 * "version": 5,
9849 * "grade": "C"
9850 * }
9851 * ],
9852 * "columns": [
9853 * { "title": "Engine", "data": "engine" },
9854 * { "title": "Browser", "data": "browser" },
9855 * { "title": "Platform", "data": "platform" },
9856 * { "title": "Version", "data": "version" },
9857 * { "title": "Grade", "data": "grade" }
9858 * ]
9859 * } );
9860 * } );
9861 */
9862 "aaData": null,
9865 /**
9866 * If ordering is enabled, then DataTables will perform a first pass sort on
9867 * initialisation. You can define which column(s) the sort is performed
9868 * upon, and the sorting direction, with this variable. The `sorting` array
9869 * should contain an array for each column to be sorted initially containing
9870 * the column's index and a direction string ('asc' or 'desc').
9871 * @type array
9872 * @default [[0,'asc']]
9873 *
9874 * @dtopt Option
9875 * @name DataTable.defaults.order
9876 *
9877 * @example
9878 * // Sort by 3rd column first, and then 4th column
9879 * $(document).ready( function() {
9880 * $('#example').dataTable( {
9881 * "order": [[2,'asc'], [3,'desc']]
9882 * } );
9883 * } );
9884 *
9885 * // No initial sorting
9886 * $(document).ready( function() {
9887 * $('#example').dataTable( {
9888 * "order": []
9889 * } );
9890 * } );
9891 */
9892 "aaSorting": [[0,'asc']],
9895 /**
9896 * This parameter is basically identical to the `sorting` parameter, but
9897 * cannot be overridden by user interaction with the table. What this means
9898 * is that you could have a column (visible or hidden) which the sorting
9899 * will always be forced on first - any sorting after that (from the user)
9900 * will then be performed as required. This can be useful for grouping rows
9901 * together.
9902 * @type array
9903 * @default null
9904 *
9905 * @dtopt Option
9906 * @name DataTable.defaults.orderFixed
9907 *
9908 * @example
9909 * $(document).ready( function() {
9910 * $('#example').dataTable( {
9911 * "orderFixed": [[0,'asc']]
9912 * } );
9913 * } )
9914 */
9915 "aaSortingFixed": [],
9918 /**
9919 * DataTables can be instructed to load data to display in the table from a
9920 * Ajax source. This option defines how that Ajax call is made and where to.
9921 *
9922 * The `ajax` property has three different modes of operation, depending on
9923 * how it is defined. These are:
9924 *
9925 * * `string` - Set the URL from where the data should be loaded from.
9926 * * `object` - Define properties for `jQuery.ajax`.
9927 * * `function` - Custom data get function
9928 *
9929 * `string`
9930 * --------
9931 *
9932 * As a string, the `ajax` property simply defines the URL from which
9933 * DataTables will load data.
9934 *
9935 * `object`
9936 * --------
9937 *
9938 * As an object, the parameters in the object are passed to
9939 * [jQuery.ajax](http://api.jquery.com/jQuery.ajax/) allowing fine control
9940 * of the Ajax request. DataTables has a number of default parameters which
9941 * you can override using this option. Please refer to the jQuery
9942 * documentation for a full description of the options available, although
9943 * the following parameters provide additional options in DataTables or
9944 * require special consideration:
9945 *
9946 * * `data` - As with jQuery, `data` can be provided as an object, but it
9947 * can also be used as a function to manipulate the data DataTables sends
9948 * to the server. The function takes a single parameter, an object of
9949 * parameters with the values that DataTables has readied for sending. An
9950 * object may be returned which will be merged into the DataTables
9951 * defaults, or you can add the items to the object that was passed in and
9952 * not return anything from the function. This supersedes `fnServerParams`
9953 * from DataTables 1.9-.
9954 *
9955 * * `dataSrc` - By default DataTables will look for the property `data` (or
9956 * `aaData` for compatibility with DataTables 1.9-) when obtaining data
9957 * from an Ajax source or for server-side processing - this parameter
9958 * allows that property to be changed. You can use Javascript dotted
9959 * object notation to get a data source for multiple levels of nesting, or
9960 * it my be used as a function. As a function it takes a single parameter,
9961 * the JSON returned from the server, which can be manipulated as
9962 * required, with the returned value being that used by DataTables as the
9963 * data source for the table. This supersedes `sAjaxDataProp` from
9964 * DataTables 1.9-.
9965 *
9966 * * `success` - Should not be overridden it is used internally in
9967 * DataTables. To manipulate / transform the data returned by the server
9968 * use `ajax.dataSrc`, or use `ajax` as a function (see below).
9969 *
9970 * `function`
9971 * ----------
9972 *
9973 * As a function, making the Ajax call is left up to yourself allowing
9974 * complete control of the Ajax request. Indeed, if desired, a method other
9975 * than Ajax could be used to obtain the required data, such as Web storage
9976 * or an AIR database.
9977 *
9978 * The function is given four parameters and no return is required. The
9979 * parameters are:
9980 *
9981 * 1. _object_ - Data to send to the server
9982 * 2. _function_ - Callback function that must be executed when the required
9983 * data has been obtained. That data should be passed into the callback
9984 * as the only parameter
9985 * 3. _object_ - DataTables settings object for the table
9986 *
9987 * Note that this supersedes `fnServerData` from DataTables 1.9-.
9988 *
9989 * @type string|object|function
9990 * @default null
9991 *
9992 * @dtopt Option
9993 * @name DataTable.defaults.ajax
9994 * @since 1.10.0
9995 *
9996 * @example
9997 * // Get JSON data from a file via Ajax.
9998 * // Note DataTables expects data in the form `{ data: [ ...data... ] }` by default).
9999 * $('#example').dataTable( {
10000 * "ajax": "data.json"
10001 * } );
10002 *
10003 * @example
10004 * // Get JSON data from a file via Ajax, using `dataSrc` to change
10005 * // `data` to `tableData` (i.e. `{ tableData: [ ...data... ] }`)
10006 * $('#example').dataTable( {
10007 * "ajax": {
10008 * "url": "data.json",
10009 * "dataSrc": "tableData"
10010 * }
10011 * } );
10012 *
10013 * @example
10014 * // Get JSON data from a file via Ajax, using `dataSrc` to read data
10015 * // from a plain array rather than an array in an object
10016 * $('#example').dataTable( {
10017 * "ajax": {
10018 * "url": "data.json",
10019 * "dataSrc": ""
10020 * }
10021 * } );
10022 *
10023 * @example
10024 * // Manipulate the data returned from the server - add a link to data
10025 * // (note this can, should, be done using `render` for the column - this
10026 * // is just a simple example of how the data can be manipulated).
10027 * $('#example').dataTable( {
10028 * "ajax": {
10029 * "url": "data.json",
10030 * "dataSrc": function ( json ) {
10031 * for ( var i=0, ien=json.length ; i<ien ; i++ ) {
10032 * json[i][0] = '<a href="/message/'+json[i][0]+'>View message</a>';
10033 * }
10034 * return json;
10035 * }
10036 * }
10037 * } );
10038 *
10039 * @example
10040 * // Add data to the request
10041 * $('#example').dataTable( {
10042 * "ajax": {
10043 * "url": "data.json",
10044 * "data": function ( d ) {
10045 * return {
10046 * "extra_search": $('#extra').val()
10047 * };
10048 * }
10049 * }
10050 * } );
10051 *
10052 * @example
10053 * // Send request as POST
10054 * $('#example').dataTable( {
10055 * "ajax": {
10056 * "url": "data.json",
10057 * "type": "POST"
10058 * }
10059 * } );
10060 *
10061 * @example
10062 * // Get the data from localStorage (could interface with a form for
10063 * // adding, editing and removing rows).
10064 * $('#example').dataTable( {
10065 * "ajax": function (data, callback, settings) {
10066 * callback(
10067 * JSON.parse( localStorage.getItem('dataTablesData') )
10068 * );
10069 * }
10070 * } );
10071 */
10072 "ajax": null,
10075 /**
10076 * This parameter allows you to readily specify the entries in the length drop
10077 * down menu that DataTables shows when pagination is enabled. It can be
10078 * either a 1D array of options which will be used for both the displayed
10079 * option and the value, or a 2D array which will use the array in the first
10080 * position as the value, and the array in the second position as the
10081 * displayed options (useful for language strings such as 'All').
10082 *
10083 * Note that the `pageLength` property will be automatically set to the
10084 * first value given in this array, unless `pageLength` is also provided.
10085 * @type array
10086 * @default [ 10, 25, 50, 100 ]
10087 *
10088 * @dtopt Option
10089 * @name DataTable.defaults.lengthMenu
10090 *
10091 * @example
10092 * $(document).ready( function() {
10093 * $('#example').dataTable( {
10094 * "lengthMenu": [[10, 25, 50, -1], [10, 25, 50, "All"]]
10095 * } );
10096 * } );
10097 */
10098 "aLengthMenu": [ 10, 25, 50, 100 ],
10101 /**
10102 * The `columns` option in the initialisation parameter allows you to define
10103 * details about the way individual columns behave. For a full list of
10104 * column options that can be set, please see
10105 * {@link DataTable.defaults.column}. Note that if you use `columns` to
10106 * define your columns, you must have an entry in the array for every single
10107 * column that you have in your table (these can be null if you don't which
10108 * to specify any options).
10109 * @member
10110 *
10111 * @name DataTable.defaults.column
10112 */
10113 "aoColumns": null,
10115 /**
10116 * Very similar to `columns`, `columnDefs` allows you to target a specific
10117 * column, multiple columns, or all columns, using the `targets` property of
10118 * each object in the array. This allows great flexibility when creating
10119 * tables, as the `columnDefs` arrays can be of any length, targeting the
10120 * columns you specifically want. `columnDefs` may use any of the column
10121 * options available: {@link DataTable.defaults.column}, but it _must_
10122 * have `targets` defined in each object in the array. Values in the `targets`
10123 * array may be:
10124 * <ul>
10125 * <li>a string - class name will be matched on the TH for the column</li>
10126 * <li>0 or a positive integer - column index counting from the left</li>
10127 * <li>a negative integer - column index counting from the right</li>
10128 * <li>the string "_all" - all columns (i.e. assign a default)</li>
10129 * </ul>
10130 * @member
10131 *
10132 * @name DataTable.defaults.columnDefs
10133 */
10134 "aoColumnDefs": null,
10137 /**
10138 * Basically the same as `search`, this parameter defines the individual column
10139 * filtering state at initialisation time. The array must be of the same size
10140 * as the number of columns, and each element be an object with the parameters
10141 * `search` and `escapeRegex` (the latter is optional). 'null' is also
10142 * accepted and the default will be used.
10143 * @type array
10144 * @default []
10145 *
10146 * @dtopt Option
10147 * @name DataTable.defaults.searchCols
10148 *
10149 * @example
10150 * $(document).ready( function() {
10151 * $('#example').dataTable( {
10152 * "searchCols": [
10153 * null,
10154 * { "search": "My filter" },
10155 * null,
10156 * { "search": "^[0-9]", "escapeRegex": false }
10157 * ]
10158 * } );
10159 * } )
10160 */
10161 "aoSearchCols": [],
10164 /**
10165 * An array of CSS classes that should be applied to displayed rows. This
10166 * array may be of any length, and DataTables will apply each class
10167 * sequentially, looping when required.
10168 * @type array
10169 * @default null <i>Will take the values determined by the `oClasses.stripe*`
10170 * options</i>
10171 *
10172 * @dtopt Option
10173 * @name DataTable.defaults.stripeClasses
10174 *
10175 * @example
10176 * $(document).ready( function() {
10177 * $('#example').dataTable( {
10178 * "stripeClasses": [ 'strip1', 'strip2', 'strip3' ]
10179 * } );
10180 * } )
10181 */
10182 "asStripeClasses": null,
10185 /**
10186 * Enable or disable automatic column width calculation. This can be disabled
10187 * as an optimisation (it takes some time to calculate the widths) if the
10188 * tables widths are passed in using `columns`.
10189 * @type boolean
10190 * @default true
10191 *
10192 * @dtopt Features
10193 * @name DataTable.defaults.autoWidth
10194 *
10195 * @example
10196 * $(document).ready( function () {
10197 * $('#example').dataTable( {
10198 * "autoWidth": false
10199 * } );
10200 * } );
10201 */
10202 "bAutoWidth": true,
10205 /**
10206 * Deferred rendering can provide DataTables with a huge speed boost when you
10207 * are using an Ajax or JS data source for the table. This option, when set to
10208 * true, will cause DataTables to defer the creation of the table elements for
10209 * each row until they are needed for a draw - saving a significant amount of
10210 * time.
10211 * @type boolean
10212 * @default false
10213 *
10214 * @dtopt Features
10215 * @name DataTable.defaults.deferRender
10216 *
10217 * @example
10218 * $(document).ready( function() {
10219 * $('#example').dataTable( {
10220 * "ajax": "sources/arrays.txt",
10221 * "deferRender": true
10222 * } );
10223 * } );
10224 */
10225 "bDeferRender": false,
10228 /**
10229 * Replace a DataTable which matches the given selector and replace it with
10230 * one which has the properties of the new initialisation object passed. If no
10231 * table matches the selector, then the new DataTable will be constructed as
10232 * per normal.
10233 * @type boolean
10234 * @default false
10235 *
10236 * @dtopt Options
10237 * @name DataTable.defaults.destroy
10238 *
10239 * @example
10240 * $(document).ready( function() {
10241 * $('#example').dataTable( {
10242 * "srollY": "200px",
10243 * "paginate": false
10244 * } );
10245 *
10246 * // Some time later....
10247 * $('#example').dataTable( {
10248 * "filter": false,
10249 * "destroy": true
10250 * } );
10251 * } );
10252 */
10253 "bDestroy": false,
10256 /**
10257 * Enable or disable filtering of data. Filtering in DataTables is "smart" in
10258 * that it allows the end user to input multiple words (space separated) and
10259 * will match a row containing those words, even if not in the order that was
10260 * specified (this allow matching across multiple columns). Note that if you
10261 * wish to use filtering in DataTables this must remain 'true' - to remove the
10262 * default filtering input box and retain filtering abilities, please use
10263 * {@link DataTable.defaults.dom}.
10264 * @type boolean
10265 * @default true
10266 *
10267 * @dtopt Features
10268 * @name DataTable.defaults.searching
10269 *
10270 * @example
10271 * $(document).ready( function () {
10272 * $('#example').dataTable( {
10273 * "searching": false
10274 * } );
10275 * } );
10276 */
10277 "bFilter": true,
10280 /**
10281 * Enable or disable the table information display. This shows information
10282 * about the data that is currently visible on the page, including information
10283 * about filtered data if that action is being performed.
10284 * @type boolean
10285 * @default true
10286 *
10287 * @dtopt Features
10288 * @name DataTable.defaults.info
10289 *
10290 * @example
10291 * $(document).ready( function () {
10292 * $('#example').dataTable( {
10293 * "info": false
10294 * } );
10295 * } );
10296 */
10297 "bInfo": true,
10300 /**
10301 * Enable jQuery UI ThemeRoller support (required as ThemeRoller requires some
10302 * slightly different and additional mark-up from what DataTables has
10303 * traditionally used).
10304 * @type boolean
10305 * @default false
10306 *
10307 * @dtopt Features
10308 * @name DataTable.defaults.jQueryUI
10309 *
10310 * @example
10311 * $(document).ready( function() {
10312 * $('#example').dataTable( {
10313 * "jQueryUI": true
10314 * } );
10315 * } );
10316 */
10317 "bJQueryUI": false,
10320 /**
10321 * Allows the end user to select the size of a formatted page from a select
10322 * menu (sizes are 10, 25, 50 and 100). Requires pagination (`paginate`).
10323 * @type boolean
10324 * @default true
10325 *
10326 * @dtopt Features
10327 * @name DataTable.defaults.lengthChange
10328 *
10329 * @example
10330 * $(document).ready( function () {
10331 * $('#example').dataTable( {
10332 * "lengthChange": false
10333 * } );
10334 * } );
10335 */
10336 "bLengthChange": true,
10339 /**
10340 * Enable or disable pagination.
10341 * @type boolean
10342 * @default true
10343 *
10344 * @dtopt Features
10345 * @name DataTable.defaults.paging
10346 *
10347 * @example
10348 * $(document).ready( function () {
10349 * $('#example').dataTable( {
10350 * "paging": false
10351 * } );
10352 * } );
10353 */
10354 "bPaginate": true,
10357 /**
10358 * Enable or disable the display of a 'processing' indicator when the table is
10359 * being processed (e.g. a sort). This is particularly useful for tables with
10360 * large amounts of data where it can take a noticeable amount of time to sort
10361 * the entries.
10362 * @type boolean
10363 * @default false
10364 *
10365 * @dtopt Features
10366 * @name DataTable.defaults.processing
10367 *
10368 * @example
10369 * $(document).ready( function () {
10370 * $('#example').dataTable( {
10371 * "processing": true
10372 * } );
10373 * } );
10374 */
10375 "bProcessing": false,
10378 /**
10379 * Retrieve the DataTables object for the given selector. Note that if the
10380 * table has already been initialised, this parameter will cause DataTables
10381 * to simply return the object that has already been set up - it will not take
10382 * account of any changes you might have made to the initialisation object
10383 * passed to DataTables (setting this parameter to true is an acknowledgement
10384 * that you understand this). `destroy` can be used to reinitialise a table if
10385 * you need.
10386 * @type boolean
10387 * @default false
10388 *
10389 * @dtopt Options
10390 * @name DataTable.defaults.retrieve
10391 *
10392 * @example
10393 * $(document).ready( function() {
10394 * initTable();
10395 * tableActions();
10396 * } );
10397 *
10398 * function initTable ()
10399 * {
10400 * return $('#example').dataTable( {
10401 * "scrollY": "200px",
10402 * "paginate": false,
10403 * "retrieve": true
10404 * } );
10405 * }
10406 *
10407 * function tableActions ()
10408 * {
10409 * var table = initTable();
10410 * // perform API operations with oTable
10411 * }
10412 */
10413 "bRetrieve": false,
10416 /**
10417 * When vertical (y) scrolling is enabled, DataTables will force the height of
10418 * the table's viewport to the given height at all times (useful for layout).
10419 * However, this can look odd when filtering data down to a small data set,
10420 * and the footer is left "floating" further down. This parameter (when
10421 * enabled) will cause DataTables to collapse the table's viewport down when
10422 * the result set will fit within the given Y height.
10423 * @type boolean
10424 * @default false
10425 *
10426 * @dtopt Options
10427 * @name DataTable.defaults.scrollCollapse
10428 *
10429 * @example
10430 * $(document).ready( function() {
10431 * $('#example').dataTable( {
10432 * "scrollY": "200",
10433 * "scrollCollapse": true
10434 * } );
10435 * } );
10436 */
10437 "bScrollCollapse": false,
10440 /**
10441 * Configure DataTables to use server-side processing. Note that the
10442 * `ajax` parameter must also be given in order to give DataTables a
10443 * source to obtain the required data for each draw.
10444 * @type boolean
10445 * @default false
10446 *
10447 * @dtopt Features
10448 * @dtopt Server-side
10449 * @name DataTable.defaults.serverSide
10450 *
10451 * @example
10452 * $(document).ready( function () {
10453 * $('#example').dataTable( {
10454 * "serverSide": true,
10455 * "ajax": "xhr.php"
10456 * } );
10457 * } );
10458 */
10459 "bServerSide": false,
10462 /**
10463 * Enable or disable sorting of columns. Sorting of individual columns can be
10464 * disabled by the `sortable` option for each column.
10465 * @type boolean
10466 * @default true
10467 *
10468 * @dtopt Features
10469 * @name DataTable.defaults.ordering
10470 *
10471 * @example
10472 * $(document).ready( function () {
10473 * $('#example').dataTable( {
10474 * "ordering": false
10475 * } );
10476 * } );
10477 */
10478 "bSort": true,
10481 /**
10482 * Enable or display DataTables' ability to sort multiple columns at the
10483 * same time (activated by shift-click by the user).
10484 * @type boolean
10485 * @default true
10486 *
10487 * @dtopt Options
10488 * @name DataTable.defaults.orderMulti
10489 *
10490 * @example
10491 * // Disable multiple column sorting ability
10492 * $(document).ready( function () {
10493 * $('#example').dataTable( {
10494 * "orderMulti": false
10495 * } );
10496 * } );
10497 */
10498 "bSortMulti": true,
10501 /**
10502 * Allows control over whether DataTables should use the top (true) unique
10503 * cell that is found for a single column, or the bottom (false - default).
10504 * This is useful when using complex headers.
10505 * @type boolean
10506 * @default false
10507 *
10508 * @dtopt Options
10509 * @name DataTable.defaults.orderCellsTop
10510 *
10511 * @example
10512 * $(document).ready( function() {
10513 * $('#example').dataTable( {
10514 * "orderCellsTop": true
10515 * } );
10516 * } );
10517 */
10518 "bSortCellsTop": false,
10521 /**
10522 * Enable or disable the addition of the classes `sorting\_1`, `sorting\_2` and
10523 * `sorting\_3` to the columns which are currently being sorted on. This is
10524 * presented as a feature switch as it can increase processing time (while
10525 * classes are removed and added) so for large data sets you might want to
10526 * turn this off.
10527 * @type boolean
10528 * @default true
10529 *
10530 * @dtopt Features
10531 * @name DataTable.defaults.orderClasses
10532 *
10533 * @example
10534 * $(document).ready( function () {
10535 * $('#example').dataTable( {
10536 * "orderClasses": false
10537 * } );
10538 * } );
10539 */
10540 "bSortClasses": true,
10543 /**
10544 * Enable or disable state saving. When enabled HTML5 `localStorage` will be
10545 * used to save table display information such as pagination information,
10546 * display length, filtering and sorting. As such when the end user reloads
10547 * the page the display display will match what thy had previously set up.
10548 *
10549 * Due to the use of `localStorage` the default state saving is not supported
10550 * in IE6 or 7. If state saving is required in those browsers, use
10551 * `stateSaveCallback` to provide a storage solution such as cookies.
10552 * @type boolean
10553 * @default false
10554 *
10555 * @dtopt Features
10556 * @name DataTable.defaults.stateSave
10557 *
10558 * @example
10559 * $(document).ready( function () {
10560 * $('#example').dataTable( {
10561 * "stateSave": true
10562 * } );
10563 * } );
10564 */
10565 "bStateSave": false,
10568 /**
10569 * This function is called when a TR element is created (and all TD child
10570 * elements have been inserted), or registered if using a DOM source, allowing
10571 * manipulation of the TR element (adding classes etc).
10572 * @type function
10573 * @param {node} row "TR" element for the current row
10574 * @param {array} data Raw data array for this row
10575 * @param {int} dataIndex The index of this row in the internal aoData array
10576 *
10577 * @dtopt Callbacks
10578 * @name DataTable.defaults.createdRow
10579 *
10580 * @example
10581 * $(document).ready( function() {
10582 * $('#example').dataTable( {
10583 * "createdRow": function( row, data, dataIndex ) {
10584 * // Bold the grade for all 'A' grade browsers
10585 * if ( data[4] == "A" )
10586 * {
10587 * $('td:eq(4)', row).html( '<b>A</b>' );
10588 * }
10589 * }
10590 * } );
10591 * } );
10592 */
10593 "fnCreatedRow": null,
10596 /**
10597 * This function is called on every 'draw' event, and allows you to
10598 * dynamically modify any aspect you want about the created DOM.
10599 * @type function
10600 * @param {object} settings DataTables settings object
10601 *
10602 * @dtopt Callbacks
10603 * @name DataTable.defaults.drawCallback
10604 *
10605 * @example
10606 * $(document).ready( function() {
10607 * $('#example').dataTable( {
10608 * "drawCallback": function( settings ) {
10609 * alert( 'DataTables has redrawn the table' );
10610 * }
10611 * } );
10612 * } );
10613 */
10614 "fnDrawCallback": null,
10617 /**
10618 * Identical to fnHeaderCallback() but for the table footer this function
10619 * allows you to modify the table footer on every 'draw' event.
10620 * @type function
10621 * @param {node} foot "TR" element for the footer
10622 * @param {array} data Full table data (as derived from the original HTML)
10623 * @param {int} start Index for the current display starting point in the
10624 * display array
10625 * @param {int} end Index for the current display ending point in the
10626 * display array
10627 * @param {array int} display Index array to translate the visual position
10628 * to the full data array
10629 *
10630 * @dtopt Callbacks
10631 * @name DataTable.defaults.footerCallback
10632 *
10633 * @example
10634 * $(document).ready( function() {
10635 * $('#example').dataTable( {
10636 * "footerCallback": function( tfoot, data, start, end, display ) {
10637 * tfoot.getElementsByTagName('th')[0].innerHTML = "Starting index is "+start;
10638 * }
10639 * } );
10640 * } )
10641 */
10642 "fnFooterCallback": null,
10645 /**
10646 * When rendering large numbers in the information element for the table
10647 * (i.e. "Showing 1 to 10 of 57 entries") DataTables will render large numbers
10648 * to have a comma separator for the 'thousands' units (e.g. 1 million is
10649 * rendered as "1,000,000") to help readability for the end user. This
10650 * function will override the default method DataTables uses.
10651 * @type function
10652 * @member
10653 * @param {int} toFormat number to be formatted
10654 * @returns {string} formatted string for DataTables to show the number
10655 *
10656 * @dtopt Callbacks
10657 * @name DataTable.defaults.formatNumber
10658 *
10659 * @example
10660 * // Format a number using a single quote for the separator (note that
10661 * // this can also be done with the language.thousands option)
10662 * $(document).ready( function() {
10663 * $('#example').dataTable( {
10664 * "formatNumber": function ( toFormat ) {
10665 * return toFormat.toString().replace(
10666 * /\B(?=(\d{3})+(?!\d))/g, "'"
10667 * );
10668 * };
10669 * } );
10670 * } );
10671 */
10672 "fnFormatNumber": function ( toFormat ) {
10673 return toFormat.toString().replace(
10674 /\B(?=(\d{3})+(?!\d))/g,
10675 this.oLanguage.sThousands
10676 );
10677 },
10680 /**
10681 * This function is called on every 'draw' event, and allows you to
10682 * dynamically modify the header row. This can be used to calculate and
10683 * display useful information about the table.
10684 * @type function
10685 * @param {node} head "TR" element for the header
10686 * @param {array} data Full table data (as derived from the original HTML)
10687 * @param {int} start Index for the current display starting point in the
10688 * display array
10689 * @param {int} end Index for the current display ending point in the
10690 * display array
10691 * @param {array int} display Index array to translate the visual position
10692 * to the full data array
10693 *
10694 * @dtopt Callbacks
10695 * @name DataTable.defaults.headerCallback
10696 *
10697 * @example
10698 * $(document).ready( function() {
10699 * $('#example').dataTable( {
10700 * "fheaderCallback": function( head, data, start, end, display ) {
10701 * head.getElementsByTagName('th')[0].innerHTML = "Displaying "+(end-start)+" records";
10702 * }
10703 * } );
10704 * } )
10705 */
10706 "fnHeaderCallback": null,
10709 /**
10710 * The information element can be used to convey information about the current
10711 * state of the table. Although the internationalisation options presented by
10712 * DataTables are quite capable of dealing with most customisations, there may
10713 * be times where you wish to customise the string further. This callback
10714 * allows you to do exactly that.
10715 * @type function
10716 * @param {object} oSettings DataTables settings object
10717 * @param {int} start Starting position in data for the draw
10718 * @param {int} end End position in data for the draw
10719 * @param {int} max Total number of rows in the table (regardless of
10720 * filtering)
10721 * @param {int} total Total number of rows in the data set, after filtering
10722 * @param {string} pre The string that DataTables has formatted using it's
10723 * own rules
10724 * @returns {string} The string to be displayed in the information element.
10725 *
10726 * @dtopt Callbacks
10727 * @name DataTable.defaults.infoCallback
10728 *
10729 * @example
10730 * $('#example').dataTable( {
10731 * "infoCallback": function( settings, start, end, max, total, pre ) {
10732 * return start +" to "+ end;
10733 * }
10734 * } );
10735 */
10736 "fnInfoCallback": null,
10739 /**
10740 * Called when the table has been initialised. Normally DataTables will
10741 * initialise sequentially and there will be no need for this function,
10742 * however, this does not hold true when using external language information
10743 * since that is obtained using an async XHR call.
10744 * @type function
10745 * @param {object} settings DataTables settings object
10746 * @param {object} json The JSON object request from the server - only
10747 * present if client-side Ajax sourced data is used
10748 *
10749 * @dtopt Callbacks
10750 * @name DataTable.defaults.initComplete
10751 *
10752 * @example
10753 * $(document).ready( function() {
10754 * $('#example').dataTable( {
10755 * "initComplete": function(settings, json) {
10756 * alert( 'DataTables has finished its initialisation.' );
10757 * }
10758 * } );
10759 * } )
10760 */
10761 "fnInitComplete": null,
10764 /**
10765 * Called at the very start of each table draw and can be used to cancel the
10766 * draw by returning false, any other return (including undefined) results in
10767 * the full draw occurring).
10768 * @type function
10769 * @param {object} settings DataTables settings object
10770 * @returns {boolean} False will cancel the draw, anything else (including no
10771 * return) will allow it to complete.
10772 *
10773 * @dtopt Callbacks
10774 * @name DataTable.defaults.preDrawCallback
10775 *
10776 * @example
10777 * $(document).ready( function() {
10778 * $('#example').dataTable( {
10779 * "preDrawCallback": function( settings ) {
10780 * if ( $('#test').val() == 1 ) {
10781 * return false;
10782 * }
10783 * }
10784 * } );
10785 * } );
10786 */
10787 "fnPreDrawCallback": null,
10790 /**
10791 * This function allows you to 'post process' each row after it have been
10792 * generated for each table draw, but before it is rendered on screen. This
10793 * function might be used for setting the row class name etc.
10794 * @type function
10795 * @param {node} row "TR" element for the current row
10796 * @param {array} data Raw data array for this row
10797 * @param {int} displayIndex The display index for the current table draw
10798 * @param {int} displayIndexFull The index of the data in the full list of
10799 * rows (after filtering)
10800 *
10801 * @dtopt Callbacks
10802 * @name DataTable.defaults.rowCallback
10803 *
10804 * @example
10805 * $(document).ready( function() {
10806 * $('#example').dataTable( {
10807 * "rowCallback": function( row, data, displayIndex, displayIndexFull ) {
10808 * // Bold the grade for all 'A' grade browsers
10809 * if ( data[4] == "A" ) {
10810 * $('td:eq(4)', row).html( '<b>A</b>' );
10811 * }
10812 * }
10813 * } );
10814 * } );
10815 */
10816 "fnRowCallback": null,
10819 /**
10820 * __Deprecated__ The functionality provided by this parameter has now been
10821 * superseded by that provided through `ajax`, which should be used instead.
10822 *
10823 * This parameter allows you to override the default function which obtains
10824 * the data from the server so something more suitable for your application.
10825 * For example you could use POST data, or pull information from a Gears or
10826 * AIR database.
10827 * @type function
10828 * @member
10829 * @param {string} source HTTP source to obtain the data from (`ajax`)
10830 * @param {array} data A key/value pair object containing the data to send
10831 * to the server
10832 * @param {function} callback to be called on completion of the data get
10833 * process that will draw the data on the page.
10834 * @param {object} settings DataTables settings object
10835 *
10836 * @dtopt Callbacks
10837 * @dtopt Server-side
10838 * @name DataTable.defaults.serverData
10839 *
10840 * @deprecated 1.10. Please use `ajax` for this functionality now.
10841 */
10842 "fnServerData": null,
10845 /**
10846 * __Deprecated__ The functionality provided by this parameter has now been
10847 * superseded by that provided through `ajax`, which should be used instead.
10848 *
10849 * It is often useful to send extra data to the server when making an Ajax
10850 * request - for example custom filtering information, and this callback
10851 * function makes it trivial to send extra information to the server. The
10852 * passed in parameter is the data set that has been constructed by
10853 * DataTables, and you can add to this or modify it as you require.
10854 * @type function
10855 * @param {array} data Data array (array of objects which are name/value
10856 * pairs) that has been constructed by DataTables and will be sent to the
10857 * server. In the case of Ajax sourced data with server-side processing
10858 * this will be an empty array, for server-side processing there will be a
10859 * significant number of parameters!
10860 * @returns {undefined} Ensure that you modify the data array passed in,
10861 * as this is passed by reference.
10862 *
10863 * @dtopt Callbacks
10864 * @dtopt Server-side
10865 * @name DataTable.defaults.serverParams
10866 *
10867 * @deprecated 1.10. Please use `ajax` for this functionality now.
10868 */
10869 "fnServerParams": null,
10872 /**
10873 * Load the table state. With this function you can define from where, and how, the
10874 * state of a table is loaded. By default DataTables will load from `localStorage`
10875 * but you might wish to use a server-side database or cookies.
10876 * @type function
10877 * @member
10878 * @param {object} settings DataTables settings object
10879 * @return {object} The DataTables state object to be loaded
10880 *
10881 * @dtopt Callbacks
10882 * @name DataTable.defaults.stateLoadCallback
10883 *
10884 * @example
10885 * $(document).ready( function() {
10886 * $('#example').dataTable( {
10887 * "stateSave": true,
10888 * "stateLoadCallback": function (settings) {
10889 * var o;
10890 *
10891 * // Send an Ajax request to the server to get the data. Note that
10892 * // this is a synchronous request.
10893 * $.ajax( {
10894 * "url": "/state_load",
10895 * "async": false,
10896 * "dataType": "json",
10897 * "success": function (json) {
10898 * o = json;
10899 * }
10900 * } );
10901 *
10902 * return o;
10903 * }
10904 * } );
10905 * } );
10906 */
10907 "fnStateLoadCallback": function ( settings ) {
10908 try {
10909 return JSON.parse(
10910 (settings.iStateDuration === -1 ? sessionStorage : localStorage).getItem(
10911 'DataTables_'+settings.sInstance+'_'+location.pathname
10912 )
10913 );
10914 } catch (e) {}
10915 },
10918 /**
10919 * Callback which allows modification of the saved state prior to loading that state.
10920 * This callback is called when the table is loading state from the stored data, but
10921 * prior to the settings object being modified by the saved state. Note that for
10922 * plug-in authors, you should use the `stateLoadParams` event to load parameters for
10923 * a plug-in.
10924 * @type function
10925 * @param {object} settings DataTables settings object
10926 * @param {object} data The state object that is to be loaded
10927 *
10928 * @dtopt Callbacks
10929 * @name DataTable.defaults.stateLoadParams
10930 *
10931 * @example
10932 * // Remove a saved filter, so filtering is never loaded
10933 * $(document).ready( function() {
10934 * $('#example').dataTable( {
10935 * "stateSave": true,
10936 * "stateLoadParams": function (settings, data) {
10937 * data.oSearch.sSearch = "";
10938 * }
10939 * } );
10940 * } );
10941 *
10942 * @example
10943 * // Disallow state loading by returning false
10944 * $(document).ready( function() {
10945 * $('#example').dataTable( {
10946 * "stateSave": true,
10947 * "stateLoadParams": function (settings, data) {
10948 * return false;
10949 * }
10950 * } );
10951 * } );
10952 */
10953 "fnStateLoadParams": null,
10956 /**
10957 * Callback that is called when the state has been loaded from the state saving method
10958 * and the DataTables settings object has been modified as a result of the loaded state.
10959 * @type function
10960 * @param {object} settings DataTables settings object
10961 * @param {object} data The state object that was loaded
10962 *
10963 * @dtopt Callbacks
10964 * @name DataTable.defaults.stateLoaded
10965 *
10966 * @example
10967 * // Show an alert with the filtering value that was saved
10968 * $(document).ready( function() {
10969 * $('#example').dataTable( {
10970 * "stateSave": true,
10971 * "stateLoaded": function (settings, data) {
10972 * alert( 'Saved filter was: '+data.oSearch.sSearch );
10973 * }
10974 * } );
10975 * } );
10976 */
10977 "fnStateLoaded": null,
10980 /**
10981 * Save the table state. This function allows you to define where and how the state
10982 * information for the table is stored By default DataTables will use `localStorage`
10983 * but you might wish to use a server-side database or cookies.
10984 * @type function
10985 * @member
10986 * @param {object} settings DataTables settings object
10987 * @param {object} data The state object to be saved
10988 *
10989 * @dtopt Callbacks
10990 * @name DataTable.defaults.stateSaveCallback
10991 *
10992 * @example
10993 * $(document).ready( function() {
10994 * $('#example').dataTable( {
10995 * "stateSave": true,
10996 * "stateSaveCallback": function (settings, data) {
10997 * // Send an Ajax request to the server with the state object
10998 * $.ajax( {
10999 * "url": "/state_save",
11000 * "data": data,
11001 * "dataType": "json",
11002 * "method": "POST"
11003 * "success": function () {}
11004 * } );
11005 * }
11006 * } );
11007 * } );
11008 */
11009 "fnStateSaveCallback": function ( settings, data ) {
11010 try {
11011 (settings.iStateDuration === -1 ? sessionStorage : localStorage).setItem(
11012 'DataTables_'+settings.sInstance+'_'+location.pathname,
11013 JSON.stringify( data )
11014 );
11015 } catch (e) {}
11016 },
11019 /**
11020 * Callback which allows modification of the state to be saved. Called when the table
11021 * has changed state a new state save is required. This method allows modification of
11022 * the state saving object prior to actually doing the save, including addition or
11023 * other state properties or modification. Note that for plug-in authors, you should
11024 * use the `stateSaveParams` event to save parameters for a plug-in.
11025 * @type function
11026 * @param {object} settings DataTables settings object
11027 * @param {object} data The state object to be saved
11028 *
11029 * @dtopt Callbacks
11030 * @name DataTable.defaults.stateSaveParams
11031 *
11032 * @example
11033 * // Remove a saved filter, so filtering is never saved
11034 * $(document).ready( function() {
11035 * $('#example').dataTable( {
11036 * "stateSave": true,
11037 * "stateSaveParams": function (settings, data) {
11038 * data.oSearch.sSearch = "";
11039 * }
11040 * } );
11041 * } );
11042 */
11043 "fnStateSaveParams": null,
11046 /**
11047 * Duration for which the saved state information is considered valid. After this period
11048 * has elapsed the state will be returned to the default.
11049 * Value is given in seconds.
11050 * @type int
11051 * @default 7200 <i>(2 hours)</i>
11052 *
11053 * @dtopt Options
11054 * @name DataTable.defaults.stateDuration
11055 *
11056 * @example
11057 * $(document).ready( function() {
11058 * $('#example').dataTable( {
11059 * "stateDuration": 60*60*24; // 1 day
11060 * } );
11061 * } )
11062 */
11063 "iStateDuration": 7200,
11066 /**
11067 * When enabled DataTables will not make a request to the server for the first
11068 * page draw - rather it will use the data already on the page (no sorting etc
11069 * will be applied to it), thus saving on an XHR at load time. `deferLoading`
11070 * is used to indicate that deferred loading is required, but it is also used
11071 * to tell DataTables how many records there are in the full table (allowing
11072 * the information element and pagination to be displayed correctly). In the case
11073 * where a filtering is applied to the table on initial load, this can be
11074 * indicated by giving the parameter as an array, where the first element is
11075 * the number of records available after filtering and the second element is the
11076 * number of records without filtering (allowing the table information element
11077 * to be shown correctly).
11078 * @type int | array
11079 * @default null
11080 *
11081 * @dtopt Options
11082 * @name DataTable.defaults.deferLoading
11083 *
11084 * @example
11085 * // 57 records available in the table, no filtering applied
11086 * $(document).ready( function() {
11087 * $('#example').dataTable( {
11088 * "serverSide": true,
11089 * "ajax": "scripts/server_processing.php",
11090 * "deferLoading": 57
11091 * } );
11092 * } );
11093 *
11094 * @example
11095 * // 57 records after filtering, 100 without filtering (an initial filter applied)
11096 * $(document).ready( function() {
11097 * $('#example').dataTable( {
11098 * "serverSide": true,
11099 * "ajax": "scripts/server_processing.php",
11100 * "deferLoading": [ 57, 100 ],
11101 * "search": {
11102 * "search": "my_filter"
11103 * }
11104 * } );
11105 * } );
11106 */
11107 "iDeferLoading": null,
11110 /**
11111 * Number of rows to display on a single page when using pagination. If
11112 * feature enabled (`lengthChange`) then the end user will be able to override
11113 * this to a custom setting using a pop-up menu.
11114 * @type int
11115 * @default 10
11116 *
11117 * @dtopt Options
11118 * @name DataTable.defaults.pageLength
11119 *
11120 * @example
11121 * $(document).ready( function() {
11122 * $('#example').dataTable( {
11123 * "pageLength": 50
11124 * } );
11125 * } )
11126 */
11127 "iDisplayLength": 10,
11130 /**
11131 * Define the starting point for data display when using DataTables with
11132 * pagination. Note that this parameter is the number of records, rather than
11133 * the page number, so if you have 10 records per page and want to start on
11134 * the third page, it should be "20".
11135 * @type int
11136 * @default 0
11137 *
11138 * @dtopt Options
11139 * @name DataTable.defaults.displayStart
11140 *
11141 * @example
11142 * $(document).ready( function() {
11143 * $('#example').dataTable( {
11144 * "displayStart": 20
11145 * } );
11146 * } )
11147 */
11148 "iDisplayStart": 0,
11151 /**
11152 * By default DataTables allows keyboard navigation of the table (sorting, paging,
11153 * and filtering) by adding a `tabindex` attribute to the required elements. This
11154 * allows you to tab through the controls and press the enter key to activate them.
11155 * The tabindex is default 0, meaning that the tab follows the flow of the document.
11156 * You can overrule this using this parameter if you wish. Use a value of -1 to
11157 * disable built-in keyboard navigation.
11158 * @type int
11159 * @default 0
11160 *
11161 * @dtopt Options
11162 * @name DataTable.defaults.tabIndex
11163 *
11164 * @example
11165 * $(document).ready( function() {
11166 * $('#example').dataTable( {
11167 * "tabIndex": 1
11168 * } );
11169 * } );
11170 */
11171 "iTabIndex": 0,
11174 /**
11175 * Classes that DataTables assigns to the various components and features
11176 * that it adds to the HTML table. This allows classes to be configured
11177 * during initialisation in addition to through the static
11178 * {@link DataTable.ext.oStdClasses} object).
11179 * @namespace
11180 * @name DataTable.defaults.classes
11181 */
11182 "oClasses": {},
11185 /**
11186 * All strings that DataTables uses in the user interface that it creates
11187 * are defined in this object, allowing you to modified them individually or
11188 * completely replace them all as required.
11189 * @namespace
11190 * @name DataTable.defaults.language
11191 */
11192 "oLanguage": {
11193 /**
11194 * Strings that are used for WAI-ARIA labels and controls only (these are not
11195 * actually visible on the page, but will be read by screenreaders, and thus
11196 * must be internationalised as well).
11197 * @namespace
11198 * @name DataTable.defaults.language.aria
11199 */
11200 "oAria": {
11201 /**
11202 * ARIA label that is added to the table headers when the column may be
11203 * sorted ascending by activing the column (click or return when focused).
11204 * Note that the column header is prefixed to this string.
11205 * @type string
11206 * @default : activate to sort column ascending
11207 *
11208 * @dtopt Language
11209 * @name DataTable.defaults.language.aria.sortAscending
11210 *
11211 * @example
11212 * $(document).ready( function() {
11213 * $('#example').dataTable( {
11214 * "language": {
11215 * "aria": {
11216 * "sortAscending": " - click/return to sort ascending"
11217 * }
11218 * }
11219 * } );
11220 * } );
11221 */
11222 "sSortAscending": ": activate to sort column ascending",
11224 /**
11225 * ARIA label that is added to the table headers when the column may be
11226 * sorted descending by activing the column (click or return when focused).
11227 * Note that the column header is prefixed to this string.
11228 * @type string
11229 * @default : activate to sort column ascending
11230 *
11231 * @dtopt Language
11232 * @name DataTable.defaults.language.aria.sortDescending
11233 *
11234 * @example
11235 * $(document).ready( function() {
11236 * $('#example').dataTable( {
11237 * "language": {
11238 * "aria": {
11239 * "sortDescending": " - click/return to sort descending"
11240 * }
11241 * }
11242 * } );
11243 * } );
11244 */
11245 "sSortDescending": ": activate to sort column descending"
11246 },
11248 /**
11249 * Pagination string used by DataTables for the built-in pagination
11250 * control types.
11251 * @namespace
11252 * @name DataTable.defaults.language.paginate
11253 */
11254 "oPaginate": {
11255 /**
11256 * Text to use when using the 'full_numbers' type of pagination for the
11257 * button to take the user to the first page.
11258 * @type string
11259 * @default First
11260 *
11261 * @dtopt Language
11262 * @name DataTable.defaults.language.paginate.first
11263 *
11264 * @example
11265 * $(document).ready( function() {
11266 * $('#example').dataTable( {
11267 * "language": {
11268 * "paginate": {
11269 * "first": "First page"
11270 * }
11271 * }
11272 * } );
11273 * } );
11274 */
11275 "sFirst": "First",
11278 /**
11279 * Text to use when using the 'full_numbers' type of pagination for the
11280 * button to take the user to the last page.
11281 * @type string
11282 * @default Last
11283 *
11284 * @dtopt Language
11285 * @name DataTable.defaults.language.paginate.last
11286 *
11287 * @example
11288 * $(document).ready( function() {
11289 * $('#example').dataTable( {
11290 * "language": {
11291 * "paginate": {
11292 * "last": "Last page"
11293 * }
11294 * }
11295 * } );
11296 * } );
11297 */
11298 "sLast": "Last",
11301 /**
11302 * Text to use for the 'next' pagination button (to take the user to the
11303 * next page).
11304 * @type string
11305 * @default Next
11306 *
11307 * @dtopt Language
11308 * @name DataTable.defaults.language.paginate.next
11309 *
11310 * @example
11311 * $(document).ready( function() {
11312 * $('#example').dataTable( {
11313 * "language": {
11314 * "paginate": {
11315 * "next": "Next page"
11316 * }
11317 * }
11318 * } );
11319 * } );
11320 */
11321 "sNext": "Next",
11324 /**
11325 * Text to use for the 'previous' pagination button (to take the user to
11326 * the previous page).
11327 * @type string
11328 * @default Previous
11329 *
11330 * @dtopt Language
11331 * @name DataTable.defaults.language.paginate.previous
11332 *
11333 * @example
11334 * $(document).ready( function() {
11335 * $('#example').dataTable( {
11336 * "language": {
11337 * "paginate": {
11338 * "previous": "Previous page"
11339 * }
11340 * }
11341 * } );
11342 * } );
11343 */
11344 "sPrevious": "Previous"
11345 },
11347 /**
11348 * This string is shown in preference to `zeroRecords` when the table is
11349 * empty of data (regardless of filtering). Note that this is an optional
11350 * parameter - if it is not given, the value of `zeroRecords` will be used
11351 * instead (either the default or given value).
11352 * @type string
11353 * @default No data available in table
11354 *
11355 * @dtopt Language
11356 * @name DataTable.defaults.language.emptyTable
11357 *
11358 * @example
11359 * $(document).ready( function() {
11360 * $('#example').dataTable( {
11361 * "language": {
11362 * "emptyTable": "No data available in table"
11363 * }
11364 * } );
11365 * } );
11366 */
11367 "sEmptyTable": "No data available in table",
11370 /**
11371 * This string gives information to the end user about the information
11372 * that is current on display on the page. The following tokens can be
11373 * used in the string and will be dynamically replaced as the table
11374 * display updates. This tokens can be placed anywhere in the string, or
11375 * removed as needed by the language requires:
11376 *
11377 * * `\_START\_` - Display index of the first record on the current page
11378 * * `\_END\_` - Display index of the last record on the current page
11379 * * `\_TOTAL\_` - Number of records in the table after filtering
11380 * * `\_MAX\_` - Number of records in the table without filtering
11381 * * `\_PAGE\_` - Current page number
11382 * * `\_PAGES\_` - Total number of pages of data in the table
11383 *
11384 * @type string
11385 * @default Showing _START_ to _END_ of _TOTAL_ entries
11386 *
11387 * @dtopt Language
11388 * @name DataTable.defaults.language.info
11389 *
11390 * @example
11391 * $(document).ready( function() {
11392 * $('#example').dataTable( {
11393 * "language": {
11394 * "info": "Showing page _PAGE_ of _PAGES_"
11395 * }
11396 * } );
11397 * } );
11398 */
11399 "sInfo": "Showing _START_ to _END_ of _TOTAL_ entries",
11402 /**
11403 * Display information string for when the table is empty. Typically the
11404 * format of this string should match `info`.
11405 * @type string
11406 * @default Showing 0 to 0 of 0 entries
11407 *
11408 * @dtopt Language
11409 * @name DataTable.defaults.language.infoEmpty
11410 *
11411 * @example
11412 * $(document).ready( function() {
11413 * $('#example').dataTable( {
11414 * "language": {
11415 * "infoEmpty": "No entries to show"
11416 * }
11417 * } );
11418 * } );
11419 */
11420 "sInfoEmpty": "Showing 0 to 0 of 0 entries",
11423 /**
11424 * When a user filters the information in a table, this string is appended
11425 * to the information (`info`) to give an idea of how strong the filtering
11426 * is. The variable _MAX_ is dynamically updated.
11427 * @type string
11428 * @default (filtered from _MAX_ total entries)
11429 *
11430 * @dtopt Language
11431 * @name DataTable.defaults.language.infoFiltered
11432 *
11433 * @example
11434 * $(document).ready( function() {
11435 * $('#example').dataTable( {
11436 * "language": {
11437 * "infoFiltered": " - filtering from _MAX_ records"
11438 * }
11439 * } );
11440 * } );
11441 */
11442 "sInfoFiltered": "(filtered from _MAX_ total entries)",
11445 /**
11446 * If can be useful to append extra information to the info string at times,
11447 * and this variable does exactly that. This information will be appended to
11448 * the `info` (`infoEmpty` and `infoFiltered` in whatever combination they are
11449 * being used) at all times.
11450 * @type string
11451 * @default <i>Empty string</i>
11452 *
11453 * @dtopt Language
11454 * @name DataTable.defaults.language.infoPostFix
11455 *
11456 * @example
11457 * $(document).ready( function() {
11458 * $('#example').dataTable( {
11459 * "language": {
11460 * "infoPostFix": "All records shown are derived from real information."
11461 * }
11462 * } );
11463 * } );
11464 */
11465 "sInfoPostFix": "",
11468 /**
11469 * This decimal place operator is a little different from the other
11470 * language options since DataTables doesn't output floating point
11471 * numbers, so it won't ever use this for display of a number. Rather,
11472 * what this parameter does is modify the sort methods of the table so
11473 * that numbers which are in a format which has a character other than
11474 * a period (`.`) as a decimal place will be sorted numerically.
11475 *
11476 * Note that numbers with different decimal places cannot be shown in
11477 * the same table and still be sortable, the table must be consistent.
11478 * However, multiple different tables on the page can use different
11479 * decimal place characters.
11480 * @type string
11481 * @default
11482 *
11483 * @dtopt Language
11484 * @name DataTable.defaults.language.decimal
11485 *
11486 * @example
11487 * $(document).ready( function() {
11488 * $('#example').dataTable( {
11489 * "language": {
11490 * "decimal": ","
11491 * "thousands": "."
11492 * }
11493 * } );
11494 * } );
11495 */
11496 "sDecimal": "",
11499 /**
11500 * DataTables has a build in number formatter (`formatNumber`) which is
11501 * used to format large numbers that are used in the table information.
11502 * By default a comma is used, but this can be trivially changed to any
11503 * character you wish with this parameter.
11504 * @type string
11505 * @default ,
11506 *
11507 * @dtopt Language
11508 * @name DataTable.defaults.language.thousands
11509 *
11510 * @example
11511 * $(document).ready( function() {
11512 * $('#example').dataTable( {
11513 * "language": {
11514 * "thousands": "'"
11515 * }
11516 * } );
11517 * } );
11518 */
11519 "sThousands": ",",
11522 /**
11523 * Detail the action that will be taken when the drop down menu for the
11524 * pagination length option is changed. The '_MENU_' variable is replaced
11525 * with a default select list of 10, 25, 50 and 100, and can be replaced
11526 * with a custom select box if required.
11527 * @type string
11528 * @default Show _MENU_ entries
11529 *
11530 * @dtopt Language
11531 * @name DataTable.defaults.language.lengthMenu
11532 *
11533 * @example
11534 * // Language change only
11535 * $(document).ready( function() {
11536 * $('#example').dataTable( {
11537 * "language": {
11538 * "lengthMenu": "Display _MENU_ records"
11539 * }
11540 * } );
11541 * } );
11542 *
11543 * @example
11544 * // Language and options change
11545 * $(document).ready( function() {
11546 * $('#example').dataTable( {
11547 * "language": {
11548 * "lengthMenu": 'Display <select>'+
11549 * '<option value="10">10</option>'+
11550 * '<option value="20">20</option>'+
11551 * '<option value="30">30</option>'+
11552 * '<option value="40">40</option>'+
11553 * '<option value="50">50</option>'+
11554 * '<option value="-1">All</option>'+
11555 * '</select> records'
11556 * }
11557 * } );
11558 * } );
11559 */
11560 "sLengthMenu": "Show _MENU_ entries",
11563 /**
11564 * When using Ajax sourced data and during the first draw when DataTables is
11565 * gathering the data, this message is shown in an empty row in the table to
11566 * indicate to the end user the the data is being loaded. Note that this
11567 * parameter is not used when loading data by server-side processing, just
11568 * Ajax sourced data with client-side processing.
11569 * @type string
11570 * @default Loading...
11571 *
11572 * @dtopt Language
11573 * @name DataTable.defaults.language.loadingRecords
11574 *
11575 * @example
11576 * $(document).ready( function() {
11577 * $('#example').dataTable( {
11578 * "language": {
11579 * "loadingRecords": "Please wait - loading..."
11580 * }
11581 * } );
11582 * } );
11583 */
11584 "sLoadingRecords": "Loading...",
11587 /**
11588 * Text which is displayed when the table is processing a user action
11589 * (usually a sort command or similar).
11590 * @type string
11591 * @default Processing...
11592 *
11593 * @dtopt Language
11594 * @name DataTable.defaults.language.processing
11595 *
11596 * @example
11597 * $(document).ready( function() {
11598 * $('#example').dataTable( {
11599 * "language": {
11600 * "processing": "DataTables is currently busy"
11601 * }
11602 * } );
11603 * } );
11604 */
11605 "sProcessing": "Processing...",
11608 /**
11609 * Details the actions that will be taken when the user types into the
11610 * filtering input text box. The variable "_INPUT_", if used in the string,
11611 * is replaced with the HTML text box for the filtering input allowing
11612 * control over where it appears in the string. If "_INPUT_" is not given
11613 * then the input box is appended to the string automatically.
11614 * @type string
11615 * @default Search:
11616 *
11617 * @dtopt Language
11618 * @name DataTable.defaults.language.search
11619 *
11620 * @example
11621 * // Input text box will be appended at the end automatically
11622 * $(document).ready( function() {
11623 * $('#example').dataTable( {
11624 * "language": {
11625 * "search": "Filter records:"
11626 * }
11627 * } );
11628 * } );
11629 *
11630 * @example
11631 * // Specify where the filter should appear
11632 * $(document).ready( function() {
11633 * $('#example').dataTable( {
11634 * "language": {
11635 * "search": "Apply filter _INPUT_ to table"
11636 * }
11637 * } );
11638 * } );
11639 */
11640 "sSearch": "Search:",
11643 /**
11644 * Assign a `placeholder` attribute to the search `input` element
11645 * @type string
11646 * @default
11647 *
11648 * @dtopt Language
11649 * @name DataTable.defaults.language.searchPlaceholder
11650 */
11651 "sSearchPlaceholder": "",
11654 /**
11655 * All of the language information can be stored in a file on the
11656 * server-side, which DataTables will look up if this parameter is passed.
11657 * It must store the URL of the language file, which is in a JSON format,
11658 * and the object has the same properties as the oLanguage object in the
11659 * initialiser object (i.e. the above parameters). Please refer to one of
11660 * the example language files to see how this works in action.
11661 * @type string
11662 * @default <i>Empty string - i.e. disabled</i>
11663 *
11664 * @dtopt Language
11665 * @name DataTable.defaults.language.url
11666 *
11667 * @example
11668 * $(document).ready( function() {
11669 * $('#example').dataTable( {
11670 * "language": {
11671 * "url": "http://www.sprymedia.co.uk/dataTables/lang.txt"
11672 * }
11673 * } );
11674 * } );
11675 */
11676 "sUrl": "",
11679 /**
11680 * Text shown inside the table records when the is no information to be
11681 * displayed after filtering. `emptyTable` is shown when there is simply no
11682 * information in the table at all (regardless of filtering).
11683 * @type string
11684 * @default No matching records found
11685 *
11686 * @dtopt Language
11687 * @name DataTable.defaults.language.zeroRecords
11688 *
11689 * @example
11690 * $(document).ready( function() {
11691 * $('#example').dataTable( {
11692 * "language": {
11693 * "zeroRecords": "No records to display"
11694 * }
11695 * } );
11696 * } );
11697 */
11698 "sZeroRecords": "No matching records found"
11699 },
11702 /**
11703 * This parameter allows you to have define the global filtering state at
11704 * initialisation time. As an object the `search` parameter must be
11705 * defined, but all other parameters are optional. When `regex` is true,
11706 * the search string will be treated as a regular expression, when false
11707 * (default) it will be treated as a straight string. When `smart`
11708 * DataTables will use it's smart filtering methods (to word match at
11709 * any point in the data), when false this will not be done.
11710 * @namespace
11711 * @extends DataTable.models.oSearch
11712 *
11713 * @dtopt Options
11714 * @name DataTable.defaults.search
11715 *
11716 * @example
11717 * $(document).ready( function() {
11718 * $('#example').dataTable( {
11719 * "search": {"search": "Initial search"}
11720 * } );
11721 * } )
11722 */
11723 "oSearch": $.extend( {}, DataTable.models.oSearch ),
11726 /**
11727 * __Deprecated__ The functionality provided by this parameter has now been
11728 * superseded by that provided through `ajax`, which should be used instead.
11729 *
11730 * By default DataTables will look for the property `data` (or `aaData` for
11731 * compatibility with DataTables 1.9-) when obtaining data from an Ajax
11732 * source or for server-side processing - this parameter allows that
11733 * property to be changed. You can use Javascript dotted object notation to
11734 * get a data source for multiple levels of nesting.
11735 * @type string
11736 * @default data
11737 *
11738 * @dtopt Options
11739 * @dtopt Server-side
11740 * @name DataTable.defaults.ajaxDataProp
11741 *
11742 * @deprecated 1.10. Please use `ajax` for this functionality now.
11743 */
11744 "sAjaxDataProp": "data",
11747 /**
11748 * __Deprecated__ The functionality provided by this parameter has now been
11749 * superseded by that provided through `ajax`, which should be used instead.
11750 *
11751 * You can instruct DataTables to load data from an external
11752 * source using this parameter (use aData if you want to pass data in you
11753 * already have). Simply provide a url a JSON object can be obtained from.
11754 * @type string
11755 * @default null
11756 *
11757 * @dtopt Options
11758 * @dtopt Server-side
11759 * @name DataTable.defaults.ajaxSource
11760 *
11761 * @deprecated 1.10. Please use `ajax` for this functionality now.
11762 */
11763 "sAjaxSource": null,
11766 /**
11767 * This initialisation variable allows you to specify exactly where in the
11768 * DOM you want DataTables to inject the various controls it adds to the page
11769 * (for example you might want the pagination controls at the top of the
11770 * table). DIV elements (with or without a custom class) can also be added to
11771 * aid styling. The follow syntax is used:
11772 * <ul>
11773 * <li>The following options are allowed:
11774 * <ul>
11775 * <li>'l' - Length changing</li>
11776 * <li>'f' - Filtering input</li>
11777 * <li>'t' - The table!</li>
11778 * <li>'i' - Information</li>
11779 * <li>'p' - Pagination</li>
11780 * <li>'r' - pRocessing</li>
11781 * </ul>
11782 * </li>
11783 * <li>The following constants are allowed:
11784 * <ul>
11785 * <li>'H' - jQueryUI theme "header" classes ('fg-toolbar ui-widget-header ui-corner-tl ui-corner-tr ui-helper-clearfix')</li>
11786 * <li>'F' - jQueryUI theme "footer" classes ('fg-toolbar ui-widget-header ui-corner-bl ui-corner-br ui-helper-clearfix')</li>
11787 * </ul>
11788 * </li>
11789 * <li>The following syntax is expected:
11790 * <ul>
11791 * <li>'<' and '>' - div elements</li>
11792 * <li>'<"class" and '>' - div with a class</li>
11793 * <li>'<"#id" and '>' - div with an ID</li>
11794 * </ul>
11795 * </li>
11796 * <li>Examples:
11797 * <ul>
11798 * <li>'<"wrapper"flipt>'</li>
11799 * <li>'<lf<t>ip>'</li>
11800 * </ul>
11801 * </li>
11802 * </ul>
11803 * @type string
11804 * @default lfrtip <i>(when `jQueryUI` is false)</i> <b>or</b>
11805 * <"H"lfr>t<"F"ip> <i>(when `jQueryUI` is true)</i>
11806 *
11807 * @dtopt Options
11808 * @name DataTable.defaults.dom
11809 *
11810 * @example
11811 * $(document).ready( function() {
11812 * $('#example').dataTable( {
11813 * "dom": '<"top"i>rt<"bottom"flp><"clear">'
11814 * } );
11815 * } );
11816 */
11817 "sDom": "lfrtip",
11820 /**
11821 * Search delay option. This will throttle full table searches that use the
11822 * DataTables provided search input element (it does not effect calls to
11823 * `dt-api search()`, providing a delay before the search is made.
11824 * @type integer
11825 * @default 0
11826 *
11827 * @dtopt Options
11828 * @name DataTable.defaults.searchDelay
11829 *
11830 * @example
11831 * $(document).ready( function() {
11832 * $('#example').dataTable( {
11833 * "searchDelay": 200
11834 * } );
11835 * } )
11836 */
11837 "searchDelay": null,
11840 /**
11841 * DataTables features four different built-in options for the buttons to
11842 * display for pagination control:
11843 *
11844 * * `simple` - 'Previous' and 'Next' buttons only
11845 * * 'simple_numbers` - 'Previous' and 'Next' buttons, plus page numbers
11846 * * `full` - 'First', 'Previous', 'Next' and 'Last' buttons
11847 * * `full_numbers` - 'First', 'Previous', 'Next' and 'Last' buttons, plus
11848 * page numbers
11849 *
11850 * Further methods can be added using {@link DataTable.ext.oPagination}.
11851 * @type string
11852 * @default simple_numbers
11853 *
11854 * @dtopt Options
11855 * @name DataTable.defaults.pagingType
11856 *
11857 * @example
11858 * $(document).ready( function() {
11859 * $('#example').dataTable( {
11860 * "pagingType": "full_numbers"
11861 * } );
11862 * } )
11863 */
11864 "sPaginationType": "simple_numbers",
11867 /**
11868 * Enable horizontal scrolling. When a table is too wide to fit into a
11869 * certain layout, or you have a large number of columns in the table, you
11870 * can enable x-scrolling to show the table in a viewport, which can be
11871 * scrolled. This property can be `true` which will allow the table to
11872 * scroll horizontally when needed, or any CSS unit, or a number (in which
11873 * case it will be treated as a pixel measurement). Setting as simply `true`
11874 * is recommended.
11875 * @type boolean|string
11876 * @default <i>blank string - i.e. disabled</i>
11877 *
11878 * @dtopt Features
11879 * @name DataTable.defaults.scrollX
11880 *
11881 * @example
11882 * $(document).ready( function() {
11883 * $('#example').dataTable( {
11884 * "scrollX": true,
11885 * "scrollCollapse": true
11886 * } );
11887 * } );
11888 */
11889 "sScrollX": "",
11892 /**
11893 * This property can be used to force a DataTable to use more width than it
11894 * might otherwise do when x-scrolling is enabled. For example if you have a
11895 * table which requires to be well spaced, this parameter is useful for
11896 * "over-sizing" the table, and thus forcing scrolling. This property can by
11897 * any CSS unit, or a number (in which case it will be treated as a pixel
11898 * measurement).
11899 * @type string
11900 * @default <i>blank string - i.e. disabled</i>
11901 *
11902 * @dtopt Options
11903 * @name DataTable.defaults.scrollXInner
11904 *
11905 * @example
11906 * $(document).ready( function() {
11907 * $('#example').dataTable( {
11908 * "scrollX": "100%",
11909 * "scrollXInner": "110%"
11910 * } );
11911 * } );
11912 */
11913 "sScrollXInner": "",
11916 /**
11917 * Enable vertical scrolling. Vertical scrolling will constrain the DataTable
11918 * to the given height, and enable scrolling for any data which overflows the
11919 * current viewport. This can be used as an alternative to paging to display
11920 * a lot of data in a small area (although paging and scrolling can both be
11921 * enabled at the same time). This property can be any CSS unit, or a number
11922 * (in which case it will be treated as a pixel measurement).
11923 * @type string
11924 * @default <i>blank string - i.e. disabled</i>
11925 *
11926 * @dtopt Features
11927 * @name DataTable.defaults.scrollY
11928 *
11929 * @example
11930 * $(document).ready( function() {
11931 * $('#example').dataTable( {
11932 * "scrollY": "200px",
11933 * "paginate": false
11934 * } );
11935 * } );
11936 */
11937 "sScrollY": "",
11940 /**
11941 * __Deprecated__ The functionality provided by this parameter has now been
11942 * superseded by that provided through `ajax`, which should be used instead.
11943 *
11944 * Set the HTTP method that is used to make the Ajax call for server-side
11945 * processing or Ajax sourced data.
11946 * @type string
11947 * @default GET
11948 *
11949 * @dtopt Options
11950 * @dtopt Server-side
11951 * @name DataTable.defaults.serverMethod
11952 *
11953 * @deprecated 1.10. Please use `ajax` for this functionality now.
11954 */
11955 "sServerMethod": "GET",
11958 /**
11959 * DataTables makes use of renderers when displaying HTML elements for
11960 * a table. These renderers can be added or modified by plug-ins to
11961 * generate suitable mark-up for a site. For example the Bootstrap
11962 * integration plug-in for DataTables uses a paging button renderer to
11963 * display pagination buttons in the mark-up required by Bootstrap.
11964 *
11965 * For further information about the renderers available see
11966 * DataTable.ext.renderer
11967 * @type string|object
11968 * @default null
11969 *
11970 * @name DataTable.defaults.renderer
11971 *
11972 */
11973 "renderer": null,
11976 /**
11977 * Set the data property name that DataTables should use to get a row's id
11978 * to set as the `id` property in the node.
11979 * @type string
11980 * @default DT_RowId
11981 *
11982 * @name DataTable.defaults.rowId
11983 */
11984 "rowId": "DT_RowId"
11985 };
11987 _fnHungarianMap( DataTable.defaults );
11991 /*
11992 * Developer note - See note in model.defaults.js about the use of Hungarian
11993 * notation and camel case.
11994 */
11996 /**
11997 * Column options that can be given to DataTables at initialisation time.
11998 * @namespace
11999 */
12000 DataTable.defaults.column = {
12001 /**
12002 * Define which column(s) an order will occur on for this column. This
12003 * allows a column's ordering to take multiple columns into account when
12004 * doing a sort or use the data from a different column. For example first
12005 * name / last name columns make sense to do a multi-column sort over the
12006 * two columns.
12007 * @type array|int
12008 * @default null <i>Takes the value of the column index automatically</i>
12009 *
12010 * @name DataTable.defaults.column.orderData
12011 * @dtopt Columns
12012 *
12013 * @example
12014 * // Using `columnDefs`
12015 * $(document).ready( function() {
12016 * $('#example').dataTable( {
12017 * "columnDefs": [
12018 * { "orderData": [ 0, 1 ], "targets": [ 0 ] },
12019 * { "orderData": [ 1, 0 ], "targets": [ 1 ] },
12020 * { "orderData": 2, "targets": [ 2 ] }
12021 * ]
12022 * } );
12023 * } );
12024 *
12025 * @example
12026 * // Using `columns`
12027 * $(document).ready( function() {
12028 * $('#example').dataTable( {
12029 * "columns": [
12030 * { "orderData": [ 0, 1 ] },
12031 * { "orderData": [ 1, 0 ] },
12032 * { "orderData": 2 },
12033 * null,
12034 * null
12035 * ]
12036 * } );
12037 * } );
12038 */
12039 "aDataSort": null,
12040 "iDataSort": -1,
12043 /**
12044 * You can control the default ordering direction, and even alter the
12045 * behaviour of the sort handler (i.e. only allow ascending ordering etc)
12046 * using this parameter.
12047 * @type array
12048 * @default [ 'asc', 'desc' ]
12049 *
12050 * @name DataTable.defaults.column.orderSequence
12051 * @dtopt Columns
12052 *
12053 * @example
12054 * // Using `columnDefs`
12055 * $(document).ready( function() {
12056 * $('#example').dataTable( {
12057 * "columnDefs": [
12058 * { "orderSequence": [ "asc" ], "targets": [ 1 ] },
12059 * { "orderSequence": [ "desc", "asc", "asc" ], "targets": [ 2 ] },
12060 * { "orderSequence": [ "desc" ], "targets": [ 3 ] }
12061 * ]
12062 * } );
12063 * } );
12064 *
12065 * @example
12066 * // Using `columns`
12067 * $(document).ready( function() {
12068 * $('#example').dataTable( {
12069 * "columns": [
12070 * null,
12071 * { "orderSequence": [ "asc" ] },
12072 * { "orderSequence": [ "desc", "asc", "asc" ] },
12073 * { "orderSequence": [ "desc" ] },
12074 * null
12075 * ]
12076 * } );
12077 * } );
12078 */
12079 "asSorting": [ 'asc', 'desc' ],
12082 /**
12083 * Enable or disable filtering on the data in this column.
12084 * @type boolean
12085 * @default true
12086 *
12087 * @name DataTable.defaults.column.searchable
12088 * @dtopt Columns
12089 *
12090 * @example
12091 * // Using `columnDefs`
12092 * $(document).ready( function() {
12093 * $('#example').dataTable( {
12094 * "columnDefs": [
12095 * { "searchable": false, "targets": [ 0 ] }
12096 * ] } );
12097 * } );
12098 *
12099 * @example
12100 * // Using `columns`
12101 * $(document).ready( function() {
12102 * $('#example').dataTable( {
12103 * "columns": [
12104 * { "searchable": false },
12105 * null,
12106 * null,
12107 * null,
12108 * null
12109 * ] } );
12110 * } );
12111 */
12112 "bSearchable": true,
12115 /**
12116 * Enable or disable ordering on this column.
12117 * @type boolean
12118 * @default true
12119 *
12120 * @name DataTable.defaults.column.orderable
12121 * @dtopt Columns
12122 *
12123 * @example
12124 * // Using `columnDefs`
12125 * $(document).ready( function() {
12126 * $('#example').dataTable( {
12127 * "columnDefs": [
12128 * { "orderable": false, "targets": [ 0 ] }
12129 * ] } );
12130 * } );
12131 *
12132 * @example
12133 * // Using `columns`
12134 * $(document).ready( function() {
12135 * $('#example').dataTable( {
12136 * "columns": [
12137 * { "orderable": false },
12138 * null,
12139 * null,
12140 * null,
12141 * null
12142 * ] } );
12143 * } );
12144 */
12145 "bSortable": true,
12148 /**
12149 * Enable or disable the display of this column.
12150 * @type boolean
12151 * @default true
12152 *
12153 * @name DataTable.defaults.column.visible
12154 * @dtopt Columns
12155 *
12156 * @example
12157 * // Using `columnDefs`
12158 * $(document).ready( function() {
12159 * $('#example').dataTable( {
12160 * "columnDefs": [
12161 * { "visible": false, "targets": [ 0 ] }
12162 * ] } );
12163 * } );
12164 *
12165 * @example
12166 * // Using `columns`
12167 * $(document).ready( function() {
12168 * $('#example').dataTable( {
12169 * "columns": [
12170 * { "visible": false },
12171 * null,
12172 * null,
12173 * null,
12174 * null
12175 * ] } );
12176 * } );
12177 */
12178 "bVisible": true,
12181 /**
12182 * Developer definable function that is called whenever a cell is created (Ajax source,
12183 * etc) or processed for input (DOM source). This can be used as a compliment to mRender
12184 * allowing you to modify the DOM element (add background colour for example) when the
12185 * element is available.
12186 * @type function
12187 * @param {element} td The TD node that has been created
12188 * @param {*} cellData The Data for the cell
12189 * @param {array|object} rowData The data for the whole row
12190 * @param {int} row The row index for the aoData data store
12191 * @param {int} col The column index for aoColumns
12192 *
12193 * @name DataTable.defaults.column.createdCell
12194 * @dtopt Columns
12195 *
12196 * @example
12197 * $(document).ready( function() {
12198 * $('#example').dataTable( {
12199 * "columnDefs": [ {
12200 * "targets": [3],
12201 * "createdCell": function (td, cellData, rowData, row, col) {
12202 * if ( cellData == "1.7" ) {
12203 * $(td).css('color', 'blue')
12204 * }
12205 * }
12206 * } ]
12207 * });
12208 * } );
12209 */
12210 "fnCreatedCell": null,
12213 /**
12214 * This parameter has been replaced by `data` in DataTables to ensure naming
12215 * consistency. `dataProp` can still be used, as there is backwards
12216 * compatibility in DataTables for this option, but it is strongly
12217 * recommended that you use `data` in preference to `dataProp`.
12218 * @name DataTable.defaults.column.dataProp
12219 */
12222 /**
12223 * This property can be used to read data from any data source property,
12224 * including deeply nested objects / properties. `data` can be given in a
12225 * number of different ways which effect its behaviour:
12226 *
12227 * * `integer` - treated as an array index for the data source. This is the
12228 * default that DataTables uses (incrementally increased for each column).
12229 * * `string` - read an object property from the data source. There are
12230 * three 'special' options that can be used in the string to alter how
12231 * DataTables reads the data from the source object:
12232 * * `.` - Dotted Javascript notation. Just as you use a `.` in
12233 * Javascript to read from nested objects, so to can the options
12234 * specified in `data`. For example: `browser.version` or
12235 * `browser.name`. If your object parameter name contains a period, use
12236 * `\\` to escape it - i.e. `first\\.name`.
12237 * * `[]` - Array notation. DataTables can automatically combine data
12238 * from and array source, joining the data with the characters provided
12239 * between the two brackets. For example: `name[, ]` would provide a
12240 * comma-space separated list from the source array. If no characters
12241 * are provided between the brackets, the original array source is
12242 * returned.
12243 * * `()` - Function notation. Adding `()` to the end of a parameter will
12244 * execute a function of the name given. For example: `browser()` for a
12245 * simple function on the data source, `browser.version()` for a
12246 * function in a nested property or even `browser().version` to get an
12247 * object property if the function called returns an object. Note that
12248 * function notation is recommended for use in `render` rather than
12249 * `data` as it is much simpler to use as a renderer.
12250 * * `null` - use the original data source for the row rather than plucking
12251 * data directly from it. This action has effects on two other
12252 * initialisation options:
12253 * * `defaultContent` - When null is given as the `data` option and
12254 * `defaultContent` is specified for the column, the value defined by
12255 * `defaultContent` will be used for the cell.
12256 * * `render` - When null is used for the `data` option and the `render`
12257 * option is specified for the column, the whole data source for the
12258 * row is used for the renderer.
12259 * * `function` - the function given will be executed whenever DataTables
12260 * needs to set or get the data for a cell in the column. The function
12261 * takes three parameters:
12262 * * Parameters:
12263 * * `{array|object}` The data source for the row
12264 * * `{string}` The type call data requested - this will be 'set' when
12265 * setting data or 'filter', 'display', 'type', 'sort' or undefined
12266 * when gathering data. Note that when `undefined` is given for the
12267 * type DataTables expects to get the raw data for the object back<
12268 * * `{*}` Data to set when the second parameter is 'set'.
12269 * * Return:
12270 * * The return value from the function is not required when 'set' is
12271 * the type of call, but otherwise the return is what will be used
12272 * for the data requested.
12273 *
12274 * Note that `data` is a getter and setter option. If you just require
12275 * formatting of data for output, you will likely want to use `render` which
12276 * is simply a getter and thus simpler to use.
12277 *
12278 * Note that prior to DataTables 1.9.2 `data` was called `mDataProp`. The
12279 * name change reflects the flexibility of this property and is consistent
12280 * with the naming of mRender. If 'mDataProp' is given, then it will still
12281 * be used by DataTables, as it automatically maps the old name to the new
12282 * if required.
12283 *
12284 * @type string|int|function|null
12285 * @default null <i>Use automatically calculated column index</i>
12286 *
12287 * @name DataTable.defaults.column.data
12288 * @dtopt Columns
12289 *
12290 * @example
12291 * // Read table data from objects
12292 * // JSON structure for each row:
12293 * // {
12294 * // "engine": {value},
12295 * // "browser": {value},
12296 * // "platform": {value},
12297 * // "version": {value},
12298 * // "grade": {value}
12299 * // }
12300 * $(document).ready( function() {
12301 * $('#example').dataTable( {
12302 * "ajaxSource": "sources/objects.txt",
12303 * "columns": [
12304 * { "data": "engine" },
12305 * { "data": "browser" },
12306 * { "data": "platform" },
12307 * { "data": "version" },
12308 * { "data": "grade" }
12309 * ]
12310 * } );
12311 * } );
12312 *
12313 * @example
12314 * // Read information from deeply nested objects
12315 * // JSON structure for each row:
12316 * // {
12317 * // "engine": {value},
12318 * // "browser": {value},
12319 * // "platform": {
12320 * // "inner": {value}
12321 * // },
12322 * // "details": [
12323 * // {value}, {value}
12324 * // ]
12325 * // }
12326 * $(document).ready( function() {
12327 * $('#example').dataTable( {
12328 * "ajaxSource": "sources/deep.txt",
12329 * "columns": [
12330 * { "data": "engine" },
12331 * { "data": "browser" },
12332 * { "data": "platform.inner" },
12333 * { "data": "platform.details.0" },
12334 * { "data": "platform.details.1" }
12335 * ]
12336 * } );
12337 * } );
12338 *
12339 * @example
12340 * // Using `data` as a function to provide different information for
12341 * // sorting, filtering and display. In this case, currency (price)
12342 * $(document).ready( function() {
12343 * $('#example').dataTable( {
12344 * "columnDefs": [ {
12345 * "targets": [ 0 ],
12346 * "data": function ( source, type, val ) {
12347 * if (type === 'set') {
12348 * source.price = val;
12349 * // Store the computed dislay and filter values for efficiency
12350 * source.price_display = val=="" ? "" : "$"+numberFormat(val);
12351 * source.price_filter = val=="" ? "" : "$"+numberFormat(val)+" "+val;
12352 * return;
12353 * }
12354 * else if (type === 'display') {
12355 * return source.price_display;
12356 * }
12357 * else if (type === 'filter') {
12358 * return source.price_filter;
12359 * }
12360 * // 'sort', 'type' and undefined all just use the integer
12361 * return source.price;
12362 * }
12363 * } ]
12364 * } );
12365 * } );
12366 *
12367 * @example
12368 * // Using default content
12369 * $(document).ready( function() {
12370 * $('#example').dataTable( {
12371 * "columnDefs": [ {
12372 * "targets": [ 0 ],
12373 * "data": null,
12374 * "defaultContent": "Click to edit"
12375 * } ]
12376 * } );
12377 * } );
12378 *
12379 * @example
12380 * // Using array notation - outputting a list from an array
12381 * $(document).ready( function() {
12382 * $('#example').dataTable( {
12383 * "columnDefs": [ {
12384 * "targets": [ 0 ],
12385 * "data": "name[, ]"
12386 * } ]
12387 * } );
12388 * } );
12389 *
12390 */
12391 "mData": null,
12394 /**
12395 * This property is the rendering partner to `data` and it is suggested that
12396 * when you want to manipulate data for display (including filtering,
12397 * sorting etc) without altering the underlying data for the table, use this
12398 * property. `render` can be considered to be the the read only companion to
12399 * `data` which is read / write (then as such more complex). Like `data`
12400 * this option can be given in a number of different ways to effect its
12401 * behaviour:
12402 *
12403 * * `integer` - treated as an array index for the data source. This is the
12404 * default that DataTables uses (incrementally increased for each column).
12405 * * `string` - read an object property from the data source. There are
12406 * three 'special' options that can be used in the string to alter how
12407 * DataTables reads the data from the source object:
12408 * * `.` - Dotted Javascript notation. Just as you use a `.` in
12409 * Javascript to read from nested objects, so to can the options
12410 * specified in `data`. For example: `browser.version` or
12411 * `browser.name`. If your object parameter name contains a period, use
12412 * `\\` to escape it - i.e. `first\\.name`.
12413 * * `[]` - Array notation. DataTables can automatically combine data
12414 * from and array source, joining the data with the characters provided
12415 * between the two brackets. For example: `name[, ]` would provide a
12416 * comma-space separated list from the source array. If no characters
12417 * are provided between the brackets, the original array source is
12418 * returned.
12419 * * `()` - Function notation. Adding `()` to the end of a parameter will
12420 * execute a function of the name given. For example: `browser()` for a
12421 * simple function on the data source, `browser.version()` for a
12422 * function in a nested property or even `browser().version` to get an
12423 * object property if the function called returns an object.
12424 * * `object` - use different data for the different data types requested by
12425 * DataTables ('filter', 'display', 'type' or 'sort'). The property names
12426 * of the object is the data type the property refers to and the value can
12427 * defined using an integer, string or function using the same rules as
12428 * `render` normally does. Note that an `_` option _must_ be specified.
12429 * This is the default value to use if you haven't specified a value for
12430 * the data type requested by DataTables.
12431 * * `function` - the function given will be executed whenever DataTables
12432 * needs to set or get the data for a cell in the column. The function
12433 * takes three parameters:
12434 * * Parameters:
12435 * * {array|object} The data source for the row (based on `data`)
12436 * * {string} The type call data requested - this will be 'filter',
12437 * 'display', 'type' or 'sort'.
12438 * * {array|object} The full data source for the row (not based on
12439 * `data`)
12440 * * Return:
12441 * * The return value from the function is what will be used for the
12442 * data requested.
12443 *
12444 * @type string|int|function|object|null
12445 * @default null Use the data source value.
12446 *
12447 * @name DataTable.defaults.column.render
12448 * @dtopt Columns
12449 *
12450 * @example
12451 * // Create a comma separated list from an array of objects
12452 * $(document).ready( function() {
12453 * $('#example').dataTable( {
12454 * "ajaxSource": "sources/deep.txt",
12455 * "columns": [
12456 * { "data": "engine" },
12457 * { "data": "browser" },
12458 * {
12459 * "data": "platform",
12460 * "render": "[, ].name"
12461 * }
12462 * ]
12463 * } );
12464 * } );
12465 *
12466 * @example
12467 * // Execute a function to obtain data
12468 * $(document).ready( function() {
12469 * $('#example').dataTable( {
12470 * "columnDefs": [ {
12471 * "targets": [ 0 ],
12472 * "data": null, // Use the full data source object for the renderer's source
12473 * "render": "browserName()"
12474 * } ]
12475 * } );
12476 * } );
12477 *
12478 * @example
12479 * // As an object, extracting different data for the different types
12480 * // This would be used with a data source such as:
12481 * // { "phone": 5552368, "phone_filter": "5552368 555-2368", "phone_display": "555-2368" }
12482 * // Here the `phone` integer is used for sorting and type detection, while `phone_filter`
12483 * // (which has both forms) is used for filtering for if a user inputs either format, while
12484 * // the formatted phone number is the one that is shown in the table.
12485 * $(document).ready( function() {
12486 * $('#example').dataTable( {
12487 * "columnDefs": [ {
12488 * "targets": [ 0 ],
12489 * "data": null, // Use the full data source object for the renderer's source
12490 * "render": {
12491 * "_": "phone",
12492 * "filter": "phone_filter",
12493 * "display": "phone_display"
12494 * }
12495 * } ]
12496 * } );
12497 * } );
12498 *
12499 * @example
12500 * // Use as a function to create a link from the data source
12501 * $(document).ready( function() {
12502 * $('#example').dataTable( {
12503 * "columnDefs": [ {
12504 * "targets": [ 0 ],
12505 * "data": "download_link",
12506 * "render": function ( data, type, full ) {
12507 * return '<a href="'+data+'">Download</a>';
12508 * }
12509 * } ]
12510 * } );
12511 * } );
12512 */
12513 "mRender": null,
12516 /**
12517 * Change the cell type created for the column - either TD cells or TH cells. This
12518 * can be useful as TH cells have semantic meaning in the table body, allowing them
12519 * to act as a header for a row (you may wish to add scope='row' to the TH elements).
12520 * @type string
12521 * @default td
12522 *
12523 * @name DataTable.defaults.column.cellType
12524 * @dtopt Columns
12525 *
12526 * @example
12527 * // Make the first column use TH cells
12528 * $(document).ready( function() {
12529 * $('#example').dataTable( {
12530 * "columnDefs": [ {
12531 * "targets": [ 0 ],
12532 * "cellType": "th"
12533 * } ]
12534 * } );
12535 * } );
12536 */
12537 "sCellType": "td",
12540 /**
12541 * Class to give to each cell in this column.
12542 * @type string
12543 * @default <i>Empty string</i>
12544 *
12545 * @name DataTable.defaults.column.class
12546 * @dtopt Columns
12547 *
12548 * @example
12549 * // Using `columnDefs`
12550 * $(document).ready( function() {
12551 * $('#example').dataTable( {
12552 * "columnDefs": [
12553 * { "class": "my_class", "targets": [ 0 ] }
12554 * ]
12555 * } );
12556 * } );
12557 *
12558 * @example
12559 * // Using `columns`
12560 * $(document).ready( function() {
12561 * $('#example').dataTable( {
12562 * "columns": [
12563 * { "class": "my_class" },
12564 * null,
12565 * null,
12566 * null,
12567 * null
12568 * ]
12569 * } );
12570 * } );
12571 */
12572 "sClass": "",
12574 /**
12575 * When DataTables calculates the column widths to assign to each column,
12576 * it finds the longest string in each column and then constructs a
12577 * temporary table and reads the widths from that. The problem with this
12578 * is that "mmm" is much wider then "iiii", but the latter is a longer
12579 * string - thus the calculation can go wrong (doing it properly and putting
12580 * it into an DOM object and measuring that is horribly(!) slow). Thus as
12581 * a "work around" we provide this option. It will append its value to the
12582 * text that is found to be the longest string for the column - i.e. padding.
12583 * Generally you shouldn't need this!
12584 * @type string
12585 * @default <i>Empty string<i>
12586 *
12587 * @name DataTable.defaults.column.contentPadding
12588 * @dtopt Columns
12589 *
12590 * @example
12591 * // Using `columns`
12592 * $(document).ready( function() {
12593 * $('#example').dataTable( {
12594 * "columns": [
12595 * null,
12596 * null,
12597 * null,
12598 * {
12599 * "contentPadding": "mmm"
12600 * }
12601 * ]
12602 * } );
12603 * } );
12604 */
12605 "sContentPadding": "",
12608 /**
12609 * Allows a default value to be given for a column's data, and will be used
12610 * whenever a null data source is encountered (this can be because `data`
12611 * is set to null, or because the data source itself is null).
12612 * @type string
12613 * @default null
12614 *
12615 * @name DataTable.defaults.column.defaultContent
12616 * @dtopt Columns
12617 *
12618 * @example
12619 * // Using `columnDefs`
12620 * $(document).ready( function() {
12621 * $('#example').dataTable( {
12622 * "columnDefs": [
12623 * {
12624 * "data": null,
12625 * "defaultContent": "Edit",
12626 * "targets": [ -1 ]
12627 * }
12628 * ]
12629 * } );
12630 * } );
12631 *
12632 * @example
12633 * // Using `columns`
12634 * $(document).ready( function() {
12635 * $('#example').dataTable( {
12636 * "columns": [
12637 * null,
12638 * null,
12639 * null,
12640 * {
12641 * "data": null,
12642 * "defaultContent": "Edit"
12643 * }
12644 * ]
12645 * } );
12646 * } );
12647 */
12648 "sDefaultContent": null,
12651 /**
12652 * This parameter is only used in DataTables' server-side processing. It can
12653 * be exceptionally useful to know what columns are being displayed on the
12654 * client side, and to map these to database fields. When defined, the names
12655 * also allow DataTables to reorder information from the server if it comes
12656 * back in an unexpected order (i.e. if you switch your columns around on the
12657 * client-side, your server-side code does not also need updating).
12658 * @type string
12659 * @default <i>Empty string</i>
12660 *
12661 * @name DataTable.defaults.column.name
12662 * @dtopt Columns
12663 *
12664 * @example
12665 * // Using `columnDefs`
12666 * $(document).ready( function() {
12667 * $('#example').dataTable( {
12668 * "columnDefs": [
12669 * { "name": "engine", "targets": [ 0 ] },
12670 * { "name": "browser", "targets": [ 1 ] },
12671 * { "name": "platform", "targets": [ 2 ] },
12672 * { "name": "version", "targets": [ 3 ] },
12673 * { "name": "grade", "targets": [ 4 ] }
12674 * ]
12675 * } );
12676 * } );
12677 *
12678 * @example
12679 * // Using `columns`
12680 * $(document).ready( function() {
12681 * $('#example').dataTable( {
12682 * "columns": [
12683 * { "name": "engine" },
12684 * { "name": "browser" },
12685 * { "name": "platform" },
12686 * { "name": "version" },
12687 * { "name": "grade" }
12688 * ]
12689 * } );
12690 * } );
12691 */
12692 "sName": "",
12695 /**
12696 * Defines a data source type for the ordering which can be used to read
12697 * real-time information from the table (updating the internally cached
12698 * version) prior to ordering. This allows ordering to occur on user
12699 * editable elements such as form inputs.
12700 * @type string
12701 * @default std
12702 *
12703 * @name DataTable.defaults.column.orderDataType
12704 * @dtopt Columns
12705 *
12706 * @example
12707 * // Using `columnDefs`
12708 * $(document).ready( function() {
12709 * $('#example').dataTable( {
12710 * "columnDefs": [
12711 * { "orderDataType": "dom-text", "targets": [ 2, 3 ] },
12712 * { "type": "numeric", "targets": [ 3 ] },
12713 * { "orderDataType": "dom-select", "targets": [ 4 ] },
12714 * { "orderDataType": "dom-checkbox", "targets": [ 5 ] }
12715 * ]
12716 * } );
12717 * } );
12718 *
12719 * @example
12720 * // Using `columns`
12721 * $(document).ready( function() {
12722 * $('#example').dataTable( {
12723 * "columns": [
12724 * null,
12725 * null,
12726 * { "orderDataType": "dom-text" },
12727 * { "orderDataType": "dom-text", "type": "numeric" },
12728 * { "orderDataType": "dom-select" },
12729 * { "orderDataType": "dom-checkbox" }
12730 * ]
12731 * } );
12732 * } );
12733 */
12734 "sSortDataType": "std",
12737 /**
12738 * The title of this column.
12739 * @type string
12740 * @default null <i>Derived from the 'TH' value for this column in the
12741 * original HTML table.</i>
12742 *
12743 * @name DataTable.defaults.column.title
12744 * @dtopt Columns
12745 *
12746 * @example
12747 * // Using `columnDefs`
12748 * $(document).ready( function() {
12749 * $('#example').dataTable( {
12750 * "columnDefs": [
12751 * { "title": "My column title", "targets": [ 0 ] }
12752 * ]
12753 * } );
12754 * } );
12755 *
12756 * @example
12757 * // Using `columns`
12758 * $(document).ready( function() {
12759 * $('#example').dataTable( {
12760 * "columns": [
12761 * { "title": "My column title" },
12762 * null,
12763 * null,
12764 * null,
12765 * null
12766 * ]
12767 * } );
12768 * } );
12769 */
12770 "sTitle": null,
12773 /**
12774 * The type allows you to specify how the data for this column will be
12775 * ordered. Four types (string, numeric, date and html (which will strip
12776 * HTML tags before ordering)) are currently available. Note that only date
12777 * formats understood by Javascript's Date() object will be accepted as type
12778 * date. For example: "Mar 26, 2008 5:03 PM". May take the values: 'string',
12779 * 'numeric', 'date' or 'html' (by default). Further types can be adding
12780 * through plug-ins.
12781 * @type string
12782 * @default null <i>Auto-detected from raw data</i>
12783 *
12784 * @name DataTable.defaults.column.type
12785 * @dtopt Columns
12786 *
12787 * @example
12788 * // Using `columnDefs`
12789 * $(document).ready( function() {
12790 * $('#example').dataTable( {
12791 * "columnDefs": [
12792 * { "type": "html", "targets": [ 0 ] }
12793 * ]
12794 * } );
12795 * } );
12796 *
12797 * @example
12798 * // Using `columns`
12799 * $(document).ready( function() {
12800 * $('#example').dataTable( {
12801 * "columns": [
12802 * { "type": "html" },
12803 * null,
12804 * null,
12805 * null,
12806 * null
12807 * ]
12808 * } );
12809 * } );
12810 */
12811 "sType": null,
12814 /**
12815 * Defining the width of the column, this parameter may take any CSS value
12816 * (3em, 20px etc). DataTables applies 'smart' widths to columns which have not
12817 * been given a specific width through this interface ensuring that the table
12818 * remains readable.
12819 * @type string
12820 * @default null <i>Automatic</i>
12821 *
12822 * @name DataTable.defaults.column.width
12823 * @dtopt Columns
12824 *
12825 * @example
12826 * // Using `columnDefs`
12827 * $(document).ready( function() {
12828 * $('#example').dataTable( {
12829 * "columnDefs": [
12830 * { "width": "20%", "targets": [ 0 ] }
12831 * ]
12832 * } );
12833 * } );
12834 *
12835 * @example
12836 * // Using `columns`
12837 * $(document).ready( function() {
12838 * $('#example').dataTable( {
12839 * "columns": [
12840 * { "width": "20%" },
12841 * null,
12842 * null,
12843 * null,
12844 * null
12845 * ]
12846 * } );
12847 * } );
12848 */
12849 "sWidth": null
12850 };
12852 _fnHungarianMap( DataTable.defaults.column );
12856 /**
12857 * DataTables settings object - this holds all the information needed for a
12858 * given table, including configuration, data and current application of the
12859 * table options. DataTables does not have a single instance for each DataTable
12860 * with the settings attached to that instance, but rather instances of the
12861 * DataTable "class" are created on-the-fly as needed (typically by a
12862 * $().dataTable() call) and the settings object is then applied to that
12863 * instance.
12864 *
12865 * Note that this object is related to {@link DataTable.defaults} but this
12866 * one is the internal data store for DataTables's cache of columns. It should
12867 * NOT be manipulated outside of DataTables. Any configuration should be done
12868 * through the initialisation options.
12869 * @namespace
12870 * @todo Really should attach the settings object to individual instances so we
12871 * don't need to create new instances on each $().dataTable() call (if the
12872 * table already exists). It would also save passing oSettings around and
12873 * into every single function. However, this is a very significant
12874 * architecture change for DataTables and will almost certainly break
12875 * backwards compatibility with older installations. This is something that
12876 * will be done in 2.0.
12877 */
12878 DataTable.models.oSettings = {
12879 /**
12880 * Primary features of DataTables and their enablement state.
12881 * @namespace
12882 */
12883 "oFeatures": {
12885 /**
12886 * Flag to say if DataTables should automatically try to calculate the
12887 * optimum table and columns widths (true) or not (false).
12888 * Note that this parameter will be set by the initialisation routine. To
12889 * set a default use {@link DataTable.defaults}.
12890 * @type boolean
12891 */
12892 "bAutoWidth": null,
12894 /**
12895 * Delay the creation of TR and TD elements until they are actually
12896 * needed by a driven page draw. This can give a significant speed
12897 * increase for Ajax source and Javascript source data, but makes no
12898 * difference at all fro DOM and server-side processing tables.
12899 * Note that this parameter will be set by the initialisation routine. To
12900 * set a default use {@link DataTable.defaults}.
12901 * @type boolean
12902 */
12903 "bDeferRender": null,
12905 /**
12906 * Enable filtering on the table or not. Note that if this is disabled
12907 * then there is no filtering at all on the table, including fnFilter.
12908 * To just remove the filtering input use sDom and remove the 'f' option.
12909 * Note that this parameter will be set by the initialisation routine. To
12910 * set a default use {@link DataTable.defaults}.
12911 * @type boolean
12912 */
12913 "bFilter": null,
12915 /**
12916 * Table information element (the 'Showing x of y records' div) enable
12917 * flag.
12918 * Note that this parameter will be set by the initialisation routine. To
12919 * set a default use {@link DataTable.defaults}.
12920 * @type boolean
12921 */
12922 "bInfo": null,
12924 /**
12925 * Present a user control allowing the end user to change the page size
12926 * when pagination is enabled.
12927 * Note that this parameter will be set by the initialisation routine. To
12928 * set a default use {@link DataTable.defaults}.
12929 * @type boolean
12930 */
12931 "bLengthChange": null,
12933 /**
12934 * Pagination enabled or not. Note that if this is disabled then length
12935 * changing must also be disabled.
12936 * Note that this parameter will be set by the initialisation routine. To
12937 * set a default use {@link DataTable.defaults}.
12938 * @type boolean
12939 */
12940 "bPaginate": null,
12942 /**
12943 * Processing indicator enable flag whenever DataTables is enacting a
12944 * user request - typically an Ajax request for server-side processing.
12945 * Note that this parameter will be set by the initialisation routine. To
12946 * set a default use {@link DataTable.defaults}.
12947 * @type boolean
12948 */
12949 "bProcessing": null,
12951 /**
12952 * Server-side processing enabled flag - when enabled DataTables will
12953 * get all data from the server for every draw - there is no filtering,
12954 * sorting or paging done on the client-side.
12955 * Note that this parameter will be set by the initialisation routine. To
12956 * set a default use {@link DataTable.defaults}.
12957 * @type boolean
12958 */
12959 "bServerSide": null,
12961 /**
12962 * Sorting enablement flag.
12963 * Note that this parameter will be set by the initialisation routine. To
12964 * set a default use {@link DataTable.defaults}.
12965 * @type boolean
12966 */
12967 "bSort": null,
12969 /**
12970 * Multi-column sorting
12971 * Note that this parameter will be set by the initialisation routine. To
12972 * set a default use {@link DataTable.defaults}.
12973 * @type boolean
12974 */
12975 "bSortMulti": null,
12977 /**
12978 * Apply a class to the columns which are being sorted to provide a
12979 * visual highlight or not. This can slow things down when enabled since
12980 * there is a lot of DOM interaction.
12981 * Note that this parameter will be set by the initialisation routine. To
12982 * set a default use {@link DataTable.defaults}.
12983 * @type boolean
12984 */
12985 "bSortClasses": null,
12987 /**
12988 * State saving enablement flag.
12989 * Note that this parameter will be set by the initialisation routine. To
12990 * set a default use {@link DataTable.defaults}.
12991 * @type boolean
12992 */
12993 "bStateSave": null
12994 },
12997 /**
12998 * Scrolling settings for a table.
12999 * @namespace
13000 */
13001 "oScroll": {
13002 /**
13003 * When the table is shorter in height than sScrollY, collapse the
13004 * table container down to the height of the table (when true).
13005 * Note that this parameter will be set by the initialisation routine. To
13006 * set a default use {@link DataTable.defaults}.
13007 * @type boolean
13008 */
13009 "bCollapse": null,
13011 /**
13012 * Width of the scrollbar for the web-browser's platform. Calculated
13013 * during table initialisation.
13014 * @type int
13015 * @default 0
13016 */
13017 "iBarWidth": 0,
13019 /**
13020 * Viewport width for horizontal scrolling. Horizontal scrolling is
13021 * disabled if an empty string.
13022 * Note that this parameter will be set by the initialisation routine. To
13023 * set a default use {@link DataTable.defaults}.
13024 * @type string
13025 */
13026 "sX": null,
13028 /**
13029 * Width to expand the table to when using x-scrolling. Typically you
13030 * should not need to use this.
13031 * Note that this parameter will be set by the initialisation routine. To
13032 * set a default use {@link DataTable.defaults}.
13033 * @type string
13034 * @deprecated
13035 */
13036 "sXInner": null,
13038 /**
13039 * Viewport height for vertical scrolling. Vertical scrolling is disabled
13040 * if an empty string.
13041 * Note that this parameter will be set by the initialisation routine. To
13042 * set a default use {@link DataTable.defaults}.
13043 * @type string
13044 */
13045 "sY": null
13046 },
13048 /**
13049 * Language information for the table.
13050 * @namespace
13051 * @extends DataTable.defaults.oLanguage
13052 */
13053 "oLanguage": {
13054 /**
13055 * Information callback function. See
13056 * {@link DataTable.defaults.fnInfoCallback}
13057 * @type function
13058 * @default null
13059 */
13060 "fnInfoCallback": null
13061 },
13063 /**
13064 * Browser support parameters
13065 * @namespace
13066 */
13067 "oBrowser": {
13068 /**
13069 * Indicate if the browser incorrectly calculates width:100% inside a
13070 * scrolling element (IE6/7)
13071 * @type boolean
13072 * @default false
13073 */
13074 "bScrollOversize": false,
13076 /**
13077 * Determine if the vertical scrollbar is on the right or left of the
13078 * scrolling container - needed for rtl language layout, although not
13079 * all browsers move the scrollbar (Safari).
13080 * @type boolean
13081 * @default false
13082 */
13083 "bScrollbarLeft": false,
13085 /**
13086 * Flag for if `getBoundingClientRect` is fully supported or not
13087 * @type boolean
13088 * @default false
13089 */
13090 "bBounding": false,
13092 /**
13093 * Browser scrollbar width
13094 * @type integer
13095 * @default 0
13096 */
13097 "barWidth": 0
13098 },
13101 "ajax": null,
13104 /**
13105 * Array referencing the nodes which are used for the features. The
13106 * parameters of this object match what is allowed by sDom - i.e.
13107 * <ul>
13108 * <li>'l' - Length changing</li>
13109 * <li>'f' - Filtering input</li>
13110 * <li>'t' - The table!</li>
13111 * <li>'i' - Information</li>
13112 * <li>'p' - Pagination</li>
13113 * <li>'r' - pRocessing</li>
13114 * </ul>
13115 * @type array
13116 * @default []
13117 */
13118 "aanFeatures": [],
13120 /**
13121 * Store data information - see {@link DataTable.models.oRow} for detailed
13122 * information.
13123 * @type array
13124 * @default []
13125 */
13126 "aoData": [],
13128 /**
13129 * Array of indexes which are in the current display (after filtering etc)
13130 * @type array
13131 * @default []
13132 */
13133 "aiDisplay": [],
13135 /**
13136 * Array of indexes for display - no filtering
13137 * @type array
13138 * @default []
13139 */
13140 "aiDisplayMaster": [],
13142 /**
13143 * Map of row ids to data indexes
13144 * @type object
13145 * @default {}
13146 */
13147 "aIds": {},
13149 /**
13150 * Store information about each column that is in use
13151 * @type array
13152 * @default []
13153 */
13154 "aoColumns": [],
13156 /**
13157 * Store information about the table's header
13158 * @type array
13159 * @default []
13160 */
13161 "aoHeader": [],
13163 /**
13164 * Store information about the table's footer
13165 * @type array
13166 * @default []
13167 */
13168 "aoFooter": [],
13170 /**
13171 * Store the applied global search information in case we want to force a
13172 * research or compare the old search to a new one.
13173 * Note that this parameter will be set by the initialisation routine. To
13174 * set a default use {@link DataTable.defaults}.
13175 * @namespace
13176 * @extends DataTable.models.oSearch
13177 */
13178 "oPreviousSearch": {},
13180 /**
13181 * Store the applied search for each column - see
13182 * {@link DataTable.models.oSearch} for the format that is used for the
13183 * filtering information for each column.
13184 * @type array
13185 * @default []
13186 */
13187 "aoPreSearchCols": [],
13189 /**
13190 * Sorting that is applied to the table. Note that the inner arrays are
13191 * used in the following manner:
13192 * <ul>
13193 * <li>Index 0 - column number</li>
13194 * <li>Index 1 - current sorting direction</li>
13195 * </ul>
13196 * Note that this parameter will be set by the initialisation routine. To
13197 * set a default use {@link DataTable.defaults}.
13198 * @type array
13199 * @todo These inner arrays should really be objects
13200 */
13201 "aaSorting": null,
13203 /**
13204 * Sorting that is always applied to the table (i.e. prefixed in front of
13205 * aaSorting).
13206 * Note that this parameter will be set by the initialisation routine. To
13207 * set a default use {@link DataTable.defaults}.
13208 * @type array
13209 * @default []
13210 */
13211 "aaSortingFixed": [],
13213 /**
13214 * Classes to use for the striping of a table.
13215 * Note that this parameter will be set by the initialisation routine. To
13216 * set a default use {@link DataTable.defaults}.
13217 * @type array
13218 * @default []
13219 */
13220 "asStripeClasses": null,
13222 /**
13223 * If restoring a table - we should restore its striping classes as well
13224 * @type array
13225 * @default []
13226 */
13227 "asDestroyStripes": [],
13229 /**
13230 * If restoring a table - we should restore its width
13231 * @type int
13232 * @default 0
13233 */
13234 "sDestroyWidth": 0,
13236 /**
13237 * Callback functions array for every time a row is inserted (i.e. on a draw).
13238 * @type array
13239 * @default []
13240 */
13241 "aoRowCallback": [],
13243 /**
13244 * Callback functions for the header on each draw.
13245 * @type array
13246 * @default []
13247 */
13248 "aoHeaderCallback": [],
13250 /**
13251 * Callback function for the footer on each draw.
13252 * @type array
13253 * @default []
13254 */
13255 "aoFooterCallback": [],
13257 /**
13258 * Array of callback functions for draw callback functions
13259 * @type array
13260 * @default []
13261 */
13262 "aoDrawCallback": [],
13264 /**
13265 * Array of callback functions for row created function
13266 * @type array
13267 * @default []
13268 */
13269 "aoRowCreatedCallback": [],
13271 /**
13272 * Callback functions for just before the table is redrawn. A return of
13273 * false will be used to cancel the draw.
13274 * @type array
13275 * @default []
13276 */
13277 "aoPreDrawCallback": [],
13279 /**
13280 * Callback functions for when the table has been initialised.
13281 * @type array
13282 * @default []
13283 */
13284 "aoInitComplete": [],
13287 /**
13288 * Callbacks for modifying the settings to be stored for state saving, prior to
13289 * saving state.
13290 * @type array
13291 * @default []
13292 */
13293 "aoStateSaveParams": [],
13295 /**
13296 * Callbacks for modifying the settings that have been stored for state saving
13297 * prior to using the stored values to restore the state.
13298 * @type array
13299 * @default []
13300 */
13301 "aoStateLoadParams": [],
13303 /**
13304 * Callbacks for operating on the settings object once the saved state has been
13305 * loaded
13306 * @type array
13307 * @default []
13308 */
13309 "aoStateLoaded": [],
13311 /**
13312 * Cache the table ID for quick access
13313 * @type string
13314 * @default <i>Empty string</i>
13315 */
13316 "sTableId": "",
13318 /**
13319 * The TABLE node for the main table
13320 * @type node
13321 * @default null
13322 */
13323 "nTable": null,
13325 /**
13326 * Permanent ref to the thead element
13327 * @type node
13328 * @default null
13329 */
13330 "nTHead": null,
13332 /**
13333 * Permanent ref to the tfoot element - if it exists
13334 * @type node
13335 * @default null
13336 */
13337 "nTFoot": null,
13339 /**
13340 * Permanent ref to the tbody element
13341 * @type node
13342 * @default null
13343 */
13344 "nTBody": null,
13346 /**
13347 * Cache the wrapper node (contains all DataTables controlled elements)
13348 * @type node
13349 * @default null
13350 */
13351 "nTableWrapper": null,
13353 /**
13354 * Indicate if when using server-side processing the loading of data
13355 * should be deferred until the second draw.
13356 * Note that this parameter will be set by the initialisation routine. To
13357 * set a default use {@link DataTable.defaults}.
13358 * @type boolean
13359 * @default false
13360 */
13361 "bDeferLoading": false,
13363 /**
13364 * Indicate if all required information has been read in
13365 * @type boolean
13366 * @default false
13367 */
13368 "bInitialised": false,
13370 /**
13371 * Information about open rows. Each object in the array has the parameters
13372 * 'nTr' and 'nParent'
13373 * @type array
13374 * @default []
13375 */
13376 "aoOpenRows": [],
13378 /**
13379 * Dictate the positioning of DataTables' control elements - see
13380 * {@link DataTable.model.oInit.sDom}.
13381 * Note that this parameter will be set by the initialisation routine. To
13382 * set a default use {@link DataTable.defaults}.
13383 * @type string
13384 * @default null
13385 */
13386 "sDom": null,
13388 /**
13389 * Search delay (in mS)
13390 * @type integer
13391 * @default null
13392 */
13393 "searchDelay": null,
13395 /**
13396 * Which type of pagination should be used.
13397 * Note that this parameter will be set by the initialisation routine. To
13398 * set a default use {@link DataTable.defaults}.
13399 * @type string
13400 * @default two_button
13401 */
13402 "sPaginationType": "two_button",
13404 /**
13405 * The state duration (for `stateSave`) in seconds.
13406 * Note that this parameter will be set by the initialisation routine. To
13407 * set a default use {@link DataTable.defaults}.
13408 * @type int
13409 * @default 0
13410 */
13411 "iStateDuration": 0,
13413 /**
13414 * Array of callback functions for state saving. Each array element is an
13415 * object with the following parameters:
13416 * <ul>
13417 * <li>function:fn - function to call. Takes two parameters, oSettings
13418 * and the JSON string to save that has been thus far created. Returns
13419 * a JSON string to be inserted into a json object
13420 * (i.e. '"param": [ 0, 1, 2]')</li>
13421 * <li>string:sName - name of callback</li>
13422 * </ul>
13423 * @type array
13424 * @default []
13425 */
13426 "aoStateSave": [],
13428 /**
13429 * Array of callback functions for state loading. Each array element is an
13430 * object with the following parameters:
13431 * <ul>
13432 * <li>function:fn - function to call. Takes two parameters, oSettings
13433 * and the object stored. May return false to cancel state loading</li>
13434 * <li>string:sName - name of callback</li>
13435 * </ul>
13436 * @type array
13437 * @default []
13438 */
13439 "aoStateLoad": [],
13441 /**
13442 * State that was saved. Useful for back reference
13443 * @type object
13444 * @default null
13445 */
13446 "oSavedState": null,
13448 /**
13449 * State that was loaded. Useful for back reference
13450 * @type object
13451 * @default null
13452 */
13453 "oLoadedState": null,
13455 /**
13456 * Source url for AJAX data for the table.
13457 * Note that this parameter will be set by the initialisation routine. To
13458 * set a default use {@link DataTable.defaults}.
13459 * @type string
13460 * @default null
13461 */
13462 "sAjaxSource": null,
13464 /**
13465 * Property from a given object from which to read the table data from. This
13466 * can be an empty string (when not server-side processing), in which case
13467 * it is assumed an an array is given directly.
13468 * Note that this parameter will be set by the initialisation routine. To
13469 * set a default use {@link DataTable.defaults}.
13470 * @type string
13471 */
13472 "sAjaxDataProp": null,
13474 /**
13475 * Note if draw should be blocked while getting data
13476 * @type boolean
13477 * @default true
13478 */
13479 "bAjaxDataGet": true,
13481 /**
13482 * The last jQuery XHR object that was used for server-side data gathering.
13483 * This can be used for working with the XHR information in one of the
13484 * callbacks
13485 * @type object
13486 * @default null
13487 */
13488 "jqXHR": null,
13490 /**
13491 * JSON returned from the server in the last Ajax request
13492 * @type object
13493 * @default undefined
13494 */
13495 "json": undefined,
13497 /**
13498 * Data submitted as part of the last Ajax request
13499 * @type object
13500 * @default undefined
13501 */
13502 "oAjaxData": undefined,
13504 /**
13505 * Function to get the server-side data.
13506 * Note that this parameter will be set by the initialisation routine. To
13507 * set a default use {@link DataTable.defaults}.
13508 * @type function
13509 */
13510 "fnServerData": null,
13512 /**
13513 * Functions which are called prior to sending an Ajax request so extra
13514 * parameters can easily be sent to the server
13515 * @type array
13516 * @default []
13517 */
13518 "aoServerParams": [],
13520 /**
13521 * Send the XHR HTTP method - GET or POST (could be PUT or DELETE if
13522 * required).
13523 * Note that this parameter will be set by the initialisation routine. To
13524 * set a default use {@link DataTable.defaults}.
13525 * @type string
13526 */
13527 "sServerMethod": null,
13529 /**
13530 * Format numbers for display.
13531 * Note that this parameter will be set by the initialisation routine. To
13532 * set a default use {@link DataTable.defaults}.
13533 * @type function
13534 */
13535 "fnFormatNumber": null,
13537 /**
13538 * List of options that can be used for the user selectable length menu.
13539 * Note that this parameter will be set by the initialisation routine. To
13540 * set a default use {@link DataTable.defaults}.
13541 * @type array
13542 * @default []
13543 */
13544 "aLengthMenu": null,
13546 /**
13547 * Counter for the draws that the table does. Also used as a tracker for
13548 * server-side processing
13549 * @type int
13550 * @default 0
13551 */
13552 "iDraw": 0,
13554 /**
13555 * Indicate if a redraw is being done - useful for Ajax
13556 * @type boolean
13557 * @default false
13558 */
13559 "bDrawing": false,
13561 /**
13562 * Draw index (iDraw) of the last error when parsing the returned data
13563 * @type int
13564 * @default -1
13565 */
13566 "iDrawError": -1,
13568 /**
13569 * Paging display length
13570 * @type int
13571 * @default 10
13572 */
13573 "_iDisplayLength": 10,
13575 /**
13576 * Paging start point - aiDisplay index
13577 * @type int
13578 * @default 0
13579 */
13580 "_iDisplayStart": 0,
13582 /**
13583 * Server-side processing - number of records in the result set
13584 * (i.e. before filtering), Use fnRecordsTotal rather than
13585 * this property to get the value of the number of records, regardless of
13586 * the server-side processing setting.
13587 * @type int
13588 * @default 0
13589 * @private
13590 */
13591 "_iRecordsTotal": 0,
13593 /**
13594 * Server-side processing - number of records in the current display set
13595 * (i.e. after filtering). Use fnRecordsDisplay rather than
13596 * this property to get the value of the number of records, regardless of
13597 * the server-side processing setting.
13598 * @type boolean
13599 * @default 0
13600 * @private
13601 */
13602 "_iRecordsDisplay": 0,
13604 /**
13605 * Flag to indicate if jQuery UI marking and classes should be used.
13606 * Note that this parameter will be set by the initialisation routine. To
13607 * set a default use {@link DataTable.defaults}.
13608 * @type boolean
13609 */
13610 "bJUI": null,
13612 /**
13613 * The classes to use for the table
13614 * @type object
13615 * @default {}
13616 */
13617 "oClasses": {},
13619 /**
13620 * Flag attached to the settings object so you can check in the draw
13621 * callback if filtering has been done in the draw. Deprecated in favour of
13622 * events.
13623 * @type boolean
13624 * @default false
13625 * @deprecated
13626 */
13627 "bFiltered": false,
13629 /**
13630 * Flag attached to the settings object so you can check in the draw
13631 * callback if sorting has been done in the draw. Deprecated in favour of
13632 * events.
13633 * @type boolean
13634 * @default false
13635 * @deprecated
13636 */
13637 "bSorted": false,
13639 /**
13640 * Indicate that if multiple rows are in the header and there is more than
13641 * one unique cell per column, if the top one (true) or bottom one (false)
13642 * should be used for sorting / title by DataTables.
13643 * Note that this parameter will be set by the initialisation routine. To
13644 * set a default use {@link DataTable.defaults}.
13645 * @type boolean
13646 */
13647 "bSortCellsTop": null,
13649 /**
13650 * Initialisation object that is used for the table
13651 * @type object
13652 * @default null
13653 */
13654 "oInit": null,
13656 /**
13657 * Destroy callback functions - for plug-ins to attach themselves to the
13658 * destroy so they can clean up markup and events.
13659 * @type array
13660 * @default []
13661 */
13662 "aoDestroyCallback": [],
13665 /**
13666 * Get the number of records in the current record set, before filtering
13667 * @type function
13668 */
13669 "fnRecordsTotal": function ()
13670 {
13671 return _fnDataSource( this ) == 'ssp' ?
13672 this._iRecordsTotal * 1 :
13673 this.aiDisplayMaster.length;
13674 },
13676 /**
13677 * Get the number of records in the current record set, after filtering
13678 * @type function
13679 */
13680 "fnRecordsDisplay": function ()
13681 {
13682 return _fnDataSource( this ) == 'ssp' ?
13683 this._iRecordsDisplay * 1 :
13684 this.aiDisplay.length;
13685 },
13687 /**
13688 * Get the display end point - aiDisplay index
13689 * @type function
13690 */
13691 "fnDisplayEnd": function ()
13692 {
13693 var
13694 len = this._iDisplayLength,
13695 start = this._iDisplayStart,
13696 calc = start + len,
13697 records = this.aiDisplay.length,
13698 features = this.oFeatures,
13699 paginate = features.bPaginate;
13701 if ( features.bServerSide ) {
13702 return paginate === false || len === -1 ?
13703 start + records :
13704 Math.min( start+len, this._iRecordsDisplay );
13705 }
13706 else {
13707 return ! paginate || calc>records || len===-1 ?
13708 records :
13709 calc;
13710 }
13711 },
13713 /**
13714 * The DataTables object for this table
13715 * @type object
13716 * @default null
13717 */
13718 "oInstance": null,
13720 /**
13721 * Unique identifier for each instance of the DataTables object. If there
13722 * is an ID on the table node, then it takes that value, otherwise an
13723 * incrementing internal counter is used.
13724 * @type string
13725 * @default null
13726 */
13727 "sInstance": null,
13729 /**
13730 * tabindex attribute value that is added to DataTables control elements, allowing
13731 * keyboard navigation of the table and its controls.
13732 */
13733 "iTabIndex": 0,
13735 /**
13736 * DIV container for the footer scrolling table if scrolling
13737 */
13738 "nScrollHead": null,
13740 /**
13741 * DIV container for the footer scrolling table if scrolling
13742 */
13743 "nScrollFoot": null,
13745 /**
13746 * Last applied sort
13747 * @type array
13748 * @default []
13749 */
13750 "aLastSort": [],
13752 /**
13753 * Stored plug-in instances
13754 * @type object
13755 * @default {}
13756 */
13757 "oPlugins": {},
13759 /**
13760 * Function used to get a row's id from the row's data
13761 * @type function
13762 * @default null
13763 */
13764 "rowIdFn": null,
13766 /**
13767 * Data location where to store a row's id
13768 * @type string
13769 * @default null
13770 */
13771 "rowId": null
13772 };
13774 /**
13775 * Extension object for DataTables that is used to provide all extension
13776 * options.
13777 *
13778 * Note that the `DataTable.ext` object is available through
13779 * `jQuery.fn.dataTable.ext` where it may be accessed and manipulated. It is
13780 * also aliased to `jQuery.fn.dataTableExt` for historic reasons.
13781 * @namespace
13782 * @extends DataTable.models.ext
13783 */
13786 /**
13787 * DataTables extensions
13788 *
13789 * This namespace acts as a collection area for plug-ins that can be used to
13790 * extend DataTables capabilities. Indeed many of the build in methods
13791 * use this method to provide their own capabilities (sorting methods for
13792 * example).
13793 *
13794 * Note that this namespace is aliased to `jQuery.fn.dataTableExt` for legacy
13795 * reasons
13796 *
13797 * @namespace
13798 */
13799 DataTable.ext = _ext = {
13800 /**
13801 * Buttons. For use with the Buttons extension for DataTables. This is
13802 * defined here so other extensions can define buttons regardless of load
13803 * order. It is _not_ used by DataTables core.
13804 *
13805 * @type object
13806 * @default {}
13807 */
13808 buttons: {},
13811 /**
13812 * Element class names
13813 *
13814 * @type object
13815 * @default {}
13816 */
13817 classes: {},
13820 /**
13821 * DataTables build type (expanded by the download builder)
13822 *
13823 * @type string
13824 */
13825 builder: "-source-",
13828 /**
13829 * Error reporting.
13830 *
13831 * How should DataTables report an error. Can take the value 'alert',
13832 * 'throw', 'none' or a function.
13833 *
13834 * @type string|function
13835 * @default alert
13836 */
13837 errMode: "alert",
13840 /**
13841 * Feature plug-ins.
13842 *
13843 * This is an array of objects which describe the feature plug-ins that are
13844 * available to DataTables. These feature plug-ins are then available for
13845 * use through the `dom` initialisation option.
13846 *
13847 * Each feature plug-in is described by an object which must have the
13848 * following properties:
13849 *
13850 * * `fnInit` - function that is used to initialise the plug-in,
13851 * * `cFeature` - a character so the feature can be enabled by the `dom`
13852 * instillation option. This is case sensitive.
13853 *
13854 * The `fnInit` function has the following input parameters:
13855 *
13856 * 1. `{object}` DataTables settings object: see
13857 * {@link DataTable.models.oSettings}
13858 *
13859 * And the following return is expected:
13860 *
13861 * * {node|null} The element which contains your feature. Note that the
13862 * return may also be void if your plug-in does not require to inject any
13863 * DOM elements into DataTables control (`dom`) - for example this might
13864 * be useful when developing a plug-in which allows table control via
13865 * keyboard entry
13866 *
13867 * @type array
13868 *
13869 * @example
13870 * $.fn.dataTable.ext.features.push( {
13871 * "fnInit": function( oSettings ) {
13872 * return new TableTools( { "oDTSettings": oSettings } );
13873 * },
13874 * "cFeature": "T"
13875 * } );
13876 */
13877 feature: [],
13880 /**
13881 * Row searching.
13882 *
13883 * This method of searching is complimentary to the default type based
13884 * searching, and a lot more comprehensive as it allows you complete control
13885 * over the searching logic. Each element in this array is a function
13886 * (parameters described below) that is called for every row in the table,
13887 * and your logic decides if it should be included in the searching data set
13888 * or not.
13889 *
13890 * Searching functions have the following input parameters:
13891 *
13892 * 1. `{object}` DataTables settings object: see
13893 * {@link DataTable.models.oSettings}
13894 * 2. `{array|object}` Data for the row to be processed (same as the
13895 * original format that was passed in as the data source, or an array
13896 * from a DOM data source
13897 * 3. `{int}` Row index ({@link DataTable.models.oSettings.aoData}), which
13898 * can be useful to retrieve the `TR` element if you need DOM interaction.
13899 *
13900 * And the following return is expected:
13901 *
13902 * * {boolean} Include the row in the searched result set (true) or not
13903 * (false)
13904 *
13905 * Note that as with the main search ability in DataTables, technically this
13906 * is "filtering", since it is subtractive. However, for consistency in
13907 * naming we call it searching here.
13908 *
13909 * @type array
13910 * @default []
13911 *
13912 * @example
13913 * // The following example shows custom search being applied to the
13914 * // fourth column (i.e. the data[3] index) based on two input values
13915 * // from the end-user, matching the data in a certain range.
13916 * $.fn.dataTable.ext.search.push(
13917 * function( settings, data, dataIndex ) {
13918 * var min = document.getElementById('min').value * 1;
13919 * var max = document.getElementById('max').value * 1;
13920 * var version = data[3] == "-" ? 0 : data[3]*1;
13921 *
13922 * if ( min == "" && max == "" ) {
13923 * return true;
13924 * }
13925 * else if ( min == "" && version < max ) {
13926 * return true;
13927 * }
13928 * else if ( min < version && "" == max ) {
13929 * return true;
13930 * }
13931 * else if ( min < version && version < max ) {
13932 * return true;
13933 * }
13934 * return false;
13935 * }
13936 * );
13937 */
13938 search: [],
13941 /**
13942 * Selector extensions
13943 *
13944 * The `selector` option can be used to extend the options available for the
13945 * selector modifier options (`selector-modifier` object data type) that
13946 * each of the three built in selector types offer (row, column and cell +
13947 * their plural counterparts). For example the Select extension uses this
13948 * mechanism to provide an option to select only rows, columns and cells
13949 * that have been marked as selected by the end user (`{selected: true}`),
13950 * which can be used in conjunction with the existing built in selector
13951 * options.
13952 *
13953 * Each property is an array to which functions can be pushed. The functions
13954 * take three attributes:
13955 *
13956 * * Settings object for the host table
13957 * * Options object (`selector-modifier` object type)
13958 * * Array of selected item indexes
13959 *
13960 * The return is an array of the resulting item indexes after the custom
13961 * selector has been applied.
13962 *
13963 * @type object
13964 */
13965 selector: {
13966 cell: [],
13967 column: [],
13968 row: []
13969 },
13972 /**
13973 * Internal functions, exposed for used in plug-ins.
13974 *
13975 * Please note that you should not need to use the internal methods for
13976 * anything other than a plug-in (and even then, try to avoid if possible).
13977 * The internal function may change between releases.
13978 *
13979 * @type object
13980 * @default {}
13981 */
13982 internal: {},
13985 /**
13986 * Legacy configuration options. Enable and disable legacy options that
13987 * are available in DataTables.
13988 *
13989 * @type object
13990 */
13991 legacy: {
13992 /**
13993 * Enable / disable DataTables 1.9 compatible server-side processing
13994 * requests
13995 *
13996 * @type boolean
13997 * @default null
13998 */
13999 ajax: null
14000 },
14003 /**
14004 * Pagination plug-in methods.
14005 *
14006 * Each entry in this object is a function and defines which buttons should
14007 * be shown by the pagination rendering method that is used for the table:
14008 * {@link DataTable.ext.renderer.pageButton}. The renderer addresses how the
14009 * buttons are displayed in the document, while the functions here tell it
14010 * what buttons to display. This is done by returning an array of button
14011 * descriptions (what each button will do).
14012 *
14013 * Pagination types (the four built in options and any additional plug-in
14014 * options defined here) can be used through the `paginationType`
14015 * initialisation parameter.
14016 *
14017 * The functions defined take two parameters:
14018 *
14019 * 1. `{int} page` The current page index
14020 * 2. `{int} pages` The number of pages in the table
14021 *
14022 * Each function is expected to return an array where each element of the
14023 * array can be one of:
14024 *
14025 * * `first` - Jump to first page when activated
14026 * * `last` - Jump to last page when activated
14027 * * `previous` - Show previous page when activated
14028 * * `next` - Show next page when activated
14029 * * `{int}` - Show page of the index given
14030 * * `{array}` - A nested array containing the above elements to add a
14031 * containing 'DIV' element (might be useful for styling).
14032 *
14033 * Note that DataTables v1.9- used this object slightly differently whereby
14034 * an object with two functions would be defined for each plug-in. That
14035 * ability is still supported by DataTables 1.10+ to provide backwards
14036 * compatibility, but this option of use is now decremented and no longer
14037 * documented in DataTables 1.10+.
14038 *
14039 * @type object
14040 * @default {}
14041 *
14042 * @example
14043 * // Show previous, next and current page buttons only
14044 * $.fn.dataTableExt.oPagination.current = function ( page, pages ) {
14045 * return [ 'previous', page, 'next' ];
14046 * };
14047 */
14048 pager: {},
14051 renderer: {
14052 pageButton: {},
14053 header: {}
14054 },
14057 /**
14058 * Ordering plug-ins - custom data source
14059 *
14060 * The extension options for ordering of data available here is complimentary
14061 * to the default type based ordering that DataTables typically uses. It
14062 * allows much greater control over the the data that is being used to
14063 * order a column, but is necessarily therefore more complex.
14064 *
14065 * This type of ordering is useful if you want to do ordering based on data
14066 * live from the DOM (for example the contents of an 'input' element) rather
14067 * than just the static string that DataTables knows of.
14068 *
14069 * The way these plug-ins work is that you create an array of the values you
14070 * wish to be ordering for the column in question and then return that
14071 * array. The data in the array much be in the index order of the rows in
14072 * the table (not the currently ordering order!). Which order data gathering
14073 * function is run here depends on the `dt-init columns.orderDataType`
14074 * parameter that is used for the column (if any).
14075 *
14076 * The functions defined take two parameters:
14077 *
14078 * 1. `{object}` DataTables settings object: see
14079 * {@link DataTable.models.oSettings}
14080 * 2. `{int}` Target column index
14081 *
14082 * Each function is expected to return an array:
14083 *
14084 * * `{array}` Data for the column to be ordering upon
14085 *
14086 * @type array
14087 *
14088 * @example
14089 * // Ordering using `input` node values
14090 * $.fn.dataTable.ext.order['dom-text'] = function ( settings, col )
14091 * {
14092 * return this.api().column( col, {order:'index'} ).nodes().map( function ( td, i ) {
14093 * return $('input', td).val();
14094 * } );
14095 * }
14096 */
14097 order: {},
14100 /**
14101 * Type based plug-ins.
14102 *
14103 * Each column in DataTables has a type assigned to it, either by automatic
14104 * detection or by direct assignment using the `type` option for the column.
14105 * The type of a column will effect how it is ordering and search (plug-ins
14106 * can also make use of the column type if required).
14107 *
14108 * @namespace
14109 */
14110 type: {
14111 /**
14112 * Type detection functions.
14113 *
14114 * The functions defined in this object are used to automatically detect
14115 * a column's type, making initialisation of DataTables super easy, even
14116 * when complex data is in the table.
14117 *
14118 * The functions defined take two parameters:
14119 *
14120 * 1. `{*}` Data from the column cell to be analysed
14121 * 2. `{settings}` DataTables settings object. This can be used to
14122 * perform context specific type detection - for example detection
14123 * based on language settings such as using a comma for a decimal
14124 * place. Generally speaking the options from the settings will not
14125 * be required
14126 *
14127 * Each function is expected to return:
14128 *
14129 * * `{string|null}` Data type detected, or null if unknown (and thus
14130 * pass it on to the other type detection functions.
14131 *
14132 * @type array
14133 *
14134 * @example
14135 * // Currency type detection plug-in:
14136 * $.fn.dataTable.ext.type.detect.push(
14137 * function ( data, settings ) {
14138 * // Check the numeric part
14139 * if ( ! $.isNumeric( data.substring(1) ) ) {
14140 * return null;
14141 * }
14142 *
14143 * // Check prefixed by currency
14144 * if ( data.charAt(0) == '$' || data.charAt(0) == '£' ) {
14145 * return 'currency';
14146 * }
14147 * return null;
14148 * }
14149 * );
14150 */
14151 detect: [],
14154 /**
14155 * Type based search formatting.
14156 *
14157 * The type based searching functions can be used to pre-format the
14158 * data to be search on. For example, it can be used to strip HTML
14159 * tags or to de-format telephone numbers for numeric only searching.
14160 *
14161 * Note that is a search is not defined for a column of a given type,
14162 * no search formatting will be performed.
14163 *
14164 * Pre-processing of searching data plug-ins - When you assign the sType
14165 * for a column (or have it automatically detected for you by DataTables
14166 * or a type detection plug-in), you will typically be using this for
14167 * custom sorting, but it can also be used to provide custom searching
14168 * by allowing you to pre-processing the data and returning the data in
14169 * the format that should be searched upon. This is done by adding
14170 * functions this object with a parameter name which matches the sType
14171 * for that target column. This is the corollary of <i>afnSortData</i>
14172 * for searching data.
14173 *
14174 * The functions defined take a single parameter:
14175 *
14176 * 1. `{*}` Data from the column cell to be prepared for searching
14177 *
14178 * Each function is expected to return:
14179 *
14180 * * `{string|null}` Formatted string that will be used for the searching.
14181 *
14182 * @type object
14183 * @default {}
14184 *
14185 * @example
14186 * $.fn.dataTable.ext.type.search['title-numeric'] = function ( d ) {
14187 * return d.replace(/\n/g," ").replace( /<.*?>/g, "" );
14188 * }
14189 */
14190 search: {},
14193 /**
14194 * Type based ordering.
14195 *
14196 * The column type tells DataTables what ordering to apply to the table
14197 * when a column is sorted upon. The order for each type that is defined,
14198 * is defined by the functions available in this object.
14199 *
14200 * Each ordering option can be described by three properties added to
14201 * this object:
14202 *
14203 * * `{type}-pre` - Pre-formatting function
14204 * * `{type}-asc` - Ascending order function
14205 * * `{type}-desc` - Descending order function
14206 *
14207 * All three can be used together, only `{type}-pre` or only
14208 * `{type}-asc` and `{type}-desc` together. It is generally recommended
14209 * that only `{type}-pre` is used, as this provides the optimal
14210 * implementation in terms of speed, although the others are provided
14211 * for compatibility with existing Javascript sort functions.
14212 *
14213 * `{type}-pre`: Functions defined take a single parameter:
14214 *
14215 * 1. `{*}` Data from the column cell to be prepared for ordering
14216 *
14217 * And return:
14218 *
14219 * * `{*}` Data to be sorted upon
14220 *
14221 * `{type}-asc` and `{type}-desc`: Functions are typical Javascript sort
14222 * functions, taking two parameters:
14223 *
14224 * 1. `{*}` Data to compare to the second parameter
14225 * 2. `{*}` Data to compare to the first parameter
14226 *
14227 * And returning:
14228 *
14229 * * `{*}` Ordering match: <0 if first parameter should be sorted lower
14230 * than the second parameter, ===0 if the two parameters are equal and
14231 * >0 if the first parameter should be sorted height than the second
14232 * parameter.
14233 *
14234 * @type object
14235 * @default {}
14236 *
14237 * @example
14238 * // Numeric ordering of formatted numbers with a pre-formatter
14239 * $.extend( $.fn.dataTable.ext.type.order, {
14240 * "string-pre": function(x) {
14241 * a = (a === "-" || a === "") ? 0 : a.replace( /[^\d\-\.]/g, "" );
14242 * return parseFloat( a );
14243 * }
14244 * } );
14245 *
14246 * @example
14247 * // Case-sensitive string ordering, with no pre-formatting method
14248 * $.extend( $.fn.dataTable.ext.order, {
14249 * "string-case-asc": function(x,y) {
14250 * return ((x < y) ? -1 : ((x > y) ? 1 : 0));
14251 * },
14252 * "string-case-desc": function(x,y) {
14253 * return ((x < y) ? 1 : ((x > y) ? -1 : 0));
14254 * }
14255 * } );
14256 */
14257 order: {}
14258 },
14260 /**
14261 * Unique DataTables instance counter
14262 *
14263 * @type int
14264 * @private
14265 */
14266 _unique: 0,
14269 //
14270 // Depreciated
14271 // The following properties are retained for backwards compatiblity only.
14272 // The should not be used in new projects and will be removed in a future
14273 // version
14274 //
14276 /**
14277 * Version check function.
14278 * @type function
14279 * @depreciated Since 1.10
14280 */
14281 fnVersionCheck: DataTable.fnVersionCheck,
14284 /**
14285 * Index for what 'this' index API functions should use
14286 * @type int
14287 * @deprecated Since v1.10
14288 */
14289 iApiIndex: 0,
14292 /**
14293 * jQuery UI class container
14294 * @type object
14295 * @deprecated Since v1.10
14296 */
14297 oJUIClasses: {},
14300 /**
14301 * Software version
14302 * @type string
14303 * @deprecated Since v1.10
14304 */
14305 sVersion: DataTable.version
14306 };
14309 //
14310 // Backwards compatibility. Alias to pre 1.10 Hungarian notation counter parts
14311 //
14312 $.extend( _ext, {
14313 afnFiltering: _ext.search,
14314 aTypes: _ext.type.detect,
14315 ofnSearch: _ext.type.search,
14316 oSort: _ext.type.order,
14317 afnSortData: _ext.order,
14318 aoFeatures: _ext.feature,
14319 oApi: _ext.internal,
14320 oStdClasses: _ext.classes,
14321 oPagination: _ext.pager
14322 } );
14325 $.extend( DataTable.ext.classes, {
14326 "sTable": "dataTable",
14327 "sNoFooter": "no-footer",
14329 /* Paging buttons */
14330 "sPageButton": "paginate_button",
14331 "sPageButtonActive": "current",
14332 "sPageButtonDisabled": "disabled",
14334 /* Striping classes */
14335 "sStripeOdd": "odd",
14336 "sStripeEven": "even",
14338 /* Empty row */
14339 "sRowEmpty": "dataTables_empty",
14341 /* Features */
14342 "sWrapper": "dataTables_wrapper",
14343 "sFilter": "dataTables_filter",
14344 "sInfo": "dataTables_info",
14345 "sPaging": "dataTables_paginate paging_", /* Note that the type is postfixed */
14346 "sLength": "dataTables_length",
14347 "sProcessing": "dataTables_processing",
14349 /* Sorting */
14350 "sSortAsc": "sorting_asc",
14351 "sSortDesc": "sorting_desc",
14352 "sSortable": "sorting", /* Sortable in both directions */
14353 "sSortableAsc": "sorting_asc_disabled",
14354 "sSortableDesc": "sorting_desc_disabled",
14355 "sSortableNone": "sorting_disabled",
14356 "sSortColumn": "sorting_", /* Note that an int is postfixed for the sorting order */
14358 /* Filtering */
14359 "sFilterInput": "",
14361 /* Page length */
14362 "sLengthSelect": "",
14364 /* Scrolling */
14365 "sScrollWrapper": "dataTables_scroll",
14366 "sScrollHead": "dataTables_scrollHead",
14367 "sScrollHeadInner": "dataTables_scrollHeadInner",
14368 "sScrollBody": "dataTables_scrollBody",
14369 "sScrollFoot": "dataTables_scrollFoot",
14370 "sScrollFootInner": "dataTables_scrollFootInner",
14372 /* Misc */
14373 "sHeaderTH": "",
14374 "sFooterTH": "",
14376 // Deprecated
14377 "sSortJUIAsc": "",
14378 "sSortJUIDesc": "",
14379 "sSortJUI": "",
14380 "sSortJUIAscAllowed": "",
14381 "sSortJUIDescAllowed": "",
14382 "sSortJUIWrapper": "",
14383 "sSortIcon": "",
14384 "sJUIHeader": "",
14385 "sJUIFooter": ""
14386 } );
14389 (function() {
14391 // Reused strings for better compression. Closure compiler appears to have a
14392 // weird edge case where it is trying to expand strings rather than use the
14393 // variable version. This results in about 200 bytes being added, for very
14394 // little preference benefit since it this run on script load only.
14395 var _empty = '';
14396 _empty = '';
14398 var _stateDefault = _empty + 'ui-state-default';
14399 var _sortIcon = _empty + 'css_right ui-icon ui-icon-';
14400 var _headerFooter = _empty + 'fg-toolbar ui-toolbar ui-widget-header ui-helper-clearfix';
14402 $.extend( DataTable.ext.oJUIClasses, DataTable.ext.classes, {
14403 /* Full numbers paging buttons */
14404 "sPageButton": "fg-button ui-button "+_stateDefault,
14405 "sPageButtonActive": "ui-state-disabled",
14406 "sPageButtonDisabled": "ui-state-disabled",
14408 /* Features */
14409 "sPaging": "dataTables_paginate fg-buttonset ui-buttonset fg-buttonset-multi "+
14410 "ui-buttonset-multi paging_", /* Note that the type is postfixed */
14412 /* Sorting */
14413 "sSortAsc": _stateDefault+" sorting_asc",
14414 "sSortDesc": _stateDefault+" sorting_desc",
14415 "sSortable": _stateDefault+" sorting",
14416 "sSortableAsc": _stateDefault+" sorting_asc_disabled",
14417 "sSortableDesc": _stateDefault+" sorting_desc_disabled",
14418 "sSortableNone": _stateDefault+" sorting_disabled",
14419 "sSortJUIAsc": _sortIcon+"triangle-1-n",
14420 "sSortJUIDesc": _sortIcon+"triangle-1-s",
14421 "sSortJUI": _sortIcon+"carat-2-n-s",
14422 "sSortJUIAscAllowed": _sortIcon+"carat-1-n",
14423 "sSortJUIDescAllowed": _sortIcon+"carat-1-s",
14424 "sSortJUIWrapper": "DataTables_sort_wrapper",
14425 "sSortIcon": "DataTables_sort_icon",
14427 /* Scrolling */
14428 "sScrollHead": "dataTables_scrollHead "+_stateDefault,
14429 "sScrollFoot": "dataTables_scrollFoot "+_stateDefault,
14431 /* Misc */
14432 "sHeaderTH": _stateDefault,
14433 "sFooterTH": _stateDefault,
14434 "sJUIHeader": _headerFooter+" ui-corner-tl ui-corner-tr",
14435 "sJUIFooter": _headerFooter+" ui-corner-bl ui-corner-br"
14436 } );
14438 }());
14442 var extPagination = DataTable.ext.pager;
14444 function _numbers ( page, pages ) {
14445 var
14446 numbers = [],
14447 buttons = extPagination.numbers_length,
14448 half = Math.floor( buttons / 2 ),
14449 i = 1;
14451 if ( pages <= buttons ) {
14452 numbers = _range( 0, pages );
14453 }
14454 else if ( page <= half ) {
14455 numbers = _range( 0, buttons-2 );
14456 numbers.push( 'ellipsis' );
14457 numbers.push( pages-1 );
14458 }
14459 else if ( page >= pages - 1 - half ) {
14460 numbers = _range( pages-(buttons-2), pages );
14461 numbers.splice( 0, 0, 'ellipsis' ); // no unshift in ie6
14462 numbers.splice( 0, 0, 0 );
14463 }
14464 else {
14465 numbers = _range( page-half+2, page+half-1 );
14466 numbers.push( 'ellipsis' );
14467 numbers.push( pages-1 );
14468 numbers.splice( 0, 0, 'ellipsis' );
14469 numbers.splice( 0, 0, 0 );
14470 }
14472 numbers.DT_el = 'span';
14473 return numbers;
14474 }
14477 $.extend( extPagination, {
14478 simple: function ( page, pages ) {
14479 return [ 'previous', 'next' ];
14480 },
14482 full: function ( page, pages ) {
14483 return [ 'first', 'previous', 'next', 'last' ];
14484 },
14486 numbers: function ( page, pages ) {
14487 return [ _numbers(page, pages) ];
14488 },
14490 simple_numbers: function ( page, pages ) {
14491 return [ 'previous', _numbers(page, pages), 'next' ];
14492 },
14494 full_numbers: function ( page, pages ) {
14495 return [ 'first', 'previous', _numbers(page, pages), 'next', 'last' ];
14496 },
14498 // For testing and plug-ins to use
14499 _numbers: _numbers,
14501 // Number of number buttons (including ellipsis) to show. _Must be odd!_
14502 numbers_length: 7
14503 } );
14506 $.extend( true, DataTable.ext.renderer, {
14507 pageButton: {
14508 _: function ( settings, host, idx, buttons, page, pages ) {
14509 var classes = settings.oClasses;
14510 var lang = settings.oLanguage.oPaginate;
14511 var aria = settings.oLanguage.oAria.paginate || {};
14512 var btnDisplay, btnClass, counter=0;
14514 var attach = function( container, buttons ) {
14515 var i, ien, node, button;
14516 var clickHandler = function ( e ) {
14517 _fnPageChange( settings, e.data.action, true );
14518 };
14520 for ( i=0, ien=buttons.length ; i<ien ; i++ ) {
14521 button = buttons[i];
14523 if ( $.isArray( button ) ) {
14524 var inner = $( '<'+(button.DT_el || 'div')+'/>' )
14525 .appendTo( container );
14526 attach( inner, button );
14527 }
14528 else {
14529 btnDisplay = null;
14530 btnClass = '';
14532 switch ( button ) {
14533 case 'ellipsis':
14534 container.append('<span class="ellipsis">…</span>');
14535 break;
14537 case 'first':
14538 btnDisplay = lang.sFirst;
14539 btnClass = button + (page > 0 ?
14540 '' : ' '+classes.sPageButtonDisabled);
14541 break;
14543 case 'previous':
14544 btnDisplay = lang.sPrevious;
14545 btnClass = button + (page > 0 ?
14546 '' : ' '+classes.sPageButtonDisabled);
14547 break;
14549 case 'next':
14550 btnDisplay = lang.sNext;
14551 btnClass = button + (page < pages-1 ?
14552 '' : ' '+classes.sPageButtonDisabled);
14553 break;
14555 case 'last':
14556 btnDisplay = lang.sLast;
14557 btnClass = button + (page < pages-1 ?
14558 '' : ' '+classes.sPageButtonDisabled);
14559 break;
14561 default:
14562 btnDisplay = button + 1;
14563 btnClass = page === button ?
14564 classes.sPageButtonActive : '';
14565 break;
14566 }
14568 if ( btnDisplay !== null ) {
14569 node = $('<a>', {
14570 'class': classes.sPageButton+' '+btnClass,
14571 'aria-controls': settings.sTableId,
14572 'aria-label': aria[ button ],
14573 'data-dt-idx': counter,
14574 'tabindex': settings.iTabIndex,
14575 'id': idx === 0 && typeof button === 'string' ?
14576 settings.sTableId +'_'+ button :
14577 null
14578 } )
14579 .html( btnDisplay )
14580 .appendTo( container );
14582 _fnBindAction(
14583 node, {action: button}, clickHandler
14584 );
14586 counter++;
14587 }
14588 }
14589 }
14590 };
14592 // IE9 throws an 'unknown error' if document.activeElement is used
14593 // inside an iframe or frame. Try / catch the error. Not good for
14594 // accessibility, but neither are frames.
14595 var activeEl;
14597 try {
14598 // Because this approach is destroying and recreating the paging
14599 // elements, focus is lost on the select button which is bad for
14600 // accessibility. So we want to restore focus once the draw has
14601 // completed
14602 activeEl = $(host).find(document.activeElement).data('dt-idx');
14603 }
14604 catch (e) {}
14606 attach( $(host).empty(), buttons );
14608 if ( activeEl ) {
14609 $(host).find( '[data-dt-idx='+activeEl+']' ).focus();
14610 }
14611 }
14612 }
14613 } );
14617 // Built in type detection. See model.ext.aTypes for information about
14618 // what is required from this methods.
14619 $.extend( DataTable.ext.type.detect, [
14620 // Plain numbers - first since V8 detects some plain numbers as dates
14621 // e.g. Date.parse('55') (but not all, e.g. Date.parse('22')...).
14622 function ( d, settings )
14623 {
14624 var decimal = settings.oLanguage.sDecimal;
14625 return _isNumber( d, decimal ) ? 'num'+decimal : null;
14626 },
14628 // Dates (only those recognised by the browser's Date.parse)
14629 function ( d, settings )
14630 {
14631 // V8 will remove any unknown characters at the start and end of the
14632 // expression, leading to false matches such as `$245.12` or `10%` being
14633 // a valid date. See forum thread 18941 for detail.
14634 if ( d && !(d instanceof Date) && ( ! _re_date_start.test(d) || ! _re_date_end.test(d) ) ) {
14635 return null;
14636 }
14637 var parsed = Date.parse(d);
14638 return (parsed !== null && !isNaN(parsed)) || _empty(d) ? 'date' : null;
14639 },
14641 // Formatted numbers
14642 function ( d, settings )
14643 {
14644 var decimal = settings.oLanguage.sDecimal;
14645 return _isNumber( d, decimal, true ) ? 'num-fmt'+decimal : null;
14646 },
14648 // HTML numeric
14649 function ( d, settings )
14650 {
14651 var decimal = settings.oLanguage.sDecimal;
14652 return _htmlNumeric( d, decimal ) ? 'html-num'+decimal : null;
14653 },
14655 // HTML numeric, formatted
14656 function ( d, settings )
14657 {
14658 var decimal = settings.oLanguage.sDecimal;
14659 return _htmlNumeric( d, decimal, true ) ? 'html-num-fmt'+decimal : null;
14660 },
14662 // HTML (this is strict checking - there must be html)
14663 function ( d, settings )
14664 {
14665 return _empty( d ) || (typeof d === 'string' && d.indexOf('<') !== -1) ?
14666 'html' : null;
14667 }
14668 ] );
14672 // Filter formatting functions. See model.ext.ofnSearch for information about
14673 // what is required from these methods.
14674 //
14675 // Note that additional search methods are added for the html numbers and
14676 // html formatted numbers by `_addNumericSort()` when we know what the decimal
14677 // place is
14680 $.extend( DataTable.ext.type.search, {
14681 html: function ( data ) {
14682 return _empty(data) ?
14683 data :
14684 typeof data === 'string' ?
14685 data
14686 .replace( _re_new_lines, " " )
14687 .replace( _re_html, "" ) :
14688 '';
14689 },
14691 string: function ( data ) {
14692 return _empty(data) ?
14693 data :
14694 typeof data === 'string' ?
14695 data.replace( _re_new_lines, " " ) :
14696 data;
14697 }
14698 } );
14702 var __numericReplace = function ( d, decimalPlace, re1, re2 ) {
14703 if ( d !== 0 && (!d || d === '-') ) {
14704 return -Infinity;
14705 }
14707 // If a decimal place other than `.` is used, it needs to be given to the
14708 // function so we can detect it and replace with a `.` which is the only
14709 // decimal place Javascript recognises - it is not locale aware.
14710 if ( decimalPlace ) {
14711 d = _numToDecimal( d, decimalPlace );
14712 }
14714 if ( d.replace ) {
14715 if ( re1 ) {
14716 d = d.replace( re1, '' );
14717 }
14719 if ( re2 ) {
14720 d = d.replace( re2, '' );
14721 }
14722 }
14724 return d * 1;
14725 };
14728 // Add the numeric 'deformatting' functions for sorting and search. This is done
14729 // in a function to provide an easy ability for the language options to add
14730 // additional methods if a non-period decimal place is used.
14731 function _addNumericSort ( decimalPlace ) {
14732 $.each(
14733 {
14734 // Plain numbers
14735 "num": function ( d ) {
14736 return __numericReplace( d, decimalPlace );
14737 },
14739 // Formatted numbers
14740 "num-fmt": function ( d ) {
14741 return __numericReplace( d, decimalPlace, _re_formatted_numeric );
14742 },
14744 // HTML numeric
14745 "html-num": function ( d ) {
14746 return __numericReplace( d, decimalPlace, _re_html );
14747 },
14749 // HTML numeric, formatted
14750 "html-num-fmt": function ( d ) {
14751 return __numericReplace( d, decimalPlace, _re_html, _re_formatted_numeric );
14752 }
14753 },
14754 function ( key, fn ) {
14755 // Add the ordering method
14756 _ext.type.order[ key+decimalPlace+'-pre' ] = fn;
14758 // For HTML types add a search formatter that will strip the HTML
14759 if ( key.match(/^html\-/) ) {
14760 _ext.type.search[ key+decimalPlace ] = _ext.type.search.html;
14761 }
14762 }
14763 );
14764 }
14767 // Default sort methods
14768 $.extend( _ext.type.order, {
14769 // Dates
14770 "date-pre": function ( d ) {
14771 return Date.parse( d ) || 0;
14772 },
14774 // html
14775 "html-pre": function ( a ) {
14776 return _empty(a) ?
14777 '' :
14778 a.replace ?
14779 a.replace( /<.*?>/g, "" ).toLowerCase() :
14780 a+'';
14781 },
14783 // string
14784 "string-pre": function ( a ) {
14785 // This is a little complex, but faster than always calling toString,
14786 // http://jsperf.com/tostring-v-check
14787 return _empty(a) ?
14788 '' :
14789 typeof a === 'string' ?
14790 a.toLowerCase() :
14791 ! a.toString ?
14792 '' :
14793 a.toString();
14794 },
14796 // string-asc and -desc are retained only for compatibility with the old
14797 // sort methods
14798 "string-asc": function ( x, y ) {
14799 return ((x < y) ? -1 : ((x > y) ? 1 : 0));
14800 },
14802 "string-desc": function ( x, y ) {
14803 return ((x < y) ? 1 : ((x > y) ? -1 : 0));
14804 }
14805 } );
14808 // Numeric sorting types - order doesn't matter here
14809 _addNumericSort( '' );
14812 $.extend( true, DataTable.ext.renderer, {
14813 header: {
14814 _: function ( settings, cell, column, classes ) {
14815 // No additional mark-up required
14816 // Attach a sort listener to update on sort - note that using the
14817 // `DT` namespace will allow the event to be removed automatically
14818 // on destroy, while the `dt` namespaced event is the one we are
14819 // listening for
14820 $(settings.nTable).on( 'order.dt.DT', function ( e, ctx, sorting, columns ) {
14821 if ( settings !== ctx ) { // need to check this this is the host
14822 return; // table, not a nested one
14823 }
14825 var colIdx = column.idx;
14827 cell
14828 .removeClass(
14829 column.sSortingClass +' '+
14830 classes.sSortAsc +' '+
14831 classes.sSortDesc
14832 )
14833 .addClass( columns[ colIdx ] == 'asc' ?
14834 classes.sSortAsc : columns[ colIdx ] == 'desc' ?
14835 classes.sSortDesc :
14836 column.sSortingClass
14837 );
14838 } );
14839 },
14841 jqueryui: function ( settings, cell, column, classes ) {
14842 $('<div/>')
14843 .addClass( classes.sSortJUIWrapper )
14844 .append( cell.contents() )
14845 .append( $('<span/>')
14846 .addClass( classes.sSortIcon+' '+column.sSortingClassJUI )
14847 )
14848 .appendTo( cell );
14850 // Attach a sort listener to update on sort
14851 $(settings.nTable).on( 'order.dt.DT', function ( e, ctx, sorting, columns ) {
14852 if ( settings !== ctx ) {
14853 return;
14854 }
14856 var colIdx = column.idx;
14858 cell
14859 .removeClass( classes.sSortAsc +" "+classes.sSortDesc )
14860 .addClass( columns[ colIdx ] == 'asc' ?
14861 classes.sSortAsc : columns[ colIdx ] == 'desc' ?
14862 classes.sSortDesc :
14863 column.sSortingClass
14864 );
14866 cell
14867 .find( 'span.'+classes.sSortIcon )
14868 .removeClass(
14869 classes.sSortJUIAsc +" "+
14870 classes.sSortJUIDesc +" "+
14871 classes.sSortJUI +" "+
14872 classes.sSortJUIAscAllowed +" "+
14873 classes.sSortJUIDescAllowed
14874 )
14875 .addClass( columns[ colIdx ] == 'asc' ?
14876 classes.sSortJUIAsc : columns[ colIdx ] == 'desc' ?
14877 classes.sSortJUIDesc :
14878 column.sSortingClassJUI
14879 );
14880 } );
14881 }
14882 }
14883 } );
14885 /*
14886 * Public helper functions. These aren't used internally by DataTables, or
14887 * called by any of the options passed into DataTables, but they can be used
14888 * externally by developers working with DataTables. They are helper functions
14889 * to make working with DataTables a little bit easier.
14890 */
14892 var __htmlEscapeEntities = function ( d ) {
14893 return typeof d === 'string' ?
14894 d.replace(/</g, '<').replace(/>/g, '>').replace(/"/g, '"') :
14895 d;
14896 };
14898 /**
14899 * Helpers for `columns.render`.
14900 *
14901 * The options defined here can be used with the `columns.render` initialisation
14902 * option to provide a display renderer. The following functions are defined:
14903 *
14904 * * `number` - Will format numeric data (defined by `columns.data`) for
14905 * display, retaining the original unformatted data for sorting and filtering.
14906 * It takes 5 parameters:
14907 * * `string` - Thousands grouping separator
14908 * * `string` - Decimal point indicator
14909 * * `integer` - Number of decimal points to show
14910 * * `string` (optional) - Prefix.
14911 * * `string` (optional) - Postfix (/suffix).
14912 * * `text` - Escape HTML to help prevent XSS attacks. It has no optional
14913 * parameters.
14914 *
14915 * @example
14916 * // Column definition using the number renderer
14917 * {
14918 * data: "salary",
14919 * render: $.fn.dataTable.render.number( '\'', '.', 0, '$' )
14920 * }
14921 *
14922 * @namespace
14923 */
14924 DataTable.render = {
14925 number: function ( thousands, decimal, precision, prefix, postfix ) {
14926 return {
14927 display: function ( d ) {
14928 if ( typeof d !== 'number' && typeof d !== 'string' ) {
14929 return d;
14930 }
14932 var negative = d < 0 ? '-' : '';
14933 var flo = parseFloat( d );
14935 // If NaN then there isn't much formatting that we can do - just
14936 // return immediately, escaping any HTML (this was supposed to
14937 // be a number after all)
14938 if ( isNaN( flo ) ) {
14939 return __htmlEscapeEntities( d );
14940 }
14942 d = Math.abs( flo );
14944 var intPart = parseInt( d, 10 );
14945 var floatPart = precision ?
14946 decimal+(d - intPart).toFixed( precision ).substring( 2 ):
14947 '';
14949 return negative + (prefix||'') +
14950 intPart.toString().replace(
14951 /\B(?=(\d{3})+(?!\d))/g, thousands
14952 ) +
14953 floatPart +
14954 (postfix||'');
14955 }
14956 };
14957 },
14959 text: function () {
14960 return {
14961 display: __htmlEscapeEntities
14962 };
14963 }
14964 };
14967 /*
14968 * This is really a good bit rubbish this method of exposing the internal methods
14969 * publicly... - To be fixed in 2.0 using methods on the prototype
14970 */
14973 /**
14974 * Create a wrapper function for exporting an internal functions to an external API.
14975 * @param {string} fn API function name
14976 * @returns {function} wrapped function
14977 * @memberof DataTable#internal
14978 */
14979 function _fnExternApiFunc (fn)
14980 {
14981 return function() {
14982 var args = [_fnSettingsFromNode( this[DataTable.ext.iApiIndex] )].concat(
14983 Array.prototype.slice.call(arguments)
14984 );
14985 return DataTable.ext.internal[fn].apply( this, args );
14986 };
14987 }
14990 /**
14991 * Reference to internal functions for use by plug-in developers. Note that
14992 * these methods are references to internal functions and are considered to be
14993 * private. If you use these methods, be aware that they are liable to change
14994 * between versions.
14995 * @namespace
14996 */
14997 $.extend( DataTable.ext.internal, {
14998 _fnExternApiFunc: _fnExternApiFunc,
14999 _fnBuildAjax: _fnBuildAjax,
15000 _fnAjaxUpdate: _fnAjaxUpdate,
15001 _fnAjaxParameters: _fnAjaxParameters,
15002 _fnAjaxUpdateDraw: _fnAjaxUpdateDraw,
15003 _fnAjaxDataSrc: _fnAjaxDataSrc,
15004 _fnAddColumn: _fnAddColumn,
15005 _fnColumnOptions: _fnColumnOptions,
15006 _fnAdjustColumnSizing: _fnAdjustColumnSizing,
15007 _fnVisibleToColumnIndex: _fnVisibleToColumnIndex,
15008 _fnColumnIndexToVisible: _fnColumnIndexToVisible,
15009 _fnVisbleColumns: _fnVisbleColumns,
15010 _fnGetColumns: _fnGetColumns,
15011 _fnColumnTypes: _fnColumnTypes,
15012 _fnApplyColumnDefs: _fnApplyColumnDefs,
15013 _fnHungarianMap: _fnHungarianMap,
15014 _fnCamelToHungarian: _fnCamelToHungarian,
15015 _fnLanguageCompat: _fnLanguageCompat,
15016 _fnBrowserDetect: _fnBrowserDetect,
15017 _fnAddData: _fnAddData,
15018 _fnAddTr: _fnAddTr,
15019 _fnNodeToDataIndex: _fnNodeToDataIndex,
15020 _fnNodeToColumnIndex: _fnNodeToColumnIndex,
15021 _fnGetCellData: _fnGetCellData,
15022 _fnSetCellData: _fnSetCellData,
15023 _fnSplitObjNotation: _fnSplitObjNotation,
15024 _fnGetObjectDataFn: _fnGetObjectDataFn,
15025 _fnSetObjectDataFn: _fnSetObjectDataFn,
15026 _fnGetDataMaster: _fnGetDataMaster,
15027 _fnClearTable: _fnClearTable,
15028 _fnDeleteIndex: _fnDeleteIndex,
15029 _fnInvalidate: _fnInvalidate,
15030 _fnGetRowElements: _fnGetRowElements,
15031 _fnCreateTr: _fnCreateTr,
15032 _fnBuildHead: _fnBuildHead,
15033 _fnDrawHead: _fnDrawHead,
15034 _fnDraw: _fnDraw,
15035 _fnReDraw: _fnReDraw,
15036 _fnAddOptionsHtml: _fnAddOptionsHtml,
15037 _fnDetectHeader: _fnDetectHeader,
15038 _fnGetUniqueThs: _fnGetUniqueThs,
15039 _fnFeatureHtmlFilter: _fnFeatureHtmlFilter,
15040 _fnFilterComplete: _fnFilterComplete,
15041 _fnFilterCustom: _fnFilterCustom,
15042 _fnFilterColumn: _fnFilterColumn,
15043 _fnFilter: _fnFilter,
15044 _fnFilterCreateSearch: _fnFilterCreateSearch,
15045 _fnEscapeRegex: _fnEscapeRegex,
15046 _fnFilterData: _fnFilterData,
15047 _fnFeatureHtmlInfo: _fnFeatureHtmlInfo,
15048 _fnUpdateInfo: _fnUpdateInfo,
15049 _fnInfoMacros: _fnInfoMacros,
15050 _fnInitialise: _fnInitialise,
15051 _fnInitComplete: _fnInitComplete,
15052 _fnLengthChange: _fnLengthChange,
15053 _fnFeatureHtmlLength: _fnFeatureHtmlLength,
15054 _fnFeatureHtmlPaginate: _fnFeatureHtmlPaginate,
15055 _fnPageChange: _fnPageChange,
15056 _fnFeatureHtmlProcessing: _fnFeatureHtmlProcessing,
15057 _fnProcessingDisplay: _fnProcessingDisplay,
15058 _fnFeatureHtmlTable: _fnFeatureHtmlTable,
15059 _fnScrollDraw: _fnScrollDraw,
15060 _fnApplyToChildren: _fnApplyToChildren,
15061 _fnCalculateColumnWidths: _fnCalculateColumnWidths,
15062 _fnThrottle: _fnThrottle,
15063 _fnConvertToWidth: _fnConvertToWidth,
15064 _fnGetWidestNode: _fnGetWidestNode,
15065 _fnGetMaxLenString: _fnGetMaxLenString,
15066 _fnStringToCss: _fnStringToCss,
15067 _fnSortFlatten: _fnSortFlatten,
15068 _fnSort: _fnSort,
15069 _fnSortAria: _fnSortAria,
15070 _fnSortListener: _fnSortListener,
15071 _fnSortAttachListener: _fnSortAttachListener,
15072 _fnSortingClasses: _fnSortingClasses,
15073 _fnSortData: _fnSortData,
15074 _fnSaveState: _fnSaveState,
15075 _fnLoadState: _fnLoadState,
15076 _fnSettingsFromNode: _fnSettingsFromNode,
15077 _fnLog: _fnLog,
15078 _fnMap: _fnMap,
15079 _fnBindAction: _fnBindAction,
15080 _fnCallbackReg: _fnCallbackReg,
15081 _fnCallbackFire: _fnCallbackFire,
15082 _fnLengthOverflow: _fnLengthOverflow,
15083 _fnRenderer: _fnRenderer,
15084 _fnDataSource: _fnDataSource,
15085 _fnRowAttributes: _fnRowAttributes,
15086 _fnCalculateEnd: function () {} // Used by a lot of plug-ins, but redundant
15087 // in 1.10, so this dead-end function is
15088 // added to prevent errors
15089 } );
15092 // jQuery access
15093 $.fn.dataTable = DataTable;
15095 // Provide access to the host jQuery object (circular reference)
15096 DataTable.$ = $;
15098 // Legacy aliases
15099 $.fn.dataTableSettings = DataTable.settings;
15100 $.fn.dataTableExt = DataTable.ext;
15102 // With a capital `D` we return a DataTables API instance rather than a
15103 // jQuery object
15104 $.fn.DataTable = function ( opts ) {
15105 return $(this).dataTable( opts ).api();
15106 };
15108 // All properties that are available to $.fn.dataTable should also be
15109 // available on $.fn.DataTable
15110 $.each( DataTable, function ( prop, val ) {
15111 $.fn.DataTable[ prop ] = val;
15112 } );
15115 // Information about events fired by DataTables - for documentation.
15116 /**
15117 * Draw event, fired whenever the table is redrawn on the page, at the same
15118 * point as fnDrawCallback. This may be useful for binding events or
15119 * performing calculations when the table is altered at all.
15120 * @name DataTable#draw.dt
15121 * @event
15122 * @param {event} e jQuery event object
15123 * @param {object} o DataTables settings object {@link DataTable.models.oSettings}
15124 */
15126 /**
15127 * Search event, fired when the searching applied to the table (using the
15128 * built-in global search, or column filters) is altered.
15129 * @name DataTable#search.dt
15130 * @event
15131 * @param {event} e jQuery event object
15132 * @param {object} o DataTables settings object {@link DataTable.models.oSettings}
15133 */
15135 /**
15136 * Page change event, fired when the paging of the table is altered.
15137 * @name DataTable#page.dt
15138 * @event
15139 * @param {event} e jQuery event object
15140 * @param {object} o DataTables settings object {@link DataTable.models.oSettings}
15141 */
15143 /**
15144 * Order event, fired when the ordering applied to the table is altered.
15145 * @name DataTable#order.dt
15146 * @event
15147 * @param {event} e jQuery event object
15148 * @param {object} o DataTables settings object {@link DataTable.models.oSettings}
15149 */
15151 /**
15152 * DataTables initialisation complete event, fired when the table is fully
15153 * drawn, including Ajax data loaded, if Ajax data is required.
15154 * @name DataTable#init.dt
15155 * @event
15156 * @param {event} e jQuery event object
15157 * @param {object} oSettings DataTables settings object
15158 * @param {object} json The JSON object request from the server - only
15159 * present if client-side Ajax sourced data is used</li></ol>
15160 */
15162 /**
15163 * State save event, fired when the table has changed state a new state save
15164 * is required. This event allows modification of the state saving object
15165 * prior to actually doing the save, including addition or other state
15166 * properties (for plug-ins) or modification of a DataTables core property.
15167 * @name DataTable#stateSaveParams.dt
15168 * @event
15169 * @param {event} e jQuery event object
15170 * @param {object} oSettings DataTables settings object
15171 * @param {object} json The state information to be saved
15172 */
15174 /**
15175 * State load event, fired when the table is loading state from the stored
15176 * data, but prior to the settings object being modified by the saved state
15177 * - allowing modification of the saved state is required or loading of
15178 * state for a plug-in.
15179 * @name DataTable#stateLoadParams.dt
15180 * @event
15181 * @param {event} e jQuery event object
15182 * @param {object} oSettings DataTables settings object
15183 * @param {object} json The saved state information
15184 */
15186 /**
15187 * State loaded event, fired when state has been loaded from stored data and
15188 * the settings object has been modified by the loaded data.
15189 * @name DataTable#stateLoaded.dt
15190 * @event
15191 * @param {event} e jQuery event object
15192 * @param {object} oSettings DataTables settings object
15193 * @param {object} json The saved state information
15194 */
15196 /**
15197 * Processing event, fired when DataTables is doing some kind of processing
15198 * (be it, order, searcg or anything else). It can be used to indicate to
15199 * the end user that there is something happening, or that something has
15200 * finished.
15201 * @name DataTable#processing.dt
15202 * @event
15203 * @param {event} e jQuery event object
15204 * @param {object} oSettings DataTables settings object
15205 * @param {boolean} bShow Flag for if DataTables is doing processing or not
15206 */
15208 /**
15209 * Ajax (XHR) event, fired whenever an Ajax request is completed from a
15210 * request to made to the server for new data. This event is called before
15211 * DataTables processed the returned data, so it can also be used to pre-
15212 * process the data returned from the server, if needed.
15213 *
15214 * Note that this trigger is called in `fnServerData`, if you override
15215 * `fnServerData` and which to use this event, you need to trigger it in you
15216 * success function.
15217 * @name DataTable#xhr.dt
15218 * @event
15219 * @param {event} e jQuery event object
15220 * @param {object} o DataTables settings object {@link DataTable.models.oSettings}
15221 * @param {object} json JSON returned from the server
15222 *
15223 * @example
15224 * // Use a custom property returned from the server in another DOM element
15225 * $('#table').dataTable().on('xhr.dt', function (e, settings, json) {
15226 * $('#status').html( json.status );
15227 * } );
15228 *
15229 * @example
15230 * // Pre-process the data returned from the server
15231 * $('#table').dataTable().on('xhr.dt', function (e, settings, json) {
15232 * for ( var i=0, ien=json.aaData.length ; i<ien ; i++ ) {
15233 * json.aaData[i].sum = json.aaData[i].one + json.aaData[i].two;
15234 * }
15235 * // Note no return - manipulate the data directly in the JSON object.
15236 * } );
15237 */
15239 /**
15240 * Destroy event, fired when the DataTable is destroyed by calling fnDestroy
15241 * or passing the bDestroy:true parameter in the initialisation object. This
15242 * can be used to remove bound events, added DOM nodes, etc.
15243 * @name DataTable#destroy.dt
15244 * @event
15245 * @param {event} e jQuery event object
15246 * @param {object} o DataTables settings object {@link DataTable.models.oSettings}
15247 */
15249 /**
15250 * Page length change event, fired when number of records to show on each
15251 * page (the length) is changed.
15252 * @name DataTable#length.dt
15253 * @event
15254 * @param {event} e jQuery event object
15255 * @param {object} o DataTables settings object {@link DataTable.models.oSettings}
15256 * @param {integer} len New length
15257 */
15259 /**
15260 * Column sizing has changed.
15261 * @name DataTable#column-sizing.dt
15262 * @event
15263 * @param {event} e jQuery event object
15264 * @param {object} o DataTables settings object {@link DataTable.models.oSettings}
15265 */
15267 /**
15268 * Column visibility has changed.
15269 * @name DataTable#column-visibility.dt
15270 * @event
15271 * @param {event} e jQuery event object
15272 * @param {object} o DataTables settings object {@link DataTable.models.oSettings}
15273 * @param {int} column Column index
15274 * @param {bool} vis `false` if column now hidden, or `true` if visible
15275 */
15277 return $.fn.dataTable;
15278 }));