diff options
Diffstat (limited to 'src/main/resources/static/plugins/datatables-rowreorder')
6 files changed, 905 insertions, 0 deletions
diff --git a/src/main/resources/static/plugins/datatables-rowreorder/css/rowReorder.bootstrap4.css b/src/main/resources/static/plugins/datatables-rowreorder/css/rowReorder.bootstrap4.css new file mode 100644 index 0000000..025b622 --- /dev/null +++ b/src/main/resources/static/plugins/datatables-rowreorder/css/rowReorder.bootstrap4.css @@ -0,0 +1,22 @@ +table.dt-rowReorder-float { + position: absolute !important; + opacity: 0.8; + table-layout: fixed; + outline: 2px solid #0275d8; + outline-offset: -2px; + z-index: 2001; +} + +tr.dt-rowReorder-moving { + outline: 2px solid #888; + outline-offset: -2px; +} + +body.dt-rowReorder-noOverflow { + overflow-x: hidden; +} + +table.dataTable td.reorder { + text-align: center; + cursor: move; +} diff --git a/src/main/resources/static/plugins/datatables-rowreorder/css/rowReorder.bootstrap4.min.css b/src/main/resources/static/plugins/datatables-rowreorder/css/rowReorder.bootstrap4.min.css new file mode 100644 index 0000000..3a53aa2 --- /dev/null +++ b/src/main/resources/static/plugins/datatables-rowreorder/css/rowReorder.bootstrap4.min.css @@ -0,0 +1 @@ +table.dt-rowReorder-float{position:absolute !important;opacity:.8;table-layout:fixed;outline:2px solid #0275d8;outline-offset:-2px;z-index:2001}tr.dt-rowReorder-moving{outline:2px solid #888;outline-offset:-2px}body.dt-rowReorder-noOverflow{overflow-x:hidden}table.dataTable td.reorder{text-align:center;cursor:move} diff --git a/src/main/resources/static/plugins/datatables-rowreorder/js/dataTables.rowReorder.js b/src/main/resources/static/plugins/datatables-rowreorder/js/dataTables.rowReorder.js new file mode 100644 index 0000000..adc4808 --- /dev/null +++ b/src/main/resources/static/plugins/datatables-rowreorder/js/dataTables.rowReorder.js @@ -0,0 +1,820 @@ +/*! 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; +})); diff --git a/src/main/resources/static/plugins/datatables-rowreorder/js/dataTables.rowReorder.min.js b/src/main/resources/static/plugins/datatables-rowreorder/js/dataTables.rowReorder.min.js new file mode 100644 index 0000000..17bdd27 --- /dev/null +++ b/src/main/resources/static/plugins/datatables-rowreorder/js/dataTables.rowReorder.min.js @@ -0,0 +1,19 @@ +/*! + RowReorder 1.2.8 + 2015-2020 SpryMedia Ltd - datatables.net/license +*/ +(function(e){"function"===typeof define&&define.amd?define(["jquery","datatables.net"],function(f){return e(f,window,document)}):"object"===typeof exports?module.exports=function(f,g){f||(f=window);if(!g||!g.fn.dataTable)g=require("datatables.net")(f,g).$;return e(g,f,f.document)}:e(jQuery,window,document)})(function(e,f,g,o){var i=e.fn.dataTable,j=function(d,c){if(!i.versionCheck||!i.versionCheck("1.10.8"))throw"DataTables RowReorder requires DataTables 1.10.8 or newer";this.c=e.extend(!0,{},i.defaults.rowReorder, +j.defaults,c);this.s={bodyTop:null,dt:new i.Api(d),getDataFn:i.ext.oApi._fnGetObjectDataFn(this.c.dataSrc),middles:null,scroll:{},scrollInterval:null,setDataFn:i.ext.oApi._fnSetObjectDataFn(this.c.dataSrc),start:{top:0,left:0,offsetTop:0,offsetLeft:0,nodes:[]},windowHeight:0,documentOuterHeight:0,domCloneOuterHeight:0};this.dom={clone:null,dtScroll:e("div.dataTables_scrollBody",this.s.dt.table().container())};var b=this.s.dt.settings()[0],a=b.rowreorder;if(a)return a;this.dom.dtScroll.length||(this.dom.dtScroll= +e(this.s.dt.table().container(),"tbody"));b.rowreorder=this;this._constructor()};e.extend(j.prototype,{_constructor:function(){var d=this,c=this.s.dt,b=e(c.table().node());"static"===b.css("position")&&b.css("position","relative");e(c.table().container()).on("mousedown.rowReorder touchstart.rowReorder",this.c.selector,function(a){if(d.c.enable){if(e(a.target).is(d.c.excludedChildren))return!0;var b=e(this).closest("tr"),h=c.row(b);if(h.any())return d._emitEvent("pre-row-reorder",{node:h.node(),index:h.index()}), +d._mouseDown(a,b),!1}});c.on("destroy.rowReorder",function(){e(c.table().container()).off(".rowReorder");c.off(".rowReorder")})},_cachePositions:function(){var d=this.s.dt,c=e(d.table().node()).find("thead").outerHeight(),b=e.unique(d.rows({page:"current"}).nodes().toArray()),b=e.map(b,function(b){var d=e(b).position().top-c;return(d+d+e(b).outerHeight())/2});this.s.middles=b;this.s.bodyTop=e(d.table().body()).offset().top;this.s.windowHeight=e(f).height();this.s.documentOuterHeight=e(g).outerHeight()}, +_clone:function(d){var c=e(this.s.dt.table().node().cloneNode(!1)).addClass("dt-rowReorder-float").append("<tbody/>").append(d.clone(!1)),b=d.outerWidth(),a=d.outerHeight(),g=d.children().map(function(){return e(this).width()});c.width(b).height(a).find("tr").children().each(function(b){this.style.width=g[b]+"px"});c.appendTo("body");this.dom.clone=c;this.s.domCloneOuterHeight=c.outerHeight()},_clonePosition:function(d){var c=this.s.start,b=this._eventToPage(d,"Y")-c.top,d=this._eventToPage(d,"X")- +c.left,a=this.c.snapX,b=b+c.offsetTop,c=!0===a?c.offsetLeft:"number"===typeof a?c.offsetLeft+a:d+c.offsetLeft;0>b?b=0:b+this.s.domCloneOuterHeight>this.s.documentOuterHeight&&(b=this.s.documentOuterHeight-this.s.domCloneOuterHeight);this.dom.clone.css({top:b,left:c})},_emitEvent:function(d,c){this.s.dt.iterator("table",function(b){e(b.nTable).triggerHandler(d+".dt",c)})},_eventToPage:function(d,c){return-1!==d.type.indexOf("touch")?d.originalEvent.touches[0]["page"+c]:d["page"+c]},_mouseDown:function(d, +c){var b=this,a=this.s.dt,m=this.s.start,h=c.offset();m.top=this._eventToPage(d,"Y");m.left=this._eventToPage(d,"X");m.offsetTop=h.top;m.offsetLeft=h.left;m.nodes=e.unique(a.rows({page:"current"}).nodes().toArray());this._cachePositions();this._clone(c);this._clonePosition(d);this.dom.target=c;c.addClass("dt-rowReorder-moving");e(g).on("mouseup.rowReorder touchend.rowReorder",function(a){b._mouseUp(a)}).on("mousemove.rowReorder touchmove.rowReorder",function(a){b._mouseMove(a)});e(f).width()===e(g).width()&& +e(g.body).addClass("dt-rowReorder-noOverflow");a=this.dom.dtScroll;this.s.scroll={windowHeight:e(f).height(),windowWidth:e(f).width(),dtTop:a.length?a.offset().top:null,dtLeft:a.length?a.offset().left:null,dtHeight:a.length?a.outerHeight():null,dtWidth:a.length?a.outerWidth():null}},_mouseMove:function(d){this._clonePosition(d);for(var c=this._eventToPage(d,"Y")-this.s.bodyTop,b=this.s.middles,a=null,g=this.s.dt,h=0,f=b.length;h<f;h++)if(c<b[h]){a=h;break}null===a&&(a=b.length);if(null===this.s.lastInsert|| +this.s.lastInsert!==a)c=e.unique(g.rows({page:"current"}).nodes().toArray()),a>this.s.lastInsert?this.dom.target.insertAfter(c[a-1]):this.dom.target.insertBefore(c[a]),this._cachePositions(),this.s.lastInsert=a;this._shiftScroll(d)},_mouseUp:function(d){var c=this,b=this.s.dt,a,f,h=this.c.dataSrc;this.dom.clone.remove();this.dom.clone=null;this.dom.target.removeClass("dt-rowReorder-moving");e(g).off(".rowReorder");e(g.body).removeClass("dt-rowReorder-noOverflow");clearInterval(this.s.scrollInterval); +this.s.scrollInterval=null;var n=this.s.start.nodes,l=e.unique(b.rows({page:"current"}).nodes().toArray()),j={},i=[],k=[],p=this.s.getDataFn,o=this.s.setDataFn;a=0;for(f=n.length;a<f;a++)if(n[a]!==l[a]){var q=b.row(l[a]).id(),u=b.row(l[a]).data(),r=b.row(n[a]).data();q&&(j[q]=p(r));i.push({node:l[a],oldData:p(u),newData:p(r),newPosition:a,oldPosition:e.inArray(l[a],n)});k.push(l[a])}var s=[i,{dataSrc:h,nodes:k,values:j,triggerRow:b.row(this.dom.target),originalEvent:d}];this._emitEvent("row-reorder", +s);var t=function(){if(c.c.update){a=0;for(f=i.length;a<f;a++){var d=b.row(i[a].node).data();o(d,i[a].newData);b.columns().every(function(){this.dataSrc()===h&&b.cell(i[a].node,this.index()).invalidate("data")})}c._emitEvent("row-reordered",s);b.draw(!1)}};this.c.editor?(this.c.enable=!1,this.c.editor.edit(k,!1,e.extend({submit:"changed"},this.c.formOptions)).multiSet(h,j).one("preSubmitCancelled.rowReorder",function(){c.c.enable=!0;c.c.editor.off(".rowReorder");b.draw(!1)}).one("submitUnsuccessful.rowReorder", +function(){b.draw(!1)}).one("submitSuccess.rowReorder",function(){t()}).one("submitComplete",function(){c.c.enable=!0;c.c.editor.off(".rowReorder")}).submit()):t()},_shiftScroll:function(d){var c=this,b=this.s.scroll,a=!1,i=d.pageY-g.body.scrollTop,h,j;i<e(f).scrollTop()+65?h=-5:i>b.windowHeight+e(f).scrollTop()-65&&(h=5);null!==b.dtTop&&d.pageY<b.dtTop+65?j=-5:null!==b.dtTop&&d.pageY>b.dtTop+b.dtHeight-65&&(j=5);h||j?(b.windowVert=h,b.dtVert=j,a=!0):this.s.scrollInterval&&(clearInterval(this.s.scrollInterval), +this.s.scrollInterval=null);!this.s.scrollInterval&&a&&(this.s.scrollInterval=setInterval(function(){if(b.windowVert){var a=e(g).scrollTop();e(g).scrollTop(a+b.windowVert);if(a!==e(g).scrollTop()){a=parseFloat(c.dom.clone.css("top"));c.dom.clone.css("top",a+b.windowVert)}}if(b.dtVert){a=c.dom.dtScroll[0];if(b.dtVert)a.scrollTop=a.scrollTop+b.dtVert}},20))}});j.defaults={dataSrc:0,editor:null,enable:!0,formOptions:{},selector:"td:first-child",snapX:!1,update:!0,excludedChildren:"a"};var k=e.fn.dataTable.Api; +k.register("rowReorder()",function(){return this});k.register("rowReorder.enable()",function(d){d===o&&(d=!0);return this.iterator("table",function(c){c.rowreorder&&(c.rowreorder.c.enable=d)})});k.register("rowReorder.disable()",function(){return this.iterator("table",function(d){d.rowreorder&&(d.rowreorder.c.enable=!1)})});j.version="1.2.8";e.fn.dataTable.RowReorder=j;e.fn.DataTable.RowReorder=j;e(g).on("init.dt.dtr",function(d,c){if("dt"===d.namespace){var b=c.oInit.rowReorder,a=i.defaults.rowReorder; +if(b||a)a=e.extend({},b,a),!1!==b&&new j(c,a)}});return j}); diff --git a/src/main/resources/static/plugins/datatables-rowreorder/js/rowReorder.bootstrap4.js b/src/main/resources/static/plugins/datatables-rowreorder/js/rowReorder.bootstrap4.js new file mode 100644 index 0000000..5d81237 --- /dev/null +++ b/src/main/resources/static/plugins/datatables-rowreorder/js/rowReorder.bootstrap4.js @@ -0,0 +1,38 @@ +/*! Bootstrap 4 styling wrapper for RowReorder + * ©2018 SpryMedia Ltd - datatables.net/license + */ + +(function( factory ){ + if ( typeof define === 'function' && define.amd ) { + // AMD + define( ['jquery', 'datatables.net-bs4', 'datatables.net-rowreorder'], 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-bs4')(root, $).$; + } + + if ( ! $.fn.dataTable.RowReorder ) { + require('datatables.net-rowreorder')(root, $); + } + + return factory( $, root, root.document ); + }; + } + else { + // Browser + factory( jQuery, window, document ); + } +}(function( $, window, document, undefined ) { + +return $.fn.dataTable; + +}));
\ No newline at end of file diff --git a/src/main/resources/static/plugins/datatables-rowreorder/js/rowReorder.bootstrap4.min.js b/src/main/resources/static/plugins/datatables-rowreorder/js/rowReorder.bootstrap4.min.js new file mode 100644 index 0000000..15bd43f --- /dev/null +++ b/src/main/resources/static/plugins/datatables-rowreorder/js/rowReorder.bootstrap4.min.js @@ -0,0 +1,5 @@ +/*! + Bootstrap 4 styling wrapper for RowReorder + ©2018 SpryMedia Ltd - datatables.net/license +*/ +(function(c){"function"===typeof define&&define.amd?define(["jquery","datatables.net-bs4","datatables.net-rowreorder"],function(a){return c(a,window,document)}):"object"===typeof exports?module.exports=function(a,b){a||(a=window);if(!b||!b.fn.dataTable)b=require("datatables.net-bs4")(a,b).$;b.fn.dataTable.RowReorder||require("datatables.net-rowreorder")(a,b);return c(b,a,a.document)}:c(jQuery,window,document)})(function(c){return c.fn.dataTable}); |