webapp/resources/datatables-1.9.4/media/src/model/model.defaults.columns.js

   1
   2
   3 /**
   4  * Column options that can be given to DataTables at initialisation time.
   5  *  @namespace
   6  */
   7 DataTable.defaults.columns = {
   8         /**
   9          * Allows a column's sorting to take multiple columns into account when
  10          * doing a sort. For example first name / last name columns make sense to
  11          * do a multi-column sort over the two columns.
  12          *  @type array
  13          *  @default null <i>Takes the value of the column index automatically</i>
  14          *  @dtopt Columns
  15          *
  16          *  @example
  17          *    // Using aoColumnDefs
  18          *    $(document).ready( function() {
  19          *      $('#example').dataTable( {
  20          *        "aoColumnDefs": [
  21          *          { "aDataSort": [ 0, 1 ], "aTargets": [ 0 ] },
  22          *          { "aDataSort": [ 1, 0 ], "aTargets": [ 1 ] },
  23          *          { "aDataSort": [ 2, 3, 4 ], "aTargets": [ 2 ] }
  24          *        ]
  25          *      } );
  26          *    } );
  27          *
  28          *  @example
  29          *    // Using aoColumns
  30          *    $(document).ready( function() {
  31          *      $('#example').dataTable( {
  32          *        "aoColumns": [
  33          *          { "aDataSort": [ 0, 1 ] },
  34          *          { "aDataSort": [ 1, 0 ] },
  35          *          { "aDataSort": [ 2, 3, 4 ] },
  36          *          null,
  37          *          null
  38          *        ]
  39          *      } );
  40          *    } );
  41          */
  42         "aDataSort": null,
  43
  44
  45         /**
  46          * You can control the default sorting direction, and even alter the behaviour
  47          * of the sort handler (i.e. only allow ascending sorting etc) using this
  48          * parameter.
  49          *  @type array
  50          *  @default [ 'asc', 'desc' ]
  51          *  @dtopt Columns
  52          *
  53          *  @example
  54          *    // Using aoColumnDefs
  55          *    $(document).ready( function() {
  56          *      $('#example').dataTable( {
  57          *        "aoColumnDefs": [
  58          *          { "asSorting": [ "asc" ], "aTargets": [ 1 ] },
  59          *          { "asSorting": [ "desc", "asc", "asc" ], "aTargets": [ 2 ] },
  60          *          { "asSorting": [ "desc" ], "aTargets": [ 3 ] }
  61          *        ]
  62          *      } );
  63          *    } );
  64          *
  65          *  @example
  66          *    // Using aoColumns
  67          *    $(document).ready( function() {
  68          *      $('#example').dataTable( {
  69          *        "aoColumns": [
  70          *          null,
  71          *          { "asSorting": [ "asc" ] },
  72          *          { "asSorting": [ "desc", "asc", "asc" ] },
  73          *          { "asSorting": [ "desc" ] },
  74          *          null
  75          *        ]
  76          *      } );
  77          *    } );
  78          */
  79         "asSorting": [ 'asc', 'desc' ],
  80
  81
  82         /**
  83          * Enable or disable filtering on the data in this column.
  84          *  @type boolean
  85          *  @default true
  86          *  @dtopt Columns
  87          *
  88          *  @example
  89          *    // Using aoColumnDefs
  90          *    $(document).ready( function() {
  91          *      $('#example').dataTable( {
  92          *        "aoColumnDefs": [
  93          *          { "bSearchable": false, "aTargets": [ 0 ] }
  94          *        ] } );
  95          *    } );
  96          *
  97          *  @example
  98          *    // Using aoColumns
  99          *    $(document).ready( function() {
 100          *      $('#example').dataTable( {
 101          *        "aoColumns": [
 102          *          { "bSearchable": false },
 103          *          null,
 104          *          null,
 105          *          null,
 106          *          null
 107          *        ] } );
 108          *    } );
 109          */
 110         "bSearchable": true,
 111
 112
 113         /**
 114          * Enable or disable sorting on this column.
 115          *  @type boolean
 116          *  @default true
 117          *  @dtopt Columns
 118          *
 119          *  @example
 120          *    // Using aoColumnDefs
 121          *    $(document).ready( function() {
 122          *      $('#example').dataTable( {
 123          *        "aoColumnDefs": [
 124          *          { "bSortable": false, "aTargets": [ 0 ] }
 125          *        ] } );
 126          *    } );
 127          *
 128          *  @example
 129          *    // Using aoColumns
 130          *    $(document).ready( function() {
 131          *      $('#example').dataTable( {
 132          *        "aoColumns": [
 133          *          { "bSortable": false },
 134          *          null,
 135          *          null,
 136          *          null,
 137          *          null
 138          *        ] } );
 139          *    } );
 140          */
 141         "bSortable": true,
 142
 143
 144         /**
 145          * <code>Deprecated</code> When using fnRender() for a column, you may wish
 146          * to use the original data (before rendering) for sorting and filtering
 147          * (the default is to used the rendered data that the user can see). This
 148          * may be useful for dates etc.
 149          *
 150          * Please note that this option has now been deprecated and will be removed
 151          * in the next version of DataTables. Please use mRender / mData rather than
 152          * fnRender.
 153          *  @type boolean
 154          *  @default true
 155          *  @dtopt Columns
 156          *  @deprecated
 157          */
 158         "bUseRendered": true,
 159
 160
 161         /**
 162          * Enable or disable the display of this column.
 163          *  @type boolean
 164          *  @default true
 165          *  @dtopt Columns
 166          *
 167          *  @example
 168          *    // Using aoColumnDefs
 169          *    $(document).ready( function() {
 170          *      $('#example').dataTable( {
 171          *        "aoColumnDefs": [
 172          *          { "bVisible": false, "aTargets": [ 0 ] }
 173          *        ] } );
 174          *    } );
 175          *
 176          *  @example
 177          *    // Using aoColumns
 178          *    $(document).ready( function() {
 179          *      $('#example').dataTable( {
 180          *        "aoColumns": [
 181          *          { "bVisible": false },
 182          *          null,
 183          *          null,
 184          *          null,
 185          *          null
 186          *        ] } );
 187          *    } );
 188          */
 189         "bVisible": true,
 190
 191
 192         /**
 193          * Developer definable function that is called whenever a cell is created (Ajax source,
 194          * etc) or processed for input (DOM source). This can be used as a compliment to mRender
 195          * allowing you to modify the DOM element (add background colour for example) when the
 196          * element is available.
 197          *  @type function
 198          *  @param {element} nTd The TD node that has been created
 199          *  @param {*} sData The Data for the cell
 200          *  @param {array|object} oData The data for the whole row
 201          *  @param {int} iRow The row index for the aoData data store
 202          *  @param {int} iCol The column index for aoColumns
 203          *  @dtopt Columns
 204          *
 205          *  @example
 206          *    $(document).ready( function() {
 207          *      $('#example').dataTable( {
 208          *        "aoColumnDefs": [ {
 209          *          "aTargets": [3],
 210          *          "fnCreatedCell": function (nTd, sData, oData, iRow, iCol) {
 211          *            if ( sData == "1.7" ) {
 212          *              $(nTd).css('color', 'blue')
 213          *            }
 214          *          }
 215          *        } ]
 216          *      });
 217          *    } );
 218          */
 219         "fnCreatedCell": null,
 220
 221
 222         /**
 223          * <code>Deprecated</code> Custom display function that will be called for the
 224          * display of each cell in this column.
 225          *
 226          * Please note that this option has now been deprecated and will be removed
 227          * in the next version of DataTables. Please use mRender / mData rather than
 228          * fnRender.
 229          *  @type function
 230          *  @param {object} o Object with the following parameters:
 231          *  @param {int}    o.iDataRow The row in aoData
 232          *  @param {int}    o.iDataColumn The column in question
 233          *  @param {array}  o.aData The data for the row in question
 234          *  @param {object} o.oSettings The settings object for this DataTables instance
 235          *  @param {object} o.mDataProp The data property used for this column
 236          *  @param {*}      val The current cell value
 237          *  @returns {string} The string you which to use in the display
 238          *  @dtopt Columns
 239          *  @deprecated
 240          */
 241         "fnRender": null,
 242
 243
 244         /**
 245          * The column index (starting from 0!) that you wish a sort to be performed
 246          * upon when this column is selected for sorting. This can be used for sorting
 247          * on hidden columns for example.
 248          *  @type int
 249          *  @default -1 <i>Use automatically calculated column index</i>
 250          *  @dtopt Columns
 251          *
 252          *  @example
 253          *    // Using aoColumnDefs
 254          *    $(document).ready( function() {
 255          *      $('#example').dataTable( {
 256          *        "aoColumnDefs": [
 257          *          { "iDataSort": 1, "aTargets": [ 0 ] }
 258          *        ]
 259          *      } );
 260          *    } );
 261          *
 262          *  @example
 263          *    // Using aoColumns
 264          *    $(document).ready( function() {
 265          *      $('#example').dataTable( {
 266          *        "aoColumns": [
 267          *          { "iDataSort": 1 },
 268          *          null,
 269          *          null,
 270          *          null,
 271          *          null
 272          *        ]
 273          *      } );
 274          *    } );
 275          */
 276         "iDataSort": -1,
 277
 278
 279         /**
 280          * This parameter has been replaced by mData in DataTables to ensure naming
 281          * consistency. mDataProp can still be used, as there is backwards compatibility
 282          * in DataTables for this option, but it is strongly recommended that you use
 283          * mData in preference to mDataProp.
 284          *  @name DataTable.defaults.columns.mDataProp
 285          */
 286
 287
 288         /**
 289          * This property can be used to read data from any JSON data source property,
 290          * including deeply nested objects / properties. mData can be given in a
 291          * number of different ways which effect its behaviour:
 292          *   <ul>
 293          *     <li>integer - treated as an array index for the data source. This is the
 294          *       default that DataTables uses (incrementally increased for each column).</li>
 295          *     <li>string - read an object property from the data source. Note that you can
 296          *       use Javascript dotted notation to read deep properties / arrays from the
 297          *       data source.</li>
 298          *     <li>null - the sDefaultContent option will be used for the cell (null
 299          *       by default, so you will need to specify the default content you want -
 300          *       typically an empty string). This can be useful on generated columns such
 301          *       as edit / delete action columns.</li>
 302          *     <li>function - the function given will be executed whenever DataTables
 303          *       needs to set or get the data for a cell in the column. The function
 304          *       takes three parameters:
 305          *       <ul>
 306          *         <li>{array|object} The data source for the row</li>
 307          *         <li>{string} The type call data requested - this will be 'set' when
 308          *           setting data or 'filter', 'display', 'type', 'sort' or undefined when
 309          *           gathering data. Note that when <i>undefined</i> is given for the type
 310          *           DataTables expects to get the raw data for the object back</li>
 311          *         <li>{*} Data to set when the second parameter is 'set'.</li>
 312          *       </ul>
 313          *       The return value from the function is not required when 'set' is the type
 314          *       of call, but otherwise the return is what will be used for the data
 315          *       requested.</li>
 316          *    </ul>
 317          *
 318          * Note that prior to DataTables 1.9.2 mData was called mDataProp. The name change
 319          * reflects the flexibility of this property and is consistent with the naming of
 320          * mRender. If 'mDataProp' is given, then it will still be used by DataTables, as
 321          * it automatically maps the old name to the new if required.
 322          *  @type string|int|function|null
 323          *  @default null <i>Use automatically calculated column index</i>
 324          *  @dtopt Columns
 325          *
 326          *  @example
 327          *    // Read table data from objects
 328          *    $(document).ready( function() {
 329          *      var oTable = $('#example').dataTable( {
 330          *        "sAjaxSource": "sources/deep.txt",
 331          *        "aoColumns": [
 332          *          { "mData": "engine" },
 333          *          { "mData": "browser" },
 334          *          { "mData": "platform.inner" },
 335          *          { "mData": "platform.details.0" },
 336          *          { "mData": "platform.details.1" }
 337          *        ]
 338          *      } );
 339          *    } );
 340          *
 341          *  @example
 342          *    // Using mData as a function to provide different information for
 343          *    // sorting, filtering and display. In this case, currency (price)
 344          *    $(document).ready( function() {
 345          *      var oTable = $('#example').dataTable( {
 346          *        "aoColumnDefs": [ {
 347          *          "aTargets": [ 0 ],
 348          *          "mData": function ( source, type, val ) {
 349          *            if (type === 'set') {
 350          *              source.price = val;
 351          *              // Store the computed dislay and filter values for efficiency
 352          *              source.price_display = val=="" ? "" : "$"+numberFormat(val);
 353          *              source.price_filter  = val=="" ? "" : "$"+numberFormat(val)+" "+val;
 354          *              return;
 355          *            }
 356          *            else if (type === 'display') {
 357          *              return source.price_display;
 358          *            }
 359          *            else if (type === 'filter') {
 360          *              return source.price_filter;
 361          *            }
 362          *            // 'sort', 'type' and undefined all just use the integer
 363          *            return source.price;
 364          *          }
 365          *        } ]
 366          *      } );
 367          *    } );
 368          */
 369         "mData": null,
 370
 371
 372         /**
 373          * This property is the rendering partner to mData and it is suggested that
 374          * when you want to manipulate data for display (including filtering, sorting etc)
 375          * but not altering the underlying data for the table, use this property. mData
 376          * can actually do everything this property can and more, but this parameter is
 377          * easier to use since there is no 'set' option. Like mData is can be given
 378          * in a number of different ways to effect its behaviour, with the addition of
 379          * supporting array syntax for easy outputting of arrays (including arrays of
 380          * objects):
 381          *   <ul>
 382          *     <li>integer - treated as an array index for the data source. This is the
 383          *       default that DataTables uses (incrementally increased for each column).</li>
 384          *     <li>string - read an object property from the data source. Note that you can
 385          *       use Javascript dotted notation to read deep properties / arrays from the
 386          *       data source and also array brackets to indicate that the data reader should
 387          *       loop over the data source array. When characters are given between the array
 388          *       brackets, these characters are used to join the data source array together.
 389          *       For example: "accounts[, ].name" would result in a comma separated list with
 390          *       the 'name' value from the 'accounts' array of objects.</li>
 391          *     <li>function - the function given will be executed whenever DataTables
 392          *       needs to set or get the data for a cell in the column. The function
 393          *       takes three parameters:
 394          *       <ul>
 395          *         <li>{array|object} The data source for the row (based on mData)</li>
 396          *         <li>{string} The type call data requested - this will be 'filter', 'display',
 397          *           'type' or 'sort'.</li>
 398          *         <li>{array|object} The full data source for the row (not based on mData)</li>
 399          *       </ul>
 400          *       The return value from the function is what will be used for the data
 401          *       requested.</li>
 402          *    </ul>
 403          *  @type string|int|function|null
 404          *  @default null <i>Use mData</i>
 405          *  @dtopt Columns
 406          *
 407          *  @example
 408          *    // Create a comma separated list from an array of objects
 409          *    $(document).ready( function() {
 410          *      var oTable = $('#example').dataTable( {
 411          *        "sAjaxSource": "sources/deep.txt",
 412          *        "aoColumns": [
 413          *          { "mData": "engine" },
 414          *          { "mData": "browser" },
 415          *          {
 416          *            "mData": "platform",
 417          *            "mRender": "[, ].name"
 418          *          }
 419          *        ]
 420          *      } );
 421          *    } );
 422          *
 423          *  @example
 424          *    // Use as a function to create a link from the data source
 425          *    $(document).ready( function() {
 426          *      var oTable = $('#example').dataTable( {
 427          *        "aoColumnDefs": [
 428          *        {
 429          *          "aTargets": [ 0 ],
 430          *          "mData": "download_link",
 431          *          "mRender": function ( data, type, full ) {
 432          *            return '<a href="'+data+'">Download</a>';
 433          *          }
 434          *        ]
 435          *      } );
 436          *    } );
 437          */
 438         "mRender": null,
 439
 440
 441         /**
 442          * Change the cell type created for the column - either TD cells or TH cells. This
 443          * can be useful as TH cells have semantic meaning in the table body, allowing them
 444          * to act as a header for a row (you may wish to add scope='row' to the TH elements).
 445          *  @type string
 446          *  @default td
 447          *  @dtopt Columns
 448          *
 449          *  @example
 450          *    // Make the first column use TH cells
 451          *    $(document).ready( function() {
 452          *      var oTable = $('#example').dataTable( {
 453          *        "aoColumnDefs": [ {
 454          *          "aTargets": [ 0 ],
 455          *          "sCellType": "th"
 456          *        } ]
 457          *      } );
 458          *    } );
 459          */
 460         "sCellType": "td",
 461
 462
 463         /**
 464          * Class to give to each cell in this column.
 465          *  @type string
 466          *  @default <i>Empty string</i>
 467          *  @dtopt Columns
 468          *
 469          *  @example
 470          *    // Using aoColumnDefs
 471          *    $(document).ready( function() {
 472          *      $('#example').dataTable( {
 473          *        "aoColumnDefs": [
 474          *          { "sClass": "my_class", "aTargets": [ 0 ] }
 475          *        ]
 476          *      } );
 477          *    } );
 478          *
 479          *  @example
 480          *    // Using aoColumns
 481          *    $(document).ready( function() {
 482          *      $('#example').dataTable( {
 483          *        "aoColumns": [
 484          *          { "sClass": "my_class" },
 485          *          null,
 486          *          null,
 487          *          null,
 488          *          null
 489          *        ]
 490          *      } );
 491          *    } );
 492          */
 493         "sClass": "",
 494
 495         /**
 496          * When DataTables calculates the column widths to assign to each column,
 497          * it finds the longest string in each column and then constructs a
 498          * temporary table and reads the widths from that. The problem with this
 499          * is that "mmm" is much wider then "iiii", but the latter is a longer
 500          * string - thus the calculation can go wrong (doing it properly and putting
 501          * it into an DOM object and measuring that is horribly(!) slow). Thus as
 502          * a "work around" we provide this option. It will append its value to the
 503          * text that is found to be the longest string for the column - i.e. padding.
 504          * Generally you shouldn't need this, and it is not documented on the
 505          * general DataTables.net documentation
 506          *  @type string
 507          *  @default <i>Empty string<i>
 508          *  @dtopt Columns
 509          *
 510          *  @example
 511          *    // Using aoColumns
 512          *    $(document).ready( function() {
 513          *      $('#example').dataTable( {
 514          *        "aoColumns": [
 515          *          null,
 516          *          null,
 517          *          null,
 518          *          {
 519          *            "sContentPadding": "mmm"
 520          *          }
 521          *        ]
 522          *      } );
 523          *    } );
 524          */
 525         "sContentPadding": "",
 526
 527
 528         /**
 529          * Allows a default value to be given for a column's data, and will be used
 530          * whenever a null data source is encountered (this can be because mData
 531          * is set to null, or because the data source itself is null).
 532          *  @type string
 533          *  @default null
 534          *  @dtopt Columns
 535          *
 536          *  @example
 537          *    // Using aoColumnDefs
 538          *    $(document).ready( function() {
 539          *      $('#example').dataTable( {
 540          *        "aoColumnDefs": [
 541          *          {
 542          *            "mData": null,
 543          *            "sDefaultContent": "Edit",
 544          *            "aTargets": [ -1 ]
 545          *          }
 546          *        ]
 547          *      } );
 548          *    } );
 549          *
 550          *  @example
 551          *    // Using aoColumns
 552          *    $(document).ready( function() {
 553          *      $('#example').dataTable( {
 554          *        "aoColumns": [
 555          *          null,
 556          *          null,
 557          *          null,
 558          *          {
 559          *            "mData": null,
 560          *            "sDefaultContent": "Edit"
 561          *          }
 562          *        ]
 563          *      } );
 564          *    } );
 565          */
 566         "sDefaultContent": null,
 567
 568
 569         /**
 570          * This parameter is only used in DataTables' server-side processing. It can
 571          * be exceptionally useful to know what columns are being displayed on the
 572          * client side, and to map these to database fields. When defined, the names
 573          * also allow DataTables to reorder information from the server if it comes
 574          * back in an unexpected order (i.e. if you switch your columns around on the
 575          * client-side, your server-side code does not also need updating).
 576          *  @type string
 577          *  @default <i>Empty string</i>
 578          *  @dtopt Columns
 579          *
 580          *  @example
 581          *    // Using aoColumnDefs
 582          *    $(document).ready( function() {
 583          *      $('#example').dataTable( {
 584          *        "aoColumnDefs": [
 585          *          { "sName": "engine", "aTargets": [ 0 ] },
 586          *          { "sName": "browser", "aTargets": [ 1 ] },
 587          *          { "sName": "platform", "aTargets": [ 2 ] },
 588          *          { "sName": "version", "aTargets": [ 3 ] },
 589          *          { "sName": "grade", "aTargets": [ 4 ] }
 590          *        ]
 591          *      } );
 592          *    } );
 593          *
 594          *  @example
 595          *    // Using aoColumns
 596          *    $(document).ready( function() {
 597          *      $('#example').dataTable( {
 598          *        "aoColumns": [
 599          *          { "sName": "engine" },
 600          *          { "sName": "browser" },
 601          *          { "sName": "platform" },
 602          *          { "sName": "version" },
 603          *          { "sName": "grade" }
 604          *        ]
 605          *      } );
 606          *    } );
 607          */
 608         "sName": "",
 609
 610
 611         /**
 612          * Defines a data source type for the sorting which can be used to read
 613          * real-time information from the table (updating the internally cached
 614          * version) prior to sorting. This allows sorting to occur on user editable
 615          * elements such as form inputs.
 616          *  @type string
 617          *  @default std
 618          *  @dtopt Columns
 619          *
 620          *  @example
 621          *    // Using aoColumnDefs
 622          *    $(document).ready( function() {
 623          *      $('#example').dataTable( {
 624          *        "aoColumnDefs": [
 625          *          { "sSortDataType": "dom-text", "aTargets": [ 2, 3 ] },
 626          *          { "sType": "numeric", "aTargets": [ 3 ] },
 627          *          { "sSortDataType": "dom-select", "aTargets": [ 4 ] },
 628          *          { "sSortDataType": "dom-checkbox", "aTargets": [ 5 ] }
 629          *        ]
 630          *      } );
 631          *    } );
 632          *
 633          *  @example
 634          *    // Using aoColumns
 635          *    $(document).ready( function() {
 636          *      $('#example').dataTable( {
 637          *        "aoColumns": [
 638          *          null,
 639          *          null,
 640          *          { "sSortDataType": "dom-text" },
 641          *          { "sSortDataType": "dom-text", "sType": "numeric" },
 642          *          { "sSortDataType": "dom-select" },
 643          *          { "sSortDataType": "dom-checkbox" }
 644          *        ]
 645          *      } );
 646          *    } );
 647          */
 648         "sSortDataType": "std",
 649
 650
 651         /**
 652          * The title of this column.
 653          *  @type string
 654          *  @default null <i>Derived from the 'TH' value for this column in the
 655          *    original HTML table.</i>
 656          *  @dtopt Columns
 657          *
 658          *  @example
 659          *    // Using aoColumnDefs
 660          *    $(document).ready( function() {
 661          *      $('#example').dataTable( {
 662          *        "aoColumnDefs": [
 663          *          { "sTitle": "My column title", "aTargets": [ 0 ] }
 664          *        ]
 665          *      } );
 666          *    } );
 667          *
 668          *  @example
 669          *    // Using aoColumns
 670          *    $(document).ready( function() {
 671          *      $('#example').dataTable( {
 672          *        "aoColumns": [
 673          *          { "sTitle": "My column title" },
 674          *          null,
 675          *          null,
 676          *          null,
 677          *          null
 678          *        ]
 679          *      } );
 680          *    } );
 681          */
 682         "sTitle": null,
 683
 684
 685         /**
 686          * The type allows you to specify how the data for this column will be sorted.
 687          * Four types (string, numeric, date and html (which will strip HTML tags
 688          * before sorting)) are currently available. Note that only date formats
 689          * understood by Javascript's Date() object will be accepted as type date. For
 690          * example: "Mar 26, 2008 5:03 PM". May take the values: 'string', 'numeric',
 691          * 'date' or 'html' (by default). Further types can be adding through
 692          * plug-ins.
 693          *  @type string
 694          *  @default null <i>Auto-detected from raw data</i>
 695          *  @dtopt Columns
 696          *
 697          *  @example
 698          *    // Using aoColumnDefs
 699          *    $(document).ready( function() {
 700          *      $('#example').dataTable( {
 701          *        "aoColumnDefs": [
 702          *          { "sType": "html", "aTargets": [ 0 ] }
 703          *        ]
 704          *      } );
 705          *    } );
 706          *
 707          *  @example
 708          *    // Using aoColumns
 709          *    $(document).ready( function() {
 710          *      $('#example').dataTable( {
 711          *        "aoColumns": [
 712          *          { "sType": "html" },
 713          *          null,
 714          *          null,
 715          *          null,
 716          *          null
 717          *        ]
 718          *      } );
 719          *    } );
 720          */
 721         "sType": null,
 722
 723
 724         /**
 725          * Defining the width of the column, this parameter may take any CSS value
 726          * (3em, 20px etc). DataTables apples 'smart' widths to columns which have not
 727          * been given a specific width through this interface ensuring that the table
 728          * remains readable.
 729          *  @type string
 730          *  @default null <i>Automatic</i>
 731          *  @dtopt Columns
 732          *
 733          *  @example
 734          *    // Using aoColumnDefs
 735          *    $(document).ready( function() {
 736          *      $('#example').dataTable( {
 737          *        "aoColumnDefs": [
 738          *          { "sWidth": "20%", "aTargets": [ 0 ] }
 739          *        ]
 740          *      } );
 741          *    } );
 742          *
 743          *  @example
 744          *    // Using aoColumns
 745          *    $(document).ready( function() {
 746          *      $('#example').dataTable( {
 747          *        "aoColumns": [
 748          *          { "sWidth": "20%" },
 749          *          null,
 750          *          null,
 751          *          null,
 752          *          null
 753          *        ]
 754          *      } );
 755          *    } );
 756          */
 757         "sWidth": null
 758 };
 759