Subversion-Projekte lars-tiefland.ci

/*! AutoFill 2.0.0

 * ©2008-2015 SpryMedia Ltd - datatables.net/license

 */

/**

 * @summary     AutoFill

 * @description Add Excel like click and drag auto-fill options to DataTables

 * @version     2.0.0

 * @file        dataTables.autoFill.js

 * @author      SpryMedia Ltd (www.sprymedia.co.uk)

 * @contact     www.sprymedia.co.uk/contact

 * @copyright   Copyright 2010-2015 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";

var _instance = 0;

/**

 * 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( dt, opts )

{

	if ( ! DataTable.versionCheck || ! DataTable.versionCheck( '1.10.8' ) ) {

		throw( "Warning: AutoFill requires DataTables 1.10.8 or greater");

	}

	// User and defaults configuration object

	this.c = $.extend( true, {},

		DataTable.defaults.autoFill,

		AutoFill.defaults,

		opts

	);

	/**

	 * @namespace Settings object which contains customisable information for AutoFill instance

	 */

	this.s = {

		/** @type {DataTable.Api} DataTables' API instance */

		dt: new DataTable.Api( dt ),

		/** @type {String} Unique namespace for events attached to the document */

		namespace: '.autoFill'+(_instance++),

		/** @type {Object} Cached dimension information for use in the mouse move event handler */

		scroll: {},

		/** @type {integer} Interval object used for smooth scrolling */

		scrollInterval: null

	};

	/**

	 * @namespace Common and useful DOM elements for the class instance

	 */

	this.dom = {

		/** @type {jQuery} AutoFill handle */

		handle: $('<div class="dt-autofill-handle"/>'),

		/**

		 * @type {Object} Selected cells outline - Need to use 4 elements,

		 *   otherwise the mouse over if you back into the selected rectangle

		 *   will be over that element, rather than the cells!

		 */

		select: {

			top:    $('<div class="dt-autofill-select top"/>'),

			right:  $('<div class="dt-autofill-select right"/>'),

			bottom: $('<div class="dt-autofill-select bottom"/>'),

			left:   $('<div class="dt-autofill-select left"/>')

		},

		/** @type {jQuery} Fill type chooser background */

		background: $('<div class="dt-autofill-background"/>'),

		/** @type {jQuery} Fill type chooser */

		list: $('<div class="dt-autofill-list">'+this.s.dt.i18n('autoFill.info', '')+'<ul/></div>'),

		/** @type {jQuery} DataTables scrolling container */

		dtScroll: null

	};

	/* Constructor logic */

	this._constructor();

};

