PHP Classes

File: assets/plugins/datatables/extensions/AutoFill/js/dataTables.autoFill.js

Recommend this page to a friend!
  Classes of Kishor Mali   PHP Hotel Booking System   assets/plugins/datatables/extensions/AutoFill/js/dataTables.autoFill.js   Download  
File: assets/plugins/datatables/extensions/AutoFill/js/dataTables.autoFill.js
Role: Auxiliary data
Content type: text/plain
Description: Auxiliary data
Class: PHP Hotel Booking System
Manage the booking of hotel rooms for customers
Author: By
Last change:
Date: 5 months ago
Size: 22,645 bytes
 

Contents

Class file image Download
/*! AutoFill 1.2.1 * ©2008-2014 SpryMedia Ltd - datatables.net/license */ /** * @summary AutoFill * @description Add Excel like click and drag auto-fill options to DataTables * @version 1.2.1 * @file dataTables.autoFill.js * @author SpryMedia Ltd (www.sprymedia.co.uk) * @contact www.sprymedia.co.uk/contact * @copyright Copyright 2010-2014 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( window, document, undefined ) { var factory = function( $, DataTable ) { "use strict"; /** * AutoFill provides Excel like auto-fill features for a DataTable * * @class AutoFill * @constructor * @param {object} oTD DataTables settings object * @param {object} oConfig Configuration object for AutoFill */ var AutoFill = function( oDT, oConfig ) { /* Sanity check that we are a new instance */ if ( ! (this instanceof AutoFill) ) { throw( "Warning: AutoFill must be initialised with the keyword 'new'" ); } if ( ! $.fn.dataTableExt.fnVersionCheck('1.7.0') ) { throw( "Warning: AutoFill requires DataTables 1.7 or greater"); } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Public class variables * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ this.c = {}; /** * @namespace Settings object which contains customisable information for AutoFill instance */ this.s = { /** * @namespace Cached information about the little dragging icon (the filler) */ "filler": { "height": 0, "width": 0 }, /** * @namespace Cached information about the border display */ "border": { "width": 2 }, /** * @namespace Store for live information for the current drag */ "drag": { "startX": -1, "startY": -1, "startTd": null, "endTd": null, "dragging": false }, /** * @namespace Data cache for information that we need for scrolling the screen when we near * the edges */ "screen": { "interval": null, "y": 0, "height": 0, "scrollTop": 0 }, /** * @namespace Data cache for the position of the DataTables scrolling element (when scrolling * is enabled) */ "scroller": { "top": 0, "bottom": 0 }, /** * @namespace Information stored for each column. An array of objects */ "columns": [] }; /** * @namespace Common and useful DOM elements for the class instance */ this.dom = { "table": null, "filler": null, "borderTop": null, "borderRight": null, "borderBottom": null, "borderLeft": null, "currentTarget": null }; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Public class methods * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /** * Retreieve the settings object from an instance * @method fnSettings * @returns {object} AutoFill settings object */ this.fnSettings = function () { return this.s; }; /* Constructor logic */ this._fnInit( oDT, oConfig ); return this; }; AutoFill.prototype = { /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Private methods (they are of course public in JS, but recommended as private) * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /** * Initialisation * @method _fnInit * @param {object} dt DataTables settings object * @param {object} config Configuration object for AutoFill * @returns void */ "_fnInit": function ( dt, config ) { var that = this, i, iLen; // Use DataTables API to get the settings allowing selectors, instances // etc to be used, or for backwards compatibility get from the old // fnSettings method this.s.dt = DataTable.Api ? new DataTable.Api( dt ).settings()[0] : dt.fnSettings(); this.s.init = config || {}; this.dom.table = this.s.dt.nTable; $.extend( true, this.c, AutoFill.defaults, config ); /* Add and configure the columns */ this._initColumns(); /* Auto Fill click and drag icon */ var filler = $('<div/>', { 'class': 'AutoFill_filler' } ) .appendTo( 'body' ); this.dom.filler = filler[0]; // Get the height / width of the click element this.s.filler.height = filler.height(); this.s.filler.width = filler.width(); filler[0].style.display = "none"; /* Border display - one div for each side. We can't just use a single * one with a border, as we want the events to effectively pass through * the transparent bit of the box */ var border; var appender = document.body; if ( that.s.dt.oScroll.sY !== "" ) { that.s.dt.nTable.parentNode.style.position = "relative"; appender = that.s.dt.nTable.parentNode; } border = $('<div/>', { "class": "AutoFill_border" } ); this.dom.borderTop = border.clone().appendTo( appender )[0]; this.dom.borderRight = border.clone().appendTo( appender )[0]; this.dom.borderBottom = border.clone().appendTo( appender )[0]; this.dom.borderLeft = border.clone().appendTo( appender )[0]; /* Events */ filler.on( 'mousedown.DTAF', function (e) { this.onselectstart = function() { return false; }; that._fnFillerDragStart.call( that, e ); return false; } ); $('tbody', this.dom.table).on( 'mouseover.DTAF mouseout.DTAF', '>tr>td, >tr>th', function (e) { that._fnFillerDisplay.call( that, e ); } ); $(this.dom.table).on( 'destroy.dt.DTAF', function () { filler.off( 'mousedown.DTAF' ).remove(); $('tbody', this.dom.table).off( 'mouseover.DTAF mouseout.DTAF' ); } ); }, _initColumns: function ( ) { var that = this; var i, ien; var dt = this.s.dt; var config = this.s.init; for ( i=0, ien=dt.aoColumns.length ; i<ien ; i++ ) { this.s.columns[i] = $.extend( true, {}, AutoFill.defaults.column ); } dt.oApi._fnApplyColumnDefs( dt, config.aoColumnDefs || config.columnDefs, config.aoColumns || config.columns, function (colIdx, def) { that._fnColumnOptions( colIdx, def ); } ); // For columns which don't have read, write, step functions defined, // use the default ones for ( i=0, ien=dt.aoColumns.length ; i<ien ; i++ ) { var column = this.s.columns[i]; if ( ! column.read ) { column.read = this._fnReadCell; } if ( ! column.write ) { column.read = this._fnWriteCell; } if ( ! column.step ) { column.read = this._fnStep; } } }, "_fnColumnOptions": function ( i, opts ) { var column = this.s.columns[ i ]; var set = function ( outProp, inProp ) { if ( opts[ inProp[0] ] !== undefined ) { column[ outProp ] = opts[ inProp[0] ]; } if ( opts[ inProp[1] ] !== undefined ) { column[ outProp ] = opts[ inProp[1] ]; } }; // Compatibility with the old Hungarian style of notation set( 'enable', ['bEnable', 'enable'] ); set( 'read', ['fnRead', 'read'] ); set( 'write', ['fnWrite', 'write'] ); set( 'step', ['fnStep', 'step'] ); set( 'increment', ['bIncrement', 'increment'] ); }, /** * Find out the coordinates of a given TD cell in a table * @method _fnTargetCoords * @param {Node} nTd * @returns {Object} x and y properties, for the position of the cell in the tables DOM */ "_fnTargetCoords": function ( nTd ) { var nTr = $(nTd).parents('tr')[0]; var position = this.s.dt.oInstance.fnGetPosition( nTd ); return { "x": $('td', nTr).index(nTd), "y": $('tr', nTr.parentNode).index(nTr), "row": position[0], "column": position[2] }; }, /** * Display the border around one or more cells (from start to end) * @method _fnUpdateBorder * @param {Node} nStart Starting cell * @param {Node} nEnd Ending cell * @returns void */ "_fnUpdateBorder": function ( nStart, nEnd ) { var border = this.s.border.width, offsetStart = $(nStart).offset(), offsetEnd = $(nEnd).offset(), x1 = offsetStart.left - border, x2 = offsetEnd.left + $(nEnd).outerWidth(), y1 = offsetStart.top - border, y2 = offsetEnd.top + $(nEnd).outerHeight(), width = offsetEnd.left + $(nEnd).outerWidth() - offsetStart.left + (2*border), height = offsetEnd.top + $(nEnd).outerHeight() - offsetStart.top + (2*border), oStyle; // Recalculate start and end (when dragging "backwards") if( offsetStart.left > offsetEnd.left) { x1 = offsetEnd.left - border; x2 = offsetStart.left + $(nStart).outerWidth(); width = offsetStart.left + $(nStart).outerWidth() - offsetEnd.left + (2*border); } if ( this.s.dt.oScroll.sY !== "" ) { /* The border elements are inside the DT scroller - so position relative to that */ var offsetScroll = $(this.s.dt.nTable.parentNode).offset(), scrollTop = $(this.s.dt.nTable.parentNode).scrollTop(), scrollLeft = $(this.s.dt.nTable.parentNode).scrollLeft(); x1 -= offsetScroll.left - scrollLeft; x2 -= offsetScroll.left - scrollLeft; y1 -= offsetScroll.top - scrollTop; y2 -= offsetScroll.top - scrollTop; } /* Top */ oStyle = this.dom.borderTop.style; oStyle.top = y1+"px"; oStyle.left = x1+"px"; oStyle.height = this.s.border.width+"px"; oStyle.width = width+"px"; /* Bottom */ oStyle = this.dom.borderBottom.style; oStyle.top = y2+"px"; oStyle.left = x1+"px"; oStyle.height = this.s.border.width+"px"; oStyle.width = width+"px"; /* Left */ oStyle = this.dom.borderLeft.style; oStyle.top = y1+"px"; oStyle.left = x1+"px"; oStyle.height = height+"px"; oStyle.width = this.s.border.width+"px"; /* Right */ oStyle = this.dom.borderRight.style; oStyle.top = y1+"px"; oStyle.left = x2+"px"; oStyle.height = height+"px"; oStyle.width = this.s.border.width+"px"; }, /** * Mouse down event handler for starting a drag * @method _fnFillerDragStart * @param {Object} e Event object * @returns void */ "_fnFillerDragStart": function (e) { var that = this; var startingTd = this.dom.currentTarget; this.s.drag.dragging = true; that.dom.borderTop.style.display = "block"; that.dom.borderRight.style.display = "block"; that.dom.borderBottom.style.display = "block"; that.dom.borderLeft.style.display = "block"; var coords = this._fnTargetCoords( startingTd ); this.s.drag.startX = coords.x; this.s.drag.startY = coords.y; this.s.drag.startTd = startingTd; this.s.drag.endTd = startingTd; this._fnUpdateBorder( startingTd, startingTd ); $(document).bind('mousemove.AutoFill', function (e) { that._fnFillerDragMove.call( that, e ); } ); $(document).bind('mouseup.AutoFill', function (e) { that._fnFillerFinish.call( that, e ); } ); /* Scrolling information cache */ this.s.screen.y = e.pageY; this.s.screen.height = $(window).height(); this.s.screen.scrollTop = $(document).scrollTop(); if ( this.s.dt.oScroll.sY !== "" ) { this.s.scroller.top = $(this.s.dt.nTable.parentNode).offset().top; this.s.scroller.bottom = this.s.scroller.top + $(this.s.dt.nTable.parentNode).height(); } /* Scrolling handler - we set an interval (which is cancelled on mouse up) which will fire * regularly and see if we need to do any scrolling */ this.s.screen.interval = setInterval( function () { var iScrollTop = $(document).scrollTop(); var iScrollDelta = iScrollTop - that.s.screen.scrollTop; that.s.screen.y += iScrollDelta; if ( that.s.screen.height - that.s.screen.y + iScrollTop < 50 ) { $('html, body').animate( { "scrollTop": iScrollTop + 50 }, 240, 'linear' ); } else if ( that.s.screen.y - iScrollTop < 50 ) { $('html, body').animate( { "scrollTop": iScrollTop - 50 }, 240, 'linear' ); } if ( that.s.dt.oScroll.sY !== "" ) { if ( that.s.screen.y > that.s.scroller.bottom - 50 ) { $(that.s.dt.nTable.parentNode).animate( { "scrollTop": $(that.s.dt.nTable.parentNode).scrollTop() + 50 }, 240, 'linear' ); } else if ( that.s.screen.y < that.s.scroller.top + 50 ) { $(that.s.dt.nTable.parentNode).animate( { "scrollTop": $(that.s.dt.nTable.parentNode).scrollTop() - 50 }, 240, 'linear' ); } } }, 250 ); }, /** * Mouse move event handler for during a move. See if we want to update the display based on the * new cursor position * @method _fnFillerDragMove * @param {Object} e Event object * @returns void */ "_fnFillerDragMove": function (e) { if ( e.target && e.target.nodeName.toUpperCase() == "TD" && e.target != this.s.drag.endTd ) { var coords = this._fnTargetCoords( e.target ); if ( this.c.mode == "y" && coords.x != this.s.drag.startX ) { e.target = $('tbody>tr:eq('+coords.y+')>td:eq('+this.s.drag.startX+')', this.dom.table)[0]; } if ( this.c.mode == "x" && coords.y != this.s.drag.startY ) { e.target = $('tbody>tr:eq('+this.s.drag.startY+')>td:eq('+coords.x+')', this.dom.table)[0]; } if ( this.c.mode == "either") { if(coords.x != this.s.drag.startX ) { e.target = $('tbody>tr:eq('+this.s.drag.startY+')>td:eq('+coords.x+')', this.dom.table)[0]; } else if ( coords.y != this.s.drag.startY ) { e.target = $('tbody>tr:eq('+coords.y+')>td:eq('+this.s.drag.startX+')', this.dom.table)[0]; } } // update coords if ( this.c.mode !== "both" ) { coords = this._fnTargetCoords( e.target ); } var drag = this.s.drag; drag.endTd = e.target; if ( coords.y >= this.s.drag.startY ) { this._fnUpdateBorder( drag.startTd, drag.endTd ); } else { this._fnUpdateBorder( drag.endTd, drag.startTd ); } this._fnFillerPosition( e.target ); } /* Update the screen information so we can perform scrolling */ this.s.screen.y = e.pageY; this.s.screen.scrollTop = $(document).scrollTop(); if ( this.s.dt.oScroll.sY !== "" ) { this.s.scroller.scrollTop = $(this.s.dt.nTable.parentNode).scrollTop(); this.s.scroller.top = $(this.s.dt.nTable.parentNode).offset().top; this.s.scroller.bottom = this.s.scroller.top + $(this.s.dt.nTable.parentNode).height(); } }, /** * Mouse release handler - end the drag and take action to update the cells with the needed values * @method _fnFillerFinish * @param {Object} e Event object * @returns void */ "_fnFillerFinish": function (e) { var that = this, i, iLen, j; $(document).unbind('mousemove.AutoFill mouseup.AutoFill'); this.dom.borderTop.style.display = "none"; this.dom.borderRight.style.display = "none"; this.dom.borderBottom.style.display = "none"; this.dom.borderLeft.style.display = "none"; this.s.drag.dragging = false; clearInterval( this.s.screen.interval ); var cells = []; var table = this.dom.table; var coordsStart = this._fnTargetCoords( this.s.drag.startTd ); var coordsEnd = this._fnTargetCoords( this.s.drag.endTd ); var columnIndex = function ( visIdx ) { return that.s.dt.oApi._fnVisibleToColumnIndex( that.s.dt, visIdx ); }; // xxx - urgh - there must be a way of reducing this... if ( coordsStart.y <= coordsEnd.y ) { for ( i=coordsStart.y ; i<=coordsEnd.y ; i++ ) { if ( coordsStart.x <= coordsEnd.x ) { for ( j=coordsStart.x ; j<=coordsEnd.x ; j++ ) { cells.push( { node: $('tbody>tr:eq('+i+')>td:eq('+j+')', table)[0], x: j - coordsStart.x, y: i - coordsStart.y, colIdx: columnIndex( j ) } ); } } else { for ( j=coordsStart.x ; j>=coordsEnd.x ; j-- ) { cells.push( { node: $('tbody>tr:eq('+i+')>td:eq('+j+')', table)[0], x: j - coordsStart.x, y: i - coordsStart.y, colIdx: columnIndex( j ) } ); } } } } else { for ( i=coordsStart.y ; i>=coordsEnd.y ; i-- ) { if ( coordsStart.x <= coordsEnd.x ) { for ( j=coordsStart.x ; j<=coordsEnd.x ; j++ ) { cells.push( { node: $('tbody>tr:eq('+i+')>td:eq('+j+')', table)[0], x: j - coordsStart.x, y: i - coordsStart.y, colIdx: columnIndex( j ) } ); } } else { for ( j=coordsStart.x ; j>=coordsEnd.x ; j-- ) { cells.push( { node: $('tbody>tr:eq('+i+')>td:eq('+j+')', table)[0], x: coordsStart.x - j, y: coordsStart.y - i, colIdx: columnIndex( j ) } ); } } } } // An auto-fill requires 2 or more cells if ( cells.length <= 1 ) { return; } var edited = []; var previous; for ( i=0, iLen=cells.length ; i<iLen ; i++ ) { var cell = cells[i]; var column = this.s.columns[ cell.colIdx ]; var read = column.read.call( column, cell.node ); var stepValue = column.step.call( column, cell.node, read, previous, i, cell.x, cell.y ); column.write.call( column, cell.node, stepValue ); previous = stepValue; edited.push( { cell: cell, colIdx: cell.colIdx, newValue: stepValue, oldValue: read } ); } if ( this.c.complete !== null ) { this.c.complete.call( this, edited ); } // In 1.10 we can do a static draw if ( DataTable.Api ) { new DataTable.Api( this.s.dt ).draw( false ); } else { this.s.dt.oInstance.fnDraw(); } }, /** * Display the drag handle on mouse over cell * @method _fnFillerDisplay * @param {Object} e Event object * @returns void */ "_fnFillerDisplay": function (e) { var filler = this.dom.filler; /* Don't display automatically when dragging */ if ( this.s.drag.dragging) { return; } /* Check that we are allowed to AutoFill this column or not */ var nTd = (e.target.nodeName.toLowerCase() == 'td') ? e.target : $(e.target).parents('td')[0]; var iX = this._fnTargetCoords(nTd).column; if ( !this.s.columns[iX].enable ) { filler.style.display = "none"; return; } if (e.type == 'mouseover') { this.dom.currentTarget = nTd; this._fnFillerPosition( nTd ); filler.style.display = "block"; } else if ( !e.relatedTarget || !e.relatedTarget.className.match(/AutoFill/) ) { filler.style.display = "none"; } }, /** * Position the filler icon over a cell * @method _fnFillerPosition * @param {Node} nTd Cell to position filler icon over * @returns void */ "_fnFillerPosition": function ( nTd ) { var offset = $(nTd).offset(); var filler = this.dom.filler; filler.style.top = (offset.top - (this.s.filler.height / 2)-1 + $(nTd).outerHeight())+"px"; filler.style.left = (offset.left - (this.s.filler.width / 2)-1 + $(nTd).outerWidth())+"px"; } }; // Alias for access DataTable.AutoFill = AutoFill; DataTable.AutoFill = AutoFill; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Constants * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /** * AutoFill version * @constant version * @type String * @default See code */ AutoFill.version = "1.2.1"; /** * AutoFill defaults * @namespace */ AutoFill.defaults = { /** * Mode for dragging (restrict to y-axis only, x-axis only, either one or none): * * * `y` - y-axis only (default) * * `x` - x-axis only * * `either` - either one, but not both axis at the same time * * `both` - multiple cells allowed * * @type {string} * @default `y` */ mode: 'y', complete: null, /** * Column definition defaults * @namespace */ column: { /** * If AutoFill should be enabled on this column * * @type {boolean} * @default true */ enable: true, /** * Allow automatic increment / decrement on this column if a number * is found. * * @type {boolean} * @default true */ increment: true, /** * Cell read function * * Default function will simply read the value from the HTML of the * cell. * * @type {function} * @param {node} cell `th` / `td` element to read the value from * @return {string} Data that has been read */ read: function ( cell ) { return $(cell).html(); }, /** * Cell write function * * Default function will simply write to the HTML and tell the DataTable * to update. * * @type {function} * @param {node} cell `th` / `td` element to write the value to * @return {string} Data two write */ write: function ( cell, val ) { var table = $(cell).parents('table'); if ( DataTable.Api ) { // 1.10 table.DataTable().cell( cell ).data( val ); } else { // 1.9 var dt = table.dataTable(); var pos = dt.fnGetPosition( cell ); dt.fnUpdate( val, pos[0], pos[2], false ); } }, /** * Step function. This provides the ability to customise how the values * are incremented. * * @param {node} cell `th` / `td` element that is being operated upon * @param {string} read Cell value from `read` function * @param {string} last Value of the previous cell * @param {integer} i Loop counter * @param {integer} x Cell x-position in the current auto-fill. The * starting cell is coordinate 0 regardless of its physical position * in the DataTable. * @param {integer} y Cell y-position in the current auto-fill. The * starting cell is coordinate 0 regardless of its physical position * in the DataTable. * @return {string} Value to write */ step: function ( cell, read, last, i, x, y ) { // Increment a number if it is found var re = /(\-?\d+)/; var match = this.increment && last ? last.match(re) : null; if ( match ) { return last.replace( re, parseInt(match[1],10) + (x<0 || y<0 ? -1 : 1) ); } return last === undefined ? read : last; } } }; return AutoFill; }; // Define as an AMD module if possible if ( typeof define === 'function' && define.amd ) { define( ['jquery', 'datatables'], factory ); } else if ( typeof exports === 'object' ) { // Node/CommonJS factory( require('jquery'), require('datatables') ); } else if ( jQuery && !jQuery.fn.dataTable.AutoFill ) { // Otherwise simply initialise as normal, stopping multiple evaluation factory( jQuery, jQuery.fn.dataTable ); } }(window, document));