'+d[i].option(a,b)+"
").append(f('
')
+ .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 ];
+ }
+} );
+
+
+
+
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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.1";
+
+
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 );
+ }
+ 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/BackEnd/assets/vendor/datatables/extensions/colreorder/dataTables.colReorder.min.js b/BackEnd/assets/vendor/datatables/extensions/colreorder/dataTables.colReorder.min.js
new file mode 100644
index 0000000..bdccb29
--- /dev/null
+++ b/BackEnd/assets/vendor/datatables/extensions/colreorder/dataTables.colReorder.min.js
@@ -0,0 +1,29 @@
+/*!
+ ColReorder 1.5.1
+ ©2010-2018 SpryMedia Ltd - datatables.net/license
+*/
+(function(e){"function"===typeof define&&define.amd?define(["jquery","datatables.net"],function(o){return e(o,window,document)}):"object"===typeof exports?module.exports=function(o,l){o||(o=window);if(!l||!l.fn.dataTable)l=require("datatables.net")(o,l).$;return e(l,o,o.document)}:e(jQuery,window,document)})(function(e,o,l,r){function q(a){for(var b=[],c=0,f=a.length;c
b||b>=l)this.oApi._fnLog(a,1,"ColReorder 'from' index is out of bounds: "+b);else if(0>c||c>=l)this.oApi._fnLog(a,1,"ColReorder 'to' index is out of bounds: "+
+c);else{j=[];d=0;for(h=l;dthis.s.fixed-1&&fMath.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 b=!1,c=this.s.mouse.toIndex,f=1,e=this.s.aoTargets.length;f").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]}});i.defaults={aiOrder:null,bEnable:!0,bRealtime:!0,iFixedColumnsLeft:0,iFixedColumnsRight:0,fnReorderCallback:null};i.version="1.5.1";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(l).on("preInit.dt.colReorder",function(a,
+b){if("dt"===a.namespace){var c=b.oInit.colReorder,f=t.defaults.colReorder;if(c||f)f=e.extend({},c,f),!1!==c&&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(c){c._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,c,e){this.context.length&&this.context[0]._colReorder.s.dt.oInstance.fnColReorder(a,b,c,e);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});
diff --git a/BackEnd/assets/vendor/datatables/extensions/fixedcolumns/dataTables.fixedColumns.js b/BackEnd/assets/vendor/datatables/extensions/fixedcolumns/dataTables.fixedColumns.js
new file mode 100644
index 0000000..91a5a2c
--- /dev/null
+++ b/BackEnd/assets/vendor/datatables/extensions/fixedcolumns/dataTables.fixedColumns.js
@@ -0,0 +1,1632 @@
+/*! FixedColumns 3.2.6
+ * ©2010-2018 SpryMedia Ltd - datatables.net/license
+ */
+
+/**
+ * @summary FixedColumns
+ * @description Freeze columns in place on a scrolling DataTable
+ * @version 3.2.6
+ * @file dataTables.fixedColumns.js
+ * @author SpryMedia Ltd (www.sprymedia.co.uk)
+ * @contact www.sprymedia.co.uk/contact
+ * @copyright Copyright 2010-2018 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;
+var _firefoxScroll;
+
+/**
+ * When making use of DataTables' x-axis scrolling feature, you may wish to
+ * fix the left most column in place. This plug-in for DataTables provides
+ * exactly this option (note for non-scrolling tables, please use the
+ * FixedHeader plug-in, which can fix headers and footers). Key
+ * features include:
+ *
+ * * Freezes the left or right most columns to the side of the table
+ * * Option to freeze two or more columns
+ * * Full integration with DataTables' scrolling options
+ * * Speed - FixedColumns is fast in its operation
+ *
+ * @class
+ * @constructor
+ * @global
+ * @param {object} dt DataTables instance. With DataTables 1.10 this can also
+ * be a jQuery collection, a jQuery selector, DataTables API instance or
+ * settings object.
+ * @param {object} [init={}] Configuration object for FixedColumns. Options are
+ * defined by {@link FixedColumns.defaults}
+ *
+ * @requires jQuery 1.7+
+ * @requires DataTables 1.8.0+
+ *
+ * @example
+ * var table = $('#example').dataTable( {
+ * "scrollX": "100%"
+ * } );
+ * new $.fn.dataTable.fixedColumns( table );
+ */
+var FixedColumns = function ( dt, init ) {
+ var that = this;
+
+ /* Sanity check - you just know it will happen */
+ if ( ! ( this instanceof FixedColumns ) ) {
+ alert( "FixedColumns warning: FixedColumns must be initialised with the 'new' keyword." );
+ return;
+ }
+
+ if ( init === undefined || init === true ) {
+ init = {};
+ }
+
+ // Use the DataTables Hungarian notation mapping method, if it exists to
+ // provide forwards compatibility for camel case variables
+ var camelToHungarian = $.fn.dataTable.camelToHungarian;
+ if ( camelToHungarian ) {
+ camelToHungarian( FixedColumns.defaults, FixedColumns.defaults, true );
+ camelToHungarian( FixedColumns.defaults, init );
+ }
+
+ // v1.10 allows the settings object to be got form a number of sources
+ var dtSettings = new $.fn.dataTable.Api( dt ).settings()[0];
+
+ /**
+ * Settings object which contains customisable information for FixedColumns instance
+ * @namespace
+ * @extends FixedColumns.defaults
+ * @private
+ */
+ this.s = {
+ /**
+ * DataTables settings objects
+ * @type object
+ * @default Obtained from DataTables instance
+ */
+ "dt": dtSettings,
+
+ /**
+ * Number of columns in the DataTable - stored for quick access
+ * @type int
+ * @default Obtained from DataTables instance
+ */
+ "iTableColumns": dtSettings.aoColumns.length,
+
+ /**
+ * Original outer widths of the columns as rendered by DataTables - used to calculate
+ * the FixedColumns grid bounding box
+ * @type array.
+ * @default []
+ */
+ "aiOuterWidths": [],
+
+ /**
+ * Original inner widths of the columns as rendered by DataTables - used to apply widths
+ * to the columns
+ * @type array.
+ * @default []
+ */
+ "aiInnerWidths": [],
+
+
+ /**
+ * Is the document layout right-to-left
+ * @type boolean
+ */
+ rtl: $(dtSettings.nTable).css('direction') === 'rtl'
+ };
+
+
+ /**
+ * DOM elements used by the class instance
+ * @namespace
+ * @private
+ *
+ */
+ this.dom = {
+ /**
+ * DataTables scrolling element
+ * @type node
+ * @default null
+ */
+ "scroller": null,
+
+ /**
+ * DataTables header table
+ * @type node
+ * @default null
+ */
+ "header": null,
+
+ /**
+ * DataTables body table
+ * @type node
+ * @default null
+ */
+ "body": null,
+
+ /**
+ * DataTables footer table
+ * @type node
+ * @default null
+ */
+ "footer": null,
+
+ /**
+ * Display grid elements
+ * @namespace
+ */
+ "grid": {
+ /**
+ * Grid wrapper. This is the container element for the 3x3 grid
+ * @type node
+ * @default null
+ */
+ "wrapper": null,
+
+ /**
+ * DataTables scrolling element. This element is the DataTables
+ * component in the display grid (making up the main table - i.e.
+ * not the fixed columns).
+ * @type node
+ * @default null
+ */
+ "dt": null,
+
+ /**
+ * Left fixed column grid components
+ * @namespace
+ */
+ "left": {
+ "wrapper": null,
+ "head": null,
+ "body": null,
+ "foot": null
+ },
+
+ /**
+ * Right fixed column grid components
+ * @namespace
+ */
+ "right": {
+ "wrapper": null,
+ "head": null,
+ "body": null,
+ "foot": null
+ }
+ },
+
+ /**
+ * Cloned table nodes
+ * @namespace
+ */
+ "clone": {
+ /**
+ * Left column cloned table nodes
+ * @namespace
+ */
+ "left": {
+ /**
+ * Cloned header table
+ * @type node
+ * @default null
+ */
+ "header": null,
+
+ /**
+ * Cloned body table
+ * @type node
+ * @default null
+ */
+ "body": null,
+
+ /**
+ * Cloned footer table
+ * @type node
+ * @default null
+ */
+ "footer": null
+ },
+
+ /**
+ * Right column cloned table nodes
+ * @namespace
+ */
+ "right": {
+ /**
+ * Cloned header table
+ * @type node
+ * @default null
+ */
+ "header": null,
+
+ /**
+ * Cloned body table
+ * @type node
+ * @default null
+ */
+ "body": null,
+
+ /**
+ * Cloned footer table
+ * @type node
+ * @default null
+ */
+ "footer": null
+ }
+ }
+ };
+
+ if ( dtSettings._oFixedColumns ) {
+ throw 'FixedColumns already initialised on this table';
+ }
+
+ /* Attach the instance to the DataTables instance so it can be accessed easily */
+ dtSettings._oFixedColumns = this;
+
+ /* Let's do it */
+ if ( ! dtSettings._bInitComplete )
+ {
+ dtSettings.oApi._fnCallbackReg( dtSettings, 'aoInitComplete', function () {
+ that._fnConstruct( init );
+ }, 'FixedColumns' );
+ }
+ else
+ {
+ this._fnConstruct( init );
+ }
+};
+
+
+
+$.extend( FixedColumns.prototype , {
+ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Public methods
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+ /**
+ * Update the fixed columns - including headers and footers. Note that FixedColumns will
+ * automatically update the display whenever the host DataTable redraws.
+ * @returns {void}
+ * @example
+ * var table = $('#example').dataTable( {
+ * "scrollX": "100%"
+ * } );
+ * var fc = new $.fn.dataTable.fixedColumns( table );
+ *
+ * // at some later point when the table has been manipulated....
+ * fc.fnUpdate();
+ */
+ "fnUpdate": function ()
+ {
+ this._fnDraw( true );
+ },
+
+
+ /**
+ * Recalculate the resizes of the 3x3 grid that FixedColumns uses for display of the table.
+ * This is useful if you update the width of the table container. Note that FixedColumns will
+ * perform this function automatically when the window.resize event is fired.
+ * @returns {void}
+ * @example
+ * var table = $('#example').dataTable( {
+ * "scrollX": "100%"
+ * } );
+ * var fc = new $.fn.dataTable.fixedColumns( table );
+ *
+ * // Resize the table container and then have FixedColumns adjust its layout....
+ * $('#content').width( 1200 );
+ * fc.fnRedrawLayout();
+ */
+ "fnRedrawLayout": function ()
+ {
+ this._fnColCalc();
+ this._fnGridLayout();
+ this.fnUpdate();
+ },
+
+
+ /**
+ * Mark a row such that it's height should be recalculated when using 'semiauto' row
+ * height matching. This function will have no effect when 'none' or 'auto' row height
+ * matching is used.
+ * @param {Node} nTr TR element that should have it's height recalculated
+ * @returns {void}
+ * @example
+ * var table = $('#example').dataTable( {
+ * "scrollX": "100%"
+ * } );
+ * var fc = new $.fn.dataTable.fixedColumns( table );
+ *
+ * // manipulate the table - mark the row as needing an update then update the table
+ * // this allows the redraw performed by DataTables fnUpdate to recalculate the row
+ * // height
+ * fc.fnRecalculateHeight();
+ * table.fnUpdate( $('#example tbody tr:eq(0)')[0], ["insert date", 1, 2, 3 ... ]);
+ */
+ "fnRecalculateHeight": function ( nTr )
+ {
+ delete nTr._DTTC_iHeight;
+ nTr.style.height = 'auto';
+ },
+
+
+ /**
+ * Set the height of a given row - provides cross browser compatibility
+ * @param {Node} nTarget TR element that should have it's height recalculated
+ * @param {int} iHeight Height in pixels to set
+ * @returns {void}
+ * @example
+ * var table = $('#example').dataTable( {
+ * "scrollX": "100%"
+ * } );
+ * var fc = new $.fn.dataTable.fixedColumns( table );
+ *
+ * // You may want to do this after manipulating a row in the fixed column
+ * fc.fnSetRowHeight( $('#example tbody tr:eq(0)')[0], 50 );
+ */
+ "fnSetRowHeight": function ( nTarget, iHeight )
+ {
+ nTarget.style.height = iHeight+"px";
+ },
+
+
+ /**
+ * Get data index information about a row or cell in the table body.
+ * This function is functionally identical to fnGetPosition in DataTables,
+ * taking the same parameter (TH, TD or TR node) and returning exactly the
+ * the same information (data index information). THe difference between
+ * the two is that this method takes into account the fixed columns in the
+ * table, so you can pass in nodes from the master table, or the cloned
+ * tables and get the index position for the data in the main table.
+ * @param {node} node TR, TH or TD element to get the information about
+ * @returns {int} If nNode is given as a TR, then a single index is
+ * returned, or if given as a cell, an array of [row index, column index
+ * (visible), column index (all)] is given.
+ */
+ "fnGetPosition": function ( node )
+ {
+ var idx;
+ var inst = this.s.dt.oInstance;
+
+ if ( ! $(node).parents('.DTFC_Cloned').length )
+ {
+ // Not in a cloned table
+ return inst.fnGetPosition( node );
+ }
+ else
+ {
+ // Its in the cloned table, so need to look up position
+ if ( node.nodeName.toLowerCase() === 'tr' ) {
+ idx = $(node).index();
+ return inst.fnGetPosition( $('tr', this.s.dt.nTBody)[ idx ] );
+ }
+ else
+ {
+ var colIdx = $(node).index();
+ idx = $(node.parentNode).index();
+ var row = inst.fnGetPosition( $('tr', this.s.dt.nTBody)[ idx ] );
+
+ return [
+ row,
+ colIdx,
+ inst.oApi._fnVisibleToColumnIndex( this.s.dt, colIdx )
+ ];
+ }
+ }
+ },
+
+
+
+ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Private methods (they are of course public in JS, but recommended as private)
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+ /**
+ * Initialisation for FixedColumns
+ * @param {Object} oInit User settings for initialisation
+ * @returns {void}
+ * @private
+ */
+ "_fnConstruct": function ( oInit )
+ {
+ var i, iLen, iWidth,
+ that = this;
+
+ /* Sanity checking */
+ if ( typeof this.s.dt.oInstance.fnVersionCheck != 'function' ||
+ this.s.dt.oInstance.fnVersionCheck( '1.8.0' ) !== true )
+ {
+ alert( "FixedColumns "+FixedColumns.VERSION+" required DataTables 1.8.0 or later. "+
+ "Please upgrade your DataTables installation" );
+ return;
+ }
+
+ if ( this.s.dt.oScroll.sX === "" )
+ {
+ this.s.dt.oInstance.oApi._fnLog( this.s.dt, 1, "FixedColumns is not needed (no "+
+ "x-scrolling in DataTables enabled), so no action will be taken. Use 'FixedHeader' for "+
+ "column fixing when scrolling is not enabled" );
+ return;
+ }
+
+ /* Apply the settings from the user / defaults */
+ this.s = $.extend( true, this.s, FixedColumns.defaults, oInit );
+
+ /* Set up the DOM as we need it and cache nodes */
+ var classes = this.s.dt.oClasses;
+ this.dom.grid.dt = $(this.s.dt.nTable).parents('div.'+classes.sScrollWrapper)[0];
+ this.dom.scroller = $('div.'+classes.sScrollBody, this.dom.grid.dt )[0];
+
+ /* Set up the DOM that we want for the fixed column layout grid */
+ this._fnColCalc();
+ this._fnGridSetup();
+
+ /* Event handlers */
+ var mouseController;
+ var mouseDown = false;
+
+ // When the mouse is down (drag scroll) the mouse controller cannot
+ // change, as the browser keeps the original element as the scrolling one
+ $(this.s.dt.nTableWrapper).on( 'mousedown.DTFC', function (e) {
+ if ( e.button === 0 ) {
+ mouseDown = true;
+
+ $(document).one( 'mouseup', function () {
+ mouseDown = false;
+ } );
+ }
+ } );
+
+ // When the body is scrolled - scroll the left and right columns
+ $(this.dom.scroller)
+ .on( 'mouseover.DTFC touchstart.DTFC', function () {
+ if ( ! mouseDown ) {
+ mouseController = 'main';
+ }
+ } )
+ .on( 'scroll.DTFC', function (e) {
+ if ( ! mouseController && e.originalEvent ) {
+ mouseController = 'main';
+ }
+
+ if ( mouseController === 'main' ) {
+ if ( that.s.iLeftColumns > 0 ) {
+ that.dom.grid.left.liner.scrollTop = that.dom.scroller.scrollTop;
+ }
+ if ( that.s.iRightColumns > 0 ) {
+ that.dom.grid.right.liner.scrollTop = that.dom.scroller.scrollTop;
+ }
+ }
+ } );
+
+ var wheelType = 'onwheel' in document.createElement('div') ?
+ 'wheel.DTFC' :
+ 'mousewheel.DTFC';
+
+ if ( that.s.iLeftColumns > 0 ) {
+ // When scrolling the left column, scroll the body and right column
+ $(that.dom.grid.left.liner)
+ .on( 'mouseover.DTFC touchstart.DTFC', function () {
+ if ( ! mouseDown ) {
+ mouseController = 'left';
+ }
+ } )
+ .on( 'scroll.DTFC', function ( e ) {
+ if ( ! mouseController && e.originalEvent ) {
+ mouseController = 'left';
+ }
+
+ if ( mouseController === 'left' ) {
+ that.dom.scroller.scrollTop = that.dom.grid.left.liner.scrollTop;
+ if ( that.s.iRightColumns > 0 ) {
+ that.dom.grid.right.liner.scrollTop = that.dom.grid.left.liner.scrollTop;
+ }
+ }
+ } )
+ .on( wheelType, function(e) {
+ // Pass horizontal scrolling through
+ var xDelta = e.type === 'wheel' ?
+ -e.originalEvent.deltaX :
+ e.originalEvent.wheelDeltaX;
+ that.dom.scroller.scrollLeft -= xDelta;
+ } );
+ }
+
+ if ( that.s.iRightColumns > 0 ) {
+ // When scrolling the right column, scroll the body and the left column
+ $(that.dom.grid.right.liner)
+ .on( 'mouseover.DTFC touchstart.DTFC', function () {
+ if ( ! mouseDown ) {
+ mouseController = 'right';
+ }
+ } )
+ .on( 'scroll.DTFC', function ( e ) {
+ if ( ! mouseController && e.originalEvent ) {
+ mouseController = 'right';
+ }
+
+ if ( mouseController === 'right' ) {
+ that.dom.scroller.scrollTop = that.dom.grid.right.liner.scrollTop;
+ if ( that.s.iLeftColumns > 0 ) {
+ that.dom.grid.left.liner.scrollTop = that.dom.grid.right.liner.scrollTop;
+ }
+ }
+ } )
+ .on( wheelType, function(e) {
+ // Pass horizontal scrolling through
+ var xDelta = e.type === 'wheel' ?
+ -e.originalEvent.deltaX :
+ e.originalEvent.wheelDeltaX;
+ that.dom.scroller.scrollLeft -= xDelta;
+ } );
+ }
+
+ $(window).on( 'resize.DTFC', function () {
+ that._fnGridLayout.call( that );
+ } );
+
+ var bFirstDraw = true;
+ var jqTable = $(this.s.dt.nTable);
+
+ jqTable
+ .on( 'draw.dt.DTFC', function () {
+ that._fnColCalc();
+ that._fnDraw.call( that, bFirstDraw );
+ bFirstDraw = false;
+ } )
+ .on( 'column-sizing.dt.DTFC', function () {
+ that._fnColCalc();
+ that._fnGridLayout( that );
+ } )
+ .on( 'column-visibility.dt.DTFC', function ( e, settings, column, vis, recalc ) {
+ if ( recalc === undefined || recalc ) {
+ that._fnColCalc();
+ that._fnGridLayout( that );
+ that._fnDraw( true );
+ }
+ } )
+ .on( 'select.dt.DTFC deselect.dt.DTFC', function ( e, dt, type, indexes ) {
+ if ( e.namespace === 'dt' ) {
+ that._fnDraw( false );
+ }
+ } )
+ .on( 'destroy.dt.DTFC', function () {
+ jqTable.off( '.DTFC' );
+
+ $(that.dom.scroller).off( '.DTFC' );
+ $(window).off( '.DTFC' );
+ $(that.s.dt.nTableWrapper).off( '.DTFC' );
+
+ $(that.dom.grid.left.liner).off( '.DTFC '+wheelType );
+ $(that.dom.grid.left.wrapper).remove();
+
+ $(that.dom.grid.right.liner).off( '.DTFC '+wheelType );
+ $(that.dom.grid.right.wrapper).remove();
+ } );
+
+ /* Get things right to start with - note that due to adjusting the columns, there must be
+ * another redraw of the main table. It doesn't need to be a full redraw however.
+ */
+ this._fnGridLayout();
+ this.s.dt.oInstance.fnDraw(false);
+ },
+
+
+ /**
+ * Calculate the column widths for the grid layout
+ * @returns {void}
+ * @private
+ */
+ "_fnColCalc": function ()
+ {
+ var that = this;
+ var iLeftWidth = 0;
+ var iRightWidth = 0;
+
+ this.s.aiInnerWidths = [];
+ this.s.aiOuterWidths = [];
+
+ $.each( this.s.dt.aoColumns, function (i, col) {
+ var th = $(col.nTh);
+ var border;
+
+ if ( ! th.filter(':visible').length ) {
+ that.s.aiInnerWidths.push( 0 );
+ that.s.aiOuterWidths.push( 0 );
+ }
+ else
+ {
+ // Inner width is used to assign widths to cells
+ // Outer width is used to calculate the container
+ var iWidth = th.outerWidth();
+
+ // When working with the left most-cell, need to add on the
+ // table's border to the outerWidth, since we need to take
+ // account of it, but it isn't in any cell
+ if ( that.s.aiOuterWidths.length === 0 ) {
+ border = $(that.s.dt.nTable).css('border-left-width');
+ iWidth += typeof border === 'string' && border.indexOf('px') === -1 ?
+ 1 :
+ parseInt( border, 10 );
+ }
+
+ // Likewise with the final column on the right
+ if ( that.s.aiOuterWidths.length === that.s.dt.aoColumns.length-1 ) {
+ border = $(that.s.dt.nTable).css('border-right-width');
+ iWidth += typeof border === 'string' && border.indexOf('px') === -1 ?
+ 1 :
+ parseInt( border, 10 );
+ }
+
+ that.s.aiOuterWidths.push( iWidth );
+ that.s.aiInnerWidths.push( th.width() );
+
+ if ( i < that.s.iLeftColumns )
+ {
+ iLeftWidth += iWidth;
+ }
+
+ if ( that.s.iTableColumns-that.s.iRightColumns <= i )
+ {
+ iRightWidth += iWidth;
+ }
+ }
+ } );
+
+ this.s.iLeftWidth = iLeftWidth;
+ this.s.iRightWidth = iRightWidth;
+ },
+
+
+ /**
+ * Set up the DOM for the fixed column. The way the layout works is to create a 1x3 grid
+ * for the left column, the DataTable (for which we just reuse the scrolling element DataTable
+ * puts into the DOM) and the right column. In each of he two fixed column elements there is a
+ * grouping wrapper element and then a head, body and footer wrapper. In each of these we then
+ * place the cloned header, body or footer tables. This effectively gives as 3x3 grid structure.
+ * @returns {void}
+ * @private
+ */
+ "_fnGridSetup": function ()
+ {
+ var that = this;
+ var oOverflow = this._fnDTOverflow();
+ var block;
+
+ this.dom.body = this.s.dt.nTable;
+ this.dom.header = this.s.dt.nTHead.parentNode;
+ this.dom.header.parentNode.parentNode.style.position = "relative";
+
+ var nSWrapper =
+ $('')[0];
+ var nLeft = nSWrapper.childNodes[0];
+ var nRight = nSWrapper.childNodes[1];
+
+ this.dom.grid.dt.parentNode.insertBefore( nSWrapper, this.dom.grid.dt );
+ nSWrapper.appendChild( this.dom.grid.dt );
+
+ this.dom.grid.wrapper = nSWrapper;
+
+ if ( this.s.iLeftColumns > 0 )
+ {
+ this.dom.grid.left.wrapper = nLeft;
+ this.dom.grid.left.head = nLeft.childNodes[0];
+ this.dom.grid.left.body = nLeft.childNodes[1];
+ this.dom.grid.left.liner = $('div.DTFC_LeftBodyLiner', nSWrapper)[0];
+
+ nSWrapper.appendChild( nLeft );
+ }
+
+ if ( this.s.iRightColumns > 0 )
+ {
+ this.dom.grid.right.wrapper = nRight;
+ this.dom.grid.right.head = nRight.childNodes[0];
+ this.dom.grid.right.body = nRight.childNodes[1];
+ this.dom.grid.right.liner = $('div.DTFC_RightBodyLiner', nSWrapper)[0];
+
+ nRight.style.right = oOverflow.bar+"px";
+
+ block = $('div.DTFC_RightHeadBlocker', nSWrapper)[0];
+ block.style.width = oOverflow.bar+"px";
+ block.style.right = -oOverflow.bar+"px";
+ this.dom.grid.right.headBlock = block;
+
+ block = $('div.DTFC_RightFootBlocker', nSWrapper)[0];
+ block.style.width = oOverflow.bar+"px";
+ block.style.right = -oOverflow.bar+"px";
+ this.dom.grid.right.footBlock = block;
+
+ nSWrapper.appendChild( nRight );
+ }
+
+ if ( this.s.dt.nTFoot )
+ {
+ this.dom.footer = this.s.dt.nTFoot.parentNode;
+ if ( this.s.iLeftColumns > 0 )
+ {
+ this.dom.grid.left.foot = nLeft.childNodes[2];
+ }
+ if ( this.s.iRightColumns > 0 )
+ {
+ this.dom.grid.right.foot = nRight.childNodes[2];
+ }
+ }
+
+ // RTL support - swap the position of the left and right columns (#48)
+ if ( this.s.rtl ) {
+ $('div.DTFC_RightHeadBlocker', nSWrapper).css( {
+ left: -oOverflow.bar+'px',
+ right: ''
+ } );
+ }
+ },
+
+
+ /**
+ * Style and position the grid used for the FixedColumns layout
+ * @returns {void}
+ * @private
+ */
+ "_fnGridLayout": function ()
+ {
+ var that = this;
+ var oGrid = this.dom.grid;
+ var iWidth = $(oGrid.wrapper).width();
+ var iBodyHeight = this.s.dt.nTable.parentNode.offsetHeight;
+ var iFullHeight = this.s.dt.nTable.parentNode.parentNode.offsetHeight;
+ var oOverflow = this._fnDTOverflow();
+ var iLeftWidth = this.s.iLeftWidth;
+ var iRightWidth = this.s.iRightWidth;
+ var rtl = $(this.dom.body).css('direction') === 'rtl';
+ var wrapper;
+ var scrollbarAdjust = function ( node, width ) {
+ if ( ! oOverflow.bar ) {
+ // If there is no scrollbar (Macs) we need to hide the auto scrollbar
+ node.style.width = (width+20)+"px";
+ node.style.paddingRight = "20px";
+ node.style.boxSizing = "border-box";
+ }
+ else if ( that._firefoxScrollError() ) {
+ // See the above function for why this is required
+ if ( $(node).height() > 34 ) {
+ node.style.width = (width+oOverflow.bar)+"px";
+ }
+ }
+ else {
+ // Otherwise just overflow by the scrollbar
+ node.style.width = (width+oOverflow.bar)+"px";
+ }
+ };
+
+ // When x scrolling - don't paint the fixed columns over the x scrollbar
+ if ( oOverflow.x )
+ {
+ iBodyHeight -= oOverflow.bar;
+ }
+
+ oGrid.wrapper.style.height = iFullHeight+"px";
+
+ if ( this.s.iLeftColumns > 0 )
+ {
+ wrapper = oGrid.left.wrapper;
+ wrapper.style.width = iLeftWidth+'px';
+ wrapper.style.height = '1px';
+
+ // Swap the position of the left and right columns for rtl (#48)
+ // This is always up against the edge, scrollbar on the far side
+ if ( rtl ) {
+ wrapper.style.left = '';
+ wrapper.style.right = 0;
+ }
+ else {
+ wrapper.style.left = 0;
+ wrapper.style.right = '';
+ }
+
+ oGrid.left.body.style.height = iBodyHeight+"px";
+ if ( oGrid.left.foot ) {
+ oGrid.left.foot.style.top = (oOverflow.x ? oOverflow.bar : 0)+"px"; // shift footer for scrollbar
+ }
+
+ scrollbarAdjust( oGrid.left.liner, iLeftWidth );
+ oGrid.left.liner.style.height = iBodyHeight+"px";
+ oGrid.left.liner.style.maxHeight = iBodyHeight+"px";
+ }
+
+ if ( this.s.iRightColumns > 0 )
+ {
+ wrapper = oGrid.right.wrapper;
+ wrapper.style.width = iRightWidth+'px';
+ wrapper.style.height = '1px';
+
+ // Need to take account of the vertical scrollbar
+ if ( this.s.rtl ) {
+ wrapper.style.left = oOverflow.y ? oOverflow.bar+'px' : 0;
+ wrapper.style.right = '';
+ }
+ else {
+ wrapper.style.left = '';
+ wrapper.style.right = oOverflow.y ? oOverflow.bar+'px' : 0;
+ }
+
+ oGrid.right.body.style.height = iBodyHeight+"px";
+ if ( oGrid.right.foot ) {
+ oGrid.right.foot.style.top = (oOverflow.x ? oOverflow.bar : 0)+"px";
+ }
+
+ scrollbarAdjust( oGrid.right.liner, iRightWidth );
+ oGrid.right.liner.style.height = iBodyHeight+"px";
+ oGrid.right.liner.style.maxHeight = iBodyHeight+"px";
+
+ oGrid.right.headBlock.style.display = oOverflow.y ? 'block' : 'none';
+ oGrid.right.footBlock.style.display = oOverflow.y ? 'block' : 'none';
+ }
+ },
+
+
+ /**
+ * Get information about the DataTable's scrolling state - specifically if the table is scrolling
+ * on either the x or y axis, and also the scrollbar width.
+ * @returns {object} Information about the DataTables scrolling state with the properties:
+ * 'x', 'y' and 'bar'
+ * @private
+ */
+ "_fnDTOverflow": function ()
+ {
+ var nTable = this.s.dt.nTable;
+ var nTableScrollBody = nTable.parentNode;
+ var out = {
+ "x": false,
+ "y": false,
+ "bar": this.s.dt.oScroll.iBarWidth
+ };
+
+ if ( nTable.offsetWidth > nTableScrollBody.clientWidth )
+ {
+ out.x = true;
+ }
+
+ if ( nTable.offsetHeight > nTableScrollBody.clientHeight )
+ {
+ out.y = true;
+ }
+
+ return out;
+ },
+
+
+ /**
+ * Clone and position the fixed columns
+ * @returns {void}
+ * @param {Boolean} bAll Indicate if the header and footer should be updated as well (true)
+ * @private
+ */
+ "_fnDraw": function ( bAll )
+ {
+ this._fnGridLayout();
+ this._fnCloneLeft( bAll );
+ this._fnCloneRight( bAll );
+
+ /* Draw callback function */
+ if ( this.s.fnDrawCallback !== null )
+ {
+ this.s.fnDrawCallback.call( this, this.dom.clone.left, this.dom.clone.right );
+ }
+
+ /* Event triggering */
+ $(this).trigger( 'draw.dtfc', {
+ "leftClone": this.dom.clone.left,
+ "rightClone": this.dom.clone.right
+ } );
+ },
+
+
+ /**
+ * Clone the right columns
+ * @returns {void}
+ * @param {Boolean} bAll Indicate if the header and footer should be updated as well (true)
+ * @private
+ */
+ "_fnCloneRight": function ( bAll )
+ {
+ if ( this.s.iRightColumns <= 0 ) {
+ return;
+ }
+
+ var that = this,
+ i, jq,
+ aiColumns = [];
+
+ for ( i=this.s.iTableColumns-this.s.iRightColumns ; ithead', oClone.header);
+ jqCloneThead.empty();
+
+ /* Add the created cloned TR elements to the table */
+ for ( i=0, iLen=aoCloneLayout.length ; ithead', oClone.header)[0] );
+
+ for ( i=0, iLen=aoCloneLayout.length ; itbody>tr', that.dom.body).css('height', 'auto');
+ }
+
+ if ( oClone.body !== null )
+ {
+ $(oClone.body).remove();
+ oClone.body = null;
+ }
+
+ oClone.body = $(this.dom.body).clone(true)[0];
+ oClone.body.className += " DTFC_Cloned";
+ oClone.body.style.paddingBottom = dt.oScroll.iBarWidth+"px";
+ oClone.body.style.marginBottom = (dt.oScroll.iBarWidth*2)+"px"; /* For IE */
+ if ( oClone.body.getAttribute('id') !== null )
+ {
+ oClone.body.removeAttribute('id');
+ }
+
+ $('>thead>tr', oClone.body).empty();
+ $('>tfoot', oClone.body).remove();
+
+ var nBody = $('tbody', oClone.body)[0];
+ $(nBody).empty();
+ if ( dt.aiDisplay.length > 0 )
+ {
+ /* Copy the DataTables' header elements to force the column width in exactly the
+ * same way that DataTables does it - have the header element, apply the width and
+ * colapse it down
+ */
+ var nInnerThead = $('>thead>tr', oClone.body)[0];
+ for ( iIndex=0 ; iIndextbody>tr', that.dom.body).each( function (z) {
+ var i = that.s.dt.oFeatures.bServerSide===false ?
+ that.s.dt.aiDisplay[ that.s.dt._iDisplayStart+z ] : z;
+ var aTds = that.s.dt.aoData[ i ].anCells || $(this).children('td, th');
+
+ var n = this.cloneNode(false);
+ n.removeAttribute('id');
+ n.setAttribute( 'data-dt-row', i );
+
+ for ( iIndex=0 ; iIndex 0 )
+ {
+ nClone = $( aTds[iColumn] ).clone(true, true)[0];
+ nClone.removeAttribute( 'id' );
+ nClone.setAttribute( 'data-dt-row', i );
+ nClone.setAttribute( 'data-dt-column', iColumn );
+ n.appendChild( nClone );
+ }
+ }
+ nBody.appendChild( n );
+ } );
+ }
+ else
+ {
+ $('>tbody>tr', that.dom.body).each( function (z) {
+ nClone = this.cloneNode(true);
+ nClone.className += ' DTFC_NoData';
+ $('td', nClone).html('');
+ nBody.appendChild( nClone );
+ } );
+ }
+
+ oClone.body.style.width = "100%";
+ oClone.body.style.margin = "0";
+ oClone.body.style.padding = "0";
+
+ // Interop with Scroller - need to use a height forcing element in the
+ // scrolling area in the same way that Scroller does in the body scroll.
+ if ( dt.oScroller !== undefined )
+ {
+ var scrollerForcer = dt.oScroller.dom.force;
+
+ if ( ! oGrid.forcer ) {
+ oGrid.forcer = scrollerForcer.cloneNode( true );
+ oGrid.liner.appendChild( oGrid.forcer );
+ }
+ else {
+ oGrid.forcer.style.height = scrollerForcer.style.height;
+ }
+ }
+
+ oGrid.liner.appendChild( oClone.body );
+
+ this._fnEqualiseHeights( 'tbody', that.dom.body, oClone.body );
+
+ /*
+ * Footer
+ */
+ if ( dt.nTFoot !== null )
+ {
+ if ( bAll )
+ {
+ if ( oClone.footer !== null )
+ {
+ oClone.footer.parentNode.removeChild( oClone.footer );
+ }
+ oClone.footer = $(this.dom.footer).clone(true, true)[0];
+ oClone.footer.className += " DTFC_Cloned";
+ oClone.footer.style.width = "100%";
+ oGrid.foot.appendChild( oClone.footer );
+
+ /* Copy the footer just like we do for the header */
+ aoCloneLayout = this._fnCopyLayout( dt.aoFooter, aiColumns, true );
+ var jqCloneTfoot = $('>tfoot', oClone.footer);
+ jqCloneTfoot.empty();
+
+ for ( i=0, iLen=aoCloneLayout.length ; itfoot', oClone.footer)[0] );
+
+ for ( i=0, iLen=aoCloneLayout.length ; ithead', oClone.header)[0] );
+ $(anUnique).each( function (i) {
+ iColumn = aiColumns[i];
+ this.style.width = that.s.aiInnerWidths[iColumn]+"px";
+ } );
+
+ if ( that.s.dt.nTFoot !== null )
+ {
+ anUnique = dt.oApi._fnGetUniqueThs( dt, $('>tfoot', oClone.footer)[0] );
+ $(anUnique).each( function (i) {
+ iColumn = aiColumns[i];
+ this.style.width = that.s.aiInnerWidths[iColumn]+"px";
+ } );
+ }
+ },
+
+
+ /**
+ * From a given table node (THEAD etc), get a list of TR direct child elements
+ * @param {Node} nIn Table element to search for TR elements (THEAD, TBODY or TFOOT element)
+ * @returns {Array} List of TR elements found
+ * @private
+ */
+ "_fnGetTrNodes": function ( nIn )
+ {
+ var aOut = [];
+ for ( var i=0, iLen=nIn.childNodes.length ; i'+nodeName+'>tr:eq(0)', original).children(':first'),
+ iBoxHack = jqBoxHack.outerHeight() - jqBoxHack.height(),
+ anOriginal = this._fnGetTrNodes( rootOriginal ),
+ anClone = this._fnGetTrNodes( rootClone ),
+ heights = [];
+
+ for ( i=0, iLen=anClone.length ; i iHeightOriginal ? iHeightClone : iHeightOriginal;
+
+ if ( this.s.sHeightMatch == 'semiauto' )
+ {
+ anOriginal[i]._DTTC_iHeight = iHeight;
+ }
+
+ heights.push( iHeight );
+ }
+
+ for ( i=0, iLen=anClone.length ; i')
+ .css( {
+ position: 'absolute',
+ top: 0,
+ left: 0,
+ height: 10,
+ width: 50,
+ overflow: 'scroll'
+ } )
+ .appendTo( 'body' );
+
+ // Make sure this doesn't apply on Macs with 0 width scrollbars
+ _firefoxScroll = (
+ test[0].clientWidth === test[0].offsetWidth && this._fnDTOverflow().bar !== 0
+ );
+
+ test.remove();
+ }
+
+ return _firefoxScroll;
+ }
+} );
+
+
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Statics
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/**
+ * FixedColumns default settings for initialisation
+ * @name FixedColumns.defaults
+ * @namespace
+ * @static
+ */
+FixedColumns.defaults = /** @lends FixedColumns.defaults */{
+ /**
+ * Number of left hand columns to fix in position
+ * @type int
+ * @default 1
+ * @static
+ * @example
+ * var = $('#example').dataTable( {
+ * "scrollX": "100%"
+ * } );
+ * new $.fn.dataTable.fixedColumns( table, {
+ * "leftColumns": 2
+ * } );
+ */
+ "iLeftColumns": 1,
+
+ /**
+ * Number of right hand columns to fix in position
+ * @type int
+ * @default 0
+ * @static
+ * @example
+ * var table = $('#example').dataTable( {
+ * "scrollX": "100%"
+ * } );
+ * new $.fn.dataTable.fixedColumns( table, {
+ * "rightColumns": 1
+ * } );
+ */
+ "iRightColumns": 0,
+
+ /**
+ * Draw callback function which is called when FixedColumns has redrawn the fixed assets
+ * @type function(object, object):void
+ * @default null
+ * @static
+ * @example
+ * var table = $('#example').dataTable( {
+ * "scrollX": "100%"
+ * } );
+ * new $.fn.dataTable.fixedColumns( table, {
+ * "drawCallback": function () {
+ * alert( "FixedColumns redraw" );
+ * }
+ * } );
+ */
+ "fnDrawCallback": null,
+
+ /**
+ * Height matching algorthim to use. This can be "none" which will result in no height
+ * matching being applied by FixedColumns (height matching could be forced by CSS in this
+ * case), "semiauto" whereby the height calculation will be performed once, and the result
+ * cached to be used again (fnRecalculateHeight can be used to force recalculation), or
+ * "auto" when height matching is performed on every draw (slowest but must accurate)
+ * @type string
+ * @default semiauto
+ * @static
+ * @example
+ * var table = $('#example').dataTable( {
+ * "scrollX": "100%"
+ * } );
+ * new $.fn.dataTable.fixedColumns( table, {
+ * "heightMatch": "auto"
+ * } );
+ */
+ "sHeightMatch": "semiauto"
+};
+
+
+
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Constants
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/**
+ * FixedColumns version
+ * @name FixedColumns.version
+ * @type String
+ * @default See code
+ * @static
+ */
+FixedColumns.version = "3.2.6";
+
+
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * DataTables API integration
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+DataTable.Api.register( 'fixedColumns()', function () {
+ return this;
+} );
+
+DataTable.Api.register( 'fixedColumns().update()', function () {
+ return this.iterator( 'table', function ( ctx ) {
+ if ( ctx._oFixedColumns ) {
+ ctx._oFixedColumns.fnUpdate();
+ }
+ } );
+} );
+
+DataTable.Api.register( 'fixedColumns().relayout()', function () {
+ return this.iterator( 'table', function ( ctx ) {
+ if ( ctx._oFixedColumns ) {
+ ctx._oFixedColumns.fnRedrawLayout();
+ }
+ } );
+} );
+
+DataTable.Api.register( 'rows().recalcHeight()', function () {
+ return this.iterator( 'row', function ( ctx, idx ) {
+ if ( ctx._oFixedColumns ) {
+ ctx._oFixedColumns.fnRecalculateHeight( this.row(idx).node() );
+ }
+ } );
+} );
+
+DataTable.Api.register( 'fixedColumns().rowIndex()', function ( row ) {
+ row = $(row);
+
+ return row.parents('.DTFC_Cloned').length ?
+ this.rows( { page: 'current' } ).indexes()[ row.index() ] :
+ this.row( row ).index();
+} );
+
+DataTable.Api.register( 'fixedColumns().cellIndex()', function ( cell ) {
+ cell = $(cell);
+
+ if ( cell.parents('.DTFC_Cloned').length ) {
+ var rowClonedIdx = cell.parent().index();
+ var rowIdx = this.rows( { page: 'current' } ).indexes()[ rowClonedIdx ];
+ var columnIdx;
+
+ if ( cell.parents('.DTFC_LeftWrapper').length ) {
+ columnIdx = cell.index();
+ }
+ else {
+ var columns = this.columns().flatten().length;
+ columnIdx = columns - this.context[0]._oFixedColumns.s.iRightColumns + cell.index();
+ }
+
+ return {
+ row: rowIdx,
+ column: this.column.index( 'toData', columnIdx ),
+ columnVisible: columnIdx
+ };
+ }
+ else {
+ return this.cell( cell ).index();
+ }
+} );
+
+
+
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Initialisation
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+// Attach a listener to the document which listens for DataTables initialisation
+// events so we can automatically initialise
+$(document).on( 'init.dt.fixedColumns', function (e, settings) {
+ if ( e.namespace !== 'dt' ) {
+ return;
+ }
+
+ var init = settings.oInit.fixedColumns;
+ var defaults = DataTable.defaults.fixedColumns;
+
+ if ( init || defaults ) {
+ var opts = $.extend( {}, init, defaults );
+
+ if ( init !== false ) {
+ new FixedColumns( settings, opts );
+ }
+ }
+} );
+
+
+
+// Make FixedColumns accessible from the DataTables instance
+$.fn.dataTable.FixedColumns = FixedColumns;
+$.fn.DataTable.FixedColumns = FixedColumns;
+
+return FixedColumns;
+}));
diff --git a/BackEnd/assets/vendor/datatables/extensions/fixedcolumns/dataTables.fixedColumns.min.js b/BackEnd/assets/vendor/datatables/extensions/fixedcolumns/dataTables.fixedColumns.min.js
new file mode 100644
index 0000000..18d839a
--- /dev/null
+++ b/BackEnd/assets/vendor/datatables/extensions/fixedcolumns/dataTables.fixedColumns.min.js
@@ -0,0 +1,35 @@
+/*!
+ FixedColumns 3.2.6
+ ©2010-2018 SpryMedia Ltd - datatables.net/license
+*/
+(function(d){"function"===typeof define&&define.amd?define(["jquery","datatables.net"],function(p){return d(p,window,document)}):"object"===typeof exports?module.exports=function(p,r){p||(p=window);if(!r||!r.fn.dataTable)r=require("datatables.net")(p,r).$;return d(r,p,p.document)}:d(jQuery,window,document)})(function(d,p,r,t){var s=d.fn.dataTable,u,m=function(a,b){var c=this;if(this instanceof m){if(b===t||!0===b)b={};var e=d.fn.dataTable.camelToHungarian;e&&(e(m.defaults,m.defaults,!0),e(m.defaults,
+b));e=(new d.fn.dataTable.Api(a)).settings()[0];this.s={dt:e,iTableColumns:e.aoColumns.length,aiOuterWidths:[],aiInnerWidths:[],rtl:"rtl"===d(e.nTable).css("direction")};this.dom={scroller:null,header:null,body:null,footer:null,grid:{wrapper:null,dt:null,left:{wrapper:null,head:null,body:null,foot:null},right:{wrapper:null,head:null,body:null,foot:null}},clone:{left:{header:null,body:null,footer:null},right:{header:null,body:null,footer:null}}};if(e._oFixedColumns)throw"FixedColumns already initialised on this table";
+e._oFixedColumns=this;e._bInitComplete?this._fnConstruct(b):e.oApi._fnCallbackReg(e,"aoInitComplete",function(){c._fnConstruct(b)},"FixedColumns")}else alert("FixedColumns warning: FixedColumns must be initialised with the 'new' keyword.")};d.extend(m.prototype,{fnUpdate:function(){this._fnDraw(!0)},fnRedrawLayout:function(){this._fnColCalc();this._fnGridLayout();this.fnUpdate()},fnRecalculateHeight:function(a){delete a._DTTC_iHeight;a.style.height="auto"},fnSetRowHeight:function(a,b){a.style.height=
+b+"px"},fnGetPosition:function(a){var b=this.s.dt.oInstance;if(d(a).parents(".DTFC_Cloned").length){if("tr"===a.nodeName.toLowerCase())return a=d(a).index(),b.fnGetPosition(d("tr",this.s.dt.nTBody)[a]);var c=d(a).index(),a=d(a.parentNode).index();return[b.fnGetPosition(d("tr",this.s.dt.nTBody)[a]),c,b.oApi._fnVisibleToColumnIndex(this.s.dt,c)]}return b.fnGetPosition(a)},_fnConstruct:function(a){var b=this;if("function"!=typeof this.s.dt.oInstance.fnVersionCheck||!0!==this.s.dt.oInstance.fnVersionCheck("1.8.0"))alert("FixedColumns "+
+m.VERSION+" required DataTables 1.8.0 or later. Please upgrade your DataTables installation");else if(""===this.s.dt.oScroll.sX)this.s.dt.oInstance.oApi._fnLog(this.s.dt,1,"FixedColumns is not needed (no x-scrolling in DataTables enabled), so no action will be taken. Use 'FixedHeader' for column fixing when scrolling is not enabled");else{this.s=d.extend(!0,this.s,m.defaults,a);a=this.s.dt.oClasses;this.dom.grid.dt=d(this.s.dt.nTable).parents("div."+a.sScrollWrapper)[0];this.dom.scroller=d("div."+
+a.sScrollBody,this.dom.grid.dt)[0];this._fnColCalc();this._fnGridSetup();var c,e=!1;d(this.s.dt.nTableWrapper).on("mousedown.DTFC",function(a){0===a.button&&(e=!0,d(r).one("mouseup",function(){e=!1}))});d(this.dom.scroller).on("mouseover.DTFC touchstart.DTFC",function(){e||(c="main")}).on("scroll.DTFC",function(a){!c&&a.originalEvent&&(c="main");if("main"===c&&(0