jquery-datatables-rails 1.12.2 → 2.1.10.0.0

data/app/assets/javascripts/dataTables/extras/{ColReorder.js → dataTables.colReorder.js}

@@ -1,27 +1,27 @@
-/*
- * File:        ColReorder.js
- * Version:     1.0.8
- * CVS:         $Id$
- * Description: Allow columns to be reordered in a DataTable
- * Author:      Allan Jardine (www.sprymedia.co.uk)
- * Created:     Wed Sep 15 18:23:29 BST 2010
- * Modified:    $Date$ by $Author$
- * Language:    Javascript
- * License:     GPL v2 or BSD 3 point style
- * Project:     DataTables
- * Contact:     www.sprymedia.co.uk/contact
+/*! ColReorder 1.1.1
+ * ©2010-2014 SpryMedia Ltd - datatables.net/license
+ */
+
+/**
+ * @summary     ColReorder
+ * @description Provide the ability to reorder columns in a DataTable
+ * @version     1.1.1
+ * @file        dataTables.colReorder.js
+ * @author      SpryMedia Ltd (www.sprymedia.co.uk)
+ * @contact     www.sprymedia.co.uk/contact
+ * @copyright   Copyright 2010-2014 SpryMedia Ltd.
  *
- * Copyright 2010-2011 Allan Jardine, all rights reserved.
+ * This source file is free software, available under the following license:
+ *   MIT license - http://datatables.net/license/mit
  *
- * This source file is free software, under either the GPL v2 license or a
- * BSD style license, available at:
- *   http://datatables.net/license_gpl2
- *   http://datatables.net/license_bsd
+ * 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($, window, document) {
+(function(window, document, undefined) {
 
 
 /**
@@ -109,6 +109,7 @@ function fnDomSwitch( nParent, iFrom, iTo )
  */
 $.fn.dataTableExt.oApi.fnColReorder = function ( oSettings, iFrom, iTo )
 {
+	var v110 = $.fn.dataTable.Api ? true : false;
 	var i, iLen, j, jLen, iCols=oSettings.aoColumns.length, nTrs, oCol;
 
 	/* Sanity check in the input */
@@ -168,6 +169,18 @@ $.fn.dataTableExt.oApi.fnColReorder = function ( oSettings, iFrom, iTo )
 		{
 			oCol.aDataSort[j] = aiInvertMapping[ oCol.aDataSort[j] ];
 		}
+
+		// Update the column indexes
+		if ( v110 ) {
+			oCol.idx = aiInvertMapping[ oCol.idx ];
+		}
+	}
+
+	if ( v110 ) {
+		// Update 1.10 optimised sort class removal variable
+		$.each( oSettings.aLastSort, function (i, val) {
+			oSettings.aLastSort[i].src = aiInvertMapping[ val.src ];
+		} );
 	}
 
 	/* Update the Get and Set functions for each column */
@@ -176,8 +189,9 @@ $.fn.dataTableExt.oApi.fnColReorder = function ( oSettings, iFrom, iTo )
 		oCol = oSettings.aoColumns[i];
 		if ( typeof oCol.mData == 'number' ) {
 			oCol.mData = aiInvertMapping[ oCol.mData ];
-			oCol.fnGetData = oSettings.oApi._fnGetObjectDataFn( oCol.mData );
-			oCol.fnSetData = oSettings.oApi._fnSetObjectDataFn( oCol.mData );
+
+			// regenerate the get / set functions
+			oSettings.oApi._fnColumnOptions( oSettings, i, {} );
 		}
 	}
 
@@ -228,7 +242,6 @@ $.fn.dataTableExt.oApi.fnColReorder = function ( oSettings, iFrom, iTo )
 		}
 	}
 
-
 	/*
 	 * Move the internal array elements
 	 */
@@ -241,10 +254,28 @@ $.fn.dataTableExt.oApi.fnColReorder = function ( oSettings, iFrom, iTo )
 	/* Array array - internal data anodes cache */
 	for ( i=0, iLen=oSettings.aoData.length ; i<iLen ; i++ )
 	{
-		if ( $.isArray( oSettings.aoData[i]._aData ) ) {
-		  fnArraySwitch( oSettings.aoData[i]._aData, iFrom, iTo );
+		var data = oSettings.aoData[i];
+
+		if ( v110 ) {
+			// DataTables 1.10+
+			if ( data.anCells ) {
+				fnArraySwitch( data.anCells, iFrom, iTo );
+			}
+
+			// For DOM sourced data, the invalidate will reread the cell into
+			// the data array, but for data sources as an array, they need to
+			// be flipped
+			if ( data.src !== 'dom' && $.isArray( data._aData ) ) {
+				fnArraySwitch( data._aData, iFrom, iTo );
+			}
+		}
+		else {
+			// DataTables 1.9-
+			if ( $.isArray( data._aData ) ) {
+				fnArraySwitch( data._aData, iFrom, iTo );
+			}
+			fnArraySwitch( data._anHidden, iFrom, iTo );
 		}
-		fnArraySwitch( oSettings.aoData[i]._anHidden, iFrom, iTo );
 	}
 
 	/* Reposition the header elements in the header layout array */
@@ -261,6 +292,11 @@ $.fn.dataTableExt.oApi.fnColReorder = function ( oSettings, iFrom, iTo )
 		}
 	}
 
