forked from ScoDoc/ScoDoc
821 lines
21 KiB
JavaScript
821 lines
21 KiB
JavaScript
/*! RowReorder 1.2.8
|
|
* 2015-2020 SpryMedia Ltd - datatables.net/license
|
|
*/
|
|
|
|
/**
|
|
* @summary RowReorder
|
|
* @description Row reordering extension for DataTables
|
|
* @version 1.2.8
|
|
* @file dataTables.rowReorder.js
|
|
* @author SpryMedia Ltd (www.sprymedia.co.uk)
|
|
* @contact www.sprymedia.co.uk/contact
|
|
* @copyright Copyright 2015-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;
|
|
|
|
|
|
/**
|
|
* RowReorder provides the ability in DataTables to click and drag rows to
|
|
* reorder them. When a row is dropped the data for the rows effected will be
|
|
* updated to reflect the change. Normally this data point should also be the
|
|
* column being sorted upon in the DataTable but this does not need to be the
|
|
* case. RowReorder implements a "data swap" method - so the rows being
|
|
* reordered take the value of the data point from the row that used to occupy
|
|
* the row's new position.
|
|
*
|
|
* Initialisation is done by either:
|
|
*
|
|
* * `rowReorder` parameter in the DataTable initialisation object
|
|
* * `new $.fn.dataTable.RowReorder( table, opts )` after DataTables
|
|
* initialisation.
|
|
*
|
|
* @class
|
|
* @param {object} settings DataTables settings object for the host table
|
|
* @param {object} [opts] Configuration options
|
|
* @requires jQuery 1.7+
|
|
* @requires DataTables 1.10.7+
|
|
*/
|
|
var RowReorder = function ( dt, opts ) {
|
|
// Sanity check that we are using DataTables 1.10 or newer
|
|
if ( ! DataTable.versionCheck || ! DataTable.versionCheck( '1.10.8' ) ) {
|
|
throw 'DataTables RowReorder requires DataTables 1.10.8 or newer';
|
|
}
|
|
|
|
// User and defaults configuration object
|
|
this.c = $.extend( true, {},
|
|
DataTable.defaults.rowReorder,
|
|
RowReorder.defaults,
|
|
opts
|
|
);
|
|
|
|
// Internal settings
|
|
this.s = {
|
|
/** @type {integer} Scroll body top cache */
|
|
bodyTop: null,
|
|
|
|
/** @type {DataTable.Api} DataTables' API instance */
|
|
dt: new DataTable.Api( dt ),
|
|
|
|
/** @type {function} Data fetch function */
|
|
getDataFn: DataTable.ext.oApi._fnGetObjectDataFn( this.c.dataSrc ),
|
|
|
|
/** @type {array} Pixel positions for row insertion calculation */
|
|
middles: null,
|
|
|
|
/** @type {Object} Cached dimension information for use in the mouse move event handler */
|
|
scroll: {},
|
|
|
|
/** @type {integer} Interval object used for smooth scrolling */
|
|
scrollInterval: null,
|
|
|
|
/** @type {function} Data set function */
|
|
setDataFn: DataTable.ext.oApi._fnSetObjectDataFn( this.c.dataSrc ),
|
|
|
|
/** @type {Object} Mouse down information */
|
|
start: {
|
|
top: 0,
|
|
left: 0,
|
|
offsetTop: 0,
|
|
offsetLeft: 0,
|
|
nodes: []
|
|
},
|
|
|
|
/** @type {integer} Window height cached value */
|
|
windowHeight: 0,
|
|
|
|
/** @type {integer} Document outer height cached value */
|
|
documentOuterHeight: 0,
|
|
|
|
/** @type {integer} DOM clone outer height cached value */
|
|
domCloneOuterHeight: 0
|
|
};
|
|
|
|
// DOM items
|
|
this.dom = {
|
|
/** @type {jQuery} Cloned row being moved around */
|
|
clone: null,
|
|
|
|
/** @type {jQuery} DataTables scrolling container */
|
|
dtScroll: $('div.dataTables_scrollBody', this.s.dt.table().container())
|
|
};
|
|
|
|
// Check if row reorder has already been initialised on this table
|
|
var settings = this.s.dt.settings()[0];
|
|
var exisiting = settings.rowreorder;
|
|
|
|
if ( exisiting ) {
|
|
return exisiting;
|
|
}
|
|
|
|
if ( !this.dom.dtScroll.length ) {
|
|
this.dom.dtScroll = $(this.s.dt.table().container(), 'tbody')
|
|
}
|
|
|
|
settings.rowreorder = this;
|
|
this._constructor();
|
|
};
|
|
|
|
|
|
$.extend( RowReorder.prototype, {
|
|
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
|
* Constructor
|
|
*/
|
|
|
|
/**
|
|
* Initialise the RowReorder instance
|
|
*
|
|
* @private
|
|
*/
|
|
_constructor: function ()
|
|
{
|
|
var that = this;
|
|
var dt = this.s.dt;
|
|
var table = $( dt.table().node() );
|
|
|
|
// Need to be able to calculate the row positions relative to the table
|
|
if ( table.css('position') === 'static' ) {
|
|
table.css( 'position', 'relative' );
|
|
}
|
|
|
|
// listen for mouse down on the target column - we have to implement
|
|
// this rather than using HTML5 drag and drop as drag and drop doesn't
|
|
// appear to work on table rows at this time. Also mobile browsers are
|
|
// not supported.
|
|
// Use `table().container()` rather than just the table node for IE8 -
|
|
// otherwise it only works once...
|
|
$(dt.table().container()).on( 'mousedown.rowReorder touchstart.rowReorder', this.c.selector, function (e) {
|
|
if ( ! that.c.enable ) {
|
|
return;
|
|
}
|
|
|
|
// Ignore excluded children of the selector
|
|
if ( $(e.target).is(that.c.excludedChildren) ) {
|
|
return true;
|
|
}
|
|
|
|
var tr = $(this).closest('tr');
|
|
var row = dt.row( tr );
|
|
|
|
// Double check that it is a DataTable row
|
|
if ( row.any() ) {
|
|
that._emitEvent( 'pre-row-reorder', {
|
|
node: row.node(),
|
|
index: row.index()
|
|
} );
|
|
|
|
that._mouseDown( e, tr );
|
|
return false;
|
|
}
|
|
} );
|
|
|
|
dt.on( 'destroy.rowReorder', function () {
|
|
$(dt.table().container()).off( '.rowReorder' );
|
|
dt.off( '.rowReorder' );
|
|
} );
|
|
},
|
|
|
|
|
|
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
|
* Private methods
|
|
*/
|
|
|
|
/**
|
|
* Cache the measurements that RowReorder needs in the mouse move handler
|
|
* to attempt to speed things up, rather than reading from the DOM.
|
|
*
|
|
* @private
|
|
*/
|
|
_cachePositions: function ()
|
|
{
|
|
var dt = this.s.dt;
|
|
|
|
// Frustratingly, if we add `position:relative` to the tbody, the
|
|
// position is still relatively to the parent. So we need to adjust
|
|
// for that
|
|
var headerHeight = $( dt.table().node() ).find('thead').outerHeight();
|
|
|
|
// Need to pass the nodes through jQuery to get them in document order,
|
|
// not what DataTables thinks it is, since we have been altering the
|
|
// order
|
|
var nodes = $.unique( dt.rows( { page: 'current' } ).nodes().toArray() );
|
|
var middles = $.map( nodes, function ( node, i ) {
|
|
var top = $(node).position().top - headerHeight;
|
|
|
|
return (top + top + $(node).outerHeight() ) / 2;
|
|
} );
|
|
|
|
this.s.middles = middles;
|
|
this.s.bodyTop = $( dt.table().body() ).offset().top;
|
|
this.s.windowHeight = $(window).height();
|
|
this.s.documentOuterHeight = $(document).outerHeight();
|
|
},
|
|
|
|
|
|
/**
|
|
* Clone a row so it can be floated around the screen
|
|
*
|
|
* @param {jQuery} target Node to be cloned
|
|
* @private
|
|
*/
|
|
_clone: function ( target )
|
|
{
|
|
var dt = this.s.dt;
|
|
var clone = $( dt.table().node().cloneNode(false) )
|
|
.addClass( 'dt-rowReorder-float' )
|
|
.append('<tbody/>')
|
|
.append( target.clone( false ) );
|
|
|
|
// Match the table and column widths - read all sizes before setting
|
|
// to reduce reflows
|
|
var tableWidth = target.outerWidth();
|
|
var tableHeight = target.outerHeight();
|
|
var sizes = target.children().map( function () {
|
|
return $(this).width();
|
|
} );
|
|
|
|
clone
|
|
.width( tableWidth )
|
|
.height( tableHeight )
|
|
.find('tr').children().each( function (i) {
|
|
this.style.width = sizes[i]+'px';
|
|
} );
|
|
|
|
// Insert into the document to have it floating around
|
|
clone.appendTo( 'body' );
|
|
|
|
this.dom.clone = clone;
|
|
this.s.domCloneOuterHeight = clone.outerHeight();
|
|
},
|
|
|
|
|
|
/**
|
|
* Update the cloned item's position in the document
|
|
*
|
|
* @param {object} e Event giving the mouse's position
|
|
* @private
|
|
*/
|
|
_clonePosition: function ( e )
|
|
{
|
|
var start = this.s.start;
|
|
var topDiff = this._eventToPage( e, 'Y' ) - start.top;
|
|
var leftDiff = this._eventToPage( e, 'X' ) - start.left;
|
|
var snap = this.c.snapX;
|
|
var left;
|
|
var top = topDiff + start.offsetTop;
|
|
|
|
if ( snap === true ) {
|
|
left = start.offsetLeft;
|
|
}
|
|
else if ( typeof snap === 'number' ) {
|
|
left = start.offsetLeft + snap;
|
|
}
|
|
else {
|
|
left = leftDiff + start.offsetLeft;
|
|
}
|
|
|
|
if(top < 0) {
|
|
top = 0
|
|
}
|
|
else if(top + this.s.domCloneOuterHeight > this.s.documentOuterHeight) {
|
|
top = this.s.documentOuterHeight - this.s.domCloneOuterHeight;
|
|
}
|
|
|
|
this.dom.clone.css( {
|
|
top: top,
|
|
left: left
|
|
} );
|
|
},
|
|
|
|
|
|
/**
|
|
* 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 );
|
|
} );
|
|
},
|
|
|
|
|
|
/**
|
|
* Get pageX/Y position from an event, regardless of if it is a mouse or
|
|
* touch event.
|
|
*
|
|
* @param {object} e Event
|
|
* @param {string} pos X or Y (must be a capital)
|
|
* @private
|
|
*/
|
|
_eventToPage: function ( e, pos )
|
|
{
|
|
if ( e.type.indexOf( 'touch' ) !== -1 ) {
|
|
return e.originalEvent.touches[0][ 'page'+pos ];
|
|
}
|
|
|
|
return e[ 'page'+pos ];
|
|
},
|
|
|
|
|
|
/**
|
|
* Mouse down event handler. Read initial positions and add event handlers
|
|
* for the move.
|
|
*
|
|
* @param {object} e Mouse event
|
|
* @param {jQuery} target TR element that is to be moved
|
|
* @private
|
|
*/
|
|
_mouseDown: function ( e, target )
|
|
{
|
|
var that = this;
|
|
var dt = this.s.dt;
|
|
var start = this.s.start;
|
|
|
|
var offset = target.offset();
|
|
start.top = this._eventToPage( e, 'Y' );
|
|
start.left = this._eventToPage( e, 'X' );
|
|
start.offsetTop = offset.top;
|
|
start.offsetLeft = offset.left;
|
|
start.nodes = $.unique( dt.rows( { page: 'current' } ).nodes().toArray() );
|
|
|
|
this._cachePositions();
|
|
this._clone( target );
|
|
this._clonePosition( e );
|
|
|
|
this.dom.target = target;
|
|
target.addClass( 'dt-rowReorder-moving' );
|
|
|
|
$( document )
|
|
.on( 'mouseup.rowReorder touchend.rowReorder', function (e) {
|
|
that._mouseUp(e);
|
|
} )
|
|
.on( 'mousemove.rowReorder touchmove.rowReorder', function (e) {
|
|
that._mouseMove(e);
|
|
} );
|
|
|
|
// Check if window is x-scrolling - if not, disable it for the duration
|
|
// of the drag
|
|
if ( $(window).width() === $(document).width() ) {
|
|
$(document.body).addClass( 'dt-rowReorder-noOverflow' );
|
|
}
|
|
|
|
// 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 row drag, which I think is a fair assumption
|
|
var scrollWrapper = this.dom.dtScroll;
|
|
this.s.scroll = {
|
|
windowHeight: $(window).height(),
|
|
windowWidth: $(window).width(),
|
|
dtTop: scrollWrapper.length ? scrollWrapper.offset().top : null,
|
|
dtLeft: scrollWrapper.length ? scrollWrapper.offset().left : null,
|
|
dtHeight: scrollWrapper.length ? scrollWrapper.outerHeight() : null,
|
|
dtWidth: scrollWrapper.length ? scrollWrapper.outerWidth() : null
|
|
};
|
|
},
|
|
|
|
|
|
/**
|
|
* Mouse move event handler - move the cloned row and shuffle the table's
|
|
* rows if required.
|
|
*
|
|
* @param {object} e Mouse event
|
|
* @private
|
|
*/
|
|
_mouseMove: function ( e )
|
|
{
|
|
this._clonePosition( e );
|
|
|
|
// Transform the mouse position into a position in the table's body
|
|
var bodyY = this._eventToPage( e, 'Y' ) - this.s.bodyTop;
|
|
var middles = this.s.middles;
|
|
var insertPoint = null;
|
|
var dt = this.s.dt;
|
|
|
|
// Determine where the row should be inserted based on the mouse
|
|
// position
|
|
for ( var i=0, ien=middles.length ; i<ien ; i++ ) {
|
|
if ( bodyY < middles[i] ) {
|
|
insertPoint = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( insertPoint === null ) {
|
|
insertPoint = middles.length;
|
|
}
|
|
|
|
// Perform the DOM shuffle if it has changed from last time
|
|
if ( this.s.lastInsert === null || this.s.lastInsert !== insertPoint ) {
|
|
var nodes = $.unique( dt.rows( { page: 'current' } ).nodes().toArray() );
|
|
|
|
if ( insertPoint > this.s.lastInsert ) {
|
|
this.dom.target.insertAfter( nodes[ insertPoint-1 ] );
|
|
}
|
|
else {
|
|
this.dom.target.insertBefore( nodes[ insertPoint ] );
|
|
}
|
|
|
|
this._cachePositions();
|
|
|
|
this.s.lastInsert = insertPoint;
|
|
}
|
|
|
|
this._shiftScroll( e );
|
|
},
|
|
|
|
|
|
/**
|
|
* Mouse up event handler - release the event handlers and perform the
|
|
* table updates
|
|
*
|
|
* @param {object} e Mouse event
|
|
* @private
|
|
*/
|
|
_mouseUp: function ( e )
|
|
{
|
|
var that = this;
|
|
var dt = this.s.dt;
|
|
var i, ien;
|
|
var dataSrc = this.c.dataSrc;
|
|
|
|
this.dom.clone.remove();
|
|
this.dom.clone = null;
|
|
|
|
this.dom.target.removeClass( 'dt-rowReorder-moving' );
|
|
//this.dom.target = null;
|
|
|
|
$(document).off( '.rowReorder' );
|
|
$(document.body).removeClass( 'dt-rowReorder-noOverflow' );
|
|
|
|
clearInterval( this.s.scrollInterval );
|
|
this.s.scrollInterval = null;
|
|
|
|
// Calculate the difference
|
|
var startNodes = this.s.start.nodes;
|
|
var endNodes = $.unique( dt.rows( { page: 'current' } ).nodes().toArray() );
|
|
var idDiff = {};
|
|
var fullDiff = [];
|
|
var diffNodes = [];
|
|
var getDataFn = this.s.getDataFn;
|
|
var setDataFn = this.s.setDataFn;
|
|
|
|
for ( i=0, ien=startNodes.length ; i<ien ; i++ ) {
|
|
if ( startNodes[i] !== endNodes[i] ) {
|
|
var id = dt.row( endNodes[i] ).id();
|
|
var endRowData = dt.row( endNodes[i] ).data();
|
|
var startRowData = dt.row( startNodes[i] ).data();
|
|
|
|
if ( id ) {
|
|
idDiff[ id ] = getDataFn( startRowData );
|
|
}
|
|
|
|
fullDiff.push( {
|
|
node: endNodes[i],
|
|
oldData: getDataFn( endRowData ),
|
|
newData: getDataFn( startRowData ),
|
|
newPosition: i,
|
|
oldPosition: $.inArray( endNodes[i], startNodes )
|
|
} );
|
|
|
|
diffNodes.push( endNodes[i] );
|
|
}
|
|
}
|
|
|
|
// Create event args
|
|
var eventArgs = [ fullDiff, {
|
|
dataSrc: dataSrc,
|
|
nodes: diffNodes,
|
|
values: idDiff,
|
|
triggerRow: dt.row( this.dom.target ),
|
|
originalEvent: e
|
|
} ];
|
|
|
|
// Emit event
|
|
this._emitEvent( 'row-reorder', eventArgs );
|
|
|
|
var update = function () {
|
|
if ( that.c.update ) {
|
|
for ( i=0, ien=fullDiff.length ; i<ien ; i++ ) {
|
|
var row = dt.row( fullDiff[i].node );
|
|
var rowData = row.data();
|
|
|
|
setDataFn( rowData, fullDiff[i].newData );
|
|
|
|
// Invalidate the cell that has the same data source as the dataSrc
|
|
dt.columns().every( function () {
|
|
if ( this.dataSrc() === dataSrc ) {
|
|
dt.cell( fullDiff[i].node, this.index() ).invalidate( 'data' );
|
|
}
|
|
} );
|
|
}
|
|
|
|
// Trigger row reordered event
|
|
that._emitEvent( 'row-reordered', eventArgs );
|
|
|
|
dt.draw( false );
|
|
}
|
|
};
|
|
|
|
// Editor interface
|
|
if ( this.c.editor ) {
|
|
// Disable user interaction while Editor is submitting
|
|
this.c.enable = false;
|
|
|
|
this.c.editor
|
|
.edit(
|
|
diffNodes,
|
|
false,
|
|
$.extend( {submit: 'changed'}, this.c.formOptions )
|
|
)
|
|
.multiSet( dataSrc, idDiff )
|
|
.one( 'preSubmitCancelled.rowReorder', function () {
|
|
that.c.enable = true;
|
|
that.c.editor.off( '.rowReorder' );
|
|
dt.draw( false );
|
|
} )
|
|
.one( 'submitUnsuccessful.rowReorder', function () {
|
|
dt.draw( false );
|
|
} )
|
|
.one( 'submitSuccess.rowReorder', function () {
|
|
update();
|
|
} )
|
|
.one( 'submitComplete', function () {
|
|
that.c.enable = true;
|
|
that.c.editor.off( '.rowReorder' );
|
|
} )
|
|
.submit();
|
|
}
|
|
else {
|
|
update();
|
|
}
|
|
},
|
|
|
|
|
|
/**
|
|
* Move the window and DataTables scrolling during a drag to scroll new
|
|
* content into view.
|
|
*
|
|
* This matches the `_shiftScroll` method used in AutoFill, but only
|
|
* horizontal scrolling is considered here.
|
|
*
|
|
* @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,
|
|
windowVert,
|
|
dtVert;
|
|
|
|
// Window calculations - based on the mouse position in the window,
|
|
// regardless of scrolling
|
|
if ( windowY < $(window).scrollTop() + buffer ) {
|
|
windowVert = scrollSpeed * -1;
|
|
}
|
|
else if ( windowY > scroll.windowHeight + $(window).scrollTop() - buffer ) {
|
|
windowVert = 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;
|
|
}
|
|
|
|
// 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 || dtVert ) {
|
|
scroll.windowVert = windowVert;
|
|
scroll.dtVert = dtVert;
|
|
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 ) {
|
|
var top = $(document).scrollTop();
|
|
$(document).scrollTop(top + scroll.windowVert);
|
|
|
|
if ( top !== $(document).scrollTop() ) {
|
|
var move = parseFloat(that.dom.clone.css("top"));
|
|
that.dom.clone.css("top", move + scroll.windowVert);
|
|
}
|
|
}
|
|
|
|
// DataTables scrolling
|
|
if ( scroll.dtVert ) {
|
|
var scroller = that.dom.dtScroll[0];
|
|
|
|
if ( scroll.dtVert ) {
|
|
scroller.scrollTop += scroll.dtVert;
|
|
}
|
|
}
|
|
}, 20 );
|
|
}
|
|
}
|
|
} );
|
|
|
|
|
|
|
|
/**
|
|
* RowReorder default settings for initialisation
|
|
*
|
|
* @namespace
|
|
* @name RowReorder.defaults
|
|
* @static
|
|
*/
|
|
RowReorder.defaults = {
|
|
/**
|
|
* Data point in the host row's data source object for where to get and set
|
|
* the data to reorder. This will normally also be the sorting column.
|
|
*
|
|
* @type {Number}
|
|
*/
|
|
dataSrc: 0,
|
|
|
|
/**
|
|
* Editor instance that will be used to perform the update
|
|
*
|
|
* @type {DataTable.Editor}
|
|
*/
|
|
editor: null,
|
|
|
|
/**
|
|
* Enable / disable RowReorder's user interaction
|
|
* @type {Boolean}
|
|
*/
|
|
enable: true,
|
|
|
|
/**
|
|
* Form options to pass to Editor when submitting a change in the row order.
|
|
* See the Editor `from-options` object for details of the options
|
|
* available.
|
|
* @type {Object}
|
|
*/
|
|
formOptions: {},
|
|
|
|
/**
|
|
* Drag handle selector. This defines the element that when dragged will
|
|
* reorder a row.
|
|
*
|
|
* @type {String}
|
|
*/
|
|
selector: 'td:first-child',
|
|
|
|
/**
|
|
* Optionally lock the dragged row's x-position. This can be `true` to
|
|
* fix the position match the host table's, `false` to allow free movement
|
|
* of the row, or a number to define an offset from the host table.
|
|
*
|
|
* @type {Boolean|number}
|
|
*/
|
|
snapX: false,
|
|
|
|
/**
|
|
* Update the table's data on drop
|
|
*
|
|
* @type {Boolean}
|
|
*/
|
|
update: true,
|
|
|
|
/**
|
|
* Selector for children of the drag handle selector that mouseDown events
|
|
* will be passed through to and drag will not activate
|
|
*
|
|
* @type {String}
|
|
*/
|
|
excludedChildren: 'a'
|
|
};
|
|
|
|
|
|
/*
|
|
* API
|
|
*/
|
|
var Api = $.fn.dataTable.Api;
|
|
|
|
// Doesn't do anything - work around for a bug in DT... Not documented
|
|
Api.register( 'rowReorder()', function () {
|
|
return this;
|
|
} );
|
|
|
|
Api.register( 'rowReorder.enable()', function ( toggle ) {
|
|
if ( toggle === undefined ) {
|
|
toggle = true;
|
|
}
|
|
|
|
return this.iterator( 'table', function ( ctx ) {
|
|
if ( ctx.rowreorder ) {
|
|
ctx.rowreorder.c.enable = toggle;
|
|
}
|
|
} );
|
|
} );
|
|
|
|
Api.register( 'rowReorder.disable()', function () {
|
|
return this.iterator( 'table', function ( ctx ) {
|
|
if ( ctx.rowreorder ) {
|
|
ctx.rowreorder.c.enable = false;
|
|
}
|
|
} );
|
|
} );
|
|
|
|
|
|
/**
|
|
* Version information
|
|
*
|
|
* @name RowReorder.version
|
|
* @static
|
|
*/
|
|
RowReorder.version = '1.2.8';
|
|
|
|
|
|
$.fn.dataTable.RowReorder = RowReorder;
|
|
$.fn.DataTable.RowReorder = RowReorder;
|
|
|
|
// Attach a listener to the document which listens for DataTables initialisation
|
|
// events so we can automatically initialise
|
|
$(document).on( 'init.dt.dtr', function (e, settings, json) {
|
|
if ( e.namespace !== 'dt' ) {
|
|
return;
|
|
}
|
|
|
|
var init = settings.oInit.rowReorder;
|
|
var defaults = DataTable.defaults.rowReorder;
|
|
|
|
if ( init || defaults ) {
|
|
var opts = $.extend( {}, init, defaults );
|
|
|
|
if ( init !== false ) {
|
|
new RowReorder( settings, opts );
|
|
}
|
|
}
|
|
} );
|
|
|
|
|
|
return RowReorder;
|
|
}));
|