AutoFill.prototype = {

	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

	 * Constructor

	 */

	/**

	 * Initialise the RowReorder instance

	 *

	 * @private

	 */

	_constructor: function ()

	{

		var that = this;

		var dt = this.s.dt;

		var dtScroll = $('div.dataTables_scrollBody', this.s.dt.table().container());

		if ( dtScroll.length ) {

			this.dom.dtScroll = dtScroll;

			// Need to scroll container to be the offset parent

			if ( dtScroll.css('position') === 'static' ) {

				dtScroll.css( 'position', 'relative' );

			}

		}

		this._focusListener();

		this.dom.handle.on( 'mousedown', function (e) {

			that._mousedown( e );

			return false;

		} );

		dt.on( 'destroy.autoFill', function () {

			dt.off( '.autoFill' );

			$(dt.table().body()).off( that.s.namespace );

			$(document.body).off( that.s.namespace );

		} );

	},

	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

	 * Private methods

	 */

	/**

	 * Display the AutoFill drag handle by appending it to a table cell. This

	 * is the opposite of the _detach method.

	 *

	 * @param  {node} node TD/TH cell to insert the handle into

	 * @private

	 */

	_attach: function ( node )

	{

		var dt = this.s.dt;

		var idx = dt.cell( node ).index();

		if ( ! idx || dt.columns( this.c.columns ).indexes().indexOf( idx.column ) === -1 ) {

			this._detach();

			return;

		}

		this.dom.attachedTo = node;

		this.dom.handle.appendTo( node );

	},

	/**

	 * Determine can the fill type should be. This can be automatic, or ask the

	 * end user.

	 *

	 * @param {array} cells Information about the selected cells from the key

	 *     up function

	 * @private

	 */

	_actionSelector: function ( cells )

	{

		var that = this;

		var dt = this.s.dt;

		var actions = AutoFill.actions;

		var available = [];

		// "Ask" each plug-in if it wants to handle this data

		$.each( actions, function ( key, action ) {

			if ( action.available( dt, cells ) ) {

				available.push( key );

			}

		} );

		if ( available.length === 1 && this.c.alwaysAsk === false ) {

			// Only one action available - enact it immediately

			var result = actions[ available[0] ].execute( dt, cells );

			this._update( result, cells );

		}

		else {

			// Multiple actions available - ask the end user what they want to do

			var list = this.dom.list.children('ul').empty();

			// Add a cancel option

			available.push( 'cancel' );

			$.each( available, function ( i, name ) {

				list.append( $('<li/>')

					.append(

						'<div class="dt-autofill-question">'+

							actions[ name ].option( dt, cells )+

						'<div>'

					)

					.append( $('<div class="dt-autofill-button">' )

						.append( $('<button class="'+AutoFill.classes.btn+'">'+dt.i18n('autoFill.button', '&gt;')+'</button>')

							.on( 'click', function () {

								var result = actions[ name ].execute(

									dt, cells, $(this).closest('li')

								);

								that._update( result, cells );

								that.dom.background.remove();

								that.dom.list.remove();

							} )

						)

					)

				);

			} );

			this.dom.background.appendTo( 'body' );

			this.dom.list.appendTo( 'body' );

			this.dom.list.css( 'margin-top', this.dom.list.outerHeight()/2 * -1 );

		}

	},

	/**

	 * Remove the AutoFill handle from the document

	 *

	 * @private

	 */

	_detach: function ()

	{

		this.dom.attachedTo = null;

		this.dom.handle.detach();

	},

	/**

	 * Draw the selection outline by calculating the range between the start

	 * and end cells, then placing the highlighting elements to draw a rectangle

	 *

	 * @param  {node}   target End cell

	 * @param  {object} e      Originating event

	 * @private

	 */

	_drawSelection: function ( target, e )

	{

		// Calculate boundary for start cell to this one

		var dt = this.s.dt;

		var start = this.s.start;

		var startCell = $(this.dom.start);

		var endCell = $(target);

		var end = {

			row: endCell.parent().index(),

			column: endCell.index()

		};

		// Be sure that is a DataTables controlled cell

		if ( ! dt.cell( endCell ).any() ) {

			return;

		}

		// if target is not in the columns available - do nothing

		if ( dt.columns( this.c.columns ).indexes().indexOf( end.column ) === -1 ) {

			return;

		}

		this.s.end = end;

		var top, bottom, left, right, height, width;

		top    = start.row    < end.row    ? startCell : endCell;

		bottom = start.row    < end.row    ? endCell   : startCell;

		left   = start.column < end.column ? startCell : endCell;

		right  = start.column < end.column ? endCell   : startCell;

		top    = top.position().top;

		left   = left.position().left;

		height = bottom.position().top + bottom.outerHeight() - top;

		width  = right.position().left + right.outerWidth() - left;

		var dtScroll = this.dom.dtScroll;

		if ( dtScroll ) {

			top += dtScroll.scrollTop();

			left += dtScroll.scrollLeft();

		}

		var select = this.dom.select;

		select.top.css( {

			top: top,

			left: left,

			width: width

		} );

		select.left.css( {

			top: top,

			left: left,

			height: height

		} );

		select.bottom.css( {

			top: top + height,

			left: left,

			width: width

		} );

		select.right.css( {

			top: top,

			left: left + width,

			height: height

		} );

	},

	/**

	 * Use the Editor API to perform an update based on the new data for the

	 * cells

	 *

	 * @param {array} cells Information about the selected cells from the key

	 *     up function

	 * @private

	 */

	_editor: function ( cells )

	{

		var dt = this.s.dt;

		var editor = this.c.editor;

		if ( ! editor ) {

			return;

		}

		// Build the object structure for Editor's multi-row editing

		var idValues = {};

		var nodes = [];

		for ( var i=0, ien=cells.length ; i<ien ; i++ ) {

			for ( var j=0, jen=cells[i].length ; j<jen ; j++ ) {

				var cell = cells[i][j];

				// Determine the field name for the cell being edited

				var col = dt.settings()[0].aoColumns[ cell.index.column ];

				var dataSrc = col.editField !== undefined ?

					col.editField :

					col.mData;

				if ( ! dataSrc ) {

					throw 'Could not automatically determine field name. '+

						'Please see https://datatables.net/tn/11';

				}

				if ( ! idValues[ dataSrc ] ) {

					idValues[ dataSrc ] = {};

				}

				var id = dt.row( cell.index.row ).id();

				idValues[ dataSrc ][ id ] = cell.set;

				// Keep a list of cells so we can activate the bubble editing

				// with them

				nodes.push( cell.index );

			}

		}

		// Perform the edit using bubble editing as it allows us to specify

		// the cells to be edited, rather than using full rows

		editor

			.bubble( nodes, false )

			.multiSet( idValues )

			.submit();

	},

	/**

	 * 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 );

		} );

	},

	/**

	 * Attach suitable listeners (based on the configuration) that will attach

	 * and detach the AutoFill handle in the document.

	 *

	 * @private

	 */

	_focusListener: function ()

	{

		var that = this;

		var dt = this.s.dt;

		var namespace = this.s.namespace;

		var focus = this.c.focus !== null ?

			this.c.focus :

			dt.settings()[0].keytable ?

				'focus' :

				'hover';

		// All event listeners attached here are removed in the `destroy`

		// callback in the constructor

		if ( focus === 'focus' ) {

			dt

				.on( 'key-focus.autoFill', function ( e, dt, cell ) {

					that._attach( cell.node() );

				} )

				.on( 'key-blur.autoFill', function ( e, dt, cell ) {

					that._detach();

				} );

		}

		else if ( focus === 'click' ) {

			$(dt.table().body()).on( 'click'+namespace, 'td, th', function (e) {

				that._attach( this );

			} );

			$(document.body).on( 'click'+namespace, function (e) {

				if ( ! $(e.target).parents().filter( dt.table().body() ).length ) {

					that._detach();

				}

			} );

		}

		else {

			$(dt.table().body())

				.on( 'mouseenter'+namespace, 'td, th', function (e) {

					that._attach( this );

				} )

				.on( 'mouseleave'+namespace, function (e) {

					that._detach();

				} );

		}

	},

	/**

	 * Start mouse drag - selects the start cell

	 *

	 * @param  {object} e Mouse down event

	 * @private

	 */

	_mousedown: function ( e )

	{

		var that = this;

		var dt = this.s.dt;

		this.dom.start = this.dom.attachedTo;

		this.s.start = {

			row: $(this.dom.start).parent().index(),

			column: $(this.dom.start).index()

		};

		$(document.body)

			.on( 'mousemove.autoFill', function (e) {

				that._mousemove( e );

			} )

			.on( 'mouseup.autoFill', function (e) {

				that._mouseup( e );

			} );

		var select = this.dom.select;

		var offsetParent = $(this.s.dt.table().body()).offsetParent();

		select.top.appendTo( offsetParent );

		select.left.appendTo( offsetParent );

		select.right.appendTo( offsetParent );

		select.bottom.appendTo( offsetParent );

		this._drawSelection( this.dom.start, e );

		this.dom.handle.css( 'display', 'none' );

		// 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 AutoFill drag, which I think is a fair assumption

		var scrollWrapper = this.dom.dtScroll;

		this.s.scroll = {

			windowHeight: $(window).height(),

			windowWidth:  $(window).width(),

			dtTop:        scrollWrapper ? scrollWrapper.offset().top : null,

			dtLeft:       scrollWrapper ? scrollWrapper.offset().left : null,

			dtHeight:     scrollWrapper ? scrollWrapper.outerHeight() : null,

			dtWidth:      scrollWrapper ? scrollWrapper.outerWidth() : null

		};

	},

	/**

	 * Mouse drag - selects the end cell and update the selection display for

	 * the end user

	 *

	 * @param  {object} e Mouse move event

	 * @private

	 */

	_mousemove: function ( e )

	{

		var that = this;

		var dt = this.s.dt;

		var name = e.target.nodeName.toLowerCase();

		if ( name !== 'td' && name !== 'th' ) {

			return;

		}

		this._drawSelection( e.target, e );

		this._shiftScroll( e );

	},

	/**

	 * End mouse drag - perform the update actions

	 *

	 * @param  {object} e Mouse up event

	 * @private

	 */

	_mouseup: function ( e )

	{

		$(document.body).off( '.autoFill' );

		var dt = this.s.dt;

		var select = this.dom.select;

		select.top.remove();

		select.left.remove();

		select.right.remove();

		select.bottom.remove();

		this.dom.handle.css( 'display', 'block' );

		// Display complete - now do something useful with the selection!

		var start = this.s.start;

		var end = this.s.end;

		// Haven't selected multiple cells, so nothing to do

		if ( start.row === end.row && start.column === end.column ) {

			return;

		}

		// Build a matrix representation of the selected rows

		var rows     = this._range( start.row, end.row );

		var columns  = this._range( start.column, end.column );

		var selected = [];

		// Can't use Array.prototype.map as IE8 doesn't support it

		// Can't use $.map as jQuery flattens 2D arrays

		// Need to use a good old fashioned for loop

		for ( var rowIdx=0 ; rowIdx<rows.length ; rowIdx++ ) {

			selected.push(

				$.map( columns, function (column) {

					var cell = dt.cell( ':eq('+rows[rowIdx]+')', column+':visible', {page:'current'} );

					return {

						cell:  cell,

						data:  cell.data(),

						index: cell.index()

					};

				} )

			);

		}

		this._actionSelector( selected );

	},

	/**

	 * Create an array with a range of numbers defined by the start and end

	 * parameters passed in (inclusive!).

	 *

	 * @param  {integer} start Start

	 * @param  {integer} end   End

	 * @private

	 */

	_range: function ( start, end )

	{

		var out = [];

		var i;

		if ( start <= end ) {

			for ( i=start ; i<=end ; i++ ) {

				out.push( i );

			}

		}

		else {

			for ( i=start ; i>=end ; i-- ) {

				out.push( i );

			}

		}

		return out;

	},

	/**

	 * Move the window and DataTables scrolling during a drag to scroll new

	 * content into view. This is done by proximity to the edge of the scrolling

	 * container of the mouse - for example near the top edge of the window

	 * should scroll up. This is a little complicated as there are two elements

	 * that can be scrolled - the window and the DataTables scrolling view port

	 * (if scrollX and / or scrollY is enabled).

	 *

	 * @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,

			windowX = e.pageX - document.body.scrollLeft,

			windowVert, windowHoriz,

			dtVert, dtHoriz;

		// 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;

		}

		if ( windowX < buffer ) {

			windowHoriz = scrollSpeed * -1;

		}

		else if ( windowX > scroll.windowWidth - buffer ) {

			windowHoriz = 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;

		}

		if ( scroll.dtLeft !== null && e.pageX < scroll.dtLeft + buffer ) {

			dtHoriz = scrollSpeed * -1;

		}

		else if ( scroll.dtLeft !== null && e.pageX > scroll.dtLeft + scroll.dtWidth - buffer ) {

			dtHoriz = 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 || windowHoriz || dtVert || dtHoriz ) {

			scroll.windowVert = windowVert;

			scroll.windowHoriz = windowHoriz;

			scroll.dtVert = dtVert;

			scroll.dtHoriz = dtHoriz;

			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;

				}

				if ( scroll.windowHoriz ) {

					document.body.scrollLeft += scroll.windowHoriz;

				}

				// DataTables scrolling

				if ( scroll.dtVert || scroll.dtHoriz ) {

					var scroller = that.dom.dtScroll[0];

					if ( scroll.dtVert ) {

						scroller.scrollTop += scroll.dtVert;

					}

					if ( scroll.dtHoriz ) {

						scroller.scrollLeft += scroll.dtHoriz;

					}

				}

			}, 20 );

		}

	},

	/**

	 * Update the DataTable after the user has selected what they want to do

	 *

	 * @param  {false|undefined} result Return from the `execute` method - can

	 *   be false internally to do nothing. This is not documented for plug-ins

	 *   and is used only by the cancel option.

	 * @param {array} cells Information about the selected cells from the key

	 *     up function, argumented with the set values

	 * @private

	 */

	_update: function ( result, cells )

	{

		// Do nothing on `false` return from an execute function

		if ( result === false ) {

			return;

		}

		var dt = this.s.dt;

		var cell;

		// Potentially allow modifications to the cells matrix

		this._emitEvent( 'preAutoFill', [ dt, cells ] );

		this._editor( cells );

		// Automatic updates are not performed if `update` is null and the

		// `editor` parameter is passed in - the reason being that Editor will

		// update the data once submitted

		var update = this.c.update !== null ?

			this.c.update :

			this.c.editor ?

				false :

				true;

		if ( update ) {

			for ( var i=0, ien=cells.length ; i<ien ; i++ ) {

				for ( var j=0, jen=cells[i].length ; j<jen ; j++ ) {

					cell = cells[i][j];

					cell.cell.data( cell.set );

				}

			}

			dt.draw(false);

		}

		this._emitEvent( 'autoFill', [ dt, cells ] );

	}

};

