diff options
Diffstat (limited to 'src/main/resources/static/plugins/datatables-colreorder/js')
4 files changed, 1564 insertions, 0 deletions
diff --git a/src/main/resources/static/plugins/datatables-colreorder/js/colReorder.bootstrap4.js b/src/main/resources/static/plugins/datatables-colreorder/js/colReorder.bootstrap4.js new file mode 100644 index 0000000..56bdec6 --- /dev/null +++ b/src/main/resources/static/plugins/datatables-colreorder/js/colReorder.bootstrap4.js @@ -0,0 +1,38 @@ +/*! Bootstrap 4 styling wrapper for ColReorder + * ©2018 SpryMedia Ltd - datatables.net/license + */ + +(function( factory ){ + if ( typeof define === 'function' && define.amd ) { + // AMD + define( ['jquery', 'datatables.net-bs4', 'datatables.net-colreorder'], 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.ColReorder ) { + require('datatables.net-colreorder')(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-colreorder/js/colReorder.bootstrap4.min.js b/src/main/resources/static/plugins/datatables-colreorder/js/colReorder.bootstrap4.min.js new file mode 100644 index 0000000..dc965a3 --- /dev/null +++ b/src/main/resources/static/plugins/datatables-colreorder/js/colReorder.bootstrap4.min.js @@ -0,0 +1,5 @@ +/*! + Bootstrap 4 styling wrapper for ColReorder + ©2018 SpryMedia Ltd - datatables.net/license +*/ +(function(c){"function"===typeof define&&define.amd?define(["jquery","datatables.net-bs4","datatables.net-colreorder"],function(a){return c(a,window,document)}):"object"===typeof exports?module.exports=function(a,b){a||(a=window);b&&b.fn.dataTable||(b=require("datatables.net-bs4")(a,b).$);b.fn.dataTable.ColReorder||require("datatables.net-colreorder")(a,b);return c(b,a,a.document)}:c(jQuery,window,document)})(function(c,a,b,d){return c.fn.dataTable}); diff --git a/src/main/resources/static/plugins/datatables-colreorder/js/dataTables.colReorder.js b/src/main/resources/static/plugins/datatables-colreorder/js/dataTables.colReorder.js new file mode 100644 index 0000000..5d19de1 --- /dev/null +++ b/src/main/resources/static/plugins/datatables-colreorder/js/dataTables.colReorder.js @@ -0,0 +1,1491 @@ +/*! ColReorder 1.5.4 + * ©2010-2021 SpryMedia Ltd - datatables.net/license + */ + +/** + * @summary ColReorder + * @description Provide the ability to reorder columns in a DataTable + * @version 1.5.4 + * @file dataTables.colReorder.js + * @author SpryMedia Ltd (www.sprymedia.co.uk) + * @contact www.sprymedia.co.uk/contact + * @copyright Copyright 2010-2021 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; + + +/** + * Switch the key value pairing of an index array to be value key (i.e. the old value is now the + * key). For example consider [ 2, 0, 1 ] this would be returned as [ 1, 2, 0 ]. + * @method fnInvertKeyValues + * @param array aIn Array to switch around + * @returns array + */ +function fnInvertKeyValues( aIn ) +{ + var aRet=[]; + for ( var i=0, iLen=aIn.length ; i<iLen ; i++ ) + { + aRet[ aIn[i] ] = i; + } + return aRet; +} + + +/** + * Modify an array by switching the position of two elements + * @method fnArraySwitch + * @param array aArray Array to consider, will be modified by reference (i.e. no return) + * @param int iFrom From point + * @param int iTo Insert point + * @returns void + */ +function fnArraySwitch( aArray, iFrom, iTo ) +{ + var mStore = aArray.splice( iFrom, 1 )[0]; + aArray.splice( iTo, 0, mStore ); +} + + +/** + * Switch the positions of nodes in a parent node (note this is specifically designed for + * table rows). Note this function considers all element nodes under the parent! + * @method fnDomSwitch + * @param string sTag Tag to consider + * @param int iFrom Element to move + * @param int Point to element the element to (before this point), can be null for append + * @returns void + */ +function fnDomSwitch( nParent, iFrom, iTo ) +{ + var anTags = []; + for ( var i=0, iLen=nParent.childNodes.length ; i<iLen ; i++ ) + { + if ( nParent.childNodes[i].nodeType == 1 ) + { + anTags.push( nParent.childNodes[i] ); + } + } + var nStore = anTags[ iFrom ]; + + if ( iTo !== null ) + { + nParent.insertBefore( nStore, anTags[iTo] ); + } + else + { + nParent.appendChild( nStore ); + } +} + + +/** + * Plug-in for DataTables which will reorder the internal column structure by taking the column + * from one position (iFrom) and insert it into a given point (iTo). + * @method $.fn.dataTableExt.oApi.fnColReorder + * @param object oSettings DataTables settings object - automatically added by DataTables! + * @param int iFrom Take the column to be repositioned from this point + * @param int iTo and insert it into this point + * @param bool drop Indicate if the reorder is the final one (i.e. a drop) + * not a live reorder + * @param bool invalidateRows speeds up processing if false passed + * @returns void + */ +$.fn.dataTableExt.oApi.fnColReorder = function ( oSettings, iFrom, iTo, drop, invalidateRows ) +{ + var i, iLen, j, jLen, jen, iCols=oSettings.aoColumns.length, nTrs, oCol; + var attrMap = function ( obj, prop, mapping ) { + if ( ! obj[ prop ] || typeof obj[ prop ] === 'function' ) { + return; + } + + var a = obj[ prop ].split('.'); + var num = a.shift(); + + if ( isNaN( num*1 ) ) { + return; + } + + obj[ prop ] = mapping[ num*1 ]+'.'+a.join('.'); + }; + + /* Sanity check in the input */ + if ( iFrom == iTo ) + { + /* Pointless reorder */ + return; + } + + if ( iFrom < 0 || iFrom >= iCols ) + { + this.oApi._fnLog( oSettings, 1, "ColReorder 'from' index is out of bounds: "+iFrom ); + return; + } + + if ( iTo < 0 || iTo >= iCols ) + { + this.oApi._fnLog( oSettings, 1, "ColReorder 'to' index is out of bounds: "+iTo ); + return; + } + + /* + * Calculate the new column array index, so we have a mapping between the old and new + */ + var aiMapping = []; + for ( i=0, iLen=iCols ; i<iLen ; i++ ) + { + aiMapping[i] = i; + } + fnArraySwitch( aiMapping, iFrom, iTo ); + var aiInvertMapping = fnInvertKeyValues( aiMapping ); + + + /* + * Convert all internal indexing to the new column order indexes + */ + /* Sorting */ + for ( i=0, iLen=oSettings.aaSorting.length ; i<iLen ; i++ ) + { + oSettings.aaSorting[i][0] = aiInvertMapping[ oSettings.aaSorting[i][0] ]; + } + + /* Fixed sorting */ + if ( oSettings.aaSortingFixed !== null ) + { + for ( i=0, iLen=oSettings.aaSortingFixed.length ; i<iLen ; i++ ) + { + oSettings.aaSortingFixed[i][0] = aiInvertMapping[ oSettings.aaSortingFixed[i][0] ]; + } + } + + /* Data column sorting (the column which the sort for a given column should take place on) */ + for ( i=0, iLen=iCols ; i<iLen ; i++ ) + { + oCol = oSettings.aoColumns[i]; + for ( j=0, jLen=oCol.aDataSort.length ; j<jLen ; j++ ) + { + oCol.aDataSort[j] = aiInvertMapping[ oCol.aDataSort[j] ]; + } + + // Update the column indexes + oCol.idx = aiInvertMapping[ oCol.idx ]; + } + + // Update 1.10 optimised sort class removal variable + $.each( oSettings.aLastSort, function (i, val) { + oSettings.aLastSort[i].src = aiInvertMapping[ val.src ]; + } ); + + /* Update the Get and Set functions for each column */ + for ( i=0, iLen=iCols ; i<iLen ; i++ ) + { + oCol = oSettings.aoColumns[i]; + + if ( typeof oCol.mData == 'number' ) { + oCol.mData = aiInvertMapping[ oCol.mData ]; + } + else if ( $.isPlainObject( oCol.mData ) ) { + // HTML5 data sourced + attrMap( oCol.mData, '_', aiInvertMapping ); + attrMap( oCol.mData, 'filter', aiInvertMapping ); + attrMap( oCol.mData, 'sort', aiInvertMapping ); + attrMap( oCol.mData, 'type', aiInvertMapping ); + } + } + + /* + * Move the DOM elements + */ + if ( oSettings.aoColumns[iFrom].bVisible ) + { + /* Calculate the current visible index and the point to insert the node before. The insert + * before needs to take into account that there might not be an element to insert before, + * in which case it will be null, and an appendChild should be used + */ + var iVisibleIndex = this.oApi._fnColumnIndexToVisible( oSettings, iFrom ); + var iInsertBeforeIndex = null; + + i = iTo < iFrom ? iTo : iTo + 1; + while ( iInsertBeforeIndex === null && i < iCols ) + { + iInsertBeforeIndex = this.oApi._fnColumnIndexToVisible( oSettings, i ); + i++; + } + + /* Header */ + nTrs = oSettings.nTHead.getElementsByTagName('tr'); + for ( i=0, iLen=nTrs.length ; i<iLen ; i++ ) + { + fnDomSwitch( nTrs[i], iVisibleIndex, iInsertBeforeIndex ); + } + + /* Footer */ + if ( oSettings.nTFoot !== null ) + { + nTrs = oSettings.nTFoot.getElementsByTagName('tr'); + for ( i=0, iLen=nTrs.length ; i<iLen ; i++ ) + { + fnDomSwitch( nTrs[i], iVisibleIndex, iInsertBeforeIndex ); + } + } + + /* Body */ + for ( i=0, iLen=oSettings.aoData.length ; i<iLen ; i++ ) + { + if ( oSettings.aoData[i].nTr !== null ) + { + fnDomSwitch( oSettings.aoData[i].nTr, iVisibleIndex, iInsertBeforeIndex ); + } + } + } + + /* + * Move the internal array elements + */ + /* Columns */ + fnArraySwitch( oSettings.aoColumns, iFrom, iTo ); + + // regenerate the get / set functions + for ( i=0, iLen=iCols ; i<iLen ; i++ ) { + oSettings.oApi._fnColumnOptions( oSettings, i, {} ); + } + + /* Search columns */ + fnArraySwitch( oSettings.aoPreSearchCols, iFrom, iTo ); + + /* Array array - internal data anodes cache */ + for ( i=0, iLen=oSettings.aoData.length ; i<iLen ; i++ ) + { + var data = oSettings.aoData[i]; + var cells = data.anCells; + + if ( cells ) { + fnArraySwitch( cells, iFrom, iTo ); + + // Longer term, should this be moved into the DataTables' invalidate + // methods? + for ( j=0, jen=cells.length ; j<jen ; j++ ) { + if ( cells[j] && cells[j]._DT_CellIndex ) { + cells[j]._DT_CellIndex.column = j; + } + } + } + + // For DOM sourced data, the invalidate will reread the cell into + // the data array, but for data sources as an array, they need to + // be flipped + if ( data.src !== 'dom' && Array.isArray( data._aData ) ) { + fnArraySwitch( data._aData, iFrom, iTo ); + } + } + + /* Reposition the header elements in the header layout array */ + for ( i=0, iLen=oSettings.aoHeader.length ; i<iLen ; i++ ) + { + fnArraySwitch( oSettings.aoHeader[i], iFrom, iTo ); + } + + if ( oSettings.aoFooter !== null ) + { + for ( i=0, iLen=oSettings.aoFooter.length ; i<iLen ; i++ ) + { + fnArraySwitch( oSettings.aoFooter[i], iFrom, iTo ); + } + } + + if ( invalidateRows || invalidateRows === undefined ) + { + $.fn.dataTable.Api( oSettings ).rows().invalidate(); + } + + /* + * Update DataTables' event handlers + */ + + /* Sort listener */ + for ( i=0, iLen=iCols ; i<iLen ; i++ ) + { + $(oSettings.aoColumns[i].nTh).off('.DT'); + this.oApi._fnSortAttachListener( oSettings, oSettings.aoColumns[i].nTh, i ); + } + + + /* Fire an event so other plug-ins can update */ + $(oSettings.oInstance).trigger( 'column-reorder.dt', [ oSettings, { + from: iFrom, + to: iTo, + mapping: aiInvertMapping, + drop: drop, + + // Old style parameters for compatibility + iFrom: iFrom, + iTo: iTo, + aiInvertMapping: aiInvertMapping + } ] ); +}; + +/** + * ColReorder provides column visibility control for DataTables + * @class ColReorder + * @constructor + * @param {object} dt DataTables settings object + * @param {object} opts ColReorder options + */ +var ColReorder = function( dt, opts ) +{ + var settings = new $.fn.dataTable.Api( dt ).settings()[0]; + + // Ensure that we can't initialise on the same table twice + if ( settings._colReorder ) { + return settings._colReorder; + } + + // Allow the options to be a boolean for defaults + if ( opts === true ) { + opts = {}; + } + + // Convert from camelCase to Hungarian, just as DataTables does + var camelToHungarian = $.fn.dataTable.camelToHungarian; + if ( camelToHungarian ) { + camelToHungarian( ColReorder.defaults, ColReorder.defaults, true ); + camelToHungarian( ColReorder.defaults, opts || {} ); + } + + + /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * Public class variables + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ + + /** + * @namespace Settings object which contains customisable information for ColReorder instance + */ + this.s = { + /** + * DataTables settings object + * @property dt + * @type Object + * @default null + */ + "dt": null, + + /** + * Enable flag + * @property dt + * @type Object + * @default null + */ + "enable": null, + + /** + * Initialisation object used for this instance + * @property init + * @type object + * @default {} + */ + "init": $.extend( true, {}, ColReorder.defaults, opts ), + + /** + * Number of columns to fix (not allow to be reordered) + * @property fixed + * @type int + * @default 0 + */ + "fixed": 0, + + /** + * Number of columns to fix counting from right (not allow to be reordered) + * @property fixedRight + * @type int + * @default 0 + */ + "fixedRight": 0, + + /** + * Callback function for once the reorder has been done + * @property reorderCallback + * @type function + * @default null + */ + "reorderCallback": null, + + /** + * @namespace Information used for the mouse drag + */ + "mouse": { + "startX": -1, + "startY": -1, + "offsetX": -1, + "offsetY": -1, + "target": -1, + "targetIndex": -1, + "fromIndex": -1 + }, + + /** + * Information which is used for positioning the insert cusor and knowing where to do the + * insert. Array of objects with the properties: + * x: x-axis position + * to: insert point + * @property aoTargets + * @type array + * @default [] + */ + "aoTargets": [] + }; + + + /** + * @namespace Common and useful DOM elements for the class instance + */ + this.dom = { + /** + * Dragging element (the one the mouse is moving) + * @property drag + * @type element + * @default null + */ + "drag": null, + + /** + * The insert cursor + * @property pointer + * @type element + * @default null + */ + "pointer": null + }; + + /* Constructor logic */ + this.s.enable = this.s.init.bEnable; + this.s.dt = settings; + this.s.dt._colReorder = this; + this._fnConstruct(); + + return this; +}; + + + +$.extend( ColReorder.prototype, { + /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * Public methods + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ + + /** + * Enable / disable end user interaction + */ + fnEnable: function ( flag ) + { + if ( flag === false ) { + return fnDisable(); + } + + this.s.enable = true; + }, + + /** + * Disable end user interaction + */ + fnDisable: function () + { + this.s.enable = false; + }, + + /** + * Reset the column ordering to the original ordering that was detected on + * start up. + * @return {this} Returns `this` for chaining. + * + * @example + * // DataTables initialisation with ColReorder + * var table = $('#example').dataTable( { + * "sDom": 'Rlfrtip' + * } ); + * + * // Add click event to a button to reset the ordering + * $('#resetOrdering').click( function (e) { + * e.preventDefault(); + * $.fn.dataTable.ColReorder( table ).fnReset(); + * } ); + */ + "fnReset": function () + { + this._fnOrderColumns( this.fnOrder() ); + + return this; + }, + + /** + * `Deprecated` - Get the current order of the columns, as an array. + * @return {array} Array of column identifiers + * @deprecated `fnOrder` should be used in preference to this method. + * `fnOrder` acts as a getter/setter. + */ + "fnGetCurrentOrder": function () + { + return this.fnOrder(); + }, + + /** + * Get the current order of the columns, as an array. Note that the values + * given in the array are unique identifiers for each column. Currently + * these are the original ordering of the columns that was detected on + * start up, but this could potentially change in future. + * @return {array} Array of column identifiers + * + * @example + * // Get column ordering for the table + * var order = $.fn.dataTable.ColReorder( dataTable ).fnOrder(); + *//** + * Set the order of the columns, from the positions identified in the + * ordering array given. Note that ColReorder takes a brute force approach + * to reordering, so it is possible multiple reordering events will occur + * before the final order is settled upon. + * @param {array} [set] Array of column identifiers in the new order. Note + * that every column must be included, uniquely, in this array. + * @return {this} Returns `this` for chaining. + * + * @example + * // Swap the first and second columns + * $.fn.dataTable.ColReorder( dataTable ).fnOrder( [1, 0, 2, 3, 4] ); + * + * @example + * // Move the first column to the end for the table `#example` + * var curr = $.fn.dataTable.ColReorder( '#example' ).fnOrder(); + * var first = curr.shift(); + * curr.push( first ); + * $.fn.dataTable.ColReorder( '#example' ).fnOrder( curr ); + * + * @example + * // Reverse the table's order + * $.fn.dataTable.ColReorder( '#example' ).fnOrder( + * $.fn.dataTable.ColReorder( '#example' ).fnOrder().reverse() + * ); + */ + "fnOrder": function ( set, original ) + { + var a = [], i, ien, j, jen; + var columns = this.s.dt.aoColumns; + + if ( set === undefined ){ + for ( i=0, ien=columns.length ; i<ien ; i++ ) { + a.push( columns[i]._ColReorder_iOrigCol ); + } + + return a; + } + + // The order given is based on the original indexes, rather than the + // existing ones, so we need to translate from the original to current + // before then doing the order + if ( original ) { + var order = this.fnOrder(); + + for ( i=0, ien=set.length ; i<ien ; i++ ) { + a.push( $.inArray( set[i], order ) ); + } + + set = a; + } + + this._fnOrderColumns( fnInvertKeyValues( set ) ); + + return this; + }, + + + /** + * Convert from the original column index, to the original + * + * @param {int|array} idx Index(es) to convert + * @param {string} dir Transpose direction - `fromOriginal` / `toCurrent` + * or `'toOriginal` / `fromCurrent` + * @return {int|array} Converted values + */ + fnTranspose: function ( idx, dir ) + { + if ( ! dir ) { + dir = 'toCurrent'; + } + + var order = this.fnOrder(); + var columns = this.s.dt.aoColumns; + + if ( dir === 'toCurrent' ) { + // Given an original index, want the current + return ! Array.isArray( idx ) ? + $.inArray( idx, order ) : + $.map( idx, function ( index ) { + return $.inArray( index, order ); + } ); + } + else { + // Given a current index, want the original + return ! Array.isArray( idx ) ? + columns[idx]._ColReorder_iOrigCol : + $.map( idx, function ( index ) { + return columns[index]._ColReorder_iOrigCol; + } ); + } + }, + + + /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * Private methods (they are of course public in JS, but recommended as private) + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ + + /** + * Constructor logic + * @method _fnConstruct + * @returns void + * @private + */ + "_fnConstruct": function () + { + var that = this; + var iLen = this.s.dt.aoColumns.length; + var table = this.s.dt.nTable; + var i; + + /* Columns discounted from reordering - counting left to right */ + if ( this.s.init.iFixedColumns ) + { + this.s.fixed = this.s.init.iFixedColumns; + } + + if ( this.s.init.iFixedColumnsLeft ) + { + this.s.fixed = this.s.init.iFixedColumnsLeft; + } + + /* Columns discounted from reordering - counting right to left */ + this.s.fixedRight = this.s.init.iFixedColumnsRight ? + this.s.init.iFixedColumnsRight : + 0; + + /* Drop callback initialisation option */ + if ( this.s.init.fnReorderCallback ) + { + this.s.reorderCallback = this.s.init.fnReorderCallback; + } + + /* Add event handlers for the drag and drop, and also mark the original column order */ + for ( i = 0; i < iLen; i++ ) + { + if ( i > this.s.fixed-1 && i < iLen - this.s.fixedRight ) + { + this._fnMouseListener( i, this.s.dt.aoColumns[i].nTh ); + } + + /* Mark the original column order for later reference */ + this.s.dt.aoColumns[i]._ColReorder_iOrigCol = i; + } + + /* State saving */ + this.s.dt.oApi._fnCallbackReg( this.s.dt, 'aoStateSaveParams', function (oS, oData) { + that._fnStateSave.call( that, oData ); + }, "ColReorder_State" ); + + /* An initial column order has been specified */ + var aiOrder = null; + if ( this.s.init.aiOrder ) + { + aiOrder = this.s.init.aiOrder.slice(); + } + + /* State loading, overrides the column order given */ + if ( this.s.dt.oLoadedState && typeof this.s.dt.oLoadedState.ColReorder != 'undefined' && + this.s.dt.oLoadedState.ColReorder.length == this.s.dt.aoColumns.length ) + { + aiOrder = this.s.dt.oLoadedState.ColReorder; + } + + /* If we have an order to apply - do so */ + if ( aiOrder ) + { + /* We might be called during or after the DataTables initialisation. If before, then we need + * to wait until the draw is done, if after, then do what we need to do right away + */ + if ( !that.s.dt._bInitComplete ) + { + var bDone = false; + $(table).on( 'draw.dt.colReorder', function () { + if ( !that.s.dt._bInitComplete && !bDone ) + { + bDone = true; + var resort = fnInvertKeyValues( aiOrder ); + that._fnOrderColumns.call( that, resort ); + } + } ); + } + else + { + var resort = fnInvertKeyValues( aiOrder ); + that._fnOrderColumns.call( that, resort ); + } + } + else { + this._fnSetColumnIndexes(); + } + + // Destroy clean up + $(table).on( 'destroy.dt.colReorder', function () { + $(table).off( 'destroy.dt.colReorder draw.dt.colReorder' ); + + $.each( that.s.dt.aoColumns, function (i, column) { + $(column.nTh).off('.ColReorder'); + $(column.nTh).removeAttr('data-column-index'); + } ); + + that.s.dt._colReorder = null; + that.s = null; + } ); + }, + + + /** + * Set the column order from an array + * @method _fnOrderColumns + * @param array a An array of integers which dictate the column order that should be applied + * @returns void + * @private + */ + "_fnOrderColumns": function ( a ) + { + var changed = false; + + if ( a.length != this.s.dt.aoColumns.length ) + { + this.s.dt.oInstance.oApi._fnLog( this.s.dt, 1, "ColReorder - array reorder does not "+ + "match known number of columns. Skipping." ); + return; + } + + for ( var i=0, iLen=a.length ; i<iLen ; i++ ) + { + var currIndex = $.inArray( i, a ); + if ( i != currIndex ) + { + /* Reorder our switching array */ + fnArraySwitch( a, currIndex, i ); + + /* Do the column reorder in the table */ + this.s.dt.oInstance.fnColReorder( currIndex, i, true, false ); + + changed = true; + } + } + + this._fnSetColumnIndexes(); + + // Has anything actually changed? If not, then nothing else to do + if ( ! changed ) { + return; + } + + $.fn.dataTable.Api( this.s.dt ).rows().invalidate(); + + /* When scrolling we need to recalculate the column sizes to allow for the shift */ + if ( this.s.dt.oScroll.sX !== "" || this.s.dt.oScroll.sY !== "" ) + { + this.s.dt.oInstance.fnAdjustColumnSizing( false ); + } + + /* Save the state */ + this.s.dt.oInstance.oApi._fnSaveState( this.s.dt ); + + if ( this.s.reorderCallback !== null ) + { + this.s.reorderCallback.call( this ); + } + }, + + + /** + * Because we change the indexes of columns in the table, relative to their starting point + * we need to reorder the state columns to what they are at the starting point so we can + * then rearrange them again on state load! + * @method _fnStateSave + * @param object oState DataTables state + * @returns string JSON encoded cookie string for DataTables + * @private + */ + "_fnStateSave": function ( oState ) + { + var i, iLen, aCopy, iOrigColumn; + var oSettings = this.s.dt; + var columns = oSettings.aoColumns; + + oState.ColReorder = []; + + /* Sorting */ + if ( oState.aaSorting ) { + // 1.10.0- + for ( i=0 ; i<oState.aaSorting.length ; i++ ) { + oState.aaSorting[i][0] = columns[ oState.aaSorting[i][0] ]._ColReorder_iOrigCol; + } + + var aSearchCopy = $.extend( true, [], oState.aoSearchCols ); + + for ( i=0, iLen=columns.length ; i<iLen ; i++ ) + { + iOrigColumn = columns[i]._ColReorder_iOrigCol; + + /* Column filter */ + oState.aoSearchCols[ iOrigColumn ] = aSearchCopy[i]; + + /* Visibility */ + oState.abVisCols[ iOrigColumn ] = columns[i].bVisible; + + /* Column reordering */ + oState.ColReorder.push( iOrigColumn ); + } + } + else if ( oState.order ) { + // 1.10.1+ + for ( i=0 ; i<oState.order.length ; i++ ) { + oState.order[i][0] = columns[ oState.order[i][0] ]._ColReorder_iOrigCol; + } + + var stateColumnsCopy = $.extend( true, [], oState.columns ); + + for ( i=0, iLen=columns.length ; i<iLen ; i++ ) + { + iOrigColumn = columns[i]._ColReorder_iOrigCol; + + /* Columns */ + oState.columns[ iOrigColumn ] = stateColumnsCopy[i]; + + /* Column reordering */ + oState.ColReorder.push( iOrigColumn ); + } + } + }, + + + /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * Mouse drop and drag + */ + + /** + * Add a mouse down listener to a particluar TH element + * @method _fnMouseListener + * @param int i Column index + * @param element nTh TH element clicked on + * @returns void + * @private + */ + "_fnMouseListener": function ( i, nTh ) + { + var that = this; + $(nTh) + .on( 'mousedown.ColReorder', function (e) { + if ( that.s.enable && e.which === 1 ) { + that._fnMouseDown.call( that, e, nTh ); + } + } ) + .on( 'touchstart.ColReorder', function (e) { + if ( that.s.enable ) { + that._fnMouseDown.call( that, e, nTh ); + } + } ); + }, + + + /** + * Mouse down on a TH element in the table header + * @method _fnMouseDown + * @param event e Mouse event + * @param element nTh TH element to be dragged + * @returns void + * @private + */ + "_fnMouseDown": function ( e, nTh ) + { + var that = this; + + /* Store information about the mouse position */ + var target = $(e.target).closest('th, td'); + var offset = target.offset(); + var idx = parseInt( $(nTh).attr('data-column-index'), 10 ); + + if ( idx === undefined ) { + return; + } + + this.s.mouse.startX = this._fnCursorPosition( e, 'pageX' ); + this.s.mouse.startY = this._fnCursorPosition( e, 'pageY' ); + this.s.mouse.offsetX = this._fnCursorPosition( e, 'pageX' ) - offset.left; + this.s.mouse.offsetY = this._fnCursorPosition( e, 'pageY' ) - offset.top; + this.s.mouse.target = this.s.dt.aoColumns[ idx ].nTh;//target[0]; + this.s.mouse.targetIndex = idx; + this.s.mouse.fromIndex = idx; + + this._fnRegions(); + + /* Add event handlers to the document */ + $(document) + .on( 'mousemove.ColReorder touchmove.ColReorder', function (e) { + that._fnMouseMove.call( that, e ); + } ) + .on( 'mouseup.ColReorder touchend.ColReorder', function (e) { + that._fnMouseUp.call( that, e ); + } ); + }, + + + /** + * Deal with a mouse move event while dragging a node + * @method _fnMouseMove + * @param event e Mouse event + * @returns void + * @private + */ + "_fnMouseMove": function ( e ) + { + var that = this; + + if ( this.dom.drag === null ) + { + /* Only create the drag element if the mouse has moved a specific distance from the start + * point - this allows the user to make small mouse movements when sorting and not have a + * possibly confusing drag element showing up + */ + if ( Math.pow( + Math.pow(this._fnCursorPosition( e, 'pageX') - this.s.mouse.startX, 2) + + Math.pow(this._fnCursorPosition( e, 'pageY') - this.s.mouse.startY, 2), 0.5 ) < 5 ) + { + return; + } + this._fnCreateDragNode(); + } + + /* Position the element - we respect where in the element the click occured */ + this.dom.drag.css( { + left: this._fnCursorPosition( e, 'pageX' ) - this.s.mouse.offsetX, + top: this._fnCursorPosition( e, 'pageY' ) - this.s.mouse.offsetY + } ); + + /* Based on the current mouse position, calculate where the insert should go */ + var target; + var lastToIndex = this.s.mouse.toIndex; + var cursorXPosiotion = this._fnCursorPosition(e, 'pageX'); + var targetsPrev = function (i) { + while (i >= 0) { + i--; + + if (i <= 0) { + return null; + } + + if (that.s.aoTargets[i+1].x !== that.s.aoTargets[i].x) { + return that.s.aoTargets[i]; + } + } + }; + var firstNotHidden = function () { + for (var i=0 ; i<that.s.aoTargets.length-1 ; i++) { + if (that.s.aoTargets[i].x !== that.s.aoTargets[i+1].x) { + return that.s.aoTargets[i]; + } + } + }; + var lastNotHidden = function () { + for (var i=that.s.aoTargets.length-1 ; i>0 ; i--) { + if (that.s.aoTargets[i].x !== that.s.aoTargets[i-1].x) { + return that.s.aoTargets[i]; + } + } + }; + + for (var i = 1; i < this.s.aoTargets.length; i++) { + var prevTarget = targetsPrev(i); + if (! prevTarget) { + prevTarget = firstNotHidden(); + } + + var prevTargetMiddle = prevTarget.x + (this.s.aoTargets[i].x - prevTarget.x) / 2; + + if (this._fnIsLtr()) { + if (cursorXPosiotion < prevTargetMiddle ) { + target = prevTarget; + break; + } + } + else { + if (cursorXPosiotion > prevTargetMiddle) { + target = prevTarget; + break; + } + } + } + + if (target) { + this.dom.pointer.css('left', target.x); + this.s.mouse.toIndex = target.to; + } + else { + // The insert element wasn't positioned in the array (less than + // operator), so we put it at the end + this.dom.pointer.css( 'left', lastNotHidden().x ); + this.s.mouse.toIndex = lastNotHidden().to; + } + + // Perform reordering if realtime updating is on and the column has moved + if ( this.s.init.bRealtime && lastToIndex !== this.s.mouse.toIndex ) { + this.s.dt.oInstance.fnColReorder( this.s.mouse.fromIndex, this.s.mouse.toIndex ); + this.s.mouse.fromIndex = this.s.mouse.toIndex; + + // Not great for performance, but required to keep everything in alignment + if ( this.s.dt.oScroll.sX !== "" || this.s.dt.oScroll.sY !== "" ) + { + this.s.dt.oInstance.fnAdjustColumnSizing( false ); + } + + this._fnRegions(); + } + }, + + + /** + * Finish off the mouse drag and insert the column where needed + * @method _fnMouseUp + * @param event e Mouse event + * @returns void + * @private + */ + "_fnMouseUp": function ( e ) + { + var that = this; + + $(document).off( '.ColReorder' ); + + if ( this.dom.drag !== null ) + { + /* Remove the guide elements */ + this.dom.drag.remove(); + this.dom.pointer.remove(); + this.dom.drag = null; + this.dom.pointer = null; + + /* Actually do the reorder */ + this.s.dt.oInstance.fnColReorder( this.s.mouse.fromIndex, this.s.mouse.toIndex, true ); + this._fnSetColumnIndexes(); + + /* When scrolling we need to recalculate the column sizes to allow for the shift */ + if ( this.s.dt.oScroll.sX !== "" || this.s.dt.oScroll.sY !== "" ) + { + this.s.dt.oInstance.fnAdjustColumnSizing( false ); + } + + /* Save the state */ + this.s.dt.oInstance.oApi._fnSaveState( this.s.dt ); + + if ( this.s.reorderCallback !== null ) + { + this.s.reorderCallback.call( this ); + } + } + }, + + + /** + * Calculate a cached array with the points of the column inserts, and the + * 'to' points + * @method _fnRegions + * @returns void + * @private + */ + "_fnRegions": function () + { + var aoColumns = this.s.dt.aoColumns; + var isLTR = this._fnIsLtr(); + this.s.aoTargets.splice(0, this.s.aoTargets.length); + var lastBound = $(this.s.dt.nTable).offset().left; + + var aoColumnBounds = []; + $.each(aoColumns, function (i, column) { + if (column.bVisible && column.nTh.style.display !== 'none') { + var nth = $(column.nTh); + var bound = nth.offset().left; + + if (isLTR) { + bound += nth.outerWidth(); + } + + aoColumnBounds.push({ + index: i, + bound: bound + }); + + lastBound = bound; + } + else { + aoColumnBounds.push({ + index: i, + bound: lastBound + }); + } + }); + + var firstColumn = aoColumnBounds[0]; + var firstColumnWidth = $(aoColumns[firstColumn.index].nTh).outerWidth(); + + this.s.aoTargets.push({ + to: 0, + x: firstColumn.bound - firstColumnWidth + }); + + for (var i = 0; i < aoColumnBounds.length; i++) { + var columnBound = aoColumnBounds[i]; + var iToPoint = columnBound.index; + + /* For the column / header in question, we want it's position to remain the same if the + * position is just to it's immediate left or right, so we only increment the counter for + * other columns + */ + if (columnBound.index < this.s.mouse.fromIndex) { + iToPoint++; + } + + this.s.aoTargets.push({ + to: iToPoint, + x: columnBound.bound + }); + } + + /* Disallow columns for being reordered by drag and drop, counting right to left */ + if ( this.s.fixedRight !== 0 ) + { + this.s.aoTargets.splice( this.s.aoTargets.length - this.s.fixedRight ); + } + + /* Disallow columns for being reordered by drag and drop, counting left to right */ + if ( this.s.fixed !== 0 ) + { + this.s.aoTargets.splice( 0, this.s.fixed ); + } + }, + + + /** + * Copy the TH element that is being drags so the user has the idea that they are actually + * moving it around the page. + * @method _fnCreateDragNode + * @returns void + * @private + */ + "_fnCreateDragNode": function () + { + var scrolling = this.s.dt.oScroll.sX !== "" || this.s.dt.oScroll.sY !== ""; + + var origCell = this.s.dt.aoColumns[ this.s.mouse.targetIndex ].nTh; + var origTr = origCell.parentNode; + var origThead = origTr.parentNode; + var origTable = origThead.parentNode; + var cloneCell = $(origCell).clone(); + + // This is a slightly odd combination of jQuery and DOM, but it is the + // fastest and least resource intensive way I could think of cloning + // the table with just a single header cell in it. + this.dom.drag = $(origTable.cloneNode(false)) + .addClass( 'DTCR_clonedTable' ) + .append( + $(origThead.cloneNode(false)).append( + $(origTr.cloneNode(false)).append( + cloneCell[0] + ) + ) + ) + .css( { + position: 'absolute', + top: 0, + left: 0, + width: $(origCell).outerWidth(), + height: $(origCell).outerHeight() + } ) + .appendTo( 'body' ); + + this.dom.pointer = $('<div></div>') + .addClass( 'DTCR_pointer' ) + .css( { + position: 'absolute', + top: scrolling ? + $('div.dataTables_scroll', this.s.dt.nTableWrapper).offset().top : + $(this.s.dt.nTable).offset().top, + height : scrolling ? + $('div.dataTables_scroll', this.s.dt.nTableWrapper).height() : + $(this.s.dt.nTable).height() + } ) + .appendTo( 'body' ); + }, + + + /** + * Add a data attribute to the column headers, so we know the index of + * the row to be reordered. This allows fast detection of the index, and + * for this plug-in to work with FixedHeader which clones the nodes. + * @private + */ + "_fnSetColumnIndexes": function () + { + $.each( this.s.dt.aoColumns, function (i, column) { + $(column.nTh).attr('data-column-index', i); + } ); + }, + + + /** + * Get cursor position regardless of mouse or touch input + * @param {Event} e jQuery Event + * @param {string} prop Property to get + * @return {number} Value + */ + _fnCursorPosition: function ( e, prop ) { + if ( e.type.indexOf('touch') !== -1 ) { + return e.originalEvent.touches[0][ prop ]; + } + return e[ prop ]; + }, + + _fnIsLtr: function () { + return $(this.s.dt.nTable).css('direction') !== "rtl"; + } +} ); + + + + + +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * Static parameters + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ + + +/** + * ColReorder default settings for initialisation + * @namespace + * @static + */ +ColReorder.defaults = { + /** + * Predefined ordering for the columns that will be applied automatically + * on initialisation. If not specified then the order that the columns are + * found to be in the HTML is the order used. + * @type array + * @default null + * @static + */ + aiOrder: null, + + /** + * ColReorder enable on initialisation + * @type boolean + * @default true + * @static + */ + bEnable: true, + + /** + * Redraw the table's column ordering as the end user draws the column + * (`true`) or wait until the mouse is released (`false` - default). Note + * that this will perform a redraw on each reordering, which involves an + * Ajax request each time if you are using server-side processing in + * DataTables. + * @type boolean + * @default false + * @static + */ + bRealtime: true, + + /** + * Indicate how many columns should be fixed in position (counting from the + * left). This will typically be 1 if used, but can be as high as you like. + * @type int + * @default 0 + * @static + */ + iFixedColumnsLeft: 0, + + /** + * As `iFixedColumnsRight` but counting from the right. + * @type int + * @default 0 + * @static + */ + iFixedColumnsRight: 0, + + /** + * Callback function that is fired when columns are reordered. The `column- + * reorder` event is preferred over this callback + * @type function():void + * @default null + * @static + */ + fnReorderCallback: null +}; + + + +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * Constants + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ + +/** + * ColReorder version + * @constant version + * @type String + * @default As code + */ +ColReorder.version = "1.5.4"; + + + +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * DataTables interfaces + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ + +// Expose +$.fn.dataTable.ColReorder = ColReorder; +$.fn.DataTable.ColReorder = ColReorder; + + +// Register a new feature with DataTables +if ( typeof $.fn.dataTable == "function" && + typeof $.fn.dataTableExt.fnVersionCheck == "function" && + $.fn.dataTableExt.fnVersionCheck('1.10.8') ) +{ + $.fn.dataTableExt.aoFeatures.push( { + "fnInit": function( settings ) { + var table = settings.oInstance; + + if ( ! settings._colReorder ) { + var dtInit = settings.oInit; + var opts = dtInit.colReorder || dtInit.oColReorder || {}; + + new ColReorder( settings, opts ); + } + else { + table.oApi._fnLog( settings, 1, "ColReorder attempted to initialise twice. Ignoring second" ); + } + + return null; /* No node for DataTables to insert */ + }, + "cFeature": "R", + "sFeature": "ColReorder" + } ); +} +else { + alert( "Warning: ColReorder requires DataTables 1.10.8 or greater - www.datatables.net/download"); +} + + +// Attach a listener to the document which listens for DataTables initialisation +// events so we can automatically initialise +$(document).on( 'preInit.dt.colReorder', function (e, settings) { + if ( e.namespace !== 'dt' ) { + return; + } + + var init = settings.oInit.colReorder; + var defaults = DataTable.defaults.colReorder; + + if ( init || defaults ) { + var opts = $.extend( {}, init, defaults ); + + if ( init !== false ) { + new ColReorder( settings, opts ); + } + } +} ); + + +// API augmentation +$.fn.dataTable.Api.register( 'colReorder.reset()', function () { + return this.iterator( 'table', function ( ctx ) { + ctx._colReorder.fnReset(); + } ); +} ); + +$.fn.dataTable.Api.register( 'colReorder.order()', function ( set, original ) { + if ( set ) { + return this.iterator( 'table', function ( ctx ) { + ctx._colReorder.fnOrder( set, original ); + } ); + } + + return this.context.length ? + this.context[0]._colReorder.fnOrder() : + null; +} ); + +$.fn.dataTable.Api.register( 'colReorder.transpose()', function ( idx, dir ) { + return this.context.length && this.context[0]._colReorder ? + this.context[0]._colReorder.fnTranspose( idx, dir ) : + idx; +} ); + +$.fn.dataTable.Api.register( 'colReorder.move()', function( from, to, drop, invalidateRows ) { + if (this.context.length) { + this.context[0]._colReorder.s.dt.oInstance.fnColReorder( from, to, drop, invalidateRows ); + this.context[0]._colReorder._fnSetColumnIndexes(); + } + return this; +} ); + +$.fn.dataTable.Api.register( 'colReorder.enable()', function( flag ) { + return this.iterator( 'table', function ( ctx ) { + if ( ctx._colReorder ) { + ctx._colReorder.fnEnable( flag ); + } + } ); +} ); + +$.fn.dataTable.Api.register( 'colReorder.disable()', function() { + return this.iterator( 'table', function ( ctx ) { + if ( ctx._colReorder ) { + ctx._colReorder.fnDisable(); + } + } ); +} ); + + +return ColReorder; +})); diff --git a/src/main/resources/static/plugins/datatables-colreorder/js/dataTables.colReorder.min.js b/src/main/resources/static/plugins/datatables-colreorder/js/dataTables.colReorder.min.js new file mode 100644 index 0000000..b546585 --- /dev/null +++ b/src/main/resources/static/plugins/datatables-colreorder/js/dataTables.colReorder.min.js @@ -0,0 +1,30 @@ +/*! + ColReorder 1.5.4 + ©2010-2021 SpryMedia Ltd - datatables.net/license +*/ +(function(e){"function"===typeof define&&define.amd?define(["jquery","datatables.net"],function(p){return e(p,window,document)}):"object"===typeof exports?module.exports=function(p,o){p||(p=window);if(!o||!o.fn.dataTable)o=require("datatables.net")(p,o).$;return e(o,p,p.document)}:e(jQuery,window,document)})(function(e,p,o,s){function r(a){for(var b=[],d=0,f=a.length;d<f;d++)b[a[d]]=d;return b}function q(a,b,d){b=a.splice(b,1)[0];a.splice(d,0,b)}function t(a,b,d){for(var f=[],e=0,c=a.childNodes.length;e< +c;e++)1==a.childNodes[e].nodeType&&f.push(a.childNodes[e]);b=f[b];null!==d?a.insertBefore(b,f[d]):a.appendChild(b)}var u=e.fn.dataTable;e.fn.dataTableExt.oApi.fnColReorder=function(a,b,d,f,h){var c,g,j,l,n,i=a.aoColumns.length,k;n=function(a,b,c){if(a[b]&&"function"!==typeof a[b]){var d=a[b].split("."),e=d.shift();isNaN(1*e)||(a[b]=c[1*e]+"."+d.join("."))}};if(b!=d)if(0>b||b>=i)this.oApi._fnLog(a,1,"ColReorder 'from' index is out of bounds: "+b);else if(0>d||d>=i)this.oApi._fnLog(a,1,"ColReorder 'to' index is out of bounds: "+ +d);else{j=[];c=0;for(g=i;c<g;c++)j[c]=c;q(j,b,d);var m=r(j);c=0;for(g=a.aaSorting.length;c<g;c++)a.aaSorting[c][0]=m[a.aaSorting[c][0]];if(null!==a.aaSortingFixed){c=0;for(g=a.aaSortingFixed.length;c<g;c++)a.aaSortingFixed[c][0]=m[a.aaSortingFixed[c][0]]}c=0;for(g=i;c<g;c++){k=a.aoColumns[c];j=0;for(l=k.aDataSort.length;j<l;j++)k.aDataSort[j]=m[k.aDataSort[j]];k.idx=m[k.idx]}e.each(a.aLastSort,function(b,c){a.aLastSort[b].src=m[c.src]});c=0;for(g=i;c<g;c++)k=a.aoColumns[c],"number"==typeof k.mData? +k.mData=m[k.mData]:e.isPlainObject(k.mData)&&(n(k.mData,"_",m),n(k.mData,"filter",m),n(k.mData,"sort",m),n(k.mData,"type",m));if(a.aoColumns[b].bVisible){n=this.oApi._fnColumnIndexToVisible(a,b);l=null;for(c=d<b?d:d+1;null===l&&c<i;)l=this.oApi._fnColumnIndexToVisible(a,c),c++;j=a.nTHead.getElementsByTagName("tr");c=0;for(g=j.length;c<g;c++)t(j[c],n,l);if(null!==a.nTFoot){j=a.nTFoot.getElementsByTagName("tr");c=0;for(g=j.length;c<g;c++)t(j[c],n,l)}c=0;for(g=a.aoData.length;c<g;c++)null!==a.aoData[c].nTr&& +t(a.aoData[c].nTr,n,l)}q(a.aoColumns,b,d);c=0;for(g=i;c<g;c++)a.oApi._fnColumnOptions(a,c,{});q(a.aoPreSearchCols,b,d);c=0;for(g=a.aoData.length;c<g;c++){l=a.aoData[c];if(k=l.anCells){q(k,b,d);j=0;for(n=k.length;j<n;j++)k[j]&&k[j]._DT_CellIndex&&(k[j]._DT_CellIndex.column=j)}"dom"!==l.src&&Array.isArray(l._aData)&&q(l._aData,b,d)}c=0;for(g=a.aoHeader.length;c<g;c++)q(a.aoHeader[c],b,d);if(null!==a.aoFooter){c=0;for(g=a.aoFooter.length;c<g;c++)q(a.aoFooter[c],b,d)}(h||h===s)&&e.fn.dataTable.Api(a).rows().invalidate(); +c=0;for(g=i;c<g;c++)e(a.aoColumns[c].nTh).off(".DT"),this.oApi._fnSortAttachListener(a,a.aoColumns[c].nTh,c);e(a.oInstance).trigger("column-reorder.dt",[a,{from:b,to:d,mapping:m,drop:f,iFrom:b,iTo:d,aiInvertMapping:m}])}};var i=function(a,b){var d=(new e.fn.dataTable.Api(a)).settings()[0];if(d._colReorder)return d._colReorder;!0===b&&(b={});var f=e.fn.dataTable.camelToHungarian;f&&(f(i.defaults,i.defaults,!0),f(i.defaults,b||{}));this.s={dt:null,enable:null,init:e.extend(!0,{},i.defaults,b),fixed:0, +fixedRight:0,reorderCallback:null,mouse:{startX:-1,startY:-1,offsetX:-1,offsetY:-1,target:-1,targetIndex:-1,fromIndex:-1},aoTargets:[]};this.dom={drag:null,pointer:null};this.s.enable=this.s.init.bEnable;this.s.dt=d;this.s.dt._colReorder=this;this._fnConstruct();return this};e.extend(i.prototype,{fnEnable:function(a){if(!1===a)return fnDisable();this.s.enable=!0},fnDisable:function(){this.s.enable=!1},fnReset:function(){this._fnOrderColumns(this.fnOrder());return this},fnGetCurrentOrder:function(){return this.fnOrder()}, +fnOrder:function(a,b){var d=[],f,h,c=this.s.dt.aoColumns;if(a===s){f=0;for(h=c.length;f<h;f++)d.push(c[f]._ColReorder_iOrigCol);return d}if(b){c=this.fnOrder();f=0;for(h=a.length;f<h;f++)d.push(e.inArray(a[f],c));a=d}this._fnOrderColumns(r(a));return this},fnTranspose:function(a,b){b||(b="toCurrent");var d=this.fnOrder(),f=this.s.dt.aoColumns;return"toCurrent"===b?!Array.isArray(a)?e.inArray(a,d):e.map(a,function(a){return e.inArray(a,d)}):!Array.isArray(a)?f[a]._ColReorder_iOrigCol:e.map(a,function(a){return f[a]._ColReorder_iOrigCol})}, +_fnConstruct:function(){var a=this,b=this.s.dt.aoColumns.length,d=this.s.dt.nTable,f;this.s.init.iFixedColumns&&(this.s.fixed=this.s.init.iFixedColumns);this.s.init.iFixedColumnsLeft&&(this.s.fixed=this.s.init.iFixedColumnsLeft);this.s.fixedRight=this.s.init.iFixedColumnsRight?this.s.init.iFixedColumnsRight:0;this.s.init.fnReorderCallback&&(this.s.reorderCallback=this.s.init.fnReorderCallback);for(f=0;f<b;f++)f>this.s.fixed-1&&f<b-this.s.fixedRight&&this._fnMouseListener(f,this.s.dt.aoColumns[f].nTh), +this.s.dt.aoColumns[f]._ColReorder_iOrigCol=f;this.s.dt.oApi._fnCallbackReg(this.s.dt,"aoStateSaveParams",function(b,c){a._fnStateSave.call(a,c)},"ColReorder_State");var h=null;this.s.init.aiOrder&&(h=this.s.init.aiOrder.slice());this.s.dt.oLoadedState&&("undefined"!=typeof this.s.dt.oLoadedState.ColReorder&&this.s.dt.oLoadedState.ColReorder.length==this.s.dt.aoColumns.length)&&(h=this.s.dt.oLoadedState.ColReorder);if(h)if(a.s.dt._bInitComplete)b=r(h),a._fnOrderColumns.call(a,b);else{var c=!1;e(d).on("draw.dt.colReorder", +function(){if(!a.s.dt._bInitComplete&&!c){c=true;var b=r(h);a._fnOrderColumns.call(a,b)}})}else this._fnSetColumnIndexes();e(d).on("destroy.dt.colReorder",function(){e(d).off("destroy.dt.colReorder draw.dt.colReorder");e.each(a.s.dt.aoColumns,function(a,b){e(b.nTh).off(".ColReorder");e(b.nTh).removeAttr("data-column-index")});a.s.dt._colReorder=null;a.s=null})},_fnOrderColumns:function(a){var b=!1;if(a.length!=this.s.dt.aoColumns.length)this.s.dt.oInstance.oApi._fnLog(this.s.dt,1,"ColReorder - array reorder does not match known number of columns. Skipping."); +else{for(var d=0,f=a.length;d<f;d++){var h=e.inArray(d,a);d!=h&&(q(a,h,d),this.s.dt.oInstance.fnColReorder(h,d,!0,!1),b=!0)}this._fnSetColumnIndexes();b&&(e.fn.dataTable.Api(this.s.dt).rows().invalidate(),(""!==this.s.dt.oScroll.sX||""!==this.s.dt.oScroll.sY)&&this.s.dt.oInstance.fnAdjustColumnSizing(!1),this.s.dt.oInstance.oApi._fnSaveState(this.s.dt),null!==this.s.reorderCallback&&this.s.reorderCallback.call(this))}},_fnStateSave:function(a){var b,d,f,h=this.s.dt.aoColumns;a.ColReorder=[];if(a.aaSorting){for(b= +0;b<a.aaSorting.length;b++)a.aaSorting[b][0]=h[a.aaSorting[b][0]]._ColReorder_iOrigCol;var c=e.extend(!0,[],a.aoSearchCols);b=0;for(d=h.length;b<d;b++)f=h[b]._ColReorder_iOrigCol,a.aoSearchCols[f]=c[b],a.abVisCols[f]=h[b].bVisible,a.ColReorder.push(f)}else if(a.order){for(b=0;b<a.order.length;b++)a.order[b][0]=h[a.order[b][0]]._ColReorder_iOrigCol;c=e.extend(!0,[],a.columns);b=0;for(d=h.length;b<d;b++)f=h[b]._ColReorder_iOrigCol,a.columns[f]=c[b],a.ColReorder.push(f)}},_fnMouseListener:function(a, +b){var d=this;e(b).on("mousedown.ColReorder",function(a){d.s.enable&&1===a.which&&d._fnMouseDown.call(d,a,b)}).on("touchstart.ColReorder",function(a){d.s.enable&&d._fnMouseDown.call(d,a,b)})},_fnMouseDown:function(a,b){var d=this,f=e(a.target).closest("th, td").offset(),h=parseInt(e(b).attr("data-column-index"),10);h!==s&&(this.s.mouse.startX=this._fnCursorPosition(a,"pageX"),this.s.mouse.startY=this._fnCursorPosition(a,"pageY"),this.s.mouse.offsetX=this._fnCursorPosition(a,"pageX")-f.left,this.s.mouse.offsetY= +this._fnCursorPosition(a,"pageY")-f.top,this.s.mouse.target=this.s.dt.aoColumns[h].nTh,this.s.mouse.targetIndex=h,this.s.mouse.fromIndex=h,this._fnRegions(),e(o).on("mousemove.ColReorder touchmove.ColReorder",function(a){d._fnMouseMove.call(d,a)}).on("mouseup.ColReorder touchend.ColReorder",function(a){d._fnMouseUp.call(d,a)}))},_fnMouseMove:function(a){var b=this;if(null===this.dom.drag){if(5>Math.pow(Math.pow(this._fnCursorPosition(a,"pageX")-this.s.mouse.startX,2)+Math.pow(this._fnCursorPosition(a, +"pageY")-this.s.mouse.startY,2),0.5))return;this._fnCreateDragNode()}this.dom.drag.css({left:this._fnCursorPosition(a,"pageX")-this.s.mouse.offsetX,top:this._fnCursorPosition(a,"pageY")-this.s.mouse.offsetY});for(var d,e=this.s.mouse.toIndex,a=this._fnCursorPosition(a,"pageX"),h=function(){for(var a=b.s.aoTargets.length-1;0<a;a--)if(b.s.aoTargets[a].x!==b.s.aoTargets[a-1].x)return b.s.aoTargets[a]},c=1;c<this.s.aoTargets.length;c++){var g;a:{for(g=c;0<=g;){g--;if(0>=g){g=null;break a}if(b.s.aoTargets[g+ +1].x!==b.s.aoTargets[g].x){g=b.s.aoTargets[g];break a}}g=void 0}if(!g)a:{for(g=0;g<b.s.aoTargets.length-1;g++)if(b.s.aoTargets[g].x!==b.s.aoTargets[g+1].x){g=b.s.aoTargets[g];break a}g=void 0}var j=g.x+(this.s.aoTargets[c].x-g.x)/2;if(this._fnIsLtr()){if(a<j){d=g;break}}else if(a>j){d=g;break}}d?(this.dom.pointer.css("left",d.x),this.s.mouse.toIndex=d.to):(this.dom.pointer.css("left",h().x),this.s.mouse.toIndex=h().to);this.s.init.bRealtime&&e!==this.s.mouse.toIndex&&(this.s.dt.oInstance.fnColReorder(this.s.mouse.fromIndex, +this.s.mouse.toIndex),this.s.mouse.fromIndex=this.s.mouse.toIndex,(""!==this.s.dt.oScroll.sX||""!==this.s.dt.oScroll.sY)&&this.s.dt.oInstance.fnAdjustColumnSizing(!1),this._fnRegions())},_fnMouseUp:function(){e(o).off(".ColReorder");null!==this.dom.drag&&(this.dom.drag.remove(),this.dom.pointer.remove(),this.dom.drag=null,this.dom.pointer=null,this.s.dt.oInstance.fnColReorder(this.s.mouse.fromIndex,this.s.mouse.toIndex,!0),this._fnSetColumnIndexes(),(""!==this.s.dt.oScroll.sX||""!==this.s.dt.oScroll.sY)&& +this.s.dt.oInstance.fnAdjustColumnSizing(!1),this.s.dt.oInstance.oApi._fnSaveState(this.s.dt),null!==this.s.reorderCallback&&this.s.reorderCallback.call(this))},_fnRegions:function(){var a=this.s.dt.aoColumns,b=this._fnIsLtr();this.s.aoTargets.splice(0,this.s.aoTargets.length);var d=e(this.s.dt.nTable).offset().left,f=[];e.each(a,function(a,c){if(c.bVisible&&"none"!==c.nTh.style.display){var h=e(c.nTh),i=h.offset().left;b&&(i+=h.outerWidth());f.push({index:a,bound:i});d=i}else f.push({index:a,bound:d})}); +var h=f[0],a=e(a[h.index].nTh).outerWidth();this.s.aoTargets.push({to:0,x:h.bound-a});for(h=0;h<f.length;h++){var a=f[h],c=a.index;a.index<this.s.mouse.fromIndex&&c++;this.s.aoTargets.push({to:c,x:a.bound})}0!==this.s.fixedRight&&this.s.aoTargets.splice(this.s.aoTargets.length-this.s.fixedRight);0!==this.s.fixed&&this.s.aoTargets.splice(0,this.s.fixed)},_fnCreateDragNode:function(){var a=""!==this.s.dt.oScroll.sX||""!==this.s.dt.oScroll.sY,b=this.s.dt.aoColumns[this.s.mouse.targetIndex].nTh,d=b.parentNode, +f=d.parentNode,h=f.parentNode,c=e(b).clone();this.dom.drag=e(h.cloneNode(!1)).addClass("DTCR_clonedTable").append(e(f.cloneNode(!1)).append(e(d.cloneNode(!1)).append(c[0]))).css({position:"absolute",top:0,left:0,width:e(b).outerWidth(),height:e(b).outerHeight()}).appendTo("body");this.dom.pointer=e("<div></div>").addClass("DTCR_pointer").css({position:"absolute",top:a?e("div.dataTables_scroll",this.s.dt.nTableWrapper).offset().top:e(this.s.dt.nTable).offset().top,height:a?e("div.dataTables_scroll", +this.s.dt.nTableWrapper).height():e(this.s.dt.nTable).height()}).appendTo("body")},_fnSetColumnIndexes:function(){e.each(this.s.dt.aoColumns,function(a,b){e(b.nTh).attr("data-column-index",a)})},_fnCursorPosition:function(a,b){return-1!==a.type.indexOf("touch")?a.originalEvent.touches[0][b]:a[b]},_fnIsLtr:function(){return"rtl"!==e(this.s.dt.nTable).css("direction")}});i.defaults={aiOrder:null,bEnable:!0,bRealtime:!0,iFixedColumnsLeft:0,iFixedColumnsRight:0,fnReorderCallback:null};i.version="1.5.4"; +e.fn.dataTable.ColReorder=i;e.fn.DataTable.ColReorder=i;"function"==typeof e.fn.dataTable&&"function"==typeof e.fn.dataTableExt.fnVersionCheck&&e.fn.dataTableExt.fnVersionCheck("1.10.8")?e.fn.dataTableExt.aoFeatures.push({fnInit:function(a){var b=a.oInstance;a._colReorder?b.oApi._fnLog(a,1,"ColReorder attempted to initialise twice. Ignoring second"):(b=a.oInit,new i(a,b.colReorder||b.oColReorder||{}));return null},cFeature:"R",sFeature:"ColReorder"}):alert("Warning: ColReorder requires DataTables 1.10.8 or greater - www.datatables.net/download"); +e(o).on("preInit.dt.colReorder",function(a,b){if("dt"===a.namespace){var d=b.oInit.colReorder,f=u.defaults.colReorder;if(d||f)f=e.extend({},d,f),!1!==d&&new i(b,f)}});e.fn.dataTable.Api.register("colReorder.reset()",function(){return this.iterator("table",function(a){a._colReorder.fnReset()})});e.fn.dataTable.Api.register("colReorder.order()",function(a,b){return a?this.iterator("table",function(d){d._colReorder.fnOrder(a,b)}):this.context.length?this.context[0]._colReorder.fnOrder():null});e.fn.dataTable.Api.register("colReorder.transpose()", +function(a,b){return this.context.length&&this.context[0]._colReorder?this.context[0]._colReorder.fnTranspose(a,b):a});e.fn.dataTable.Api.register("colReorder.move()",function(a,b,d,e){this.context.length&&(this.context[0]._colReorder.s.dt.oInstance.fnColReorder(a,b,d,e),this.context[0]._colReorder._fnSetColumnIndexes());return this});e.fn.dataTable.Api.register("colReorder.enable()",function(a){return this.iterator("table",function(b){b._colReorder&&b._colReorder.fnEnable(a)})});e.fn.dataTable.Api.register("colReorder.disable()", +function(){return this.iterator("table",function(a){a._colReorder&&a._colReorder.fnDisable()})});return i}); |