src/ceph/src/pybind/mgr/dashboard/static/AdminLTE-2.3.7/plugins/datatables/extensions/FixedColumns/js/dataTables.fixedColumns.js

   1 /*! FixedColumns 3.0.4
   2  * ©2010-2014 SpryMedia Ltd - datatables.net/license
   3  */
   4
   5 /**
   6  * @summary     FixedColumns
   7  * @description Freeze columns in place on a scrolling DataTable
   8  * @version     3.0.4
   9  * @file        dataTables.fixedColumns.js
  10  * @author      SpryMedia Ltd (www.sprymedia.co.uk)
  11  * @contact     www.sprymedia.co.uk/contact
  12  * @copyright   Copyright 2010-2014 SpryMedia Ltd.
  13  *
  14  * This source file is free software, available under the following license:
  15  *   MIT license - http://datatables.net/license/mit
  16  *
  17  * This source file is distributed in the hope that it will be useful, but
  18  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  19  * or FITNESS FOR A PARTICULAR PURPOSE. See the license files for details.
  20  *
  21  * For details please refer to: http://www.datatables.net
  22  */
  23
  24
  25 (function(window, document, undefined) {
  26
  27
  28 var factory = function( $, DataTable ) {
  29 "use strict";
  30
  31 /**
  32  * When making use of DataTables' x-axis scrolling feature, you may wish to
  33  * fix the left most column in place. This plug-in for DataTables provides
  34  * exactly this option (note for non-scrolling tables, please use the
  35  * FixedHeader plug-in, which can fix headers, footers and columns). Key
  36  * features include:
  37  *
  38  * * Freezes the left or right most columns to the side of the table
  39  * * Option to freeze two or more columns
  40  * * Full integration with DataTables' scrolling options
  41  * * Speed - FixedColumns is fast in its operation
  42  *
  43  *  @class
  44  *  @constructor
  45  *  @global
  46  *  @param {object} dt DataTables instance. With DataTables 1.10 this can also
  47  *    be a jQuery collection, a jQuery selector, DataTables API instance or
  48  *    settings object.
  49  *  @param {object} [init={}] Configuration object for FixedColumns. Options are
  50  *    defined by {@link FixedColumns.defaults}
  51  *
  52  *  @requires jQuery 1.7+
  53  *  @requires DataTables 1.8.0+
  54  *
  55  *  @example
  56  *      var table = $('#example').dataTable( {
  57  *        "scrollX": "100%"
  58  *      } );
  59  *      new $.fn.dataTable.fixedColumns( table );
  60  */
  61 var FixedColumns = function ( dt, init ) {
  62         var that = this;
  63
  64         /* Sanity check - you just know it will happen */
  65         if ( ! ( this instanceof FixedColumns ) )
  66         {
  67                 alert( "FixedColumns warning: FixedColumns must be initialised with the 'new' keyword." );
  68                 return;
  69         }
  70
  71         if ( typeof init == 'undefined' )
  72         {
  73                 init = {};
  74         }
  75
  76         // Use the DataTables Hungarian notation mapping method, if it exists to
  77         // provide forwards compatibility for camel case variables
  78         var camelToHungarian = $.fn.dataTable.camelToHungarian;
  79         if ( camelToHungarian ) {
  80                 camelToHungarian( FixedColumns.defaults, FixedColumns.defaults, true );
  81                 camelToHungarian( FixedColumns.defaults, init );
  82         }
  83
  84         // v1.10 allows the settings object to be got form a number of sources
  85         var dtSettings = $.fn.dataTable.Api ?
  86                 new $.fn.dataTable.Api( dt ).settings()[0] :
  87                 dt.fnSettings();
  88
  89         /**
  90          * Settings object which contains customisable information for FixedColumns instance
  91          * @namespace
  92          * @extends FixedColumns.defaults
  93          * @private
  94          */
  95         this.s = {
  96                 /**
  97                  * DataTables settings objects
  98                  *  @type     object
  99                  *  @default  Obtained from DataTables instance
 100                  */
 101                 "dt": dtSettings,
 102
 103                 /**
 104                  * Number of columns in the DataTable - stored for quick access
 105                  *  @type     int
 106                  *  @default  Obtained from DataTables instance
 107                  */
 108                 "iTableColumns": dtSettings.aoColumns.length,
 109
 110                 /**
 111                  * Original outer widths of the columns as rendered by DataTables - used to calculate
 112                  * the FixedColumns grid bounding box
 113                  *  @type     array.<int>
 114                  *  @default  []
 115                  */
 116                 "aiOuterWidths": [],
 117
 118                 /**
 119                  * Original inner widths of the columns as rendered by DataTables - used to apply widths
 120                  * to the columns
 121                  *  @type     array.<int>
 122                  *  @default  []
 123                  */
 124                 "aiInnerWidths": []
 125         };
 126
 127
 128         /**
 129          * DOM elements used by the class instance
 130          * @namespace
 131          * @private
 132          *
 133          */
 134         this.dom = {
 135                 /**
 136                  * DataTables scrolling element
 137                  *  @type     node
 138                  *  @default  null
 139                  */
 140                 "scroller": null,
 141
 142                 /**
 143                  * DataTables header table
 144                  *  @type     node
 145                  *  @default  null
 146                  */
 147                 "header": null,
 148
 149                 /**
 150                  * DataTables body table
 151                  *  @type     node
 152                  *  @default  null
 153                  */
 154                 "body": null,
 155
 156                 /**
 157                  * DataTables footer table
 158                  *  @type     node
 159                  *  @default  null
 160                  */
 161                 "footer": null,
 162
 163                 /**
 164                  * Display grid elements
 165                  * @namespace
 166                  */
 167                 "grid": {
 168                         /**
 169                          * Grid wrapper. This is the container element for the 3x3 grid
 170                          *  @type     node
 171                          *  @default  null
 172                          */
 173                         "wrapper": null,
 174
 175                         /**
 176                          * DataTables scrolling element. This element is the DataTables
 177                          * component in the display grid (making up the main table - i.e.
 178                          * not the fixed columns).
 179                          *  @type     node
 180                          *  @default  null
 181                          */
 182                         "dt": null,
 183
 184                         /**
 185                          * Left fixed column grid components
 186                          * @namespace
 187                          */
 188                         "left": {
 189                                 "wrapper": null,
 190                                 "head": null,
 191                                 "body": null,
 192                                 "foot": null
 193                         },
 194
 195                         /**
 196                          * Right fixed column grid components
 197                          * @namespace
 198                          */
 199                         "right": {
 200                                 "wrapper": null,
 201                                 "head": null,
 202                                 "body": null,
 203                                 "foot": null
 204                         }
 205                 },
 206
 207                 /**
 208                  * Cloned table nodes
 209                  * @namespace
 210                  */
 211                 "clone": {
 212                         /**
 213                          * Left column cloned table nodes
 214                          * @namespace
 215                          */
 216                         "left": {
 217                                 /**
 218                                  * Cloned header table
 219                                  *  @type     node
 220                                  *  @default  null
 221                                  */
 222                                 "header": null,
 223
 224                                 /**
 225                                  * Cloned body table
 226                                  *  @type     node
 227                                  *  @default  null
 228                                  */
 229                                 "body": null,
 230
 231                                 /**
 232                                  * Cloned footer table
 233                                  *  @type     node
 234                                  *  @default  null
 235                                  */
 236                                 "footer": null
 237                         },
 238
 239                         /**
 240                          * Right column cloned table nodes
 241                          * @namespace
 242                          */
 243                         "right": {
 244                                 /**
 245                                  * Cloned header table
 246                                  *  @type     node
 247                                  *  @default  null
 248                                  */
 249                                 "header": null,
 250
 251                                 /**
 252                                  * Cloned body table
 253                                  *  @type     node
 254                                  *  @default  null
 255                                  */
 256                                 "body": null,
 257
 258                                 /**
 259                                  * Cloned footer table
 260                                  *  @type     node
 261                                  *  @default  null
 262                                  */
 263                                 "footer": null
 264                         }
 265                 }
 266         };
 267
 268         /* Attach the instance to the DataTables instance so it can be accessed easily */
 269         dtSettings._oFixedColumns = this;
 270
 271         /* Let's do it */
 272         if ( ! dtSettings._bInitComplete )
 273         {
 274                 dtSettings.oApi._fnCallbackReg( dtSettings, 'aoInitComplete', function () {
 275                         that._fnConstruct( init );
 276                 }, 'FixedColumns' );
 277         }
 278         else
 279         {
 280                 this._fnConstruct( init );
 281         }
 282 };
 283
 284
 285
 286 FixedColumns.prototype = /** @lends FixedColumns.prototype */{
 287         /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 288          * Public methods
 289          * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 290
 291         /**
 292          * Update the fixed columns - including headers and footers. Note that FixedColumns will
 293          * automatically update the display whenever the host DataTable redraws.
 294          *  @returns {void}
 295          *  @example
 296          *      var table = $('#example').dataTable( {
 297          *          "scrollX": "100%"
 298          *      } );
 299          *      var fc = new $.fn.dataTable.fixedColumns( table );
 300          *
 301          *      // at some later point when the table has been manipulated....
 302          *      fc.fnUpdate();
 303          */
 304         "fnUpdate": function ()
 305         {
 306                 this._fnDraw( true );
 307         },
 308
 309
 310         /**
 311          * Recalculate the resizes of the 3x3 grid that FixedColumns uses for display of the table.
 312          * This is useful if you update the width of the table container. Note that FixedColumns will
 313          * perform this function automatically when the window.resize event is fired.
 314          *  @returns {void}
 315          *  @example
 316          *      var table = $('#example').dataTable( {
 317          *          "scrollX": "100%"
 318          *      } );
 319          *      var fc = new $.fn.dataTable.fixedColumns( table );
 320          *
 321          *      // Resize the table container and then have FixedColumns adjust its layout....
 322          *      $('#content').width( 1200 );
 323          *      fc.fnRedrawLayout();
 324          */
 325         "fnRedrawLayout": function ()
 326         {
 327                 this._fnColCalc();
 328                 this._fnGridLayout();
 329                 this.fnUpdate();
 330         },
 331
 332
 333         /**
 334          * Mark a row such that it's height should be recalculated when using 'semiauto' row
 335          * height matching. This function will have no effect when 'none' or 'auto' row height
 336          * matching is used.
 337          *  @param   {Node} nTr TR element that should have it's height recalculated
 338          *  @returns {void}
 339          *  @example
 340          *      var table = $('#example').dataTable( {
 341          *          "scrollX": "100%"
 342          *      } );
 343          *      var fc = new $.fn.dataTable.fixedColumns( table );
 344          *
 345          *      // manipulate the table - mark the row as needing an update then update the table
 346          *      // this allows the redraw performed by DataTables fnUpdate to recalculate the row
 347          *      // height
 348          *      fc.fnRecalculateHeight();
 349          *      table.fnUpdate( $('#example tbody tr:eq(0)')[0], ["insert date", 1, 2, 3 ... ]);
 350          */
 351         "fnRecalculateHeight": function ( nTr )
 352         {
 353                 delete nTr._DTTC_iHeight;
 354                 nTr.style.height = 'auto';
 355         },
 356
 357
 358         /**
 359          * Set the height of a given row - provides cross browser compatibility
 360          *  @param   {Node} nTarget TR element that should have it's height recalculated
 361          *  @param   {int} iHeight Height in pixels to set
 362          *  @returns {void}
 363          *  @example
 364          *      var table = $('#example').dataTable( {
 365          *          "scrollX": "100%"
 366          *      } );
 367          *      var fc = new $.fn.dataTable.fixedColumns( table );
 368          *
 369          *      // You may want to do this after manipulating a row in the fixed column
 370          *      fc.fnSetRowHeight( $('#example tbody tr:eq(0)')[0], 50 );
 371          */
 372         "fnSetRowHeight": function ( nTarget, iHeight )
 373         {
 374                 nTarget.style.height = iHeight+"px";
 375         },
 376
 377
 378         /**
 379          * Get data index information about a row or cell in the table body.
 380          * This function is functionally identical to fnGetPosition in DataTables,
 381          * taking the same parameter (TH, TD or TR node) and returning exactly the
 382          * the same information (data index information). THe difference between
 383          * the two is that this method takes into account the fixed columns in the
 384          * table, so you can pass in nodes from the master table, or the cloned
 385          * tables and get the index position for the data in the main table.
 386          *  @param {node} node TR, TH or TD element to get the information about
 387          *  @returns {int} If nNode is given as a TR, then a single index is
 388          *    returned, or if given as a cell, an array of [row index, column index
 389          *    (visible), column index (all)] is given.
 390          */
 391         "fnGetPosition": function ( node )
 392         {
 393                 var idx;
 394                 var inst = this.s.dt.oInstance;
 395
 396                 if ( ! $(node).parents('.DTFC_Cloned').length )
 397                 {
 398                         // Not in a cloned table
 399                         return inst.fnGetPosition( node );
 400                 }
 401                 else
 402                 {
 403                         // Its in the cloned table, so need to look up position
 404                         if ( node.nodeName.toLowerCase() === 'tr' ) {
 405                                 idx = $(node).index();
 406                                 return inst.fnGetPosition( $('tr', this.s.dt.nTBody)[ idx ] );
 407                         }
 408                         else
 409                         {
 410                                 var colIdx = $(node).index();
 411                                 idx = $(node.parentNode).index();
 412                                 var row = inst.fnGetPosition( $('tr', this.s.dt.nTBody)[ idx ] );
 413
 414                                 return [
 415                                         row,
 416                                         colIdx,
 417                                         inst.oApi._fnVisibleToColumnIndex( this.s.dt, colIdx )
 418                                 ];
 419                         }
 420                 }
 421         },
 422
 423
 424
 425         /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 426          * Private methods (they are of course public in JS, but recommended as private)
 427          * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 428
 429         /**
 430          * Initialisation for FixedColumns
 431          *  @param   {Object} oInit User settings for initialisation
 432          *  @returns {void}
 433          *  @private
 434          */
 435         "_fnConstruct": function ( oInit )
 436         {
 437                 var i, iLen, iWidth,
 438                         that = this;
 439
 440                 /* Sanity checking */
 441                 if ( typeof this.s.dt.oInstance.fnVersionCheck != 'function' ||
 442                      this.s.dt.oInstance.fnVersionCheck( '1.8.0' ) !== true )
 443                 {
 444                         alert( "FixedColumns "+FixedColumns.VERSION+" required DataTables 1.8.0 or later. "+
 445                                 "Please upgrade your DataTables installation" );
 446                         return;
 447                 }
 448
 449                 if ( this.s.dt.oScroll.sX === "" )
 450                 {
 451                         this.s.dt.oInstance.oApi._fnLog( this.s.dt, 1, "FixedColumns is not needed (no "+
 452                                 "x-scrolling in DataTables enabled), so no action will be taken. Use 'FixedHeader' for "+
 453                                 "column fixing when scrolling is not enabled" );
 454                         return;
 455                 }
 456
 457                 /* Apply the settings from the user / defaults */
 458                 this.s = $.extend( true, this.s, FixedColumns.defaults, oInit );
 459
 460                 /* Set up the DOM as we need it and cache nodes */
 461                 var classes = this.s.dt.oClasses;
 462                 this.dom.grid.dt = $(this.s.dt.nTable).parents('div.'+classes.sScrollWrapper)[0];
 463                 this.dom.scroller = $('div.'+classes.sScrollBody, this.dom.grid.dt )[0];
 464
 465                 /* Set up the DOM that we want for the fixed column layout grid */
 466                 this._fnColCalc();
 467                 this._fnGridSetup();
 468
 469                 /* Event handlers */
 470                 var mouseController;
 471
 472                 // When the body is scrolled - scroll the left and right columns
 473                 $(this.dom.scroller)
 474                         .on( 'mouseover.DTFC touchstart.DTFC', function () {
 475                                 mouseController = 'main';
 476                         } )
 477                         .on( 'scroll.DTFC', function () {
 478                                 if ( mouseController === 'main' ) {
 479                                         if ( that.s.iLeftColumns > 0 ) {
 480                                                 that.dom.grid.left.liner.scrollTop = that.dom.scroller.scrollTop;
 481                                         }
 482                                         if ( that.s.iRightColumns > 0 ) {
 483                                                 that.dom.grid.right.liner.scrollTop = that.dom.scroller.scrollTop;
 484                                         }
 485                                 }
 486                         } );
 487
 488                 var wheelType = 'onwheel' in document.createElement('div') ?
 489                         'wheel.DTFC' :
 490                         'mousewheel.DTFC';
 491
 492                 if ( that.s.iLeftColumns > 0 ) {
 493                         // When scrolling the left column, scroll the body and right column
 494                         $(that.dom.grid.left.liner)
 495                                 .on( 'mouseover.DTFC touchstart.DTFC', function () {
 496                                         mouseController = 'left';
 497                                 } )
 498                                 .on( 'scroll.DTFC', function () {
 499                                         if ( mouseController === 'left' ) {
 500                                                 that.dom.scroller.scrollTop = that.dom.grid.left.liner.scrollTop;
 501                                                 if ( that.s.iRightColumns > 0 ) {
 502                                                         that.dom.grid.right.liner.scrollTop = that.dom.grid.left.liner.scrollTop;
 503                                                 }
 504                                         }
 505                                 } )
 506                                 .on( wheelType, function(e) { // xxx update the destroy as well
 507                                         // Pass horizontal scrolling through
 508                                         var xDelta = e.type === 'wheel' ?
 509                                                 -e.originalEvent.deltaX :
 510                                                 e.originalEvent.wheelDeltaX;
 511                                         that.dom.scroller.scrollLeft -= xDelta;
 512                                 } );
 513                 }
 514
 515                 if ( that.s.iRightColumns > 0 ) {
 516                         // When scrolling the right column, scroll the body and the left column
 517                         $(that.dom.grid.right.liner)
 518                                 .on( 'mouseover.DTFC touchstart.DTFC', function () {
 519                                         mouseController = 'right';
 520                                 } )
 521                                 .on( 'scroll.DTFC', function () {
 522                                         if ( mouseController === 'right' ) {
 523                                                 that.dom.scroller.scrollTop = that.dom.grid.right.liner.scrollTop;
 524                                                 if ( that.s.iLeftColumns > 0 ) {
 525                                                         that.dom.grid.left.liner.scrollTop = that.dom.grid.right.liner.scrollTop;
 526                                                 }
 527                                         }
 528                                 } )
 529                                 .on( wheelType, function(e) {
 530                                         // Pass horizontal scrolling through
 531                                         var xDelta = e.type === 'wheel' ?
 532                                                 -e.originalEvent.deltaX :
 533                                                 e.originalEvent.wheelDeltaX;
 534                                         that.dom.scroller.scrollLeft -= xDelta;
 535                                 } );
 536                 }
 537
 538                 $(window).on( 'resize.DTFC', function () {
 539                         that._fnGridLayout.call( that );
 540                 } );
 541
 542                 var bFirstDraw = true;
 543                 var jqTable = $(this.s.dt.nTable);
 544
 545                 jqTable
 546                         .on( 'draw.dt.DTFC', function () {
 547                                 that._fnDraw.call( that, bFirstDraw );
 548                                 bFirstDraw = false;
 549                         } )
 550                         .on( 'column-sizing.dt.DTFC', function () {
 551                                 that._fnColCalc();
 552                                 that._fnGridLayout( that );
 553                         } )
 554                         .on( 'column-visibility.dt.DTFC', function () {
 555                                 that._fnColCalc();
 556                                 that._fnGridLayout( that );
 557                                 that._fnDraw( true );
 558                         } )
 559                         .on( 'destroy.dt.DTFC', function () {
 560                                 jqTable.off( 'column-sizing.dt.DTFC destroy.dt.DTFC draw.dt.DTFC' );
 561
 562                                 $(that.dom.scroller).off( 'scroll.DTFC mouseover.DTFC' );
 563                                 $(window).off( 'resize.DTFC' );
 564
 565                                 $(that.dom.grid.left.liner).off( 'scroll.DTFC mouseover.DTFC '+wheelType );
 566                                 $(that.dom.grid.left.wrapper).remove();
 567
 568                                 $(that.dom.grid.right.liner).off( 'scroll.DTFC mouseover.DTFC '+wheelType );
 569                                 $(that.dom.grid.right.wrapper).remove();
 570                         } );
 571
 572                 /* Get things right to start with - note that due to adjusting the columns, there must be
 573                  * another redraw of the main table. It doesn't need to be a full redraw however.
 574                  */
 575                 this._fnGridLayout();
 576                 this.s.dt.oInstance.fnDraw(false);
 577         },
 578
 579
 580         /**
 581          * Calculate the column widths for the grid layout
 582          *  @returns {void}
 583          *  @private
 584          */
 585         "_fnColCalc": function ()
 586         {
 587                 var that = this;
 588                 var iLeftWidth = 0;
 589                 var iRightWidth = 0;
 590
 591                 this.s.aiInnerWidths = [];
 592                 this.s.aiOuterWidths = [];
 593
 594                 $.each( this.s.dt.aoColumns, function (i, col) {
 595                         var th = $(col.nTh);
 596                         var border;
 597
 598                         if ( ! th.filter(':visible').length ) {
 599                                 that.s.aiInnerWidths.push( 0 );
 600                                 that.s.aiOuterWidths.push( 0 );
 601                         }
 602                         else
 603                         {
 604                                 // Inner width is used to assign widths to cells
 605                                 // Outer width is used to calculate the container
 606                                 var iWidth = th.outerWidth();
 607
 608                                 // When working with the left most-cell, need to add on the
 609                                 // table's border to the outerWidth, since we need to take
 610                                 // account of it, but it isn't in any cell
 611                                 if ( that.s.aiOuterWidths.length === 0 ) {
 612                                         border = $(that.s.dt.nTable).css('border-left-width');
 613                                         iWidth += typeof border === 'string' ? 1 : parseInt( border, 10 );
 614                                 }
 615
 616                                 // Likewise with the final column on the right
 617                                 if ( that.s.aiOuterWidths.length === that.s.dt.aoColumns.length-1 ) {
 618                                         border = $(that.s.dt.nTable).css('border-right-width');
 619                                         iWidth += typeof border === 'string' ? 1 : parseInt( border, 10 );
 620                                 }
 621
 622                                 that.s.aiOuterWidths.push( iWidth );
 623                                 that.s.aiInnerWidths.push( th.width() );
 624
 625                                 if ( i < that.s.iLeftColumns )
 626                                 {
 627                                         iLeftWidth += iWidth;
 628                                 }
 629
 630                                 if ( that.s.iTableColumns-that.s.iRightColumns <= i )
 631                                 {
 632                                         iRightWidth += iWidth;
 633                                 }
 634                         }
 635                 } );
 636
 637                 this.s.iLeftWidth = iLeftWidth;
 638                 this.s.iRightWidth = iRightWidth;
 639         },
 640
 641
 642         /**
 643          * Set up the DOM for the fixed column. The way the layout works is to create a 1x3 grid
 644          * for the left column, the DataTable (for which we just reuse the scrolling element DataTable
 645          * puts into the DOM) and the right column. In each of he two fixed column elements there is a
 646          * grouping wrapper element and then a head, body and footer wrapper. In each of these we then
 647          * place the cloned header, body or footer tables. This effectively gives as 3x3 grid structure.
 648          *  @returns {void}
 649          *  @private
 650          */
 651         "_fnGridSetup": function ()
 652         {
 653                 var that = this;
 654                 var oOverflow = this._fnDTOverflow();
 655                 var block;
 656
 657                 this.dom.body = this.s.dt.nTable;
 658                 this.dom.header = this.s.dt.nTHead.parentNode;
 659                 this.dom.header.parentNode.parentNode.style.position = "relative";
 660
 661                 var nSWrapper =
 662                         $('<div class="DTFC_ScrollWrapper" style="position:relative; clear:both;">'+
 663                                 '<div class="DTFC_LeftWrapper" style="position:absolute; top:0; left:0;">'+
 664                                         '<div class="DTFC_LeftHeadWrapper" style="position:relative; top:0; left:0; overflow:hidden;"></div>'+
 665                                         '<div class="DTFC_LeftBodyWrapper" style="position:relative; top:0; left:0; overflow:hidden;">'+
 666                                                 '<div class="DTFC_LeftBodyLiner" style="position:relative; top:0; left:0; overflow-y:scroll;"></div>'+
 667                                         '</div>'+
 668                                         '<div class="DTFC_LeftFootWrapper" style="position:relative; top:0; left:0; overflow:hidden;"></div>'+
 669                                 '</div>'+
 670                                 '<div class="DTFC_RightWrapper" style="position:absolute; top:0; left:0;">'+
 671                                         '<div class="DTFC_RightHeadWrapper" style="position:relative; top:0; left:0;">'+
 672                                                 '<div class="DTFC_RightHeadBlocker DTFC_Blocker" style="position:absolute; top:0; bottom:0;"></div>'+
 673                                         '</div>'+
 674                                         '<div class="DTFC_RightBodyWrapper" style="position:relative; top:0; left:0; overflow:hidden;">'+
 675                                                 '<div class="DTFC_RightBodyLiner" style="position:relative; top:0; left:0; overflow-y:scroll;"></div>'+
 676                                         '</div>'+
 677                                         '<div class="DTFC_RightFootWrapper" style="position:relative; top:0; left:0;">'+
 678                                                 '<div class="DTFC_RightFootBlocker DTFC_Blocker" style="position:absolute; top:0; bottom:0;"></div>'+
 679                                         '</div>'+
 680                                 '</div>'+
 681                         '</div>')[0];
 682                 var nLeft = nSWrapper.childNodes[0];
 683                 var nRight = nSWrapper.childNodes[1];
 684
 685                 this.dom.grid.dt.parentNode.insertBefore( nSWrapper, this.dom.grid.dt );
 686                 nSWrapper.appendChild( this.dom.grid.dt );
 687
 688                 this.dom.grid.wrapper = nSWrapper;
 689
 690                 if ( this.s.iLeftColumns > 0 )
 691                 {
 692                         this.dom.grid.left.wrapper = nLeft;
 693                         this.dom.grid.left.head = nLeft.childNodes[0];
 694                         this.dom.grid.left.body = nLeft.childNodes[1];
 695                         this.dom.grid.left.liner = $('div.DTFC_LeftBodyLiner', nSWrapper)[0];
 696
 697                         nSWrapper.appendChild( nLeft );
 698                 }
 699
 700                 if ( this.s.iRightColumns > 0 )
 701                 {
 702                         this.dom.grid.right.wrapper = nRight;
 703                         this.dom.grid.right.head = nRight.childNodes[0];
 704                         this.dom.grid.right.body = nRight.childNodes[1];
 705                         this.dom.grid.right.liner = $('div.DTFC_RightBodyLiner', nSWrapper)[0];
 706
 707                         block = $('div.DTFC_RightHeadBlocker', nSWrapper)[0];
 708                         block.style.width = oOverflow.bar+"px";
 709                         block.style.right = -oOverflow.bar+"px";
 710                         this.dom.grid.right.headBlock = block;
 711
 712                         block = $('div.DTFC_RightFootBlocker', nSWrapper)[0];
 713                         block.style.width = oOverflow.bar+"px";
 714                         block.style.right = -oOverflow.bar+"px";
 715                         this.dom.grid.right.footBlock = block;
 716
 717                         nSWrapper.appendChild( nRight );
 718                 }
 719
 720                 if ( this.s.dt.nTFoot )
 721                 {
 722                         this.dom.footer = this.s.dt.nTFoot.parentNode;
 723                         if ( this.s.iLeftColumns > 0 )
 724                         {
 725                                 this.dom.grid.left.foot = nLeft.childNodes[2];
 726                         }
 727                         if ( this.s.iRightColumns > 0 )
 728                         {
 729                                 this.dom.grid.right.foot = nRight.childNodes[2];
 730                         }
 731                 }
 732         },
 733
 734
 735         /**
 736          * Style and position the grid used for the FixedColumns layout
 737          *  @returns {void}
 738          *  @private
 739          */
 740         "_fnGridLayout": function ()
 741         {
 742                 var oGrid = this.dom.grid;
 743                 var iWidth = $(oGrid.wrapper).width();
 744                 var iBodyHeight = $(this.s.dt.nTable.parentNode).outerHeight();
 745                 var iFullHeight = $(this.s.dt.nTable.parentNode.parentNode).outerHeight();
 746                 var oOverflow = this._fnDTOverflow();
 747                 var
 748                         iLeftWidth = this.s.iLeftWidth,
 749                         iRightWidth = this.s.iRightWidth,
 750                         iRight;
 751                 var scrollbarAdjust = function ( node, width ) {
 752                         if ( ! oOverflow.bar ) {
 753                                 // If there is no scrollbar (Macs) we need to hide the auto scrollbar
 754                                 node.style.width = (width+20)+"px";
 755                                 node.style.paddingRight = "20px";
 756                                 node.style.boxSizing = "border-box";
 757                         }
 758                         else {
 759                                 // Otherwise just overflow by the scrollbar
 760                                 node.style.width = (width+oOverflow.bar)+"px";
 761                         }
 762                 };
 763
 764                 // When x scrolling - don't paint the fixed columns over the x scrollbar
 765                 if ( oOverflow.x )
 766                 {
 767                         iBodyHeight -= oOverflow.bar;
 768                 }
 769
 770                 oGrid.wrapper.style.height = iFullHeight+"px";
 771
 772                 if ( this.s.iLeftColumns > 0 )
 773                 {
 774                         oGrid.left.wrapper.style.width = iLeftWidth+"px";
 775                         oGrid.left.wrapper.style.height = "1px";
 776                         oGrid.left.body.style.height = iBodyHeight+"px";
 777                         if ( oGrid.left.foot ) {
 778                                 oGrid.left.foot.style.top = (oOverflow.x ? oOverflow.bar : 0)+"px"; // shift footer for scrollbar
 779                         }
 780
 781                         scrollbarAdjust( oGrid.left.liner, iLeftWidth );
 782                         oGrid.left.liner.style.height = iBodyHeight+"px";
 783                 }
 784
 785                 if ( this.s.iRightColumns > 0 )
 786                 {
 787                         iRight = iWidth - iRightWidth;
 788                         if ( oOverflow.y )
 789                         {
 790                                 iRight -= oOverflow.bar;
 791                         }
 792
 793                         oGrid.right.wrapper.style.width = iRightWidth+"px";
 794                         oGrid.right.wrapper.style.left = iRight+"px";
 795                         oGrid.right.wrapper.style.height = "1px";
 796                         oGrid.right.body.style.height = iBodyHeight+"px";
 797                         if ( oGrid.right.foot ) {
 798                                 oGrid.right.foot.style.top = (oOverflow.x ? oOverflow.bar : 0)+"px";
 799                         }
 800
 801                         scrollbarAdjust( oGrid.right.liner, iRightWidth );
 802                         oGrid.right.liner.style.height = iBodyHeight+"px";
 803
 804                         oGrid.right.headBlock.style.display = oOverflow.y ? 'block' : 'none';
 805                         oGrid.right.footBlock.style.display = oOverflow.y ? 'block' : 'none';
 806                 }
 807         },
 808
 809
 810         /**
 811          * Get information about the DataTable's scrolling state - specifically if the table is scrolling
 812          * on either the x or y axis, and also the scrollbar width.
 813          *  @returns {object} Information about the DataTables scrolling state with the properties:
 814          *    'x', 'y' and 'bar'
 815          *  @private
 816          */
 817         "_fnDTOverflow": function ()
 818         {
 819                 var nTable = this.s.dt.nTable;
 820                 var nTableScrollBody = nTable.parentNode;
 821                 var out = {
 822                         "x": false,
 823                         "y": false,
 824                         "bar": this.s.dt.oScroll.iBarWidth
 825                 };
 826
 827                 if ( nTable.offsetWidth > nTableScrollBody.clientWidth )
 828                 {
 829                         out.x = true;
 830                 }
 831
 832                 if ( nTable.offsetHeight > nTableScrollBody.clientHeight )
 833                 {
 834                         out.y = true;
 835                 }
 836
 837                 return out;
 838         },
 839
 840
 841         /**
 842          * Clone and position the fixed columns
 843          *  @returns {void}
 844          *  @param   {Boolean} bAll Indicate if the header and footer should be updated as well (true)
 845          *  @private
 846          */
 847         "_fnDraw": function ( bAll )
 848         {
 849                 this._fnGridLayout();
 850                 this._fnCloneLeft( bAll );
 851                 this._fnCloneRight( bAll );
 852
 853                 /* Draw callback function */
 854                 if ( this.s.fnDrawCallback !== null )
 855                 {
 856                         this.s.fnDrawCallback.call( this, this.dom.clone.left, this.dom.clone.right );
 857                 }
 858
 859                 /* Event triggering */
 860                 $(this).trigger( 'draw.dtfc', {
 861                         "leftClone": this.dom.clone.left,
 862                         "rightClone": this.dom.clone.right
 863                 } );
 864         },
 865
 866
 867         /**
 868          * Clone the right columns
 869          *  @returns {void}
 870          *  @param   {Boolean} bAll Indicate if the header and footer should be updated as well (true)
 871          *  @private
 872          */
 873         "_fnCloneRight": function ( bAll )
 874         {
 875                 if ( this.s.iRightColumns <= 0 ) {
 876                         return;
 877                 }
 878
 879                 var that = this,
 880                         i, jq,
 881                         aiColumns = [];
 882
 883                 for ( i=this.s.iTableColumns-this.s.iRightColumns ; i<this.s.iTableColumns ; i++ ) {
 884                         if ( this.s.dt.aoColumns[i].bVisible ) {
 885                                 aiColumns.push( i );
 886                         }
 887                 }
 888
 889                 this._fnClone( this.dom.clone.right, this.dom.grid.right, aiColumns, bAll );
 890         },
 891
 892
 893         /**
 894          * Clone the left columns
 895          *  @returns {void}
 896          *  @param   {Boolean} bAll Indicate if the header and footer should be updated as well (true)
 897          *  @private
 898          */
 899         "_fnCloneLeft": function ( bAll )
 900         {
 901                 if ( this.s.iLeftColumns <= 0 ) {
 902                         return;
 903                 }
 904
 905                 var that = this,
 906                         i, jq,
 907                         aiColumns = [];
 908
 909                 for ( i=0 ; i<this.s.iLeftColumns ; i++ ) {
 910                         if ( this.s.dt.aoColumns[i].bVisible ) {
 911                                 aiColumns.push( i );
 912                         }
 913                 }
 914
 915                 this._fnClone( this.dom.clone.left, this.dom.grid.left, aiColumns, bAll );
 916         },
 917
 918
 919         /**
 920          * Make a copy of the layout object for a header or footer element from DataTables. Note that
 921          * this method will clone the nodes in the layout object.
 922          *  @returns {Array} Copy of the layout array
 923          *  @param   {Object} aoOriginal Layout array from DataTables (aoHeader or aoFooter)
 924          *  @param   {Object} aiColumns Columns to copy
 925          *  @private
 926          */
 927         "_fnCopyLayout": function ( aoOriginal, aiColumns )
 928         {
 929                 var aReturn = [];
 930                 var aClones = [];
 931                 var aCloned = [];
 932
 933                 for ( var i=0, iLen=aoOriginal.length ; i<iLen ; i++ )
 934                 {
 935                         var aRow = [];
 936                         aRow.nTr = $(aoOriginal[i].nTr).clone(true, true)[0];
 937
 938                         for ( var j=0, jLen=this.s.iTableColumns ; j<jLen ; j++ )
 939                         {
 940                                 if ( $.inArray( j, aiColumns ) === -1 )
 941                                 {
 942                                         continue;
 943                                 }
 944
 945                                 var iCloned = $.inArray( aoOriginal[i][j].cell, aCloned );
 946                                 if ( iCloned === -1 )
 947                                 {
 948                                         var nClone = $(aoOriginal[i][j].cell).clone(true, true)[0];
 949                                         aClones.push( nClone );
 950                                         aCloned.push( aoOriginal[i][j].cell );
 951
 952                                         aRow.push( {
 953                                                 "cell": nClone,
 954                                                 "unique": aoOriginal[i][j].unique
 955                                         } );
 956                                 }
 957                                 else
 958                                 {
 959                                         aRow.push( {
 960                                                 "cell": aClones[ iCloned ],
 961                                                 "unique": aoOriginal[i][j].unique
 962                                         } );
 963                                 }
 964                         }
 965
 966                         aReturn.push( aRow );
 967                 }
 968
 969                 return aReturn;
 970         },
 971
 972
 973         /**
 974          * Clone the DataTable nodes and place them in the DOM (sized correctly)
 975          *  @returns {void}
 976          *  @param   {Object} oClone Object containing the header, footer and body cloned DOM elements
 977          *  @param   {Object} oGrid Grid object containing the display grid elements for the cloned
 978          *                    column (left or right)
 979          *  @param   {Array} aiColumns Column indexes which should be operated on from the DataTable
 980          *  @param   {Boolean} bAll Indicate if the header and footer should be updated as well (true)
 981          *  @private
 982          */
 983         "_fnClone": function ( oClone, oGrid, aiColumns, bAll )
 984         {
 985                 var that = this,
 986                         i, iLen, j, jLen, jq, nTarget, iColumn, nClone, iIndex, aoCloneLayout,
 987                         jqCloneThead, aoFixedHeader,
 988                         dt = this.s.dt;
 989
 990                 /*
 991                  * Header
 992                  */
 993                 if ( bAll )
 994                 {
 995                         if ( oClone.header !== null )
 996                         {
 997                                 oClone.header.parentNode.removeChild( oClone.header );
 998                         }
 999                         oClone.header = $(this.dom.header).clone(true, true)[0];
1000                         oClone.header.className += " DTFC_Cloned";
1001                         oClone.header.style.width = "100%";
1002                         oGrid.head.appendChild( oClone.header );
1003
1004                         /* Copy the DataTables layout cache for the header for our floating column */
1005                         aoCloneLayout = this._fnCopyLayout( dt.aoHeader, aiColumns );
1006                         jqCloneThead = $('>thead', oClone.header);
1007                         jqCloneThead.empty();
1008
1009                         /* Add the created cloned TR elements to the table */
1010                         for ( i=0, iLen=aoCloneLayout.length ; i<iLen ; i++ )
1011                         {
1012                                 jqCloneThead[0].appendChild( aoCloneLayout[i].nTr );
1013                         }
1014
1015                         /* Use the handy _fnDrawHead function in DataTables to do the rowspan/colspan
1016                          * calculations for us
1017                          */
1018                         dt.oApi._fnDrawHead( dt, aoCloneLayout, true );
1019                 }
1020                 else
1021                 {
1022                         /* To ensure that we copy cell classes exactly, regardless of colspan, multiple rows
1023                          * etc, we make a copy of the header from the DataTable again, but don't insert the
1024                          * cloned cells, just copy the classes across. To get the matching layout for the
1025                          * fixed component, we use the DataTables _fnDetectHeader method, allowing 1:1 mapping
1026                          */
1027                         aoCloneLayout = this._fnCopyLayout( dt.aoHeader, aiColumns );
1028                         aoFixedHeader=[];
1029
1030                         dt.oApi._fnDetectHeader( aoFixedHeader, $('>thead', oClone.header)[0] );
1031
1032                         for ( i=0, iLen=aoCloneLayout.length ; i<iLen ; i++ )
1033                         {
1034                                 for ( j=0, jLen=aoCloneLayout[i].length ; j<jLen ; j++ )
1035                                 {
1036                                         aoFixedHeader[i][j].cell.className = aoCloneLayout[i][j].cell.className;
1037
1038                                         // If jQuery UI theming is used we need to copy those elements as well
1039                                         $('span.DataTables_sort_icon', aoFixedHeader[i][j].cell).each( function () {
1040                                                 this.className = $('span.DataTables_sort_icon', aoCloneLayout[i][j].cell)[0].className;
1041                                         } );
1042                                 }
1043                         }
1044                 }
1045                 this._fnEqualiseHeights( 'thead', this.dom.header, oClone.header );
1046
1047                 /*
1048                  * Body
1049                  */
1050                 if ( this.s.sHeightMatch == 'auto' )
1051                 {
1052                         /* Remove any heights which have been applied already and let the browser figure it out */
1053                         $('>tbody>tr', that.dom.body).css('height', 'auto');
1054                 }
1055
1056                 if ( oClone.body !== null )
1057                 {
1058                         oClone.body.parentNode.removeChild( oClone.body );
1059                         oClone.body = null;
1060                 }
1061
1062                 oClone.body = $(this.dom.body).clone(true)[0];
1063                 oClone.body.className += " DTFC_Cloned";
1064                 oClone.body.style.paddingBottom = dt.oScroll.iBarWidth+"px";
1065                 oClone.body.style.marginBottom = (dt.oScroll.iBarWidth*2)+"px"; /* For IE */
1066                 if ( oClone.body.getAttribute('id') !== null )
1067                 {
1068                         oClone.body.removeAttribute('id');
1069                 }
1070
1071                 $('>thead>tr', oClone.body).empty();
1072                 $('>tfoot', oClone.body).remove();
1073
1074                 var nBody = $('tbody', oClone.body)[0];
1075                 $(nBody).empty();
1076                 if ( dt.aiDisplay.length > 0 )
1077                 {
1078                         /* Copy the DataTables' header elements to force the column width in exactly the
1079                          * same way that DataTables does it - have the header element, apply the width and
1080                          * colapse it down
1081                          */
1082                         var nInnerThead = $('>thead>tr', oClone.body)[0];
1083                         for ( iIndex=0 ; iIndex<aiColumns.length ; iIndex++ )
1084                         {
1085                                 iColumn = aiColumns[iIndex];
1086
1087                                 nClone = $(dt.aoColumns[iColumn].nTh).clone(true)[0];
1088                                 nClone.innerHTML = "";
1089
1090                                 var oStyle = nClone.style;
1091                                 oStyle.paddingTop = "0";
1092                                 oStyle.paddingBottom = "0";
1093                                 oStyle.borderTopWidth = "0";
1094                                 oStyle.borderBottomWidth = "0";
1095                                 oStyle.height = 0;
1096                                 oStyle.width = that.s.aiInnerWidths[iColumn]+"px";
1097
1098                                 nInnerThead.appendChild( nClone );
1099                         }
1100
1101                         /* Add in the tbody elements, cloning form the master table */
1102                         $('>tbody>tr', that.dom.body).each( function (z) {
1103                                 var n = this.cloneNode(false);
1104                                 n.removeAttribute('id');
1105                                 var i = that.s.dt.oFeatures.bServerSide===false ?
1106                                         that.s.dt.aiDisplay[ that.s.dt._iDisplayStart+z ] : z;
1107                                 var aTds = that.s.dt.aoData[ i ].anCells || $(this).children('td, th');
1108
1109                                 for ( iIndex=0 ; iIndex<aiColumns.length ; iIndex++ )
1110                                 {
1111                                         iColumn = aiColumns[iIndex];
1112
1113                                         if ( aTds.length > 0 )
1114                                         {
1115                                                 nClone = $( aTds[iColumn] ).clone(true, true)[0];
1116                                                 n.appendChild( nClone );
1117                                         }
1118                                 }
1119                                 nBody.appendChild( n );
1120                         } );
1121                 }
1122                 else
1123                 {
1124                         $('>tbody>tr', that.dom.body).each( function (z) {
1125                                 nClone = this.cloneNode(true);
1126                                 nClone.className += ' DTFC_NoData';
1127                                 $('td', nClone).html('');
1128                                 nBody.appendChild( nClone );
1129                         } );
1130                 }
1131
1132                 oClone.body.style.width = "100%";
1133                 oClone.body.style.margin = "0";
1134                 oClone.body.style.padding = "0";
1135
1136                 // Interop with Scroller - need to use a height forcing element in the
1137                 // scrolling area in the same way that Scroller does in the body scroll.
1138                 if ( dt.oScroller !== undefined )
1139                 {
1140                         var scrollerForcer = dt.oScroller.dom.force;
1141
1142                         if ( ! oGrid.forcer ) {
1143                                 oGrid.forcer = scrollerForcer.cloneNode( true );
1144                                 oGrid.liner.appendChild( oGrid.forcer );
1145                         }
1146                         else {
1147                                 oGrid.forcer.style.height = scrollerForcer.style.height;
1148                         }
1149                 }
1150
1151                 oGrid.liner.appendChild( oClone.body );
1152
1153                 this._fnEqualiseHeights( 'tbody', that.dom.body, oClone.body );
1154
1155                 /*
1156                  * Footer
1157                  */
1158                 if ( dt.nTFoot !== null )
1159                 {
1160                         if ( bAll )
1161                         {
1162                                 if ( oClone.footer !== null )
1163                                 {
1164                                         oClone.footer.parentNode.removeChild( oClone.footer );
1165                                 }
1166                                 oClone.footer = $(this.dom.footer).clone(true, true)[0];
1167                                 oClone.footer.className += " DTFC_Cloned";
1168                                 oClone.footer.style.width = "100%";
1169                                 oGrid.foot.appendChild( oClone.footer );
1170
1171                                 /* Copy the footer just like we do for the header */
1172                                 aoCloneLayout = this._fnCopyLayout( dt.aoFooter, aiColumns );
1173                                 var jqCloneTfoot = $('>tfoot', oClone.footer);
1174                                 jqCloneTfoot.empty();
1175
1176                                 for ( i=0, iLen=aoCloneLayout.length ; i<iLen ; i++ )
1177                                 {
1178                                         jqCloneTfoot[0].appendChild( aoCloneLayout[i].nTr );
1179                                 }
1180                                 dt.oApi._fnDrawHead( dt, aoCloneLayout, true );
1181                         }
1182                         else
1183                         {
1184                                 aoCloneLayout = this._fnCopyLayout( dt.aoFooter, aiColumns );
1185                                 var aoCurrFooter=[];
1186
1187                                 dt.oApi._fnDetectHeader( aoCurrFooter, $('>tfoot', oClone.footer)[0] );
1188
1189                                 for ( i=0, iLen=aoCloneLayout.length ; i<iLen ; i++ )
1190                                 {
1191                                         for ( j=0, jLen=aoCloneLayout[i].length ; j<jLen ; j++ )
1192                                         {
1193                                                 aoCurrFooter[i][j].cell.className = aoCloneLayout[i][j].cell.className;
1194                                         }
1195                                 }
1196                         }
1197                         this._fnEqualiseHeights( 'tfoot', this.dom.footer, oClone.footer );
1198                 }
1199
1200                 /* Equalise the column widths between the header footer and body - body get's priority */
1201                 var anUnique = dt.oApi._fnGetUniqueThs( dt, $('>thead', oClone.header)[0] );
1202                 $(anUnique).each( function (i) {
1203                         iColumn = aiColumns[i];
1204                         this.style.width = that.s.aiInnerWidths[iColumn]+"px";
1205                 } );
1206
1207                 if ( that.s.dt.nTFoot !== null )
1208                 {
1209                         anUnique = dt.oApi._fnGetUniqueThs( dt, $('>tfoot', oClone.footer)[0] );
1210                         $(anUnique).each( function (i) {
1211                                 iColumn = aiColumns[i];
1212                                 this.style.width = that.s.aiInnerWidths[iColumn]+"px";
1213                         } );
1214                 }
1215         },
1216
1217
1218         /**
1219          * From a given table node (THEAD etc), get a list of TR direct child elements
1220          *  @param   {Node} nIn Table element to search for TR elements (THEAD, TBODY or TFOOT element)
1221          *  @returns {Array} List of TR elements found
1222          *  @private
1223          */
1224         "_fnGetTrNodes": function ( nIn )
1225         {
1226                 var aOut = [];
1227                 for ( var i=0, iLen=nIn.childNodes.length ; i<iLen ; i++ )
1228                 {
1229                         if ( nIn.childNodes[i].nodeName.toUpperCase() == "TR" )
1230                         {
1231                                 aOut.push( nIn.childNodes[i] );
1232                         }
1233                 }
1234                 return aOut;
1235         },
1236
1237
1238         /**
1239          * Equalise the heights of the rows in a given table node in a cross browser way
1240          *  @returns {void}
1241          *  @param   {String} nodeName Node type - thead, tbody or tfoot
1242          *  @param   {Node} original Original node to take the heights from
1243          *  @param   {Node} clone Copy the heights to
1244          *  @private
1245          */
1246         "_fnEqualiseHeights": function ( nodeName, original, clone )
1247         {
1248                 if ( this.s.sHeightMatch == 'none' && nodeName !== 'thead' && nodeName !== 'tfoot' )
1249                 {
1250                         return;
1251                 }
1252
1253                 var that = this,
1254                         i, iLen, iHeight, iHeight2, iHeightOriginal, iHeightClone,
1255                         rootOriginal = original.getElementsByTagName(nodeName)[0],
1256                         rootClone    = clone.getElementsByTagName(nodeName)[0],
1257                         jqBoxHack    = $('>'+nodeName+'>tr:eq(0)', original).children(':first'),
1258                         iBoxHack     = jqBoxHack.outerHeight() - jqBoxHack.height(),
1259                         anOriginal   = this._fnGetTrNodes( rootOriginal ),
1260                         anClone      = this._fnGetTrNodes( rootClone ),
1261                         heights      = [];
1262
1263                 for ( i=0, iLen=anClone.length ; i<iLen ; i++ )
1264                 {
1265                         iHeightOriginal = anOriginal[i].offsetHeight;
1266                         iHeightClone = anClone[i].offsetHeight;
1267                         iHeight = iHeightClone > iHeightOriginal ? iHeightClone : iHeightOriginal;
1268
1269                         if ( this.s.sHeightMatch == 'semiauto' )
1270                         {
1271                                 anOriginal[i]._DTTC_iHeight = iHeight;
1272                         }
1273
1274                         heights.push( iHeight );
1275                 }
1276
1277                 for ( i=0, iLen=anClone.length ; i<iLen ; i++ )
1278                 {
1279                         anClone[i].style.height = heights[i]+"px";
1280                         anOriginal[i].style.height = heights[i]+"px";
1281                 }
1282         }
1283 };
1284
1285
1286
1287 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
1288  * Statics
1289  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1290
1291 /**
1292  * FixedColumns default settings for initialisation
1293  *  @name FixedColumns.defaults
1294  *  @namespace
1295  *  @static
1296  */
1297 FixedColumns.defaults = /** @lends FixedColumns.defaults */{
1298         /**
1299          * Number of left hand columns to fix in position
1300          *  @type     int
1301          *  @default  1
1302          *  @static
1303          *  @example
1304          *      var  = $('#example').dataTable( {
1305          *          "scrollX": "100%"
1306          *      } );
1307          *      new $.fn.dataTable.fixedColumns( table, {
1308          *          "leftColumns": 2
1309          *      } );
1310          */
1311         "iLeftColumns": 1,
1312
1313         /**
1314          * Number of right hand columns to fix in position
1315          *  @type     int
1316          *  @default  0
1317          *  @static
1318          *  @example
1319          *      var table = $('#example').dataTable( {
1320          *          "scrollX": "100%"
1321          *      } );
1322          *      new $.fn.dataTable.fixedColumns( table, {
1323          *          "rightColumns": 1
1324          *      } );
1325          */
1326         "iRightColumns": 0,
1327
1328         /**
1329          * Draw callback function which is called when FixedColumns has redrawn the fixed assets
1330          *  @type     function(object, object):void
1331          *  @default  null
1332          *  @static
1333          *  @example
1334          *      var table = $('#example').dataTable( {
1335          *          "scrollX": "100%"
1336          *      } );
1337          *      new $.fn.dataTable.fixedColumns( table, {
1338          *          "drawCallback": function () {
1339          *                  alert( "FixedColumns redraw" );
1340          *              }
1341          *      } );
1342          */
1343         "fnDrawCallback": null,
1344
1345         /**
1346          * Height matching algorthim to use. This can be "none" which will result in no height
1347          * matching being applied by FixedColumns (height matching could be forced by CSS in this
1348          * case), "semiauto" whereby the height calculation will be performed once, and the result
1349          * cached to be used again (fnRecalculateHeight can be used to force recalculation), or
1350          * "auto" when height matching is performed on every draw (slowest but must accurate)
1351          *  @type     string
1352          *  @default  semiauto
1353          *  @static
1354          *  @example
1355          *      var table = $('#example').dataTable( {
1356          *          "scrollX": "100%"
1357          *      } );
1358          *      new $.fn.dataTable.fixedColumns( table, {
1359          *          "heightMatch": "auto"
1360          *      } );
1361          */
1362         "sHeightMatch": "semiauto"
1363 };
1364
1365
1366
1367
1368 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
1369  * Constants
1370  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1371
1372 /**
1373  * FixedColumns version
1374  *  @name      FixedColumns.version
1375  *  @type      String
1376  *  @default   See code
1377  *  @static
1378  */
1379 FixedColumns.version = "3.0.4";
1380
1381
1382
1383 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
1384  * Fired events (for documentation)
1385  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1386
1387
1388 /**
1389  * Event fired whenever FixedColumns redraws the fixed columns (i.e. clones the table elements from the main DataTable). This will occur whenever the DataTable that the FixedColumns instance is attached does its own draw.
1390  * @name FixedColumns#draw.dtfc
1391  * @event
1392  * @param {event} e jQuery event object
1393  * @param {object} o Event parameters from FixedColumns
1394  * @param {object} o.leftClone Instance's object dom.clone.left for easy reference. This object contains references to the left fixed clumn column's nodes
1395  * @param {object} o.rightClone Instance's object dom.clone.right for easy reference. This object contains references to the right fixed clumn column's nodes
1396  */
1397
1398
1399 // Make FixedColumns accessible from the DataTables instance
1400 $.fn.dataTable.FixedColumns = FixedColumns;
1401 $.fn.DataTable.FixedColumns = FixedColumns;
1402
1403
1404 return FixedColumns;
1405 }; // /factory
1406
1407
1408 // Define as an AMD module if possible
1409 if ( typeof define === 'function' && define.amd ) {
1410         define( ['jquery', 'datatables'], factory );
1411 }
1412 else if ( typeof exports === 'object' ) {
1413     // Node/CommonJS
1414     factory( require('jquery'), require('datatables') );
1415 }
1416 else if ( jQuery && !jQuery.fn.dataTable.FixedColumns ) {
1417         // Otherwise simply initialise as normal, stopping multiple evaluation
1418         factory( jQuery, jQuery.fn.dataTable );
1419 }
1420
1421
1422 })(window, document);
1423