/**

 * AutoFill actions. The options here determine how AutoFill will fill the data

 * in the table when the user has selected a range of cells. Please see the

 * documentation on the DataTables site for full details on how to create plug-

 * ins.

 *

 * @type {Object}

 */

AutoFill.actions = {

	increment: {

		available: function ( dt, cells ) {

			return $.isNumeric( cells[0][0].data );

		},

		option: function ( dt, cells ) {

			return dt.i18n(

				'autoFill.increment',

				'Increment / decrement each cell by: <input type="number" value="1">'

			);

		},

		execute: function ( dt, cells, node ) {

			var value = cells[0][0].data * 1;

			var increment = $('input', node).val() * 1;

			for ( var i=0, ien=cells.length ; i<ien ; i++ ) {

				for ( var j=0, jen=cells[i].length ; j<jen ; j++ ) {

					cells[i][j].set = value;

					value += increment;

				}

			}

		}

	},

	fill: {

		available: function ( dt, cells ) {

			return true;

		},

		option: function ( dt, cells ) {

			return dt.i18n('autoFill.fill', 'Fill all cells with <i>'+cells[0][0].data+'</i>' );

		},

		execute: function ( dt, cells, node ) {

			var value = cells[0][0].data;

			for ( var i=0, ien=cells.length ; i<ien ; i++ ) {

				for ( var j=0, jen=cells[i].length ; j<jen ; j++ ) {

					cells[i][j].set = value;

				}

			}

		}

	},

	fillHorizontal: {

		available: function ( dt, cells ) {

			return cells.length > 1 && cells[0].length > 1;

		},

		option: function ( dt, cells ) {

			return dt.i18n('autoFill.fillHorizontal', 'Fill cells horizontally' );

		},

		execute: function ( dt, cells, node ) {

			for ( var i=0, ien=cells.length ; i<ien ; i++ ) {

				for ( var j=0, jen=cells[i].length ; j<jen ; j++ ) {

					cells[i][j].set = cells[i][0].data;

				}

			}

		}

	},

	fillVertical: {

		available: function ( dt, cells ) {

			return cells.length > 1 && cells[0].length > 1;

		},

		option: function ( dt, cells ) {

			return dt.i18n('autoFill.fillVertical', 'Fill cells vertically' );

		},

		execute: function ( dt, cells, node ) {

			for ( var i=0, ien=cells.length ; i<ien ; i++ ) {

				for ( var j=0, jen=cells[i].length ; j<jen ; j++ ) {

					cells[i][j].set = cells[0][j].data;

				}

			}

		}

	},

	// Special type that does not make itself available, but is added

	// automatically by AutoFill if a multi-choice list is shown. This allows

	// sensible code reuse

	cancel: {

		available: function () {

			return false;

		},

		option: function ( dt ) {

			return dt.i18n('autoFill.cancel', 'Cancel' );

		},

		execute: function () {

			return false;

		}

	}

};

