jquery-tablesorter 1.13.4 → 1.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fbc77e5c7eae0e53eeabee85b7bc2383ee47f418
-  data.tar.gz: fc1cc344b8642f999e4787d8c82e4d93c6f73f30
+  metadata.gz: 6dfe913d87203537e4c01799330730a0a5d07c76
+  data.tar.gz: 4372b67de0d2b979cdd67be82de133141e02bb70
 SHA512:
-  metadata.gz: db3c65d13f8da77d1cdd84f9c40d6e3460317d7f59f3a30a3c6042f7366d0bc2606c2b4fcb94030164e8490251d592764c6664523b5e0cf6e4eb65fb34e6d46f
-  data.tar.gz: 0cd1b23750074956747fba1febbbcbe0d1084bcef6218d67d96723e65c6aeb28959ed198d016984a32f6667b7e57040e8ddce8b8531c7f63aa40dfc2de8a1b95
+  metadata.gz: 6ac07021042d37ed4bceca7f05ebd40b086ee7f5437fbc8de5dfd97bf81bb546c52818a6be7d8a674beaa35d7629a3e61970621db28db57bf8c758676249831d
+  data.tar.gz: 7cbe44694d1091fc8a2a1c9666280ee4ea2580a414fb9bbb3b08adccfd660da3f07cbc0b88b0c9cd54f2a7d14e20c1d4afd1db790bcc047cc5012fd37f1a7b86

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright 2014 Jun Lin, Erik-B. Ernst
+Copyright 2015 Jun Lin, Erik-B. Ernst
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -4,7 +4,7 @@
 
 Simple integration of jquery-tablesorter into the asset pipeline.
 
