X-Git-Url: https://gerrit.opnfv.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fceph%2Fsrc%2Fpybind%2Fmgr%2Fdashboard%2Fstatic%2FAdminLTE-2.3.7%2Fplugins%2Fdatatables%2Fextensions%2FAutoFill%2Fjs%2FdataTables.autoFill.js;fp=src%2Fceph%2Fsrc%2Fpybind%2Fmgr%2Fdashboard%2Fstatic%2FAdminLTE-2.3.7%2Fplugins%2Fdatatables%2Fextensions%2FAutoFill%2Fjs%2FdataTables.autoFill.js;h=6bbfa35b937271faffcbac10f3f57425ab84e780;hb=812ff6ca9fcd3e629e49d4328905f33eee8ca3f5;hp=0000000000000000000000000000000000000000;hpb=15280273faafb77777eab341909a3f495cf248d9;p=stor4nfv.git

diff --git a/src/ceph/src/pybind/mgr/dashboard/static/AdminLTE-2.3.7/plugins/datatables/extensions/AutoFill/js/dataTables.autoFill.js b/src/ceph/src/pybind/mgr/dashboard/static/AdminLTE-2.3.7/plugins/datatables/extensions/AutoFill/js/dataTables.autoFill.js
new file mode 100644
index 0000000..6bbfa35
--- /dev/null
+++ b/src/ceph/src/pybind/mgr/dashboard/static/AdminLTE-2.3.7/plugins/datatables/extensions/AutoFill/js/dataTables.autoFill.js
@@ -0,0 +1,855 @@
+/*! AutoFill 1.2.1
+ * ©2008-2014 SpryMedia Ltd - datatables.net/license
+ */
+
+/**
+ * @summary     AutoFill
+ * @description Add Excel like click and drag auto-fill options to DataTables
+ * @version     1.2.1
+ * @file        dataTables.autoFill.js
+ * @author      SpryMedia Ltd (www.sprymedia.co.uk)
+ * @contact     www.sprymedia.co.uk/contact
+ * @copyright   Copyright 2010-2014 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( window, document, undefined ) {
+
+var factory = function( $, DataTable ) {
+"use strict";
+
+/** 
+ * AutoFill provides Excel like auto-fill features for a DataTable
+ *
+ * @class AutoFill
+ * @constructor
+ * @param {object} oTD DataTables settings object
+ * @param {object} oConfig Configuration object for AutoFill
+ */
+var AutoFill = function( oDT, oConfig )
+{
+	/* Sanity check that we are a new instance */
+	if ( ! (this instanceof AutoFill) ) {
+		throw( "Warning: AutoFill must be initialised with the keyword 'new'" );
+	}
+
+	if ( ! $.fn.dataTableExt.fnVersionCheck('1.7.0') ) {
+		throw( "Warning: AutoFill requires DataTables 1.7 or greater");
+	}
+
+
+	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+	 * Public class variables
+	 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+	this.c = {};
+
+	/**
+	 * @namespace Settings object which contains customisable information for AutoFill instance
+	 */
+	this.s = {
+		/**
+		 * @namespace Cached information about the little dragging icon (the filler)
+		 */
+		"filler": {
+			"height": 0,
+			"width": 0
+		},
+
+		/**
+		 * @namespace Cached information about the border display
+		 */
+		"border": {
+			"width": 2
+		},
+
+		/**
+		 * @namespace Store for live information for the current drag
+		 */
+		"drag": {
+			"startX": -1,
+			"startY": -1,
+			"startTd": null,
+			"endTd": null,
+			"dragging": false
+		},
+
+		/**
+		 * @namespace Data cache for information that we need for scrolling the screen when we near
+		 *   the edges
+		 */
+		"screen": {
+			"interval": null,
+			"y": 0,
+			"height": 0,
+			"scrollTop": 0
+		},
+
+		/**
+		 * @namespace Data cache for the position of the DataTables scrolling element (when scrolling
+		 *   is enabled)
+		 */
+		"scroller": {
+			"top": 0,
+			"bottom": 0
+		},
+
+		/**
+		 * @namespace Information stored for each column. An array of objects
+		 */
+		"columns": []
+	};
+
+
+	/**
+	 * @namespace Common and useful DOM elements for the class instance
+	 */
+	this.dom = {
+		"table": null,
+		"filler": null,
+		"borderTop": null,
+		"borderRight": null,
+		"borderBottom": null,
+		"borderLeft": null,
+		"currentTarget": null
+	};
+
+
+
+	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+	 * Public class methods
+	 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+	/**
+	 * Retreieve the settings object from an instance
+	 *  @method fnSettings
+	 *  @returns {object} AutoFill settings object
+	 */
+	this.fnSettings = function () {
+		return this.s;
+	};
+
+
+	/* Constructor logic */
+	this._fnInit( oDT, oConfig );
+	return this;
+};
+
+
+
+AutoFill.prototype = {
+	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+	 * Private methods (they are of course public in JS, but recommended as private)
+	 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+	/**
+	 * Initialisation
+	 *  @method _fnInit
+	 *  @param {object} dt DataTables settings object
+	 *  @param {object} config Configuration object for AutoFill
+	 *  @returns void
+	 */
+	"_fnInit": function ( dt, config )
+	{
+		var
+			that = this,
+			i, iLen;
+
+		// Use DataTables API to get the settings allowing selectors, instances
+		// etc to be used, or for backwards compatibility get from the old
+		// fnSettings method
+		this.s.dt = DataTable.Api ?
+			new DataTable.Api( dt ).settings()[0] :
+			dt.fnSettings();
+		this.s.init = config || {};
+		this.dom.table = this.s.dt.nTable;
+
+		$.extend( true, this.c, AutoFill.defaults, config );
+
+		/* Add and configure the columns */
+		this._initColumns();
+
+		/* Auto Fill click and drag icon */
+		var filler = $('<div/>', {
+				'class': 'AutoFill_filler'
+			} )
+			.appendTo( 'body' );
+		this.dom.filler = filler[0];
+
+		// Get the height / width of the click element
+		this.s.filler.height = filler.height();
+		this.s.filler.width = filler.width();
+		filler[0].style.display = "none";
+
+		/* Border display - one div for each side. We can't just use a single
+		 * one with a border, as we want the events to effectively pass through
+		 * the transparent bit of the box
+		 */
+		var border;
+		var appender = document.body;
+		if ( that.s.dt.oScroll.sY !== "" ) {
+			that.s.dt.nTable.parentNode.style.position = "relative";
+			appender = that.s.dt.nTable.parentNode;
+		}
+
+		border = $('<div/>', {
+			"class": "AutoFill_border"
+		} );
+		this.dom.borderTop    = border.clone().appendTo( appender )[0];
+		this.dom.borderRight  = border.clone().appendTo( appender )[0];
+		this.dom.borderBottom = border.clone().appendTo( appender )[0];
+		this.dom.borderLeft   = border.clone().appendTo( appender )[0];
+
+		/* Events */
+		filler.on( 'mousedown.DTAF', function (e) {
+			this.onselectstart = function() { return false; };
+			that._fnFillerDragStart.call( that, e );
+			return false;
+		} );
+
+		$('tbody', this.dom.table).on(
+			'mouseover.DTAF mouseout.DTAF',
+			'>tr>td, >tr>th',
+			function (e) {
+				that._fnFillerDisplay.call( that, e );
+			}
+		);
+
+		$(this.dom.table).on( 'destroy.dt.DTAF', function () {
+			filler.off( 'mousedown.DTAF' ).remove();
+			$('tbody', this.dom.table).off( 'mouseover.DTAF mouseout.DTAF' );
+		} );
+	},
+
+
+	_initColumns: function ( )
+	{
+		var that = this;
+		var i, ien;
+		var dt = this.s.dt;
+		var config = this.s.init;
+
+		for ( i=0, ien=dt.aoColumns.length ; i<ien ; i++ ) {
+			this.s.columns[i] = $.extend( true, {}, AutoFill.defaults.column );
+		}
+
+		dt.oApi._fnApplyColumnDefs(
+			dt,
+			config.aoColumnDefs || config.columnDefs,
+			config.aoColumns || config.columns,
+			function (colIdx, def) {
+				that._fnColumnOptions( colIdx, def );
+			}
+		);
+
+		// For columns which don't have read, write, step functions defined,
+		// use the default ones
+		for ( i=0, ien=dt.aoColumns.length ; i<ien ; i++ ) {
+			var column = this.s.columns[i];
+
+			if ( ! column.read ) {
+				column.read = this._fnReadCell;
+			}
+			if ( ! column.write ) {
+				column.read = this._fnWriteCell;
+			}
+			if ( ! column.step ) {
+				column.read = this._fnStep;
+			}
+		}
+	},
+
+
+	"_fnColumnOptions": function ( i, opts )
+	{
+		var column = this.s.columns[ i ];
+		var set = function ( outProp, inProp ) {
+			if ( opts[ inProp[0] ] !== undefined ) {
+				column[ outProp ] = opts[ inProp[0] ];
+			}
+			if ( opts[ inProp[1] ] !== undefined ) {
+				column[ outProp ] = opts[ inProp[1] ];
+			}
+		};
+
+		// Compatibility with the old Hungarian style of notation
+		set( 'enable',    ['bEnable',     'enable'] );
+		set( 'read',      ['fnRead',      'read'] );
+		set( 'write',     ['fnWrite',     'write'] );
+		set( 'step',      ['fnStep',      'step'] );
+		set( 'increment', ['bIncrement',  'increment'] );
+	},
+
+
+	/**
+	 * Find out the coordinates of a given TD cell in a table
+	 *  @method  _fnTargetCoords
+	 *  @param   {Node} nTd
+	 *  @returns {Object} x and y properties, for the position of the cell in the tables DOM
+	 */
+	"_fnTargetCoords": function ( nTd )
+	{
+		var nTr = $(nTd).parents('tr')[0];
+		var position = this.s.dt.oInstance.fnGetPosition( nTd );
+
+		return {
+			"x":      $('td', nTr).index(nTd),
+			"y":      $('tr', nTr.parentNode).index(nTr),
+			"row":    position[0],
+			"column": position[2]
+		};
+	},
+
+
+	/**
+	 * Display the border around one or more cells (from start to end)
+	 *  @method  _fnUpdateBorder
+	 *  @param   {Node} nStart Starting cell
+	 *  @param   {Node} nEnd Ending cell
+	 *  @returns void
+	 */
+	"_fnUpdateBorder": function ( nStart, nEnd )
+	{
+		var
+			border = this.s.border.width,
+			offsetStart = $(nStart).offset(),
+			offsetEnd = $(nEnd).offset(),
+			x1 = offsetStart.left - border,
+			x2 = offsetEnd.left + $(nEnd).outerWidth(),
+			y1 = offsetStart.top - border,
+			y2 = offsetEnd.top + $(nEnd).outerHeight(),
+			width = offsetEnd.left + $(nEnd).outerWidth() - offsetStart.left + (2*border),
+			height = offsetEnd.top + $(nEnd).outerHeight() - offsetStart.top + (2*border),
+			oStyle;
+
+		// Recalculate start and end (when dragging "backwards")  
+		if( offsetStart.left > offsetEnd.left) {
+			x1 = offsetEnd.left - border;
+			x2 = offsetStart.left + $(nStart).outerWidth();
+			width = offsetStart.left + $(nStart).outerWidth() - offsetEnd.left + (2*border);
+		}
+
+		if ( this.s.dt.oScroll.sY !== "" )
+		{
+			/* The border elements are inside the DT scroller - so position relative to that */
+			var
+				offsetScroll = $(this.s.dt.nTable.parentNode).offset(),
+				scrollTop = $(this.s.dt.nTable.parentNode).scrollTop(),
+				scrollLeft = $(this.s.dt.nTable.parentNode).scrollLeft();
+
+			x1 -= offsetScroll.left - scrollLeft;
+			x2 -= offsetScroll.left - scrollLeft;
+			y1 -= offsetScroll.top - scrollTop;
+			y2 -= offsetScroll.top - scrollTop;
+		}
+
+		/* Top */
+		oStyle = this.dom.borderTop.style;
+		oStyle.top = y1+"px";
+		oStyle.left = x1+"px";
+		oStyle.height = this.s.border.width+"px";
+		oStyle.width = width+"px";
+
+		/* Bottom */
+		oStyle = this.dom.borderBottom.style;
+		oStyle.top = y2+"px";
+		oStyle.left = x1+"px";
+		oStyle.height = this.s.border.width+"px";
+		oStyle.width = width+"px";
+
+		/* Left */
+		oStyle = this.dom.borderLeft.style;
+		oStyle.top = y1+"px";
+		oStyle.left = x1+"px";
+		oStyle.height = height+"px";
+		oStyle.width = this.s.border.width+"px";
+
+		/* Right */
+		oStyle = this.dom.borderRight.style;
+		oStyle.top = y1+"px";
+		oStyle.left = x2+"px";
+		oStyle.height = height+"px";
+		oStyle.width = this.s.border.width+"px";
+	},
+
+
+	/**
+	 * Mouse down event handler for starting a drag
+	 *  @method  _fnFillerDragStart
+	 *  @param   {Object} e Event object
+	 *  @returns void
+	 */
+	"_fnFillerDragStart": function (e)
+	{
+		var that = this;
+		var startingTd = this.dom.currentTarget;
+
+		this.s.drag.dragging = true;
+
+		that.dom.borderTop.style.display = "block";
+		that.dom.borderRight.style.display = "block";
+		that.dom.borderBottom.style.display = "block";
+		that.dom.borderLeft.style.display = "block";
+
+		var coords = this._fnTargetCoords( startingTd );
+		this.s.drag.startX = coords.x;
+		this.s.drag.startY = coords.y;
+
+		this.s.drag.startTd = startingTd;
+		this.s.drag.endTd = startingTd;
+
+		this._fnUpdateBorder( startingTd, startingTd );
+
+		$(document).bind('mousemove.AutoFill', function (e) {
+			that._fnFillerDragMove.call( that, e );
+		} );
+
+		$(document).bind('mouseup.AutoFill', function (e) {
+			that._fnFillerFinish.call( that, e );
+		} );
+
+		/* Scrolling information cache */
+		this.s.screen.y = e.pageY;
+		this.s.screen.height = $(window).height();
+		this.s.screen.scrollTop = $(document).scrollTop();
+
+		if ( this.s.dt.oScroll.sY !== "" )
+		{
+			this.s.scroller.top = $(this.s.dt.nTable.parentNode).offset().top;
+			this.s.scroller.bottom = this.s.scroller.top + $(this.s.dt.nTable.parentNode).height();
+		}
+
+		/* Scrolling handler - we set an interval (which is cancelled on mouse up) which will fire
+		 * regularly and see if we need to do any scrolling
+		 */
+		this.s.screen.interval = setInterval( function () {
+			var iScrollTop = $(document).scrollTop();
+			var iScrollDelta = iScrollTop - that.s.screen.scrollTop;
+			that.s.screen.y += iScrollDelta;
+
+			if ( that.s.screen.height - that.s.screen.y + iScrollTop < 50 )
+			{
+				$('html, body').animate( {
+					"scrollTop": iScrollTop + 50
+				}, 240, 'linear' );
+			}
+			else if ( that.s.screen.y - iScrollTop < 50 )
+			{
+				$('html, body').animate( {
+					"scrollTop": iScrollTop - 50
+				}, 240, 'linear' );
+			}
+
+			if ( that.s.dt.oScroll.sY !== "" )
+			{
+				if ( that.s.screen.y > that.s.scroller.bottom - 50 )
+				{
+					$(that.s.dt.nTable.parentNode).animate( {
+						"scrollTop": $(that.s.dt.nTable.parentNode).scrollTop() + 50
+					}, 240, 'linear' );
+				}
+				else if ( that.s.screen.y < that.s.scroller.top + 50 )
+				{
+					$(that.s.dt.nTable.parentNode).animate( {
+						"scrollTop": $(that.s.dt.nTable.parentNode).scrollTop() - 50
+					}, 240, 'linear' );
+				}
+			}
+		}, 250 );
+	},
+
+
+	/**
+	 * Mouse move event handler for during a move. See if we want to update the display based on the
+	 * new cursor position
+	 *  @method  _fnFillerDragMove
+	 *  @param   {Object} e Event object
+	 *  @returns void
+	 */
+	"_fnFillerDragMove": function (e)
+	{
+		if ( e.target && e.target.nodeName.toUpperCase() == "TD" &&
+			 e.target != this.s.drag.endTd )
+		{
+			var coords = this._fnTargetCoords( e.target );
+
+			if ( this.c.mode == "y" && coords.x != this.s.drag.startX )
+			{
+				e.target = $('tbody>tr:eq('+coords.y+')>td:eq('+this.s.drag.startX+')', this.dom.table)[0];
+			}
+			if ( this.c.mode == "x" && coords.y != this.s.drag.startY )
+			{
+				e.target = $('tbody>tr:eq('+this.s.drag.startY+')>td:eq('+coords.x+')', this.dom.table)[0];
+			}
+
+			if ( this.c.mode == "either")
+			{
+				if(coords.x != this.s.drag.startX )
+				{
+					e.target = $('tbody>tr:eq('+this.s.drag.startY+')>td:eq('+coords.x+')', this.dom.table)[0];
+				}
+				else if ( coords.y != this.s.drag.startY ) {
+					e.target = $('tbody>tr:eq('+coords.y+')>td:eq('+this.s.drag.startX+')', this.dom.table)[0];
+				}
+			}
+
+			// update coords
+			if ( this.c.mode !== "both" ) {
+				coords = this._fnTargetCoords( e.target );
+			}
+
+			var drag = this.s.drag;
+			drag.endTd = e.target;
+
+			if ( coords.y >= this.s.drag.startY ) {
+				this._fnUpdateBorder( drag.startTd, drag.endTd );
+			}
+			else {
+				this._fnUpdateBorder( drag.endTd, drag.startTd );
+			}
+			this._fnFillerPosition( e.target );
+		}
+
+		/* Update the screen information so we can perform scrolling */
+		this.s.screen.y = e.pageY;
+		this.s.screen.scrollTop = $(document).scrollTop();
+
+		if ( this.s.dt.oScroll.sY !== "" )
+		{
+			this.s.scroller.scrollTop = $(this.s.dt.nTable.parentNode).scrollTop();
+			this.s.scroller.top = $(this.s.dt.nTable.parentNode).offset().top;
+			this.s.scroller.bottom = this.s.scroller.top + $(this.s.dt.nTable.parentNode).height();
+		}
+	},
+
+
+	/**
+	 * Mouse release handler - end the drag and take action to update the cells with the needed values
+	 *  @method  _fnFillerFinish
+	 *  @param   {Object} e Event object
+	 *  @returns void
+	 */
+	"_fnFillerFinish": function (e)
+	{
+		var that = this, i, iLen, j;
+
+		$(document).unbind('mousemove.AutoFill mouseup.AutoFill');
+
+		this.dom.borderTop.style.display = "none";
+		this.dom.borderRight.style.display = "none";
+		this.dom.borderBottom.style.display = "none";
+		this.dom.borderLeft.style.display = "none";
+
+		this.s.drag.dragging = false;
+
+		clearInterval( this.s.screen.interval );
+
+		var cells = [];
+		var table = this.dom.table;
+		var coordsStart = this._fnTargetCoords( this.s.drag.startTd );
+		var coordsEnd = this._fnTargetCoords( this.s.drag.endTd );
+		var columnIndex = function ( visIdx ) {
+			return that.s.dt.oApi._fnVisibleToColumnIndex( that.s.dt, visIdx );
+		};
+
+		// xxx - urgh - there must be a way of reducing this...
+		if ( coordsStart.y <= coordsEnd.y ) {
+			for ( i=coordsStart.y ; i<=coordsEnd.y ; i++ ) {
+				if ( coordsStart.x <= coordsEnd.x ) {
+					for ( j=coordsStart.x ; j<=coordsEnd.x ; j++ ) {
+						cells.push( {
+							node:   $('tbody>tr:eq('+i+')>td:eq('+j+')', table)[0],
+							x:      j - coordsStart.x,
+							y:      i - coordsStart.y,
+							colIdx: columnIndex( j )
+						} );
+					}
+				}
+				else {
+					for ( j=coordsStart.x ; j>=coordsEnd.x ; j-- ) {
+						cells.push( {
+							node:   $('tbody>tr:eq('+i+')>td:eq('+j+')', table)[0],
+							x:      j - coordsStart.x,
+							y:      i - coordsStart.y,
+							colIdx: columnIndex( j )
+						} );
+					}
+				}
+			}
+		}
+		else {
+			for ( i=coordsStart.y ; i>=coordsEnd.y ; i-- ) {
+				if ( coordsStart.x <= coordsEnd.x ) {
+					for ( j=coordsStart.x ; j<=coordsEnd.x ; j++ ) {
+						cells.push( {
+							node:   $('tbody>tr:eq('+i+')>td:eq('+j+')', table)[0],
+							x:      j - coordsStart.x,
+							y:      i - coordsStart.y,
+							colIdx: columnIndex( j )
+						} );
+					}
+				}
+				else {
+					for ( j=coordsStart.x ; j>=coordsEnd.x ; j-- ) {
+						cells.push( {
+							node:   $('tbody>tr:eq('+i+')>td:eq('+j+')', table)[0],
+							x:      coordsStart.x - j,
+							y:      coordsStart.y - i,
+							colIdx: columnIndex( j )
+						} );
+					}
+				}
+			}
+		}
+
+		// An auto-fill requires 2 or more cells
+		if ( cells.length <= 1 ) {
+			return;
+		}
+
+		var edited = [];
+		var previous;
+
+		for ( i=0, iLen=cells.length ; i<iLen ; i++ ) {
+			var cell      = cells[i];
+			var column    = this.s.columns[ cell.colIdx ];
+			var read      = column.read.call( column, cell.node );
+			var stepValue = column.step.call( column, cell.node, read, previous, i, cell.x, cell.y );
+
+			column.write.call( column, cell.node, stepValue );
+
+			previous = stepValue;
+			edited.push( {
+				cell:     cell,
+				colIdx:   cell.colIdx,
+				newValue: stepValue,
+				oldValue: read
+			} );
+		}
+
+		if ( this.c.complete !== null ) {
+			this.c.complete.call( this, edited );
+		}
+
+		// In 1.10 we can do a static draw
+		if ( DataTable.Api ) {
+			new DataTable.Api( this.s.dt ).draw( false );
+		}
+		else {
+			this.s.dt.oInstance.fnDraw();
+		}
+	},
+
+
+	/**
+	 * Display the drag handle on mouse over cell
+	 *  @method  _fnFillerDisplay
+	 *  @param   {Object} e Event object
+	 *  @returns void
+	 */
+	"_fnFillerDisplay": function (e)
+	{
+		var filler = this.dom.filler;
+
+		/* Don't display automatically when dragging */
+		if ( this.s.drag.dragging)
+		{
+			return;
+		}
+
+		/* Check that we are allowed to AutoFill this column or not */
+		var nTd = (e.target.nodeName.toLowerCase() == 'td') ? e.target : $(e.target).parents('td')[0];
+		var iX = this._fnTargetCoords(nTd).column;
+		if ( !this.s.columns[iX].enable )
+		{
+			filler.style.display = "none";
+			return;
+		}
+
+		if (e.type == 'mouseover')
+		{
+			this.dom.currentTarget = nTd;
+			this._fnFillerPosition( nTd );
+
+			filler.style.display = "block";
+		}
+		else if ( !e.relatedTarget || !e.relatedTarget.className.match(/AutoFill/) )
+		{
+			filler.style.display = "none";
+		}
+	},
+
+
+	/**
+	 * Position the filler icon over a cell
+	 *  @method  _fnFillerPosition
+	 *  @param   {Node} nTd Cell to position filler icon over
+	 *  @returns void
+	 */
+	"_fnFillerPosition": function ( nTd )
+	{
+		var offset = $(nTd).offset();
+		var filler = this.dom.filler;
+		filler.style.top = (offset.top - (this.s.filler.height / 2)-1 + $(nTd).outerHeight())+"px";
+		filler.style.left = (offset.left - (this.s.filler.width / 2)-1 + $(nTd).outerWidth())+"px";
+	}
+};
+
+
+// Alias for access
+DataTable.AutoFill = AutoFill;
+DataTable.AutoFill = AutoFill;
+
+
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Constants
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/**
+ * AutoFill version
+ *  @constant  version
+ *  @type      String
+ *  @default   See code
+ */
+AutoFill.version = "1.2.1";
+
+
+/**
+ * AutoFill defaults
+ *  @namespace
+ */
+AutoFill.defaults = {
+	/**
+	 * Mode for dragging (restrict to y-axis only, x-axis only, either one or none):
+	 *
+	 *  * `y`      - y-axis only (default)
+	 *  * `x`      - x-axis only
+	 *  * `either` - either one, but not both axis at the same time
+	 *  * `both`   - multiple cells allowed
+	 *
+	 * @type {string}
+	 * @default `y`
+	 */
+	mode: 'y',
+
+	complete: null,
+
+	/**
+	 * Column definition defaults
+	 *  @namespace
+	 */
+	column: {
+		/**
+		 * If AutoFill should be enabled on this column
+		 *
+		 * @type {boolean}
+		 * @default true
+		 */
+		enable: true,
+
+		/**
+		 * Allow automatic increment / decrement on this column if a number
+		 * is found.
+		 *
+		 * @type {boolean}
+		 * @default true
+		 */
+		increment: true,
+
+		/**
+		 * Cell read function
+		 *
+		 * Default function will simply read the value from the HTML of the
+		 * cell.
+		 *
+		 * @type   {function}
+		 * @param  {node} cell `th` / `td` element to read the value from
+		 * @return {string}    Data that has been read
+		 */
+		read: function ( cell ) {
+			return $(cell).html();
+		},
+
+		/**
+		 * Cell write function
+		 *
+		 * Default function will simply write to the HTML and tell the DataTable
+		 * to update.
+		 *
+		 * @type   {function}
+		 * @param  {node} cell `th` / `td` element to write the value to
+		 * @return {string}    Data two write
+		 */
+		write: function ( cell, val ) {
+			var table = $(cell).parents('table');
+			if ( DataTable.Api ) {
+				// 1.10
+				table.DataTable().cell( cell ).data( val );
+			}
+			else {
+				// 1.9
+				var dt = table.dataTable();
+				var pos = dt.fnGetPosition( cell );
+				dt.fnUpdate( val, pos[0], pos[2], false );
+			}
+		},
+
+		/**
+		 * Step function. This provides the ability to customise how the values
+		 * are incremented.
+		 *
+		 * @param  {node} cell `th` / `td` element that is being operated upon
+		 * @param  {string} read Cell value from `read` function
+		 * @param  {string} last Value of the previous cell
+		 * @param  {integer} i Loop counter
+		 * @param  {integer} x Cell x-position in the current auto-fill. The
+		 *   starting cell is coordinate 0 regardless of its physical position
+		 *   in the DataTable.
+		 * @param  {integer} y Cell y-position in the current auto-fill. The
+		 *   starting cell is coordinate 0 regardless of its physical position
+		 *   in the DataTable.
+		 * @return {string} Value to write
+		 */
+		step: function ( cell, read, last, i, x, y ) {
+			// Increment a number if it is found
+			var re = /(\-?\d+)/;
+			var match = this.increment && last ? last.match(re) : null;
+			if ( match ) {
+				return last.replace( re, parseInt(match[1],10) + (x<0 || y<0 ? -1 : 1) );
+			}
+			return last === undefined ?
+				read :
+				last;
+		}
+	}
+};
+
+return AutoFill;
+};
+
+
+// Define as an AMD module if possible
+if ( typeof define === 'function' && define.amd ) {
+	define( ['jquery', 'datatables'], factory );
+}
+else if ( typeof exports === 'object' ) {
+    // Node/CommonJS
+    factory( require('jquery'), require('datatables') );
+}
+else if ( jQuery && !jQuery.fn.dataTable.AutoFill ) {
+	// Otherwise simply initialise as normal, stopping multiple evaluation
+	factory( jQuery, jQuery.fn.dataTable );
+}
+
+
+}(window, document));
+