secure-sharing/SecureSharing/wwwroot/plugins/datatables-autofill/js/dataTables.autoFill.js

/*! AutoFill 2.3.5
 * ©2008-2020 SpryMedia Ltd - datatables.net/license
 */

/**
 * @summary     AutoFill
 * @description Add Excel like click and drag auto-fill options to DataTables
 * @version     2.3.5
 * @file        dataTables.autoFill.js
 * @author      SpryMedia Ltd (www.sprymedia.co.uk)
 * @contact     www.sprymedia.co.uk/contact
 * @copyright   Copyright 2010-2020 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;


    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,

            handle: {
                height: 0,
                width: 0
            },

            /**
             * Enabled setting
             * @type {Boolean}
             */
            enabled: false
        };


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

            /** @type {jQuery} Offset parent element */
            offsetParent: null
        };


        /* Constructor logic */
        this._constructor();
    };


    $.extend(AutoFill.prototype, {
        /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
         * Public methods (exposed via the DataTables API below)
         */
        enabled: function () {
            return this.s.enabled;
        },


        enable: function (flag) {
            var that = this;

            if (flag === false) {
                return this.disable();
            }

            this.s.enabled = true;

            this._focusListener();

            this.dom.handle.on('mousedown', function (e) {
                that._mousedown(e);
                return false;
            });

            return this;
        },

        disable: function () {
            this.s.enabled = false;

            this._focusListenerRemove();

            return this;
        },


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

            // Make the instance accessible to the API
            dt.settings()[0].autoFill = this;

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

            if (this.c.enable !== false) {
                this.enable();
            }

            dt.on('destroy.autoFill', function () {
                that._focusListenerRemove();
            });
        },


        /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
         * 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();
            var handle = this.dom.handle;
            var handleDim = this.s.handle;

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

            if (!this.dom.offsetParent) {
                // We attach to the table's offset parent
                this.dom.offsetParent = $(dt.table().node()).offsetParent();
            }

            if (!handleDim.height || !handleDim.width) {
                // Append to document so we can get its size. Not expecting it to
                // change during the life time of the page
                handle.appendTo('body');
                handleDim.height = handle.outerHeight();
                handleDim.width = handle.outerWidth();
            }

            // Might need to go through multiple offset parents
            var offset = this._getPosition(node, this.dom.offsetParent);

            this.dom.attachedTo = node;
            handle
                .css({
                    top: offset.top + node.offsetHeight - handleDim.height,
                    left: offset.left + node.offsetWidth - handleDim.width
                })
                .appendTo(this.dom.offsetParent);
        },


        /**
         * 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 if (available.length > 1) {
                // 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 end = {
                row: this.c.vertical ?
                    dt.rows({page: 'current'}).nodes().indexOf(target.parentNode) :
                    start.row,
                column: this.c.horizontal ?
                    $(target).index() :
                    start.column
            };
            var colIndx = dt.column.index('toData', end.column);
            var endRow = dt.row(':eq(' + end.row + ')', {page: 'current'}); // Workaround for M581
            var endCell = $(dt.cell(endRow.index(), colIndx).node());

            // 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(colIndx) === -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 = this._getPosition(top.get(0)).top;
            left = this._getPosition(left.get(0)).left;
            height = this._getPosition(bottom.get(0)).top + bottom.outerHeight() - top;
            width = this._getPosition(right.get(0)).left + right.outerWidth() - left;

            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 = [];
            var fields = editor.fields();

            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 fieldName = col.editField;

                    if (fieldName === undefined) {
                        var dataSrc = col.mData;

                        // dataSrc is the `field.data` property, but we need to set
                        // using the field name, so we need to translate from the
                        // data to the name
                        for (var k = 0, ken = fields.length; k < ken; k++) {
                            var field = editor.field(fields[k]);

                            if (field.dataSrc() === dataSrc) {
                                fieldName = field.name();
                                break;
                            }
                        }
                    }

                    if (!fieldName) {
                        throw 'Could not automatically determine field data. ' +
                        'Please see https://datatables.net/tn/11';
                    }

                    if (!idValues[fieldName]) {
                        idValues[fieldName] = {};
                    }

                    var id = dt.row(cell.index.row).id();
                    idValues[fieldName][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.init().keys || 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) {
                        if ($(e.relatedTarget).hasClass('dt-autofill-handle')) {
                            return;
                        }

                        that._detach();
                    });
            }
        },


        _focusListenerRemove: function () {
            var dt = this.s.dt;

            dt.off('.autoFill');
            $(dt.table().body()).off(this.s.namespace);
            $(document.body).off(this.s.namespace);
        },


        /**
         * Get the position of a node, relative to another, including any scrolling
         * offsets.
         * @param  {Node}   node         Node to get the position of
         * @param  {jQuery} targetParent Node to use as the parent
         * @return {object}              Offset calculation
         * @private
         */
        _getPosition: function (node, targetParent) {
            var
                currNode = node,
                currOffsetParent,
                top = 0,
                left = 0;

            if (!targetParent) {
                targetParent = $($(this.s.dt.table().node())[0].offsetParent);
            }

            do {
                // Don't use jQuery().position() the behaviour changes between 1.x and 3.x for
                // tables
                var positionTop = currNode.offsetTop;
                var positionLeft = currNode.offsetLeft;

                // jQuery doesn't give a `table` as the offset parent oddly, so use DOM directly
                currOffsetParent = $(currNode.offsetParent);

                top += positionTop + parseInt(currOffsetParent.css('border-top-width')) * 1;
                left += positionLeft + parseInt(currOffsetParent.css('border-left-width')) * 1;

                // Emergency fall back. Shouldn't happen, but just in case!
                if (currNode.nodeName.toLowerCase() === 'body') {
                    break;
                }

                currNode = currOffsetParent.get(0); // for next loop
            }
            while (currOffsetParent.get(0) !== targetParent.get(0))

            return {
                top: top,
                left: left
            };
        },


        /**
         * 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: dt.rows({page: 'current'}).nodes().indexOf($(this.dom.start).parent()[0]),
                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 = $(dt.table().node()).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 that = this;
            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;
            }

            var startDt = dt.cell(':eq(' + start.row + ')', start.column + ':visible', {page: 'current'});

            // If Editor is active inside this cell (inline editing) we need to wait for Editor to
            // submit and then we can loop back and trigger the fill.
            if ($('div.DTE', startDt.node()).length) {
                var editor = dt.editor();

                editor
                    .on('submitSuccess.dtaf close.dtaf', function () {
                        editor.off('.dtaf');

                        setTimeout(function () {
                            that._mouseup(e);
                        }, 100);
                    })
                    .on('submitComplete.dtaf preSubmitCancelled.dtaf close.dtaf', function () {
                        editor.off('.dtaf');
                    });

                // Make the current input submit
                editor.submit();

                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 = [];
            var dtSettings = dt.settings()[0];
            var dtColumns = dtSettings.aoColumns;
            var enabledColumns = dt.columns(this.c.columns).indexes();

            // 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 row = dt.row(':eq(' + rows[rowIdx] + ')', {page: 'current'}); // Workaround for M581
                        var cell = dt.cell(row.index(), column + ':visible');
                        var data = cell.data();
                        var cellIndex = cell.index();
                        var editField = dtColumns[cellIndex.column].editField;

                        if (editField !== undefined) {
                            data = dtSettings.oApi._fnGetObjectDataFn(editField)(dt.row(cellIndex.row).data());
                        }

                        if (enabledColumns.indexOf(cellIndex.column) === -1) {
                            return;
                        }

                        return {
                            cell: cell,
                            data: data,
                            label: cell.data(),
                            index: cellIndex
                        };
                    })
                );
            }

            this._actionSelector(selected);

            // Stop shiftScroll
            clearInterval(this.s.scrollInterval);
            this.s.scrollInterval = null;
        },


        /**
         * 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;
            var columns = dt.columns(this.c.columns).indexes();

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

                        if (columns.indexOf(cell.index.column) !== -1) {
                            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) {
                var d = cells[0][0].label;

                // is numeric test based on jQuery's old `isNumeric` function
                return !isNaN(d - parseFloat(d));
            },

            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].label + '</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;
            },

            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.3.5';


    /**
     * 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} Enable AutoFill on load */
        enable: true,

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

        /** @type {boolean} Enable vertical fill */
        vertical: true,

        /** @type {boolean} Enable horizontal fill */
        horizontal: true
    };


    /**
     * Classes used by AutoFill that are configurable
     *
     * @namespace
     */
    AutoFill.classes = {
        /** @type {String} Class used by the selection button */
        btn: 'btn'
    };


    /*
     * API
     */
    var Api = $.fn.dataTable.Api;

// Doesn't do anything - Not documented
    Api.register('autoFill()', function () {
        return this;
    });

    Api.register('autoFill().enabled()', function () {
        var ctx = this.context[0];

        return ctx.autoFill ?
            ctx.autoFill.enabled() :
            false;
    });

    Api.register('autoFill().enable()', function (flag) {
        return this.iterator('table', function (ctx) {
            if (ctx.autoFill) {
                ctx.autoFill.enable(flag);
            }
        });
    });

    Api.register('autoFill().disable()', function () {
        return this.iterator('table', function (ctx) {
            if (ctx.autoFill) {
                ctx.autoFill.disable();
            }
        });
    });


// Attach a listener to the document which listens for DataTables initialisation
// events so we can automatically initialise
    $(document).on('preInit.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;
}));