Файловый менеджер

Файловый менеджер - Редактировать - /home/amitahospital/public_html/amita_master/plugins/datatables/extensions/Responsive/js/dataTables.responsive.js

Назад
/! Responsive 1.0.6 2014-2015 SpryMedia Ltd - datatables.net/license / /* * @summary Responsive * @description Responsive tables plug-in for DataTables * @version 1.0.6 * @file dataTables.responsive.js * @author SpryMedia Ltd (www.sprymedia.co.uk) * @contact www.sprymedia.co.uk/contact * @copyright Copyright 2014-2015 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"; /* * Responsive is a plug-in for the DataTables library that makes use of * DataTables' ability to change the visibility of columns, changing the * visibility of columns so the displayed columns fit into the table container. * The end result is that complex tables will be dynamically adjusted to fit * into the viewport, be it on a desktop, tablet or mobile browser. * * Responsive for DataTables has two modes of operation, which can used * individually or combined: * * * Class name based control - columns assigned class names that match the * breakpoint logic can be shown / hidden as required for each breakpoint. * * Automatic control - columns are automatically hidden when there is no * room left to display them. Columns removed from the right. * * In additional to column visibility control, Responsive also has built into * options to use DataTables' child row display to show / hide the information * from the table that has been hidden. There are also two modes of operation * for this child row display: * * * Inline - when the control element that the user can use to show / hide * child rows is displayed inside the first column of the table. * * Column - where a whole column is dedicated to be the show / hide control. * * Initialisation of Responsive is performed by: * * * Adding the class `responsive` or `dt-responsive` to the table. In this case * Responsive will automatically be initialised with the default configuration * options when the DataTable is created. * * Using the `responsive` option in the DataTables configuration options. This * can also be used to specify the configuration options, or simply set to * `true` to use the defaults. * * @class * @param {object} settings DataTables settings object for the host table * @param {object} [opts] Configuration options * @requires jQuery 1.7+ * @requires DataTables 1.10.1+ * * @example * $('#example').DataTable( { * responsive: true * } ); * } ); / var Responsive = function ( settings, opts ) { // Sanity check that we are using DataTables 1.10 or newer if ( ! DataTable.versionCheck \|\| ! DataTable.versionCheck( '1.10.1' ) ) { throw 'DataTables Responsive requires DataTables 1.10.1 or newer'; } this.s = { dt: new DataTable.Api( settings ), columns: [] }; // Check if responsive has already been initialised on this table if ( this.s.dt.settings()[0].responsive ) { return; } // details is an object, but for simplicity the user can give it as a string if ( opts && typeof opts.details === 'string' ) { opts.details = { type: opts.details }; } this.c = $.extend( true, {}, Responsive.defaults, DataTable.defaults.responsive, opts ); settings.responsive = this; this._constructor(); }; Responsive.prototype = { / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Constructor / /* * Initialise the Responsive instance * * @private / _constructor: function () { var that = this; var dt = this.s.dt; dt.settings()[0]._responsive = this; // Use DataTables' private throttle function to avoid processor thrashing $(window).on( 'resize.dtr orientationchange.dtr', dt.settings()[0].oApi._fnThrottle( function () { that._resize(); } ) ); // Destroy event handler dt.on( 'destroy.dtr', function () { $(window).off( 'resize.dtr orientationchange.dtr draw.dtr' ); } ); // Reorder the breakpoints array here in case they have been added out // of order this.c.breakpoints.sort( function (a, b) { return a.width < b.width ? 1 : a.width > b.width ? -1 : 0; } ); // Determine which columns are already hidden, and should therefore // remain hidden. todo - should this be done? See thread 22677 // // this.s.alwaysHidden = dt.columns(':hidden').indexes(); this._classLogic(); this._resizeAuto(); // Details handler var details = this.c.details; if ( details.type ) { that._detailsInit(); this._detailsVis(); dt.on( 'column-visibility.dtr', function () { that._detailsVis(); } ); // Redraw the details box on each draw. This is used until // DataTables implements a native `updated` event for rows dt.on( 'draw.dtr', function () { dt.rows( {page: 'current'} ).iterator( 'row', function ( settings, idx ) { var row = dt.row( idx ); if ( row.child.isShown() ) { var info = that.c.details.renderer( dt, idx ); row.child( info, 'child' ).show(); } } ); } ); $(dt.table().node()).addClass( 'dtr-'+details.type ); } // First pass - draw the table for the current viewport size this._resize(); }, / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Private methods / /* * Calculate the visibility for the columns in a table for a given * breakpoint. The result is pre-determined based on the class logic if * class names are used to control all columns, but the width of the table * is also used if there are columns which are to be automatically shown * and hidden. * * @param {string} breakpoint Breakpoint name to use for the calculation * @return {array} Array of boolean values initiating the visibility of each * column. * @private / _columnsVisiblity: function ( breakpoint ) { var dt = this.s.dt; var columns = this.s.columns; var i, ien; // Class logic - determine which columns are in this breakpoint based // on the classes. If no class control (i.e. `auto`) then `-` is used // to indicate this to the rest of the function var display = $.map( columns, function ( col ) { return col.auto && col.minWidth === null ? false : col.auto === true ? '-' : $.inArray( breakpoint, col.includeIn ) !== -1; } ); // Auto column control - first pass: how much width is taken by the // ones that must be included from the non-auto columns var requiredWidth = 0; for ( i=0, ien=display.length ; i<ien ; i++ ) { if ( display[i] === true ) { requiredWidth += columns[i].minWidth; } } // Second pass, use up any remaining width for other columns. For // scrolling tables we need to subtract the width of the scrollbar. It // may not be requires which makes this sub-optimal, but it would // require another full redraw to make complete use of those extra few // pixels var scrolling = dt.settings()[0].oScroll; var bar = scrolling.sY \|\| scrolling.sX ? scrolling.iBarWidth : 0; var widthAvailable = dt.table().container().offsetWidth - bar; var usedWidth = widthAvailable - requiredWidth; // Control column needs to always be included. This makes it sub- // optimal in terms of using the available with, but to stop layout // thrashing or overflow. Also we need to account for the control column // width first so we know how much width is available for the other // columns, since the control column might not be the first one shown for ( i=0, ien=display.length ; i<ien ; i++ ) { if ( columns[i].control ) { usedWidth -= columns[i].minWidth; } } // Allow columns to be shown (counting from the left) until we run out // of room var empty = false; for ( i=0, ien=display.length ; i<ien ; i++ ) { if ( display[i] === '-' && ! columns[i].control ) { // Once we've found a column that won't fit we don't let any // others display either, or columns might disappear in the // middle of the table if ( empty \|\| usedWidth - columns[i].minWidth < 0 ) { empty = true; display[i] = false; } else { display[i] = true; } usedWidth -= columns[i].minWidth; } } // Determine if the 'control' column should be shown (if there is one). // This is the case when there is a hidden column (that is not the // control column). The two loops look inefficient here, but they are // trivial and will fly through. We need to know the outcome from the // first , before the action in the second can be taken var showControl = false; for ( i=0, ien=columns.length ; i<ien ; i++ ) { if ( ! columns[i].control && ! columns[i].never && ! display[i] ) { showControl = true; break; } } for ( i=0, ien=columns.length ; i<ien ; i++ ) { if ( columns[i].control ) { display[i] = showControl; } } // Finally we need to make sure that there is at least one column that // is visible if ( $.inArray( true, display ) === -1 ) { display[0] = true; } return display; }, /* * Create the internal `columns` array with information about the columns * for the table. This includes determining which breakpoints the column * will appear in, based upon class names in the column, which makes up the * vast majority of this method. * * @private / _classLogic: function () { var that = this; var calc = {}; var breakpoints = this.c.breakpoints; var columns = this.s.dt.columns().eq(0).map( function (i) { var className = this.column(i).header().className; return { className: className, includeIn: [], auto: false, control: false, never: className.match(/\bnever\b/) ? true : false }; } ); // Simply add a breakpoint to `includeIn` array, ensuring that there are // no duplicates var add = function ( colIdx, name ) { var includeIn = columns[ colIdx ].includeIn; if ( $.inArray( name, includeIn ) === -1 ) { includeIn.push( name ); } }; var column = function ( colIdx, name, operator, matched ) { var size, i, ien; if ( ! operator ) { columns[ colIdx ].includeIn.push( name ); } else if ( operator === 'max-' ) { // Add this breakpoint and all smaller size = that._find( name ).width; for ( i=0, ien=breakpoints.length ; i<ien ; i++ ) { if ( breakpoints[i].width <= size ) { add( colIdx, breakpoints[i].name ); } } } else if ( operator === 'min-' ) { // Add this breakpoint and all larger size = that._find( name ).width; for ( i=0, ien=breakpoints.length ; i<ien ; i++ ) { if ( breakpoints[i].width >= size ) { add( colIdx, breakpoints[i].name ); } } } else if ( operator === 'not-' ) { // Add all but this breakpoint (xxx need extra information) for ( i=0, ien=breakpoints.length ; i<ien ; i++ ) { if ( breakpoints[i].name.indexOf( matched ) === -1 ) { add( colIdx, breakpoints[i].name ); } } } }; // Loop over each column and determine if it has a responsive control // class columns.each( function ( col, i ) { var classNames = col.className.split(' '); var hasClass = false; // Split the class name up so multiple rules can be applied if needed for ( var k=0, ken=classNames.length ; k<ken ; k++ ) { var className = $.trim( classNames[k] ); if ( className === 'all' ) { // Include in all hasClass = true; col.includeIn = $.map( breakpoints, function (a) { return a.name; } ); return; } else if ( className === 'none' \|\| className === 'never' ) { // Include in none (default) and no auto hasClass = true; return; } else if ( className === 'control' ) { // Special column that is only visible, when one of the other // columns is hidden. This is used for the details control hasClass = true; col.control = true; return; } $.each( breakpoints, function ( j, breakpoint ) { // Does this column have a class that matches this breakpoint? var brokenPoint = breakpoint.name.split('-'); var re = new RegExp( '(min\\-\|max\\-\|not\\-)?('+brokenPoint[0]+')(\\-[_a-zA-Z0-9])?' ); var match = className.match( re ); if ( match ) { hasClass = true; if ( match[2] === brokenPoint[0] && match[3] === '-'+brokenPoint[1] ) { // Class name matches breakpoint name fully column( i, breakpoint.name, match[1], match[2]+match[3] ); } else if ( match[2] === brokenPoint[0] && ! match[3] ) { // Class name matched primary breakpoint name with no qualifier column( i, breakpoint.name, match[1], match[2] ); } } } ); } // If there was no control class, then automatic sizing is used if ( ! hasClass ) { col.auto = true; } } ); this.s.columns = columns; }, /* * Initialisation for the details handler * * @private / _detailsInit: function () { var that = this; var dt = this.s.dt; var details = this.c.details; // The inline type always uses the first child as the target if ( details.type === 'inline' ) { details.target = 'td:first-child'; } // type.target can be a string jQuery selector or a column index var target = details.target; var selector = typeof target === 'string' ? target : 'td'; // Click handler to show / hide the details rows when they are available $( dt.table().body() ).on( 'click', selector, function (e) { // If the table is not collapsed (i.e. there is no hidden columns) // then take no action if ( ! $(dt.table().node()).hasClass('collapsed' ) ) { return; } // Check that the row is actually a DataTable's controlled node if ( ! dt.row( $(this).closest('tr') ).length ) { return; } // For column index, we determine if we should act or not in the // handler - otherwise it is already okay if ( typeof target === 'number' ) { var targetIdx = target < 0 ? dt.columns().eq(0).length + target : target; if ( dt.cell( this ).index().column !== targetIdx ) { return; } } // $().closest() includes itself in its check var row = dt.row( $(this).closest('tr') ); if ( row.child.isShown() ) { row.child( false ); $( row.node() ).removeClass( 'parent' ); } else { var info = that.c.details.renderer( dt, row[0] ); row.child( info, 'child' ).show(); $( row.node() ).addClass( 'parent' ); } } ); }, /* * Update the child rows in the table whenever the column visibility changes * * @private / _detailsVis: function () { var that = this; var dt = this.s.dt; // Find how many columns are hidden var hiddenColumns = dt.columns().indexes().filter( function ( idx ) { var col = dt.column( idx ); if ( col.visible() ) { return null; } // Only counts as hidden if it doesn't have the `never` class return $( col.header() ).hasClass( 'never' ) ? null : idx; } ); var haveHidden = true; if ( hiddenColumns.length === 0 \|\| ( hiddenColumns.length === 1 && this.s.columns[ hiddenColumns[0] ].control ) ) { haveHidden = false; } if ( haveHidden ) { // Show all existing child rows dt.rows( { page: 'current' } ).eq(0).each( function (idx) { var row = dt.row( idx ); if ( row.child() ) { var info = that.c.details.renderer( dt, row[0] ); // The renderer can return false to have no child row if ( info === false ) { row.child.hide(); } else { row.child( info, 'child' ).show(); } } } ); } else { // Hide all existing child rows dt.rows( { page: 'current' } ).eq(0).each( function (idx) { dt.row( idx ).child.hide(); } ); } }, /* * Find a breakpoint object from a name * @param {string} name Breakpoint name to find * @return {object} Breakpoint description object / _find: function ( name ) { var breakpoints = this.c.breakpoints; for ( var i=0, ien=breakpoints.length ; i<ien ; i++ ) { if ( breakpoints[i].name === name ) { return breakpoints[i]; } } }, /* * Alter the table display for a resized viewport. This involves first * determining what breakpoint the window currently is in, getting the * column visibilities to apply and then setting them. * * @private / _resize: function () { var dt = this.s.dt; var width = $(window).width(); var breakpoints = this.c.breakpoints; var breakpoint = breakpoints[0].name; var columns = this.s.columns; var i, ien; // Determine what breakpoint we are currently at for ( i=breakpoints.length-1 ; i>=0 ; i-- ) { if ( width <= breakpoints[i].width ) { breakpoint = breakpoints[i].name; break; } } // Show the columns for that break point var columnsVis = this._columnsVisiblity( breakpoint ); // Set the class before the column visibility is changed so event // listeners know what the state is. Need to determine if there are // any columns that are not visible but can be shown var collapsedClass = false; for ( i=0, ien=columns.length ; i<ien ; i++ ) { if ( columnsVis[i] === false && ! columns[i].never ) { collapsedClass = true; break; } } $( dt.table().node() ).toggleClass('collapsed', collapsedClass ); dt.columns().eq(0).each( function ( colIdx, i ) { dt.column( colIdx ).visible( columnsVis[i] ); } ); }, /* * Determine the width of each column in the table so the auto column hiding * has that information to work with. This method is never going to be 100% * perfect since column widths can change slightly per page, but without * seriously compromising performance this is quite effective. * * @private / _resizeAuto: function () { var dt = this.s.dt; var columns = this.s.columns; // Are we allowed to do auto sizing? if ( ! this.c.auto ) { return; } // Are there any columns that actually need auto-sizing, or do they all // have classes defined if ( $.inArray( true, $.map( columns, function (c) { return c.auto; } ) ) === -1 ) { return; } // Clone the table with the current data in it var tableWidth = dt.table().node().offsetWidth; var columnWidths = dt.columns; var clonedTable = dt.table().node().cloneNode( false ); var clonedHeader = $( dt.table().header().cloneNode( false ) ).appendTo( clonedTable ); var clonedBody = $( dt.table().body().cloneNode( false ) ).appendTo( clonedTable ); $( dt.table().footer() ).clone( false ).appendTo( clonedTable ); // This is a bit slow, but we need to get a clone of each row that // includes all columns. As such, try to do this as little as possible. dt.rows( { page: 'current' } ).indexes().flatten().each( function ( idx ) { var clone = dt.row( idx ).node().cloneNode( true ); if ( dt.columns( ':hidden' ).flatten().length ) { $(clone).append( dt.cells( idx, ':hidden' ).nodes().to$().clone() ); } $(clone).appendTo( clonedBody ); } ); var cells = dt.columns().header().to$().clone( false ); $('<tr/>') .append( cells ) .appendTo( clonedHeader ); // In the inline case extra padding is applied to the first column to // give space for the show / hide icon. We need to use this in the // calculation if ( this.c.details.type === 'inline' ) { $(clonedTable).addClass( 'dtr-inline collapsed' ); } var inserted = $('<div/>') .css( { width: 1, height: 1, overflow: 'hidden' } ) .append( clonedTable ); // Remove columns which are not to be included inserted.find('th.never, td.never').remove(); inserted.insertBefore( dt.table().node() ); // The cloned header now contains the smallest that each column can be dt.columns().eq(0).each( function ( idx ) { columns[idx].minWidth = cells[ idx ].offsetWidth \|\| 0; } ); inserted.remove(); } }; /* * List of default breakpoints. Each item in the array is an object with two * properties: * * * `name` - the breakpoint name. * * `width` - the breakpoint width * * @name Responsive.breakpoints * @static / Responsive.breakpoints = [ { name: 'desktop', width: Infinity }, { name: 'tablet-l', width: 1024 }, { name: 'tablet-p', width: 768 }, { name: 'mobile-l', width: 480 }, { name: 'mobile-p', width: 320 } ]; /* * Responsive default settings for initialisation * * @namespace * @name Responsive.defaults * @static / Responsive.defaults = { /* * List of breakpoints for the instance. Note that this means that each * instance can have its own breakpoints. Additionally, the breakpoints * cannot be changed once an instance has been creased. * * @type {Array} * @default Takes the value of `Responsive.breakpoints` / breakpoints: Responsive.breakpoints, /* * Enable / disable auto hiding calculations. It can help to increase * performance slightly if you disable this option, but all columns would * need to have breakpoint classes assigned to them * * @type {Boolean} * @default `true` / auto: true, /* * Details control. If given as a string value, the `type` property of the * default object is set to that value, and the defaults used for the rest * of the object - this is for ease of implementation. * * The object consists of the following properties: * * * `renderer` - function that is called for display of the child row data. * The default function will show the data from the hidden columns * * `target` - Used as the selector for what objects to attach the child * open / close to * * `type` - `false` to disable the details display, `inline` or `column` * for the two control types * * @type {Object\|string} / details: { renderer: function ( api, rowIdx ) { var data = api.cells( rowIdx, ':hidden' ).eq(0).map( function ( cell ) { var header = $( api.column( cell.column ).header() ); var idx = api.cell( cell ).index(); if ( header.hasClass( 'control' ) \|\| header.hasClass( 'never' ) ) { return ''; } // Use a non-public DT API method to render the data for display // This needs to be updated when DT adds a suitable method for // this type of data retrieval var dtPrivate = api.settings()[0]; var cellData = dtPrivate.oApi._fnGetCellData( dtPrivate, idx.row, idx.column, 'display' ); var title = header.text(); if ( title ) { title = title + ':'; } return '<li data-dtr-index="'+idx.column+'">'+ '<span class="dtr-title">'+ title+ '</span> '+ '<span class="dtr-data">'+ cellData+ '</span>'+ '</li>'; } ).toArray().join(''); return data ? $('<ul data-dtr-index="'+rowIdx+'"/>').append( data ) : false; }, target: 0, type: 'inline' } }; / * API / var Api = $.fn.dataTable.Api; // Doesn't do anything - work around for a bug in DT... Not documented Api.register( 'responsive()', function () { return this; } ); Api.register( 'responsive.index()', function ( li ) { li = $(li); return { column: li.data('dtr-index'), row: li.parent().data('dtr-index') }; } ); Api.register( 'responsive.rebuild()', function () { return this.iterator( 'table', function ( ctx ) { if ( ctx._responsive ) { ctx._responsive._classLogic(); } } ); } ); Api.register( 'responsive.recalc()', function () { return this.iterator( 'table', function ( ctx ) { if ( ctx._responsive ) { ctx._responsive._resizeAuto(); ctx._responsive._resize(); } } ); } ); /* * Version information * * @name Responsive.version * @static */ Responsive.version = '1.0.6'; $.fn.dataTable.Responsive = Responsive; $.fn.DataTable.Responsive = Responsive; // Attach a listener to the document which listens for DataTables initialisation // events so we can automatically initialise $(document).on( 'init.dt.dtr', function (e, settings, json) { if ( e.namespace !== 'dt' ) { return; } if ( $(settings.nTable).hasClass( 'responsive' ) \|\| $(settings.nTable).hasClass( 'dt-responsive' ) \|\| settings.oInit.responsive \|\| DataTable.defaults.responsive ) { var init = settings.oInit.responsive; if ( init !== false ) { new Responsive( settings, $.isPlainObject( init ) ? init : {} ); } } } ); return Responsive; }; // /factory // 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.Responsive ) { // Otherwise simply initialise as normal, stopping multiple evaluation factory( jQuery, jQuery.fn.dataTable ); } })(window, document);

| ver. 1.4 | Github | . | PHP 7.4.33 | Генерация страницы: 0.06 | proxy | phpinfo | Настройка