Mercurial > repos > saskia-hiltemann > ireport
view DataTables-1.9.4/media/src/model/model.defaults.columns.js @ 9:7300ed4c1481 draft default tip
Uploaded
author | saskia-hiltemann |
---|---|
date | Mon, 04 Sep 2017 10:49:00 -0400 |
parents | ac5f9272033b |
children |
line wrap: on
line source
/** * 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 };