+	// In 1.10 we need to invalidate row cached data for sorting, filtering etc
+	if ( v110 ) {
+		var api = new $.fn.dataTable.Api( oSettings );
+		api.rows().invalidate();
+	}
 
 	/*
 	 * Update DataTables' event handlers
@@ -269,7 +305,7 @@ $.fn.dataTableExt.oApi.fnColReorder = function ( oSettings, iFrom, iTo )
 	/* Sort listener */
 	for ( i=0, iLen=iCols ; i<iLen ; i++ )
 	{
-		$(oSettings.aoColumns[i].nTh).unbind('click');
+		$(oSettings.aoColumns[i].nTh).off('click.DT');
 		this.oApi._fnSortAttachListener( oSettings, oSettings.aoColumns[i].nTh, i );
 	}
 
@@ -280,34 +316,58 @@ $.fn.dataTableExt.oApi.fnColReorder = function ( oSettings, iFrom, iTo )
 		"iTo": iTo,
 		"aiInvertMapping": aiInvertMapping
 	} ] );
-
-	if ( typeof oSettings.oInstance._oPluginFixedHeader != 'undefined' )
-	{
-		oSettings.oInstance._oPluginFixedHeader.fnUpdate();
-	}
 };
 
 
 
+var factory = function( $, DataTable ) {
+"use strict";
 
 /**
- * ColReorder provides column visiblity control for DataTables
+ * ColReorder provides column visibility control for DataTables
  * @class ColReorder
  * @constructor
- * @param {object} DataTables settings object
- * @param {object} ColReorder options
+ * @param {object} dt DataTables settings object
+ * @param {object} opts ColReorder options
  */
-ColReorder = function( oDTSettings, oOpts )
+var ColReorder = function( dt, opts )
 {
-	/* Santiy check that we are a new instance */
-	if ( !this.CLASS || this.CLASS != "ColReorder" )
-	{
-		alert( "Warning: ColReorder must be initialised with the keyword 'new'" );
+	var oDTSettings;
+
+	if ( $.fn.dataTable.Api ) {
+		oDTSettings = new $.fn.dataTable.Api( dt ).settings()[0];
+	}
+	// 1.9 compatibility
+	else if ( dt.fnSettings ) {
+		// DataTables object, convert to the settings object
+		oDTSettings = dt.fnSettings();
+	}
+	else if ( typeof dt === 'string' ) {
+		// jQuery selector
+		if ( $.fn.dataTable.fnIsDataTable( $(dt)[0] ) ) {
+			oDTSettings = $(dt).eq(0).dataTable().fnSettings();
+		}
+	}
+	else if ( dt.nodeName && dt.nodeName.toLowerCase() === 'table' ) {
+		// Table node
+		if ( $.fn.dataTable.fnIsDataTable( dt.nodeName ) ) {
+			oDTSettings = $(dt.nodeName).dataTable().fnSettings();
+		}
+	}
+	else if ( dt instanceof jQuery ) {
+		// jQuery object
+		if ( $.fn.dataTable.fnIsDataTable( dt[0] ) ) {
+			oDTSettings = dt.eq(0).dataTable().fnSettings();
+		}
+	}
+	else {
+		// DataTables settings object
+		oDTSettings = dt;
 	}
 
-	if ( typeof oOpts == 'undefined' )
-	{
-		oOpts = {};
+	// Convert from camelCase to Hungarian, just as DataTables does
+	if ( $.fn.dataTable.camelToHungarian ) {
+		$.fn.dataTable.camelToHungarian( ColReorder.defaults, opts || {} );
 	}
 
 
@@ -333,7 +393,7 @@ ColReorder = function( oDTSettings, oOpts )
 		 *  @type     object
 		 *  @default  {}
 		 */
-		"init": oOpts,
+		"init": $.extend( true, {}, ColReorder.defaults, opts ),
 
 		/**
 		 * Number of columns to fix (not allow to be reordered)
@@ -343,6 +403,14 @@ ColReorder = function( oDTSettings, oOpts )
 		 */
 		"fixed": 0,
 
+		/**
+		 * Number of columns to fix counting from right (not allow to be reordered)
+		 *  @property fixedRight
+		 *  @type     int
+		 *  @default  0
+		 */
+		"fixedRight": 0,
+
 		/**
 		 * Callback function for once the reorder has been done
 		 *  @property dropcallback
@@ -401,13 +469,12 @@ ColReorder = function( oDTSettings, oOpts )
 
 	/* Constructor logic */
 	this.s.dt = oDTSettings.oInstance.fnSettings();
+	this.s.dt._colReorder = this;
 	this._fnConstruct();
 
 	/* Add destroy callback */
-	oDTSettings.oApi._fnCallbackReg(oDTSettings, 'aoDestroyCallback', jQuery.proxy(this._fnDestroy, this), 'ColReorder');
+	oDTSettings.oApi._fnCallbackReg(oDTSettings, 'aoDestroyCallback', $.proxy(this._fnDestroy, this), 'ColReorder');
 
-	/* Store the instance for later use */
-	ColReorder.aoInstances.push( this );
 	return this;
 };
 
@@ -418,6 +485,23 @@ ColReorder.prototype = {
 	 * Public methods
 	 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
+	/**
+	 * Reset the column ordering to the original ordering that was detected on
+	 * start up.
+	 *  @return {this} Returns `this` for chaining.
+	 *
+	 *  @example
+	 *    // DataTables initialisation with ColReorder
+	 *    var table = $('#example').dataTable( {
+	 *        "sDom": 'Rlfrtip'
+	 *    } );
+	 *
+	 *    // Add click event to a button to reset the ordering
+	 *    $('#resetOrdering').click( function (e) {
+	 *        e.preventDefault();
+	 *        $.fn.dataTable.ColReorder( table ).fnReset();
+	 *    } );
+	 */
 	"fnReset": function ()
 	{
 		var a = [];
@@ -427,6 +511,72 @@ ColReorder.prototype = {
 		}
 
 		this._fnOrderColumns( a );
+
+		return this;
+	},
+
+	/**
+	 * `Deprecated` - Get the current order of the columns, as an array.
+	 *  @return {array} Array of column identifiers
+	 *  @deprecated `fnOrder` should be used in preference to this method.
+	 *      `fnOrder` acts as a getter/setter.
+	 */
+	"fnGetCurrentOrder": function ()
+	{
+		return this.fnOrder();
+	},
+
+	/**
+	 * Get the current order of the columns, as an array. Note that the values
+	 * given in the array are unique identifiers for each column. Currently
+	 * these are the original ordering of the columns that was detected on
+	 * start up, but this could potentially change in future.
+	 *  @return {array} Array of column identifiers
+	 *
+	 *  @example
+	 *    // Get column ordering for the table
+	 *    var order = $.fn.dataTable.ColReorder( dataTable ).fnOrder();
+	 *//**
+	 * Set the order of the columns, from the positions identified in the
+	 * ordering array given. Note that ColReorder takes a brute force approach
+	 * to reordering, so it is possible multiple reordering events will occur
+	 * before the final order is settled upon.
+	 *  @param {array} [set] Array of column identifiers in the new order. Note
+	 *    that every column must be included, uniquely, in this array.
+	 *  @return {this} Returns `this` for chaining.
+	 *
+	 *  @example
+	 *    // Swap the first and second columns
+	 *    $.fn.dataTable.ColReorder( dataTable ).fnOrder( [1, 0, 2, 3, 4] );
+	 *
+	 *  @example
+	 *    // Move the first column to the end for the table `#example`
+	 *    var curr = $.fn.dataTable.ColReorder( '#example' ).fnOrder();
+	 *    var first = curr.shift();
+	 *    curr.push( first );
+	 *    $.fn.dataTable.ColReorder( '#example' ).fnOrder( curr );
+	 *
+	 *  @example
+	 *    // Reverse the table's order
+	 *    $.fn.dataTable.ColReorder( '#example' ).fnOrder(
+	 *      $.fn.dataTable.ColReorder( '#example' ).fnOrder().reverse()
+	 *    );
+	 */
+	"fnOrder": function ( set )
+	{
+		if ( set === undefined )
+		{
+			var a = [];
+			for ( var i=0, iLen=this.s.dt.aoColumns.length ; i<iLen ; i++ )
+			{
+				a.push( this.s.dt.aoColumns[i]._ColReorder_iOrigCol );
+			}
+			return a;
+		}
+
+		this._fnOrderColumns( fnInvertKeyValues( set ) );
+
+		return this;
 	},
 
 
@@ -443,24 +593,30 @@ ColReorder.prototype = {
 	"_fnConstruct": function ()
 	{
 		var that = this;
-		var i, iLen;
+		var iLen = this.s.dt.aoColumns.length;
+		var i;
 
 		/* Columns discounted from reordering - counting left to right */
-		if ( typeof this.s.init.iFixedColumns != 'undefined' )
+		if ( this.s.init.iFixedColumns )
 		{
 			this.s.fixed = this.s.init.iFixedColumns;
 		}
 
+		/* Columns discounted from reordering - counting right to left */
+		this.s.fixedRight = this.s.init.iFixedColumnsRight ?
+			this.s.init.iFixedColumnsRight :
+			0;
+
 		/* Drop callback initialisation option */
-		if ( typeof this.s.init.fnReorderCallback != 'undefined' )
+		if ( this.s.init.fnReorderCallback )
 		{
 			this.s.dropCallback = this.s.init.fnReorderCallback;
 		}
 
 		/* Add event handlers for the drag and drop, and also mark the original column order */
-		for ( i=0, iLen=this.s.dt.aoColumns.length ; i<iLen ; i++ )
+		for ( i = 0; i < iLen; i++ )
 		{
-			if ( i > this.s.fixed-1 )
+			if ( i > this.s.fixed-1 && i < iLen - this.s.fixedRight )
 			{
 				this._fnMouseListener( i, this.s.dt.aoColumns[i].nTh );
 			}
@@ -476,7 +632,7 @@ ColReorder.prototype = {
 
 		/* An initial column order has been specified */
 		var aiOrder = null;
-		if ( typeof this.s.init.aiOrder != 'undefined' )
+		if ( this.s.init.aiOrder )
 		{
 			aiOrder = this.s.init.aiOrder.slice();
 		}
@@ -515,6 +671,9 @@ ColReorder.prototype = {
 				that._fnOrderColumns.call( that, resort );
 			}
 		}
+		else {
+			this._fnSetColumnIndexes();
+		}
 	},
 
 
@@ -530,7 +689,7 @@ ColReorder.prototype = {
 		if ( a.length != this.s.dt.aoColumns.length )
 		{
 			this.s.dt.oInstance.oApi._fnLog( this.s.dt, 1, "ColReorder - array reorder does not "+
-			 	"match known number of columns. Skipping." );
+				"match known number of columns. Skipping." );
 			return;
 		}
 
@@ -555,6 +714,8 @@ ColReorder.prototype = {
 
 		/* Save the state */
 		this.s.dt.oInstance.oApi._fnSaveState( this.s.dt );
+
+		this._fnSetColumnIndexes();
 	},
 
 
@@ -578,7 +739,7 @@ ColReorder.prototype = {
 			oState.aaSorting[i][0] = oSettings.aoColumns[ oState.aaSorting[i][0] ]._ColReorder_iOrigCol;
 		}
 
-		aSearchCopy = $.extend( true, [], oState.aoSearchCols );
+		var aSearchCopy = $.extend( true, [], oState.aoSearchCols );
 		oState.ColReorder = [];
 
 		for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
@@ -612,7 +773,7 @@ ColReorder.prototype = {
 	"_fnMouseListener": function ( i, nTh )
 	{
 		var that = this;
-		$(nTh).bind( 'mousedown.ColReorder', function (e) {
+		$(nTh).on( 'mousedown.ColReorder', function (e) {
 			e.preventDefault();
 			that._fnMouseDown.call( that, e, nTh );
 		} );
@@ -629,65 +790,35 @@ ColReorder.prototype = {
 	 */
 	"_fnMouseDown": function ( e, nTh )
 	{
-		var
-			that = this,
-			aoColumns = this.s.dt.aoColumns;
+		var that = this;
 
 		/* Store information about the mouse position */
-		var nThTarget = e.target.nodeName == "TH" ? e.target : $(e.target).parents('TH')[0];
-		var offset = $(nThTarget).offset();
+		var target = $(e.target).closest('th, td');
+		var offset = target.offset();
+		var idx = parseInt( $(nTh).attr('data-column-index'), 10 );
+
+		if ( idx === undefined ) {
+			return;
+		}
+
 		this.s.mouse.startX = e.pageX;
 		this.s.mouse.startY = e.pageY;
 		this.s.mouse.offsetX = e.pageX - offset.left;
 		this.s.mouse.offsetY = e.pageY - offset.top;
-		this.s.mouse.target = nTh;
-		this.s.mouse.targetIndex = $('th', nTh.parentNode).index( nTh );
-		this.s.mouse.fromIndex = this.s.dt.oInstance.oApi._fnVisibleToColumnIndex( this.s.dt,
-			this.s.mouse.targetIndex );
-
-		/* Calculate a cached array with the points of the column inserts, and the 'to' points */
-		this.s.aoTargets.splice( 0, this.s.aoTargets.length );
-
-		this.s.aoTargets.push( {
-			"x":  $(this.s.dt.nTable).offset().left,
-			"to": 0
-		} );
-
-		var iToPoint = 0;
-		for ( var i=0, iLen=aoColumns.length ; i<iLen ; i++ )
-		{
-			/* For the column / header in question, we want it's position to remain the same if the
-			 * position is just to it's immediate left or right, so we only incremement the counter for
-			 * other columns
-			 */
-			if ( i != this.s.mouse.fromIndex )
-			{
-				iToPoint++;
-			}
-
-			if ( aoColumns[i].bVisible )
-			{
-				this.s.aoTargets.push( {
-					"x":  $(aoColumns[i].nTh).offset().left + $(aoColumns[i].nTh).outerWidth(),
-					"to": iToPoint
-				} );
-			}
-		}
+		this.s.mouse.target = this.s.dt.aoColumns[ idx ].nTh;//target[0];
+		this.s.mouse.targetIndex = idx;
+		this.s.mouse.fromIndex = idx;
 
-		/* Disallow columns for being reordered by drag and drop, counting left to right */
-		if ( this.s.fixed !== 0 )
-		{
-			this.s.aoTargets.splice( 0, this.s.fixed );
-		}
+		this._fnRegions();
 
 		/* Add event handlers to the document */
-		$(document).bind( 'mousemove.ColReorder', function (e) {
-			that._fnMouseMove.call( that, e );
-		} );
-
-		$(document).bind( 'mouseup.ColReorder', function (e) {
-			that._fnMouseUp.call( that, e );
-		} );
+		$(document)
+			.on( 'mousemove.ColReorder', function (e) {
+				that._fnMouseMove.call( that, e );
+			} )
+			.on( 'mouseup.ColReorder', function (e) {
+				that._fnMouseUp.call( that, e );
+			} );
 	},
 
 
@@ -718,30 +849,40 @@ ColReorder.prototype = {
 		}
 
 		/* Position the element - we respect where in the element the click occured */
-		this.dom.drag.style.left = (e.pageX - this.s.mouse.offsetX) + "px";
-		this.dom.drag.style.top = (e.pageY - this.s.mouse.offsetY) + "px";
+		this.dom.drag.css( {
+			left: e.pageX - this.s.mouse.offsetX,
+			top: e.pageY - this.s.mouse.offsetY
+		} );
 
 		/* Based on the current mouse position, calculate where the insert should go */
 		var bSet = false;
+		var lastToIndex = this.s.mouse.toIndex;
+
 		for ( var i=1, iLen=this.s.aoTargets.length ; i<iLen ; i++ )
 		{
 			if ( e.pageX < this.s.aoTargets[i-1].x + ((this.s.aoTargets[i].x-this.s.aoTargets[i-1].x)/2) )
 			{
-				this.dom.pointer.style.left = this.s.aoTargets[i-1].x +"px";
+				this.dom.pointer.css( 'left', this.s.aoTargets[i-1].x );
 				this.s.mouse.toIndex = this.s.aoTargets[i-1].to;
 				bSet = true;
 				break;
 			}
 		}
 
-		/* The insert element wasn't positioned in the array (less than operator), so we put it at
-		 * the end
-		 */
+		// The insert element wasn't positioned in the array (less than
+		// operator), so we put it at the end
 		if ( !bSet )
 		{
-			this.dom.pointer.style.left = this.s.aoTargets[this.s.aoTargets.length-1].x +"px";
+			this.dom.pointer.css( 'left', this.s.aoTargets[this.s.aoTargets.length-1].x );
 			this.s.mouse.toIndex = this.s.aoTargets[this.s.aoTargets.length-1].to;
 		}
+
+		// Perform reordering if realtime updating is on and the column has moved
+		if ( this.s.init.bRealtime && lastToIndex !== this.s.mouse.toIndex ) {
+			this.s.dt.oInstance.fnColReorder( this.s.mouse.fromIndex, this.s.mouse.toIndex );
+			this.s.mouse.fromIndex = this.s.mouse.toIndex;
+			this._fnRegions();
+		}
 	},
 
 
@@ -756,19 +897,19 @@ ColReorder.prototype = {
 	{
 		var that = this;
 
-		$(document).unbind( 'mousemove.ColReorder' );
-		$(document).unbind( 'mouseup.ColReorder' );
+		$(document).off( 'mousemove.ColReorder mouseup.ColReorder' );
 
 		if ( this.dom.drag !== null )
 		{
 			/* Remove the guide elements */
-			document.body.removeChild( this.dom.drag );
-			document.body.removeChild( this.dom.pointer );
+			this.dom.drag.remove();
+			this.dom.pointer.remove();
 			this.dom.drag = null;
 			this.dom.pointer = null;
 
 			/* Actually do the reorder */
 			this.s.dt.oInstance.fnColReorder( this.s.mouse.fromIndex, this.s.mouse.toIndex );
+			this._fnSetColumnIndexes();
 
 			/* When scrolling we need to recalculate the column sizes to allow for the shift */
 			if ( this.s.dt.oScroll.sX !== "" || this.s.dt.oScroll.sY !== "" )
@@ -788,65 +929,108 @@ ColReorder.prototype = {
 
 
 	/**
-	 * Copy the TH element that is being drags so the user has the idea that they are actually
-	 * moving it around the page.
-	 *  @method  _fnCreateDragNode
+	 * Calculate a cached array with the points of the column inserts, and the
+	 * 'to' points
+	 *  @method  _fnRegions
 	 *  @returns void
 	 *  @private
 	 */
-	"_fnCreateDragNode": function ()
+	"_fnRegions": function ()
 	{
-		var that = this;
-
-		this.dom.drag = $(this.s.dt.nTHead.parentNode).clone(true)[0];
-		this.dom.drag.className += " DTCR_clonedTable";
-		while ( this.dom.drag.getElementsByTagName('caption').length > 0 )
-		{
-			this.dom.drag.removeChild( this.dom.drag.getElementsByTagName('caption')[0] );
-		}
-		while ( this.dom.drag.getElementsByTagName('tbody').length > 0 )
-		{
-			this.dom.drag.removeChild( this.dom.drag.getElementsByTagName('tbody')[0] );
-		}
-		while ( this.dom.drag.getElementsByTagName('tfoot').length > 0 )
-		{
-			this.dom.drag.removeChild( this.dom.drag.getElementsByTagName('tfoot')[0] );
-		}
-
-		$('thead tr:eq(0)', this.dom.drag).each( function () {
-			$('th', this).eq(that.s.mouse.targetIndex).siblings().remove();
-		} );
-		$('tr', this.dom.drag).height( $('tr:eq(0)', that.s.dt.nTHead).height() );
+		var aoColumns = this.s.dt.aoColumns;
 
-		$('thead tr:gt(0)', this.dom.drag).remove();
+		this.s.aoTargets.splice( 0, this.s.aoTargets.length );
 
-		$('thead th:eq(0)', this.dom.drag).each( function (i) {
-			this.style.width = $('th:eq('+that.s.mouse.targetIndex+')', that.s.dt.nTHead).width()+"px";
+		this.s.aoTargets.push( {
+			"x":  $(this.s.dt.nTable).offset().left,
+			"to": 0
 		} );
 
-		this.dom.drag.style.position = "absolute";
-		this.dom.drag.style.top = "0px";
-		this.dom.drag.style.left = "0px";
-		this.dom.drag.style.width = $('th:eq('+that.s.mouse.targetIndex+')', that.s.dt.nTHead).outerWidth()+"px";
-
+		var iToPoint = 0;
+		for ( var i=0, iLen=aoColumns.length ; i<iLen ; i++ )
+		{
+			/* For the column / header in question, we want it's position to remain the same if the
+			 * position is just to it's immediate left or right, so we only incremement the counter for
+			 * other columns
+			 */
+			if ( i != this.s.mouse.fromIndex )
+			{
+				iToPoint++;
+			}
 
-		this.dom.pointer = document.createElement( 'div' );
-		this.dom.pointer.className = "DTCR_pointer";
-		this.dom.pointer.style.position = "absolute";
+			if ( aoColumns[i].bVisible )
+			{
+				this.s.aoTargets.push( {
+					"x":  $(aoColumns[i].nTh).offset().left + $(aoColumns[i].nTh).outerWidth(),
+					"to": iToPoint
+				} );
+			}
+		}
 
-		if ( this.s.dt.oScroll.sX === "" && this.s.dt.oScroll.sY === "" )
+		/* Disallow columns for being reordered by drag and drop, counting right to left */
+		if ( this.s.fixedRight !== 0 )
 		{
-			this.dom.pointer.style.top = $(this.s.dt.nTable).offset().top+"px";
-			this.dom.pointer.style.height = $(this.s.dt.nTable).height()+"px";
+			this.s.aoTargets.splice( this.s.aoTargets.length - this.s.fixedRight );
 		}
-		else
+
+		/* Disallow columns for being reordered by drag and drop, counting left to right */
+		if ( this.s.fixed !== 0 )
 		{
-			this.dom.pointer.style.top = $('div.dataTables_scroll', this.s.dt.nTableWrapper).offset().top+"px";
-			this.dom.pointer.style.height = $('div.dataTables_scroll', this.s.dt.nTableWrapper).height()+"px";
+			this.s.aoTargets.splice( 0, this.s.fixed );
 		}
+	},
+
 
-		document.body.appendChild( this.dom.pointer );
-		document.body.appendChild( this.dom.drag );
+	/**
+	 * Copy the TH element that is being drags so the user has the idea that they are actually
+	 * moving it around the page.
+	 *  @method  _fnCreateDragNode
+	 *  @returns void
+	 *  @private
+	 */
+	"_fnCreateDragNode": function ()
+	{
+		var scrolling = this.s.dt.oScroll.sX !== "" || this.s.dt.oScroll.sY !== "";
+
+		var origCell = this.s.dt.aoColumns[ this.s.mouse.targetIndex ].nTh;
+		var origTr = origCell.parentNode;
+		var origThead = origTr.parentNode;
+		var origTable = origThead.parentNode;
+		var cloneCell = $(origCell).clone();
+
+		// This is a slightly odd combination of jQuery and DOM, but it is the
+		// fastest and least resource intensive way I could think of cloning
+		// the table with just a single header cell in it.
+		this.dom.drag = $(origTable.cloneNode(false))
+			.addClass( 'DTCR_clonedTable' )
+			.append(
+				origThead.cloneNode(false).appendChild(
+					origTr.cloneNode(false).appendChild(
+						cloneCell[0]
+					)
+				)
+			)
+			.css( {
+				position: 'absolute',
+				top: 0,
+				left: 0,
+				width: $(origCell).outerWidth(),
+				height: $(origCell).outerHeight()
+			} )
+			.appendTo( 'body' );
+
+		this.dom.pointer = $('<div></div>')
+			.addClass( 'DTCR_pointer' )
+			.css( {
+				position: 'absolute',
+				top: scrolling ?
+					$('div.dataTables_scroll', this.s.dt.nTableWrapper).offset().top :
+					$(this.s.dt.nTable).offset().top,
+				height : scrolling ?
+					$('div.dataTables_scroll', this.s.dt.nTableWrapper).height() :
+					$(this.s.dt.nTable).height()
+			} )
+			.appendTo( 'body' );
 	},
 
 	/**
@@ -857,19 +1041,39 @@ ColReorder.prototype = {
 	 */
 	"_fnDestroy": function ()
 	{
-		for ( var i=0, iLen=ColReorder.aoInstances.length ; i<iLen ; i++ )
+		var i, iLen;
+
+		for ( i=0, iLen=this.s.dt.aoDrawCallback.length ; i<iLen ; i++ )
 		{
-			if ( ColReorder.aoInstances[i] === this )
+			if ( this.s.dt.aoDrawCallback[i].sName === 'ColReorder_Pre' )
 			{
-				ColReorder.aoInstances.splice( i, 1 );
+				this.s.dt.aoDrawCallback.splice( i, 1 );
 				break;
 			}
 		}
 
-		$(this.s.dt.nTHead).find( '*' ).unbind( '.ColReorder' );
+		$(this.s.dt.nTHead).find( '*' ).off( '.ColReorder' );
+
+		$.each( this.s.dt.aoColumns, function (i, column) {
+			$(column.nTh).removeAttr('data-column-index');
+		} );
 
-		this.s.dt.oInstance._oPluginColReorder = null;
+		this.s.dt._colReorder = null;
 		this.s = null;
+	},
+
+
+	/**
+	 * Add a data attribute to the column headers, so we know the index of
+	 * the row to be reordered. This allows fast detection of the index, and
+	 * for this plug-in to work with FixedHeader which clones the nodes.
+	 *  @private
+	 */
+	"_fnSetColumnIndexes": function ()
+	{
+		$.each( this.s.dt.aoColumns, function (i, column) {
+			$(column.nTh).attr('data-column-index', i);
+		} );
 	}
 };
 
@@ -881,102 +1085,233 @@ ColReorder.prototype = {
  * Static parameters
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
+
 /**
- * Array of all ColReorder instances for later reference
- *  @property ColReorder.aoInstances
- *  @type     array
- *  @default  []
+ * ColReorder default settings for initialisation
+ *  @namespace
  *  @static
  */
-ColReorder.aoInstances = [];
-
-
+ColReorder.defaults = {
+	/**
+	 * Predefined ordering for the columns that will be applied automatically
+	 * on initialisation. If not specified then the order that the columns are
+	 * found to be in the HTML is the order used.
+	 *  @type array
+	 *  @default null
+	 *  @static
+	 *  @example
+	 *      // Using the `oColReorder` option in the DataTables options object
+	 *      $('#example').dataTable( {
+	 *          "sDom": 'Rlfrtip',
+	 *          "oColReorder": {
+	 *              "aiOrder": [ 4, 3, 2, 1, 0 ]
+	 *          }
+	 *      } );
+	 *
+	 *  @example
+	 *      // Using `new` constructor
+	 *      $('#example').dataTable()
+	 *
+	 *      new $.fn.dataTable.ColReorder( '#example', {
+	 *          "aiOrder": [ 4, 3, 2, 1, 0 ]
+	 *      } );
+	 */
+	aiOrder: null,
 
+	/**
+	 * Redraw the table's column ordering as the end user draws the column
+	 * (`true`) or wait until the mouse is released (`false` - default). Note
+	 * that this will perform a redraw on each reordering, which involves an
+	 * Ajax request each time if you are using server-side processing in
+	 * DataTables.
+	 *  @type boolean
+	 *  @default false
+	 *  @static
+	 *  @example
+	 *      // Using the `oColReorder` option in the DataTables options object
+	 *      $('#example').dataTable( {
+	 *          "sDom": 'Rlfrtip',
+	 *          "oColReorder": {
+	 *              "bRealtime": true
+	 *          }
+	 *      } );
+	 *
+	 *  @example
+	 *      // Using `new` constructor
+	 *      $('#example').dataTable()
+	 *
+	 *      new $.fn.dataTable.ColReorder( '#example', {
+	 *          "bRealtime": true
+	 *      } );
+	 */
+	bRealtime: false,
 
+	/**
+	 * Indicate how many columns should be fixed in position (counting from the
+	 * left). This will typically be 1 if used, but can be as high as you like.
+	 *  @type int
+	 *  @default 0
+	 *  @static
+	 *  @example
+	 *      // Using the `oColReorder` option in the DataTables options object
+	 *      $('#example').dataTable( {
+	 *          "sDom": 'Rlfrtip',
+	 *          "oColReorder": {
+	 *              "iFixedColumns": 1
+	 *          }
+	 *      } );
+	 *
+	 *  @example
+	 *      // Using `new` constructor
+	 *      $('#example').dataTable()
+	 *
+	 *      new $.fn.dataTable.ColReorder( '#example', {
+	 *          "iFixedColumns": 1
+	 *      } );
+	 */
+	iFixedColumns: 0,
 
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * Static functions
- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+	/**
+	 * As `iFixedColumnsRight` but counting from the right.
+	 *  @type int
+	 *  @default 0
+	 *  @static
+	 *  @example
+	 *      // Using the `oColReorder` option in the DataTables options object
+	 *      $('#example').dataTable( {
+	 *          "sDom": 'Rlfrtip',
+	 *          "oColReorder": {
+	 *              "iFixedColumnsRight": 1
+	 *          }
+	 *      } );
+	 *
+	 *  @example
+	 *      // Using `new` constructor
+	 *      $('#example').dataTable()
+	 *
+	 *      new $.fn.dataTable.ColReorder( '#example', {
+	 *          "iFixedColumnsRight": 1
+	 *      } );
+	 */
+	iFixedColumnsRight: 0,
 
-/**
- * Reset the column ordering for a DataTables instance
- *  @method  ColReorder.fnReset
- *  @param   object oTable DataTables instance to consider
- *  @returns void
- *  @static
- */
-ColReorder.fnReset = function ( oTable )
-{
-	for ( var i=0, iLen=ColReorder.aoInstances.length ; i<iLen ; i++ )
-	{
-		if ( ColReorder.aoInstances[i].s.dt.oInstance == oTable )
-		{
-			ColReorder.aoInstances[i].fnReset();
-		}
-	}
+	/**
+	 * Callback function that is fired when columns are reordered
+	 *  @type function():void
+	 *  @default null
+	 *  @static
+	 *  @example
+	 *      // Using the `oColReorder` option in the DataTables options object
+	 *      $('#example').dataTable( {
+	 *          "sDom": 'Rlfrtip',
+	 *          "oColReorder": {
+	 *              "fnReorderCallback": function () {
+	 *                  alert( 'Columns reordered' );
+	 *              }
+	 *          }
+	 *      } );
+	 *
+	 *  @example
+	 *      // Using `new` constructor
+	 *      $('#example').dataTable()
+	 *
+	 *      new $.fn.dataTable.ColReorder( '#example', {
+	 *          "fnReorderCallback": function () {
+	 *              alert( 'Columns reordered' );
+	 *          }
+	 *      } );
+	 */
+	fnReorderCallback: null
 };
 
 
 
-
-
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  * Constants
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
-/**
- * Name of this class
- *  @constant CLASS
- *  @type     String
- *  @default  ColReorder
- */
-ColReorder.prototype.CLASS = "ColReorder";
-
-
 /**
  * ColReorder version
- *  @constant  VERSION
+ *  @constant  version
  *  @type      String
  *  @default   As code
  */
-ColReorder.VERSION = "1.0.8";
-ColReorder.prototype.VERSION = ColReorder.VERSION;
-
-
+ColReorder.version = "1.1.1";
 
 
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * Initialisation
+ * DataTables interfaces
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
-/*
- * Register a new feature with DataTables
- */
+// Expose
+$.fn.dataTable.ColReorder = ColReorder;
+$.fn.DataTable.ColReorder = ColReorder;
+
+
+// Register a new feature with DataTables
 if ( typeof $.fn.dataTable == "function" &&
      typeof $.fn.dataTableExt.fnVersionCheck == "function" &&
      $.fn.dataTableExt.fnVersionCheck('1.9.3') )
 {
 	$.fn.dataTableExt.aoFeatures.push( {
-		"fnInit": function( oDTSettings ) {
-			var oTable = oDTSettings.oInstance;
-			if ( typeof oTable._oPluginColReorder == 'undefined' ) {
-				var opts = typeof oDTSettings.oInit.oColReorder != 'undefined' ?
-					oDTSettings.oInit.oColReorder : {};
-				oTable._oPluginColReorder = new ColReorder( oDTSettings, opts );
-			} else {
-				oTable.oApi._fnLog( oDTSettings, 1, "ColReorder attempted to initialise twice. Ignoring second" );
+		"fnInit": function( settings ) {
+			var table = settings.oInstance;
+
+			if ( ! settings._colReorder ) {
+				var dtInit = settings.oInit;
+				var opts = dtInit.colReorder || dtInit.oColReorder || {};
+
+				new ColReorder( settings, opts );
+			}
+			else {
+				table.oApi._fnLog( settings, 1, "ColReorder attempted to initialise twice. Ignoring second" );
 			}
 
-			return null; /* No node to insert */
+			return null; /* No node for DataTables to insert */
 		},
 		"cFeature": "R",
 		"sFeature": "ColReorder"
 	} );
 }
-else
-{
+else {
 	alert( "Warning: ColReorder requires DataTables 1.9.3 or greater - www.datatables.net/download");
 }
 
-})(jQuery, window, document);
+
+// API augmentation
+if ( $.fn.dataTable.Api ) {
+	$.fn.dataTable.Api.register( 'colReorder.reset()', function () {
+		return this.iterator( 'table', function ( ctx ) {
+			ctx._colReorder.fnReset();
+		} );
+	} );
+
+	$.fn.dataTable.Api.register( 'colReorder.order()', function ( set ) {
+		if ( set ) {
+			return this.iterator( 'table', function ( ctx ) {
+				ctx._colReorder.fnOrder( set );
+			} );
+		}
+
+		return this.context.length ?
+			this.context[0]._colReorder.fnOrder() :
+			null;
+	} );
+}
+
+return ColReorder;
+}; // /factory
+
+
+// Define as an AMD module if possible
+if ( typeof define === 'function' && define.amd ) {
+	define( 'datatables-colreorder', ['jquery', 'datatables'], factory );
+}
+else if ( jQuery && !jQuery.fn.dataTable.ColReorder ) {
+	// Otherwise simply initialise as normal, stopping multiple evaluation
+	factory( jQuery, jQuery.fn.dataTable );
+}
+
+
+})(window, document);