effective_datatables 4.3.4 → 4.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4dabd6230608916ad4260f443412c2b81bb4ec80
-  data.tar.gz: 26a82f35207f348157706794fcb818a1b58e77db
+  metadata.gz: 7ce4be5421f36169833da3142e5f171f63f794a6
+  data.tar.gz: ca64b139e8056c55d46723abfca5ead307b8667b
 SHA512:
-  metadata.gz: 17fd09f4caa9cfd14798fe9744a627e355f4f90504cb40a02943b35155fe25d15a4e7708bfab3d4a167b1acd3a9260ba2d8fa95117566cb085b21679099258de
-  data.tar.gz: b31833cadf5f81ba9e5e7cb69260891fb2498647b872243afd9cec216070ff8c9d40be2da3137b78b06ff60b21f766d2ea081cbc2f6c2dd77e3a10b68868dbaf
+  metadata.gz: 9036c5d175ae16eb22ea83892b49e72c5916dd4d53bfda0863fe7d7f6f6c26abf68715cdb29b2de15822b4486353b18042b473d8f8ff1569c0cca7ded5c943fb
+  data.tar.gz: b7519014581a8e3e07f496bf17dba5d8a847ad129c07ed0604ae9bdb273d7968743b3e7fe7aece5adb35ad471a1844be0d4cfc4512df3557fd203da68aa53e59

data/README.md

@@ -571,6 +571,24 @@ When not specified, effective_datatables will sort by the first defined column.
 order :created_at, :asc|:desc
 ```
 
+### reorder
+
+Enables drag-and-drop row re-ordering.
+
+Only works with ActiveRecord collections.
+
+The underlying field must be an Integer, and it's assumed to be a sequential list of unique numbers.
+
+When a drag and drop is completed, a POST request is made to the datatables#reorder action that will update the indexes.
+
+Both zero and one based lists will work.
+
+```ruby
+reorder :position
+```
+
+Using `reorder` will sort the collection by this field and disable all other column sorting.
+
 ### aggregate
 
 The `aggregate` command inserts a row in the table's `tfoot`.
@@ -658,7 +676,7 @@ filters do
   filter :end_date, nil, parse: -> { |term| Time.zone.local(term).end_of_day }
   filter :user, current_user, as: :select, collection: User.all
   filter :year, 2018, as: :select, collection: [2018, 2017], label: false, include_blank: false
-  filter :reports, '2018', as: :grouped_select, collection: [['Years', [['2017', '2017'], ['2018', '2018']]], ['Months', [['January', '1'], ['February', '2']]]], group_method: :last
+  filter :year_group, '2018', as: :select, grouped: true, collection: { 'Years' => [['2017', 2017], ['2018', 2018]], 'Months' => [['January', 1], ['February', 2]] }
 end
 ```
 

data/app/assets/javascripts/dataTables/buttons/buttons.bootstrap4.js

@@ -57,6 +57,7 @@ $.extend( true, DataTable.Buttons.defaults, {
 } );
 
 DataTable.ext.buttons.collection.className += ' dropdown-toggle';
+DataTable.ext.buttons.collection.rightAlignClassName = 'dropdown-menu-right';
 
 return DataTable.Buttons;
 }));

data/app/assets/javascripts/dataTables/buttons/buttons.colVis.js