-Current tablesorter version: 2.18.4 (12/22/2014), [documentation]
+Current tablesorter version: 2.19.0 (2/7/2015), [documentation]
 
 Any issue associated with the js/css files, please report to [Mottie's fork].
 
@@ -26,7 +26,7 @@ Or install it yourself as:
 
 Rails 3.1 and higher (tested up to 4.2)
 
-Tested with ruby 1.9.3 - 2.1.5
+Tested with ruby 1.9.3 - 2.2.0
 
 ## Usage
 

data/lib/jquery-tablesorter/version.rb

@@ -1,3 +1,3 @@
 module JqueryTablesorter
-  VERSION = '1.13.4'
+  VERSION = '1.14.0'
 end

data/vendor/assets/images/jquery-tablesorter/dragtable-handle.svg

@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="2" height="13">
+	<rect style="fill:#333;fill-opacity:.8;" width="1" height="1" x="1" y="2"/>
+	<rect style="fill:#333;fill-opacity:.8;" width="1" height="1" x="1" y="4"/>
+	<rect style="fill:#333;fill-opacity:.8;" width="1" height="1" x="1" y="6"/>
+	<rect style="fill:#333;fill-opacity:.8;" width="1" height="1" x="1" y="8"/>
+	<rect style="fill:#333;fill-opacity:.8;" width="1" height="1" x="1" y="10"/>
+</svg>

data/vendor/assets/javascripts/jquery-tablesorter/addons/pager/jquery.tablesorter.pager.js

@@ -1,6 +1,6 @@
 /*!
  * tablesorter (FORK) pager plugin
- * updated 12/22/2014 (v2.18.4)
+ * updated 2/7/2015 (v2.19.0)
  */
 /*jshint browser:true, jquery:true, unused:false */
 ;(function($) {
@@ -114,7 +114,10 @@
 
 		};
 
-		var $this = this,
+		var pagerEvents = 'filterInit filterStart filterEnd sortEnd disable enable destroy updateComplete ' +
+			'pageSize pageSet pageAndSize pagerUpdate ',
+
+		$this = this,
 
 		// hide arrows at extremes
 		pagerArrows = function(p, disable) {
@@ -132,15 +135,18 @@
 		},
 
 		calcFilters = function(table, p) {
-			var c = table.config,
+			var tbodyIndex,
+				c = table.config,
 				hasFilters = c.$table.hasClass('hasFilters');
 			if (hasFilters && !p.ajaxUrl) {
 				if ($.isEmptyObject(c.cache)) {
 					// delayInit: true so nothing is in the cache
 					p.filteredRows = p.totalRows = c.$tbodies.eq(0).children('tr').not( p.countChildRows ? '' : '.' + c.cssChildRow ).length;
 				} else {
+					// just in case the pager tbody isn't the first tbody
+					tbodyIndex = c.$table.children('tbody').index( c.$tbodies.eq(0) );
 					p.filteredRows = 0;
-					$.each(c.cache[0].normalized, function(i, el) {
+					$.each(c.cache[tbodyIndex].normalized, function(i, el) {
 						p.filteredRows += p.regexRows.test(el[c.columns].$row[0].className) ? 0 : 1;
 					});
 				}
@@ -153,7 +159,7 @@
 			if ( p.initializing ) { return; }
 			var s, t, $out,
 				c = table.config,
-				sz = p.size || 10; // don't allow dividing by zero
+				sz = p.size || p.settings.size || 10; // don't allow dividing by zero
 			if (p.countChildRows) { t.push(c.cssChildRow); }
 			p.totalPages = Math.ceil( p.totalRows / sz ); // needed for "pageSize" method
 			c.totalRows = p.totalRows;
@@ -162,8 +168,8 @@
 			p.filteredPages = Math.ceil( p.filteredRows / sz ) || 0;
 			if ( Math.min( p.totalPages, p.filteredPages ) >= 0 ) {
 				t = (p.size * p.page > p.filteredRows) && completed;
-				p.startRow = (t) ? 1 : (p.filteredRows === 0 ? 0 : p.size * p.page + 1);
-				p.page = (t) ? 0 : p.page;
+				p.page = (t) ? p.pageReset || 0 : p.page;
+				p.startRow = (t) ? p.size * p.page + 1 : (p.filteredRows === 0 ? 0 : p.size * p.page + 1);
 				p.endRow = Math.min( p.filteredRows, p.totalRows, p.size * ( p.page + 1 ) );
 				$out = p.$container.find(p.cssPageDisplay);
 				// form the output string (can now get a new output string from the server)
@@ -187,16 +193,16 @@
 						}
 						return extra.length > 1 && data && data[extra[0]] ? data[extra[0]][extra[1]] : p[str] || (data ? data[str] : deflt) || deflt;
 					});
+				if ( p.$goto.length ) {
+					t = '';
+					$.each(buildPageSelect(p), function(i, opt){
+						t += '<option value="' + opt + '">' + opt + '</option>';
+					});
+					// innerHTML doesn't work in IE9 - http://support2.microsoft.com/kb/276228
+					p.$goto.html(t).val( p.page + 1 );
+				}
 				if ($out.length) {
 					$out[ ($out[0].tagName === 'INPUT') ? 'val' : 'html' ](s);
-					if ( p.$goto.length ) {
-						t = '';
-						$.each(buildPageSelect(p), function(i, opt){
-							t += '<option value="' + opt + '">' + opt + '</option>';
-						});
-						// innerHTML doesn't work in IE9 - http://support2.microsoft.com/kb/276228
-						p.$goto.html(t).val( p.page + 1 );
-					}
 					// rebind startRow/page inputs
 					$out.find('.ts-startRow, .ts-page').unbind('change').bind('change', function(){
 						var v = $(this).val(),
@@ -319,7 +325,9 @@
 				s = ( p.page * p.size ),
 				e =  s + p.size,
 				f = c.widgetOptions && c.widgetOptions.filter_filteredRow || 'filtered',
+				last = 0, // for cache indexing
 				j = 0; // size counter
+				p.cacheIndex = [];
 				for ( i = 0; i < l; i++ ){
 					if ( !rows[i].className.match(f) ) {
 						if (j === s && rows[i].className.match(c.cssChildRow)) {
@@ -327,6 +335,10 @@
 							rows[i].style.display = 'none';
 						} else {
 							rows[i].style.display = ( j >= s && j < e ) ? '' : 'none';
+							if (last !== j && j >= s && j < e) {
+								p.cacheIndex.push(i);
+								last = j;
+							}
 							// don't count child rows
 							j += rows[i].className.match(c.cssChildRow + '|' + c.selectorRemove.slice(1)) && !p.countChildRows ? 0 : 1;
 							if ( j === e && rows[i].style.display !== 'none' && rows[i].className.match(ts.css.cssHasChild) ) {
@@ -345,7 +357,7 @@
 		},
 
 		hideRowsSetup = function(table, p){
-			p.size = parseInt( p.$size.val(), 10 ) || p.size;
+			p.size = parseInt( p.$size.val(), 10 ) || p.size || p.settings.size || 10;
 			$.data(table, 'pagerLastSize', p.size);
 			pagerArrows(p);
 			if ( !p.removeRows ) {
@@ -457,11 +469,11 @@
 				}
 				// make sure last pager settings are saved, prevents multiple server side calls with
 				// the same parameters
-				p.totalPages = Math.ceil( p.totalRows / ( p.size || 10 ) );
+				p.totalPages = Math.ceil( p.totalRows / ( p.size || p.settings.size || 10 ) );
 				p.last.totalRows = p.totalRows;
 				p.last.currentFilters = p.currentFilters;
 				p.last.sortList = (c.sortList || []).join(',');
-				updatePageDisplay(table, p, true);
+				updatePageDisplay(table, p, false);
 				$t.trigger('updateCache', [function(){
 					if (p.initialized) {
 						// apply widgets after table has rendered & after a delay to prevent
@@ -470,6 +482,7 @@
 							$t
 								.trigger('applyWidgets')
 								.trigger('pagerChange', p);
+							updatePageDisplay(table, p, true);
 							}, 0);
 					}
 				}]);
@@ -580,6 +593,7 @@
 				// lets not render the table more than once
 				moveToLastPage(table, p);
 			}
+			p.cacheIndex = [];
 			p.isDisabled = false; // needed because sorting will change the page and re-enable the pager
 			if (p.initialized) { $t.trigger('pagerChange', p); }
 
@@ -598,6 +612,7 @@
 						count++;
 						if (count > s && added <= e) {
 							added++;
+							p.cacheIndex.push(index);
 							$tb.append(rows[index]);
 						}
 					}
@@ -644,7 +659,8 @@
 			c.$table.trigger('updateCache', [ function(){
 				var i,
 					rows = [],
-					n = table.config.cache[0].normalized;
+					tbodyIndex = c.$table.children('tbody').index( c.$tbodies.eq(0) ),
+					n = table.config.cache[tbodyIndex].normalized;
 				p.totalRows = n.length;
 				for (i = 0; i < p.totalRows; i++) {
 					rows.push(n[i][c.columns].$row);
@@ -711,7 +727,7 @@
 		},
 
 		setPageSize = function(table, size, p) {
-			p.size = size || p.size || 10;
+			p.size = size || p.size || p.settings.size || 10;
 			p.$size.val(p.size);
 			$.data(table, 'pagerLastPage', p.page);
 			$.data(table, 'pagerLastSize', p.size);
@@ -752,7 +768,7 @@
 			table.config.appender = null; // remove pager appender function
 			p.initialized = false;
 			delete table.config.rowsCopy;
-			$(table).unbind('filterInit filterStart filterEnd sortEnd disable enable destroy updateComplete pageSize pageSet '.split(' ').join('.pager '));
+			$(table).unbind(pagerEvents.split(' ').join('.pager '));
 			if (ts.storage) {
 				ts.storage(table, p.storageKey, '');
 			}
@@ -767,7 +783,7 @@
 				.attr('aria-disabled', 'false');
 			p.isDisabled = false;
 			p.page = $.data(table, 'pagerLastPage') || p.page || 0;
-			p.size = $.data(table, 'pagerLastSize') || parseInt(p.$size.find('option[selected]').val(), 10) || p.size || 10;
+			p.size = $.data(table, 'pagerLastSize') || parseInt(p.$size.find('option[selected]').val(), 10) || p.size || p.settings.size || 10;
 			p.$size.val(p.size); // set page size
 			p.totalPages = Math.ceil( Math.min( p.totalRows, p.filteredRows ) / p.size );
 			// if table id exists, include page display with aria info
@@ -793,7 +809,7 @@
 			if ( !p.ajax ) {
 				c.rowsCopy = rows;
 				p.totalRows = p.countChildRows ? c.$tbodies.eq(0).children('tr').length : rows.length;
-				p.size = $.data(table, 'pagerLastSize') || p.size || 10;
+				p.size = $.data(table, 'pagerLastSize') || p.size || p.settings.size || 10;
 				p.totalPages = Math.ceil( p.totalRows / p.size );
 				renderTable(table, rows, p);
 				// update display here in case all rows are removed
@@ -813,6 +829,8 @@
 					$t = c.$table,
 					// added in case the pager is reinitialized after being destroyed.
 					pager = p.$container = $(p.container).addClass('tablesorter-pager').show();
+				// save a copy of the original settings
+				p.settings = $.extend( true, {}, $.tablesorterPager.defaults, settings );
 				if (c.debug) {
 					ts.log('Pager initializing');
 				}
@@ -822,7 +840,7 @@
 				if (p.savePages && ts.storage) {
 					t = ts.storage(table, p.storageKey) || {}; // fixes #387
 					p.page = isNaN(t.page) ? p.page : t.page;
-					p.size = ( isNaN(t.size) ? p.size : t.size ) || 10;
+					p.size = ( isNaN(t.size) ? p.size : t.size ) || p.settings.size || 10;
 					$.data(table, 'pagerLastSize', p.size);
 				}
 
@@ -830,9 +848,9 @@
 				p.regexRows = new RegExp('(' + (wo.filter_filteredRow || 'filtered') + '|' + c.selectorRemove.slice(1) + '|' + c.cssChildRow + ')');
 
 				$t
-					.unbind('filterInit filterStart filterEnd sortEnd disable enable destroy updateComplete pageSize pageSet '.split(' ').join('.pager '))
-					.bind('filterInit.pager filterStart.pager', function(e) {
-						p.currentFilters = c.$table.data('lastSearch');
+					.unbind(pagerEvents.split(' ').join('.pager '))
+					.bind('filterInit.pager filterStart.pager', function(e, filters) {
+						p.currentFilters = $.isArray(filters) ? filters : c.$table.data('lastSearch');
 						// don't change page if filters are the same (pager updating, etc)
 						if (e.type === 'filterStart' && p.pageReset !== false && (c.lastCombinedFilter || '') !== (p.currentFilters || []).join('')) {
 							p.page = p.pageReset; // fixes #456 & #565
@@ -881,18 +899,26 @@
 						changeHeight(table, p);
 						updatePageDisplay(table, p, true);
 					})
-					.bind('pageSize.pager', function(e,v){
+					.bind('pageSize.pager refreshComplete.pager', function(e,v){
 						e.stopPropagation();
-						setPageSize(table, parseInt(v, 10) || 10, p);
+						setPageSize(table, parseInt(v, 10) || p.settings.size || 10, p);
 						hideRows(table, p);
 						updatePageDisplay(table, p, false);
-						if (p.$size.length) { p.$size.val(p.size); } // twice?
 					})
-					.bind('pageSet.pager', function(e,v){
+					.bind('pageSet.pager pagerUpdate.pager', function(e,v){
 						e.stopPropagation();
 						p.page = (parseInt(v, 10) || 1) - 1;
-						if (p.$goto.length) { p.$goto.val(p.size); } // twice?
+						// force pager refresh
+						if (e.type === 'pagerUpdate') { p.last.page = true; }
+						moveToPage(table, p, true);
+						updatePageDisplay(table, p, false);
+					})
+					.bind('pageAndSize.pager', function(e, page, size){
+						e.stopPropagation();
+						p.page = (parseInt(page, 10) || 1) - 1;
+						setPageSize(table, parseInt(size, 10) || p.settings.size || 10, p);
 						moveToPage(table, p, true);
+						hideRows(table, p);
 						updatePageDisplay(table, p, false);
 					});
 

data/vendor/assets/javascripts/jquery-tablesorter/extras/jquery.dragtable.mod.js

@@ -0,0 +1,605 @@
+/*! Dragtable Mod for TableSorter - 2/7/2015 (v2.19.0) *//*
+ * Requires
+ *   tablesorter v2.8+
+ *   jQuery 1.7+
+ *   jQuery UI (Core, Widget, Mouse & Sortable)
+ *   Dragtable by Akottr (https://github.com/akottr) modified by Rob Garrison
+ */
+/*jshint browser:true, jquery:true, unused:false */
+/*global jQuery: false */
+;(function( $ ) {
+'use strict';
+  var undef,
+    ts = $.tablesorter;
+
+  ts.dragtable = {
+    create : function( _this ) {
+      var hasAccept,
+        $table = _this.originalTable.el,
+        handle = _this.options.dragHandle.replace('.', '');
+      $table.children('thead').children().children('th,td').each(function(){
+        var $this = $(this);
+        if ( !$this.find( _this.options.dragHandle + ',.' + handle + '-disabled' ).length ) {
+          hasAccept = _this.options.dragaccept ? $this.hasClass( _this.options.dragaccept.replace('.', '') ) : true;
+          $this
+            // sortClass includes a "." to match the tablesorter selectorSort option - for consistency
+            .wrapInner('<div class="' + _this.options.sortClass.replace('.', '') + '"/>')
+            // add handle class + "-disabled" to drag-disabled columns
+            .prepend('<div class="' + handle + ( hasAccept ? '' : '-disabled' ) + '"></div>');
+        }
+      });
+    },
+    start : function( table ) {
+      table = $( table )[0];
+      if ( table && table.config ) {
+        table.config.widgetOptions.dragtableLast = {
+          search : $( table ).data( 'lastSearch' ),
+          order : ts.dragtable.getOrder( table )
+        };
+      }
+    },
+    update : function( _this ) {
+      var t, list, val,
+        dragTable = _this.originalTable,
+        table = dragTable.el[ 0 ],
+        $table = $( table ),
+        c = table.config,
+        wo = c && c.widgetOptions,
+        startIndex = dragTable.startIndex - 1,
+        endIndex = dragTable.endIndex - 1,
+        columnOrder = ts.dragtable.getOrder( table ) || [],
+        hasFilters = ts.hasWidget( $table, 'filter' ) || false,
+        last = wo && wo.dragtableLast || {},
+        // update moved filters
+        filters = [];
+
+      // only trigger updateAll if column order changed
+      if ( ( last.order || [] ).join( '' ) !== columnOrder.join( '' ) ) {
+
+        if ( c.sortList.length ) {
+          // must deep extend (nested arrays) to prevent list from changing with c.sortList
+          list = $.extend( true, [], c.sortList );
+          $.each( columnOrder, function( indx, value ) {
+            val = ts.isValueInArray( parseInt( value, 10 ), list );
+            if ( value !== last.order[ indx ] && val >= 0 ) {
+              c.sortList[ val ][ 0 ] = indx;
+            }
+          });
+        }
+
+        // update filter widget
+        if ( hasFilters ) {
+          $.each( last.search || [], function( indx ) {
+            filters[ indx ] = last.search[ columnOrder[ indx ] ];
+          });
+        }
+
+        // update preset editable widget columns
+        t = ( ts.hasWidget( c.$table, 'editable' ) || false ) ? wo.editable_columnsArray : false;
+        if ( t ) {
+          c.widgetOptions.editable_columnsArray = ts.dragtable.reindexArrayItem( t, startIndex, endIndex );
+        }
+        // update ignore math columns
+        t = ( ts.hasWidget( c.$table, 'math' ) || false ) ? wo.math_ignore : false;
+        if ( t ) {
+          c.widgetOptions.math_ignore = ts.dragtable.reindexArrayItem( t, startIndex, endIndex );
+        }
+        // update preset resizable widget widths
+        t = ( ts.hasWidget( c.$table, 'resizable' ) || false ) ? wo.resizable_widths : false;
+        if ( t ) {
+          // use zero-based indexes in the array
+          wo.resizable_widths = ts.dragtable.moveArrayItem( t, startIndex, endIndex );
+        }
+        /*
+        // chart widget WIP - there are other options that need to be rearranged!
+        t = ( ts.hasWidget( c.$table, 'chart' ) || false ) ? wo.chart_ignoreColumns : false;
+        if ( t ) {
+          // use zero-based indexes in the array
+          wo.chart_ignoreColumns = ts.dragtable.moveArrayItem( t, startIndex, endIndex );
+        }
+        */
+
+        $table.trigger('updateAll', [ false, function() {
+          if ( hasFilters ) {
+            setTimeout( function() {
+              // just update the filter values
+              c.lastCombinedFilter = null;
+              c.$table.data('lastSearch', filters);
+              ts.setFilters( $table, filters );
+              if ($.isFunction(_this.options.tablesorterComplete)) {
+                _this.options.tablesorterComplete( c.table );
+              }
+            }, 10 );
+          }
+        } ]);
+      }
+    },
+    getOrder : function( table ) {
+      return $( table ).children( 'thead' ).children( '.' + ts.css.headerRow ).children().map( function() {
+        return $( this ).attr( 'data-column' );
+      }).get() || [];
+    },
+    // bubble the moved col left or right
+    startColumnMove : function( dragTable ) {
+      var $cols,
+        c = dragTable.el[ 0 ].config,
+        startIndex = dragTable.startIndex - 1,
+        endIndex = dragTable.endIndex - 1,
+        cols = c.columns - 1,
+        pos = endIndex === cols ? false : endIndex <= startIndex,
+        $rows = c.$table.children().children( 'tr' );
+      if ( c.debug ) {
+        ts.log( 'Inserting column ' + startIndex + ( pos ? ' before' : ' after' ) + ' column ' + endIndex );
+      }
+      $rows.each( function() {
+        $cols = $( this ).children();
+        $cols.eq( startIndex )[ pos ? 'insertBefore' : 'insertAfter' ]( $cols.eq( endIndex ) );
+      });
+      // rearrange col in colgroup
+      $cols = c.$table.children( 'colgroup' ).children();
+      $cols.eq( startIndex )[ pos ? 'insertBefore' : 'insertAfter' ]( $cols.eq( endIndex ) );
+    },
+    swapNodes : function( a, b ) {
+      var indx, aparent, asibling,
+        len = a.length;
+      for ( indx = 0; indx < len; indx++ ) {
+        aparent = a[ indx ].parentNode;
+        asibling = a[ indx ].nextSibling === b[ indx ] ? a[ indx ] : a[ indx ].nextSibling;
+        b[ indx ].parentNode.insertBefore( a[ indx ], b[ indx ] );
+        aparent.insertBefore( b[ indx ], asibling );
+      }
+    },
+    // http://stackoverflow.com/a/5306832/145346
+    moveArrayItem : function( array, oldIndex, newIndex ) {
+      var indx, len = array.length;
+      if ( newIndex >= len ) {
+        indx = newIndex - len;
+        while ( ( indx-- ) + 1 ) {
+          array.push( undef );
+        }
+      }
+      array.splice( newIndex, 0, array.splice( oldIndex, 1 )[ 0 ] );
+      return array;
+    },
+    reindexArrayItem : function( array, oldIndex, newIndex ) {
+      var nIndx = $.inArray( newIndex, array ),
+        oIndx = $.inArray( oldIndex, array ),
+        max = Math.max.apply( Math, array ),
+        arry = [];
+      // columns in the array were swapped so return original array
+      if ( nIndx >= 0 && oIndx >= 0 ) {
+       return array;
+      }
+      // columns not in the array were moved
+      $.each( array, function( indx, value ) {
+        // column (not in array) inserted between indexes
+        if ( newIndex < oldIndex ) {
+          // ( [ 0,1,2,3 ], 5, 1 ) -> column inserted between 0 & 1 => [ 0,2,3,4 ]
+          if ( value >= newIndex ) {
+            // 5 -> 1  [ 0, 2, 3 ] then 1 -> 0 [ 1, 2, 3 ]
+            arry.push( value + ( value < oldIndex ? 1 : 0 ) );
+          } else {
+            arry.push( value );
+          }
+        } else if ( newIndex > oldIndex ) {
+          // ( [ 0,1,2,3 ], 1, 5 ) -> column in array moved outside => [ 0,1,2,5 ]
+          if ( value === oldIndex ) {
+            arry.push( newIndex );
+          } else if ( value < newIndex && value >= oldIndex ) {
+            arry.push( value - 1 );
+          } else if ( value <= newIndex ) {
+            arry.push( value );
+          } else if ( value > oldIndex ) {
+            arry.push( value + ( value < newIndex ? 0 : 1 ) );
+          }
+        }
+      });
+      return arry.sort();
+    }
+  };
+
+/*!
+ * dragtable
+ *  _____       _
+ * |     |___ _| |
+ * | | | | . | . |
+ * |_|_|_|___|___|
+ *
+ * @Version 2.0.14 MOD
+ *
+ * Copyright (c) 2010-2013, Andres akottr@gmail.com
+ * Dual licensed under the MIT (MIT-LICENSE.txt)
+ * and GPL (GPL-LICENSE.txt) licenses.
+ *
+ * Inspired by the the dragtable from Dan Vanderkam (danvk.org/dragtable/)
+ * Thanks to the jquery and jqueryui comitters
+ *
+ * Any comment, bug report, feature-request is welcome
+ * Feel free to contact me.
+ */
+
+/* TOKNOW:
+ * For IE7 you need this css rule:
+ * table {
+ *   border-collapse: collapse;
+ * }
+ * Or take a clean reset.css (see http://meyerweb.com/eric/tools/css/reset/)
+ */
+
+/* TODO: investigate
+ * Does not work properly with css rule:
+ * html {
+ *      overflow: -moz-scrollbars-vertical;
+ *  }
+ * Workaround:
+ * Fixing Firefox issues by scrolling down the page
+ * http://stackoverflow.com/questions/2451528/jquery-ui-sortable-scroll-helper-element-offset-firefox-issue
+ *
+ * var start = $.noop;
+ * var beforeStop = $.noop;
+ * if($.browser.mozilla) {
+ * var start = function (event, ui) {
+ *               if( ui.helper !== undefined )
+ *                 ui.helper.css('position','absolute').css('margin-top', $(window).scrollTop() );
+ *               }
+ * var beforeStop = function (event, ui) {
+ *              if( ui.offset !== undefined )
+ *                ui.helper.css('margin-top', 0);
+ *              }
+ * }
+ *
+ * and pass this as start and stop function to the sortable initialisation
+ * start: start,
+ * beforeStop: beforeStop
+ */
+/*
+ * Special thx to all pull requests comitters
+ */
+
+  $.widget("akottr.dragtable", {
+    options: {
+      revert: false,               // smooth revert
+      dragHandle: '.table-handle', // handle for moving cols, if not exists the whole 'th' is the handle
+      maxMovingRows: 40,           // 1 -> only header. 40 row should be enough, the rest is usually not in the viewport
+      excludeFooter: false,        // excludes the footer row(s) while moving other columns. Make sense if there is a footer with a colspan. */
+      onlyHeaderThreshold: 100,    // TODO:  not implemented yet, switch automatically between entire col moving / only header moving
+      dragaccept: null,            // draggable cols -> default all
+      persistState: null,          // url or function -> plug in your custom persistState function right here. function call is persistState(originalTable)
+      restoreState: null,          // JSON-Object or function:  some kind of experimental aka Quick-Hack TODO: do it better
+      exact: true,                 // removes pixels, so that the overlay table width fits exactly the original table width
+      clickDelay: 10,              // ms to wait before rendering sortable list and delegating click event
+      containment: null,           // @see http://api.jqueryui.com/sortable/#option-containment, use it if you want to move in 2 dimesnions (together with axis: null)
+      cursor: 'move',              // @see http://api.jqueryui.com/sortable/#option-cursor
+      cursorAt: false,             // @see http://api.jqueryui.com/sortable/#option-cursorAt
+      distance: 0,                 // @see http://api.jqueryui.com/sortable/#option-distance, for immediate feedback use "0"
+      tolerance: 'pointer',        // @see http://api.jqueryui.com/sortable/#option-tolerance
+      axis: 'x',                   // @see http://api.jqueryui.com/sortable/#option-axis, Only vertical moving is allowed. Use 'x' or null. Use this in conjunction with the 'containment' setting
+      beforeStart: $.noop,         // returning FALSE will stop the execution chain.
+      beforeMoving: $.noop,
+      beforeReorganize: $.noop,
+      beforeStop: $.noop,
+      // new options
+      tablesorterComplete: null,
+      sortClass : '.sorter'
+    },
+    originalTable: {
+      el: null,
+      selectedHandle: null,
+      sortOrder: null,
+      startIndex: 0,
+      endIndex: 0
+    },
+    sortableTable: {
+      el: $(),
+      selectedHandle: $(),
+      movingRow: $()
+    },
+    persistState: function() {
+      var _this = this;
+      this.originalTable.el.find('th').each(function(i) {
+        if (this.id !== '') {
+          _this.originalTable.sortOrder[this.id] = i;
+        }
+      });
+      $.ajax({
+        url: this.options.persistState,
+        data: this.originalTable.sortOrder
+      });
+    },
+    /*
+     * persistObj looks like
+     * {'id1':'2','id3':'3','id2':'1'}
+     * table looks like
+     * |   id2  |   id1   |   id3   |
+     */
+    _restoreState: function(persistObj) {
+      for (var n in persistObj) {
+        if (n in persistObj) {
+          this.originalTable.startIndex = $('#' + n).closest('th').prevAll().length + 1;
+          this.originalTable.endIndex = parseInt(persistObj[n], 10) + 1;
+          this._bubbleCols();
+        }
+      }
+    },
+    // bubble the moved col left or right
+    _bubbleCols: function() {
+      ts.dragtable.startColumnMove(this.originalTable);
+    },
+    _rearrangeTableBackroundProcessing: function() {
+      var _this = this;
+      return function() {
+        _this._bubbleCols();
+        _this.options.beforeStop(_this.originalTable);
+        _this.sortableTable.el.remove();
+        restoreTextSelection();
+        ts.dragtable.update(_this);
+        // persist state if necessary
+        if ($.isFunction(_this.options.persistState)) {
+          _this.options.persistState(_this.originalTable);
+        } else {
+          _this.persistState();
+        }
+
+      };
+    },
+    _rearrangeTable: function() {
+      var _this = this;
+      return function() {
+        // remove handler-class -> handler is now finished
+        _this.originalTable.selectedHandle.removeClass('dragtable-handle-selected');
+        // add disabled class -> reorgorganisation starts soon
+        _this.sortableTable.el.sortable("disable");
+        _this.sortableTable.el.addClass('dragtable-disabled');
+        _this.options.beforeReorganize(_this.originalTable, _this.sortableTable);
+        // do reorganisation asynchronous
+        // for chrome a little bit more than 1 ms because we want to force a rerender
+        _this.originalTable.endIndex = _this.sortableTable.movingRow.prevAll().length + 1;
+        setTimeout(_this._rearrangeTableBackroundProcessing(), 50);
+      };
+    },
+    /*
+     * Disrupts the table. The original table stays the same.
+     * But on a layer above the original table we are constructing a list (ul > li)
+     * each li with a separate table representig a single col of the original table.
+     */
+    _generateSortable: function(e) {
+      if (e.cancelBubble) {
+        e.cancelBubble = true;
+      } else {
+        e.stopPropagation();
+      }
+      var _this = this;
+      // table attributes
+      var attrs = this.originalTable.el[0].attributes;
+      var tableAttrsString = '';
+      for (var i = 0; i < attrs.length; i++) {
+        if ( (attrs[i].value || attrs[i].nodeValue) && attrs[i].nodeName != 'id' && attrs[i].nodeName != 'width') {
+          tableAttrsString += attrs[i].nodeName + '="' + ( attrs[i].value || attrs[i].nodeValue ) + '" ';
+        }
+      }
+      // row attributes
+      var rowAttrsArr = [];
+      //compute height, special handling for ie needed :-(
+      var heightArr = [];
+
+      // don't save tfoot attributes because it messes up indexing
+      _this.originalTable.el.children('thead, tbody').children('tr:visible').slice(0, _this.options.maxMovingRow).each(function() {
+        // row attributes
+        var attrs = this.attributes;
+        var attrsString = '';
+        for (var j = 0; j < attrs.length; j++) {
+          if ( (attrs[j].value || attrs[j].nodeValue ) && attrs[j].nodeName != 'id') {
+            attrsString += ' ' + attrs[j].nodeName + '="' + ( attrs[j].value || attrs[j].nodeValue ) + '"';
+          }
+        }
+        rowAttrsArr.push(attrsString);
+        heightArr.push($(this).height());
+      });
+
+      // compute width, no special handling for ie needed :-)
+      var widthArr = [];
+      // compute total width, needed for not wrapping around after the screen ends (floating)
+      var totalWidth = 0;
+      /* Find children thead and tbody.
+       * Only to process the immediate tr-children. Bugfix for inner tables
+       */
+      var thtb = _this.originalTable.el.children();
+      var headerRows = thtb.filter('thead').children('tr:visible');
+      var visibleRows = thtb.filter('tbody').children('tr:visible');
+
+      headerRows.eq(0).children('th, td').filter(':visible').each(function() {
+        var w = $(this).outerWidth();
+        widthArr.push(w);
+        totalWidth += w;
+      });
+      if(_this.options.exact) {
+        var difference = totalWidth - _this.originalTable.el.outerWidth();
+        widthArr[0] -= difference;
+      }
+      // one extra px on right and left side
+      totalWidth += 2;
+
+      var captionHeight = 0;
+      thtb.filter('caption').each(function(){
+        captionHeight += $(this).outerHeight();
+      });
+
+      var sortableHtml = '<ul class="dragtable-sortable" style="position:absolute; width:' + totalWidth + 'px;">';
+      var sortableColumn = [];
+      // assemble the needed html
+      // build list
+      var rowIndex,
+        columns = headerRows.eq(0).children('th, td').length;
+      /*jshint loopfunc:true */
+      for (i = 0; i < columns; i++) {
+        var row = headerRows.children(':nth-child(' + (i + 1) + ')');
+        if (row.is(':visible')) {
+          rowIndex = 0;
+          sortableColumn[i] = '<li style="width:' + row.outerWidth() + 'px;">' +
+            '<table ' + tableAttrsString + '>' +
+            ( captionHeight ? '<caption style="height:' + captionHeight + 'px;"></caption>' : '' ) +
+            '<thead>';
+          // thead
+          headerRows.each(function(j){
+            sortableColumn[i] += '<tr ' + rowAttrsArr[rowIndex++] +
+              ( heightArr[j] ? ' style="height:' + heightArr[j] + 'px;"' : '' ) + '>' +
+              row[j].outerHTML + '</tr>';
+          });
+          sortableColumn[i] += '</thead><tbody>';
+          // tbody
+          row = visibleRows.children(':nth-child(' + (i + 1) + ')');
+          if (_this.options.maxMovingRows > 1) {
+            row = row.add(visibleRows.children(':nth-child(' + (i + 1) + ')').slice(0, _this.options.maxMovingRows - 1));
+          }
+          row.each(function(j) {
+            sortableColumn[i] += '<tr ' + rowAttrsArr[rowIndex++] +
+              ( heightArr[j] ? ' style="height:' + heightArr[j] + 'px;"' : '' ) + '>' +
+              this.outerHTML + '</tr>';
+          });
+          sortableColumn[i] += '</tbody>';
+
+          // add footer to end of max Rows
+          if (!_this.options.excludeFooter) {
+            sortableColumn[i] += '<tfoot><tr ' + rowAttrsArr[rowIndex++] + '>' +
+              thtb.filter('tfoot').children('tr:visible').children()[i].outerHTML + '</tr></tfoot>';
+          }
+          sortableColumn[i] += '</table></li>';
+        }
+      }
+      sortableHtml += sortableColumn.join('') + '</ul>';
+      this.sortableTable.el = this.originalTable.el.before(sortableHtml).prev();
+      // set width if necessary
+      this.sortableTable.el.find('> li > table').each(function(i) {
+        $(this).css('width', widthArr[i] + 'px');
+      });
+
+      // assign this.sortableTable.selectedHandle
+      this.sortableTable.selectedHandle = this.sortableTable.el.find('th .dragtable-handle-selected');
+
+      var items = !this.options.dragaccept ? 'li' : 'li:has(' + this.options.dragaccept + ')';
+      this.sortableTable.el.sortable({
+        items: items,
+        stop: this._rearrangeTable(),
+        // pass thru options for sortable widget
+        revert: this.options.revert,
+        tolerance: this.options.tolerance,
+        containment: this.options.containment,
+        cursor: this.options.cursor,
+        cursorAt: this.options.cursorAt,
+        distance: this.options.distance,
+        axis: this.options.axis
+      });
+
+      // assign start index
+      this.originalTable.startIndex = $(e.target).closest('th,td').prevAll().length + 1;
+      this.options.beforeMoving(this.originalTable, this.sortableTable);
+      // Start moving by delegating the original event to the new sortable table
+      this.sortableTable.movingRow = this.sortableTable.el.children('li:nth-child(' + this.originalTable.startIndex + ')');
+
+      // prevent the user from drag selecting "highlighting" surrounding page elements
+      disableTextSelection();
+      // clone the initial event and trigger the sort with it
+      this.sortableTable.movingRow.trigger($.extend($.Event(e.type), {
+        which: 1,
+        clientX: e.clientX,
+        clientY: e.clientY,
+        pageX: e.pageX,
+        pageY: e.pageY,
+        screenX: e.screenX,
+        screenY: e.screenY
+      }));
+
+      // Some inner divs to deliver the posibillity to style the placeholder more sophisticated
+      var placeholder = this.sortableTable.el.find('.ui-sortable-placeholder');
+      if(placeholder.height() > 0) {
+        placeholder.css('height', this.sortableTable.el.find('.ui-sortable-helper').height());
+      }
+
+      placeholder.html('<div class="outer" style="height:100%;"><div class="inner" style="height:100%;"></div></div>');
+    },
+    bindTo: {},
+    _create: function() {
+      var _this = this;
+      _this.originalTable = {
+        el: _this.element,
+        selectedHandle: $(),
+        sortOrder: {},
+        startIndex: 0,
+        endIndex: 0
+      };
+      ts.dragtable.create( _this );
+      // filter only the cols that are accepted
+      _this.bindTo = '> thead > tr > ' + ( _this.options.dragaccept || 'th, td' );
+      // bind draggable to handle if exists
+      if (_this.element.find(_this.bindTo).find(_this.options.dragHandle).length) {
+        _this.bindTo += ' ' + _this.options.dragHandle;
+      }
+      // restore state if necessary
+      if ($.isFunction(_this.options.restoreState)) {
+        _this.options.restoreState(_this.originalTable);
+      } else {
+        _this._restoreState(_this.options.restoreState);
+      }
+      _this.originalTable.el.on( 'mousedown.dragtable', _this.bindTo, function(evt) {
+        // listen only to left mouse click
+        if (evt.which!==1) return;
+        ts.dragtable.start( _this.originalTable.el );
+        if (_this.options.beforeStart(_this.originalTable) === false) {
+          return;
+        }
+        clearTimeout(_this.downTimer);
+        _this.downTimer = setTimeout(function() {
+          _this.originalTable.selectedHandle = $(_this);
+          _this.originalTable.selectedHandle.addClass('dragtable-handle-selected');
+          _this._generateSortable(evt);
+        }, _this.options.clickDelay);
+      }).on( 'mouseup.dragtable', _this.options.dragHandle,function() {
+        clearTimeout(_this.downTimer);
+      });
+    },
+    redraw: function(){
+      this.destroy();
+      this._create();
+    },
+    destroy: function() {
+      this.originalTable.el.off('mousedown.dragtable mouseup.dragtable', this.bindTo);
+      $.Widget.prototype.destroy.apply(this, arguments); // default destroy
+      // now do other stuff particular to this widget
+    }
+  });
+
+  /** closure-scoped "private" functions **/
+  var body_onselectstart_save = $(document.body).attr('onselectstart'),
+  body_unselectable_save = $(document.body).attr('unselectable');
+
+  // css properties to disable user-select on the body tag by appending a <style> tag to the <head>
+  // remove any current document selections
+  function disableTextSelection() {
+    // jQuery doesn't support the element.text attribute in MSIE 8
+    // http://stackoverflow.com/questions/2692770/style-style-textcss-appendtohead-does-not-work-in-ie
+    var $style = $('<style id="__dragtable_disable_text_selection__" type="text/css">body { -ms-user-select:none;-moz-user-select:-moz-none;-khtml-user-select:none;-webkit-user-select:none;user-select:none; }</style>');
+    $(document.head).append($style);
+    $(document.body).attr('onselectstart', 'return false;').attr('unselectable', 'on');
+    if (window.getSelection) {
+      window.getSelection().removeAllRanges();
+    } else {
+      document.selection.empty(); // MSIE http://msdn.microsoft.com/en-us/library/ms535869%28v=VS.85%29.aspx
+    }
+  }
+
+  // remove the <style> tag, and restore the original <body> onselectstart attribute
+  function restoreTextSelection() {
+    $('#__dragtable_disable_text_selection__').remove();
+    if (body_onselectstart_save) {
+      $(document.body).attr('onselectstart', body_onselectstart_save);
+    } else {
+      $(document.body).removeAttr('onselectstart');
+    }
+    if (body_unselectable_save) {
+      $(document.body).attr('unselectable', body_unselectable_save);
+    } else {
+      $(document.body).removeAttr('unselectable');
+    }
+  }
+
+})(jQuery);