diff options
Diffstat (limited to 'public/javascripts/widget-scroller.js')
| -rw-r--r-- | public/javascripts/widget-scroller.js | 921 |
1 files changed, 921 insertions, 0 deletions
diff --git a/public/javascripts/widget-scroller.js b/public/javascripts/widget-scroller.js new file mode 100644 index 0000000..82a8730 --- /dev/null +++ b/public/javascripts/widget-scroller.js @@ -0,0 +1,921 @@ +/*! Widget: scroller - updated 10/31/2015 (v2.24.0) *//* + Copyright (C) 2011 T. Connell & Associates, Inc. + + Dual-licensed under the MIT and GPL licenses + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT + LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN + NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + Resizable scroller widget for the jQuery tablesorter plugin + + Version 2.0 - modified by Rob Garrison 4/12/2013; + updated 3/5/2015 (v2.22.2) with lots of help from TheSin- + Requires jQuery v1.7+ + Requires the tablesorter plugin, v2.8+, available at http://mottie.github.com/tablesorter/docs/ + + Usage: + $(function() { + $('table.tablesorter').tablesorter({ + widgets: ['zebra', 'scroller'], + widgetOptions : { + scroller_height : 300, // height of scroll window + scroller_jumpToHeader : true, // header snap to browser top when scrolling the tbody + scroller_upAfterSort : true, // scroll tbody to top after sorting + scroller_fixedColumns : 0 // set number of fixed columns + } + }); + }); + + Website: www.tconnell.com +*/ +/*jshint browser:true, jquery:true, unused:false */ +;( function( $, window ) { + 'use strict'; + + var ts = $.tablesorter, + tscss = ts.css; + + $.extend( ts.css, { + scrollerWrap : 'tablesorter-scroller', + scrollerHeader : 'tablesorter-scroller-header', + scrollerTable : 'tablesorter-scroller-table', + scrollerFooter : 'tablesorter-scroller-footer', + scrollerFixed : 'tablesorter-scroller-fixed', + scrollerFixedPanel : 'tablesorter-scroller-fixed-panel', + scrollerHasFix : 'tablesorter-scroller-has-fixed-columns', + scrollerHideColumn : 'tablesorter-scroller-hidden-column', + scrollerHideElement : 'tablesorter-scroller-hidden', + scrollerSpacerRow : 'tablesorter-scroller-spacer', + scrollerBarSpacer : 'tablesorter-scroller-bar-spacer', + scrollerAddedHeight : 'tablesorter-scroller-added-height', + scrollerHack : 'tablesorter-scroller-scrollbar-hack', + // class name on table cannot start with 'tablesorter-' or the + // suffix 'scroller-rtl' will match as a theme name + scrollerRtl : 'ts-scroller-rtl' + }); + + ts.addWidget({ + id : 'scroller', + priority : 60, // run after the filter widget + options : { + scroller_height : 300, + // pop table header into view while scrolling up the page + scroller_jumpToHeader : true, + // scroll tbody to top after sorting + scroller_upAfterSort : true, + // set number of fixed columns + scroller_fixedColumns : 0, + // add hover highlighting to the fixed column (disable if it causes slowing) + scroller_rowHighlight : 'hover', + // add a fixed column overlay for styling + scroller_addFixedOverlay : false, + // In tablesorter v2.19.0 the scroll bar width is auto-detected + // add a value here to override the auto-detected setting + scroller_barWidth : null + }, + format : function( table, c, wo ) { + if ( !c.isScrolling ) { + // initialize here instead of in widget init to give the + // filter widget time to finish building the filter row + ts.scroller.setup( c, wo ); + } + }, + remove : function( table, c, wo ) { + ts.scroller.remove( c, wo ); + } + }); + + /* Add window resizeEnd event (also used by columnSelector widget) */ + ts.window_resize = function() { + if ( ts.timer_resize ) { + clearTimeout( ts.timer_resize ); + } + ts.timer_resize = setTimeout( function() { + $( window ).trigger( 'resizeEnd' ); + }, 250 ); + }; + + // Add extra scroller css + $( function() { + var style = '<style>' + + /* overall wrapper & table section wrappers */ + '.' + tscss.scrollerWrap + ' { position: relative; overflow: hidden; }' + + /* add border-box sizing to all scroller widget tables; see #135 */ + '.' + tscss.scrollerWrap + ' * { box-sizing: border-box; }' + + '.' + tscss.scrollerHeader + ', .' + tscss.scrollerFooter + ' { position: relative; overflow: hidden; }' + + '.' + tscss.scrollerHeader + ' table.' + tscss.table + ' { margin-bottom: 0; }' + + /* always leave the scroll bar visible for tbody, or table overflows into the scrollbar + when height < max height (filtering) */ + '.' + tscss.scrollerTable + ' { position: relative; overflow: auto; }' + + '.' + tscss.scrollerTable + ' table.' + tscss.table + + ' { border-top: 0; margin-top: 0; margin-bottom: 0; overflow: hidden; }' + + /* hide footer in original table */ + '.' + tscss.scrollerTable + ' tfoot, .' + tscss.scrollerHideElement + ', .' + tscss.scrollerHideColumn + + ' { display: none; }' + + + /*** fixed column ***/ + /* disable pointer-events on fixed column wrapper or the user can't interact with the horizontal scrollbar */ + '.' + tscss.scrollerFixed + ', .' + tscss.scrollerFixed + ' .' + tscss.scrollerFixedPanel + + ' { pointer-events: none; }' + + /* enable pointer-events for fixed column children; see #135 & #878 */ + '.' + tscss.scrollerFixed + ' > div { pointer-events: all; }' + + '.' + tscss.scrollerWrap + ' .' + tscss.scrollerFixed + ' { position: absolute; top: 0; z-index: 1; left: 0 } ' + + '.' + tscss.scrollerWrap + ' .' + tscss.scrollerFixed + '.' + tscss.scrollerRtl + ' { left: auto; right: 0 } ' + + /* add horizontal scroll bar; set to 'auto', see #135 */ + '.' + tscss.scrollerWrap + '.' + tscss.scrollerHasFix + ' > .' + tscss.scrollerTable + ' { overflow: auto; }' + + /* need to position the tbody & tfoot absolutely to hide the scrollbar & move the footer + below the horizontal scrollbar */ + '.' + tscss.scrollerFixed + ' .' + tscss.scrollerFooter + ' { position: absolute; bottom: 0; }' + + /* hide fixed tbody scrollbar - see http://goo.gl/VsLe6n - set overflow to auto here for mousewheel scroll */ + '.' + tscss.scrollerFixed + ' .' + tscss.scrollerTable + + ' { position: relative; left: 0; overflow: auto; -ms-overflow-style: none; }' + + '.' + tscss.scrollerFixed + ' .' + tscss.scrollerTable + '::-webkit-scrollbar { display: none; }' + + /*** fixed column panel ***/ + '.' + tscss.scrollerWrap + ' .' + tscss.scrollerFixedPanel + + ' { position: absolute; top: 0; bottom: 0; z-index: 2; left: 0; right: 0; } ' + + '</style>'; + $( style ).appendTo( 'body' ); + }); + + ts.scroller = { + + // Ugh.. Firefox misbehaves, so it needs to be detected + isFirefox : navigator.userAgent.toLowerCase().indexOf( 'firefox' ) > -1, + // old IE needs a wrap to hide the fixed column scrollbar; http://stackoverflow.com/a/24408672/145346 + isOldIE : document.all && !window.atob, + isIE : ( document.all && !window.atob ) || navigator.appVersion.indexOf( 'Trident/' ) > 0, + // http://stackoverflow.com/questions/7944460/detect-safari-browser - needed to position scrolling body + // when the table is set up in RTL direction + isSafari : navigator.userAgent.toLowerCase().indexOf( 'safari' ) > -1 && + navigator.userAgent.toLowerCase().indexOf( 'chrome' ) === -1, + + hasScrollBar : function( $target, checkWidth ) { + if ( checkWidth ) { + return $target.get(0).scrollWidth > $target.width(); + } else { + return $target.get(0).scrollHeight > $target.height(); + } + }, + + setWidth : function( $el, width ) { + $el.css({ + 'width' : width, + 'min-width' : width, + 'max-width' : width + }); + }, + + // modified from http://davidwalsh.name/detect-scrollbar-width + getBarWidth : function() { + var $div = $( '<div>' ).css({ + 'position' : 'absolute', + 'top' : '-9999px', + 'left' : 0, + 'width' : '100px', + 'height' : '100px', + 'overflow' : 'scroll', + 'visibility' : 'hidden' + }).appendTo( 'body' ), + div = $div[0], + barWidth = div.offsetWidth - div.clientWidth; + $div.remove(); + return barWidth; + }, + + setup : function( c, wo ) { + var maxHt, tbHt, $hdr, $t, $hCells, $fCells, $tableWrap, events, tmp, detectedWidth, + $win = $( window ), + tsScroller = ts.scroller, + namespace = c.namespace + 'tsscroller', + $foot = $(), + // c.namespace contains a unique tablesorter ID, per table + id = c.namespace.slice( 1 ) + 'tsscroller', + $table = c.$table; + + // force config.widthFixed option - this helps maintain proper alignment across cloned tables + c.widthFixed = true; + + wo.scroller_calcWidths = []; + wo.scroller_saved = [ 0, 0 ]; + wo.scroller_isBusy = true; + + // set scrollbar width to one of the following (1) explicitly set scroller_barWidth option, + // (2) detected scrollbar width or (3) fallback of 15px + if ( wo.scroller_barWidth !== null ) { + wo.scroller_barSetWidth = wo.scroller_barWidth; + } else { + detectedWidth = tsScroller.getBarWidth(); + wo.scroller_barSetWidth = detectedWidth !== null ? detectedWidth : 15; + } + + maxHt = wo.scroller_height || 300; + + $hdr = $( '<table class="' + $table.attr( 'class' ) + '" cellpadding=0 cellspacing=0>' + + $table.children( 'thead' )[ 0 ].outerHTML + '</table>' ); + wo.scroller_$header = $hdr.addClass( c.namespace.slice( 1 ) + '_extra_table' ); + + $t = $table.children( 'tfoot' ); + if ( $t.length ) { + $foot = $( '<table class="' + $table.attr( 'class' ) + + '" cellpadding=0 cellspacing=0 style="margin-top:0"></table>' ) + .addClass( c.namespace.slice( 1 ) + '_extra_table' ) + // maintain any bindings on the tfoot cells + .append( $t.clone( true ) ) + .wrap( '<div class="' + tscss.scrollerFooter + '"/>' ); + $fCells = $foot.children( 'tfoot' ).eq( 0 ).children( 'tr' ).children(); + } + wo.scroller_$footer = $foot; + + $table + .wrap( '<div id="' + id + '" class="' + tscss.scrollerWrap + '" />' ) + .before( $hdr ) + // shrink filter row but don't completely hide it because the inputs/selectors may distort the columns + .find( '.' + tscss.filterRow ) + .addClass( tscss.filterRowHide ); + + wo.scroller_$container = $table.parent(); + + if ( $foot.length ) { + // $foot.parent() to include <div> wrapper + $table.after( $foot.parent() ); + } + + $hCells = $hdr + .wrap( '<div class="' + tscss.scrollerHeader + '" />' ) + .find( '.' + tscss.header ); + + // use max-height, so the height resizes dynamically while filtering + $table.wrap( '<div class="' + tscss.scrollerTable + '" style="max-height:' + maxHt + 'px;" />' ); + $tableWrap = $table.parent(); + + // make scroller header sortable + ts.bindEvents( c.table, $hCells ); + + // look for filter widget + if ( $table.hasClass( 'hasFilters' ) ) { + ts.filter.bindSearch( $table, $hdr.find( '.' + tscss.filter ) ); + } + + $table + .find( 'thead' ) + .addClass( tscss.scrollerHideElement ); + + tbHt = $tableWrap.parent().height(); + + // The header will always jump into view if scrolling the table body + $tableWrap + .off( 'scroll' + namespace ) + .on( 'scroll' + namespace, function() { + if ( wo.scroller_jumpToHeader ) { + var pos = $win.scrollTop() - $hdr.offset().top; + if ( $( this ).scrollTop() !== 0 && pos < tbHt && pos > 0 ) { + $win.scrollTop( $hdr.offset().top ); + } + } + $hdr + .parent() + .add( $foot.parent() ) + .scrollLeft( $( this ).scrollLeft() ); + }); + + // resize/update events - filterEnd fires after "tablesorter-initialized" and "updateComplete" + events = ( ( ts.hasWidget( c.table, 'filter' ) ? 'filterEnd' : 'tablesorter-initialized updateComplete' ) + + ' sortEnd pagerComplete columnUpdate ' ).split( ' ' ).join( namespace + ' ' ); + + $table + .off( namespace ) + .on( 'sortEnd filterEnd'.split( ' ' ).join( namespace + ' ' ), function( event ) { + // Sorting, so scroll to top + if ( event.type === 'sortEnd' && wo.scroller_upAfterSort ) { + $tableWrap.animate({ + scrollTop : 0 + }, 'fast' ); + } else if ( wo.scroller_fixedColumns ) { + setTimeout( function() { + // restore previous scroll position + $tableWrap + .scrollTop( wo.scroller_saved[1] ) + .scrollLeft( wo.scroller_saved[0] ); + tsScroller.updateFixed( c, wo ); + }, 0 ); + } + }) + .on( 'setFixedColumnSize' + namespace, function( event, size ) { + var $wrap = wo.scroller_$container; + if ( typeof size !== 'undefined' && !isNaN( size ) ) { + wo.scroller_fixedColumns = parseInt( size, 10 ); + } + // remove fixed columns + tsScroller.removeFixed( c, wo ); + size = wo.scroller_fixedColumns; + if ( size > 0 && size < c.columns - 1 ) { + tsScroller.updateFixed( c, wo ); + } else if ( $wrap.hasClass( tscss.scrollerHasFix ) ) { + $wrap.removeClass( tscss.scrollerHasFix ); + // resize needed to make tables full width + tsScroller.resize( c, wo ); + } + }) + .on( events, function( event ) { + // Stop from running twice with pager + if ( ts.hasWidget( 'pager' ) && event.type === 'updateComplete' ) { + return; + } + if ( wo.scroller_fixedColumns > 0 ) { + tsScroller.updateFixed( c, wo ); + } + // adjust column sizes after an update + tsScroller.resize( c, wo ); + }); + + // Setup window.resizeEnd event + $win + .off( 'resize resizeEnd '.split( ' ' ).join( namespace + ' ' ) ) + .on( 'resize' + namespace, ts.window_resize ) + .on( 'resizeEnd' + namespace, function() { + // IE calls resize when you modify content, so we have to unbind the resize event + // so we don't end up with an infinite loop. we can rebind after we're done. + $win.off( 'resize' + namespace, ts.window_resize ); + tsScroller.resize( c, wo ); + $win.on( 'resize' + namespace, ts.window_resize ); + $tableWrap.trigger( 'scroll' + namespace ); + }); + + // initialization flag + c.isScrolling = true; + + tsScroller.updateFixed( c, wo ); + + // updateAll called - need to give the browser time to adjust the layout + // before calculating fix column widths + if ( c.table.hasInitialized && c.isScrolling ) { + setTimeout(function(){ + ts.scroller.resize( c, wo ); + }, 50); + } + + }, + + resize : function( c, wo ) { + if ( wo.scroller_isBusy ) { return; } + var index, borderWidth, setWidth, $hCells, $bCells, $fCells, $headers, $this, temp, + tsScroller = ts.scroller, + $container = wo.scroller_$container, + $table = c.$table, + $tableWrap = $table.parent(), + $hdr = wo.scroller_$header, + $foot = wo.scroller_$footer, + id = c.namespace.slice( 1 ) + 'tsscroller', + // Hide other scrollers so we can resize + $div = $( 'div.' + tscss.scrollerWrap + '[id!="' + id + '"]' ) + .addClass( tscss.scrollerHideElement ), + row = '<tr class="' + tscss.scrollerSpacerRow + ' ' + c.selectorRemove.slice(1) + '">'; + + wo.scroller_calcWidths = []; + + // Remove fixed so we get proper widths and heights + tsScroller.removeFixed( c, wo ); + $container.find( '.' + tscss.scrollerSpacerRow ).remove(); + // remove ts added colgroups + $container.find( '.' + ts.css.colgroup ).remove(); + + // show original table elements to get proper alignment + $table + .find( '.' + tscss.scrollerHideElement ) + .removeClass( tscss.scrollerHideElement ); + + // include left & right border widths + borderWidth = parseInt( $table.css( 'border-left-width' ), 10 ); + + $headers = c.$headerIndexed; + + for ( index = 0; index < c.columns; index++ ) { + $this = $headers[ index ]; + // code from https://github.com/jmosbech/StickyTableHeaders + if ( $this.css( 'box-sizing' ) === 'border-box' ) { + setWidth = $this.outerWidth(); + } else { + if ( $this.css( 'border-collapse' ) === 'collapse' ) { + if ( $this.length && window.getComputedStyle ) { + setWidth = parseFloat( window.getComputedStyle( $this[ 0 ], null ).width ); + } else { + // ie8 only + setWidth = $this.outerWidth() - parseFloat( $this.css( 'padding-left' ) ) - + parseFloat( $this.css( 'padding-right' ) ) - + ( parseFloat( $this.css( 'border-width' ) ) || 0 ); + } + } else { + setWidth = $this.width(); + } + } + row += '<td data-column="' + index + '" style="padding:0;margin:0;border:0;height:0;max-height:0;' + + 'min-height:0;width:' + setWidth + 'px;min-width:' + setWidth + 'px;max-width:' + setWidth + 'px"></td>'; + + // save current widths + wo.scroller_calcWidths[ index ] = setWidth; + } + row += '</tr>'; + c.$tbodies.eq(0).prepend( row ); // tbody + $hdr.children( 'thead' ).append( row ); + $foot.children( 'tfoot' ).append( row ); + + // include colgroup or alignment is off + ts.fixColumnWidth( c.table ); + row = c.$table.children( 'colgroup' )[0].outerHTML; + $hdr.prepend( row ); + $foot.prepend( row ); + + temp = $tableWrap.parent().innerWidth() - + ( tsScroller.hasScrollBar( $tableWrap ) ? wo.scroller_barSetWidth : 0 ); + $tableWrap.width( temp ); + + temp = ( tsScroller.hasScrollBar( $tableWrap ) ? wo.scroller_barSetWidth : 0 ) + borderWidth; + setWidth = $tableWrap.innerWidth() - temp; + + $hdr + .parent() + .add( $foot.parent() ) + .width( setWidth ); + + $tableWrap + .width( setWidth + temp ); + + // hide original table thead + $table.children( 'thead' ).addClass( tscss.scrollerHideElement ); + + // update fixed column sizes + tsScroller.updateFixed( c, wo ); + + $div.removeClass( tscss.scrollerHideElement ); + + // restore scrollTop - fixes #926 + $tableWrap.scrollTop( wo.scroller_saved[1] ); + wo.scroller_$container + .find( '.' + tscss.scrollerFixed ) + .find( '.' + tscss.scrollerTable ) + .scrollTop( wo.scroller_saved[1] ); + + // update resizable widget handles + setTimeout( function() { + c.$table.triggerHandler( 'resizableUpdate' ); + }, 100 ); + + }, + + // Add fixed (frozen) columns (Do not call directly, use updateFixed) + setupFixed : function( c, wo ) { + var index, index2, $el, len, temp, $fixedColumn, $fixedTbody, + $table = c.$table, + $wrapper = wo.scroller_$container, + fixedColumns = wo.scroller_fixedColumns; + + $fixedColumn = $wrapper + .addClass( tscss.scrollerHasFix ) + .clone() + .addClass( tscss.scrollerFixed ) + .removeClass( tscss.scrollerWrap ) + .attr( 'id', '' ); + + if ( wo.scroller_addFixedOverlay ) { + $fixedColumn.append( '<div class="' + tscss.scrollerFixedPanel + '">' ); + } + + $fixedTbody = $fixedColumn.find( '.' + tscss.scrollerTable ); + $fixedTbody + .children( 'table' ) + .addClass( c.namespace.slice( 1 ) + '_extra_table' ) + .attr( 'id', '' ) + .children( 'thead, tfoot' ) + .remove(); + + wo.scroller_$fixedColumns = $fixedColumn; + + // RTL support (fixes column on right) + if ( $table.hasClass( tscss.scrollerRtl ) ) { + $fixedColumn.addClass( tscss.scrollerRtl ); + } + + $el = $fixedColumn.find( 'tr' ); + len = $el.length; + for ( index = 0; index < len; index++ ) { + $el.eq( index ).children( ':gt(' + ( fixedColumns - 1 ) + ')' ).remove(); + } + $fixedColumn + .addClass( tscss.scrollerHideElement ) + .prependTo( $wrapper ); + + // look for filter widget + if ( c.$table.hasClass( 'hasFilters' ) ) { + // make sure fixed column filters aren't disabled + $el = $fixedColumn + .find( '.' + tscss.filter ) + .not( '.' + tscss.filterDisabled ) + .prop( 'disabled', false ); + ts.filter.bindSearch( $table, $fixedColumn.find( '.' + tscss.filter ) ); + // disable/enable filters behind fixed column + $el = $wrapper + .children( '.' + tscss.scrollerHeader ) + .find( '.' + tscss.filter ); + len = $el.length; + for ( index = 0; index < len; index++ ) { + // previously disabled filter; don't mess with it! filterDisabled class added by filter widget + if ( !$el.eq( index ).hasClass( tscss.filterDisabled || 'disabled' ) ) { + // disable filters behind fixed column; don't disable visible filters + $el.eq( index ).prop( 'disabled', index < fixedColumns ); + } + } + } + + // disable/enable tab indexes behind fixed column + c.$table + .add( '.' + tscss.scrollerFooter + ' table' ) + .children( 'thead' ) + .children( 'tr.' + tscss.headerRow ) + .children() + .attr( 'tabindex', -1 ); + + $el = wo.scroller_$header + .add( $fixedColumn.find( '.' + tscss.scrollerTable + ' table' ) ) + .children( 'thead' ) + .children( 'tr.' + tscss.headerRow ); + len = $el.length; + for ( index = 0; index < len; index++ ) { + temp = $el.eq( index ).children(); + for ( index2 = 0; index2 < temp.length; index2++ ) { + temp.eq( index2 ).attr( 'tabindex', index2 < fixedColumns ? -1 : 0 ); + } + } + + ts.bindEvents( c.table, $fixedColumn.find( '.' + tscss.header ) ); + ts.scroller.bindFixedColumnEvents( c, wo ); + + /*** Scrollbar hack! Since we can't hide the scrollbar with css ***/ + if ( ts.scroller.isFirefox || ts.scroller.isOldIE ) { + $fixedTbody.wrap( '<div class="' + tscss.scrollerHack + '" style="overflow:hidden;">' ); + } + + }, + + bindFixedColumnEvents : function( c, wo ) { + // update thead & tbody in fixed column + var tsScroller = ts.scroller, + namespace = c.namespace + 'tsscrollerFixed', + events = 'scroll' + namespace, + $fixedTbody = wo.scroller_$fixedColumns.find( '.' + tscss.scrollerTable ), + fixedScroll = true, + tableScroll = true; + + c.$table + .parent() + // *** SCROLL *** scroll fixed column along with main + .off( events ) + .on( events, function() { + if ( wo.scroller_isBusy ) { return; } + // using flags to prevent firing the scroll event excessively leading to slow scrolling in Firefox + if ( !wo.scroller_isBusy && ( fixedScroll || !( tsScroller.isFirefox || tsScroller.isIE ) ) ) { + tableScroll = false; + var $this = $( this ); + $fixedTbody[0].scrollTop = wo.scroller_saved[1] = $this.scrollTop(); + wo.scroller_saved[0] = $this.scrollLeft(); + setTimeout( function() { + tableScroll = true; + }, 20 ); + } + }); + // scroll main along with fixed column + $fixedTbody + .off( events ) + .on( events, function() { + // using flags to prevent firing the scroll event excessively leading to slow scrolling in Firefox + if ( !wo.scroller_isBusy && ( tableScroll || !( tsScroller.isFirefox || tsScroller.isIE ) ) ) { + fixedScroll = false; + var $this = $( this ); + c.$table.parent()[0].scrollTop = wo.scroller_saved[1] = $this.scrollTop(); + setTimeout( function() { + fixedScroll = true; + }, 20 ); + } + }) + .scroll(); + + // *** ROW HIGHLIGHT *** + if ( wo.scroller_rowHighlight !== '' ) { + events = 'mouseover mouseleave '.split( ' ' ).join( namespace + ' ' ); + // can't use c.$tbodies because it doesn't include info-only tbodies + c.$table + .off( events, 'tbody > tr' ) + .on( events, 'tbody > tr', function( event ) { + var indx = c.$table.children( 'tbody' ).children( 'tr' ).index( this ); + $fixedTbody + .children( 'table' ) + .children( 'tbody' ) + .children( 'tr' ) + .eq( indx ) + .add( this ) + .toggleClass( wo.scroller_rowHighlight, event.type === 'mouseover' ); + }); + $fixedTbody + .find( 'table' ) + .off( events, 'tbody > tr' ) + .on( events, 'tbody > tr', function( event ) { + var $fixed = $fixedTbody.children( 'table' ).children( 'tbody' ).children( 'tr' ), + indx = $fixed.index( this ); + c.$table + .children( 'tbody' ) + .children( 'tr' ) + .eq( indx ) + .add( this ) + .toggleClass( wo.scroller_rowHighlight, event.type === 'mouseover' ); + }); + } + }, + + adjustWidth : function( c, wo, totalWidth, adj, dir ) { + var $wrapper = wo.scroller_$container; + + // RTL support (fixes column on right) + $wrapper + .children( '.' + tscss.scrollerTable ) + .css( dir ? 'right' : 'left', totalWidth ); + $wrapper + .children( '.' + tscss.scrollerHeader + ', .' + tscss.scrollerFooter ) + // Safari needs a scrollbar width of extra adjusment to align the fixed & scrolling columns + .css( dir ? 'right' : 'left', totalWidth + ( dir && ts.scroller.isSafari ? adj : 0 ) ); + }, + + updateFixed : function( c, wo ) { + var temp, adj, + $wrapper = wo.scroller_$container, + $hdr = wo.scroller_$header, + $foot = wo.scroller_$footer, + $table = c.$table, + $tableWrap = $table.parent(), + scrollBarWidth = wo.scroller_barSetWidth, + dir = $table.hasClass( tscss.scrollerRtl ); + + if ( wo.scroller_fixedColumns === 0 ) { + wo.scroller_isBusy = false; + ts.scroller.removeFixed( c, wo ); + temp = $wrapper.width(); + $tableWrap.width( temp ); + adj = ts.scroller.hasScrollBar( $tableWrap ) ? scrollBarWidth : 0; + $hdr + .parent() + .add( $foot.parent() ) + .width( temp - adj ); + return; + } + + if ( !c.isScrolling ) { + return; + } + + wo.scroller_isBusy = true; + + // Make sure the wo.scroller_$fixedColumns container exists, if not build it + if ( !$wrapper.find( '.' + tscss.scrollerFixed ).length ) { + ts.scroller.setupFixed( c, wo ); + } + + // scroller_fixedColumns + var index, tbodyIndex, rowIndex, $tbody, $adjCol, $fb, $fixHead, $fixBody, $fixFoot, + totalRows, row, + + // source cells for measurement + $mainTbodies = wo.scroller_$container + .children( '.' + tscss.scrollerTable ) + .children( 'table' ) + .children( 'tbody' ), + // variable gets redefined + $rows = wo.scroller_$header + .children( 'thead' ) + .children( '.' + tscss.headerRow ), + + // hide fixed column during resize, or we get a FOUC + $fixedColumn = wo.scroller_$fixedColumns + .addClass( tscss.scrollerHideElement ), + + // target cells + $fixedTbodiesTable = $fixedColumn + .find( '.' + tscss.scrollerTable ) + .children( 'table' ), + $fixedTbodies = $fixedTbodiesTable + .children( 'tbody' ), + // variables + tsScroller = ts.scroller, + fixedColumns = wo.scroller_fixedColumns, + // get dimensions + $temp = $table.find( 'tbody td' ), + borderRightWidth = parseInt( $temp.css( 'border-right-width' ), 10 ) || 1, + borderSpacing = parseInt( ( $temp.css( 'border-spacing' ) || '' ).split( /\s/ )[ 0 ], 10 ) / 2 || 0, + totalWidth = parseInt( $table.css( 'padding-left' ), 10 ) + + parseInt( $table.css( 'padding-right' ), 10 ) - + borderRightWidth, + widths = wo.scroller_calcWidths; + + ts.scroller.removeFixed( c, wo, false ); + + // calculate fixed column width + for ( index = 0; index < fixedColumns; index++ ) { + totalWidth += widths[ index ] + borderSpacing; + } + + // set fixed column width + totalWidth = totalWidth + borderRightWidth * 2 - borderSpacing; + tsScroller.setWidth( $fixedColumn.add( $fixedColumn.children() ), totalWidth ); + tsScroller.setWidth( $fixedColumn.children().children( 'table' ), totalWidth ); + + // update fixed column tbody content, set cell widths on hidden row + for ( tbodyIndex = 0; tbodyIndex < c.$tbodies.length; tbodyIndex++ ) { + $tbody = $mainTbodies.eq( tbodyIndex ); + if ( $tbody.length ) { + // get tbody + $rows = $tbody.children(); + totalRows = $rows.length; + $fb = ts.processTbody( $fixedTbodiesTable, $fixedTbodies.eq( tbodyIndex ), true ); + $fb.empty(); + // update tbody cells after sort/filtering + for ( rowIndex = 0; rowIndex < totalRows; rowIndex++ ) { + $adjCol = $( $rows[ rowIndex ].outerHTML ); + $adjCol + .children( 'td, th' ) + .slice( fixedColumns ) + .remove(); + $fb.append( $adjCol ); + } + + // restore tbody + ts.processTbody( $fixedTbodiesTable, $fb, false ); + } + } + + adj = ts.scroller.hasScrollBar( $tableWrap ) ? scrollBarWidth : 0; + + /*** scrollbar HACK! Since we can't hide the scrollbar with css ***/ + if ( tsScroller.isFirefox || tsScroller.isOldIE ) { + $fixedTbodiesTable + .css( 'width', totalWidth ) + .parent() + .css( 'width', totalWidth + adj ); + } + + $fixedColumn.removeClass( tscss.scrollerHideElement ); + for ( index = 0; index < fixedColumns; index++ ) { + $wrapper + .children( 'div' ) + .children( 'table' ) + .find( 'th:nth-child(' + ( index + 1 ) + '), td:nth-child(' + ( index + 1 ) + ')' ) + .addClass( tscss.scrollerHideColumn ); + } + + totalWidth = totalWidth - borderRightWidth; + temp = $tableWrap.parent().innerWidth() - totalWidth; + $tableWrap.width( temp ); + // RTL support (fixes column on right) + $wrapper + .children( '.' + tscss.scrollerTable ) + .css( dir ? 'right' : 'left', totalWidth ); + $wrapper + .children( '.' + tscss.scrollerHeader + ', .' + tscss.scrollerFooter ) + // Safari needs a scrollbar width of extra adjusment to align the fixed & scrolling columns + .css( dir ? 'right' : 'left', totalWidth + ( dir && ts.scroller.isSafari ? adj : 0 ) ); + + $hdr + .parent() + .add( $foot.parent() ) + .width( temp - adj ); + + // fix gap under the tbody for the horizontal scrollbar + temp = ts.scroller.hasScrollBar( $tableWrap, true ); + adj = temp ? scrollBarWidth : 0; + if ( !$fixedColumn.find( '.' + tscss.scrollerBarSpacer ).length && temp ) { + $temp = $( '<div class="' + tscss.scrollerBarSpacer + '">' ) + .css( 'height', adj + 'px' ); + $fixedColumn.find( '.' + tscss.scrollerTable ).append( $temp ); + } else if ( !temp ) { + $fixedColumn.find( '.' + tscss.scrollerBarSpacer ).remove(); + } + + ts.scroller.updateRowHeight( c, wo ); + // set fixed column height (changes with filtering) + $fixedColumn.height( $wrapper.height() ); + + $fixedColumn.removeClass( tscss.scrollerHideElement ); + + wo.scroller_isBusy = false; + + }, + + fixHeight : function( $rows, $fixedRows ) { + var index, heightRow, heightFixed, $r, $f, + addedHt = tscss.scrollerAddedHeight, + len = $rows.length; + for ( index = 0; index < len; index++ ) { + $r = $rows.eq( index ); + $f = $fixedRows.eq( index ); + heightRow = $r.height(); + heightFixed = $f.height(); + if ( heightRow > heightFixed ) { + $f.addClass( addedHt ).height( heightRow ); + } else if ( heightRow < heightFixed ) { + $r.addClass( addedHt ).height( heightFixed ); + } + } + }, + + updateRowHeight : function( c, wo ) { + var $rows, $fixed, + $fixedColumns = wo.scroller_$fixedColumns; + + wo.scroller_$container + .find( '.' + tscss.scrollerAddedHeight ) + .removeClass( tscss.scrollerAddedHeight ) + .height( '' ); + + $rows = wo.scroller_$header + .children( 'thead' ) + .children( 'tr' ); + $fixed = $fixedColumns + .children( '.' + tscss.scrollerHeader ) + .children( 'table' ) + .children( 'thead' ) + .children( 'tr' ); + ts.scroller.fixHeight( $rows, $fixed ); + + $rows = wo.scroller_$footer + .children( 'tfoot' ) + .children( 'tr' ); + $fixed = $fixedColumns + .children( '.' + tscss.scrollerFooter ) + .children( 'table' ) + .children( 'tfoot' ) + .children( 'tr' ); + ts.scroller.fixHeight( $rows, $fixed ); + + if ( ts.scroller.isFirefox || ts.scroller.isOldIE ) { + // Firefox/Old IE scrollbar hack (wraps table to hide the scrollbar) + $fixedColumns = $fixedColumns.find( '.' + tscss.scrollerHack ); + } + $rows = c.$table + .children( 'tbody' ) + .children( 'tr' ); + $fixed = $fixedColumns + .children( '.' + tscss.scrollerTable ) + .children( 'table' ) + .children( 'tbody' ) + .children( 'tr' ); + ts.scroller.fixHeight( $rows, $fixed ); + + }, + + removeFixed : function( c, wo, removeIt ) { + var $table = c.$table, + $wrapper = wo.scroller_$container, + dir = $table.hasClass( tscss.scrollerRtl ); + + // remove fixed columns + if ( removeIt || typeof removeIt === 'undefined' ) { + $wrapper.find( '.' + tscss.scrollerFixed ).remove(); + } + + $wrapper + .find( '.' + tscss.scrollerHideColumn ) + .removeClass( tscss.scrollerHideColumn ); + + // RTL support ( fixes column on right ) + $wrapper + .children( ':not(.' + tscss.scrollerFixed + ')' ) + .css( dir ? 'right' : 'left', 0 ); + }, + + remove : function( c, wo ) { + var $wrap = wo.scroller_$container, + namespace = c.namespace + 'tsscroller'; + c.$table.off( namespace ); + $( window ).off( namespace ); + if ( $wrap ) { + c.$table + .insertBefore( $wrap ) + .find( 'thead' ) + .removeClass( tscss.scrollerHideElement ) + .children( 'tr.' + tscss.headerRow ) + .children() + .attr( 'tabindex', 0 ) + .end() + .find( '.' + tscss.filterRow ) + .removeClass( tscss.scrollerHideElement + ' ' + tscss.filterRowHide ); + c.$table + .find( '.' + tscss.filter ) + .not( '.' + tscss.filterDisabled ) + .prop( 'disabled', false ); + $wrap.remove(); + c.isScrolling = false; + } + } + + }; + +})( jQuery, window ); |