Changeset 85105 in spip-zone


Ignore:
Timestamp:
Oct 10, 2014, 6:21:39 PM (5 years ago)
Author:
spip.franck@…
Message:

On passe jquery.MultiFile? en 1.48 à la place de la 1.31
Le fichier vient de là: http://www.fyneworks.com/jquery/multiple-file-upload/
Concernant les changements, c'est là qu'il faut voir: https://code.google.com/p/jquery-multifile-plugin/source/list

Location:
_core_/plugins/medias
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • _core_/plugins/medias/javascript/jquery.multifile.js

    r75797 r85105  
    11/*
    2  ### jQuery Multiple File Upload Plugin v1.31 - 2009-01-17 ###
     2 ### jQuery Multiple File Upload Plugin v1.48 - 2013-02-19 ###
    33 * Home: http://www.fyneworks.com/jquery/multiple-file-upload/
    44 * Code: http://code.google.com/p/jquery-multifile-plugin/
    55 *
    6  * Dual licensed under the MIT and GPL licenses:
    7  *   http://www.opensource.org/licenses/mit-license.php
    8  *   http://www.gnu.org/licenses/gpl.html
     6        * Licensed under http://en.wikipedia.org/wiki/MIT_License
    97 ###
    108*/
     
    1412/*# AVOID COLLISIONS #*/
    1513 
    16  // extend jQuery - $.MultiFile hook
    17  $.extend($, {
    18   MultiFile: function( o /* Object */ ){
    19    //return $("INPUT[type='file'].multi").MultiFile(o);
    20    return $("input:file.multi").MultiFile(o);
    21   }
    22  });
    23  
    24  //===
    25  
    26  // extend $.MultiFile - default options
    27  $.extend($.MultiFile, {
    28   options: {
    29    accept: '', max: -1,
    30    // error handling function
    31    error: function(s){
    32     if($.blockUI){
    33      $.blockUI({
    34       message: s.replace(/\n/gi,'<br/>'),
    35       css: {
    36        border:'none', padding:'15px', size:'12.0pt',
    37        backgroundColor:'#900', color:'#fff',
    38        opacity:'.8','-webkit-border-radius': '10px','-moz-border-radius': '10px'
    39       }
    40      });
    41      window.setTimeout($.unblockUI, 2000);
    42     }
    43     else{
    44      alert(s);
    45     }
    46    },
    47    // namePattern: $name/$id (from master element), $i (slave count), $g (group count)
    48    namePattern: '$name',
    49    // STRING: collection lets you show messages in different languages
    50    STRING: {
    51     remove:'x',
    52     denied:'You cannot select a $ext file.\nTry again...',
    53     file:'$file',
    54     selected:'File selected: $file',
    55     duplicate:'This file has already been selected:\n$file'
    56    }
    57   }
    58  });
    59  
    60  //===
    61  
    62  // extend $.MultiFile - global methods
    63  $.extend($.MultiFile, {
     14        // plugin initialization
     15        $.fn.MultiFile = function(options){
     16                if(this.length==0) return this; // quick fail
     17               
     18                // Handle API methods
     19                if(typeof arguments[0]=='string'){
     20                        // Perform API methods on individual elements
     21                        if(this.length>1){
     22                                var args = arguments;
     23                                return this.each(function(){
     24                                        $.fn.MultiFile.apply($(this), args);
     25    });
     26                        };
     27                        // Invoke API method handler
     28                        $.fn.MultiFile[arguments[0]].apply(this, $.makeArray(arguments).slice(1) || []);
     29                        // Quick exit...
     30                        return this;
     31                };
     32               
     33                // Initialize options for this call
     34                var options = $.extend(
     35                        {}/* new object */,
     36                        $.fn.MultiFile.options/* default options */,
     37                        options || {} /* just-in-time options */
     38                );
     39               
     40                // Empty Element Fix!!!
     41                // this code will automatically intercept native form submissions
     42                // and disable empty file elements
     43                $('form')
     44                .not('MultiFile-intercepted')
     45                .addClass('MultiFile-intercepted')
     46                .submit($.fn.MultiFile.disableEmpty);
     47               
     48                //### http://plugins.jquery.com/node/1363
     49                // utility method to integrate this plugin with others...
     50                if($.fn.MultiFile.options.autoIntercept){
     51                        $.fn.MultiFile.intercept( $.fn.MultiFile.options.autoIntercept /* array of methods to intercept */ );
     52                        $.fn.MultiFile.options.autoIntercept = null; /* only run this once */
     53                };
     54               
     55                // loop through each matched element
     56                this
     57                 .not('.MultiFile-applied')
     58                        .addClass('MultiFile-applied')
     59                .each(function(){
     60                        //#####################################################################
     61                        // MAIN PLUGIN FUNCTIONALITY - START
     62                        //#####################################################################
     63                       
     64       // BUG 1251 FIX: http://plugins.jquery.com/project/comments/add/1251
     65       // variable group_count would repeat itself on multiple calls to the plugin.
     66       // this would cause a conflict with multiple elements
     67       // changes scope of variable to global so id will be unique over n calls
     68       window.MultiFile = (window.MultiFile || 0) + 1;
     69       var group_count = window.MultiFile;
     70       
     71       // Copy parent attributes - Thanks to Jonas Wagner
     72       // we will use this one to create new input elements
     73       var MultiFile = {e:this, E:$(this), clone:$(this).clone()};
     74       
     75       //===
     76       
     77       //# USE CONFIGURATION
     78       if(typeof options=='number') options = {max:options};
     79       var o = $.extend({},
     80        $.fn.MultiFile.options,
     81        options || {},
     82                                        ($.metadata? MultiFile.E.metadata(): ($.meta?MultiFile.E.data():null)) || {}, /* metadata options */
     83                                                                {} /* internals */
     84       );
     85       // limit number of files that can be selected?
     86       if(!(o.max>0) /*IsNull(MultiFile.max)*/){
     87        o.max = MultiFile.E.attr('maxlength');
     88       };
     89                                                        if(!(o.max>0) /*IsNull(MultiFile.max)*/){
     90                                                                o.max = (String(MultiFile.e.className.match(/\b(max|limit)\-([0-9]+)\b/gi) || ['']).match(/[0-9]+/gi) || [''])[0];
     91                                                                if(!(o.max>0)) o.max = -1;
     92                                                                else           o.max = String(o.max).match(/[0-9]+/gi)[0];
     93                                                        }
     94       o.max = new Number(o.max);
     95       // limit extensions?
     96       o.accept = o.accept || MultiFile.E.attr('accept') || '';
     97       if(!o.accept){
     98        o.accept = (MultiFile.e.className.match(/\b(accept\-[\w\|]+)\b/gi)) || '';
     99        o.accept = new String(o.accept).replace(/^(accept|ext)\-/i,'');
     100       };
     101       
     102       //===
     103       
     104       // APPLY CONFIGURATION
     105                                                        $.extend(MultiFile, o || {});
     106       MultiFile.STRING = $.extend({},$.fn.MultiFile.options.STRING,MultiFile.STRING);
     107       
     108       //===
     109       
     110       //#########################################
     111       // PRIVATE PROPERTIES/METHODS
     112       $.extend(MultiFile, {
     113        n: 0, // How many elements are currently selected?
     114        slaves: [], files: [],
     115        instanceKey: MultiFile.e.id || 'MultiFile'+String(group_count), // Instance Key?
     116        generateID: function(z){ return MultiFile.instanceKey + (z>0 ?'_F'+String(z):''); },
     117        trigger: function(event, element){
     118         var handler = MultiFile[event], value = $(element).attr('value');
     119         if(handler){
     120          var returnValue = handler(element, value, MultiFile);
     121          if( returnValue!=null ) return returnValue;
     122         }
     123         return true;
     124        }
     125       });
     126       
     127       //===
     128       
     129       // Setup dynamic regular expression for extension validation
     130       // - thanks to John-Paul Bader: http://smyck.de/2006/08/11/javascript-dynamic-regular-expresions/
     131       if(String(MultiFile.accept).length>1){
     132                                                                MultiFile.accept = MultiFile.accept.replace(/\W+/g,'|').replace(/^\W|\W$/g,'');
     133        MultiFile.rxAccept = new RegExp('\\.('+(MultiFile.accept?MultiFile.accept:'')+')$','gi');
     134       };
     135       
     136       //===
     137       
     138       // Create wrapper to hold our file list
     139       MultiFile.wrapID = MultiFile.instanceKey+'_wrap'; // Wrapper ID?
     140       MultiFile.E.wrap('<div class="MultiFile-wrap" id="'+MultiFile.wrapID+'"></div>');
     141       MultiFile.wrapper = $('#'+MultiFile.wrapID+'');
     142       
     143       //===
     144       
     145       // MultiFile MUST have a name - default: file1[], file2[], file3[]
     146       MultiFile.e.name = MultiFile.e.name || 'file'+ group_count +'[]';
     147       
     148       //===
     149       
     150                                                        if(!MultiFile.list){
     151                                                                // Create a wrapper for the list
     152                                                                // * OPERA BUG: NO_MODIFICATION_ALLOWED_ERR ('list' is a read-only property)
     153                                                                // this change allows us to keep the files in the order they were selected
     154                                                                MultiFile.wrapper.append( '<div class="MultiFile-list" id="'+MultiFile.wrapID+'_list"></div>' );
     155                                                                MultiFile.list = $('#'+MultiFile.wrapID+'_list');
     156                                                        };
     157       MultiFile.list = $(MultiFile.list);
     158                                                       
     159       //===
     160       
     161       // Bind a new element
     162       MultiFile.addSlave = function( slave, slave_count ){
     163                                                                //if(window.console) console.log('MultiFile.addSlave',slave_count);
     164                                                               
     165        // Keep track of how many elements have been displayed
     166        MultiFile.n++;
     167        // Add reference to master element
     168        slave.MultiFile = MultiFile;
     169                                                               
     170                                                                // BUG FIX: http://plugins.jquery.com/node/1495
     171                                                                // Clear identifying properties from clones
     172                                                                if(slave_count>0) slave.id = slave.name = '';
     173                                                               
     174        // Define element's ID and name (upload components need this!)
     175        //slave.id = slave.id || MultiFile.generateID(slave_count);
     176                                                                if(slave_count>0) slave.id = MultiFile.generateID(slave_count);
     177                                                                //FIX for: http://code.google.com/p/jquery-multifile-plugin/issues/detail?id=23
     178       
     179        // 2008-Apr-29: New customizable naming convention (see url below)
     180        // http://groups.google.com/group/jquery-dev/browse_frm/thread/765c73e41b34f924#
     181        slave.name = String(MultiFile.namePattern
     182         /*master name*/.replace(/\$name/gi,$(MultiFile.clone).attr('name'))
     183         /*master id  */.replace(/\$id/gi,  $(MultiFile.clone).attr('id'))
     184         /*group count*/.replace(/\$g/gi,   group_count)//(group_count>0?group_count:''))
     185         /*slave count*/.replace(/\$i/gi,   slave_count)//(slave_count>0?slave_count:''))
     186        );
     187       
     188        // If we've reached maximum number, disable input slave
     189        if( (MultiFile.max > 0) && ((MultiFile.n-1) > (MultiFile.max)) )//{ // MultiFile.n Starts at 1, so subtract 1 to find true count
     190         slave.disabled = true;
     191        //};
     192       
     193        // Remember most recent slave
     194        MultiFile.current = MultiFile.slaves[slave_count] = slave;
     195       
     196                                                                // We'll use jQuery from now on
     197                                                                slave = $(slave);
     198       
     199        // Clear value
     200        slave.val('').attr('value','')[0].value = '';
     201       
     202                                                                // Stop plugin initializing on slaves
     203                                                                slave.addClass('MultiFile-applied');
     204                                                               
     205        // Triggered when a file is selected
     206        slave.change(function(){
     207          //if(window.console) console.log('MultiFile.slave.change',slave_count);
     208                                                                 
     209          // Lose focus to stop IE7 firing onchange again
     210          $(this).blur();
     211         
     212          //# Trigger Event! onFileSelect
     213          if(!MultiFile.trigger('onFileSelect', this, MultiFile)) return false;
     214          //# End Event!
     215         
     216          //# Retrive value of selected file from element
     217          var ERROR = '', v = String(this.value || ''/*.attr('value)*/);
     218         
     219          // check extension
     220          if(MultiFile.accept && v && !v.match(MultiFile.rxAccept))//{
     221            ERROR = MultiFile.STRING.denied.replace('$ext', String(v.match(/\.\w{1,4}$/gi)));
     222           //}
     223          //};
     224         
     225          // Disallow duplicates
     226                                                                                for(var f in MultiFile.slaves)//{
     227           if(MultiFile.slaves[f] && MultiFile.slaves[f]!=this)//{
     228                                                                                //console.log(MultiFile.slaves[f],MultiFile.slaves[f].value);
     229            if(MultiFile.slaves[f].value==v)//{
     230             ERROR = MultiFile.STRING.duplicate.replace('$file', v.match(/[^\/\\]+$/gi));
     231            //};
     232           //};
     233          //};
     234         
     235          // Create a new file input element
     236          var newEle = $(MultiFile.clone).clone();// Copy parent attributes - Thanks to Jonas Wagner
     237          //# Let's remember which input we've generated so
     238          // we can disable the empty ones before submission
     239          // See: http://plugins.jquery.com/node/1495
     240          newEle.addClass('MultiFile');
     241         
     242          // Handle error
     243          if(ERROR!=''){
     244            // Handle error
     245            MultiFile.error(ERROR);
     246                                                                                               
     247            // 2007-06-24: BUG FIX - Thanks to Adrian Wróbel <adrian [dot] wrobel [at] gmail.com>
     248            // Ditch the trouble maker and add a fresh new element
     249            MultiFile.n--;
     250            MultiFile.addSlave(newEle[0], slave_count);
     251            slave.parent().prepend(newEle);
     252            slave.remove();
     253            return false;
     254          };
     255         
     256          // Hide this element (NB: display:none is evil!)
     257          $(this).css({ position:'absolute', top: '-3000px' });
     258         
     259          // Add new element to the form
     260          slave.after(newEle);
     261         
     262          // Update list
     263          MultiFile.addToList( this, slave_count );
     264         
     265          // Bind functionality
     266          MultiFile.addSlave( newEle[0], slave_count+1 );
     267         
     268          //# Trigger Event! afterFileSelect
     269          if(!MultiFile.trigger('afterFileSelect', this, MultiFile)) return false;
     270          //# End Event!
     271         
     272        }); // slave.change()
     273                                                               
     274                                                                // Save control to element
     275                                                                $(slave).data('MultiFile', MultiFile);
     276                                                               
     277       };// MultiFile.addSlave
     278       // Bind a new element
     279       
     280       
     281       
     282       // Add a new file to the list
     283       MultiFile.addToList = function( slave, slave_count ){
     284        //if(window.console) console.log('MultiFile.addToList',slave_count);
     285                                                               
     286        //# Trigger Event! onFileAppend
     287        if(!MultiFile.trigger('onFileAppend', slave, MultiFile)) return false;
     288        //# End Event!
     289       
     290        // Create label elements
     291        var
     292         r = $('<div class="MultiFile-label"></div>'),
     293         v = String(slave.value || ''/*.attr('value)*/),
     294         a = $('<span class="MultiFile-title" title="'+MultiFile.STRING.selected.replace('$file', v)+'">'+MultiFile.STRING.file.replace('$file', v.match(/[^\/\\]+$/gi)[0])+'</span>'),
     295         b = $('<a class="MultiFile-remove" href="#'+MultiFile.wrapID+'">'+MultiFile.STRING.remove+'</a>');
     296       
     297        // Insert label
     298        MultiFile.list.append(
     299         r.append(b, ' ', a)
     300        );
     301       
     302        b
     303                                                                .click(function(){
     304         
     305          //# Trigger Event! onFileRemove
     306          if(!MultiFile.trigger('onFileRemove', slave, MultiFile)) return false;
     307          //# End Event!
     308         
     309          MultiFile.n--;
     310          MultiFile.current.disabled = false;
     311         
     312          // Remove element, remove label, point to current
     313                                                                                MultiFile.slaves[slave_count] = null;
     314                                                                                $(slave).remove();
     315                                                                                $(this).parent().remove();
     316                                                                               
     317          // Show most current element again (move into view) and clear selection
     318          $(MultiFile.current).css({ position:'', top: '' });
     319                                                                                $(MultiFile.current).reset().val('').attr('value', '')[0].value = '';
     320         
     321          //# Trigger Event! afterFileRemove
     322          if(!MultiFile.trigger('afterFileRemove', slave, MultiFile)) return false;
     323          //# End Event!
     324                                                                               
     325          return false;
     326        });
     327       
     328        //# Trigger Event! afterFileAppend
     329        if(!MultiFile.trigger('afterFileAppend', slave, MultiFile)) return false;
     330        //# End Event!
     331       
     332       }; // MultiFile.addToList
     333       // Add element to selected files list
     334       
     335       
     336       
     337       // Bind functionality to the first element
     338       if(!MultiFile.MultiFile) MultiFile.addSlave(MultiFile.e, 0);
     339       
     340       // Increment control count
     341       //MultiFile.I++; // using window.MultiFile
     342       MultiFile.n++;
     343                                                       
     344                                                        // Save control to element
     345                                                        MultiFile.E.data('MultiFile', MultiFile);
     346                                                       
     347
     348                        //#####################################################################
     349                        // MAIN PLUGIN FUNCTIONALITY - END
     350                        //#####################################################################
     351                }); // each element
     352        };
     353       
     354        /*--------------------------------------------------------*/
     355       
     356        /*
     357                ### Core functionality and API ###
     358        */
     359        $.extend($.fn.MultiFile, {
     360  /**
     361   * This method removes all selected files
     362   *
     363   * Returns a jQuery collection of all affected elements.
     364   *
     365   * @name reset
     366   * @type jQuery
     367   * @cat Plugins/MultiFile
     368   * @author Diego A. (http://www.fyneworks.com/)
     369   *
     370   * @example $.fn.MultiFile.reset();
     371   */
     372  reset: function(){
     373                        var settings = $(this).data('MultiFile');
     374                        //if(settings) settings.wrapper.find('a.MultiFile-remove').click();
     375                        if(settings) settings.list.find('a.MultiFile-remove').click();
     376   return $(this);
     377  },
    64378 
    65379 
     
    72386   * @name disableEmpty
    73387   * @type jQuery
    74    * @cat Plugins/Multifile
     388   * @cat Plugins/MultiFile
    75389   * @author Diego A. (http://www.fyneworks.com/)
    76390   *
    77    * @example $.MultiFile.disableEmpty();
     391   * @example $.fn.MultiFile.disableEmpty();
    78392   * @param String class (optional) A string specifying a class to be applied to all affected elements - Default: 'mfD'.
    79393   */
    80   disableEmpty: function(klass){
     394  disableEmpty: function(klass){ klass = (typeof(klass)=='string'?klass:'')||'mfD';
    81395   var o = [];
    82    $('input:file').each(function(){ if($(this).val()=='') o[o.length] = this; });
    83    return $(o).each(function(){ this.disabled = true }).addClass(klass || 'mfD');
     396   $('input:file.MultiFile').each(function(){ if($(this).val()=='') o[o.length] = this; });
     397   return $(o).each(function(){ this.disabled = true }).addClass(klass);
    84398  },
    85399 
    86400 
    87  /**
    88   * This method re-enables 'empty' file elements that were disabled (and marked) with the $.MultiFile.disableEmpty method.
    89   *
    90   * Returns a jQuery collection of all affected elements.
    91   *
    92   * @name reEnableEmpty
    93   * @type jQuery
    94   * @cat Plugins/Multifile
    95   * @author Diego A. (http://www.fyneworks.com/)
    96   *
    97   * @example $.MultiFile.reEnableEmpty();
    98   * @param String klass (optional) A string specifying the class that was used to mark affected elements - Default: 'mfD'.
    99   */
    100   reEnableEmpty: function(klass){
    101    klass = klass || 'mfD';
     401                /**
     402                        * This method re-enables 'empty' file elements that were disabled (and marked) with the $.fn.MultiFile.disableEmpty method.
     403                        *
     404                        * Returns a jQuery collection of all affected elements.
     405                        *
     406                        * @name reEnableEmpty
     407                        * @type jQuery
     408                        * @cat Plugins/MultiFile
     409                        * @author Diego A. (http://www.fyneworks.com/)
     410                        *
     411                        * @example $.fn.MultiFile.reEnableEmpty();
     412                        * @param String klass (optional) A string specifying the class that was used to mark affected elements - Default: 'mfD'.
     413                        */
     414  reEnableEmpty: function(klass){ klass = (typeof(klass)=='string'?klass:'')||'mfD';
    102415   return $('input:file.'+klass).removeClass(klass).each(function(){ this.disabled = false });
    103416  },
    104417 
    105418 
    106  /**
    107   * This method will intercept other jQuery plugins and disable empty file input elements prior to form submission
    108   *
    109   * @name intercept
    110   * @cat Plugins/Multifile
    111   * @author Diego A. (http://www.fyneworks.com/)
    112   *
    113   * @example $.MultiFile.intercept();
    114   * @param Array methods (optional) Array of method names to be intercepted
    115   */
    116   autoIntercept: [ 'submit', 'ajaxSubmit', 'validate' /* array of methods to intercept */ ],
     419                /**
     420                        * This method will intercept other jQuery plugins and disable empty file input elements prior to form submission
     421                        *
     422       
     423                        * @name intercept
     424                        * @cat Plugins/MultiFile
     425                        * @author Diego A. (http://www.fyneworks.com/)
     426                        *
     427                        * @example $.fn.MultiFile.intercept();
     428                        * @param Array methods (optional) Array of method names to be intercepted
     429                        */
    117430  intercepted: {},
    118431  intercept: function(methods, context, args){
     
    120433   if(args.constructor.toString().indexOf("Array")<0) args = [ args ];
    121434   if(typeof(methods)=='function'){
    122     $.MultiFile.disableEmpty();
     435    $.fn.MultiFile.disableEmpty();
    123436    value = methods.apply(context || window, args);
    124     $.MultiFile.reEnableEmpty();
     437                                //SEE-http://code.google.com/p/jquery-multifile-plugin/issues/detail?id=27
     438                                setTimeout(function(){ $.fn.MultiFile.reEnableEmpty() },1000);
    125439    return value;
    126440   };
     
    129443    method = methods[i]+''; // make sure that we have a STRING
    130444    if(method) (function(method){ // make sure that method is ISOLATED for the interception
    131      $.MultiFile.intercepted[method] = $.fn[method] || function(){};
     445     $.fn.MultiFile.intercepted[method] = $.fn[method] || function(){};
    132446     $.fn[method] = function(){
    133       $.MultiFile.disableEmpty();
    134       value = $.MultiFile.intercepted[method].apply(this, arguments);
    135       $.MultiFile.reEnableEmpty();
     447      $.fn.MultiFile.disableEmpty();
     448      value = $.fn.MultiFile.intercepted[method].apply(this, arguments);
     449                                                //SEE http://code.google.com/p/jquery-multifile-plugin/issues/detail?id=27
     450      setTimeout(function(){ $.fn.MultiFile.reEnableEmpty() },1000);
    136451      return value;
    137452     }; // interception
    138453    })(method); // MAKE SURE THAT method IS ISOLATED for the interception
    139454   };// for each method
    140   }
     455  } // $.fn.MultiFile.intercept
     456               
    141457 });
    142  
    143  //===
    144  
    145  // extend jQuery function library
    146  $.extend($.fn, {
    147    
    148                         // Use this function to clear values of file inputs
    149                         // But this doesn't always work: $(element).val('').attr('value', '')[0].value = '';
    150                         reset: function(){ return this.each(function(){ try{ this.reset(); }catch(e){} }); },
    151    
    152    // MultiFile function
    153    MultiFile: function( options /* Object */ ){
    154    
    155     //### http://plugins.jquery.com/node/1363
    156     // utility method to integrate this plugin with others...
    157     if($.MultiFile.autoIntercept){
    158      $.MultiFile.intercept( $.MultiFile.autoIntercept /* array of methods to intercept */ );
    159      $.MultiFile.autoIntercept = null; /* only run this once */
    160     };
    161    
    162     //===
    163    
    164     // Bind to each element in current jQuery object
    165     return $(this).each(function(group_count){
    166      if(this._MultiFile) return; this._MultiFile = true;
    167      
    168        // BUG 1251 FIX: http://plugins.jquery.com/project/comments/add/1251
    169        // variable group_count would repeat itself on multiple calls to the plugin.
    170        // this would cause a conflict with multiple elements
    171        // changes scope of variable to global so id will be unique over n calls
    172        window.MultiFile = (window.MultiFile || 0) + 1;
    173        group_count = window.MultiFile;
    174        
    175        // Copy parent attributes - Thanks to Jonas Wagner
    176        // we will use this one to create new input elements
    177        var MF = {e:this, E:$(this), clone:$(this).clone()};
    178        
    179        //===
    180        
    181        //# USE CONFIGURATION
    182        if(typeof options=='number') options = {max:options};
    183        if(typeof options=='string') options = {accept:options};
    184        var o = $.extend({},
    185         $.MultiFile.options,
    186         options || {},
    187         ($.meta ? MF.E.data()/*NEW metadata plugin*/ :
    188         ($.metadata ? MF.E.metadata()/*OLD metadata plugin*/ :
    189         null/*metadata plugin not available*/)) || {}
    190        );
    191        // limit number of files that can be selected?
    192        if(!(o.max>0) /*IsNull(MF.max)*/){
    193         o.max = MF.E.attr('maxlength');
    194         if(!(o.max>0) /*IsNull(MF.max)*/){
    195          o.max = (String(MF.e.className.match(/\b(max|limit)\-([0-9]+)\b/gi) || ['']).match(/[0-9]+/gi) || [''])[0];
    196          if(!(o.max>0)) o.max = -1;
    197          else           o.max = String(o.max).match(/[0-9]+/gi)[0];
    198         }
    199        };
    200        o.max = new Number(o.max);
    201        // limit extensions?
    202        o.accept = o.accept || MF.E.attr('accept') || '';
    203        if(!o.accept){
    204         o.accept = (MF.e.className.match(/\b(accept\-[\w\|]+)\b/gi)) || '';
    205         o.accept = new String(o.accept).replace(/^(accept|ext)\-/i,'');
    206        };
    207        
    208        //===
    209        
    210        // APPLY CONFIGURATION
    211        $.extend(MF, o || {});
    212        MF.STRING = $.extend({},$.MultiFile.options.STRING,MF.STRING);
    213        
    214        //===
    215        
    216        //#########################################
    217        // PRIVATE PROPERTIES/METHODS
    218        $.extend(MF, {
    219         n: 0, // How many elements are currently selected?
    220         slaves: [], files: [],
    221         instanceKey: MF.e.id || 'MultiFile'+String(group_count), // Instance Key?
    222         generateID: function(z){ return MF.instanceKey + (z>0 ?'_F'+String(z):''); },
    223         trigger: function(event, element){
    224          var handler = MF[event], value = $(element).attr('value');
    225          if(handler){
    226           var returnValue = handler(element, value, MF);
    227           if( returnValue!=null ) return returnValue;
    228          }
    229          return true;
    230         }
    231        });
    232        
    233        //===
    234        
    235        // Setup dynamic regular expression for extension validation
    236        // - thanks to John-Paul Bader: http://smyck.de/2006/08/11/javascript-dynamic-regular-expresions/
    237        if(String(MF.accept).length>1){
    238         MF.rxAccept = new RegExp('\\.('+(MF.accept?MF.accept:'')+')$','gi');
    239        };
    240        
    241        //===
    242        
    243        // Create wrapper to hold our file list
    244        MF.wrapID = MF.instanceKey+'_wrap'; // Wrapper ID?
    245        MF.E.wrap('<div id="'+MF.wrapID+'"></div>');
    246        MF.wrapper = $('#'+MF.wrapID+'');
    247        
    248        //===
    249        
    250        // MF MUST have a name - default: file1[], file2[], file3[]
    251        MF.e.name = MF.e.name || 'file'+ group_count +'[]';
    252        
    253        //===
    254        
    255                                                         if(!MF.list){
    256                                                                 // Create a wrapper for the list
    257                                                                 // * OPERA BUG: NO_MODIFICATION_ALLOWED_ERR ('list' is a read-only property)
    258                                                                 // this change allows us to keep the files in the order they were selected
    259                                                                 MF.wrapper.append( '<span id="'+MF.wrapID+'_list"></span>' );
    260                                                                 MF.list = $('#'+MF.wrapID+'_list');
    261                                                         };
    262        MF.list = $(MF.list);
    263                                                        
    264        //===
    265        
    266        // Bind a new element
    267        MF.addSlave = function( slave, slave_count ){
    268         // Keep track of how many elements have been displayed
    269         MF.n++;
    270         // Add reference to master element
    271         slave.MF = MF;
    272         // Count slaves
    273         slave.i = slave_count;
    274        
    275         // BUG FIX: http://plugins.jquery.com/node/1495
    276         // Clear identifying properties from clones
    277         if(slave.i>0) slave.id = slave.name = null;
    278        
    279         // Define element's ID and name (upload components need this!)
    280         slave.id = slave.id || MF.generateID(slave.i);
    281        
    282         //slave.name = (slave.name || MF.E.attr('name') || 'file');// + (slave.i>0?slave.i:''); // same name as master element
    283         // 2008-Apr-29: New customizable naming convention (see url below)
    284         // http://groups.google.com/group/jquery-dev/browse_frm/thread/765c73e41b34f924#
    285         slave.name = String(MF.namePattern
    286          /*master name*/.replace(/\$name/gi,MF.E.attr('name'))
    287          /*master id  */.replace(/\$id/gi,  MF.E.attr('id'))
    288          /*group count*/.replace(/\$g/gi,   (group_count>0?group_count:''))
    289          /*slave count*/.replace(/\$i/gi,   (slave_count>0?slave_count:''))
    290         );
    291        
    292         // Clear value
    293         $(slave).val('').attr('value','')[0].value = '';
    294        
    295         // If we've reached maximum number, disable input slave
    296         if( (MF.max > 0) && ((MF.n-1) > (MF.max)) )//{ // MF.n Starts at 1, so subtract 1 to find true count
    297          slave.disabled = true;
    298         //};
    299        
    300         // Remember most recent slave
    301         MF.current = MF.slaves[slave.i] = slave;
    302        
    303         // now let's use jQuery
    304         slave = $(slave);
    305        
    306         // Triggered when a file is selected
    307         $(slave).change(function(){
    308          
    309           // Lose focus to stop IE7 firing onchange again
    310           $(this).blur();
    311          
    312           //# Trigger Event! onFileSelect
    313           if(!MF.trigger('onFileSelect', this, MF)) return false;
    314           //# End Event!
    315          
    316           //# Retrive value of selected file from element
    317           var ERROR = '', v = String(this.value || ''/*.attr('value)*/);
    318          
    319           // check extension
    320           if(MF.accept && v && !v.match(MF.rxAccept))//{
    321             ERROR = MF.STRING.denied.replace('$ext', String(v.match(/\.\w{1,4}$/gi)));
    322            //}
    323           //};
    324          
    325           // Disallow duplicates
    326                                                                                 for(var f in MF.slaves)//{
    327            if(MF.slaves[f] && MF.slaves[f]!=this)//{
    328                                                                                 //console.log(MF.slaves[f],MF.slaves[f].value);
    329             if(MF.slaves[f].value==v)//{
    330              ERROR = MF.STRING.duplicate.replace('$file', v.match(/[^\/\\]+$/gi));
    331             //};
    332            //};
    333           //};
    334          
    335           // Create a new file input element
    336           //var newEle = $('<input name="'+(MF.E.attr('name') || '')+'" type="file"/>');
    337           var newEle = $(MF.clone).clone();// Copy parent attributes - Thanks to Jonas Wagner
    338           //# Let's remember which input we've generated so
    339           // we can disable the empty ones before submission
    340           // See: http://plugins.jquery.com/node/1495
    341           newEle.addClass('MultiFile');
    342          
    343           // Handle error
    344           if(ERROR!=''){
    345             // Handle error
    346             MF.error(ERROR);
    347            
    348             // Clear element value (DOES NOT WORK in some browsers)
    349             //slave.reset().val('').attr('value', '')[0].value = '';
    350            
    351             // 2007-06-24: BUG FIX - Thanks to Adrian Wróbel <adrian [dot] wrobel [at] gmail.com>
    352             // Ditch the trouble maker and add a fresh new element
    353             MF.n--;
    354             MF.addSlave(newEle[0], this.i);
    355             MF.list.before(newEle);//slave.parent().prepend(newEle);
    356             slave.remove();
    357             return false;
    358           };
    359          
    360           // Hide this element (NB: display:none is evil!)
    361           $(this).css({ position:'absolute', top: '-3000px' });
    362          
    363           // Add new element to the form
    364           MF.list.before(newEle);//.append(newEle);
    365           //MF.wrapper.prepend(newEle);//.append(newEle);
    366          
    367           // Update list
    368           MF.addToList( this );
    369          
    370           // Bind functionality
    371           MF.addSlave( newEle[0], this.i+1 );
    372          
    373           //# Trigger Event! afterFileSelect
    374           if(!MF.trigger('afterFileSelect', this, MF)) return false;
    375           //# End Event!
    376          
    377         }); // slave.change()
    378        
    379        };// MF.addSlave
    380        // Bind a new element
    381        
    382        
    383        
    384        // Add a new file to the list
    385        MF.addToList = function( slave ){
    386        
    387         //# Trigger Event! onFileAppend
    388         if(!MF.trigger('onFileAppend', slave, MF)) return false;
    389         //# End Event!
    390        
    391         // Create label elements
    392         var
    393          r = $('<div></div>'),
    394          v = String(slave.value || ''/*.attr('value)*/),
    395          a = $('<span class="file" title="'+MF.STRING.selected.replace('$file', v)+'">'+MF.STRING.file.replace('$file', v.match(/[^\/\\]+$/gi)[0])+'</span>'),
    396          b = $('<a href="#'+MF.wrapID+'">'+MF.STRING.remove+'</a>');
    397        
    398         // Insert label
    399         MF.list.append(
    400          r.append(b, ' ', a)//.prepend(slave.i+': ')
    401         );
    402        
    403         b.click(function(){
    404          
    405           //# Trigger Event! onFileRemove
    406           if(!MF.trigger('onFileRemove', slave, MF)) return false;
    407           //# End Event!
    408          
    409           MF.n--;
    410           MF.current.disabled = false;
    411          
    412           // Remove element, remove label, point to current
    413                                                                                 MF.slaves[slave.i] = null;
    414                                                                                 $(slave).remove();
    415                                                                                 $(this).parent().remove();
    416          
    417           // Show most current element again (move into view) and clear selection
    418           $(MF.current).css({ position:'', top: '' });
    419                                                                                 $(MF.current).reset().val('').attr('value', '')[0].value = '';
    420          
    421           //# Trigger Event! afterFileRemove
    422           if(!MF.trigger('afterFileRemove', slave, MF)) return false;
    423           //# End Event!
    424                                                                                
    425           return false;
    426         });
    427        
    428         //# Trigger Event! afterFileAppend
    429         if(!MF.trigger('afterFileAppend', slave, MF)) return false;
    430         //# End Event!
    431        
    432        }; // MF.addToList
    433        // Add element to selected files list
    434        
    435        
    436        
    437        // Bind functionality to the first element
    438        if(!MF.MF) MF.addSlave(MF.e, 0);
    439        
    440        // Increment control count
    441        //MF.I++; // using window.MultiFile
    442        MF.n++;
    443        
    444     });
    445     // each element
    446    
    447    }
    448    // MultiFile function
    449  
     458       
     459        /*--------------------------------------------------------*/
     460       
     461        /*
     462                ### Default Settings ###
     463                eg.: You can override default control like this:
     464                $.fn.MultiFile.options.accept = 'gif|jpg';
     465        */
     466        $.fn.MultiFile.options = { //$.extend($.fn.MultiFile, { options: {
     467                accept: '', // accepted file extensions
     468                max: -1,    // maximum number of selectable files
     469               
     470                // name to use for newly created elements
     471                namePattern: '$name', // same name by default (which creates an array)
     472         /*master name*/ // use $name
     473         /*master id  */ // use $id
     474         /*group count*/ // use $g
     475         /*slave count*/ // use $i
     476                                                                        /*other      */ // use any combination of he above, eg.: $name_file$i
     477               
     478                // STRING: collection lets you show messages in different languages
     479                STRING: {
     480                        remove:'x',
     481                        denied:'You cannot select a $ext file.\nTry again...',
     482                        file:'$file',
     483                        selected:'File selected: $file',
     484                        duplicate:'This file has already been selected:\n$file'
     485                },
     486               
     487                // name of methods that should be automcatically intercepted so the plugin can disable
     488                // extra file elements that are empty before execution and automatically re-enable them afterwards
     489  autoIntercept: [ 'submit', 'ajaxSubmit', 'ajaxForm', 'validate', 'valid' /* array of methods to intercept */ ],
     490               
     491                // error handling function
     492                error: function(s){
     493                        /*
     494                        ERROR! blockUI is not currently working in IE
     495                        if($.blockUI){
     496                                $.blockUI({
     497                                        message: s.replace(/\n/gi,'<br/>'),
     498                                        css: {
     499                                                border:'none', padding:'15px', size:'12.0pt',
     500                                                backgroundColor:'#900', color:'#fff',
     501                                                opacity:'.8','-webkit-border-radius': '10px','-moz-border-radius': '10px'
     502                                        }
     503                                });
     504                                window.setTimeout($.unblockUI, 2000);
     505                        }
     506                        else//{// save a byte!
     507                        */
     508                         alert(s);
     509                        //}// save a byte!
     510                }
     511 }; //} });
     512       
     513        /*--------------------------------------------------------*/
     514       
     515        /*
     516                ### Additional Methods ###
     517                Required functionality outside the plugin's scope
     518        */
     519       
     520        // Native input reset method - because this alone doesn't always work: $(element).val('').attr('value', '')[0].value = '';
     521        $.fn.reset = function(){ return this.each(function(){ try{ this.reset(); }catch(e){} }); };
     522       
     523        /*--------------------------------------------------------*/
     524       
     525        /*
     526                ### Default implementation ###
     527                The plugin will attach itself to file inputs
     528                with the class 'multi' when the page loads
     529        */
     530        $(function(){
     531  //$("input:file.multi").MultiFile();
     532  $("input[type=file].multi").MultiFile();
    450533 });
    451  // extend jQuery function library
    452  
    453  
    454  
    455  /*
    456   ### Default implementation ###
    457   The plugin will attach itself to file inputs
    458   with the class 'multi' when the page loads
    459  */
    460  $(function(){ $.MultiFile() });
    461  
    462  
    463  
     534       
     535       
     536       
    464537/*# AVOID COLLISIONS #*/
    465538})(jQuery);
  • _core_/plugins/medias/paquet.xml

    r83817 r85105  
    22        prefix="medias"
    33        categorie="multimedia"
    4         version="2.8.25"
     4        version="2.8.26"
    55        etat="stable"
    66        compatibilite="[3.0.0;3.1.*]"
Note: See TracChangeset for help on using the changeset viewer.