/* 
  ### jQuery Multiple File Upload Plugin v1.47 - 2010-03-26 ### 
  * Home: http://www.fyneworks.com/jquery/multiple-file-upload/ 
  * Code: http://code.google.com/p/jquery-multifile-plugin/ 
  * 
  * Dual licensed under the MIT and GPL licenses: 
  *   http://www.opensource.org/licenses/mit-license.php 
  *   http://www.gnu.org/licenses/gpl.html 
  ### 
 */ 
  
 /*# AVOID COLLISIONS #*/ 
 ;if(window.jQuery) (function($){ 
 /*# AVOID COLLISIONS #*/ 
   
         // plugin initialization 
         $.fn.MultiFile = function(options){ 
                 if(this.length==0) return this; // quick fail 
                  
                 // Handle API methods 
                 if(typeof arguments[0]=='string'){ 
                         // Perform API methods on individual elements 
                         if(this.length>1){ 
                                 var args = arguments; 
                                 return this.each(function(){ 
                                         $.fn.MultiFile.apply($(this), args); 
     }); 
                         }; 
                         // Invoke API method handler 
                         $.fn.MultiFile[arguments[0]].apply(this, $.makeArray(arguments).slice(1) || []); 
                         // Quick exit... 
                         return this; 
                 }; 
                  
                 // Initialize options for this call 
                 var options = $.extend( 
                         {}/* new object */, 
                         $.fn.MultiFile.options/* default options */, 
                         options || {} /* just-in-time options */ 
                 ); 
                  
                 // Empty Element Fix!!! 
                 // this code will automatically intercept native form submissions 
                 // and disable empty file elements 
                 $('form') 
                 .not('MultiFile-intercepted') 
                 .addClass('MultiFile-intercepted') 
                 .submit($.fn.MultiFile.disableEmpty); 
                  
                 //### http://plugins.jquery.com/node/1363 
                 // utility method to integrate this plugin with others... 
                 if($.fn.MultiFile.options.autoIntercept){ 
                         $.fn.MultiFile.intercept( $.fn.MultiFile.options.autoIntercept /* array of methods to intercept */ ); 
                         $.fn.MultiFile.options.autoIntercept = null; /* only run this once */ 
                 }; 
                  
                 // loop through each matched element 
                 this 
                  .not('.MultiFile-applied') 
                         .addClass('MultiFile-applied') 
                 .each(function(){ 
                         //##################################################################### 
                         // MAIN PLUGIN FUNCTIONALITY - START 
                         //##################################################################### 
                          
        // BUG 1251 FIX: http://plugins.jquery.com/project/comments/add/1251 
        // variable group_count would repeat itself on multiple calls to the plugin. 
        // this would cause a conflict with multiple elements 
        // changes scope of variable to global so id will be unique over n calls 
        window.MultiFile = (window.MultiFile || 0) + 1; 
        var group_count = window.MultiFile; 
         
        // Copy parent attributes - Thanks to Jonas Wagner 
        // we will use this one to create new input elements 
        var MultiFile = {e:this, E:$(this), clone:$(this).clone()}; 
         
        //=== 
         
        //# USE CONFIGURATION 
        if(typeof options=='number') options = {max:options}; 
        var o = $.extend({}, 
         $.fn.MultiFile.options, 
         options || {}, 
                                         ($.metadata? MultiFile.E.metadata(): ($.meta?MultiFile.E.data():null)) || {}, /* metadata options */ 
                                                                 {} /* internals */ 
        ); 
        // limit number of files that can be selected? 
        if(!(o.max>0) /*IsNull(MultiFile.max)*/){ 
         o.max = MultiFile.E.attr('maxlength'); 
         if(!(o.max>0) /*IsNull(MultiFile.max)*/){ 
          o.max = (String(MultiFile.e.className.match(/\b(max|limit)\-([0-9]+)\b/gi) || ['']).match(/[0-9]+/gi) || [''])[0]; 
          if(!(o.max>0)) o.max = -1; 
          else           o.max = String(o.max).match(/[0-9]+/gi)[0]; 
         } 
        }; 
        o.max = new Number(o.max); 
        // limit extensions? 
        o.accept = o.accept || MultiFile.E.attr('accept') || ''; 
        if(!o.accept){ 
         o.accept = (MultiFile.e.className.match(/\b(accept\-[\w\|]+)\b/gi)) || ''; 
         o.accept = new String(o.accept).replace(/^(accept|ext)\-/i,''); 
        }; 
         
        //=== 
         
        // APPLY CONFIGURATION 
                                                         $.extend(MultiFile, o || {}); 
        MultiFile.STRING = $.extend({},$.fn.MultiFile.options.STRING,MultiFile.STRING); 
         
        //=== 
         
        //######################################### 
        // PRIVATE PROPERTIES/METHODS 
        $.extend(MultiFile, { 
         n: 0, // How many elements are currently selected? 
         slaves: [], files: [], 
         instanceKey: MultiFile.e.id || 'MultiFile'+String(group_count), // Instance Key? 
         generateID: function(z){ return MultiFile.instanceKey + (z>0 ?'_F'+String(z):''); }, 
         trigger: function(event, element){ 
          var handler = MultiFile[event], value = $(element).attr('value'); 
          if(handler){ 
           var returnValue = handler(element, value, MultiFile); 
           if( returnValue!=null ) return returnValue; 
          } 
          return true; 
         } 
        }); 
         
        //=== 
         
        // Setup dynamic regular expression for extension validation 
        // - thanks to John-Paul Bader: http://smyck.de/2006/08/11/javascript-dynamic-regular-expresions/ 
        if(String(MultiFile.accept).length>1){ 
                                                                 MultiFile.accept = MultiFile.accept.replace(/\W+/g,'|').replace(/^\W|\W$/g,''); 
         MultiFile.rxAccept = new RegExp('\\.('+(MultiFile.accept?MultiFile.accept:'')+')$','gi'); 
        }; 
         
        //=== 
         
        // Create wrapper to hold our file list 
        MultiFile.wrapID = MultiFile.instanceKey+'_wrap'; // Wrapper ID? 
        MultiFile.E.wrap('<div class="MultiFile-wrap" id="'+MultiFile.wrapID+'"></div>'); 
        MultiFile.wrapper = $('#'+MultiFile.wrapID+''); 
         
        //=== 
         
        // MultiFile MUST have a name - default: file1[], file2[], file3[] 
        MultiFile.e.name = MultiFile.e.name || 'file'+ group_count +'[]'; 
         
        //=== 
         
                                                         if(!MultiFile.list){ 
                                                                 // Create a wrapper for the list 
                                                                 // * OPERA BUG: NO_MODIFICATION_ALLOWED_ERR ('list' is a read-only property) 
                                                                 // this change allows us to keep the files in the order they were selected 
                                                                 MultiFile.wrapper.append( '<div class="MultiFile-list" id="'+MultiFile.wrapID+'_list"></div>' ); 
                                                                 MultiFile.list = $('#'+MultiFile.wrapID+'_list'); 
                                                         }; 
        MultiFile.list = $(MultiFile.list); 
                                                          
        //=== 
         
        // Bind a new element 
        MultiFile.addSlave = function( slave, slave_count ){ 
                                                                 //if(window.console) console.log('MultiFile.addSlave',slave_count); 
                                                                  
         // Keep track of how many elements have been displayed 
         MultiFile.n++; 
         // Add reference to master element 
         slave.MultiFile = MultiFile; 
                                                                  
                                                                 // BUG FIX: http://plugins.jquery.com/node/1495 
                                                                 // Clear identifying properties from clones 
                                                                 if(slave_count>0) slave.id = slave.name = ''; 
                                                                  
         // Define element's ID and name (upload components need this!) 
         //slave.id = slave.id || MultiFile.generateID(slave_count); 
                                                                 if(slave_count>0) slave.id = MultiFile.generateID(slave_count); 
                                                                 //FIX for: http://code.google.com/p/jquery-multifile-plugin/issues/detail?id=23 
          
         // 2008-Apr-29: New customizable naming convention (see url below) 
         // http://groups.google.com/group/jquery-dev/browse_frm/thread/765c73e41b34f924# 
         slave.name = String(MultiFile.namePattern 
          /*master name*/.replace(/\$name/gi,$(MultiFile.clone).attr('name')) 
          /*master id  */.replace(/\$id/gi,  $(MultiFile.clone).attr('id')) 
          /*group count*/.replace(/\$g/gi,   group_count)//(group_count>0?group_count:'')) 
          /*slave count*/.replace(/\$i/gi,   slave_count)//(slave_count>0?slave_count:'')) 
         ); 
          
         // If we've reached maximum number, disable input slave 
         if( (MultiFile.max > 0) && ((MultiFile.n-1) > (MultiFile.max)) )//{ // MultiFile.n Starts at 1, so subtract 1 to find true count 
          slave.disabled = true; 
         //}; 
          
         // Remember most recent slave 
         MultiFile.current = MultiFile.slaves[slave_count] = slave; 
          
                                                                 // We'll use jQuery from now on 
                                                                 slave = $(slave); 
          
         // Clear value 
         slave.val('').attr('value','')[0].value = ''; 
          
                                                                 // Stop plugin initializing on slaves 
                                                                 slave.addClass('MultiFile-applied'); 
                                                                  
         // Triggered when a file is selected 
         slave.change(function(){ 
           //if(window.console) console.log('MultiFile.slave.change',slave_count); 
                                                                   
           // Lose focus to stop IE7 firing onchange again 
           $(this).blur(); 
            
           //# Trigger Event! onFileSelect 
           if(!MultiFile.trigger('onFileSelect', this, MultiFile)) return false; 
           //# End Event! 
            
           //# Retrive value of selected file from element 
           var ERROR = '', v = String(this.value || ''/*.attr('value)*/); 
            
           // check extension 
           if(MultiFile.accept && v && !v.match(MultiFile.rxAccept))//{ 
             ERROR = MultiFile.STRING.denied.replace('$ext', String(v.match(/\.\w{1,4}$/gi))); 
            //} 
           //}; 
            
           // Disallow duplicates 
                                                                                 for(var f in MultiFile.slaves)//{ 
            if(MultiFile.slaves[f] && MultiFile.slaves[f]!=this)//{ 
                                                                                 //console.log(MultiFile.slaves[f],MultiFile.slaves[f].value); 
             if(MultiFile.slaves[f].value==v)//{ 
              ERROR = MultiFile.STRING.duplicate.replace('$file', v.match(/[^\/\\]+$/gi)); 
             //}; 
            //}; 
           //}; 
            
           // Create a new file input element 
           var newEle = $(MultiFile.clone).clone();// Copy parent attributes - Thanks to Jonas Wagner 
           //# Let's remember which input we've generated so 
           // we can disable the empty ones before submission 
           // See: http://plugins.jquery.com/node/1495 
           newEle.addClass('MultiFile'); 
            
           // Handle error 
           if(ERROR!=''){ 
             // Handle error 
             MultiFile.error(ERROR); 
                                                                                                  
             // 2007-06-24: BUG FIX - Thanks to Adrian Wróbel <adrian [dot] wrobel [at] gmail.com> 
             // Ditch the trouble maker and add a fresh new element 
             MultiFile.n--; 
             MultiFile.addSlave(newEle[0], slave_count); 
             slave.parent().prepend(newEle); 
             slave.remove(); 
             return false; 
           }; 
            
           // Hide this element (NB: display:none is evil!) 
           $(this).css({ position:'absolute', top: '-3000px' }); 
            
           // Add new element to the form 
           slave.after(newEle); 
            
           // Update list 
           MultiFile.addToList( this, slave_count ); 
            
           // Bind functionality 
           MultiFile.addSlave( newEle[0], slave_count+1 ); 
            
           //# Trigger Event! afterFileSelect 
           if(!MultiFile.trigger('afterFileSelect', this, MultiFile)) return false; 
           //# End Event! 
            
         }); // slave.change() 
                                                                  
                                                                 // Save control to element 
                                                                 $(slave).data('MultiFile', MultiFile); 
                                                                  
        };// MultiFile.addSlave 
        // Bind a new element 
         
         
         
        // Add a new file to the list 
        MultiFile.addToList = function( slave, slave_count ){ 
         //if(window.console) console.log('MultiFile.addToList',slave_count); 
                                                                  
         //# Trigger Event! onFileAppend 
         if(!MultiFile.trigger('onFileAppend', slave, MultiFile)) return false; 
         //# End Event! 
          
         // Create label elements 
         var 
          r = $('<div class="MultiFile-label"></div>'), 
          v = String(slave.value || ''/*.attr('value)*/), 
          a = $('<span class="MultiFile-title" title="'+MultiFile.STRING.selected.replace('$file', v)+'">'+MultiFile.STRING.file.replace('$file', v.match(/[^\/\\]+$/gi)[0])+'</span>'), 
          b = $('<a class="MultiFile-remove" href="#'+MultiFile.wrapID+'">'+MultiFile.STRING.remove+'</a>'); 
          
         // Insert label 
         MultiFile.list.append( 
          r.append(b, ' ', a) 
         ); 
          
         b 
                                                                 .click(function(){ 
           
           //# Trigger Event! onFileRemove 
           if(!MultiFile.trigger('onFileRemove', slave, MultiFile)) return false; 
           //# End Event! 
            
           MultiFile.n--; 
           MultiFile.current.disabled = false; 
            
           // Remove element, remove label, point to current 
                                                                                 MultiFile.slaves[slave_count] = null; 
                                                                                 $(slave).remove(); 
                                                                                 $(this).parent().remove(); 
                                                                                  
           // Show most current element again (move into view) and clear selection 
           $(MultiFile.current).css({ position:'', top: '' }); 
                                                                                 $(MultiFile.current).reset().val('').attr('value', '')[0].value = ''; 
            
           //# Trigger Event! afterFileRemove 
           if(!MultiFile.trigger('afterFileRemove', slave, MultiFile)) return false; 
           //# End Event! 
                                                                                  
           return false; 
         }); 
          
         //# Trigger Event! afterFileAppend 
         if(!MultiFile.trigger('afterFileAppend', slave, MultiFile)) return false; 
         //# End Event! 
          
        }; // MultiFile.addToList 
        // Add element to selected files list 
         
         
         
        // Bind functionality to the first element 
        if(!MultiFile.MultiFile) MultiFile.addSlave(MultiFile.e, 0); 
         
        // Increment control count 
        //MultiFile.I++; // using window.MultiFile 
        MultiFile.n++; 
                                                          
                                                         // Save control to element 
                                                         MultiFile.E.data('MultiFile', MultiFile); 
                                                          
  
                         //##################################################################### 
                         // MAIN PLUGIN FUNCTIONALITY - END 
                         //##################################################################### 
                 }); // each element 
         }; 
          
         /*--------------------------------------------------------*/ 
          
         /* 
                 ### Core functionality and API ### 
         */ 
         $.extend($.fn.MultiFile, { 
   /** 
    * This method removes all selected files 
    * 
    * Returns a jQuery collection of all affected elements. 
    * 
    * @name reset 
    * @type jQuery 
    * @cat Plugins/MultiFile 
    * @author Diego A. (http://www.fyneworks.com/) 
    * 
    * @example $.fn.MultiFile.reset(); 
    */ 
   reset: function(){ 
                         var settings = $(this).data('MultiFile'); 
                         //if(settings) settings.wrapper.find('a.MultiFile-remove').click(); 
                         if(settings) settings.list.find('a.MultiFile-remove').click(); 
    return $(this); 
   }, 
    
    
   /** 
    * This utility makes it easy to disable all 'empty' file elements in the document before submitting a form. 
    * It marks the affected elements so they can be easily re-enabled after the form submission or validation. 
    * 
    * Returns a jQuery collection of all affected elements. 
    * 
    * @name disableEmpty 
    * @type jQuery 
    * @cat Plugins/MultiFile 
    * @author Diego A. (http://www.fyneworks.com/) 
    * 
    * @example $.fn.MultiFile.disableEmpty(); 
    * @param String class (optional) A string specifying a class to be applied to all affected elements - Default: 'mfD'. 
    */ 
   disableEmpty: function(klass){ klass = (typeof(klass)=='string'?klass:'')||'mfD'; 
    var o = []; 
    $('input:file.MultiFile').each(function(){ if($(this).val()=='') o[o.length] = this; }); 
    return $(o).each(function(){ this.disabled = true }).addClass(klass); 
   }, 
    
    
                 /** 
                         * This method re-enables 'empty' file elements that were disabled (and marked) with the $.fn.MultiFile.disableEmpty method. 
                         * 
                         * Returns a jQuery collection of all affected elements. 
                         * 
                         * @name reEnableEmpty 
                         * @type jQuery 
                         * @cat Plugins/MultiFile 
                         * @author Diego A. (http://www.fyneworks.com/) 
                         * 
                         * @example $.fn.MultiFile.reEnableEmpty(); 
                         * @param String klass (optional) A string specifying the class that was used to mark affected elements - Default: 'mfD'. 
                         */ 
   reEnableEmpty: function(klass){ klass = (typeof(klass)=='string'?klass:'')||'mfD'; 
    return $('input:file.'+klass).removeClass(klass).each(function(){ this.disabled = false }); 
   }, 
    
    
                 /** 
                         * This method will intercept other jQuery plugins and disable empty file input elements prior to form submission 
                         * 
          
                         * @name intercept 
                         * @cat Plugins/MultiFile 
                         * @author Diego A. (http://www.fyneworks.com/) 
                         * 
                         * @example $.fn.MultiFile.intercept(); 
                         * @param Array methods (optional) Array of method names to be intercepted 
                         */ 
   intercepted: {}, 
   intercept: function(methods, context, args){ 
    var method, value; args = args || []; 
    if(args.constructor.toString().indexOf("Array")<0) args = [ args ]; 
    if(typeof(methods)=='function'){ 
     $.fn.MultiFile.disableEmpty(); 
     value = methods.apply(context || window, args); 
                                 //SEE-http://code.google.com/p/jquery-multifile-plugin/issues/detail?id=27 
                                 setTimeout(function(){ $.fn.MultiFile.reEnableEmpty() },1000); 
     return value; 
    }; 
    if(methods.constructor.toString().indexOf("Array")<0) methods = [methods]; 
    for(var i=0;i<methods.length;i++){ 
     method = methods[i]+''; // make sure that we have a STRING 
     if(method) (function(method){ // make sure that method is ISOLATED for the interception 
      $.fn.MultiFile.intercepted[method] = $.fn[method] || function(){}; 
      $.fn[method] = function(){ 
       $.fn.MultiFile.disableEmpty(); 
       value = $.fn.MultiFile.intercepted[method].apply(this, arguments); 
                                                 //SEE-http://code.google.com/p/jquery-multifile-plugin/issues/detail?id=27 
       setTimeout(function(){ $.fn.MultiFile.reEnableEmpty() },1000); 
       return value; 
      }; // interception 
     })(method); // MAKE SURE THAT method IS ISOLATED for the interception 
    };// for each method 
   } // $.fn.MultiFile.intercept 
                  
  }); 
          
         /*--------------------------------------------------------*/ 
          
         /* 
                 ### Default Settings ### 
                 eg.: You can override default control like this: 
                 $.fn.MultiFile.options.accept = 'gif|jpg'; 
         */ 
         $.fn.MultiFile.options = { //$.extend($.fn.MultiFile, { options: { 
                 accept: '', // accepted file extensions 
                 max: -1,    // maximum number of selectable files 
                  
                 // name to use for newly created elements 
                 namePattern: '$name', // same name by default (which creates an array) 
                  
                 // STRING: collection lets you show messages in different languages 
                 STRING: { 
                         remove:'x', 
                         denied:'You cannot select a $ext file.\nTry again...', 
                         file:'$file', 
                         selected:'File selected: $file', 
                         duplicate:'This file has already been selected:\n$file' 
                 }, 
                  
                 // name of methods that should be automcatically intercepted so the plugin can disable 
                 // extra file elements that are empty before execution and automatically re-enable them afterwards 
   autoIntercept: [ 'submit', 'ajaxSubmit', 'ajaxForm', 'validate', 'valid' /* array of methods to intercept */ ], 
                  
                 // error handling function 
                 error: function(s){ 
                         /* 
                         ERROR! blockUI is not currently working in IE 
                         if($.blockUI){ 
                                 $.blockUI({ 
                                         message: s.replace(/\n/gi,'<br/>'), 
                                         css: {  
                                                 border:'none', padding:'15px', size:'12.0pt', 
                                                 backgroundColor:'#900', color:'#fff', 
                                                 opacity:'.8','-webkit-border-radius': '10px','-moz-border-radius': '10px' 
                                         } 
                                 }); 
                                 window.setTimeout($.unblockUI, 2000); 
                         } 
                         else//{// save a byte! 
                         */ 
                          alert(s); 
                         //}// save a byte! 
                 } 
  }; //} }); 
          
         /*--------------------------------------------------------*/ 
          
         /* 
                 ### Additional Methods ### 
                 Required functionality outside the plugin's scope 
         */ 
          
         // Native input reset method - because this alone doesn't always work: $(element).val('').attr('value', '')[0].value = ''; 
         $.fn.reset = function(){ return this.each(function(){ try{ this.reset(); }catch(e){} }); }; 
          
         /*--------------------------------------------------------*/ 
          
         /* 
                 ### Default implementation ### 
                 The plugin will attach itself to file inputs 
                 with the class 'multi' when the page loads 
         */ 
         $(function(){ 
   //$("input:file.multi").MultiFile(); 
   $("input[type=file].multi").MultiFile(); 
  }); 
          
          
          
 /*# AVOID COLLISIONS #*/ 
 })(jQuery); 
 /*# AVOID COLLISIONS #*/