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

   1
   2
   3 /**
   4  * Initialisation options that can be given to DataTables at initialisation
   5  * time.
   6  *  @namespace
   7  */
   8 DataTable.defaults = {
   9         /**
  10          * An array of data to use for the table, passed in at initialisation which
  11          * will be used in preference to any data which is already in the DOM. This is
  12          * particularly useful for constructing tables purely in Javascript, for
  13          * example with a custom Ajax call.
  14          *  @type array
  15          *  @default null
  16          *  @dtopt Option
  17          *
  18          *  @example
  19          *    // Using a 2D array data source
  20          *    $(document).ready( function () {
  21          *      $('#example').dataTable( {
  22          *        "aaData": [
  23          *          ['Trident', 'Internet Explorer 4.0', 'Win 95+', 4, 'X'],
  24          *          ['Trident', 'Internet Explorer 5.0', 'Win 95+', 5, 'C'],
  25          *        ],
  26          *        "aoColumns": [
  27          *          { "sTitle": "Engine" },
  28          *          { "sTitle": "Browser" },
  29          *          { "sTitle": "Platform" },
  30          *          { "sTitle": "Version" },
  31          *          { "sTitle": "Grade" }
  32          *        ]
  33          *      } );
  34          *    } );
  35          *
  36          *  @example
  37          *    // Using an array of objects as a data source (mData)
  38          *    $(document).ready( function () {
  39          *      $('#example').dataTable( {
  40          *        "aaData": [
  41          *          {
  42          *            "engine":   "Trident",
  43          *            "browser":  "Internet Explorer 4.0",
  44          *            "platform": "Win 95+",
  45          *            "version":  4,
  46          *            "grade":    "X"
  47          *          },
  48          *          {
  49          *            "engine":   "Trident",
  50          *            "browser":  "Internet Explorer 5.0",
  51          *            "platform": "Win 95+",
  52          *            "version":  5,
  53          *            "grade":    "C"
  54          *          }
  55          *        ],
  56          *        "aoColumns": [
  57          *          { "sTitle": "Engine",   "mData": "engine" },
  58          *          { "sTitle": "Browser",  "mData": "browser" },
  59          *          { "sTitle": "Platform", "mData": "platform" },
  60          *          { "sTitle": "Version",  "mData": "version" },
  61          *          { "sTitle": "Grade",    "mData": "grade" }
  62          *        ]
  63          *      } );
  64          *    } );
  65          */
  66         "aaData": null,
  67
  68
  69         /**
  70          * If sorting is enabled, then DataTables will perform a first pass sort on
  71          * initialisation. You can define which column(s) the sort is performed upon,
  72          * and the sorting direction, with this variable. The aaSorting array should
  73          * contain an array for each column to be sorted initially containing the
  74          * column's index and a direction string ('asc' or 'desc').
  75          *  @type array
  76          *  @default [[0,'asc']]
  77          *  @dtopt Option
  78          *
  79          *  @example
  80          *    // Sort by 3rd column first, and then 4th column
  81          *    $(document).ready( function() {
  82          *      $('#example').dataTable( {
  83          *        "aaSorting": [[2,'asc'], [3,'desc']]
  84          *      } );
  85          *    } );
  86          *
  87          *    // No initial sorting
  88          *    $(document).ready( function() {
  89          *      $('#example').dataTable( {
  90          *        "aaSorting": []
  91          *      } );
  92          *    } );
  93          */
  94         "aaSorting": [[0,'asc']],
  95
  96
  97         /**
  98          * This parameter is basically identical to the aaSorting parameter, but
  99          * cannot be overridden by user interaction with the table. What this means
 100          * is that you could have a column (visible or hidden) which the sorting will
 101          * always be forced on first - any sorting after that (from the user) will
 102          * then be performed as required. This can be useful for grouping rows
 103          * together.
 104          *  @type array
 105          *  @default null
 106          *  @dtopt Option
 107          *
 108          *  @example
 109          *    $(document).ready( function() {
 110          *      $('#example').dataTable( {
 111          *        "aaSortingFixed": [[0,'asc']]
 112          *      } );
 113          *    } )
 114          */
 115         "aaSortingFixed": null,
 116
 117
 118         /**
 119          * This parameter allows you to readily specify the entries in the length drop
 120          * down menu that DataTables shows when pagination is enabled. It can be
 121          * either a 1D array of options which will be used for both the displayed
 122          * option and the value, or a 2D array which will use the array in the first
 123          * position as the value, and the array in the second position as the
 124          * displayed options (useful for language strings such as 'All').
 125          *  @type array
 126          *  @default [ 10, 25, 50, 100 ]
 127          *  @dtopt Option
 128          *
 129          *  @example
 130          *    $(document).ready( function() {
 131          *      $('#example').dataTable( {
 132          *        "aLengthMenu": [[10, 25, 50, -1], [10, 25, 50, "All"]]
 133          *      } );
 134          *    } );
 135          *
 136          *  @example
 137          *    // Setting the default display length as well as length menu
 138          *    // This is likely to be wanted if you remove the '10' option which
 139          *    // is the iDisplayLength default.
 140          *    $(document).ready( function() {
 141          *      $('#example').dataTable( {
 142          *        "iDisplayLength": 25,
 143          *        "aLengthMenu": [[25, 50, 100, -1], [25, 50, 100, "All"]]
 144          *      } );
 145          *    } );
 146          */
 147         "aLengthMenu": [ 10, 25, 50, 100 ],
 148
 149
 150         /**
 151          * The aoColumns option in the initialisation parameter allows you to define
 152          * details about the way individual columns behave. For a full list of
 153          * column options that can be set, please see
 154          * {@link DataTable.defaults.columns}. Note that if you use aoColumns to
 155          * define your columns, you must have an entry in the array for every single
 156          * column that you have in your table (these can be null if you don't which
 157          * to specify any options).
 158          *  @member
 159          */
 160         "aoColumns": null,
 161
 162         /**
 163          * Very similar to aoColumns, aoColumnDefs allows you to target a specific
 164          * column, multiple columns, or all columns, using the aTargets property of
 165          * each object in the array. This allows great flexibility when creating
 166          * tables, as the aoColumnDefs arrays can be of any length, targeting the
 167          * columns you specifically want. aoColumnDefs may use any of the column
 168          * options available: {@link DataTable.defaults.columns}, but it _must_
 169          * have aTargets defined in each object in the array. Values in the aTargets
 170          * array may be:
 171          *   <ul>
 172          *     <li>a string - class name will be matched on the TH for the column</li>
 173          *     <li>0 or a positive integer - column index counting from the left</li>
 174          *     <li>a negative integer - column index counting from the right</li>
 175          *     <li>the string "_all" - all columns (i.e. assign a default)</li>
 176          *   </ul>
 177          *  @member
 178          */
 179         "aoColumnDefs": null,
 180
 181
 182         /**
 183          * Basically the same as oSearch, this parameter defines the individual column
 184          * filtering state at initialisation time. The array must be of the same size
 185          * as the number of columns, and each element be an object with the parameters
 186          * "sSearch" and "bEscapeRegex" (the latter is optional). 'null' is also
 187          * accepted and the default will be used.
 188          *  @type array
 189          *  @default []
 190          *  @dtopt Option
 191          *
 192          *  @example
 193          *    $(document).ready( function() {
 194          *      $('#example').dataTable( {
 195          *        "aoSearchCols": [
 196          *          null,
 197          *          { "sSearch": "My filter" },
 198          *          null,
 199          *          { "sSearch": "^[0-9]", "bEscapeRegex": false }
 200          *        ]
 201          *      } );
 202          *    } )
 203          */
 204         "aoSearchCols": [],
 205
 206
 207         /**
 208          * An array of CSS classes that should be applied to displayed rows. This
 209          * array may be of any length, and DataTables will apply each class
 210          * sequentially, looping when required.
 211          *  @type array
 212          *  @default null <i>Will take the values determined by the oClasses.sStripe*
 213          *    options</i>
 214          *  @dtopt Option
 215          *
 216          *  @example
 217          *    $(document).ready( function() {
 218          *      $('#example').dataTable( {
 219          *        "asStripeClasses": [ 'strip1', 'strip2', 'strip3' ]
 220          *      } );
 221          *    } )
 222          */
 223         "asStripeClasses": null,
 224
 225
 226         /**
 227          * Enable or disable automatic column width calculation. This can be disabled
 228          * as an optimisation (it takes some time to calculate the widths) if the
 229          * tables widths are passed in using aoColumns.
 230          *  @type boolean
 231          *  @default true
 232          *  @dtopt Features
 233          *
 234          *  @example
 235          *    $(document).ready( function () {
 236          *      $('#example').dataTable( {
 237          *        "bAutoWidth": false
 238          *      } );
 239          *    } );
 240          */
 241         "bAutoWidth": true,
 242
 243
 244         /**
 245          * Deferred rendering can provide DataTables with a huge speed boost when you
 246          * are using an Ajax or JS data source for the table. This option, when set to
 247          * true, will cause DataTables to defer the creation of the table elements for
 248          * each row until they are needed for a draw - saving a significant amount of
 249          * time.
 250          *  @type boolean
 251          *  @default false
 252          *  @dtopt Features
 253          *
 254          *  @example
 255          *    $(document).ready( function() {
 256          *      var oTable = $('#example').dataTable( {
 257          *        "sAjaxSource": "sources/arrays.txt",
 258          *        "bDeferRender": true
 259          *      } );
 260          *    } );
 261          */
 262         "bDeferRender": false,
 263
 264
 265         /**
 266          * Replace a DataTable which matches the given selector and replace it with
 267          * one which has the properties of the new initialisation object passed. If no
 268          * table matches the selector, then the new DataTable will be constructed as
 269          * per normal.
 270          *  @type boolean
 271          *  @default false
 272          *  @dtopt Options
 273          *
 274          *  @example
 275          *    $(document).ready( function() {
 276          *      $('#example').dataTable( {
 277          *        "sScrollY": "200px",
 278          *        "bPaginate": false
 279          *      } );
 280          *
 281          *      // Some time later....
 282          *      $('#example').dataTable( {
 283          *        "bFilter": false,
 284          *        "bDestroy": true
 285          *      } );
 286          *    } );
 287          */
 288         "bDestroy": false,
 289
 290
 291         /**
 292          * Enable or disable filtering of data. Filtering in DataTables is "smart" in
 293          * that it allows the end user to input multiple words (space separated) and
 294          * will match a row containing those words, even if not in the order that was
 295          * specified (this allow matching across multiple columns). Note that if you
 296          * wish to use filtering in DataTables this must remain 'true' - to remove the
 297          * default filtering input box and retain filtering abilities, please use
 298          * {@link DataTable.defaults.sDom}.
 299          *  @type boolean
 300          *  @default true
 301          *  @dtopt Features
 302          *
 303          *  @example
 304          *    $(document).ready( function () {
 305          *      $('#example').dataTable( {
 306          *        "bFilter": false
 307          *      } );
 308          *    } );
 309          */
 310         "bFilter": true,
 311
 312
 313         /**
 314          * Enable or disable the table information display. This shows information
 315          * about the data that is currently visible on the page, including information
 316          * about filtered data if that action is being performed.
 317          *  @type boolean
 318          *  @default true
 319          *  @dtopt Features
 320          *
 321          *  @example
 322          *    $(document).ready( function () {
 323          *      $('#example').dataTable( {
 324          *        "bInfo": false
 325          *      } );
 326          *    } );
 327          */
 328         "bInfo": true,
 329
 330
 331         /**
 332          * Enable jQuery UI ThemeRoller support (required as ThemeRoller requires some
 333          * slightly different and additional mark-up from what DataTables has
 334          * traditionally used).
 335          *  @type boolean
 336          *  @default false
 337          *  @dtopt Features
 338          *
 339          *  @example
 340          *    $(document).ready( function() {
 341          *      $('#example').dataTable( {
 342          *        "bJQueryUI": true
 343          *      } );
 344          *    } );
 345          */
 346         "bJQueryUI": false,
 347
 348
 349         /**
 350          * Allows the end user to select the size of a formatted page from a select
 351          * menu (sizes are 10, 25, 50 and 100). Requires pagination (bPaginate).
 352          *  @type boolean
 353          *  @default true
 354          *  @dtopt Features
 355          *
 356          *  @example
 357          *    $(document).ready( function () {
 358          *      $('#example').dataTable( {
 359          *        "bLengthChange": false
 360          *      } );
 361          *    } );
 362          */
 363         "bLengthChange": true,
 364
 365
 366         /**
 367          * Enable or disable pagination.
 368          *  @type boolean
 369          *  @default true
 370          *  @dtopt Features
 371          *
 372          *  @example
 373          *    $(document).ready( function () {
 374          *      $('#example').dataTable( {
 375          *        "bPaginate": false
 376          *      } );
 377          *    } );
 378          */
 379         "bPaginate": true,
 380
 381
 382         /**
 383          * Enable or disable the display of a 'processing' indicator when the table is
 384          * being processed (e.g. a sort). This is particularly useful for tables with
 385          * large amounts of data where it can take a noticeable amount of time to sort
 386          * the entries.
 387          *  @type boolean
 388          *  @default false
 389          *  @dtopt Features
 390          *
 391          *  @example
 392          *    $(document).ready( function () {
 393          *      $('#example').dataTable( {
 394          *        "bProcessing": true
 395          *      } );
 396          *    } );
 397          */
 398         "bProcessing": false,
 399
 400
 401         /**
 402          * Retrieve the DataTables object for the given selector. Note that if the
 403          * table has already been initialised, this parameter will cause DataTables
 404          * to simply return the object that has already been set up - it will not take
 405          * account of any changes you might have made to the initialisation object
 406          * passed to DataTables (setting this parameter to true is an acknowledgement
 407          * that you understand this). bDestroy can be used to reinitialise a table if
 408          * you need.
 409          *  @type boolean
 410          *  @default false
 411          *  @dtopt Options
 412          *
 413          *  @example
 414          *    $(document).ready( function() {
 415          *      initTable();
 416          *      tableActions();
 417          *    } );
 418          *
 419          *    function initTable ()
 420          *    {
 421          *      return $('#example').dataTable( {
 422          *        "sScrollY": "200px",
 423          *        "bPaginate": false,
 424          *        "bRetrieve": true
 425          *      } );
 426          *    }
 427          *
 428          *    function tableActions ()
 429          *    {
 430          *      var oTable = initTable();
 431          *      // perform API operations with oTable
 432          *    }
 433          */
 434         "bRetrieve": false,
 435
 436
 437         /**
 438          * Indicate if DataTables should be allowed to set the padding / margin
 439          * etc for the scrolling header elements or not. Typically you will want
 440          * this.
 441          *  @type boolean
 442          *  @default true
 443          *  @dtopt Options
 444          *
 445          *  @example
 446          *    $(document).ready( function() {
 447          *      $('#example').dataTable( {
 448          *        "bScrollAutoCss": false,
 449          *        "sScrollY": "200px"
 450          *      } );
 451          *    } );
 452          */
 453         "bScrollAutoCss": true,
 454
 455
 456         /**
 457          * When vertical (y) scrolling is enabled, DataTables will force the height of
 458          * the table's viewport to the given height at all times (useful for layout).
 459          * However, this can look odd when filtering data down to a small data set,
 460          * and the footer is left "floating" further down. This parameter (when
 461          * enabled) will cause DataTables to collapse the table's viewport down when
 462          * the result set will fit within the given Y height.
 463          *  @type boolean
 464          *  @default false
 465          *  @dtopt Options
 466          *
 467          *  @example
 468          *    $(document).ready( function() {
 469          *      $('#example').dataTable( {
 470          *        "sScrollY": "200",
 471          *        "bScrollCollapse": true
 472          *      } );
 473          *    } );
 474          */
 475         "bScrollCollapse": false,
 476
 477
 478         /**
 479          * Enable infinite scrolling for DataTables (to be used in combination with
 480          * sScrollY). Infinite scrolling means that DataTables will continually load
 481          * data as a user scrolls through a table, which is very useful for large
 482          * dataset. This cannot be used with pagination, which is automatically
 483          * disabled. Note - the Scroller extra for DataTables is recommended in
 484          * in preference to this option.
 485          *  @type boolean
 486          *  @default false
 487          *  @dtopt Features
 488          *
 489          *  @example
 490          *    $(document).ready( function() {
 491          *      $('#example').dataTable( {
 492          *        "bScrollInfinite": true,
 493          *        "bScrollCollapse": true,
 494          *        "sScrollY": "200px"
 495          *      } );
 496          *    } );
 497          */
 498         "bScrollInfinite": false,
 499
 500
 501         /**
 502          * Configure DataTables to use server-side processing. Note that the
 503          * sAjaxSource parameter must also be given in order to give DataTables a
 504          * source to obtain the required data for each draw.
 505          *  @type boolean
 506          *  @default false
 507          *  @dtopt Features
 508          *  @dtopt Server-side
 509          *
 510          *  @example
 511          *    $(document).ready( function () {
 512          *      $('#example').dataTable( {
 513          *        "bServerSide": true,
 514          *        "sAjaxSource": "xhr.php"
 515          *      } );
 516          *    } );
 517          */
 518         "bServerSide": false,
 519
 520
 521         /**
 522          * Enable or disable sorting of columns. Sorting of individual columns can be
 523          * disabled by the "bSortable" option for each column.
 524          *  @type boolean
 525          *  @default true
 526          *  @dtopt Features
 527          *
 528          *  @example
 529          *    $(document).ready( function () {
 530          *      $('#example').dataTable( {
 531          *        "bSort": false
 532          *      } );
 533          *    } );
 534          */
 535         "bSort": true,
 536
 537
 538         /**
 539          * Allows control over whether DataTables should use the top (true) unique
 540          * cell that is found for a single column, or the bottom (false - default).
 541          * This is useful when using complex headers.
 542          *  @type boolean
 543          *  @default false
 544          *  @dtopt Options
 545          *
 546          *  @example
 547          *    $(document).ready( function() {
 548          *      $('#example').dataTable( {
 549          *        "bSortCellsTop": true
 550          *      } );
 551          *    } );
 552          */
 553         "bSortCellsTop": false,
 554
 555
 556         /**
 557          * Enable or disable the addition of the classes 'sorting_1', 'sorting_2' and
 558          * 'sorting_3' to the columns which are currently being sorted on. This is
 559          * presented as a feature switch as it can increase processing time (while
 560          * classes are removed and added) so for large data sets you might want to
 561          * turn this off.
 562          *  @type boolean
 563          *  @default true
 564          *  @dtopt Features
 565          *
 566          *  @example
 567          *    $(document).ready( function () {
 568          *      $('#example').dataTable( {
 569          *        "bSortClasses": false
 570          *      } );
 571          *    } );
 572          */
 573         "bSortClasses": true,
 574
 575
 576         /**
 577          * Enable or disable state saving. When enabled a cookie will be used to save
 578          * table display information such as pagination information, display length,
 579          * filtering and sorting. As such when the end user reloads the page the
 580          * display display will match what thy had previously set up.
 581          *  @type boolean
 582          *  @default false
 583          *  @dtopt Features
 584          *
 585          *  @example
 586          *    $(document).ready( function () {
 587          *      $('#example').dataTable( {
 588          *        "bStateSave": true
 589          *      } );
 590          *    } );
 591          */
 592         "bStateSave": false,
 593
 594
 595         /**
 596          * Customise the cookie and / or the parameters being stored when using
 597          * DataTables with state saving enabled. This function is called whenever
 598          * the cookie is modified, and it expects a fully formed cookie string to be
 599          * returned. Note that the data object passed in is a Javascript object which
 600          * must be converted to a string (JSON.stringify for example).
 601          *  @type function
 602          *  @param {string} sName Name of the cookie defined by DataTables
 603          *  @param {object} oData Data to be stored in the cookie
 604          *  @param {string} sExpires Cookie expires string
 605          *  @param {string} sPath Path of the cookie to set
 606          *  @returns {string} Cookie formatted string (which should be encoded by
 607          *    using encodeURIComponent())
 608          *  @dtopt Callbacks
 609          *
 610          *  @example
 611          *    $(document).ready( function () {
 612          *      $('#example').dataTable( {
 613          *        "fnCookieCallback": function (sName, oData, sExpires, sPath) {
 614          *          // Customise oData or sName or whatever else here
 615          *          return sName + "="+JSON.stringify(oData)+"; expires=" + sExpires +"; path=" + sPath;
 616          *        }
 617          *      } );
 618          *    } );
 619          */
 620         "fnCookieCallback": null,
 621
 622
 623         /**
 624          * This function is called when a TR element is created (and all TD child
 625          * elements have been inserted), or registered if using a DOM source, allowing
 626          * manipulation of the TR element (adding classes etc).
 627          *  @type function
 628          *  @param {node} nRow "TR" element for the current row
 629          *  @param {array} aData Raw data array for this row
 630          *  @param {int} iDataIndex The index of this row in aoData
 631          *  @dtopt Callbacks
 632          *
 633          *  @example
 634          *    $(document).ready( function() {
 635          *      $('#example').dataTable( {
 636          *        "fnCreatedRow": function( nRow, aData, iDataIndex ) {
 637          *          // Bold the grade for all 'A' grade browsers
 638          *          if ( aData[4] == "A" )
 639          *          {
 640          *            $('td:eq(4)', nRow).html( '<b>A</b>' );
 641          *          }
 642          *        }
 643          *      } );
 644          *    } );
 645          */
 646         "fnCreatedRow": null,
 647
 648
 649         /**
 650          * This function is called on every 'draw' event, and allows you to
 651          * dynamically modify any aspect you want about the created DOM.
 652          *  @type function
 653          *  @param {object} oSettings DataTables settings object
 654          *  @dtopt Callbacks
 655          *
 656          *  @example
 657          *    $(document).ready( function() {
 658          *      $('#example').dataTable( {
 659          *        "fnDrawCallback": function( oSettings ) {
 660          *          alert( 'DataTables has redrawn the table' );
 661          *        }
 662          *      } );
 663          *    } );
 664          */
 665         "fnDrawCallback": null,
 666
 667
 668         /**
 669          * Identical to fnHeaderCallback() but for the table footer this function
 670          * allows you to modify the table footer on every 'draw' even.
 671          *  @type function
 672          *  @param {node} nFoot "TR" element for the footer
 673          *  @param {array} aData Full table data (as derived from the original HTML)
 674          *  @param {int} iStart Index for the current display starting point in the
 675          *    display array
 676          *  @param {int} iEnd Index for the current display ending point in the
 677          *    display array
 678          *  @param {array int} aiDisplay Index array to translate the visual position
 679          *    to the full data array
 680          *  @dtopt Callbacks
 681          *
 682          *  @example
 683          *    $(document).ready( function() {
 684          *      $('#example').dataTable( {
 685          *        "fnFooterCallback": function( nFoot, aData, iStart, iEnd, aiDisplay ) {
 686          *          nFoot.getElementsByTagName('th')[0].innerHTML = "Starting index is "+iStart;
 687          *        }
 688          *      } );
 689          *    } )
 690          */
 691         "fnFooterCallback": null,
 692
 693
 694         /**
 695          * When rendering large numbers in the information element for the table
 696          * (i.e. "Showing 1 to 10 of 57 entries") DataTables will render large numbers
 697          * to have a comma separator for the 'thousands' units (e.g. 1 million is
 698          * rendered as "1,000,000") to help readability for the end user. This
 699          * function will override the default method DataTables uses.
 700          *  @type function
 701          *  @member
 702          *  @param {int} iIn number to be formatted
 703          *  @returns {string} formatted string for DataTables to show the number
 704          *  @dtopt Callbacks
 705          *
 706          *  @example
 707          *    $(document).ready( function() {
 708          *      $('#example').dataTable( {
 709          *        "fnFormatNumber": function ( iIn ) {
 710          *          if ( iIn &lt; 1000 ) {
 711          *            return iIn;
 712          *          } else {
 713          *            var
 714          *              s=(iIn+""),
 715          *              a=s.split(""), out="",
 716          *              iLen=s.length;
 717          *
 718          *            for ( var i=0 ; i&lt;iLen ; i++ ) {
 719          *              if ( i%3 === 0 &amp;&amp; i !== 0 ) {
 720          *                out = "'"+out;
 721          *              }
 722          *              out = a[iLen-i-1]+out;
 723          *            }
 724          *          }
 725          *          return out;
 726          *        };
 727          *      } );
 728          *    } );
 729          */
 730         "fnFormatNumber": function ( iIn ) {
 731                 if ( iIn < 1000 )
 732                 {
 733                         // A small optimisation for what is likely to be the majority of use cases
 734                         return iIn;
 735                 }
 736
 737                 var s=(iIn+""), a=s.split(""), out="", iLen=s.length;
 738
 739                 for ( var i=0 ; i<iLen ; i++ )
 740                 {
 741                         if ( i%3 === 0 && i !== 0 )
 742                         {
 743                                 out = this.oLanguage.sInfoThousands+out;
 744                         }
 745                         out = a[iLen-i-1]+out;
 746                 }
 747                 return out;
 748         },
 749
 750
 751         /**
 752          * This function is called on every 'draw' event, and allows you to
 753          * dynamically modify the header row. This can be used to calculate and
 754          * display useful information about the table.
 755          *  @type function
 756          *  @param {node} nHead "TR" element for the header
 757          *  @param {array} aData Full table data (as derived from the original HTML)
 758          *  @param {int} iStart Index for the current display starting point in the
 759          *    display array
 760          *  @param {int} iEnd Index for the current display ending point in the
 761          *    display array
 762          *  @param {array int} aiDisplay Index array to translate the visual position
 763          *    to the full data array
 764          *  @dtopt Callbacks
 765          *
 766          *  @example
 767          *    $(document).ready( function() {
 768          *      $('#example').dataTable( {
 769          *        "fnHeaderCallback": function( nHead, aData, iStart, iEnd, aiDisplay ) {
 770          *          nHead.getElementsByTagName('th')[0].innerHTML = "Displaying "+(iEnd-iStart)+" records";
 771          *        }
 772          *      } );
 773          *    } )
 774          */
 775         "fnHeaderCallback": null,
 776
 777
 778         /**
 779          * The information element can be used to convey information about the current
 780          * state of the table. Although the internationalisation options presented by
 781          * DataTables are quite capable of dealing with most customisations, there may
 782          * be times where you wish to customise the string further. This callback
 783          * allows you to do exactly that.
 784          *  @type function
 785          *  @param {object} oSettings DataTables settings object
 786          *  @param {int} iStart Starting position in data for the draw
 787          *  @param {int} iEnd End position in data for the draw
 788          *  @param {int} iMax Total number of rows in the table (regardless of
 789          *    filtering)
 790          *  @param {int} iTotal Total number of rows in the data set, after filtering
 791          *  @param {string} sPre The string that DataTables has formatted using it's
 792          *    own rules
 793          *  @returns {string} The string to be displayed in the information element.
 794          *  @dtopt Callbacks
 795          *
 796          *  @example
 797          *    $('#example').dataTable( {
 798          *      "fnInfoCallback": function( oSettings, iStart, iEnd, iMax, iTotal, sPre ) {
 799          *        return iStart +" to "+ iEnd;
 800          *      }
 801          *    } );
 802          */
 803         "fnInfoCallback": null,
 804
 805
 806         /**
 807          * Called when the table has been initialised. Normally DataTables will
 808          * initialise sequentially and there will be no need for this function,
 809          * however, this does not hold true when using external language information
 810          * since that is obtained using an async XHR call.
 811          *  @type function
 812          *  @param {object} oSettings DataTables settings object
 813          *  @param {object} json The JSON object request from the server - only
 814          *    present if client-side Ajax sourced data is used
 815          *  @dtopt Callbacks
 816          *
 817          *  @example
 818          *    $(document).ready( function() {
 819          *      $('#example').dataTable( {
 820          *        "fnInitComplete": function(oSettings, json) {
 821          *          alert( 'DataTables has finished its initialisation.' );
 822          *        }
 823          *      } );
 824          *    } )
 825          */
 826         "fnInitComplete": null,
 827
 828
 829         /**
 830          * Called at the very start of each table draw and can be used to cancel the
 831          * draw by returning false, any other return (including undefined) results in
 832          * the full draw occurring).
 833          *  @type function
 834          *  @param {object} oSettings DataTables settings object
 835          *  @returns {boolean} False will cancel the draw, anything else (including no
 836          *    return) will allow it to complete.
 837          *  @dtopt Callbacks
 838          *
 839          *  @example
 840          *    $(document).ready( function() {
 841          *      $('#example').dataTable( {
 842          *        "fnPreDrawCallback": function( oSettings ) {
 843          *          if ( $('#test').val() == 1 ) {
 844          *            return false;
 845          *          }
 846          *        }
 847          *      } );
 848          *    } );
 849          */
 850         "fnPreDrawCallback": null,
 851
 852
 853         /**
 854          * This function allows you to 'post process' each row after it have been
 855          * generated for each table draw, but before it is rendered on screen. This
 856          * function might be used for setting the row class name etc.
 857          *  @type function
 858          *  @param {node} nRow "TR" element for the current row
 859          *  @param {array} aData Raw data array for this row
 860          *  @param {int} iDisplayIndex The display index for the current table draw
 861          *  @param {int} iDisplayIndexFull The index of the data in the full list of
 862          *    rows (after filtering)
 863          *  @dtopt Callbacks
 864          *
 865          *  @example
 866          *    $(document).ready( function() {
 867          *      $('#example').dataTable( {
 868          *        "fnRowCallback": function( nRow, aData, iDisplayIndex, iDisplayIndexFull ) {
 869          *          // Bold the grade for all 'A' grade browsers
 870          *          if ( aData[4] == "A" )
 871          *          {
 872          *            $('td:eq(4)', nRow).html( '<b>A</b>' );
 873          *          }
 874          *        }
 875          *      } );
 876          *    } );
 877          */
 878         "fnRowCallback": null,
 879
 880
 881         /**
 882          * This parameter allows you to override the default function which obtains
 883          * the data from the server ($.getJSON) so something more suitable for your
 884          * application. For example you could use POST data, or pull information from
 885          * a Gears or AIR database.
 886          *  @type function
 887          *  @member
 888          *  @param {string} sSource HTTP source to obtain the data from (sAjaxSource)
 889          *  @param {array} aoData A key/value pair object containing the data to send
 890          *    to the server
 891          *  @param {function} fnCallback to be called on completion of the data get
 892          *    process that will draw the data on the page.
 893          *  @param {object} oSettings DataTables settings object
 894          *  @dtopt Callbacks
 895          *  @dtopt Server-side
 896          *
 897          *  @example
 898          *    // POST data to server
 899          *    $(document).ready( function() {
 900          *      $('#example').dataTable( {
 901          *        "bProcessing": true,
 902          *        "bServerSide": true,
 903          *        "sAjaxSource": "xhr.php",
 904          *        "fnServerData": function ( sSource, aoData, fnCallback, oSettings ) {
 905          *          oSettings.jqXHR = $.ajax( {
 906          *            "dataType": 'json',
 907          *            "type": "POST",
 908          *            "url": sSource,
 909          *            "data": aoData,
 910          *            "success": fnCallback
 911          *          } );
 912          *        }
 913          *      } );
 914          *    } );
 915          */
 916         "fnServerData": function ( sUrl, aoData, fnCallback, oSettings ) {
 917                 oSettings.jqXHR = $.ajax( {
 918                         "url":  sUrl,
 919                         "data": aoData,
 920                         "success": function (json) {
 921                                 if ( json.sError ) {
 922                                         oSettings.oApi._fnLog( oSettings, 0, json.sError );
 923                                 }
 924
 925                                 $(oSettings.oInstance).trigger('xhr', [oSettings, json]);
 926                                 fnCallback( json );
 927                         },
 928                         "dataType": "json",
 929                         "cache": false,
 930                         "type": oSettings.sServerMethod,
 931                         "error": function (xhr, error, thrown) {
 932                                 if ( error == "parsererror" ) {
 933                                         oSettings.oApi._fnLog( oSettings, 0, "DataTables warning: JSON data from "+
 934                                                 "server could not be parsed. This is caused by a JSON formatting error." );
 935                                 }
 936                         }
 937                 } );
 938         },
 939
 940
 941         /**
 942          * It is often useful to send extra data to the server when making an Ajax
 943          * request - for example custom filtering information, and this callback
 944          * function makes it trivial to send extra information to the server. The
 945          * passed in parameter is the data set that has been constructed by
 946          * DataTables, and you can add to this or modify it as you require.
 947          *  @type function
 948          *  @param {array} aoData Data array (array of objects which are name/value
 949          *    pairs) that has been constructed by DataTables and will be sent to the
 950          *    server. In the case of Ajax sourced data with server-side processing
 951          *    this will be an empty array, for server-side processing there will be a
 952          *    significant number of parameters!
 953          *  @returns {undefined} Ensure that you modify the aoData array passed in,
 954          *    as this is passed by reference.
 955          *  @dtopt Callbacks
 956          *  @dtopt Server-side
 957          *
 958          *  @example
 959          *    $(document).ready( function() {
 960          *      $('#example').dataTable( {
 961          *        "bProcessing": true,
 962          *        "bServerSide": true,
 963          *        "sAjaxSource": "scripts/server_processing.php",
 964          *        "fnServerParams": function ( aoData ) {
 965          *          aoData.push( { "name": "more_data", "value": "my_value" } );
 966          *        }
 967          *      } );
 968          *    } );
 969          */
 970         "fnServerParams": null,
 971
 972
 973         /**
 974          * Load the table state. With this function you can define from where, and how, the
 975          * state of a table is loaded. By default DataTables will load from its state saving
 976          * cookie, but you might wish to use local storage (HTML5) or a server-side database.
 977          *  @type function
 978          *  @member
 979          *  @param {object} oSettings DataTables settings object
 980          *  @return {object} The DataTables state object to be loaded
 981          *  @dtopt Callbacks
 982          *
 983          *  @example
 984          *    $(document).ready( function() {
 985          *      $('#example').dataTable( {
 986          *        "bStateSave": true,
 987          *        "fnStateLoad": function (oSettings) {
 988          *          var o;
 989          *
 990          *          // Send an Ajax request to the server to get the data. Note that
 991          *          // this is a synchronous request.
 992          *          $.ajax( {
 993          *            "url": "/state_load",
 994          *            "async": false,
 995          *            "dataType": "json",
 996          *            "success": function (json) {
 997          *              o = json;
 998          *            }
 999          *          } );
1000          *
1001          *          return o;
1002          *        }
1003          *      } );
1004          *    } );
1005          */
1006         "fnStateLoad": function ( oSettings ) {
1007                 var sData = this.oApi._fnReadCookie( oSettings.sCookiePrefix+oSettings.sInstance );
1008                 var oData;
1009
1010                 try {
1011                         oData = (typeof $.parseJSON === 'function') ?
1012                                 $.parseJSON(sData) : eval( '('+sData+')' );
1013                 } catch (e) {
1014                         oData = null;
1015                 }
1016
1017                 return oData;
1018         },
1019
1020
1021         /**
1022          * Callback which allows modification of the saved state prior to loading that state.
1023          * This callback is called when the table is loading state from the stored data, but
1024          * prior to the settings object being modified by the saved state. Note that for
1025          * plug-in authors, you should use the 'stateLoadParams' event to load parameters for
1026          * a plug-in.
1027          *  @type function
1028          *  @param {object} oSettings DataTables settings object
1029          *  @param {object} oData The state object that is to be loaded
1030          *  @dtopt Callbacks
1031          *
1032          *  @example
1033          *    // Remove a saved filter, so filtering is never loaded
1034          *    $(document).ready( function() {
1035          *      $('#example').dataTable( {
1036          *        "bStateSave": true,
1037          *        "fnStateLoadParams": function (oSettings, oData) {
1038          *          oData.oSearch.sSearch = "";
1039          *        }
1040          *      } );
1041          *    } );
1042          *
1043          *  @example
1044          *    // Disallow state loading by returning false
1045          *    $(document).ready( function() {
1046          *      $('#example').dataTable( {
1047          *        "bStateSave": true,
1048          *        "fnStateLoadParams": function (oSettings, oData) {
1049          *          return false;
1050          *        }
1051          *      } );
1052          *    } );
1053          */
1054         "fnStateLoadParams": null,
1055
1056
1057         /**
1058          * Callback that is called when the state has been loaded from the state saving method
1059          * and the DataTables settings object has been modified as a result of the loaded state.
1060          *  @type function
1061          *  @param {object} oSettings DataTables settings object
1062          *  @param {object} oData The state object that was loaded
1063          *  @dtopt Callbacks
1064          *
1065          *  @example
1066          *    // Show an alert with the filtering value that was saved
1067          *    $(document).ready( function() {
1068          *      $('#example').dataTable( {
1069          *        "bStateSave": true,
1070          *        "fnStateLoaded": function (oSettings, oData) {
1071          *          alert( 'Saved filter was: '+oData.oSearch.sSearch );
1072          *        }
1073          *      } );
1074          *    } );
1075          */
1076         "fnStateLoaded": null,
1077
1078
1079         /**
1080          * Save the table state. This function allows you to define where and how the state
1081          * information for the table is stored - by default it will use a cookie, but you
1082          * might want to use local storage (HTML5) or a server-side database.
1083          *  @type function
1084          *  @member
1085          *  @param {object} oSettings DataTables settings object
1086          *  @param {object} oData The state object to be saved
1087          *  @dtopt Callbacks
1088          *
1089          *  @example
1090          *    $(document).ready( function() {
1091          *      $('#example').dataTable( {
1092          *        "bStateSave": true,
1093          *        "fnStateSave": function (oSettings, oData) {
1094          *          // Send an Ajax request to the server with the state object
1095          *          $.ajax( {
1096          *            "url": "/state_save",
1097          *            "data": oData,
1098          *            "dataType": "json",
1099          *            "method": "POST"
1100          *            "success": function () {}
1101          *          } );
1102          *        }
1103          *      } );
1104          *    } );
1105          */
1106         "fnStateSave": function ( oSettings, oData ) {
1107                 this.oApi._fnCreateCookie(
1108                         oSettings.sCookiePrefix+oSettings.sInstance,
1109                         this.oApi._fnJsonString(oData),
1110                         oSettings.iCookieDuration,
1111                         oSettings.sCookiePrefix,
1112                         oSettings.fnCookieCallback
1113                 );
1114         },
1115
1116
1117         /**
1118          * Callback which allows modification of the state to be saved. Called when the table
1119          * has changed state a new state save is required. This method allows modification of
1120          * the state saving object prior to actually doing the save, including addition or
1121          * other state properties or modification. Note that for plug-in authors, you should
1122          * use the 'stateSaveParams' event to save parameters for a plug-in.
1123          *  @type function
1124          *  @param {object} oSettings DataTables settings object
1125          *  @param {object} oData The state object to be saved
1126          *  @dtopt Callbacks
1127          *
1128          *  @example
1129          *    // Remove a saved filter, so filtering is never saved
1130          *    $(document).ready( function() {
1131          *      $('#example').dataTable( {
1132          *        "bStateSave": true,
1133          *        "fnStateSaveParams": function (oSettings, oData) {
1134          *          oData.oSearch.sSearch = "";
1135          *        }
1136          *      } );
1137          *    } );
1138          */
1139         "fnStateSaveParams": null,
1140
1141
1142         /**
1143          * Duration of the cookie which is used for storing session information. This
1144          * value is given in seconds.
1145          *  @type int
1146          *  @default 7200 <i>(2 hours)</i>
1147          *  @dtopt Options
1148          *
1149          *  @example
1150          *    $(document).ready( function() {
1151          *      $('#example').dataTable( {
1152          *        "iCookieDuration": 60*60*24; // 1 day
1153          *      } );
1154          *    } )
1155          */
1156         "iCookieDuration": 7200,
1157
1158
1159         /**
1160          * When enabled DataTables will not make a request to the server for the first
1161          * page draw - rather it will use the data already on the page (no sorting etc
1162          * will be applied to it), thus saving on an XHR at load time. iDeferLoading
1163          * is used to indicate that deferred loading is required, but it is also used
1164          * to tell DataTables how many records there are in the full table (allowing
1165          * the information element and pagination to be displayed correctly). In the case
1166          * where a filtering is applied to the table on initial load, this can be
1167          * indicated by giving the parameter as an array, where the first element is
1168          * the number of records available after filtering and the second element is the
1169          * number of records without filtering (allowing the table information element
1170          * to be shown correctly).
1171          *  @type int | array
1172          *  @default null
1173          *  @dtopt Options
1174          *
1175          *  @example
1176          *    // 57 records available in the table, no filtering applied
1177          *    $(document).ready( function() {
1178          *      $('#example').dataTable( {
1179          *        "bServerSide": true,
1180          *        "sAjaxSource": "scripts/server_processing.php",
1181          *        "iDeferLoading": 57
1182          *      } );
1183          *    } );
1184          *
1185          *  @example
1186          *    // 57 records after filtering, 100 without filtering (an initial filter applied)
1187          *    $(document).ready( function() {
1188          *      $('#example').dataTable( {
1189          *        "bServerSide": true,
1190          *        "sAjaxSource": "scripts/server_processing.php",
1191          *        "iDeferLoading": [ 57, 100 ],
1192          *        "oSearch": {
1193          *          "sSearch": "my_filter"
1194          *        }
1195          *      } );
1196          *    } );
1197          */
1198         "iDeferLoading": null,
1199
1200
1201         /**
1202          * Number of rows to display on a single page when using pagination. If
1203          * feature enabled (bLengthChange) then the end user will be able to override
1204          * this to a custom setting using a pop-up menu.
1205          *  @type int
1206          *  @default 10
1207          *  @dtopt Options
1208          *
1209          *  @example
1210          *    $(document).ready( function() {
1211          *      $('#example').dataTable( {
1212          *        "iDisplayLength": 50
1213          *      } );
1214          *    } )
1215          */
1216         "iDisplayLength": 10,
1217
1218
1219         /**
1220          * Define the starting point for data display when using DataTables with
1221          * pagination. Note that this parameter is the number of records, rather than
1222          * the page number, so if you have 10 records per page and want to start on
1223          * the third page, it should be "20".
1224          *  @type int
1225          *  @default 0
1226          *  @dtopt Options
1227          *
1228          *  @example
1229          *    $(document).ready( function() {
1230          *      $('#example').dataTable( {
1231          *        "iDisplayStart": 20
1232          *      } );
1233          *    } )
1234          */
1235         "iDisplayStart": 0,
1236
1237
1238         /**
1239          * The scroll gap is the amount of scrolling that is left to go before
1240          * DataTables will load the next 'page' of data automatically. You typically
1241          * want a gap which is big enough that the scrolling will be smooth for the
1242          * user, while not so large that it will load more data than need.
1243          *  @type int
1244          *  @default 100
1245          *  @dtopt Options
1246          *
1247          *  @example
1248          *    $(document).ready( function() {
1249          *      $('#example').dataTable( {
1250          *        "bScrollInfinite": true,
1251          *        "bScrollCollapse": true,
1252          *        "sScrollY": "200px",
1253          *        "iScrollLoadGap": 50
1254          *      } );
1255          *    } );
1256          */
1257         "iScrollLoadGap": 100,
1258
1259
1260         /**
1261          * By default DataTables allows keyboard navigation of the table (sorting, paging,
1262          * and filtering) by adding a tabindex attribute to the required elements. This
1263          * allows you to tab through the controls and press the enter key to activate them.
1264          * The tabindex is default 0, meaning that the tab follows the flow of the document.
1265          * You can overrule this using this parameter if you wish. Use a value of -1 to
1266          * disable built-in keyboard navigation.
1267          *  @type int
1268          *  @default 0
1269          *  @dtopt Options
1270          *
1271          *  @example
1272          *    $(document).ready( function() {
1273          *      $('#example').dataTable( {
1274          *        "iTabIndex": 1
1275          *      } );
1276          *    } );
1277          */
1278         "iTabIndex": 0,
1279
1280
1281         /**
1282          * All strings that DataTables uses in the user interface that it creates
1283          * are defined in this object, allowing you to modified them individually or
1284          * completely replace them all as required.
1285          *  @namespace
1286          */
1287         "oLanguage": {
1288                 /**
1289                  * Strings that are used for WAI-ARIA labels and controls only (these are not
1290                  * actually visible on the page, but will be read by screenreaders, and thus
1291                  * must be internationalised as well).
1292                  *  @namespace
1293                  */
1294                 "oAria": {
1295                         /**
1296                          * ARIA label that is added to the table headers when the column may be
1297                          * sorted ascending by activing the column (click or return when focused).
1298                          * Note that the column header is prefixed to this string.
1299                          *  @type string
1300                          *  @default : activate to sort column ascending
1301                          *  @dtopt Language
1302                          *
1303                          *  @example
1304                          *    $(document).ready( function() {
1305                          *      $('#example').dataTable( {
1306                          *        "oLanguage": {
1307                          *          "oAria": {
1308                          *            "sSortAscending": " - click/return to sort ascending"
1309                          *          }
1310                          *        }
1311                          *      } );
1312                          *    } );
1313                          */
1314                         "sSortAscending": ": activate to sort column ascending",
1315
1316                         /**
1317                          * ARIA label that is added to the table headers when the column may be
1318                          * sorted descending by activing the column (click or return when focused).
1319                          * Note that the column header is prefixed to this string.
1320                          *  @type string
1321                          *  @default : activate to sort column ascending
1322                          *  @dtopt Language
1323                          *
1324                          *  @example
1325                          *    $(document).ready( function() {
1326                          *      $('#example').dataTable( {
1327                          *        "oLanguage": {
1328                          *          "oAria": {
1329                          *            "sSortDescending": " - click/return to sort descending"
1330                          *          }
1331                          *        }
1332                          *      } );
1333                          *    } );
1334                          */
1335                         "sSortDescending": ": activate to sort column descending"
1336                 },
1337
1338                 /**
1339                  * Pagination string used by DataTables for the two built-in pagination
1340                  * control types ("two_button" and "full_numbers")
1341                  *  @namespace
1342                  */
1343                 "oPaginate": {
1344                         /**
1345                          * Text to use when using the 'full_numbers' type of pagination for the
1346                          * button to take the user to the first page.
1347                          *  @type string
1348                          *  @default First
1349                          *  @dtopt Language
1350                          *
1351                          *  @example
1352                          *    $(document).ready( function() {
1353                          *      $('#example').dataTable( {
1354                          *        "oLanguage": {
1355                          *          "oPaginate": {
1356                          *            "sFirst": "First page"
1357                          *          }
1358                          *        }
1359                          *      } );
1360                          *    } );
1361                          */
1362                         "sFirst": "First",
1363
1364
1365                         /**
1366                          * Text to use when using the 'full_numbers' type of pagination for the
1367                          * button to take the user to the last page.
1368                          *  @type string
1369                          *  @default Last
1370                          *  @dtopt Language
1371                          *
1372                          *  @example
1373                          *    $(document).ready( function() {
1374                          *      $('#example').dataTable( {
1375                          *        "oLanguage": {
1376                          *          "oPaginate": {
1377                          *            "sLast": "Last page"
1378                          *          }
1379                          *        }
1380                          *      } );
1381                          *    } );
1382                          */
1383                         "sLast": "Last",
1384
1385
1386                         /**
1387                          * Text to use for the 'next' pagination button (to take the user to the
1388                          * next page).
1389                          *  @type string
1390                          *  @default Next
1391                          *  @dtopt Language
1392                          *
1393                          *  @example
1394                          *    $(document).ready( function() {
1395                          *      $('#example').dataTable( {
1396                          *        "oLanguage": {
1397                          *          "oPaginate": {
1398                          *            "sNext": "Next page"
1399                          *          }
1400                          *        }
1401                          *      } );
1402                          *    } );
1403                          */
1404                         "sNext": "Next",
1405
1406
1407                         /**
1408                          * Text to use for the 'previous' pagination button (to take the user to
1409                          * the previous page).
1410                          *  @type string
1411                          *  @default Previous
1412                          *  @dtopt Language
1413                          *
1414                          *  @example
1415                          *    $(document).ready( function() {
1416                          *      $('#example').dataTable( {
1417                          *        "oLanguage": {
1418                          *          "oPaginate": {
1419                          *            "sPrevious": "Previous page"
1420                          *          }
1421                          *        }
1422                          *      } );
1423                          *    } );
1424                          */
1425                         "sPrevious": "Previous"
1426                 },
1427
1428                 /**
1429                  * This string is shown in preference to sZeroRecords when the table is
1430                  * empty of data (regardless of filtering). Note that this is an optional
1431                  * parameter - if it is not given, the value of sZeroRecords will be used
1432                  * instead (either the default or given value).
1433                  *  @type string
1434                  *  @default No data available in table
1435                  *  @dtopt Language
1436                  *
1437                  *  @example
1438                  *    $(document).ready( function() {
1439                  *      $('#example').dataTable( {
1440                  *        "oLanguage": {
1441                  *          "sEmptyTable": "No data available in table"
1442                  *        }
1443                  *      } );
1444                  *    } );
1445                  */
1446                 "sEmptyTable": "No data available in table",
1447
1448
1449                 /**
1450                  * This string gives information to the end user about the information that
1451                  * is current on display on the page. The _START_, _END_ and _TOTAL_
1452                  * variables are all dynamically replaced as the table display updates, and
1453                  * can be freely moved or removed as the language requirements change.
1454                  *  @type string
1455                  *  @default Showing _START_ to _END_ of _TOTAL_ entries
1456                  *  @dtopt Language
1457                  *
1458                  *  @example
1459                  *    $(document).ready( function() {
1460                  *      $('#example').dataTable( {
1461                  *        "oLanguage": {
1462                  *          "sInfo": "Got a total of _TOTAL_ entries to show (_START_ to _END_)"
1463                  *        }
1464                  *      } );
1465                  *    } );
1466                  */
1467                 "sInfo": "Showing _START_ to _END_ of _TOTAL_ entries",
1468
1469
1470                 /**
1471                  * Display information string for when the table is empty. Typically the
1472                  * format of this string should match sInfo.
1473                  *  @type string
1474                  *  @default Showing 0 to 0 of 0 entries
1475                  *  @dtopt Language
1476                  *
1477                  *  @example
1478                  *    $(document).ready( function() {
1479                  *      $('#example').dataTable( {
1480                  *        "oLanguage": {
1481                  *          "sInfoEmpty": "No entries to show"
1482                  *        }
1483                  *      } );
1484                  *    } );
1485                  */
1486                 "sInfoEmpty": "Showing 0 to 0 of 0 entries",
1487
1488
1489                 /**
1490                  * When a user filters the information in a table, this string is appended
1491                  * to the information (sInfo) to give an idea of how strong the filtering
1492                  * is. The variable _MAX_ is dynamically updated.
1493                  *  @type string
1494                  *  @default (filtered from _MAX_ total entries)
1495                  *  @dtopt Language
1496                  *
1497                  *  @example
1498                  *    $(document).ready( function() {
1499                  *      $('#example').dataTable( {
1500                  *        "oLanguage": {
1501                  *          "sInfoFiltered": " - filtering from _MAX_ records"
1502                  *        }
1503                  *      } );
1504                  *    } );
1505                  */
1506                 "sInfoFiltered": "(filtered from _MAX_ total entries)",
1507
1508
1509                 /**
1510                  * If can be useful to append extra information to the info string at times,
1511                  * and this variable does exactly that. This information will be appended to
1512                  * the sInfo (sInfoEmpty and sInfoFiltered in whatever combination they are
1513                  * being used) at all times.
1514                  *  @type string
1515                  *  @default <i>Empty string</i>
1516                  *  @dtopt Language
1517                  *
1518                  *  @example
1519                  *    $(document).ready( function() {
1520                  *      $('#example').dataTable( {
1521                  *        "oLanguage": {
1522                  *          "sInfoPostFix": "All records shown are derived from real information."
1523                  *        }
1524                  *      } );
1525                  *    } );
1526                  */
1527                 "sInfoPostFix": "",
1528
1529
1530                 /**
1531                  * DataTables has a build in number formatter (fnFormatNumber) which is used
1532                  * to format large numbers that are used in the table information. By
1533                  * default a comma is used, but this can be trivially changed to any
1534                  * character you wish with this parameter.
1535                  *  @type string
1536                  *  @default ,
1537                  *  @dtopt Language
1538                  *
1539                  *  @example
1540                  *    $(document).ready( function() {
1541                  *      $('#example').dataTable( {
1542                  *        "oLanguage": {
1543                  *          "sInfoThousands": "'"
1544                  *        }
1545                  *      } );
1546                  *    } );
1547                  */
1548                 "sInfoThousands": ",",
1549
1550
1551                 /**
1552                  * Detail the action that will be taken when the drop down menu for the
1553                  * pagination length option is changed. The '_MENU_' variable is replaced
1554                  * with a default select list of 10, 25, 50 and 100, and can be replaced
1555                  * with a custom select box if required.
1556                  *  @type string
1557                  *  @default Show _MENU_ entries
1558                  *  @dtopt Language
1559                  *
1560                  *  @example
1561                  *    // Language change only
1562                  *    $(document).ready( function() {
1563                  *      $('#example').dataTable( {
1564                  *        "oLanguage": {
1565                  *          "sLengthMenu": "Display _MENU_ records"
1566                  *        }
1567                  *      } );
1568                  *    } );
1569                  *
1570                  *  @example
1571                  *    // Language and options change
1572                  *    $(document).ready( function() {
1573                  *      $('#example').dataTable( {
1574                  *        "oLanguage": {
1575                  *          "sLengthMenu": 'Display <select>'+
1576                  *            '<option value="10">10</option>'+
1577                  *            '<option value="20">20</option>'+
1578                  *            '<option value="30">30</option>'+
1579                  *            '<option value="40">40</option>'+
1580                  *            '<option value="50">50</option>'+
1581                  *            '<option value="-1">All</option>'+
1582                  *            '</select> records'
1583                  *        }
1584                  *      } );
1585                  *    } );
1586                  */
1587                 "sLengthMenu": "Show _MENU_ entries",
1588
1589
1590                 /**
1591                  * When using Ajax sourced data and during the first draw when DataTables is
1592                  * gathering the data, this message is shown in an empty row in the table to
1593                  * indicate to the end user the the data is being loaded. Note that this
1594                  * parameter is not used when loading data by server-side processing, just
1595                  * Ajax sourced data with client-side processing.
1596                  *  @type string
1597                  *  @default Loading...
1598                  *  @dtopt Language
1599                  *
1600                  *  @example
1601                  *    $(document).ready( function() {
1602                  *      $('#example').dataTable( {
1603                  *        "oLanguage": {
1604                  *          "sLoadingRecords": "Please wait - loading..."
1605                  *        }
1606                  *      } );
1607                  *    } );
1608                  */
1609                 "sLoadingRecords": "Loading...",
1610
1611
1612                 /**
1613                  * Text which is displayed when the table is processing a user action
1614                  * (usually a sort command or similar).
1615                  *  @type string
1616                  *  @default Processing...
1617                  *  @dtopt Language
1618                  *
1619                  *  @example
1620                  *    $(document).ready( function() {
1621                  *      $('#example').dataTable( {
1622                  *        "oLanguage": {
1623                  *          "sProcessing": "DataTables is currently busy"
1624                  *        }
1625                  *      } );
1626                  *    } );
1627                  */
1628                 "sProcessing": "Processing...",
1629
1630
1631                 /**
1632                  * Details the actions that will be taken when the user types into the
1633                  * filtering input text box. The variable "_INPUT_", if used in the string,
1634                  * is replaced with the HTML text box for the filtering input allowing
1635                  * control over where it appears in the string. If "_INPUT_" is not given
1636                  * then the input box is appended to the string automatically.
1637                  *  @type string
1638                  *  @default Search:
1639                  *  @dtopt Language
1640                  *
1641                  *  @example
1642                  *    // Input text box will be appended at the end automatically
1643                  *    $(document).ready( function() {
1644                  *      $('#example').dataTable( {
1645                  *        "oLanguage": {
1646                  *          "sSearch": "Filter records:"
1647                  *        }
1648                  *      } );
1649                  *    } );
1650                  *
1651                  *  @example
1652                  *    // Specify where the filter should appear
1653                  *    $(document).ready( function() {
1654                  *      $('#example').dataTable( {
1655                  *        "oLanguage": {
1656                  *          "sSearch": "Apply filter _INPUT_ to table"
1657                  *        }
1658                  *      } );
1659                  *    } );
1660                  */
1661                 "sSearch": "Search:",
1662
1663
1664                 /**
1665                  * All of the language information can be stored in a file on the
1666                  * server-side, which DataTables will look up if this parameter is passed.
1667                  * It must store the URL of the language file, which is in a JSON format,
1668                  * and the object has the same properties as the oLanguage object in the
1669                  * initialiser object (i.e. the above parameters). Please refer to one of
1670                  * the example language files to see how this works in action.
1671                  *  @type string
1672                  *  @default <i>Empty string - i.e. disabled</i>
1673                  *  @dtopt Language
1674                  *
1675                  *  @example
1676                  *    $(document).ready( function() {
1677                  *      $('#example').dataTable( {
1678                  *        "oLanguage": {
1679                  *          "sUrl": "http://www.sprymedia.co.uk/dataTables/lang.txt"
1680                  *        }
1681                  *      } );
1682                  *    } );
1683                  */
1684                 "sUrl": "",
1685
1686
1687                 /**
1688                  * Text shown inside the table records when the is no information to be
1689                  * displayed after filtering. sEmptyTable is shown when there is simply no
1690                  * information in the table at all (regardless of filtering).
1691                  *  @type string
1692                  *  @default No matching records found
1693                  *  @dtopt Language
1694                  *
1695                  *  @example
1696                  *    $(document).ready( function() {
1697                  *      $('#example').dataTable( {
1698                  *        "oLanguage": {
1699                  *          "sZeroRecords": "No records to display"
1700                  *        }
1701                  *      } );
1702                  *    } );
1703                  */
1704                 "sZeroRecords": "No matching records found"
1705         },
1706
1707
1708         /**
1709          * This parameter allows you to have define the global filtering state at
1710          * initialisation time. As an object the "sSearch" parameter must be
1711          * defined, but all other parameters are optional. When "bRegex" is true,
1712          * the search string will be treated as a regular expression, when false
1713          * (default) it will be treated as a straight string. When "bSmart"
1714          * DataTables will use it's smart filtering methods (to word match at
1715          * any point in the data), when false this will not be done.
1716          *  @namespace
1717          *  @extends DataTable.models.oSearch
1718          *  @dtopt Options
1719          *
1720          *  @example
1721          *    $(document).ready( function() {
1722          *      $('#example').dataTable( {
1723          *        "oSearch": {"sSearch": "Initial search"}
1724          *      } );
1725          *    } )
1726          */
1727         "oSearch": $.extend( {}, DataTable.models.oSearch ),
1728
1729
1730         /**
1731          * By default DataTables will look for the property 'aaData' when obtaining
1732          * data from an Ajax source or for server-side processing - this parameter
1733          * allows that property to be changed. You can use Javascript dotted object
1734          * notation to get a data source for multiple levels of nesting.
1735          *  @type string
1736          *  @default aaData
1737          *  @dtopt Options
1738          *  @dtopt Server-side
1739          *
1740          *  @example
1741          *    // Get data from { "data": [...] }
1742          *    $(document).ready( function() {
1743          *      var oTable = $('#example').dataTable( {
1744          *        "sAjaxSource": "sources/data.txt",
1745          *        "sAjaxDataProp": "data"
1746          *      } );
1747          *    } );
1748          *
1749          *  @example
1750          *    // Get data from { "data": { "inner": [...] } }
1751          *    $(document).ready( function() {
1752          *      var oTable = $('#example').dataTable( {
1753          *        "sAjaxSource": "sources/data.txt",
1754          *        "sAjaxDataProp": "data.inner"
1755          *      } );
1756          *    } );
1757          */
1758         "sAjaxDataProp": "aaData",
1759
1760
1761         /**
1762          * You can instruct DataTables to load data from an external source using this
1763          * parameter (use aData if you want to pass data in you already have). Simply
1764          * provide a url a JSON object can be obtained from. This object must include
1765          * the parameter 'aaData' which is the data source for the table.
1766          *  @type string
1767          *  @default null
1768          *  @dtopt Options
1769          *  @dtopt Server-side
1770          *
1771          *  @example
1772          *    $(document).ready( function() {
1773          *      $('#example').dataTable( {
1774          *        "sAjaxSource": "http://www.sprymedia.co.uk/dataTables/json.php"
1775          *      } );
1776          *    } )
1777          */
1778         "sAjaxSource": null,
1779
1780
1781         /**
1782          * This parameter can be used to override the default prefix that DataTables
1783          * assigns to a cookie when state saving is enabled.
1784          *  @type string
1785          *  @default SpryMedia_DataTables_
1786          *  @dtopt Options
1787          *
1788          *  @example
1789          *    $(document).ready( function() {
1790          *      $('#example').dataTable( {
1791          *        "sCookiePrefix": "my_datatable_",
1792          *      } );
1793          *    } );
1794          */
1795         "sCookiePrefix": "SpryMedia_DataTables_",
1796
1797
1798         /**
1799          * This initialisation variable allows you to specify exactly where in the
1800          * DOM you want DataTables to inject the various controls it adds to the page
1801          * (for example you might want the pagination controls at the top of the
1802          * table). DIV elements (with or without a custom class) can also be added to
1803          * aid styling. The follow syntax is used:
1804          *   <ul>
1805          *     <li>The following options are allowed:
1806          *       <ul>
1807          *         <li>'l' - Length changing</li
1808          *         <li>'f' - Filtering input</li>
1809          *         <li>'t' - The table!</li>
1810          *         <li>'i' - Information</li>
1811          *         <li>'p' - Pagination</li>
1812          *         <li>'r' - pRocessing</li>
1813          *       </ul>
1814          *     </li>
1815          *     <li>The following constants are allowed:
1816          *       <ul>
1817          *         <li>'H' - jQueryUI theme "header" classes ('fg-toolbar ui-widget-header ui-corner-tl ui-corner-tr ui-helper-clearfix')</li>
1818          *         <li>'F' - jQueryUI theme "footer" classes ('fg-toolbar ui-widget-header ui-corner-bl ui-corner-br ui-helper-clearfix')</li>
1819          *       </ul>
1820          *     </li>
1821          *     <li>The following syntax is expected:
1822          *       <ul>
1823          *         <li>'&lt;' and '&gt;' - div elements</li>
1824          *         <li>'&lt;"class" and '&gt;' - div with a class</li>
1825          *         <li>'&lt;"#id" and '&gt;' - div with an ID</li>
1826          *       </ul>
1827          *     </li>
1828          *     <li>Examples:
1829          *       <ul>
1830          *         <li>'&lt;"wrapper"flipt&gt;'</li>
1831          *         <li>'&lt;lf&lt;t&gt;ip&gt;'</li>
1832          *       </ul>
1833          *     </li>
1834          *   </ul>
1835          *  @type string
1836          *  @default lfrtip <i>(when bJQueryUI is false)</i> <b>or</b>
1837          *    <"H"lfr>t<"F"ip> <i>(when bJQueryUI is true)</i>
1838          *  @dtopt Options
1839          *
1840          *  @example
1841          *    $(document).ready( function() {
1842          *      $('#example').dataTable( {
1843          *        "sDom": '&lt;"top"i&gt;rt&lt;"bottom"flp&gt;&lt;"clear"&gt;'
1844          *      } );
1845          *    } );
1846          */
1847         "sDom": "lfrtip",
1848
1849
1850         /**
1851          * DataTables features two different built-in pagination interaction methods
1852          * ('two_button' or 'full_numbers') which present different page controls to
1853          * the end user. Further methods can be added using the API (see below).
1854          *  @type string
1855          *  @default two_button
1856          *  @dtopt Options
1857          *
1858          *  @example
1859          *    $(document).ready( function() {
1860          *      $('#example').dataTable( {
1861          *        "sPaginationType": "full_numbers"
1862          *      } );
1863          *    } )
1864          */
1865         "sPaginationType": "two_button",
1866
1867
1868         /**
1869          * Enable horizontal scrolling. When a table is too wide to fit into a certain
1870          * layout, or you have a large number of columns in the table, you can enable
1871          * x-scrolling to show the table in a viewport, which can be scrolled. This
1872          * property can be any CSS unit, or a number (in which case it will be treated
1873          * as a pixel measurement).
1874          *  @type string
1875          *  @default <i>blank string - i.e. disabled</i>
1876          *  @dtopt Features
1877          *
1878          *  @example
1879          *    $(document).ready( function() {
1880          *      $('#example').dataTable( {
1881          *        "sScrollX": "100%",
1882          *        "bScrollCollapse": true
1883          *      } );
1884          *    } );
1885          */
1886         "sScrollX": "",
1887
1888
1889         /**
1890          * This property can be used to force a DataTable to use more width than it
1891          * might otherwise do when x-scrolling is enabled. For example if you have a
1892          * table which requires to be well spaced, this parameter is useful for
1893          * "over-sizing" the table, and thus forcing scrolling. This property can by
1894          * any CSS unit, or a number (in which case it will be treated as a pixel
1895          * measurement).
1896          *  @type string
1897          *  @default <i>blank string - i.e. disabled</i>
1898          *  @dtopt Options
1899          *
1900          *  @example
1901          *    $(document).ready( function() {
1902          *      $('#example').dataTable( {
1903          *        "sScrollX": "100%",
1904          *        "sScrollXInner": "110%"
1905          *      } );
1906          *    } );
1907          */
1908         "sScrollXInner": "",
1909
1910
1911         /**
1912          * Enable vertical scrolling. Vertical scrolling will constrain the DataTable
1913          * to the given height, and enable scrolling for any data which overflows the
1914          * current viewport. This can be used as an alternative to paging to display
1915          * a lot of data in a small area (although paging and scrolling can both be
1916          * enabled at the same time). This property can be any CSS unit, or a number
1917          * (in which case it will be treated as a pixel measurement).
1918          *  @type string
1919          *  @default <i>blank string - i.e. disabled</i>
1920          *  @dtopt Features
1921          *
1922          *  @example
1923          *    $(document).ready( function() {
1924          *      $('#example').dataTable( {
1925          *        "sScrollY": "200px",
1926          *        "bPaginate": false
1927          *      } );
1928          *    } );
1929          */
1930         "sScrollY": "",
1931
1932
1933         /**
1934          * Set the HTTP method that is used to make the Ajax call for server-side
1935          * processing or Ajax sourced data.
1936          *  @type string
1937          *  @default GET
1938          *  @dtopt Options
1939          *  @dtopt Server-side
1940          *
1941          *  @example
1942          *    $(document).ready( function() {
1943          *      $('#example').dataTable( {
1944          *        "bServerSide": true,
1945          *        "sAjaxSource": "scripts/post.php",
1946          *        "sServerMethod": "POST"
1947          *      } );
1948          *    } );
1949          */
1950         "sServerMethod": "GET"
1951 };
1952