Initial checkin
This commit is contained in:
commit
d75eb444fc
4304 changed files with 369634 additions and 0 deletions
263
js/datatables/media/src/model/model.column.js
Normal file
263
js/datatables/media/src/model/model.column.js
Normal file
|
@ -0,0 +1,263 @@
|
|||
|
||||
|
||||
|
||||
/**
|
||||
* Template object for the column information object in DataTables. This object
|
||||
* is held in the settings aoColumns array and contains all the information that
|
||||
* DataTables needs about each individual column.
|
||||
*
|
||||
* Note that this object is related to {@link DataTable.defaults.columns}
|
||||
* but this one is the internal data store for DataTables's cache of columns.
|
||||
* It should NOT be manipulated outside of DataTables. Any configuration should
|
||||
* be done through the initialisation options.
|
||||
* @namespace
|
||||
*/
|
||||
DataTable.models.oColumn = {
|
||||
/**
|
||||
* A list of the columns that sorting should occur on when this column
|
||||
* is sorted. That this property is an array allows multi-column sorting
|
||||
* to be defined for a column (for example first name / last name columns
|
||||
* would benefit from this). The values are integers pointing to the
|
||||
* columns to be sorted on (typically it will be a single integer pointing
|
||||
* at itself, but that doesn't need to be the case).
|
||||
* @type array
|
||||
*/
|
||||
"aDataSort": null,
|
||||
|
||||
/**
|
||||
* Define the sorting directions that are applied to the column, in sequence
|
||||
* as the column is repeatedly sorted upon - i.e. the first value is used
|
||||
* as the sorting direction when the column if first sorted (clicked on).
|
||||
* Sort it again (click again) and it will move on to the next index.
|
||||
* Repeat until loop.
|
||||
* @type array
|
||||
*/
|
||||
"asSorting": null,
|
||||
|
||||
/**
|
||||
* Flag to indicate if the column is searchable, and thus should be included
|
||||
* in the filtering or not.
|
||||
* @type boolean
|
||||
*/
|
||||
"bSearchable": null,
|
||||
|
||||
/**
|
||||
* Flag to indicate if the column is sortable or not.
|
||||
* @type boolean
|
||||
*/
|
||||
"bSortable": null,
|
||||
|
||||
/**
|
||||
* <code>Deprecated</code> When using fnRender, you have two options for what
|
||||
* to do with the data, and this property serves as the switch. Firstly, you
|
||||
* can have the sorting and filtering use the rendered value (true - default),
|
||||
* or you can have the sorting and filtering us the original value (false).
|
||||
*
|
||||
* Please note that this option has now been deprecated and will be removed
|
||||
* in the next version of DataTables. Please use mRender / mData rather than
|
||||
* fnRender.
|
||||
* @type boolean
|
||||
* @deprecated
|
||||
*/
|
||||
"bUseRendered": null,
|
||||
|
||||
/**
|
||||
* Flag to indicate if the column is currently visible in the table or not
|
||||
* @type boolean
|
||||
*/
|
||||
"bVisible": null,
|
||||
|
||||
/**
|
||||
* Flag to indicate to the type detection method if the automatic type
|
||||
* detection should be used, or if a column type (sType) has been specified
|
||||
* @type boolean
|
||||
* @default true
|
||||
* @private
|
||||
*/
|
||||
"_bAutoType": true,
|
||||
|
||||
/**
|
||||
* Developer definable function that is called whenever a cell is created (Ajax source,
|
||||
* etc) or processed for input (DOM source). This can be used as a compliment to mRender
|
||||
* allowing you to modify the DOM element (add background colour for example) when the
|
||||
* element is available.
|
||||
* @type function
|
||||
* @param {element} nTd The TD node that has been created
|
||||
* @param {*} sData The Data for the cell
|
||||
* @param {array|object} oData The data for the whole row
|
||||
* @param {int} iRow The row index for the aoData data store
|
||||
* @default null
|
||||
*/
|
||||
"fnCreatedCell": null,
|
||||
|
||||
/**
|
||||
* Function to get data from a cell in a column. You should <b>never</b>
|
||||
* access data directly through _aData internally in DataTables - always use
|
||||
* the method attached to this property. It allows mData to function as
|
||||
* required. This function is automatically assigned by the column
|
||||
* initialisation method
|
||||
* @type function
|
||||
* @param {array|object} oData The data array/object for the array
|
||||
* (i.e. aoData[]._aData)
|
||||
* @param {string} sSpecific The specific data type you want to get -
|
||||
* 'display', 'type' 'filter' 'sort'
|
||||
* @returns {*} The data for the cell from the given row's data
|
||||
* @default null
|
||||
*/
|
||||
"fnGetData": null,
|
||||
|
||||
/**
|
||||
* <code>Deprecated</code> Custom display function that will be called for the
|
||||
* display of each cell in this column.
|
||||
*
|
||||
* Please note that this option has now been deprecated and will be removed
|
||||
* in the next version of DataTables. Please use mRender / mData rather than
|
||||
* fnRender.
|
||||
* @type function
|
||||
* @param {object} o Object with the following parameters:
|
||||
* @param {int} o.iDataRow The row in aoData
|
||||
* @param {int} o.iDataColumn The column in question
|
||||
* @param {array} o.aData The data for the row in question
|
||||
* @param {object} o.oSettings The settings object for this DataTables instance
|
||||
* @returns {string} The string you which to use in the display
|
||||
* @default null
|
||||
* @deprecated
|
||||
*/
|
||||
"fnRender": null,
|
||||
|
||||
/**
|
||||
* Function to set data for a cell in the column. You should <b>never</b>
|
||||
* set the data directly to _aData internally in DataTables - always use
|
||||
* this method. It allows mData to function as required. This function
|
||||
* is automatically assigned by the column initialisation method
|
||||
* @type function
|
||||
* @param {array|object} oData The data array/object for the array
|
||||
* (i.e. aoData[]._aData)
|
||||
* @param {*} sValue Value to set
|
||||
* @default null
|
||||
*/
|
||||
"fnSetData": null,
|
||||
|
||||
/**
|
||||
* Property to read the value for the cells in the column from the data
|
||||
* source array / object. If null, then the default content is used, if a
|
||||
* function is given then the return from the function is used.
|
||||
* @type function|int|string|null
|
||||
* @default null
|
||||
*/
|
||||
"mData": null,
|
||||
|
||||
/**
|
||||
* Partner property to mData which is used (only when defined) to get
|
||||
* the data - i.e. it is basically the same as mData, but without the
|
||||
* 'set' option, and also the data fed to it is the result from mData.
|
||||
* This is the rendering method to match the data method of mData.
|
||||
* @type function|int|string|null
|
||||
* @default null
|
||||
*/
|
||||
"mRender": null,
|
||||
|
||||
/**
|
||||
* Unique header TH/TD element for this column - this is what the sorting
|
||||
* listener is attached to (if sorting is enabled.)
|
||||
* @type node
|
||||
* @default null
|
||||
*/
|
||||
"nTh": null,
|
||||
|
||||
/**
|
||||
* Unique footer TH/TD element for this column (if there is one). Not used
|
||||
* in DataTables as such, but can be used for plug-ins to reference the
|
||||
* footer for each column.
|
||||
* @type node
|
||||
* @default null
|
||||
*/
|
||||
"nTf": null,
|
||||
|
||||
/**
|
||||
* The class to apply to all TD elements in the table's TBODY for the column
|
||||
* @type string
|
||||
* @default null
|
||||
*/
|
||||
"sClass": null,
|
||||
|
||||
/**
|
||||
* When DataTables calculates the column widths to assign to each column,
|
||||
* it finds the longest string in each column and then constructs a
|
||||
* temporary table and reads the widths from that. The problem with this
|
||||
* is that "mmm" is much wider then "iiii", but the latter is a longer
|
||||
* string - thus the calculation can go wrong (doing it properly and putting
|
||||
* it into an DOM object and measuring that is horribly(!) slow). Thus as
|
||||
* a "work around" we provide this option. It will append its value to the
|
||||
* text that is found to be the longest string for the column - i.e. padding.
|
||||
* @type string
|
||||
*/
|
||||
"sContentPadding": null,
|
||||
|
||||
/**
|
||||
* Allows a default value to be given for a column's data, and will be used
|
||||
* whenever a null data source is encountered (this can be because mData
|
||||
* is set to null, or because the data source itself is null).
|
||||
* @type string
|
||||
* @default null
|
||||
*/
|
||||
"sDefaultContent": null,
|
||||
|
||||
/**
|
||||
* Name for the column, allowing reference to the column by name as well as
|
||||
* by index (needs a lookup to work by name).
|
||||
* @type string
|
||||
*/
|
||||
"sName": null,
|
||||
|
||||
/**
|
||||
* Custom sorting data type - defines which of the available plug-ins in
|
||||
* afnSortData the custom sorting will use - if any is defined.
|
||||
* @type string
|
||||
* @default std
|
||||
*/
|
||||
"sSortDataType": 'std',
|
||||
|
||||
/**
|
||||
* Class to be applied to the header element when sorting on this column
|
||||
* @type string
|
||||
* @default null
|
||||
*/
|
||||
"sSortingClass": null,
|
||||
|
||||
/**
|
||||
* Class to be applied to the header element when sorting on this column -
|
||||
* when jQuery UI theming is used.
|
||||
* @type string
|
||||
* @default null
|
||||
*/
|
||||
"sSortingClassJUI": null,
|
||||
|
||||
/**
|
||||
* Title of the column - what is seen in the TH element (nTh).
|
||||
* @type string
|
||||
*/
|
||||
"sTitle": null,
|
||||
|
||||
/**
|
||||
* Column sorting and filtering type
|
||||
* @type string
|
||||
* @default null
|
||||
*/
|
||||
"sType": null,
|
||||
|
||||
/**
|
||||
* Width of the column
|
||||
* @type string
|
||||
* @default null
|
||||
*/
|
||||
"sWidth": null,
|
||||
|
||||
/**
|
||||
* Width of the column when it was first "encountered"
|
||||
* @type string
|
||||
* @default null
|
||||
*/
|
||||
"sWidthOrig": null
|
||||
};
|
||||
|
759
js/datatables/media/src/model/model.defaults.columns.js
Normal file
759
js/datatables/media/src/model/model.defaults.columns.js
Normal file
|
@ -0,0 +1,759 @@
|
|||
|
||||
|
||||
/**
|
||||
* Column options that can be given to DataTables at initialisation time.
|
||||
* @namespace
|
||||
*/
|
||||
DataTable.defaults.columns = {
|
||||
/**
|
||||
* Allows a column's sorting to take multiple columns into account when
|
||||
* doing a sort. For example first name / last name columns make sense to
|
||||
* do a multi-column sort over the two columns.
|
||||
* @type array
|
||||
* @default null <i>Takes the value of the column index automatically</i>
|
||||
* @dtopt Columns
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumnDefs
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumnDefs": [
|
||||
* { "aDataSort": [ 0, 1 ], "aTargets": [ 0 ] },
|
||||
* { "aDataSort": [ 1, 0 ], "aTargets": [ 1 ] },
|
||||
* { "aDataSort": [ 2, 3, 4 ], "aTargets": [ 2 ] }
|
||||
* ]
|
||||
* } );
|
||||
* } );
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumns
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumns": [
|
||||
* { "aDataSort": [ 0, 1 ] },
|
||||
* { "aDataSort": [ 1, 0 ] },
|
||||
* { "aDataSort": [ 2, 3, 4 ] },
|
||||
* null,
|
||||
* null
|
||||
* ]
|
||||
* } );
|
||||
* } );
|
||||
*/
|
||||
"aDataSort": null,
|
||||
|
||||
|
||||
/**
|
||||
* You can control the default sorting direction, and even alter the behaviour
|
||||
* of the sort handler (i.e. only allow ascending sorting etc) using this
|
||||
* parameter.
|
||||
* @type array
|
||||
* @default [ 'asc', 'desc' ]
|
||||
* @dtopt Columns
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumnDefs
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumnDefs": [
|
||||
* { "asSorting": [ "asc" ], "aTargets": [ 1 ] },
|
||||
* { "asSorting": [ "desc", "asc", "asc" ], "aTargets": [ 2 ] },
|
||||
* { "asSorting": [ "desc" ], "aTargets": [ 3 ] }
|
||||
* ]
|
||||
* } );
|
||||
* } );
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumns
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumns": [
|
||||
* null,
|
||||
* { "asSorting": [ "asc" ] },
|
||||
* { "asSorting": [ "desc", "asc", "asc" ] },
|
||||
* { "asSorting": [ "desc" ] },
|
||||
* null
|
||||
* ]
|
||||
* } );
|
||||
* } );
|
||||
*/
|
||||
"asSorting": [ 'asc', 'desc' ],
|
||||
|
||||
|
||||
/**
|
||||
* Enable or disable filtering on the data in this column.
|
||||
* @type boolean
|
||||
* @default true
|
||||
* @dtopt Columns
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumnDefs
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumnDefs": [
|
||||
* { "bSearchable": false, "aTargets": [ 0 ] }
|
||||
* ] } );
|
||||
* } );
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumns
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumns": [
|
||||
* { "bSearchable": false },
|
||||
* null,
|
||||
* null,
|
||||
* null,
|
||||
* null
|
||||
* ] } );
|
||||
* } );
|
||||
*/
|
||||
"bSearchable": true,
|
||||
|
||||
|
||||
/**
|
||||
* Enable or disable sorting on this column.
|
||||
* @type boolean
|
||||
* @default true
|
||||
* @dtopt Columns
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumnDefs
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumnDefs": [
|
||||
* { "bSortable": false, "aTargets": [ 0 ] }
|
||||
* ] } );
|
||||
* } );
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumns
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumns": [
|
||||
* { "bSortable": false },
|
||||
* null,
|
||||
* null,
|
||||
* null,
|
||||
* null
|
||||
* ] } );
|
||||
* } );
|
||||
*/
|
||||
"bSortable": true,
|
||||
|
||||
|
||||
/**
|
||||
* <code>Deprecated</code> When using fnRender() for a column, you may wish
|
||||
* to use the original data (before rendering) for sorting and filtering
|
||||
* (the default is to used the rendered data that the user can see). This
|
||||
* may be useful for dates etc.
|
||||
*
|
||||
* Please note that this option has now been deprecated and will be removed
|
||||
* in the next version of DataTables. Please use mRender / mData rather than
|
||||
* fnRender.
|
||||
* @type boolean
|
||||
* @default true
|
||||
* @dtopt Columns
|
||||
* @deprecated
|
||||
*/
|
||||
"bUseRendered": true,
|
||||
|
||||
|
||||
/**
|
||||
* Enable or disable the display of this column.
|
||||
* @type boolean
|
||||
* @default true
|
||||
* @dtopt Columns
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumnDefs
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumnDefs": [
|
||||
* { "bVisible": false, "aTargets": [ 0 ] }
|
||||
* ] } );
|
||||
* } );
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumns
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumns": [
|
||||
* { "bVisible": false },
|
||||
* null,
|
||||
* null,
|
||||
* null,
|
||||
* null
|
||||
* ] } );
|
||||
* } );
|
||||
*/
|
||||
"bVisible": true,
|
||||
|
||||
|
||||
/**
|
||||
* Developer definable function that is called whenever a cell is created (Ajax source,
|
||||
* etc) or processed for input (DOM source). This can be used as a compliment to mRender
|
||||
* allowing you to modify the DOM element (add background colour for example) when the
|
||||
* element is available.
|
||||
* @type function
|
||||
* @param {element} nTd The TD node that has been created
|
||||
* @param {*} sData The Data for the cell
|
||||
* @param {array|object} oData The data for the whole row
|
||||
* @param {int} iRow The row index for the aoData data store
|
||||
* @param {int} iCol The column index for aoColumns
|
||||
* @dtopt Columns
|
||||
*
|
||||
* @example
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumnDefs": [ {
|
||||
* "aTargets": [3],
|
||||
* "fnCreatedCell": function (nTd, sData, oData, iRow, iCol) {
|
||||
* if ( sData == "1.7" ) {
|
||||
* $(nTd).css('color', 'blue')
|
||||
* }
|
||||
* }
|
||||
* } ]
|
||||
* });
|
||||
* } );
|
||||
*/
|
||||
"fnCreatedCell": null,
|
||||
|
||||
|
||||
/**
|
||||
* <code>Deprecated</code> Custom display function that will be called for the
|
||||
* display of each cell in this column.
|
||||
*
|
||||
* Please note that this option has now been deprecated and will be removed
|
||||
* in the next version of DataTables. Please use mRender / mData rather than
|
||||
* fnRender.
|
||||
* @type function
|
||||
* @param {object} o Object with the following parameters:
|
||||
* @param {int} o.iDataRow The row in aoData
|
||||
* @param {int} o.iDataColumn The column in question
|
||||
* @param {array} o.aData The data for the row in question
|
||||
* @param {object} o.oSettings The settings object for this DataTables instance
|
||||
* @param {object} o.mDataProp The data property used for this column
|
||||
* @param {*} val The current cell value
|
||||
* @returns {string} The string you which to use in the display
|
||||
* @dtopt Columns
|
||||
* @deprecated
|
||||
*/
|
||||
"fnRender": null,
|
||||
|
||||
|
||||
/**
|
||||
* The column index (starting from 0!) that you wish a sort to be performed
|
||||
* upon when this column is selected for sorting. This can be used for sorting
|
||||
* on hidden columns for example.
|
||||
* @type int
|
||||
* @default -1 <i>Use automatically calculated column index</i>
|
||||
* @dtopt Columns
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumnDefs
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumnDefs": [
|
||||
* { "iDataSort": 1, "aTargets": [ 0 ] }
|
||||
* ]
|
||||
* } );
|
||||
* } );
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumns
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumns": [
|
||||
* { "iDataSort": 1 },
|
||||
* null,
|
||||
* null,
|
||||
* null,
|
||||
* null
|
||||
* ]
|
||||
* } );
|
||||
* } );
|
||||
*/
|
||||
"iDataSort": -1,
|
||||
|
||||
|
||||
/**
|
||||
* This parameter has been replaced by mData in DataTables to ensure naming
|
||||
* consistency. mDataProp can still be used, as there is backwards compatibility
|
||||
* in DataTables for this option, but it is strongly recommended that you use
|
||||
* mData in preference to mDataProp.
|
||||
* @name DataTable.defaults.columns.mDataProp
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* This property can be used to read data from any JSON data source property,
|
||||
* including deeply nested objects / properties. mData can be given in a
|
||||
* number of different ways which effect its behaviour:
|
||||
* <ul>
|
||||
* <li>integer - treated as an array index for the data source. This is the
|
||||
* default that DataTables uses (incrementally increased for each column).</li>
|
||||
* <li>string - read an object property from the data source. Note that you can
|
||||
* use Javascript dotted notation to read deep properties / arrays from the
|
||||
* data source.</li>
|
||||
* <li>null - the sDefaultContent option will be used for the cell (null
|
||||
* by default, so you will need to specify the default content you want -
|
||||
* typically an empty string). This can be useful on generated columns such
|
||||
* as edit / delete action columns.</li>
|
||||
* <li>function - the function given will be executed whenever DataTables
|
||||
* needs to set or get the data for a cell in the column. The function
|
||||
* takes three parameters:
|
||||
* <ul>
|
||||
* <li>{array|object} The data source for the row</li>
|
||||
* <li>{string} The type call data requested - this will be 'set' when
|
||||
* setting data or 'filter', 'display', 'type', 'sort' or undefined when
|
||||
* gathering data. Note that when <i>undefined</i> is given for the type
|
||||
* DataTables expects to get the raw data for the object back</li>
|
||||
* <li>{*} Data to set when the second parameter is 'set'.</li>
|
||||
* </ul>
|
||||
* The return value from the function is not required when 'set' is the type
|
||||
* of call, but otherwise the return is what will be used for the data
|
||||
* requested.</li>
|
||||
* </ul>
|
||||
*
|
||||
* Note that prior to DataTables 1.9.2 mData was called mDataProp. The name change
|
||||
* reflects the flexibility of this property and is consistent with the naming of
|
||||
* mRender. If 'mDataProp' is given, then it will still be used by DataTables, as
|
||||
* it automatically maps the old name to the new if required.
|
||||
* @type string|int|function|null
|
||||
* @default null <i>Use automatically calculated column index</i>
|
||||
* @dtopt Columns
|
||||
*
|
||||
* @example
|
||||
* // Read table data from objects
|
||||
* $(document).ready( function() {
|
||||
* var oTable = $('#example').dataTable( {
|
||||
* "sAjaxSource": "sources/deep.txt",
|
||||
* "aoColumns": [
|
||||
* { "mData": "engine" },
|
||||
* { "mData": "browser" },
|
||||
* { "mData": "platform.inner" },
|
||||
* { "mData": "platform.details.0" },
|
||||
* { "mData": "platform.details.1" }
|
||||
* ]
|
||||
* } );
|
||||
* } );
|
||||
*
|
||||
* @example
|
||||
* // Using mData as a function to provide different information for
|
||||
* // sorting, filtering and display. In this case, currency (price)
|
||||
* $(document).ready( function() {
|
||||
* var oTable = $('#example').dataTable( {
|
||||
* "aoColumnDefs": [ {
|
||||
* "aTargets": [ 0 ],
|
||||
* "mData": function ( source, type, val ) {
|
||||
* if (type === 'set') {
|
||||
* source.price = val;
|
||||
* // Store the computed dislay and filter values for efficiency
|
||||
* source.price_display = val=="" ? "" : "$"+numberFormat(val);
|
||||
* source.price_filter = val=="" ? "" : "$"+numberFormat(val)+" "+val;
|
||||
* return;
|
||||
* }
|
||||
* else if (type === 'display') {
|
||||
* return source.price_display;
|
||||
* }
|
||||
* else if (type === 'filter') {
|
||||
* return source.price_filter;
|
||||
* }
|
||||
* // 'sort', 'type' and undefined all just use the integer
|
||||
* return source.price;
|
||||
* }
|
||||
* } ]
|
||||
* } );
|
||||
* } );
|
||||
*/
|
||||
"mData": null,
|
||||
|
||||
|
||||
/**
|
||||
* This property is the rendering partner to mData and it is suggested that
|
||||
* when you want to manipulate data for display (including filtering, sorting etc)
|
||||
* but not altering the underlying data for the table, use this property. mData
|
||||
* can actually do everything this property can and more, but this parameter is
|
||||
* easier to use since there is no 'set' option. Like mData is can be given
|
||||
* in a number of different ways to effect its behaviour, with the addition of
|
||||
* supporting array syntax for easy outputting of arrays (including arrays of
|
||||
* objects):
|
||||
* <ul>
|
||||
* <li>integer - treated as an array index for the data source. This is the
|
||||
* default that DataTables uses (incrementally increased for each column).</li>
|
||||
* <li>string - read an object property from the data source. Note that you can
|
||||
* use Javascript dotted notation to read deep properties / arrays from the
|
||||
* data source and also array brackets to indicate that the data reader should
|
||||
* loop over the data source array. When characters are given between the array
|
||||
* brackets, these characters are used to join the data source array together.
|
||||
* For example: "accounts[, ].name" would result in a comma separated list with
|
||||
* the 'name' value from the 'accounts' array of objects.</li>
|
||||
* <li>function - the function given will be executed whenever DataTables
|
||||
* needs to set or get the data for a cell in the column. The function
|
||||
* takes three parameters:
|
||||
* <ul>
|
||||
* <li>{array|object} The data source for the row (based on mData)</li>
|
||||
* <li>{string} The type call data requested - this will be 'filter', 'display',
|
||||
* 'type' or 'sort'.</li>
|
||||
* <li>{array|object} The full data source for the row (not based on mData)</li>
|
||||
* </ul>
|
||||
* The return value from the function is what will be used for the data
|
||||
* requested.</li>
|
||||
* </ul>
|
||||
* @type string|int|function|null
|
||||
* @default null <i>Use mData</i>
|
||||
* @dtopt Columns
|
||||
*
|
||||
* @example
|
||||
* // Create a comma separated list from an array of objects
|
||||
* $(document).ready( function() {
|
||||
* var oTable = $('#example').dataTable( {
|
||||
* "sAjaxSource": "sources/deep.txt",
|
||||
* "aoColumns": [
|
||||
* { "mData": "engine" },
|
||||
* { "mData": "browser" },
|
||||
* {
|
||||
* "mData": "platform",
|
||||
* "mRender": "[, ].name"
|
||||
* }
|
||||
* ]
|
||||
* } );
|
||||
* } );
|
||||
*
|
||||
* @example
|
||||
* // Use as a function to create a link from the data source
|
||||
* $(document).ready( function() {
|
||||
* var oTable = $('#example').dataTable( {
|
||||
* "aoColumnDefs": [
|
||||
* {
|
||||
* "aTargets": [ 0 ],
|
||||
* "mData": "download_link",
|
||||
* "mRender": function ( data, type, full ) {
|
||||
* return '<a href="'+data+'">Download</a>';
|
||||
* }
|
||||
* ]
|
||||
* } );
|
||||
* } );
|
||||
*/
|
||||
"mRender": null,
|
||||
|
||||
|
||||
/**
|
||||
* Change the cell type created for the column - either TD cells or TH cells. This
|
||||
* can be useful as TH cells have semantic meaning in the table body, allowing them
|
||||
* to act as a header for a row (you may wish to add scope='row' to the TH elements).
|
||||
* @type string
|
||||
* @default td
|
||||
* @dtopt Columns
|
||||
*
|
||||
* @example
|
||||
* // Make the first column use TH cells
|
||||
* $(document).ready( function() {
|
||||
* var oTable = $('#example').dataTable( {
|
||||
* "aoColumnDefs": [ {
|
||||
* "aTargets": [ 0 ],
|
||||
* "sCellType": "th"
|
||||
* } ]
|
||||
* } );
|
||||
* } );
|
||||
*/
|
||||
"sCellType": "td",
|
||||
|
||||
|
||||
/**
|
||||
* Class to give to each cell in this column.
|
||||
* @type string
|
||||
* @default <i>Empty string</i>
|
||||
* @dtopt Columns
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumnDefs
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumnDefs": [
|
||||
* { "sClass": "my_class", "aTargets": [ 0 ] }
|
||||
* ]
|
||||
* } );
|
||||
* } );
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumns
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumns": [
|
||||
* { "sClass": "my_class" },
|
||||
* null,
|
||||
* null,
|
||||
* null,
|
||||
* null
|
||||
* ]
|
||||
* } );
|
||||
* } );
|
||||
*/
|
||||
"sClass": "",
|
||||
|
||||
/**
|
||||
* When DataTables calculates the column widths to assign to each column,
|
||||
* it finds the longest string in each column and then constructs a
|
||||
* temporary table and reads the widths from that. The problem with this
|
||||
* is that "mmm" is much wider then "iiii", but the latter is a longer
|
||||
* string - thus the calculation can go wrong (doing it properly and putting
|
||||
* it into an DOM object and measuring that is horribly(!) slow). Thus as
|
||||
* a "work around" we provide this option. It will append its value to the
|
||||
* text that is found to be the longest string for the column - i.e. padding.
|
||||
* Generally you shouldn't need this, and it is not documented on the
|
||||
* general DataTables.net documentation
|
||||
* @type string
|
||||
* @default <i>Empty string<i>
|
||||
* @dtopt Columns
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumns
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumns": [
|
||||
* null,
|
||||
* null,
|
||||
* null,
|
||||
* {
|
||||
* "sContentPadding": "mmm"
|
||||
* }
|
||||
* ]
|
||||
* } );
|
||||
* } );
|
||||
*/
|
||||
"sContentPadding": "",
|
||||
|
||||
|
||||
/**
|
||||
* Allows a default value to be given for a column's data, and will be used
|
||||
* whenever a null data source is encountered (this can be because mData
|
||||
* is set to null, or because the data source itself is null).
|
||||
* @type string
|
||||
* @default null
|
||||
* @dtopt Columns
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumnDefs
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumnDefs": [
|
||||
* {
|
||||
* "mData": null,
|
||||
* "sDefaultContent": "Edit",
|
||||
* "aTargets": [ -1 ]
|
||||
* }
|
||||
* ]
|
||||
* } );
|
||||
* } );
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumns
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumns": [
|
||||
* null,
|
||||
* null,
|
||||
* null,
|
||||
* {
|
||||
* "mData": null,
|
||||
* "sDefaultContent": "Edit"
|
||||
* }
|
||||
* ]
|
||||
* } );
|
||||
* } );
|
||||
*/
|
||||
"sDefaultContent": null,
|
||||
|
||||
|
||||
/**
|
||||
* This parameter is only used in DataTables' server-side processing. It can
|
||||
* be exceptionally useful to know what columns are being displayed on the
|
||||
* client side, and to map these to database fields. When defined, the names
|
||||
* also allow DataTables to reorder information from the server if it comes
|
||||
* back in an unexpected order (i.e. if you switch your columns around on the
|
||||
* client-side, your server-side code does not also need updating).
|
||||
* @type string
|
||||
* @default <i>Empty string</i>
|
||||
* @dtopt Columns
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumnDefs
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumnDefs": [
|
||||
* { "sName": "engine", "aTargets": [ 0 ] },
|
||||
* { "sName": "browser", "aTargets": [ 1 ] },
|
||||
* { "sName": "platform", "aTargets": [ 2 ] },
|
||||
* { "sName": "version", "aTargets": [ 3 ] },
|
||||
* { "sName": "grade", "aTargets": [ 4 ] }
|
||||
* ]
|
||||
* } );
|
||||
* } );
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumns
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumns": [
|
||||
* { "sName": "engine" },
|
||||
* { "sName": "browser" },
|
||||
* { "sName": "platform" },
|
||||
* { "sName": "version" },
|
||||
* { "sName": "grade" }
|
||||
* ]
|
||||
* } );
|
||||
* } );
|
||||
*/
|
||||
"sName": "",
|
||||
|
||||
|
||||
/**
|
||||
* Defines a data source type for the sorting which can be used to read
|
||||
* real-time information from the table (updating the internally cached
|
||||
* version) prior to sorting. This allows sorting to occur on user editable
|
||||
* elements such as form inputs.
|
||||
* @type string
|
||||
* @default std
|
||||
* @dtopt Columns
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumnDefs
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumnDefs": [
|
||||
* { "sSortDataType": "dom-text", "aTargets": [ 2, 3 ] },
|
||||
* { "sType": "numeric", "aTargets": [ 3 ] },
|
||||
* { "sSortDataType": "dom-select", "aTargets": [ 4 ] },
|
||||
* { "sSortDataType": "dom-checkbox", "aTargets": [ 5 ] }
|
||||
* ]
|
||||
* } );
|
||||
* } );
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumns
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumns": [
|
||||
* null,
|
||||
* null,
|
||||
* { "sSortDataType": "dom-text" },
|
||||
* { "sSortDataType": "dom-text", "sType": "numeric" },
|
||||
* { "sSortDataType": "dom-select" },
|
||||
* { "sSortDataType": "dom-checkbox" }
|
||||
* ]
|
||||
* } );
|
||||
* } );
|
||||
*/
|
||||
"sSortDataType": "std",
|
||||
|
||||
|
||||
/**
|
||||
* The title of this column.
|
||||
* @type string
|
||||
* @default null <i>Derived from the 'TH' value for this column in the
|
||||
* original HTML table.</i>
|
||||
* @dtopt Columns
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumnDefs
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumnDefs": [
|
||||
* { "sTitle": "My column title", "aTargets": [ 0 ] }
|
||||
* ]
|
||||
* } );
|
||||
* } );
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumns
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumns": [
|
||||
* { "sTitle": "My column title" },
|
||||
* null,
|
||||
* null,
|
||||
* null,
|
||||
* null
|
||||
* ]
|
||||
* } );
|
||||
* } );
|
||||
*/
|
||||
"sTitle": null,
|
||||
|
||||
|
||||
/**
|
||||
* The type allows you to specify how the data for this column will be sorted.
|
||||
* Four types (string, numeric, date and html (which will strip HTML tags
|
||||
* before sorting)) are currently available. Note that only date formats
|
||||
* understood by Javascript's Date() object will be accepted as type date. For
|
||||
* example: "Mar 26, 2008 5:03 PM". May take the values: 'string', 'numeric',
|
||||
* 'date' or 'html' (by default). Further types can be adding through
|
||||
* plug-ins.
|
||||
* @type string
|
||||
* @default null <i>Auto-detected from raw data</i>
|
||||
* @dtopt Columns
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumnDefs
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumnDefs": [
|
||||
* { "sType": "html", "aTargets": [ 0 ] }
|
||||
* ]
|
||||
* } );
|
||||
* } );
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumns
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumns": [
|
||||
* { "sType": "html" },
|
||||
* null,
|
||||
* null,
|
||||
* null,
|
||||
* null
|
||||
* ]
|
||||
* } );
|
||||
* } );
|
||||
*/
|
||||
"sType": null,
|
||||
|
||||
|
||||
/**
|
||||
* Defining the width of the column, this parameter may take any CSS value
|
||||
* (3em, 20px etc). DataTables apples 'smart' widths to columns which have not
|
||||
* been given a specific width through this interface ensuring that the table
|
||||
* remains readable.
|
||||
* @type string
|
||||
* @default null <i>Automatic</i>
|
||||
* @dtopt Columns
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumnDefs
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumnDefs": [
|
||||
* { "sWidth": "20%", "aTargets": [ 0 ] }
|
||||
* ]
|
||||
* } );
|
||||
* } );
|
||||
*
|
||||
* @example
|
||||
* // Using aoColumns
|
||||
* $(document).ready( function() {
|
||||
* $('#example').dataTable( {
|
||||
* "aoColumns": [
|
||||
* { "sWidth": "20%" },
|
||||
* null,
|
||||
* null,
|
||||
* null,
|
||||
* null
|
||||
* ]
|
||||
* } );
|
||||
* } );
|
||||
*/
|
||||
"sWidth": null
|
||||
};
|
||||
|
1952
js/datatables/media/src/model/model.defaults.js
Normal file
1952
js/datatables/media/src/model/model.defaults.js
Normal file
File diff suppressed because it is too large
Load diff
528
js/datatables/media/src/model/model.ext.js
Normal file
528
js/datatables/media/src/model/model.ext.js
Normal file
|
@ -0,0 +1,528 @@
|
|||
|
||||
|
||||
/**
|
||||
* DataTables extension options and plug-ins. This namespace acts as a collection "area"
|
||||
* for plug-ins that can be used to extend the default DataTables behaviour - indeed many
|
||||
* of the build in methods use this method to provide their own capabilities (sorting methods
|
||||
* for example).
|
||||
*
|
||||
* Note that this namespace is aliased to jQuery.fn.dataTableExt so it can be readily accessed
|
||||
* and modified by plug-ins.
|
||||
* @namespace
|
||||
*/
|
||||
DataTable.models.ext = {
|
||||
/**
|
||||
* Plug-in filtering functions - this method of filtering is complimentary to the default
|
||||
* type based filtering, and a lot more comprehensive as it allows you complete control
|
||||
* over the filtering logic. Each element in this array is a function (parameters
|
||||
* described below) that is called for every row in the table, and your logic decides if
|
||||
* it should be included in the filtered data set or not.
|
||||
* <ul>
|
||||
* <li>
|
||||
* Function input parameters:
|
||||
* <ul>
|
||||
* <li>{object} DataTables settings object: see {@link DataTable.models.oSettings}.</li>
|
||||
* <li>{array|object} Data for the row to be processed (same as the original format
|
||||
* that was passed in as the data source, or an array from a DOM data source</li>
|
||||
* <li>{int} Row index in aoData ({@link DataTable.models.oSettings.aoData}), which can
|
||||
* be useful to retrieve the TR element if you need DOM interaction.</li>
|
||||
* </ul>
|
||||
* </li>
|
||||
* <li>
|
||||
* Function return:
|
||||
* <ul>
|
||||
* <li>{boolean} Include the row in the filtered result set (true) or not (false)</li>
|
||||
* </ul>
|
||||
* </il>
|
||||
* </ul>
|
||||
* @type array
|
||||
* @default []
|
||||
*
|
||||
* @example
|
||||
* // The following example shows custom filtering being applied to the fourth column (i.e.
|
||||
* // the aData[3] index) based on two input values from the end-user, matching the data in
|
||||
* // a certain range.
|
||||
* $.fn.dataTableExt.afnFiltering.push(
|
||||
* function( oSettings, aData, iDataIndex ) {
|
||||
* var iMin = document.getElementById('min').value * 1;
|
||||
* var iMax = document.getElementById('max').value * 1;
|
||||
* var iVersion = aData[3] == "-" ? 0 : aData[3]*1;
|
||||
* if ( iMin == "" && iMax == "" ) {
|
||||
* return true;
|
||||
* }
|
||||
* else if ( iMin == "" && iVersion < iMax ) {
|
||||
* return true;
|
||||
* }
|
||||
* else if ( iMin < iVersion && "" == iMax ) {
|
||||
* return true;
|
||||
* }
|
||||
* else if ( iMin < iVersion && iVersion < iMax ) {
|
||||
* return true;
|
||||
* }
|
||||
* return false;
|
||||
* }
|
||||
* );
|
||||
*/
|
||||
"afnFiltering": [],
|
||||
|
||||
|
||||
/**
|
||||
* Plug-in sorting functions - this method of sorting is complimentary to the default type
|
||||
* based sorting that DataTables does automatically, allowing much greater control over the
|
||||
* the data that is being used to sort a column. This is useful if you want to do sorting
|
||||
* based on live data (for example the contents of an 'input' element) rather than just the
|
||||
* static string that DataTables knows of. The way these plug-ins work is that you create
|
||||
* an array of the values you wish to be sorted for the column in question and then return
|
||||
* that array. Which pre-sorting function is run here depends on the sSortDataType parameter
|
||||
* that is used for the column (if any). This is the corollary of <i>ofnSearch</i> for sort
|
||||
* data.
|
||||
* <ul>
|
||||
* <li>
|
||||
* Function input parameters:
|
||||
* <ul>
|
||||
* <li>{object} DataTables settings object: see {@link DataTable.models.oSettings}.</li>
|
||||
* <li>{int} Target column index</li>
|
||||
* </ul>
|
||||
* </li>
|
||||
* <li>
|
||||
* Function return:
|
||||
* <ul>
|
||||
* <li>{array} Data for the column to be sorted upon</li>
|
||||
* </ul>
|
||||
* </il>
|
||||
* </ul>
|
||||
*
|
||||
* Note that as of v1.9, it is typically preferable to use <i>mData</i> to prepare data for
|
||||
* the different uses that DataTables can put the data to. Specifically <i>mData</i> when
|
||||
* used as a function will give you a 'type' (sorting, filtering etc) that you can use to
|
||||
* prepare the data as required for the different types. As such, this method is deprecated.
|
||||
* @type array
|
||||
* @default []
|
||||
* @deprecated
|
||||
*
|
||||
* @example
|
||||
* // Updating the cached sorting information with user entered values in HTML input elements
|
||||
* jQuery.fn.dataTableExt.afnSortData['dom-text'] = function ( oSettings, iColumn )
|
||||
* {
|
||||
* var aData = [];
|
||||
* $( 'td:eq('+iColumn+') input', oSettings.oApi._fnGetTrNodes(oSettings) ).each( function () {
|
||||
* aData.push( this.value );
|
||||
* } );
|
||||
* return aData;
|
||||
* }
|
||||
*/
|
||||
"afnSortData": [],
|
||||
|
||||
|
||||
/**
|
||||
* Feature plug-ins - This is an array of objects which describe the feature plug-ins that are
|
||||
* available to DataTables. These feature plug-ins are accessible through the sDom initialisation
|
||||
* option. As such, each feature plug-in must describe a function that is used to initialise
|
||||
* itself (fnInit), a character so the feature can be enabled by sDom (cFeature) and the name
|
||||
* of the feature (sFeature). Thus the objects attached to this method must provide:
|
||||
* <ul>
|
||||
* <li>{function} fnInit Initialisation of the plug-in
|
||||
* <ul>
|
||||
* <li>
|
||||
* Function input parameters:
|
||||
* <ul>
|
||||
* <li>{object} DataTables settings object: see {@link DataTable.models.oSettings}.</li>
|
||||
* </ul>
|
||||
* </li>
|
||||
* <li>
|
||||
* Function return:
|
||||
* <ul>
|
||||
* <li>{node|null} The element which contains your feature. Note that the return
|
||||
* may also be void if your plug-in does not require to inject any DOM elements
|
||||
* into DataTables control (sDom) - for example this might be useful when
|
||||
* developing a plug-in which allows table control via keyboard entry.</li>
|
||||
* </ul>
|
||||
* </il>
|
||||
* </ul>
|
||||
* </li>
|
||||
* <li>{character} cFeature Character that will be matched in sDom - case sensitive</li>
|
||||
* <li>{string} sFeature Feature name</li>
|
||||
* </ul>
|
||||
* @type array
|
||||
* @default []
|
||||
*
|
||||
* @example
|
||||
* // How TableTools initialises itself.
|
||||
* $.fn.dataTableExt.aoFeatures.push( {
|
||||
* "fnInit": function( oSettings ) {
|
||||
* return new TableTools( { "oDTSettings": oSettings } );
|
||||
* },
|
||||
* "cFeature": "T",
|
||||
* "sFeature": "TableTools"
|
||||
* } );
|
||||
*/
|
||||
"aoFeatures": [],
|
||||
|
||||
|
||||
/**
|
||||
* Type detection plug-in functions - DataTables utilises types to define how sorting and
|
||||
* filtering behave, and types can be either be defined by the developer (sType for the
|
||||
* column) or they can be automatically detected by the methods in this array. The functions
|
||||
* defined in the array are quite simple, taking a single parameter (the data to analyse)
|
||||
* and returning the type if it is a known type, or null otherwise.
|
||||
* <ul>
|
||||
* <li>
|
||||
* Function input parameters:
|
||||
* <ul>
|
||||
* <li>{*} Data from the column cell to be analysed</li>
|
||||
* </ul>
|
||||
* </li>
|
||||
* <li>
|
||||
* Function return:
|
||||
* <ul>
|
||||
* <li>{string|null} Data type detected, or null if unknown (and thus pass it
|
||||
* on to the other type detection functions.</li>
|
||||
* </ul>
|
||||
* </il>
|
||||
* </ul>
|
||||
* @type array
|
||||
* @default []
|
||||
*
|
||||
* @example
|
||||
* // Currency type detection plug-in:
|
||||
* jQuery.fn.dataTableExt.aTypes.push(
|
||||
* function ( sData ) {
|
||||
* var sValidChars = "0123456789.-";
|
||||
* var Char;
|
||||
*
|
||||
* // Check the numeric part
|
||||
* for ( i=1 ; i<sData.length ; i++ ) {
|
||||
* Char = sData.charAt(i);
|
||||
* if (sValidChars.indexOf(Char) == -1) {
|
||||
* return null;
|
||||
* }
|
||||
* }
|
||||
*
|
||||
* // Check prefixed by currency
|
||||
* if ( sData.charAt(0) == '$' || sData.charAt(0) == '£' ) {
|
||||
* return 'currency';
|
||||
* }
|
||||
* return null;
|
||||
* }
|
||||
* );
|
||||
*/
|
||||
"aTypes": [],
|
||||
|
||||
|
||||
/**
|
||||
* Provide a common method for plug-ins to check the version of DataTables being used,
|
||||
* in order to ensure compatibility.
|
||||
* @type function
|
||||
* @param {string} sVersion Version string to check for, in the format "X.Y.Z". Note
|
||||
* that the formats "X" and "X.Y" are also acceptable.
|
||||
* @returns {boolean} true if this version of DataTables is greater or equal to the
|
||||
* required version, or false if this version of DataTales is not suitable
|
||||
*
|
||||
* @example
|
||||
* $(document).ready(function() {
|
||||
* var oTable = $('#example').dataTable();
|
||||
* alert( oTable.fnVersionCheck( '1.9.0' ) );
|
||||
* } );
|
||||
*/
|
||||
"fnVersionCheck": DataTable.fnVersionCheck,
|
||||
|
||||
|
||||
/**
|
||||
* Index for what 'this' index API functions should use
|
||||
* @type int
|
||||
* @default 0
|
||||
*/
|
||||
"iApiIndex": 0,
|
||||
|
||||
|
||||
/**
|
||||
* Pre-processing of filtering data plug-ins - When you assign the sType for a column
|
||||
* (or have it automatically detected for you by DataTables or a type detection plug-in),
|
||||
* you will typically be using this for custom sorting, but it can also be used to provide
|
||||
* custom filtering by allowing you to pre-processing the data and returning the data in
|
||||
* the format that should be filtered upon. This is done by adding functions this object
|
||||
* with a parameter name which matches the sType for that target column. This is the
|
||||
* corollary of <i>afnSortData</i> for filtering data.
|
||||
* <ul>
|
||||
* <li>
|
||||
* Function input parameters:
|
||||
* <ul>
|
||||
* <li>{*} Data from the column cell to be prepared for filtering</li>
|
||||
* </ul>
|
||||
* </li>
|
||||
* <li>
|
||||
* Function return:
|
||||
* <ul>
|
||||
* <li>{string|null} Formatted string that will be used for the filtering.</li>
|
||||
* </ul>
|
||||
* </il>
|
||||
* </ul>
|
||||
*
|
||||
* Note that as of v1.9, it is typically preferable to use <i>mData</i> to prepare data for
|
||||
* the different uses that DataTables can put the data to. Specifically <i>mData</i> when
|
||||
* used as a function will give you a 'type' (sorting, filtering etc) that you can use to
|
||||
* prepare the data as required for the different types. As such, this method is deprecated.
|
||||
* @type object
|
||||
* @default {}
|
||||
* @deprecated
|
||||
*
|
||||
* @example
|
||||
* $.fn.dataTableExt.ofnSearch['title-numeric'] = function ( sData ) {
|
||||
* return sData.replace(/\n/g," ").replace( /<.*?>/g, "" );
|
||||
* }
|
||||
*/
|
||||
"ofnSearch": {},
|
||||
|
||||
|
||||
/**
|
||||
* Container for all private functions in DataTables so they can be exposed externally
|
||||
* @type object
|
||||
* @default {}
|
||||
*/
|
||||
"oApi": {},
|
||||
|
||||
|
||||
/**
|
||||
* Storage for the various classes that DataTables uses
|
||||
* @type object
|
||||
* @default {}
|
||||
*/
|
||||
"oStdClasses": {},
|
||||
|
||||
|
||||
/**
|
||||
* Storage for the various classes that DataTables uses - jQuery UI suitable
|
||||
* @type object
|
||||
* @default {}
|
||||
*/
|
||||
"oJUIClasses": {},
|
||||
|
||||
|
||||
/**
|
||||
* Pagination plug-in methods - The style and controls of the pagination can significantly
|
||||
* impact on how the end user interacts with the data in your table, and DataTables allows
|
||||
* the addition of pagination controls by extending this object, which can then be enabled
|
||||
* through the <i>sPaginationType</i> initialisation parameter. Each pagination type that
|
||||
* is added is an object (the property name of which is what <i>sPaginationType</i> refers
|
||||
* to) that has two properties, both methods that are used by DataTables to update the
|
||||
* control's state.
|
||||
* <ul>
|
||||
* <li>
|
||||
* fnInit - Initialisation of the paging controls. Called only during initialisation
|
||||
* of the table. It is expected that this function will add the required DOM elements
|
||||
* to the page for the paging controls to work. The element pointer
|
||||
* 'oSettings.aanFeatures.p' array is provided by DataTables to contain the paging
|
||||
* controls (note that this is a 2D array to allow for multiple instances of each
|
||||
* DataTables DOM element). It is suggested that you add the controls to this element
|
||||
* as children
|
||||
* <ul>
|
||||
* <li>
|
||||
* Function input parameters:
|
||||
* <ul>
|
||||
* <li>{object} DataTables settings object: see {@link DataTable.models.oSettings}.</li>
|
||||
* <li>{node} Container into which the pagination controls must be inserted</li>
|
||||
* <li>{function} Draw callback function - whenever the controls cause a page
|
||||
* change, this method must be called to redraw the table.</li>
|
||||
* </ul>
|
||||
* </li>
|
||||
* <li>
|
||||
* Function return:
|
||||
* <ul>
|
||||
* <li>No return required</li>
|
||||
* </ul>
|
||||
* </il>
|
||||
* </ul>
|
||||
* </il>
|
||||
* <li>
|
||||
* fnInit - This function is called whenever the paging status of the table changes and is
|
||||
* typically used to update classes and/or text of the paging controls to reflex the new
|
||||
* status.
|
||||
* <ul>
|
||||
* <li>
|
||||
* Function input parameters:
|
||||
* <ul>
|
||||
* <li>{object} DataTables settings object: see {@link DataTable.models.oSettings}.</li>
|
||||
* <li>{function} Draw callback function - in case you need to redraw the table again
|
||||
* or attach new event listeners</li>
|
||||
* </ul>
|
||||
* </li>
|
||||
* <li>
|
||||
* Function return:
|
||||
* <ul>
|
||||
* <li>No return required</li>
|
||||
* </ul>
|
||||
* </il>
|
||||
* </ul>
|
||||
* </il>
|
||||
* </ul>
|
||||
* @type object
|
||||
* @default {}
|
||||
*
|
||||
* @example
|
||||
* $.fn.dataTableExt.oPagination.four_button = {
|
||||
* "fnInit": function ( oSettings, nPaging, fnCallbackDraw ) {
|
||||
* nFirst = document.createElement( 'span' );
|
||||
* nPrevious = document.createElement( 'span' );
|
||||
* nNext = document.createElement( 'span' );
|
||||
* nLast = document.createElement( 'span' );
|
||||
*
|
||||
* nFirst.appendChild( document.createTextNode( oSettings.oLanguage.oPaginate.sFirst ) );
|
||||
* nPrevious.appendChild( document.createTextNode( oSettings.oLanguage.oPaginate.sPrevious ) );
|
||||
* nNext.appendChild( document.createTextNode( oSettings.oLanguage.oPaginate.sNext ) );
|
||||
* nLast.appendChild( document.createTextNode( oSettings.oLanguage.oPaginate.sLast ) );
|
||||
*
|
||||
* nFirst.className = "paginate_button first";
|
||||
* nPrevious.className = "paginate_button previous";
|
||||
* nNext.className="paginate_button next";
|
||||
* nLast.className = "paginate_button last";
|
||||
*
|
||||
* nPaging.appendChild( nFirst );
|
||||
* nPaging.appendChild( nPrevious );
|
||||
* nPaging.appendChild( nNext );
|
||||
* nPaging.appendChild( nLast );
|
||||
*
|
||||
* $(nFirst).click( function () {
|
||||
* oSettings.oApi._fnPageChange( oSettings, "first" );
|
||||
* fnCallbackDraw( oSettings );
|
||||
* } );
|
||||
*
|
||||
* $(nPrevious).click( function() {
|
||||
* oSettings.oApi._fnPageChange( oSettings, "previous" );
|
||||
* fnCallbackDraw( oSettings );
|
||||
* } );
|
||||
*
|
||||
* $(nNext).click( function() {
|
||||
* oSettings.oApi._fnPageChange( oSettings, "next" );
|
||||
* fnCallbackDraw( oSettings );
|
||||
* } );
|
||||
*
|
||||
* $(nLast).click( function() {
|
||||
* oSettings.oApi._fnPageChange( oSettings, "last" );
|
||||
* fnCallbackDraw( oSettings );
|
||||
* } );
|
||||
*
|
||||
* $(nFirst).bind( 'selectstart', function () { return false; } );
|
||||
* $(nPrevious).bind( 'selectstart', function () { return false; } );
|
||||
* $(nNext).bind( 'selectstart', function () { return false; } );
|
||||
* $(nLast).bind( 'selectstart', function () { return false; } );
|
||||
* },
|
||||
*
|
||||
* "fnUpdate": function ( oSettings, fnCallbackDraw ) {
|
||||
* if ( !oSettings.aanFeatures.p ) {
|
||||
* return;
|
||||
* }
|
||||
*
|
||||
* // Loop over each instance of the pager
|
||||
* var an = oSettings.aanFeatures.p;
|
||||
* for ( var i=0, iLen=an.length ; i<iLen ; i++ ) {
|
||||
* var buttons = an[i].getElementsByTagName('span');
|
||||
* if ( oSettings._iDisplayStart === 0 ) {
|
||||
* buttons[0].className = "paginate_disabled_previous";
|
||||
* buttons[1].className = "paginate_disabled_previous";
|
||||
* }
|
||||
* else {
|
||||
* buttons[0].className = "paginate_enabled_previous";
|
||||
* buttons[1].className = "paginate_enabled_previous";
|
||||
* }
|
||||
*
|
||||
* if ( oSettings.fnDisplayEnd() == oSettings.fnRecordsDisplay() ) {
|
||||
* buttons[2].className = "paginate_disabled_next";
|
||||
* buttons[3].className = "paginate_disabled_next";
|
||||
* }
|
||||
* else {
|
||||
* buttons[2].className = "paginate_enabled_next";
|
||||
* buttons[3].className = "paginate_enabled_next";
|
||||
* }
|
||||
* }
|
||||
* }
|
||||
* };
|
||||
*/
|
||||
"oPagination": {},
|
||||
|
||||
|
||||
/**
|
||||
* Sorting plug-in methods - Sorting in DataTables is based on the detected type of the
|
||||
* data column (you can add your own type detection functions, or override automatic
|
||||
* detection using sType). With this specific type given to the column, DataTables will
|
||||
* apply the required sort from the functions in the object. Each sort type must provide
|
||||
* two mandatory methods, one each for ascending and descending sorting, and can optionally
|
||||
* provide a pre-formatting method that will help speed up sorting by allowing DataTables
|
||||
* to pre-format the sort data only once (rather than every time the actual sort functions
|
||||
* are run). The two sorting functions are typical Javascript sort methods:
|
||||
* <ul>
|
||||
* <li>
|
||||
* Function input parameters:
|
||||
* <ul>
|
||||
* <li>{*} Data to compare to the second parameter</li>
|
||||
* <li>{*} Data to compare to the first parameter</li>
|
||||
* </ul>
|
||||
* </li>
|
||||
* <li>
|
||||
* Function return:
|
||||
* <ul>
|
||||
* <li>{int} Sorting match: <0 if first parameter should be sorted lower than
|
||||
* the second parameter, ===0 if the two parameters are equal and >0 if
|
||||
* the first parameter should be sorted height than the second parameter.</li>
|
||||
* </ul>
|
||||
* </il>
|
||||
* </ul>
|
||||
* @type object
|
||||
* @default {}
|
||||
*
|
||||
* @example
|
||||
* // Case-sensitive string sorting, with no pre-formatting method
|
||||
* $.extend( $.fn.dataTableExt.oSort, {
|
||||
* "string-case-asc": function(x,y) {
|
||||
* return ((x < y) ? -1 : ((x > y) ? 1 : 0));
|
||||
* },
|
||||
* "string-case-desc": function(x,y) {
|
||||
* return ((x < y) ? 1 : ((x > y) ? -1 : 0));
|
||||
* }
|
||||
* } );
|
||||
*
|
||||
* @example
|
||||
* // Case-insensitive string sorting, with pre-formatting
|
||||
* $.extend( $.fn.dataTableExt.oSort, {
|
||||
* "string-pre": function(x) {
|
||||
* return x.toLowerCase();
|
||||
* },
|
||||
* "string-asc": function(x,y) {
|
||||
* return ((x < y) ? -1 : ((x > y) ? 1 : 0));
|
||||
* },
|
||||
* "string-desc": function(x,y) {
|
||||
* return ((x < y) ? 1 : ((x > y) ? -1 : 0));
|
||||
* }
|
||||
* } );
|
||||
*/
|
||||
"oSort": {},
|
||||
|
||||
|
||||
/**
|
||||
* Version string for plug-ins to check compatibility. Allowed format is
|
||||
* a.b.c.d.e where: a:int, b:int, c:int, d:string(dev|beta), e:int. d and
|
||||
* e are optional
|
||||
* @type string
|
||||
* @default Version number
|
||||
*/
|
||||
"sVersion": DataTable.version,
|
||||
|
||||
|
||||
/**
|
||||
* How should DataTables report an error. Can take the value 'alert' or 'throw'
|
||||
* @type string
|
||||
* @default alert
|
||||
*/
|
||||
"sErrMode": "alert",
|
||||
|
||||
|
||||
/**
|
||||
* Store information for DataTables to access globally about other instances
|
||||
* @namespace
|
||||
* @private
|
||||
*/
|
||||
"_oExternConfig": {
|
||||
/* int:iNextUnique - next unique number for an instance */
|
||||
"iNextUnique": 0
|
||||
}
|
||||
};
|
||||
|
64
js/datatables/media/src/model/model.row.js
Normal file
64
js/datatables/media/src/model/model.row.js
Normal file
|
@ -0,0 +1,64 @@
|
|||
|
||||
|
||||
|
||||
/**
|
||||
* Template object for the way in which DataTables holds information about
|
||||
* each individual row. This is the object format used for the settings
|
||||
* aoData array.
|
||||
* @namespace
|
||||
*/
|
||||
DataTable.models.oRow = {
|
||||
/**
|
||||
* TR element for the row
|
||||
* @type node
|
||||
* @default null
|
||||
*/
|
||||
"nTr": null,
|
||||
|
||||
/**
|
||||
* Data object from the original data source for the row. This is either
|
||||
* an array if using the traditional form of DataTables, or an object if
|
||||
* using mData options. The exact type will depend on the passed in
|
||||
* data from the data source, or will be an array if using DOM a data
|
||||
* source.
|
||||
* @type array|object
|
||||
* @default []
|
||||
*/
|
||||
"_aData": [],
|
||||
|
||||
/**
|
||||
* Sorting data cache - this array is ostensibly the same length as the
|
||||
* number of columns (although each index is generated only as it is
|
||||
* needed), and holds the data that is used for sorting each column in the
|
||||
* row. We do this cache generation at the start of the sort in order that
|
||||
* the formatting of the sort data need be done only once for each cell
|
||||
* per sort. This array should not be read from or written to by anything
|
||||
* other than the master sorting methods.
|
||||
* @type array
|
||||
* @default []
|
||||
* @private
|
||||
*/
|
||||
"_aSortData": [],
|
||||
|
||||
/**
|
||||
* Array of TD elements that are cached for hidden rows, so they can be
|
||||
* reinserted into the table if a column is made visible again (or to act
|
||||
* as a store if a column is made hidden). Only hidden columns have a
|
||||
* reference in the array. For non-hidden columns the value is either
|
||||
* undefined or null.
|
||||
* @type array nodes
|
||||
* @default []
|
||||
* @private
|
||||
*/
|
||||
"_anHidden": [],
|
||||
|
||||
/**
|
||||
* Cache of the class name that DataTables has applied to the row, so we
|
||||
* can quickly look at this variable rather than needing to do a DOM check
|
||||
* on className for the nTr property.
|
||||
* @type string
|
||||
* @default <i>Empty string</i>
|
||||
* @private
|
||||
*/
|
||||
"_sRowStripe": ""
|
||||
};
|
40
js/datatables/media/src/model/model.search.js
Normal file
40
js/datatables/media/src/model/model.search.js
Normal file
|
@ -0,0 +1,40 @@
|
|||
|
||||
|
||||
|
||||
/**
|
||||
* Template object for the way in which DataTables holds information about
|
||||
* search information for the global filter and individual column filters.
|
||||
* @namespace
|
||||
*/
|
||||
DataTable.models.oSearch = {
|
||||
/**
|
||||
* Flag to indicate if the filtering should be case insensitive or not
|
||||
* @type boolean
|
||||
* @default true
|
||||
*/
|
||||
"bCaseInsensitive": true,
|
||||
|
||||
/**
|
||||
* Applied search term
|
||||
* @type string
|
||||
* @default <i>Empty string</i>
|
||||
*/
|
||||
"sSearch": "",
|
||||
|
||||
/**
|
||||
* Flag to indicate if the search term should be interpreted as a
|
||||
* regular expression (true) or not (false) and therefore and special
|
||||
* regex characters escaped.
|
||||
* @type boolean
|
||||
* @default false
|
||||
*/
|
||||
"bRegex": false,
|
||||
|
||||
/**
|
||||
* Flag to indicate if DataTables is to use its smart filtering or not.
|
||||
* @type boolean
|
||||
* @default true
|
||||
*/
|
||||
"bSmart": true
|
||||
};
|
||||
|
882
js/datatables/media/src/model/model.settings.js
Normal file
882
js/datatables/media/src/model/model.settings.js
Normal file
|
@ -0,0 +1,882 @@
|
|||
|
||||
|
||||
/**
|
||||
* DataTables settings object - this holds all the information needed for a
|
||||
* given table, including configuration, data and current application of the
|
||||
* table options. DataTables does not have a single instance for each DataTable
|
||||
* with the settings attached to that instance, but rather instances of the
|
||||
* DataTable "class" are created on-the-fly as needed (typically by a
|
||||
* $().dataTable() call) and the settings object is then applied to that
|
||||
* instance.
|
||||
*
|
||||
* Note that this object is related to {@link DataTable.defaults} but this
|
||||
* one is the internal data store for DataTables's cache of columns. It should
|
||||
* NOT be manipulated outside of DataTables. Any configuration should be done
|
||||
* through the initialisation options.
|
||||
* @namespace
|
||||
* @todo Really should attach the settings object to individual instances so we
|
||||
* don't need to create new instances on each $().dataTable() call (if the
|
||||
* table already exists). It would also save passing oSettings around and
|
||||
* into every single function. However, this is a very significant
|
||||
* architecture change for DataTables and will almost certainly break
|
||||
* backwards compatibility with older installations. This is something that
|
||||
* will be done in 2.0.
|
||||
*/
|
||||
DataTable.models.oSettings = {
|
||||
/**
|
||||
* Primary features of DataTables and their enablement state.
|
||||
* @namespace
|
||||
*/
|
||||
"oFeatures": {
|
||||
|
||||
/**
|
||||
* Flag to say if DataTables should automatically try to calculate the
|
||||
* optimum table and columns widths (true) or not (false).
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type boolean
|
||||
*/
|
||||
"bAutoWidth": null,
|
||||
|
||||
/**
|
||||
* Delay the creation of TR and TD elements until they are actually
|
||||
* needed by a driven page draw. This can give a significant speed
|
||||
* increase for Ajax source and Javascript source data, but makes no
|
||||
* difference at all fro DOM and server-side processing tables.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type boolean
|
||||
*/
|
||||
"bDeferRender": null,
|
||||
|
||||
/**
|
||||
* Enable filtering on the table or not. Note that if this is disabled
|
||||
* then there is no filtering at all on the table, including fnFilter.
|
||||
* To just remove the filtering input use sDom and remove the 'f' option.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type boolean
|
||||
*/
|
||||
"bFilter": null,
|
||||
|
||||
/**
|
||||
* Table information element (the 'Showing x of y records' div) enable
|
||||
* flag.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type boolean
|
||||
*/
|
||||
"bInfo": null,
|
||||
|
||||
/**
|
||||
* Present a user control allowing the end user to change the page size
|
||||
* when pagination is enabled.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type boolean
|
||||
*/
|
||||
"bLengthChange": null,
|
||||
|
||||
/**
|
||||
* Pagination enabled or not. Note that if this is disabled then length
|
||||
* changing must also be disabled.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type boolean
|
||||
*/
|
||||
"bPaginate": null,
|
||||
|
||||
/**
|
||||
* Processing indicator enable flag whenever DataTables is enacting a
|
||||
* user request - typically an Ajax request for server-side processing.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type boolean
|
||||
*/
|
||||
"bProcessing": null,
|
||||
|
||||
/**
|
||||
* Server-side processing enabled flag - when enabled DataTables will
|
||||
* get all data from the server for every draw - there is no filtering,
|
||||
* sorting or paging done on the client-side.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type boolean
|
||||
*/
|
||||
"bServerSide": null,
|
||||
|
||||
/**
|
||||
* Sorting enablement flag.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type boolean
|
||||
*/
|
||||
"bSort": null,
|
||||
|
||||
/**
|
||||
* Apply a class to the columns which are being sorted to provide a
|
||||
* visual highlight or not. This can slow things down when enabled since
|
||||
* there is a lot of DOM interaction.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type boolean
|
||||
*/
|
||||
"bSortClasses": null,
|
||||
|
||||
/**
|
||||
* State saving enablement flag.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type boolean
|
||||
*/
|
||||
"bStateSave": null
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* Scrolling settings for a table.
|
||||
* @namespace
|
||||
*/
|
||||
"oScroll": {
|
||||
/**
|
||||
* Indicate if DataTables should be allowed to set the padding / margin
|
||||
* etc for the scrolling header elements or not. Typically you will want
|
||||
* this.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type boolean
|
||||
*/
|
||||
"bAutoCss": null,
|
||||
|
||||
/**
|
||||
* When the table is shorter in height than sScrollY, collapse the
|
||||
* table container down to the height of the table (when true).
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type boolean
|
||||
*/
|
||||
"bCollapse": null,
|
||||
|
||||
/**
|
||||
* Infinite scrolling enablement flag. Now deprecated in favour of
|
||||
* using the Scroller plug-in.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type boolean
|
||||
*/
|
||||
"bInfinite": null,
|
||||
|
||||
/**
|
||||
* Width of the scrollbar for the web-browser's platform. Calculated
|
||||
* during table initialisation.
|
||||
* @type int
|
||||
* @default 0
|
||||
*/
|
||||
"iBarWidth": 0,
|
||||
|
||||
/**
|
||||
* Space (in pixels) between the bottom of the scrolling container and
|
||||
* the bottom of the scrolling viewport before the next page is loaded
|
||||
* when using infinite scrolling.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type int
|
||||
*/
|
||||
"iLoadGap": null,
|
||||
|
||||
/**
|
||||
* Viewport width for horizontal scrolling. Horizontal scrolling is
|
||||
* disabled if an empty string.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type string
|
||||
*/
|
||||
"sX": null,
|
||||
|
||||
/**
|
||||
* Width to expand the table to when using x-scrolling. Typically you
|
||||
* should not need to use this.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type string
|
||||
* @deprecated
|
||||
*/
|
||||
"sXInner": null,
|
||||
|
||||
/**
|
||||
* Viewport height for vertical scrolling. Vertical scrolling is disabled
|
||||
* if an empty string.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type string
|
||||
*/
|
||||
"sY": null
|
||||
},
|
||||
|
||||
/**
|
||||
* Language information for the table.
|
||||
* @namespace
|
||||
* @extends DataTable.defaults.oLanguage
|
||||
*/
|
||||
"oLanguage": {
|
||||
/**
|
||||
* Information callback function. See
|
||||
* {@link DataTable.defaults.fnInfoCallback}
|
||||
* @type function
|
||||
* @default null
|
||||
*/
|
||||
"fnInfoCallback": null
|
||||
},
|
||||
|
||||
/**
|
||||
* Browser support parameters
|
||||
* @namespace
|
||||
*/
|
||||
"oBrowser": {
|
||||
/**
|
||||
* Indicate if the browser incorrectly calculates width:100% inside a
|
||||
* scrolling element (IE6/7)
|
||||
* @type boolean
|
||||
* @default false
|
||||
*/
|
||||
"bScrollOversize": false
|
||||
},
|
||||
|
||||
/**
|
||||
* Array referencing the nodes which are used for the features. The
|
||||
* parameters of this object match what is allowed by sDom - i.e.
|
||||
* <ul>
|
||||
* <li>'l' - Length changing</li>
|
||||
* <li>'f' - Filtering input</li>
|
||||
* <li>'t' - The table!</li>
|
||||
* <li>'i' - Information</li>
|
||||
* <li>'p' - Pagination</li>
|
||||
* <li>'r' - pRocessing</li>
|
||||
* </ul>
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"aanFeatures": [],
|
||||
|
||||
/**
|
||||
* Store data information - see {@link DataTable.models.oRow} for detailed
|
||||
* information.
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"aoData": [],
|
||||
|
||||
/**
|
||||
* Array of indexes which are in the current display (after filtering etc)
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"aiDisplay": [],
|
||||
|
||||
/**
|
||||
* Array of indexes for display - no filtering
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"aiDisplayMaster": [],
|
||||
|
||||
/**
|
||||
* Store information about each column that is in use
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"aoColumns": [],
|
||||
|
||||
/**
|
||||
* Store information about the table's header
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"aoHeader": [],
|
||||
|
||||
/**
|
||||
* Store information about the table's footer
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"aoFooter": [],
|
||||
|
||||
/**
|
||||
* Search data array for regular expression searching
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"asDataSearch": [],
|
||||
|
||||
/**
|
||||
* Store the applied global search information in case we want to force a
|
||||
* research or compare the old search to a new one.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @namespace
|
||||
* @extends DataTable.models.oSearch
|
||||
*/
|
||||
"oPreviousSearch": {},
|
||||
|
||||
/**
|
||||
* Store the applied search for each column - see
|
||||
* {@link DataTable.models.oSearch} for the format that is used for the
|
||||
* filtering information for each column.
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"aoPreSearchCols": [],
|
||||
|
||||
/**
|
||||
* Sorting that is applied to the table. Note that the inner arrays are
|
||||
* used in the following manner:
|
||||
* <ul>
|
||||
* <li>Index 0 - column number</li>
|
||||
* <li>Index 1 - current sorting direction</li>
|
||||
* <li>Index 2 - index of asSorting for this column</li>
|
||||
* </ul>
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type array
|
||||
* @todo These inner arrays should really be objects
|
||||
*/
|
||||
"aaSorting": null,
|
||||
|
||||
/**
|
||||
* Sorting that is always applied to the table (i.e. prefixed in front of
|
||||
* aaSorting).
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type array|null
|
||||
* @default null
|
||||
*/
|
||||
"aaSortingFixed": null,
|
||||
|
||||
/**
|
||||
* Classes to use for the striping of a table.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"asStripeClasses": null,
|
||||
|
||||
/**
|
||||
* If restoring a table - we should restore its striping classes as well
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"asDestroyStripes": [],
|
||||
|
||||
/**
|
||||
* If restoring a table - we should restore its width
|
||||
* @type int
|
||||
* @default 0
|
||||
*/
|
||||
"sDestroyWidth": 0,
|
||||
|
||||
/**
|
||||
* Callback functions array for every time a row is inserted (i.e. on a draw).
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"aoRowCallback": [],
|
||||
|
||||
/**
|
||||
* Callback functions for the header on each draw.
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"aoHeaderCallback": [],
|
||||
|
||||
/**
|
||||
* Callback function for the footer on each draw.
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"aoFooterCallback": [],
|
||||
|
||||
/**
|
||||
* Array of callback functions for draw callback functions
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"aoDrawCallback": [],
|
||||
|
||||
/**
|
||||
* Array of callback functions for row created function
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"aoRowCreatedCallback": [],
|
||||
|
||||
/**
|
||||
* Callback functions for just before the table is redrawn. A return of
|
||||
* false will be used to cancel the draw.
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"aoPreDrawCallback": [],
|
||||
|
||||
/**
|
||||
* Callback functions for when the table has been initialised.
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"aoInitComplete": [],
|
||||
|
||||
|
||||
/**
|
||||
* Callbacks for modifying the settings to be stored for state saving, prior to
|
||||
* saving state.
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"aoStateSaveParams": [],
|
||||
|
||||
/**
|
||||
* Callbacks for modifying the settings that have been stored for state saving
|
||||
* prior to using the stored values to restore the state.
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"aoStateLoadParams": [],
|
||||
|
||||
/**
|
||||
* Callbacks for operating on the settings object once the saved state has been
|
||||
* loaded
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"aoStateLoaded": [],
|
||||
|
||||
/**
|
||||
* Cache the table ID for quick access
|
||||
* @type string
|
||||
* @default <i>Empty string</i>
|
||||
*/
|
||||
"sTableId": "",
|
||||
|
||||
/**
|
||||
* The TABLE node for the main table
|
||||
* @type node
|
||||
* @default null
|
||||
*/
|
||||
"nTable": null,
|
||||
|
||||
/**
|
||||
* Permanent ref to the thead element
|
||||
* @type node
|
||||
* @default null
|
||||
*/
|
||||
"nTHead": null,
|
||||
|
||||
/**
|
||||
* Permanent ref to the tfoot element - if it exists
|
||||
* @type node
|
||||
* @default null
|
||||
*/
|
||||
"nTFoot": null,
|
||||
|
||||
/**
|
||||
* Permanent ref to the tbody element
|
||||
* @type node
|
||||
* @default null
|
||||
*/
|
||||
"nTBody": null,
|
||||
|
||||
/**
|
||||
* Cache the wrapper node (contains all DataTables controlled elements)
|
||||
* @type node
|
||||
* @default null
|
||||
*/
|
||||
"nTableWrapper": null,
|
||||
|
||||
/**
|
||||
* Indicate if when using server-side processing the loading of data
|
||||
* should be deferred until the second draw.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type boolean
|
||||
* @default false
|
||||
*/
|
||||
"bDeferLoading": false,
|
||||
|
||||
/**
|
||||
* Indicate if all required information has been read in
|
||||
* @type boolean
|
||||
* @default false
|
||||
*/
|
||||
"bInitialised": false,
|
||||
|
||||
/**
|
||||
* Information about open rows. Each object in the array has the parameters
|
||||
* 'nTr' and 'nParent'
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"aoOpenRows": [],
|
||||
|
||||
/**
|
||||
* Dictate the positioning of DataTables' control elements - see
|
||||
* {@link DataTable.model.oInit.sDom}.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type string
|
||||
* @default null
|
||||
*/
|
||||
"sDom": null,
|
||||
|
||||
/**
|
||||
* Which type of pagination should be used.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type string
|
||||
* @default two_button
|
||||
*/
|
||||
"sPaginationType": "two_button",
|
||||
|
||||
/**
|
||||
* The cookie duration (for bStateSave) in seconds.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type int
|
||||
* @default 0
|
||||
*/
|
||||
"iCookieDuration": 0,
|
||||
|
||||
/**
|
||||
* The cookie name prefix.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type string
|
||||
* @default <i>Empty string</i>
|
||||
*/
|
||||
"sCookiePrefix": "",
|
||||
|
||||
/**
|
||||
* Callback function for cookie creation.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type function
|
||||
* @default null
|
||||
*/
|
||||
"fnCookieCallback": null,
|
||||
|
||||
/**
|
||||
* Array of callback functions for state saving. Each array element is an
|
||||
* object with the following parameters:
|
||||
* <ul>
|
||||
* <li>function:fn - function to call. Takes two parameters, oSettings
|
||||
* and the JSON string to save that has been thus far created. Returns
|
||||
* a JSON string to be inserted into a json object
|
||||
* (i.e. '"param": [ 0, 1, 2]')</li>
|
||||
* <li>string:sName - name of callback</li>
|
||||
* </ul>
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"aoStateSave": [],
|
||||
|
||||
/**
|
||||
* Array of callback functions for state loading. Each array element is an
|
||||
* object with the following parameters:
|
||||
* <ul>
|
||||
* <li>function:fn - function to call. Takes two parameters, oSettings
|
||||
* and the object stored. May return false to cancel state loading</li>
|
||||
* <li>string:sName - name of callback</li>
|
||||
* </ul>
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"aoStateLoad": [],
|
||||
|
||||
/**
|
||||
* State that was loaded from the cookie. Useful for back reference
|
||||
* @type object
|
||||
* @default null
|
||||
*/
|
||||
"oLoadedState": null,
|
||||
|
||||
/**
|
||||
* Source url for AJAX data for the table.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type string
|
||||
* @default null
|
||||
*/
|
||||
"sAjaxSource": null,
|
||||
|
||||
/**
|
||||
* Property from a given object from which to read the table data from. This
|
||||
* can be an empty string (when not server-side processing), in which case
|
||||
* it is assumed an an array is given directly.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type string
|
||||
*/
|
||||
"sAjaxDataProp": null,
|
||||
|
||||
/**
|
||||
* Note if draw should be blocked while getting data
|
||||
* @type boolean
|
||||
* @default true
|
||||
*/
|
||||
"bAjaxDataGet": true,
|
||||
|
||||
/**
|
||||
* The last jQuery XHR object that was used for server-side data gathering.
|
||||
* This can be used for working with the XHR information in one of the
|
||||
* callbacks
|
||||
* @type object
|
||||
* @default null
|
||||
*/
|
||||
"jqXHR": null,
|
||||
|
||||
/**
|
||||
* Function to get the server-side data.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type function
|
||||
*/
|
||||
"fnServerData": null,
|
||||
|
||||
/**
|
||||
* Functions which are called prior to sending an Ajax request so extra
|
||||
* parameters can easily be sent to the server
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"aoServerParams": [],
|
||||
|
||||
/**
|
||||
* Send the XHR HTTP method - GET or POST (could be PUT or DELETE if
|
||||
* required).
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type string
|
||||
*/
|
||||
"sServerMethod": null,
|
||||
|
||||
/**
|
||||
* Format numbers for display.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type function
|
||||
*/
|
||||
"fnFormatNumber": null,
|
||||
|
||||
/**
|
||||
* List of options that can be used for the user selectable length menu.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"aLengthMenu": null,
|
||||
|
||||
/**
|
||||
* Counter for the draws that the table does. Also used as a tracker for
|
||||
* server-side processing
|
||||
* @type int
|
||||
* @default 0
|
||||
*/
|
||||
"iDraw": 0,
|
||||
|
||||
/**
|
||||
* Indicate if a redraw is being done - useful for Ajax
|
||||
* @type boolean
|
||||
* @default false
|
||||
*/
|
||||
"bDrawing": false,
|
||||
|
||||
/**
|
||||
* Draw index (iDraw) of the last error when parsing the returned data
|
||||
* @type int
|
||||
* @default -1
|
||||
*/
|
||||
"iDrawError": -1,
|
||||
|
||||
/**
|
||||
* Paging display length
|
||||
* @type int
|
||||
* @default 10
|
||||
*/
|
||||
"_iDisplayLength": 10,
|
||||
|
||||
/**
|
||||
* Paging start point - aiDisplay index
|
||||
* @type int
|
||||
* @default 0
|
||||
*/
|
||||
"_iDisplayStart": 0,
|
||||
|
||||
/**
|
||||
* Paging end point - aiDisplay index. Use fnDisplayEnd rather than
|
||||
* this property to get the end point
|
||||
* @type int
|
||||
* @default 10
|
||||
* @private
|
||||
*/
|
||||
"_iDisplayEnd": 10,
|
||||
|
||||
/**
|
||||
* Server-side processing - number of records in the result set
|
||||
* (i.e. before filtering), Use fnRecordsTotal rather than
|
||||
* this property to get the value of the number of records, regardless of
|
||||
* the server-side processing setting.
|
||||
* @type int
|
||||
* @default 0
|
||||
* @private
|
||||
*/
|
||||
"_iRecordsTotal": 0,
|
||||
|
||||
/**
|
||||
* Server-side processing - number of records in the current display set
|
||||
* (i.e. after filtering). Use fnRecordsDisplay rather than
|
||||
* this property to get the value of the number of records, regardless of
|
||||
* the server-side processing setting.
|
||||
* @type boolean
|
||||
* @default 0
|
||||
* @private
|
||||
*/
|
||||
"_iRecordsDisplay": 0,
|
||||
|
||||
/**
|
||||
* Flag to indicate if jQuery UI marking and classes should be used.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type boolean
|
||||
*/
|
||||
"bJUI": null,
|
||||
|
||||
/**
|
||||
* The classes to use for the table
|
||||
* @type object
|
||||
* @default {}
|
||||
*/
|
||||
"oClasses": {},
|
||||
|
||||
/**
|
||||
* Flag attached to the settings object so you can check in the draw
|
||||
* callback if filtering has been done in the draw. Deprecated in favour of
|
||||
* events.
|
||||
* @type boolean
|
||||
* @default false
|
||||
* @deprecated
|
||||
*/
|
||||
"bFiltered": false,
|
||||
|
||||
/**
|
||||
* Flag attached to the settings object so you can check in the draw
|
||||
* callback if sorting has been done in the draw. Deprecated in favour of
|
||||
* events.
|
||||
* @type boolean
|
||||
* @default false
|
||||
* @deprecated
|
||||
*/
|
||||
"bSorted": false,
|
||||
|
||||
/**
|
||||
* Indicate that if multiple rows are in the header and there is more than
|
||||
* one unique cell per column, if the top one (true) or bottom one (false)
|
||||
* should be used for sorting / title by DataTables.
|
||||
* Note that this parameter will be set by the initialisation routine. To
|
||||
* set a default use {@link DataTable.defaults}.
|
||||
* @type boolean
|
||||
*/
|
||||
"bSortCellsTop": null,
|
||||
|
||||
/**
|
||||
* Initialisation object that is used for the table
|
||||
* @type object
|
||||
* @default null
|
||||
*/
|
||||
"oInit": null,
|
||||
|
||||
/**
|
||||
* Destroy callback functions - for plug-ins to attach themselves to the
|
||||
* destroy so they can clean up markup and events.
|
||||
* @type array
|
||||
* @default []
|
||||
*/
|
||||
"aoDestroyCallback": [],
|
||||
|
||||
|
||||
/**
|
||||
* Get the number of records in the current record set, before filtering
|
||||
* @type function
|
||||
*/
|
||||
"fnRecordsTotal": function ()
|
||||
{
|
||||
if ( this.oFeatures.bServerSide ) {
|
||||
return parseInt(this._iRecordsTotal, 10);
|
||||
} else {
|
||||
return this.aiDisplayMaster.length;
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* Get the number of records in the current record set, after filtering
|
||||
* @type function
|
||||
*/
|
||||
"fnRecordsDisplay": function ()
|
||||
{
|
||||
if ( this.oFeatures.bServerSide ) {
|
||||
return parseInt(this._iRecordsDisplay, 10);
|
||||
} else {
|
||||
return this.aiDisplay.length;
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* Set the display end point - aiDisplay index
|
||||
* @type function
|
||||
* @todo Should do away with _iDisplayEnd and calculate it on-the-fly here
|
||||
*/
|
||||
"fnDisplayEnd": function ()
|
||||
{
|
||||
if ( this.oFeatures.bServerSide ) {
|
||||
if ( this.oFeatures.bPaginate === false || this._iDisplayLength == -1 ) {
|
||||
return this._iDisplayStart+this.aiDisplay.length;
|
||||
} else {
|
||||
return Math.min( this._iDisplayStart+this._iDisplayLength,
|
||||
this._iRecordsDisplay );
|
||||
}
|
||||
} else {
|
||||
return this._iDisplayEnd;
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* The DataTables object for this table
|
||||
* @type object
|
||||
* @default null
|
||||
*/
|
||||
"oInstance": null,
|
||||
|
||||
/**
|
||||
* Unique identifier for each instance of the DataTables object. If there
|
||||
* is an ID on the table node, then it takes that value, otherwise an
|
||||
* incrementing internal counter is used.
|
||||
* @type string
|
||||
* @default null
|
||||
*/
|
||||
"sInstance": null,
|
||||
|
||||
/**
|
||||
* tabindex attribute value that is added to DataTables control elements, allowing
|
||||
* keyboard navigation of the table and its controls.
|
||||
*/
|
||||
"iTabIndex": 0,
|
||||
|
||||
/**
|
||||
* DIV container for the footer scrolling table if scrolling
|
||||
*/
|
||||
"nScrollHead": null,
|
||||
|
||||
/**
|
||||
* DIV container for the footer scrolling table if scrolling
|
||||
*/
|
||||
"nScrollFoot": null
|
||||
};
|
Loading…
Add table
Add a link
Reference in a new issue