/**

 * AutoFill version

 *

 * @static

 * @type      String

 */

AutoFill.version = '2.0.0';

/**

 * AutoFill defaults

 *

 * @namespace

 */

AutoFill.defaults = {

	/** @type {Boolean} Ask user what they want to do, even for a single option */

	alwaysAsk: false,

	/** @type {string|null} What will trigger a focus */

	focus: null, // focus, click, hover

	/** @type {column-selector} Columns to provide auto fill for */

	columns: '', // all

	/** @type {boolean|null} Update the cells after a drag */

	update: null, // false is editor given, true otherwise

	/** @type {DataTable.Editor} Editor instance for automatic submission */

	editor: null

};

/**

 * Classes used by AutoFill that are configurable

 *

 * @namespace

 */

AutoFill.classes = {

	/** @type {String} Class used by the selection button */

	btn: 'btn'

};

// Attach a listener to the document which listens for DataTables initialisation

// events so we can automatically initialise

$(document).on( 'init.dt.autofill', function (e, settings, json) {

	if ( e.namespace !== 'dt' ) {

		return;

	}

	var init = settings.oInit.autoFill;

	var defaults = DataTable.defaults.autoFill;

	if ( init || defaults ) {

		var opts = $.extend( {}, init, defaults );

		if ( init !== false ) {

			new AutoFill( settings, opts  );

		}

	}

} );

// Alias for access

DataTable.AutoFill = AutoFill;

DataTable.AutoFill = AutoFill;

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));