|
|
@@ -1,855 +0,0 @@
|
|
|
-/*! 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));
|
|
|
-
|