@@ -108,6 +108,7 @@ $.extend( DataTable.ext.buttons, {
 		},
 		init: function ( dt, button, conf ) {
 			var that = this;
+			button.attr( 'data-cv-idx', conf.columns );
 
 			dt
 				.on( 'column-visibility.dt'+conf.namespace, function (e, settings) {
@@ -122,8 +123,17 @@ $.extend( DataTable.ext.buttons, {
 						return;
 					}
 
-					that.text( conf._columnText( dt, conf ) );
-					that.active( dt.column( conf.columns ).visible() );
+					conf.columns = $.inArray( conf.columns, details.mapping );
+					button.attr( 'data-cv-idx', conf.columns );
+
+					// Reorder buttons for new table order
+					button
+						.parent()
+						.children('[data-cv-idx]')
+						.sort( function (a, b) {
+							return (a.getAttribute('data-cv-idx')*1) - (b.getAttribute('data-cv-idx')*1);
+						} )
+						.appendTo(button.parent());
 				} );
 
 			this.active( dt.column( conf.columns ).visible() );

data/app/assets/javascripts/dataTables/buttons/buttons.html5.js

@@ -48,6 +48,20 @@ function _pdfMake () {
 	return pdfmake || window.pdfMake;
 }
 
+DataTable.Buttons.pdfMake = function (_) {
+	if ( ! _ ) {
+		return _pdfMake();
+	}
+	pdfmake = m_ake;
+}
+
+DataTable.Buttons.jszip = function (_) {
+	if ( ! _ ) {
+		return _jsZip();
+	}
+	jszip = _;
+}
+
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  * FileSaver.js dependency
@@ -422,6 +436,9 @@ function _addToZip( zip, obj ) {
 
 				// Return namespace attributes to being as such
 				str = str.replace( /_dt_b_namespace_token_/g, ':' );
+
+				// Remove testing name space that IE puts into the space preserve attr
+				str = str.replace( /xmlns:NS[\d]+="" NS[\d]+:/g, '' );
 			}
 
 			// Safari, IE and Edge will put empty name space attributes onto
@@ -505,11 +522,11 @@ function _excelColWidth( data, col ) {
 
 		// Max width rather than having potentially massive column widths
 		if ( max > 40 ) {
-			return 52; // 40 * 1.3
+			return 54; // 40 * 1.35
 		}
 	}
 
-	max *= 1.3;
+	max *= 1.35;
 
 	// And a min width
 	return max > 6 ? max : 6;
@@ -550,8 +567,9 @@ var excelStrings = {
 				'<workbookView xWindow="0" yWindow="0" windowWidth="25600" windowHeight="19020" tabRatio="500"/>'+
 			'</bookViews>'+
 			'<sheets>'+
-				'<sheet name="" sheetId="1" r:id="rId1"/>'+
+				'<sheet name="Sheet1" sheetId="1" r:id="rId1"/>'+
 			'</sheets>'+
+			'<definedNames/>'+
 		'</workbook>',
 
 	"xl/worksheets/sheet1.xml":
@@ -992,6 +1010,7 @@ DataTable.ext.buttons.excelHtml5 = {
 
 		var that = this;
 		var rowPos = 0;
+		var dataStartRow, dataEndRow;
 		var getXml = function ( type ) {
 			var str = excelStrings[ type ];
 
@@ -1124,8 +1143,6 @@ DataTable.ext.buttons.excelHtml5 = {
 			rowPos++;
 		};
 
-		$( 'sheets sheet', xlsx.xl['workbook.xml'] ).attr( 'name', _sheetname( config ) );
-
 		if ( config.customizeData ) {
 			config.customizeData( data );
 		}
@@ -1154,16 +1171,21 @@ DataTable.ext.buttons.excelHtml5 = {
 			mergeCells( rowPos, data.header.length-1 );
 		}
 
+
 		// Table itself
 		if ( config.header ) {
 			addRow( data.header, rowPos );
 			$('row:last c', rels).attr( 's', '2' ); // bold
 		}
 
+		dataStartRow = rowPos;
+
 		for ( var n=0, ie=data.body.length ; n<ie ; n++ ) {
 			addRow( data.body[n], rowPos );
 		}
 
+		dataEndRow = rowPos;
+
 		if ( config.footer && data.footer ) {
 			addRow( data.footer, rowPos);
 			$('row:last c', rels).attr( 's', '2' ); // bold
@@ -1190,6 +1212,29 @@ DataTable.ext.buttons.excelHtml5 = {
 			} ) );
 		}
 
+		// Auto filter for columns
+		$('mergeCells', rels).before( _createNode( rels, 'autoFilter', {
+			attr: {
+				ref: 'A'+dataStartRow+':'+createCellPos(data.header.length-1)+dataEndRow
+			}
+		} ) );
+
+		// Workbook modifications
+		var workbook = xlsx.xl['workbook.xml'];
+
+		$( 'sheets sheet', workbook ).attr( 'name', _sheetname( config ) );
+
+		if ( config.autoFilter ) {
+			$('definedNames', workbook).append( _createNode( workbook, 'definedName', {
+				attr: {
+					name: '_xlnm._FilterDatabase',
+					localSheetId: '0',
+					hidden: 1
+				},
+				text: _sheetname(config)+'!$A$'+dataStartRow+':'+createCellPos(data.header.length-1)+dataEndRow
+			} ) );
+		}
+
 		// Let the developer customise the document if they want to
 		if ( config.customize ) {
 			config.customize( xlsx, config, dt );
@@ -1244,7 +1289,11 @@ DataTable.ext.buttons.excelHtml5 = {
 
 	messageBottom: '*',
 
-	createEmptyCells: false
+	createEmptyCells: false,
+
+	autoFilter: false,
+
+	sheetName: ''
 };
 
 //
@@ -1280,6 +1329,9 @@ DataTable.ext.buttons.pdfHtml5 = {
 
 		for ( var i=0, ien=data.body.length ; i<ien ; i++ ) {
 			rows.push( $.map( data.body[i], function ( d ) {
+				if ( d === null || d === undefined ) {
+					d = '';
+				}
 				return {
 					text: typeof d === 'string' ? d : d+'',
 					style: i % 2 ? 'tableBodyEven' : 'tableBodyOdd'

data/app/assets/javascripts/dataTables/buttons/buttons.print.js

@@ -91,9 +91,13 @@ DataTable.ext.buttons.print = {
 			$.extend( {decodeEntities: false}, config.exportOptions ) // XSS protection
 		);
 		var exportInfo = dt.buttons.exportInfo( config );
-		var columnClasses = $.map( dt.settings()[0].aoColumns, function (col, key) {
-			return col.sClass;
-		} );
+		var columnClasses = dt
+			.columns( config.exportOptions.columns )
+			.flatten()
+			.map( function (idx) {
+				return dt.settings()[0].aoColumns[dt.column(idx).index()].sClass;
+			} )
+			.toArray();
 
 		var addRow = function ( d, tag ) {
 			var str = '<tr>';
@@ -169,12 +173,19 @@ DataTable.ext.buttons.print = {
 		}
 
 		// Allow stylesheets time to load
-		win.setTimeout( function () {
+		var autoPrint = function () {
 			if ( config.autoPrint ) {
 				win.print(); // blocking - so close will not
 				win.close(); // execute until this is done
 			}
-		}, 1000 );
+		};
+
+		if ( navigator.userAgent.match(/Trident\/\d.\d/) ) { // IE needs to call this without a setTimeout
+			autoPrint();
+		}
+		else {
+			win.setTimeout( autoPrint, 1000 );
+		}
 	},
 
 	title: '*',

data/app/assets/javascripts/dataTables/buttons/dataTables.buttons.js

@@ -1,4 +1,4 @@
-/*! Buttons for DataTables 1.5.2
+/*! Buttons for DataTables 1.5.4
  * ©2016-2018 SpryMedia Ltd - datatables.net/license
  */
 
@@ -489,7 +489,7 @@ $.extend( Buttons.prototype, {
 				var collectionDom = this.c.dom.collection;
 				built.collection = $('<'+collectionDom.tag+'/>')
 					.addClass( collectionDom.className )
-					.attr( 'role', 'menu') ;
+					.attr( 'role', 'menu' ) ;
 				built.conf._collection = built.collection;
 
 				this._expandButton( built.buttons, built.conf.buttons, true, attachPoint );
@@ -908,20 +908,23 @@ $.extend( Buttons.prototype, {
  * @param  {string} Class to assign to the background
  * @static
  */
-Buttons.background = function ( show, className, fade ) {
+Buttons.background = function ( show, className, fade, insertPoint ) {
 	if ( fade === undefined ) {
 		fade = 400;
 	}
+	if ( ! insertPoint ) {
+		insertPoint = document.body;
+	}
 
 	if ( show ) {
 		$('<div/>')
 			.addClass( className )
 			.css( 'display', 'none' )
-			.appendTo( 'body' )
+			.insertAfter( insertPoint )
 			.fadeIn( fade );
 	}
 	else {
-		$('body > div.'+className)
+		$('div.'+className)
 			.fadeOut( fade, function () {
 				$(this)
 					.removeClass( className )
@@ -1145,7 +1148,10 @@ Buttons.defaults = {
 			className: 'dt-button-collection'
 		},
 		button: {
-			tag: 'button',
+			// Flash buttons will not work with `<button>` in IE - it has to be `<a>`
+			tag: 'ActiveXObject' in window ?
+				'a' :
+				'button',
 			className: 'dt-button',
 			active: 'active',
 			disabled: 'disabled'
@@ -1162,7 +1168,7 @@ Buttons.defaults = {
  * @type {string}
  * @static
  */
-Buttons.version = '1.5.2';
+Buttons.version = '1.5.4';
 
 
 $.extend( _dtButtons, {
@@ -1190,13 +1196,15 @@ $.extend( _dtButtons, {
 				insertPoint = document.body.lastChild;
 			}
 
+			config._collection.find('.dt-button-collection-title').remove();
+			config._collection.prepend('<div class="dt-button-collection-title">'+config.collectionTitle+'</div>');
+
 			config._collection
 				.addClass( config.collectionLayout )
 				.css( 'display', 'none' )
 				.insertAfter( insertPoint )
 				.fadeIn( config.fade );
 
-
 			var position = config._collection.css( 'position' );
 
 			if ( multiLevel && position === 'absolute' ) {
@@ -1226,6 +1234,12 @@ $.extend( _dtButtons, {
 					config._collection.css( 'top', hostPosition.top - config._collection.outerHeight() - 5);
 				}
 
+				// Right alignment is enabled on a class, e.g. bootstrap:
+				// $.fn.dataTable.Buttons.defaults.dom.collection.className += " dropdown-menu-right";
+				if ( config._collection.hasClass( config.rightAlignClassName ) ) {
+					config._collection.css( 'left', hostPosition.left + host.outerWidth() - config._collection.outerWidth() );
+				}
+
 				// Right alignment in table container
 				var listRight = hostPosition.left + config._collection.outerWidth();
 				var tableRight = tableContainer.offset().left + tableContainer.width();
@@ -1250,7 +1264,7 @@ $.extend( _dtButtons, {
 			}
 
 			if ( config.background ) {
-				Buttons.background( true, config.backgroundClassName, config.fade );
+				Buttons.background( true, config.backgroundClassName, config.fade, insertPoint );
 			}
 
 			var close = function () {
@@ -1260,7 +1274,7 @@ $.extend( _dtButtons, {
 				} );
 
 				$('div.dt-button-background').off( 'click.dtb-collection' );
-				Buttons.background( false, config.backgroundClassName, config.fade );
+				Buttons.background( false, config.backgroundClassName, config.fade, insertPoint );
 
 				$('body').off( '.dtb-collection' );
 				dt.off( 'buttons-action.b-internal' );
@@ -1299,7 +1313,9 @@ $.extend( _dtButtons, {
 		},
 		background: true,
 		collectionLayout: '',
+		collectionTitle: '',
 		backgroundClassName: 'dt-button-background',
+		rightAlignClassName: 'dt-button-right',
 		autoClose: false,
 		fade: 400,
 		attr: {

data/app/assets/javascripts/dataTables/rowReorder/dataTables.rowReorder.js

@@ -0,0 +1,818 @@
+/*! RowReorder 1.2.4
+ * 2015-2018 SpryMedia Ltd - datatables.net/license
+ */
+
+/**
+ * @summary     RowReorder
+ * @description Row reordering extension for DataTables
+ * @version     1.2.4
+ * @file        dataTables.rowReorder.js
+ * @author      SpryMedia Ltd (www.sprymedia.co.uk)
+ * @contact     www.sprymedia.co.uk/contact
+ * @copyright   Copyright 2015-2018 SpryMedia Ltd.
+ *
+ * This source file is free software, available under the following license:
+ *   MIT license - http://datatables.net/license/mit
+ *
+ * This source file is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the license files for details.
+ *
+ * For details please refer to: http://www.datatables.net
+ */
+
+(function( factory ){
+  if ( typeof define === 'function' && define.amd ) {
+    // AMD
+    define( ['jquery', 'datatables.net'], function ( $ ) {
+      return factory( $, window, document );
+    } );
+  }
+  else if ( typeof exports === 'object' ) {
+    // CommonJS
+    module.exports = function (root, $) {
+      if ( ! root ) {
+        root = window;
+      }
+
+      if ( ! $ || ! $.fn.dataTable ) {
+        $ = require('datatables.net')(root, $).$;
+      }
+
+      return factory( $, root, root.document );
+    };
+  }
+  else {
+    // Browser
+    factory( jQuery, window, document );
+  }
+}(function( $, window, document, undefined ) {
+'use strict';
+var DataTable = $.fn.dataTable;
+
+
+/**
+ * RowReorder provides the ability in DataTables to click and drag rows to
+ * reorder them. When a row is dropped the data for the rows effected will be
+ * updated to reflect the change. Normally this data point should also be the
+ * column being sorted upon in the DataTable but this does not need to be the
+ * case. RowReorder implements a "data swap" method - so the rows being
+ * reordered take the value of the data point from the row that used to occupy
+ * the row's new position.
+ *
+ * Initialisation is done by either:
+ *
+ * * `rowReorder` parameter in the DataTable initialisation object
+ * * `new $.fn.dataTable.RowReorder( table, opts )` after DataTables
+ *   initialisation.
+ *
+ *  @class
+ *  @param {object} settings DataTables settings object for the host table
+ *  @param {object} [opts] Configuration options
+ *  @requires jQuery 1.7+
+ *  @requires DataTables 1.10.7+
+ */
+var RowReorder = function ( dt, opts ) {
+  // Sanity check that we are using DataTables 1.10 or newer
+  if ( ! DataTable.versionCheck || ! DataTable.versionCheck( '1.10.8' ) ) {
+    throw 'DataTables RowReorder requires DataTables 1.10.8 or newer';
+  }
+
+  // User and defaults configuration object
+  this.c = $.extend( true, {},
+    DataTable.defaults.rowReorder,
+    RowReorder.defaults,
+    opts
+  );
+
+  // Internal settings
+  this.s = {
+    /** @type {integer} Scroll body top cache */
+    bodyTop: null,
+
+    /** @type {DataTable.Api} DataTables' API instance */
+    dt: new DataTable.Api( dt ),
+
+    /** @type {function} Data fetch function */
+    getDataFn: DataTable.ext.oApi._fnGetObjectDataFn( this.c.dataSrc ),
+
+    /** @type {array} Pixel positions for row insertion calculation */
+    middles: null,
+
+    /** @type {Object} Cached dimension information for use in the mouse move event handler */
+    scroll: {},
+
+    /** @type {integer} Interval object used for smooth scrolling */
+    scrollInterval: null,
+
+    /** @type {function} Data set function */
+    setDataFn: DataTable.ext.oApi._fnSetObjectDataFn( this.c.dataSrc ),
+
+    /** @type {Object} Mouse down information */
+    start: {
+      top: 0,
+      left: 0,
+      offsetTop: 0,
+      offsetLeft: 0,
+      nodes: []
+    },
+
+    /** @type {integer} Window height cached value */
+    windowHeight: 0,
+
+    /** @type {integer} Document outer height cached value */
+    documentOuterHeight: 0,
+
+    /** @type {integer} DOM clone outer height cached value */
+    domCloneOuterHeight: 0
+  };
+
+  // DOM items
+  this.dom = {
+    /** @type {jQuery} Cloned row being moved around */
+    clone: null,
+
+    /** @type {jQuery} DataTables scrolling container */
+    dtScroll: $('div.dataTables_scrollBody', this.s.dt.table().container())
+  };
+
+  // Check if row reorder has already been initialised on this table
+  var settings = this.s.dt.settings()[0];
+  var exisiting = settings.rowreorder;
+  if ( exisiting ) {
+    return exisiting;
+  }
+
+  settings.rowreorder = this;
+  this._constructor();
+};
+
+
+$.extend( RowReorder.prototype, {
+  /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+   * Constructor
+   */
+
+  /**
+   * Initialise the RowReorder instance
+   *
+   * @private
+   */
+  _constructor: function ()
+  {
+    var that = this;
+    var dt = this.s.dt;
+    var table = $( dt.table().node() );
+
+    // Need to be able to calculate the row positions relative to the table
+    if ( table.css('position') === 'static' ) {
+      table.css( 'position', 'relative' );
+    }
+
+    // listen for mouse down on the target column - we have to implement
+    // this rather than using HTML5 drag and drop as drag and drop doesn't
+    // appear to work on table rows at this time. Also mobile browsers are
+    // not supported.
+    // Use `table().container()` rather than just the table node for IE8 -
+    // otherwise it only works once...
+    $(dt.table().container()).on( 'mousedown.rowReorder touchstart.rowReorder', this.c.selector, function (e) {
+      if ( ! that.c.enable ) {
+        return;
+      }
+
+      // Ignore excluded children of the selector
+      if ( $(e.target).is(that.c.excludedChildren) ) {
+        return true;
+      }
+
+      var tr = $(this).closest('tr');
+      var row = dt.row( tr );
+
+      // Double check that it is a DataTable row
+      if ( row.any() ) {
+        that._emitEvent( 'pre-row-reorder', {
+          node: row.node(),
+          index: row.index()
+        } );
+
+        that._mouseDown( e, tr );
+        return false;
+      }
+    } );
+
+    dt.on( 'destroy.rowReorder', function () {
+      $(dt.table().container()).off( '.rowReorder' );
+      dt.off( '.rowReorder' );
+    } );
+  },
+
+
+  /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+   * Private methods
+   */
+
+  /**
+   * Cache the measurements that RowReorder needs in the mouse move handler
+   * to attempt to speed things up, rather than reading from the DOM.
+   *
+   * @private
+   */
+  _cachePositions: function ()
+  {
+    var dt = this.s.dt;
+
+    // Frustratingly, if we add `position:relative` to the tbody, the
+    // position is still relatively to the parent. So we need to adjust
+    // for that
+    var headerHeight = $( dt.table().node() ).find('thead').outerHeight();
+
+    // Need to pass the nodes through jQuery to get them in document order,
+    // not what DataTables thinks it is, since we have been altering the
+    // order
+    var nodes = $.unique( dt.rows( { page: 'current' } ).nodes().toArray() );
+    var tops = $.map( nodes, function ( node, i ) {
+      return $(node).position().top - headerHeight;
+    } );
+
+    var middles = $.map( tops, function ( top, i ) {
+      return tops.length < i-1 ?
+        (top + tops[i+1]) / 2 :
+        (top + top + $( dt.row( ':last-child' ).node() ).outerHeight() ) / 2;
+    } );
+
+    this.s.middles = middles;
+    this.s.bodyTop = $( dt.table().body() ).offset().top;
+    this.s.windowHeight = $(window).height();
+    this.s.documentOuterHeight = $(document).outerHeight();
+  },
+
+
+  /**
+   * Clone a row so it can be floated around the screen
+   *
+   * @param  {jQuery} target Node to be cloned
+   * @private
+   */
+  _clone: function ( target )
+  {
+    var dt = this.s.dt;
+    var clone = $( dt.table().node().cloneNode(false) )
+      .addClass( 'dt-rowReorder-float' )
+      .append('<tbody/>')
+      .append( target.clone( false ) );
+
+    // Match the table and column widths - read all sizes before setting
+    // to reduce reflows
+    var tableWidth = target.outerWidth();
+    var tableHeight = target.outerHeight();
+    var sizes = target.children().map( function () {
+      return $(this).width();
+    } );
+
+    clone
+      .width( tableWidth )
+      .height( tableHeight )
+      .find('tr').children().each( function (i) {
+        this.style.width = sizes[i]+'px';
+      } );
+
+    // Insert into the document to have it floating around
+    clone.appendTo( 'body' );
+
+    this.dom.clone = clone;
+    this.s.domCloneOuterHeight = clone.outerHeight();
+  },
+
+
+  /**
+   * Update the cloned item's position in the document
+   *
+   * @param  {object} e Event giving the mouse's position
+   * @private
+   */
+  _clonePosition: function ( e )
+  {
+    var start = this.s.start;
+    var topDiff = this._eventToPage( e, 'Y' ) - start.top;
+    var leftDiff = this._eventToPage( e, 'X' ) - start.left;
+    var snap = this.c.snapX;
+    var left;
+    var top = topDiff + start.offsetTop;
+
+    if ( snap === true ) {
+      left = start.offsetLeft;
+    }
+    else if ( typeof snap === 'number' ) {
+      left = start.offsetLeft + snap;
+    }
+    else {
+      left = leftDiff + start.offsetLeft;
+    }
+
+    if(top < 0) {
+      top = 0
+    }
+    else if(top + this.s.domCloneOuterHeight > this.s.documentOuterHeight) {
+      top = this.s.documentOuterHeight - this.s.domCloneOuterHeight;
+    }
+
+    this.dom.clone.css( {
+      top: top,
+      left: left
+    } );
+  },
+
+
+  /**
+   * Emit an event on the DataTable for listeners
+   *
+   * @param  {string} name Event name
+   * @param  {array} args Event arguments
+   * @private
+   */
+  _emitEvent: function ( name, args )
+  {
+    this.s.dt.iterator( 'table', function ( ctx, i ) {
+      $(ctx.nTable).triggerHandler( name+'.dt', args );
+    } );
+  },
+
+
+  /**
+   * Get pageX/Y position from an event, regardless of if it is a mouse or
+   * touch event.
+   *
+   * @param  {object} e Event
+   * @param  {string} pos X or Y (must be a capital)
+   * @private
+   */
+  _eventToPage: function ( e, pos )
+  {
+    if ( e.type.indexOf( 'touch' ) !== -1 ) {
+      return e.originalEvent.touches[0][ 'page'+pos ];
+    }
+
+    return e[ 'page'+pos ];
+  },
+
+
+  /**
+   * Mouse down event handler. Read initial positions and add event handlers
+   * for the move.
+   *
+   * @param  {object} e      Mouse event
+   * @param  {jQuery} target TR element that is to be moved
+   * @private
+   */
+  _mouseDown: function ( e, target )
+  {
+    var that = this;
+    var dt = this.s.dt;
+    var start = this.s.start;
+
+    var offset = target.offset();
+    start.top = this._eventToPage( e, 'Y' );
+    start.left = this._eventToPage( e, 'X' );
+    start.offsetTop = offset.top;
+    start.offsetLeft = offset.left;
+    start.nodes = $.unique( dt.rows( { page: 'current' } ).nodes().toArray() );
+
+    this._cachePositions();
+    this._clone( target );
+    this._clonePosition( e );
+
+    this.dom.target = target;
+    target.addClass( 'dt-rowReorder-moving' );
+
+    $( document )
+      .on( 'mouseup.rowReorder touchend.rowReorder', function (e) {
+        that._mouseUp(e);
+      } )
+      .on( 'mousemove.rowReorder touchmove.rowReorder', function (e) {
+        that._mouseMove(e);
+      } );
+
+    // Check if window is x-scrolling - if not, disable it for the duration
+    // of the drag
+    if ( $(window).width() === $(document).width() ) {
+      $(document.body).addClass( 'dt-rowReorder-noOverflow' );
+    }
+
+    // Cache scrolling information so mouse move doesn't need to read.
+    // This assumes that the window and DT scroller will not change size
+    // during an row drag, which I think is a fair assumption
+    var scrollWrapper = this.dom.dtScroll;
+    this.s.scroll = {
+      windowHeight: $(window).height(),
+      windowWidth:  $(window).width(),
+      dtTop:        scrollWrapper.length ? scrollWrapper.offset().top : null,
+      dtLeft:       scrollWrapper.length ? scrollWrapper.offset().left : null,
+      dtHeight:     scrollWrapper.length ? scrollWrapper.outerHeight() : null,
+      dtWidth:      scrollWrapper.length ? scrollWrapper.outerWidth() : null
+    };
+  },
+
+
+  /**
+   * Mouse move event handler - move the cloned row and shuffle the table's
+   * rows if required.
+   *
+   * @param  {object} e Mouse event
+   * @private
+   */
+  _mouseMove: function ( e )
+  {
+    this._clonePosition( e );
+
+    // Transform the mouse position into a position in the table's body
+    var bodyY = this._eventToPage( e, 'Y' ) - this.s.bodyTop;
+    var middles = this.s.middles;
+    var insertPoint = null;
+    var dt = this.s.dt;
+    var body = dt.table().body();
+
+    // Determine where the row should be inserted based on the mouse
+    // position
+    for ( var i=0, ien=middles.length ; i<ien ; i++ ) {
+      if ( bodyY < middles[i] ) {
+        insertPoint = i;
+        break;
+      }
+    }
+
+    if ( insertPoint === null ) {
+      insertPoint = middles.length;
+    }
+
+    // Perform the DOM shuffle if it has changed from last time
+    if ( this.s.lastInsert === null || this.s.lastInsert !== insertPoint ) {
+      if ( insertPoint === 0 ) {
+        this.dom.target.prependTo( body );
+      }
+      else {
+        var nodes = $.unique( dt.rows( { page: 'current' } ).nodes().toArray() );
+
+        if ( insertPoint > this.s.lastInsert ) {
+          this.dom.target.insertAfter( nodes[ insertPoint-1 ] );
+        }
+        else {
+          this.dom.target.insertBefore( nodes[ insertPoint ] );
+        }
+      }
+
+      this._cachePositions();
+
+      this.s.lastInsert = insertPoint;
+    }
+
+    this._shiftScroll( e );
+  },
+
+
+  /**
+   * Mouse up event handler - release the event handlers and perform the
+   * table updates
+   *
+   * @param  {object} e Mouse event
+   * @private
+   */
+  _mouseUp: function ( e )
+  {
+    var that = this;
+    var dt = this.s.dt;
+    var i, ien;
+    var dataSrc = this.c.dataSrc;
+
+    this.dom.clone.remove();
+    this.dom.clone = null;
+
+    this.dom.target.removeClass( 'dt-rowReorder-moving' );
+    //this.dom.target = null;
+
+    $(document).off( '.rowReorder' );
+    $(document.body).removeClass( 'dt-rowReorder-noOverflow' );
+
+    clearInterval( this.s.scrollInterval );
+    this.s.scrollInterval = null;
+
+    // Calculate the difference
+    var startNodes = this.s.start.nodes;
+    var endNodes = $.unique( dt.rows( { page: 'current' } ).nodes().toArray() );
+    var idDiff = {};
+    var fullDiff = [];
+    var diffNodes = [];
+    var getDataFn = this.s.getDataFn;
+    var setDataFn = this.s.setDataFn;
+
+    for ( i=0, ien=startNodes.length ; i<ien ; i++ ) {
+      if ( startNodes[i] !== endNodes[i] ) {
+        var id = dt.row( endNodes[i] ).id();
+        var endRowData = dt.row( endNodes[i] ).data();
+        var startRowData = dt.row( startNodes[i] ).data();
+
+        if ( id ) {
+          idDiff[ id ] = getDataFn( startRowData );
+        }
+
+        fullDiff.push( {
+          node: endNodes[i],
+          oldData: getDataFn( endRowData ),
+          newData: getDataFn( startRowData ),
+          newPosition: i,
+          oldPosition: $.inArray( endNodes[i], startNodes )
+        } );
+
+        diffNodes.push( endNodes[i] );
+      }
+    }
+
+    // Create event args
+    var eventArgs = [ fullDiff, {
+      dataSrc:    dataSrc,
+      nodes:      diffNodes,
+      values:     idDiff,
+      triggerRow: dt.row( this.dom.target )
+    } ];
+
+    // Emit event
+    this._emitEvent( 'row-reorder', eventArgs );
+
+    var update = function () {
+      if ( that.c.update ) {
+        for ( i=0, ien=fullDiff.length ; i<ien ; i++ ) {
+          var row = dt.row( fullDiff[i].node );
+          var rowData = row.data();
+
+          setDataFn( rowData, fullDiff[i].newData );
+
+          // Invalidate the cell that has the same data source as the dataSrc
+          dt.columns().every( function () {
+            if ( this.dataSrc() === dataSrc ) {
+              dt.cell( fullDiff[i].node, this.index() ).invalidate( 'data' );
+            }
+          } );
+        }
+
+        // Trigger row reordered event
+        that._emitEvent( 'row-reordered', eventArgs );
+
+        dt.draw( false );
+      }
+    };
+
+    // Editor interface
+    if ( this.c.editor ) {
+      // Disable user interaction while Editor is submitting
+      this.c.enable = false;
+
+      this.c.editor
+        .edit(
+          diffNodes,
+          false,
+          $.extend( {submit: 'changed'}, this.c.formOptions )
+        )
+        .multiSet( dataSrc, idDiff )
+        .one( 'preSubmitCancelled.rowReorder', function () {
+          that.c.enable = true;
+          that.c.editor.off( '.rowReorder' );
+          dt.draw( false );
+        } )
+        .one( 'submitUnsuccessful.rowReorder', function () {
+          dt.draw( false );
+        } )
+        .one( 'submitSuccess.rowReorder', function () {
+          update();
+        } )
+        .one( 'submitComplete', function () {
+          that.c.enable = true;
+          that.c.editor.off( '.rowReorder' );
+        } )
+        .submit();
+    }
+    else {
+      update();
+    }
+  },
+
+
+  /**
+   * Move the window and DataTables scrolling during a drag to scroll new
+   * content into view.
+   *
+   * This matches the `_shiftScroll` method used in AutoFill, but only
+   * horizontal scrolling is considered here.
+   *
+   * @param  {object} e Mouse move event object
+   * @private
+   */
+  _shiftScroll: function ( e )
+  {
+    var that = this;
+    var dt = this.s.dt;
+    var scroll = this.s.scroll;
+    var runInterval = false;
+    var scrollSpeed = 5;
+    var buffer = 65;
+    var
+      windowY = e.pageY - document.body.scrollTop,
+      windowVert,
+      dtVert;
+
+    // Window calculations - based on the mouse position in the window,
+    // regardless of scrolling
+    if ( windowY < buffer ) {
+      windowVert = scrollSpeed * -1;
+    }
+    else if ( windowY > scroll.windowHeight - buffer ) {
+      windowVert = scrollSpeed;
+    }
+
+    // DataTables scrolling calculations - based on the table's position in
+    // the document and the mouse position on the page
+    if ( scroll.dtTop !== null && e.pageY < scroll.dtTop + buffer ) {
+      dtVert = scrollSpeed * -1;
+    }
+    else if ( scroll.dtTop !== null && e.pageY > scroll.dtTop + scroll.dtHeight - buffer ) {
+      dtVert = scrollSpeed;
+    }
+
+    // This is where it gets interesting. We want to continue scrolling
+    // without requiring a mouse move, so we need an interval to be
+    // triggered. The interval should continue until it is no longer needed,
+    // but it must also use the latest scroll commands (for example consider
+    // that the mouse might move from scrolling up to scrolling left, all
+    // with the same interval running. We use the `scroll` object to "pass"
+    // this information to the interval. Can't use local variables as they
+    // wouldn't be the ones that are used by an already existing interval!
+    if ( windowVert || dtVert ) {
+      scroll.windowVert = windowVert;
+      scroll.dtVert = dtVert;
+      runInterval = true;
+    }
+    else if ( this.s.scrollInterval ) {
+      // Don't need to scroll - remove any existing timer
+      clearInterval( this.s.scrollInterval );
+      this.s.scrollInterval = null;
+    }
+
+    // If we need to run the interval to scroll and there is no existing
+    // interval (if there is an existing one, it will continue to run)
+    if ( ! this.s.scrollInterval && runInterval ) {
+      this.s.scrollInterval = setInterval( function () {
+        // Don't need to worry about setting scroll <0 or beyond the
+        // scroll bound as the browser will just reject that.
+        if ( scroll.windowVert ) {
+          document.body.scrollTop += scroll.windowVert;
+        }
+
+        // DataTables scrolling
+        if ( scroll.dtVert ) {
+          var scroller = that.dom.dtScroll[0];
+
+          if ( scroll.dtVert ) {
+            scroller.scrollTop += scroll.dtVert;
+          }
+        }
+      }, 20 );
+    }
+  }
+} );
+
+
+
+/**
+ * RowReorder default settings for initialisation
+ *
+ * @namespace
+ * @name RowReorder.defaults
+ * @static
+ */
+RowReorder.defaults = {
+  /**
+   * Data point in the host row's data source object for where to get and set
+   * the data to reorder. This will normally also be the sorting column.
+   *
+   * @type {Number}
+   */
+  dataSrc: 0,
+
+  /**
+   * Editor instance that will be used to perform the update
+   *
+   * @type {DataTable.Editor}
+   */
+  editor: null,
+
+  /**
+   * Enable / disable RowReorder's user interaction
+   * @type {Boolean}
+   */
+  enable: true,
+
+  /**
+   * Form options to pass to Editor when submitting a change in the row order.
+   * See the Editor `from-options` object for details of the options
+   * available.
+   * @type {Object}
+   */
+  formOptions: {},
+
+  /**
+   * Drag handle selector. This defines the element that when dragged will
+   * reorder a row.
+   *
+   * @type {String}
+   */
+  selector: 'td:first-child',
+
+  /**
+   * Optionally lock the dragged row's x-position. This can be `true` to
+   * fix the position match the host table's, `false` to allow free movement
+   * of the row, or a number to define an offset from the host table.
+   *
+   * @type {Boolean|number}
+   */
+  snapX: false,
+
+  /**
+   * Update the table's data on drop
+   *
+   * @type {Boolean}
+   */
+  update: true,
+
+  /**
+   * Selector for children of the drag handle selector that mouseDown events
+   * will be passed through to and drag will not activate
+   *
+   * @type {String}
+   */
+  excludedChildren: 'a'
+};
+
+
+/*
+ * API
+ */
+var Api = $.fn.dataTable.Api;
+
+// Doesn't do anything - work around for a bug in DT... Not documented
+Api.register( 'rowReorder()', function () {
+  return this;
+} );
+
+Api.register( 'rowReorder.enable()', function ( toggle ) {
+  if ( toggle === undefined ) {
+    toggle = true;
+  }
+
+  return this.iterator( 'table', function ( ctx ) {
+    if ( ctx.rowreorder ) {
+      ctx.rowreorder.c.enable = toggle;
+    }
+  } );
+} );
+
+Api.register( 'rowReorder.disable()', function () {
+  return this.iterator( 'table', function ( ctx ) {
+    if ( ctx.rowreorder ) {
+      ctx.rowreorder.c.enable = false;
+    }
+  } );
+} );
+
+
+/**
+ * Version information
+ *
+ * @name RowReorder.version
+ * @static
+ */
+RowReorder.version = '1.2.4';
+
+
+$.fn.dataTable.RowReorder = RowReorder;
+$.fn.DataTable.RowReorder = RowReorder;
+
+// Attach a listener to the document which listens for DataTables initialisation
+// events so we can automatically initialise
+$(document).on( 'init.dt.dtr', function (e, settings, json) {
+  if ( e.namespace !== 'dt' ) {
+    return;
+  }
+
+  var init = settings.oInit.rowReorder;
+  var defaults = DataTable.defaults.rowReorder;
+
+  if ( init || defaults ) {
+    var opts = $.extend( {}, init, defaults );
+
+    if ( init !== false ) {
+      new RowReorder( settings, opts  );
+    }
+  }
+} );
+
+
+return RowReorder;
+}));