820 lines
20 KiB
JavaScript
820 lines
20 KiB
JavaScript
/*
|
|
* File: AutoFill.js
|
|
* Version: 1.1.2
|
|
* CVS: $Id$
|
|
* Description: AutoFill for DataTables
|
|
* Author: Allan Jardine (www.sprymedia.co.uk)
|
|
* Created: Mon 6 Sep 2010 16:54:41 BST
|
|
* Modified: $Date$ by $Author$
|
|
* Language: Javascript
|
|
* License: GPL v2 or BSD 3 point
|
|
* Project: DataTables
|
|
* Contact: www.sprymedia.co.uk/contact
|
|
*
|
|
* Copyright 2010-2011 Allan Jardine, all rights reserved.
|
|
*
|
|
* This source file is free software, under either the GPL v2 license or a
|
|
* BSD style license, available at:
|
|
* http://datatables.net/license_gpl2
|
|
* http://datatables.net/license_bsd
|
|
*
|
|
*/
|
|
|
|
/* Global scope for AutoFill */
|
|
var AutoFill;
|
|
|
|
(function($) {
|
|
|
|
/**
|
|
* AutoFill provides Excel like auto fill features for a DataTable
|
|
* @class AutoFill
|
|
* @constructor
|
|
* @param {object} DataTables settings object
|
|
* @param {object} Configuration object for AutoFill
|
|
*/
|
|
AutoFill = function( oDT, oConfig )
|
|
{
|
|
/* Santiy check that we are a new instance */
|
|
if ( !this.CLASS || this.CLASS != "AutoFill" )
|
|
{
|
|
alert( "Warning: AutoFill must be initialised with the keyword 'new'" );
|
|
return;
|
|
}
|
|
|
|
if ( !$.fn.dataTableExt.fnVersionCheck('1.7.0') )
|
|
{
|
|
alert( "Warning: AutoFill requires DataTables 1.7 or greater - www.datatables.net/download");
|
|
return;
|
|
}
|
|
|
|
|
|
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
|
* Public class variables
|
|
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
|
|
|
/**
|
|
* @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} oDT DataTables settings object
|
|
* @param {object} oConfig Configuration object for AutoFill
|
|
* @returns void
|
|
*/
|
|
"_fnInit": function ( oDT, oConfig )
|
|
{
|
|
var
|
|
that = this,
|
|
i, iLen;
|
|
|
|
/*
|
|
* Settings
|
|
*/
|
|
this.s.dt = oDT.fnSettings();
|
|
|
|
this.dom.table = this.s.dt.nTable;
|
|
|
|
/* Add and configure the columns */
|
|
for ( i=0, iLen=this.s.dt.aoColumns.length ; i<iLen ; i++ )
|
|
{
|
|
this._fnAddColumn( i );
|
|
}
|
|
|
|
if ( typeof oConfig != 'undefined' && typeof oConfig.aoColumnDefs != 'undefined' )
|
|
{
|
|
this._fnColumnDefs( oConfig.aoColumnDefs );
|
|
}
|
|
|
|
if ( typeof oConfig != 'undefined' && typeof oConfig.aoColumns != 'undefined' )
|
|
{
|
|
this._fnColumnsAll( oConfig.aoColumns );
|
|
}
|
|
|
|
|
|
/*
|
|
* DOM
|
|
*/
|
|
|
|
/* Auto Fill click and drag icon */
|
|
var filler = document.createElement('div');
|
|
filler.className = "AutoFill_filler";
|
|
document.body.appendChild( filler );
|
|
this.dom.filler = filler;
|
|
|
|
filler.style.display = "block";
|
|
this.s.filler.height = $(filler).height();
|
|
this.s.filler.width = $(filler).width();
|
|
filler.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 = document.createElement('div');
|
|
border.className = "AutoFill_border";
|
|
appender.appendChild( border );
|
|
this.dom.borderTop = border;
|
|
|
|
border = document.createElement('div');
|
|
border.className = "AutoFill_border";
|
|
appender.appendChild( border );
|
|
this.dom.borderRight = border;
|
|
|
|
border = document.createElement('div');
|
|
border.className = "AutoFill_border";
|
|
appender.appendChild( border );
|
|
this.dom.borderBottom = border;
|
|
|
|
border = document.createElement('div');
|
|
border.className = "AutoFill_border";
|
|
appender.appendChild( border );
|
|
this.dom.borderLeft = border;
|
|
|
|
/*
|
|
* Events
|
|
*/
|
|
|
|
$(filler).mousedown( function (e) {
|
|
this.onselectstart = function() { return false; };
|
|
that._fnFillerDragStart.call( that, e );
|
|
return false;
|
|
} );
|
|
|
|
$('tbody>tr>td', this.dom.table).live( 'mouseover mouseout', function (e) {
|
|
that._fnFillerDisplay.call( that, e );
|
|
} );
|
|
},
|
|
|
|
|
|
"_fnColumnDefs": function ( aoColumnDefs )
|
|
{
|
|
var
|
|
i, j, k, iLen, jLen, kLen,
|
|
aTargets;
|
|
|
|
/* Loop over the column defs array - loop in reverse so first instace has priority */
|
|
for ( i=aoColumnDefs.length-1 ; i>=0 ; i-- )
|
|
{
|
|
/* Each column def can target multiple columns, as it is an array */
|
|
aTargets = aoColumnDefs[i].aTargets;
|
|
for ( j=0, jLen=aTargets.length ; j<jLen ; j++ )
|
|
{
|
|
if ( typeof aTargets[j] == 'number' && aTargets[j] >= 0 )
|
|
{
|
|
/* 0+ integer, left to right column counting. */
|
|
this._fnColumnOptions( aTargets[j], aoColumnDefs[i] );
|
|
}
|
|
else if ( typeof aTargets[j] == 'number' && aTargets[j] < 0 )
|
|
{
|
|
/* Negative integer, right to left column counting */
|
|
this._fnColumnOptions( this.s.dt.aoColumns.length+aTargets[j], aoColumnDefs[i] );
|
|
}
|
|
else if ( typeof aTargets[j] == 'string' )
|
|
{
|
|
/* Class name matching on TH element */
|
|
for ( k=0, kLen=this.s.dt.aoColumns.length ; k<kLen ; k++ )
|
|
{
|
|
if ( aTargets[j] == "_all" ||
|
|
this.s.dt.aoColumns[k].nTh.className.indexOf( aTargets[j] ) != -1 )
|
|
{
|
|
this._fnColumnOptions( k, aoColumnDefs[i] );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
|
|
"_fnColumnsAll": function ( aoColumns )
|
|
{
|
|
for ( var i=0, iLen=this.s.dt.aoColumns.length ; i<iLen ; i++ )
|
|
{
|
|
this._fnColumnOptions( i, aoColumns[i] );
|
|
}
|
|
},
|
|
|
|
|
|
"_fnAddColumn": function ( i )
|
|
{
|
|
this.s.columns[i] = {
|
|
"enable": true,
|
|
"read": this._fnReadCell,
|
|
"write": this._fnWriteCell,
|
|
"step": this._fnStep,
|
|
"complete": null
|
|
};
|
|
},
|
|
|
|
"_fnColumnOptions": function ( i, opts )
|
|
{
|
|
if ( typeof opts.bEnable != 'undefined' )
|
|
{
|
|
this.s.columns[i].enable = opts.bEnable;
|
|
}
|
|
|
|
if ( typeof opts.fnRead != 'undefined' )
|
|
{
|
|
this.s.columns[i].read = opts.fnRead;
|
|
}
|
|
|
|
if ( typeof opts.fnWrite != 'undefined' )
|
|
{
|
|
this.s.columns[i].write = opts.fnWrite;
|
|
}
|
|
|
|
if ( typeof opts.fnStep != 'undefined' )
|
|
{
|
|
this.s.columns[i].step = opts.fnStep;
|
|
}
|
|
|
|
if ( typeof opts.fnCallback != 'undefined' )
|
|
{
|
|
this.s.columns[i].complete = opts.fnCallback;
|
|
}
|
|
},
|
|
|
|
|
|
/**
|
|
* 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];
|
|
|
|
return {
|
|
"x": $('td', nTr).index(nTd),
|
|
"y": $('tr', nTr.parentNode).index(nTr)
|
|
};
|
|
},
|
|
|
|
|
|
/**
|
|
* 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;
|
|
|
|
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 ( coords.x != this.s.drag.startX )
|
|
{
|
|
e.target = $('tbody>tr:eq('+coords.y+')>td:eq('+this.s.drag.startX+')', this.dom.table)[0];
|
|
coords = this._fnTargetCoords( e.target );
|
|
}
|
|
|
|
if ( coords.x == this.s.drag.startX )
|
|
{
|
|
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;
|
|
|
|
$(document).unbind('mousemove.AutoFill');
|
|
$(document).unbind('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 coordsStart = this._fnTargetCoords( this.s.drag.startTd );
|
|
var coordsEnd = this._fnTargetCoords( this.s.drag.endTd );
|
|
var aTds = [];
|
|
var bIncrement;
|
|
|
|
if ( coordsStart.y <= coordsEnd.y )
|
|
{
|
|
bIncrement = true;
|
|
for ( i=coordsStart.y ; i<=coordsEnd.y ; i++ )
|
|
{
|
|
aTds.push( $('tbody>tr:eq('+i+')>td:eq('+coordsStart.x+')', this.dom.table)[0] );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bIncrement = false;
|
|
for ( i=coordsStart.y ; i>=coordsEnd.y ; i-- )
|
|
{
|
|
aTds.push( $('tbody>tr:eq('+i+')>td:eq('+coordsStart.x+')', this.dom.table)[0] );
|
|
}
|
|
}
|
|
|
|
|
|
var iColumn = coordsStart.x;
|
|
var bLast = false;
|
|
var aoEdited = [];
|
|
var sStart = this.s.columns[iColumn].read.call( this, this.s.drag.startTd );
|
|
var oPrepped = this._fnPrep( sStart );
|
|
|
|
for ( i=0, iLen=aTds.length ; i<iLen ; i++ )
|
|
{
|
|
if ( i==iLen-1 )
|
|
{
|
|
bLast = true;
|
|
}
|
|
|
|
var original = this.s.columns[iColumn].read.call( this, aTds[i] );
|
|
var step = this.s.columns[iColumn].step.call( this, aTds[i], oPrepped, i, bIncrement,
|
|
'SPRYMEDIA_AUTOFILL_STEPPER' );
|
|
this.s.columns[iColumn].write.call( this, aTds[i], step, bLast );
|
|
|
|
aoEdited.push( {
|
|
"td": aTds[i],
|
|
"newValue": step,
|
|
"oldValue": original
|
|
} );
|
|
}
|
|
|
|
if ( this.s.columns[iColumn].complete !== null )
|
|
{
|
|
this.s.columns[iColumn].complete.call( this, aoEdited );
|
|
}
|
|
},
|
|
|
|
|
|
/**
|
|
* Chunk a string such that it can be filled in by the stepper function
|
|
* @method _fnPrep
|
|
* @param {String} sStr String to prep
|
|
* @returns {Object} with parameters, iStart, sStr and sPostFix
|
|
*/
|
|
"_fnPrep": function ( sStr )
|
|
{
|
|
var aMatch = sStr.match(/[\d\.]+/g);
|
|
if ( !aMatch || aMatch.length === 0 )
|
|
{
|
|
return {
|
|
"iStart": 0,
|
|
"sStr": sStr,
|
|
"sPostFix": ""
|
|
};
|
|
}
|
|
|
|
var sLast = aMatch[ aMatch.length-1 ];
|
|
var num = parseInt(sLast, 10);
|
|
var regex = new RegExp( '^(.*)'+sLast+'(.*?)$' );
|
|
var decimal = sLast.match(/\./) ? "."+sLast.split('.')[1] : "";
|
|
|
|
return {
|
|
"iStart": num,
|
|
"sStr": sStr.replace(regex, "$1SPRYMEDIA_AUTOFILL_STEPPER$2"),
|
|
"sPostFix": decimal
|
|
};
|
|
},
|
|
|
|
|
|
/**
|
|
* Render a string for it's position in the table after the drag (incrememt numbers)
|
|
* @method _fnStep
|
|
* @param {Node} nTd Cell being written to
|
|
* @param {Object} oPrepped Prepared object for the stepper (from _fnPrep)
|
|
* @param {Int} iDiff Step difference
|
|
* @param {Boolean} bIncrement Increment (true) or decriment (false)
|
|
* @param {String} sToken Token to replace
|
|
* @returns {String} Rendered information
|
|
*/
|
|
"_fnStep": function ( nTd, oPrepped, iDiff, bIncrement, sToken )
|
|
{
|
|
var iReplace = bIncrement ? (oPrepped.iStart+iDiff) : (oPrepped.iStart-iDiff);
|
|
if ( isNaN(iReplace) )
|
|
{
|
|
iReplace = "";
|
|
}
|
|
return oPrepped.sStr.replace( sToken, iReplace+oPrepped.sPostFix );
|
|
},
|
|
|
|
|
|
/**
|
|
* Read informaiton from a cell, possibly using live DOM elements if suitable
|
|
* @method _fnReadCell
|
|
* @param {Node} nTd Cell to read
|
|
* @returns {String} Read value
|
|
*/
|
|
"_fnReadCell": function ( nTd )
|
|
{
|
|
var jq = $('input', nTd);
|
|
if ( jq.length > 0 )
|
|
{
|
|
return $(jq).val();
|
|
}
|
|
|
|
jq = $('select', nTd);
|
|
if ( jq.length > 0 )
|
|
{
|
|
return $(jq).val();
|
|
}
|
|
|
|
return nTd.innerHTML;
|
|
},
|
|
|
|
|
|
/**
|
|
* Write informaiton to a cell, possibly using live DOM elements if suitable
|
|
* @method _fnWriteCell
|
|
* @param {Node} nTd Cell to write
|
|
* @param {String} sVal Value to write
|
|
* @param {Boolean} bLast Flag to show if this is that last update
|
|
* @returns void
|
|
*/
|
|
"_fnWriteCell": function ( nTd, sVal, bLast )
|
|
{
|
|
var jq = $('input', nTd);
|
|
if ( jq.length > 0 )
|
|
{
|
|
$(jq).val( sVal );
|
|
return;
|
|
}
|
|
|
|
jq = $('select', nTd);
|
|
if ( jq.length > 0 )
|
|
{
|
|
$(jq).val( sVal );
|
|
return;
|
|
}
|
|
|
|
var pos = this.s.dt.oInstance.fnGetPosition( nTd );
|
|
this.s.dt.oInstance.fnUpdate( sVal, pos[0], pos[2], bLast );
|
|
},
|
|
|
|
|
|
/**
|
|
* Display the drag handle on mouse over cell
|
|
* @method _fnFillerDisplay
|
|
* @param {Object} e Event object
|
|
* @returns void
|
|
*/
|
|
"_fnFillerDisplay": function (e)
|
|
{
|
|
/* 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).x;
|
|
if ( !this.s.columns[iX].enable )
|
|
{
|
|
return;
|
|
}
|
|
|
|
var filler = this.dom.filler;
|
|
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";
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
|
* Constants
|
|
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
|
|
|
/**
|
|
* Name of this class
|
|
* @constant CLASS
|
|
* @type String
|
|
* @default AutoFill
|
|
*/
|
|
AutoFill.prototype.CLASS = "AutoFill";
|
|
|
|
|
|
/**
|
|
* AutoFill version
|
|
* @constant VERSION
|
|
* @type String
|
|
* @default 1.1.2
|
|
*/
|
|
AutoFill.VERSION = "1.1.2";
|
|
AutoFill.prototype.VERSION = AutoFill.VERSION;
|
|
|
|
|
|
})(jQuery); |