/*
SWFObject v2.2 <http://code.google.com/p/swfobject/> 
is released under the MIT License <http://www.opensource.org/licenses/mit-license.php> 
*/
;
var swfobject=function(){
    var D="undefined",r="object",S="Shockwave Flash",W="ShockwaveFlash.ShockwaveFlash",q="application/x-shockwave-flash",R="SWFObjectExprInst",x="onreadystatechange",O=window,j=document,t=navigator,T=false,U=[h],o=[],N=[],I=[],l,Q,E,B,J=false,a=false,n,G,m=true,M=function(){
        var aa=typeof j.getElementById!=D&&typeof j.getElementsByTagName!=D&&typeof j.createElement!=D,ah=t.userAgent.toLowerCase(),Y=t.platform.toLowerCase(),ae=Y?/win/.test(Y):/win/.test(ah),ac=Y?/mac/.test(Y):/mac/.test(ah),af=/webkit/.test(ah)?parseFloat(ah.replace(/^.*webkit\/(\d+(\.\d+)?).*$/,"$1")):false,X=!+"\v1",ag=[0,0,0],ab=null;
        if(typeof t.plugins!=D&&typeof t.plugins[S]==r){
            ab=t.plugins[S].description;
            if(ab&&!(typeof t.mimeTypes!=D&&t.mimeTypes[q]&&!t.mimeTypes[q].enabledPlugin)){
                T=true;
                X=false;
                ab=ab.replace(/^.*\s+(\S+\s+\S+$)/,"$1");
                ag[0]=parseInt(ab.replace(/^(.*)\..*$/,"$1"),10);
                ag[1]=parseInt(ab.replace(/^.*\.(.*)\s.*$/,"$1"),10);
                ag[2]=/[a-zA-Z]/.test(ab)?parseInt(ab.replace(/^.*[a-zA-Z]+(.*)$/,"$1"),10):0;
            }
        }else{
        if(typeof O.ActiveXObject!=D){
            try{
                var ad=new ActiveXObject(W);
                if(ad){
                    ab=ad.GetVariable("$version");
                    if(ab){
                        X=true;
                        ab=ab.split(" ")[1].split(",");
                        ag=[parseInt(ab[0],10),parseInt(ab[1],10),parseInt(ab[2],10)];
                    }
                }
            }catch(Z){}
}
}
return{
    w3:aa,
    pv:ag,
    wk:af,
    ie:X,
    win:ae,
    mac:ac
};
}(),k=function(){
    if(!M.w3){
        return;
    }
    if((typeof j.readyState!=D&&j.readyState=="complete")||(typeof j.readyState==D&&(j.getElementsByTagName("body")[0]||j.body))){
        f();
    }
    if(!J){
        if(typeof j.addEventListener!=D){
            j.addEventListener("DOMContentLoaded",f,false);
        }
        if(M.ie&&M.win){
            j.attachEvent(x,function(){
                if(j.readyState=="complete"){
                    j.detachEvent(x,arguments.callee);
                    f();
                }
            });
        if(O==top){
            (function(){
                if(J){
                    return;
                }
                try{
                    j.documentElement.doScroll("left");
                }catch(X){
                    setTimeout(arguments.callee,0);
                    return;
                }
                f();
            })();
        }
    }
    if(M.wk){
    (function(){
        if(J){
            return;
        }
        if(!/loaded|complete/.test(j.readyState)){
            setTimeout(arguments.callee,0);
            return;
        }
        f();
    })();
}
s(f);
}
}();
function f(){
    if(J){
        return;
    }
    try{
        var Z=j.getElementsByTagName("body")[0].appendChild(C("span"));
        Z.parentNode.removeChild(Z);
    }catch(aa){
        return;
    }
    J=true;
    var X=U.length;
    for(var Y=0;Y<X;Y++){
        U[Y]();
    }
    }
    function K(X){
    if(J){
        X();
    }else{
        U[U.length]=X;
    }
}
function s(Y){
    if(typeof O.addEventListener!=D){
        O.addEventListener("load",Y,false);
    }else{
        if(typeof j.addEventListener!=D){
            j.addEventListener("load",Y,false);
        }else{
            if(typeof O.attachEvent!=D){
                i(O,"onload",Y);
            }else{
                if(typeof O.onload=="function"){
                    var X=O.onload;
                    O.onload=function(){
                        X();
                        Y();
                    };
                
            }else{
                O.onload=Y;
            }
        }
    }
}
}
function h(){
    if(T){
        V();
    }else{
        H();
    }
}
function V(){
    var X=j.getElementsByTagName("body")[0];
    var aa=C(r);
    aa.setAttribute("type",q);
    var Z=X.appendChild(aa);
    if(Z){
        var Y=0;
        (function(){
            if(typeof Z.GetVariable!=D){
                var ab=Z.GetVariable("$version");
                if(ab){
                    ab=ab.split(" ")[1].split(",");
                    M.pv=[parseInt(ab[0],10),parseInt(ab[1],10),parseInt(ab[2],10)];
                }
            }else{
            if(Y<10){
                Y++;
                setTimeout(arguments.callee,10);
                return;
            }
        }
        X.removeChild(aa);
        Z=null;
        H();
    })();
}else{
    H();
}
}
function H(){
    var ag=o.length;
    if(ag>0){
        for(var af=0;af<ag;af++){
            var Y=o[af].id;
            var ab=o[af].callbackFn;
            var aa={
                success:false,
                id:Y
            };
            
            if(M.pv[0]>0){
                var ae=c(Y);
                if(ae){
                    if(F(o[af].swfVersion)&&!(M.wk&&M.wk<312)){
                        w(Y,true);
                        if(ab){
                            aa.success=true;
                            aa.ref=z(Y);
                            ab(aa);
                        }
                    }else{
                    if(o[af].expressInstall&&A()){
                        var ai={};
                        
                        ai.data=o[af].expressInstall;
                        ai.width=ae.getAttribute("width")||"0";
                        ai.height=ae.getAttribute("height")||"0";
                        if(ae.getAttribute("class")){
                            ai.styleclass=ae.getAttribute("class");
                        }
                        if(ae.getAttribute("align")){
                            ai.align=ae.getAttribute("align");
                        }
                        var ah={};
                        
                        var X=ae.getElementsByTagName("param");
                        var ac=X.length;
                        for(var ad=0;ad<ac;ad++){
                            if(X[ad].getAttribute("name").toLowerCase()!="movie"){
                                ah[X[ad].getAttribute("name")]=X[ad].getAttribute("value");
                            }
                        }
                        P(ai,ah,Y,ab);
                }else{
                    p(ae);
                    if(ab){
                        ab(aa);
                    }
                }
            }
        }
}else{
    w(Y,true);
    if(ab){
        var Z=z(Y);
        if(Z&&typeof Z.SetVariable!=D){
            aa.success=true;
            aa.ref=Z;
        }
        ab(aa);
    }
}
}
}
}
function z(aa){
    var X=null;
    var Y=c(aa);
    if(Y&&Y.nodeName=="OBJECT"){
        if(typeof Y.SetVariable!=D){
            X=Y;
        }else{
            var Z=Y.getElementsByTagName(r)[0];
            if(Z){
                X=Z;
            }
        }
    }
return X;
}
function A(){
    return !a&&F("6.0.65")&&(M.win||M.mac)&&!(M.wk&&M.wk<312);
}
function P(aa,ab,X,Z){
    a=true;
    E=Z||null;
    B={
        success:false,
        id:X
    };
    
    var ae=c(X);
    if(ae){
        if(ae.nodeName=="OBJECT"){
            l=g(ae);
            Q=null;
        }else{
            l=ae;
            Q=X;
        }
        aa.id=R;
        if(typeof aa.width==D||(!/%$/.test(aa.width)&&parseInt(aa.width,10)<310)){
            aa.width="310";
        }
        if(typeof aa.height==D||(!/%$/.test(aa.height)&&parseInt(aa.height,10)<137)){
            aa.height="137";
        }
        j.title=j.title.slice(0,47)+" - Flash Player Installation";
        var ad=M.ie&&M.win?"ActiveX":"PlugIn",ac="MMredirectURL="+O.location.toString().replace(/&/g,"%26")+"&MMplayerType="+ad+"&MMdoctitle="+j.title;
        if(typeof ab.flashvars!=D){
            ab.flashvars+="&"+ac;
        }else{
            ab.flashvars=ac;
        }
        if(M.ie&&M.win&&ae.readyState!=4){
            var Y=C("div");
            X+="SWFObjectNew";
            Y.setAttribute("id",X);
            ae.parentNode.insertBefore(Y,ae);
            ae.style.display="none";
            (function(){
                if(ae.readyState==4){
                    ae.parentNode.removeChild(ae);
                }else{
                    setTimeout(arguments.callee,10);
                }
            })();
    }
    u(aa,ab,X);
}
}
function p(Y){
    if(M.ie&&M.win&&Y.readyState!=4){
        var X=C("div");
        Y.parentNode.insertBefore(X,Y);
        X.parentNode.replaceChild(g(Y),X);
        Y.style.display="none";
        (function(){
            if(Y.readyState==4){
                Y.parentNode.removeChild(Y);
            }else{
                setTimeout(arguments.callee,10);
            }
        })();
}else{
    Y.parentNode.replaceChild(g(Y),Y);
}
}
function g(ab){
    var aa=C("div");
    if(M.win&&M.ie){
        aa.innerHTML=ab.innerHTML;
    }else{
        var Y=ab.getElementsByTagName(r)[0];
        if(Y){
            var ad=Y.childNodes;
            if(ad){
                var X=ad.length;
                for(var Z=0;Z<X;Z++){
                    if(!(ad[Z].nodeType==1&&ad[Z].nodeName=="PARAM")&&!(ad[Z].nodeType==8)){
                        aa.appendChild(ad[Z].cloneNode(true));
                    }
                }
                }
        }
}
return aa;
}
function u(ai,ag,Y){
    var X,aa=c(Y);
    if(M.wk&&M.wk<312){
        return X;
    }
    if(aa){
        if(typeof ai.id==D){
            ai.id=Y;
        }
        if(M.ie&&M.win){
            var ah="";
            for(var ae in ai){
                if(ai[ae]!=Object.prototype[ae]){
                    if(ae.toLowerCase()=="data"){
                        ag.movie=ai[ae];
                    }else{
                        if(ae.toLowerCase()=="styleclass"){
                            ah+=' class="'+ai[ae]+'"';
                        }else{
                            if(ae.toLowerCase()!="classid"){
                                ah+=" "+ae+'="'+ai[ae]+'"';
                            }
                        }
                    }
            }
            }
        var af="";
for(var ad in ag){
    if(ag[ad]!=Object.prototype[ad]){
        af+='<param name="'+ad+'" value="'+ag[ad]+'" />';
    }
}
aa.outerHTML='<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"'+ah+">"+af+"</object>";
N[N.length]=ai.id;
X=c(ai.id);
}else{
    var Z=C(r);
    Z.setAttribute("type",q);
    for(var ac in ai){
        if(ai[ac]!=Object.prototype[ac]){
            if(ac.toLowerCase()=="styleclass"){
                Z.setAttribute("class",ai[ac]);
            }else{
                if(ac.toLowerCase()!="classid"){
                    Z.setAttribute(ac,ai[ac]);
                }
            }
        }
    }
    for(var ab in ag){
    if(ag[ab]!=Object.prototype[ab]&&ab.toLowerCase()!="movie"){
        e(Z,ab,ag[ab]);
    }
}
aa.parentNode.replaceChild(Z,aa);
X=Z;
}
}
return X;
}
function e(Z,X,Y){
    var aa=C("param");
    aa.setAttribute("name",X);
    aa.setAttribute("value",Y);
    Z.appendChild(aa);
}
function y(Y){
    var X=c(Y);
    if(X&&X.nodeName=="OBJECT"){
        if(M.ie&&M.win){
            X.style.display="none";
            (function(){
                if(X.readyState==4){
                    b(Y);
                }else{
                    setTimeout(arguments.callee,10);
                }
            })();
    }else{
        X.parentNode.removeChild(X);
    }
}
}
function b(Z){
    var Y=c(Z);
    if(Y){
        for(var X in Y){
            if(typeof Y[X]=="function"){
                Y[X]=null;
            }
        }
        Y.parentNode.removeChild(Y);
}
}
function c(Z){
    var X=null;
    try{
        X=j.getElementById(Z);
    }catch(Y){}
    return X;
}
function C(X){
    return j.createElement(X);
}
function i(Z,X,Y){
    Z.attachEvent(X,Y);
    I[I.length]=[Z,X,Y];
}
function F(Z){
    var Y=M.pv,X=Z.split(".");
    X[0]=parseInt(X[0],10);
    X[1]=parseInt(X[1],10)||0;
    X[2]=parseInt(X[2],10)||0;
    return(Y[0]>X[0]||(Y[0]==X[0]&&Y[1]>X[1])||(Y[0]==X[0]&&Y[1]==X[1]&&Y[2]>=X[2]))?true:false;
}
function v(ac,Y,ad,ab){
    if(M.ie&&M.mac){
        return;
    }
    var aa=j.getElementsByTagName("head")[0];
    if(!aa){
        return;
    }
    var X=(ad&&typeof ad=="string")?ad:"screen";
    if(ab){
        n=null;
        G=null;
    }
    if(!n||G!=X){
        var Z=C("style");
        Z.setAttribute("type","text/css");
        Z.setAttribute("media",X);
        n=aa.appendChild(Z);
        if(M.ie&&M.win&&typeof j.styleSheets!=D&&j.styleSheets.length>0){
            n=j.styleSheets[j.styleSheets.length-1];
        }
        G=X;
    }
    if(M.ie&&M.win){
        if(n&&typeof n.addRule==r){
            n.addRule(ac,Y);
        }
    }else{
    if(n&&typeof j.createTextNode!=D){
        n.appendChild(j.createTextNode(ac+" {"+Y+"}"));
    }
}
}
function w(Z,X){
    if(!m){
        return;
    }
    var Y=X?"visible":"hidden";
    if(J&&c(Z)){
        c(Z).style.visibility=Y;
    }else{
        v("#"+Z,"visibility:"+Y);
    }
}
function L(Y){
    var Z=/[\\\"<>\.;]/;
    var X=Z.exec(Y)!=null;
    return X&&typeof encodeURIComponent!=D?encodeURIComponent(Y):Y;
}
var d=function(){
    if(M.ie&&M.win){
        window.attachEvent("onunload",function(){
            var ac=I.length;
            for(var ab=0;ab<ac;ab++){
                I[ab][0].detachEvent(I[ab][1],I[ab][2]);
            }
            var Z=N.length;
            for(var aa=0;aa<Z;aa++){
                y(N[aa]);
            }
            for(var Y in M){
                M[Y]=null;
            }
            M=null;
            for(var X in swfobject){
                swfobject[X]=null;
            }
            swfobject=null;
        });
    }
}();
return{
    registerObject:function(ab,X,aa,Z){
        if(M.w3&&ab&&X){
            var Y={};
            
            Y.id=ab;
            Y.swfVersion=X;
            Y.expressInstall=aa;
            Y.callbackFn=Z;
            o[o.length]=Y;
            w(ab,false);
        }else{
            if(Z){
                Z({
                    success:false,
                    id:ab
                });
            }
        }
    },
getObjectById:function(X){
    if(M.w3){
        return z(X);
    }
},
embedSWF:function(ab,ah,ae,ag,Y,aa,Z,ad,af,ac){
    var X={
        success:false,
        id:ah
    };
    if(M.w3&&!(M.wk&&M.wk<312)&&ab&&ah&&ae&&ag&&Y){
        w(ah,false);
        K(function(){
            ae+="";
            ag+="";
            var aj={};
            
            if(af&&typeof af===r){
                for(var al in af){
                    aj[al]=af[al];
                }
                }
                aj.data=ab;
        aj.width=ae;
        aj.height=ag;
        var am={};
        
        if(ad&&typeof ad===r){
            for(var ak in ad){
                am[ak]=ad[ak];
            }
            }
            if(Z&&typeof Z===r){
            for(var ai in Z){
                if(typeof am.flashvars!=D){
                    am.flashvars+="&"+ai+"="+Z[ai];
                }else{
                    am.flashvars=ai+"="+Z[ai];
                }
            }
            }
            if(F(Y)){
    var an=u(aj,am,ah);
    if(aj.id==ah){
        w(ah,true);
    }
    X.success=true;
    X.ref=an;
}else{
    if(aa&&A()){
        aj.data=aa;
        P(aj,am,ah,ac);
        return;
    }else{
        w(ah,true);
    }
}
if(ac){
    ac(X);
}
});
}else{
    if(ac){
        ac(X);
    }
}
},
switchOffAutoHideShow:function(){
    m=false;
},
ua:M,
getFlashPlayerVersion:function(){
    return{
        major:M.pv[0],
        minor:M.pv[1],
        release:M.pv[2]
        };
},
hasFlashPlayerVersion:F,
createSWF:function(Z,Y,X){
    if(M.w3){
        return u(Z,Y,X);
    }else{
        return undefined;
    }
},
showExpressInstall:function(Z,aa,X,Y){
    if(M.w3&&A()){
        P(Z,aa,X,Y);
    }
},
removeSWF:function(X){
    if(M.w3){
        y(X);
    }
},
createCSS:function(aa,Z,Y,X){
    if(M.w3){
        v(aa,Z,Y,X);
    }
},
addDomLoadEvent:K,
addLoadEvent:s,
getQueryParamValue:function(aa){
    var Z=j.location.search||j.location.hash;
    if(Z){
        if(/\?/.test(Z)){
            Z=Z.split("?")[1];
        }
        if(aa==null){
            return L(Z);
        }
        var Y=Z.split("&");
        for(var X=0;X<Y.length;X++){
            if(Y[X].substring(0,Y[X].indexOf("="))==aa){
                return L(Y[X].substring((Y[X].indexOf("=")+1)));
            }
        }
        }
    return"";
},
expressInstallCallback:function(){
    if(a){
        var X=c(R);
        if(X&&l){
            X.parentNode.replaceChild(l,X);
            if(Q){
                w(Q,true);
                if(M.ie&&M.win){
                    l.style.display="block";
                }
            }
            if(E){
            E(B);
        }
    }
    a=false;
}
}
};

}();

/*
SWFUpload: http://www.swfupload.org, http://swfupload.googlecode.com

mmSWFUpload 1.0: Flash upload dialog - http://profandesign.se/swfupload/,  http://www.vinterwebb.se/

SWFUpload is (c) 2006-2007 Lars Huring, Olov Nilzén and Mammon Media and is released under the MIT License:
http://www.opensource.org/licenses/mit-license.php
 
SWFUpload 2 is (c) 2007-2008 Jake Roberts and is released under the MIT License:
http://www.opensource.org/licenses/mit-license.php
*/

var SWFUpload;
if(SWFUpload==undefined){
    SWFUpload=function(a){
        this.initSWFUpload(a)
        }
    }
    SWFUpload.prototype.initSWFUpload=function(b){
    try{
        this.customSettings={};
        
        this.settings=b;
        this.eventQueue=[];
        this.movieName="SWFUpload_"+SWFUpload.movieCount++;
        this.movieElement=null;
        SWFUpload.instances[this.movieName]=this;
        this.initSettings();
        this.loadFlash();
        this.displayDebugInfo()
        }catch(a){
        delete SWFUpload.instances[this.movieName];
        throw a
        }
    };

SWFUpload.instances={};
    
SWFUpload.movieCount=0;
SWFUpload.version="2.2.0 2009-03-25";
SWFUpload.QUEUE_ERROR={
    QUEUE_LIMIT_EXCEEDED:-100,
    FILE_EXCEEDS_SIZE_LIMIT:-110,
    ZERO_BYTE_FILE:-120,
    INVALID_FILETYPE:-130
};

SWFUpload.UPLOAD_ERROR={
    HTTP_ERROR:-200,
    MISSING_UPLOAD_URL:-210,
    IO_ERROR:-220,
    SECURITY_ERROR:-230,
    UPLOAD_LIMIT_EXCEEDED:-240,
    UPLOAD_FAILED:-250,
    SPECIFIED_FILE_ID_NOT_FOUND:-260,
    FILE_VALIDATION_FAILED:-270,
    FILE_CANCELLED:-280,
    UPLOAD_STOPPED:-290
};

SWFUpload.FILE_STATUS={
    QUEUED:-1,
    IN_PROGRESS:-2,
    ERROR:-3,
    COMPLETE:-4,
    CANCELLED:-5
};

SWFUpload.BUTTON_ACTION={
    SELECT_FILE:-100,
    SELECT_FILES:-110,
    START_UPLOAD:-120
};

SWFUpload.CURSOR={
    ARROW:-1,
    HAND:-2
};

SWFUpload.WINDOW_MODE={
    WINDOW:"window",
    TRANSPARENT:"transparent",
    OPAQUE:"opaque"
};

SWFUpload.completeURL=function(a){
    if(typeof(a)!=="string"||a.match(/^https?:\/\//i)||a.match(/^\//)){
        return a
        }
        var c=window.location.protocol+"//"+window.location.hostname+(window.location.port?":"+window.location.port:"");
    var b=window.location.pathname.lastIndexOf("/");
    if(b<=0){
        path="/"
        }else{
        path=window.location.pathname.substr(0,b)+"/"
        }
        return path+a
    };
    
SWFUpload.prototype.initSettings=function(){
    this.ensureDefault=function(b,a){
        this.settings[b]=(this.settings[b]==undefined)?a:this.settings[b]
        };
        
    this.ensureDefault("upload_url","");
    this.ensureDefault("preserve_relative_urls",false);
    this.ensureDefault("file_post_name","Filedata");
    this.ensureDefault("post_params",{});
    this.ensureDefault("use_query_string",false);
    this.ensureDefault("requeue_on_error",false);
    this.ensureDefault("http_success",[]);
    this.ensureDefault("assume_success_timeout",0);
    this.ensureDefault("file_types","*.*");
    this.ensureDefault("file_types_description","All Files");
    this.ensureDefault("file_size_limit",0);
    this.ensureDefault("file_upload_limit",0);
    this.ensureDefault("file_queue_limit",0);
    this.ensureDefault("flash_url","swfupload.swf");
    this.ensureDefault("prevent_swf_caching",true);
    this.ensureDefault("button_image_url","");
    this.ensureDefault("button_width",1);
    this.ensureDefault("button_height",1);
    this.ensureDefault("button_text","");
    this.ensureDefault("button_text_style","color: #000000; font-size: 16pt;");
    this.ensureDefault("button_text_top_padding",0);
    this.ensureDefault("button_text_left_padding",0);
    this.ensureDefault("button_action",SWFUpload.BUTTON_ACTION.SELECT_FILES);
    this.ensureDefault("button_disabled",false);
    this.ensureDefault("button_placeholder_id","");
    this.ensureDefault("button_placeholder",null);
    this.ensureDefault("button_cursor",SWFUpload.CURSOR.ARROW);
    this.ensureDefault("button_window_mode",SWFUpload.WINDOW_MODE.WINDOW);
    this.ensureDefault("debug",false);
    this.settings.debug_enabled=this.settings.debug;
    this.settings.return_upload_start_handler=this.returnUploadStart;
    this.ensureDefault("swfupload_loaded_handler",null);
    this.ensureDefault("file_dialog_start_handler",null);
    this.ensureDefault("file_queued_handler",null);
    this.ensureDefault("file_queue_error_handler",null);
    this.ensureDefault("file_dialog_complete_handler",null);
    this.ensureDefault("upload_start_handler",null);
    this.ensureDefault("upload_progress_handler",null);
    this.ensureDefault("upload_error_handler",null);
    this.ensureDefault("upload_success_handler",null);
    this.ensureDefault("upload_complete_handler",null);
    this.ensureDefault("debug_handler",this.debugMessage);
    this.ensureDefault("custom_settings",{});
    this.customSettings=this.settings.custom_settings;
    if(!!this.settings.prevent_swf_caching){
        this.settings.flash_url=this.settings.flash_url+(this.settings.flash_url.indexOf("?")<0?"?":"&")+"preventswfcaching="+new Date().getTime()
        }
        if(!this.settings.preserve_relative_urls){
        this.settings.upload_url=SWFUpload.completeURL(this.settings.upload_url);
        this.settings.button_image_url=SWFUpload.completeURL(this.settings.button_image_url)
        }
        delete this.ensureDefault
    };
    
SWFUpload.prototype.loadFlash=function(){
    var a,b;
    if(document.getElementById(this.movieName)!==null){
        throw"ID "+this.movieName+" is already in use. The Flash Object could not be added"
        }
        a=document.getElementById(this.settings.button_placeholder_id)||this.settings.button_placeholder;
    if(a==undefined){
        throw"Could not find the placeholder element: "+this.settings.button_placeholder_id
        }
        b=document.createElement("div");
    b.innerHTML=this.getFlashHTML();
    a.parentNode.replaceChild(b.firstChild,a);
    if(window[this.movieName]==undefined){
        window[this.movieName]=this.getMovieElement()
        }
    };

SWFUpload.prototype.getFlashHTML=function(){
    return['<object id="',this.movieName,'" type="application/x-shockwave-flash" data="',this.settings.flash_url,'" width="',this.settings.button_width,'" height="',this.settings.button_height,'" class="swfupload">','<param name="wmode" value="',this.settings.button_window_mode,'" />','<param name="movie" value="',this.settings.flash_url,'" />','<param name="quality" value="high" />','<param name="menu" value="false" />','<param name="allowScriptAccess" value="always" />','<param name="flashvars" value="'+this.getFlashVars()+'" />',"</object>"].join("")
    };
    
SWFUpload.prototype.getFlashVars=function(){
    var b=this.buildParamString();
    var a=this.settings.http_success.join(",");
    return["movieName=",encodeURIComponent(this.movieName),"&amp;uploadURL=",encodeURIComponent(this.settings.upload_url),"&amp;useQueryString=",encodeURIComponent(this.settings.use_query_string),"&amp;requeueOnError=",encodeURIComponent(this.settings.requeue_on_error),"&amp;httpSuccess=",encodeURIComponent(a),"&amp;assumeSuccessTimeout=",encodeURIComponent(this.settings.assume_success_timeout),"&amp;params=",encodeURIComponent(b),"&amp;filePostName=",encodeURIComponent(this.settings.file_post_name),"&amp;fileTypes=",encodeURIComponent(this.settings.file_types),"&amp;fileTypesDescription=",encodeURIComponent(this.settings.file_types_description),"&amp;fileSizeLimit=",encodeURIComponent(this.settings.file_size_limit),"&amp;fileUploadLimit=",encodeURIComponent(this.settings.file_upload_limit),"&amp;fileQueueLimit=",encodeURIComponent(this.settings.file_queue_limit),"&amp;debugEnabled=",encodeURIComponent(this.settings.debug_enabled),"&amp;buttonImageURL=",encodeURIComponent(this.settings.button_image_url),"&amp;buttonWidth=",encodeURIComponent(this.settings.button_width),"&amp;buttonHeight=",encodeURIComponent(this.settings.button_height),"&amp;buttonText=",encodeURIComponent(this.settings.button_text),"&amp;buttonTextTopPadding=",encodeURIComponent(this.settings.button_text_top_padding),"&amp;buttonTextLeftPadding=",encodeURIComponent(this.settings.button_text_left_padding),"&amp;buttonTextStyle=",encodeURIComponent(this.settings.button_text_style),"&amp;buttonAction=",encodeURIComponent(this.settings.button_action),"&amp;buttonDisabled=",encodeURIComponent(this.settings.button_disabled),"&amp;buttonCursor=",encodeURIComponent(this.settings.button_cursor)].join("")
    };
    
SWFUpload.prototype.getMovieElement=function(){
    if(this.movieElement==undefined){
        this.movieElement=document.getElementById(this.movieName)
        }
        if(this.movieElement===null){
        throw"Could not find Flash element"
        }
        return this.movieElement
    };
    
SWFUpload.prototype.buildParamString=function(){
    var c=this.settings.post_params;
    var b=[];
    if(typeof(c)==="object"){
        for(var a in c){
            if(c.hasOwnProperty(a)){
                b.push(encodeURIComponent(a.toString())+"="+encodeURIComponent(c[a].toString()))
                }
            }
        }
        return b.join("&amp;")
};

SWFUpload.prototype.destroy=function(){
    try{
        this.cancelUpload(null,false);
        var a=null;
        a=this.getMovieElement();
        if(a&&typeof(a.CallFunction)==="unknown"){
            for(var c in a){
                try{
                    if(typeof(a[c])==="function"){
                        a[c]=null
                        }
                    }catch(e){}
                }
                try{
        a.parentNode.removeChild(a)
        }catch(b){}
}
window[this.movieName]=null;
SWFUpload.instances[this.movieName]=null;
delete SWFUpload.instances[this.movieName];
this.movieElement=null;
this.settings=null;
this.customSettings=null;
this.eventQueue=null;
this.movieName=null;
return true
}catch(d){
    return false
    }
};

SWFUpload.prototype.displayDebugInfo=function(){
    this.debug(["---SWFUpload Instance Info---\n","Version: ",SWFUpload.version,"\n","Movie Name: ",this.movieName,"\n","Settings:\n","\t","upload_url:               ",this.settings.upload_url,"\n","\t","flash_url:                ",this.settings.flash_url,"\n","\t","use_query_string:         ",this.settings.use_query_string.toString(),"\n","\t","requeue_on_error:         ",this.settings.requeue_on_error.toString(),"\n","\t","http_success:             ",this.settings.http_success.join(", "),"\n","\t","assume_success_timeout:   ",this.settings.assume_success_timeout,"\n","\t","file_post_name:           ",this.settings.file_post_name,"\n","\t","post_params:              ",this.settings.post_params.toString(),"\n","\t","file_types:               ",this.settings.file_types,"\n","\t","file_types_description:   ",this.settings.file_types_description,"\n","\t","file_size_limit:          ",this.settings.file_size_limit,"\n","\t","file_upload_limit:        ",this.settings.file_upload_limit,"\n","\t","file_queue_limit:         ",this.settings.file_queue_limit,"\n","\t","debug:                    ",this.settings.debug.toString(),"\n","\t","prevent_swf_caching:      ",this.settings.prevent_swf_caching.toString(),"\n","\t","button_placeholder_id:    ",this.settings.button_placeholder_id.toString(),"\n","\t","button_placeholder:       ",(this.settings.button_placeholder?"Set":"Not Set"),"\n","\t","button_image_url:         ",this.settings.button_image_url.toString(),"\n","\t","button_width:             ",this.settings.button_width.toString(),"\n","\t","button_height:            ",this.settings.button_height.toString(),"\n","\t","button_text:              ",this.settings.button_text.toString(),"\n","\t","button_text_style:        ",this.settings.button_text_style.toString(),"\n","\t","button_text_top_padding:  ",this.settings.button_text_top_padding.toString(),"\n","\t","button_text_left_padding: ",this.settings.button_text_left_padding.toString(),"\n","\t","button_action:            ",this.settings.button_action.toString(),"\n","\t","button_disabled:          ",this.settings.button_disabled.toString(),"\n","\t","custom_settings:          ",this.settings.custom_settings.toString(),"\n","Event Handlers:\n","\t","swfupload_loaded_handler assigned:  ",(typeof this.settings.swfupload_loaded_handler==="function").toString(),"\n","\t","file_dialog_start_handler assigned: ",(typeof this.settings.file_dialog_start_handler==="function").toString(),"\n","\t","file_queued_handler assigned:       ",(typeof this.settings.file_queued_handler==="function").toString(),"\n","\t","file_queue_error_handler assigned:  ",(typeof this.settings.file_queue_error_handler==="function").toString(),"\n","\t","upload_start_handler assigned:      ",(typeof this.settings.upload_start_handler==="function").toString(),"\n","\t","upload_progress_handler assigned:   ",(typeof this.settings.upload_progress_handler==="function").toString(),"\n","\t","upload_error_handler assigned:      ",(typeof this.settings.upload_error_handler==="function").toString(),"\n","\t","upload_success_handler assigned:    ",(typeof this.settings.upload_success_handler==="function").toString(),"\n","\t","upload_complete_handler assigned:   ",(typeof this.settings.upload_complete_handler==="function").toString(),"\n","\t","debug_handler assigned:             ",(typeof this.settings.debug_handler==="function").toString(),"\n"].join(""))
    };
    
SWFUpload.prototype.addSetting=function(b,c,a){
    if(c==undefined){
        return(this.settings[b]=a)
        }else{
        return(this.settings[b]=c)
        }
    };

SWFUpload.prototype.getSetting=function(a){
    if(this.settings[a]!=undefined){
        return this.settings[a]
        }
        return""
    };
    
SWFUpload.prototype.callFlash=function(functionName,argumentArray){
    argumentArray=argumentArray||[];
    var movieElement=this.getMovieElement();
    var returnValue,returnString;
    try{
        returnString=movieElement.CallFunction('<invoke name="'+functionName+'" returntype="javascript">'+__flash__argumentsToXML(argumentArray,0)+"</invoke>");
        returnValue=eval(returnString)
        }catch(ex){
        throw"Call to "+functionName+" failed"
        }
        if(returnValue!=undefined&&typeof returnValue.post==="object"){
        returnValue=this.unescapeFilePostParams(returnValue)
        }
        return returnValue
    };
    
SWFUpload.prototype.selectFile=function(){
    this.callFlash("SelectFile")
    };
    
SWFUpload.prototype.selectFiles=function(){
    this.callFlash("SelectFiles")
    };
    
SWFUpload.prototype.startUpload=function(a){
    this.callFlash("StartUpload",[a])
    };
    
SWFUpload.prototype.cancelUpload=function(a,b){
    if(b!==false){
        b=true
        }
        this.callFlash("CancelUpload",[a,b])
    };
    
SWFUpload.prototype.stopUpload=function(){
    this.callFlash("StopUpload")
    };
    
SWFUpload.prototype.getStats=function(){
    return this.callFlash("GetStats")
    };
    
SWFUpload.prototype.setStats=function(a){
    this.callFlash("SetStats",[a])
    };
    
SWFUpload.prototype.getFile=function(a){
    if(typeof(a)==="number"){
        return this.callFlash("GetFileByIndex",[a])
        }else{
        return this.callFlash("GetFile",[a])
        }
    };

SWFUpload.prototype.addFileParam=function(a,b,c){
    return this.callFlash("AddFileParam",[a,b,c])
    };
    
SWFUpload.prototype.removeFileParam=function(a,b){
    this.callFlash("RemoveFileParam",[a,b])
    };
    
SWFUpload.prototype.setUploadURL=function(a){
    this.settings.upload_url=a.toString();
    this.callFlash("SetUploadURL",[a])
    };
    
SWFUpload.prototype.setPostParams=function(a){
    this.settings.post_params=a;
    this.callFlash("SetPostParams",[a])
    };
    
SWFUpload.prototype.addPostParam=function(a,b){
    this.settings.post_params[a]=b;
    this.callFlash("SetPostParams",[this.settings.post_params])
    };
    
SWFUpload.prototype.removePostParam=function(a){
    delete this.settings.post_params[a];
    this.callFlash("SetPostParams",[this.settings.post_params])
    };
    
SWFUpload.prototype.setFileTypes=function(a,b){
    this.settings.file_types=a;
    this.settings.file_types_description=b;
    this.callFlash("SetFileTypes",[a,b])
    };
    
SWFUpload.prototype.setFileSizeLimit=function(a){
    this.settings.file_size_limit=a;
    this.callFlash("SetFileSizeLimit",[a])
    };
    
SWFUpload.prototype.setFileUploadLimit=function(a){
    this.settings.file_upload_limit=a;
    this.callFlash("SetFileUploadLimit",[a])
    };
    
SWFUpload.prototype.setFileQueueLimit=function(a){
    this.settings.file_queue_limit=a;
    this.callFlash("SetFileQueueLimit",[a])
    };
    
SWFUpload.prototype.setFilePostName=function(a){
    this.settings.file_post_name=a;
    this.callFlash("SetFilePostName",[a])
    };
    
SWFUpload.prototype.setUseQueryString=function(a){
    this.settings.use_query_string=a;
    this.callFlash("SetUseQueryString",[a])
    };
    
SWFUpload.prototype.setRequeueOnError=function(a){
    this.settings.requeue_on_error=a;
    this.callFlash("SetRequeueOnError",[a])
    };
    
SWFUpload.prototype.setHTTPSuccess=function(a){
    if(typeof a==="string"){
        a=a.replace(" ","").split(",")
        }
        this.settings.http_success=a;
    this.callFlash("SetHTTPSuccess",[a])
    };
    
SWFUpload.prototype.setAssumeSuccessTimeout=function(a){
    this.settings.assume_success_timeout=a;
    this.callFlash("SetAssumeSuccessTimeout",[a])
    };
    
SWFUpload.prototype.setDebugEnabled=function(a){
    this.settings.debug_enabled=a;
    this.callFlash("SetDebugEnabled",[a])
    };
    
SWFUpload.prototype.setButtonImageURL=function(a){
    if(a==undefined){
        a=""
        }
        this.settings.button_image_url=a;
    this.callFlash("SetButtonImageURL",[a])
    };
    
SWFUpload.prototype.setButtonDimensions=function(c,a){
    this.settings.button_width=c;
    this.settings.button_height=a;
    var b=this.getMovieElement();
    if(b!=undefined){
        b.style.width=c+"px";
        b.style.height=a+"px"
        }
        this.callFlash("SetButtonDimensions",[c,a])
    };
    
SWFUpload.prototype.setButtonText=function(a){
    this.settings.button_text=a;
    this.callFlash("SetButtonText",[a])
    };
    
SWFUpload.prototype.setButtonTextPadding=function(b,a){
    this.settings.button_text_top_padding=a;
    this.settings.button_text_left_padding=b;
    this.callFlash("SetButtonTextPadding",[b,a])
    };
    
SWFUpload.prototype.setButtonTextStyle=function(a){
    this.settings.button_text_style=a;
    this.callFlash("SetButtonTextStyle",[a])
    };
    
SWFUpload.prototype.setButtonDisabled=function(a){
    this.settings.button_disabled=a;
    this.callFlash("SetButtonDisabled",[a])
    };
    
SWFUpload.prototype.setButtonAction=function(a){
    this.settings.button_action=a;
    this.callFlash("SetButtonAction",[a])
    };
    
SWFUpload.prototype.setButtonCursor=function(a){
    this.settings.button_cursor=a;
    this.callFlash("SetButtonCursor",[a])
    };
    
SWFUpload.prototype.queueEvent=function(b,c){
    if(c==undefined){
        c=[]
        }else{
        if(!(c instanceof Array)){
            c=[c]
            }
        }
    var a=this;
if(typeof this.settings[b]==="function"){
    this.eventQueue.push(function(){
        this.settings[b].apply(this,c)
        });
    setTimeout(function(){
        a.executeNextEvent()
        },0)
    }else{
    if(this.settings[b]!==null){
        throw"Event handler "+b+" is unknown or is not a function"
        }
    }
};

SWFUpload.prototype.executeNextEvent=function(){
    var a=this.eventQueue?this.eventQueue.shift():null;
    if(typeof(a)==="function"){
        a.apply(this)
        }
    };

SWFUpload.prototype.unescapeFilePostParams=function(c){
    var e=/[$]([0-9a-f]{4})/i;
    var f={};
    
    var d;
    if(c!=undefined){
        for(var a in c.post){
            if(c.post.hasOwnProperty(a)){
                d=a;
                var b;
                while((b=e.exec(d))!==null){
                    d=d.replace(b[0],String.fromCharCode(parseInt("0x"+b[1],16)))
                    }
                    f[d]=c.post[a]
                }
            }
        c.post=f
    }
    return c
};

SWFUpload.prototype.testExternalInterface=function(){
    try{
        return this.callFlash("TestExternalInterface")
        }catch(a){
        return false
        }
    };

SWFUpload.prototype.flashReady=function(){
    var a=this.getMovieElement();
    if(!a){
        this.debug("Flash called back ready but the flash movie can't be found.");
        return
    }
    this.cleanUp(a);
    this.queueEvent("swfupload_loaded_handler")
    };
    
SWFUpload.prototype.cleanUp=function(a){
    try{
        if(this.movieElement&&typeof(a.CallFunction)==="unknown"){
            this.debug("Removing Flash functions hooks (this should only run in IE and should prevent memory leaks)");
            for(var c in a){
                try{
                    if(typeof(a[c])==="function"){
                        a[c]=null
                        }
                    }catch(b){}
                }
            }
    }catch(d){}
window.__flash__removeCallback=function(e,f){
    try{
        if(e){
            e[f]=null
            }
        }catch(g){}
}
};

SWFUpload.prototype.fileDialogStart=function(){
    this.queueEvent("file_dialog_start_handler")
    };
    
SWFUpload.prototype.fileQueued=function(a){
    a=this.unescapeFilePostParams(a);
    this.queueEvent("file_queued_handler",a)
    };
    
SWFUpload.prototype.fileQueueError=function(a,c,b){
    a=this.unescapeFilePostParams(a);
    this.queueEvent("file_queue_error_handler",[a,c,b])
    };
    
SWFUpload.prototype.fileDialogComplete=function(b,c,a){
    this.queueEvent("file_dialog_complete_handler",[b,c,a])
    };
    
SWFUpload.prototype.uploadStart=function(a){
    a=this.unescapeFilePostParams(a);
    this.queueEvent("return_upload_start_handler",a)
    };
    
SWFUpload.prototype.returnUploadStart=function(a){
    var b;
    if(typeof this.settings.upload_start_handler==="function"){
        a=this.unescapeFilePostParams(a);
        b=this.settings.upload_start_handler.call(this,a)
        }else{
        if(this.settings.upload_start_handler!=undefined){
            throw"upload_start_handler must be a function"
            }
        }
    if(b===undefined){
    b=true
    }
    b=!!b;
this.callFlash("ReturnUploadStart",[b])
    };
    
SWFUpload.prototype.uploadProgress=function(a,c,b){
    a=this.unescapeFilePostParams(a);
    this.queueEvent("upload_progress_handler",[a,c,b])
    };
    
SWFUpload.prototype.uploadError=function(a,c,b){
    a=this.unescapeFilePostParams(a);
    this.queueEvent("upload_error_handler",[a,c,b])
    };
    
SWFUpload.prototype.uploadSuccess=function(b,a,c){
    b=this.unescapeFilePostParams(b);
    this.queueEvent("upload_success_handler",[b,a,c])
    };
    
SWFUpload.prototype.uploadComplete=function(a){
    a=this.unescapeFilePostParams(a);
    this.queueEvent("upload_complete_handler",a)
    };
    
SWFUpload.prototype.debug=function(a){
    this.queueEvent("debug_handler",a)
    };
    
SWFUpload.prototype.debugMessage=function(c){
    if(this.settings.debug){
        var a,d=[];
        if(typeof c==="object"&&typeof c.name==="string"&&typeof c.message==="string"){
            for(var b in c){
                if(c.hasOwnProperty(b)){
                    d.push(b+": "+c[b])
                    }
                }
            a=d.join("\n")||"";
        d=a.split("\n");
        a="EXCEPTION: "+d.join("\nEXCEPTION: ");
        SWFUpload.Console.writeLine(a)
        }else{
        SWFUpload.Console.writeLine(c)
        }
    }
};

SWFUpload.Console={};
    
SWFUpload.Console.writeLine=function(d){
    var b,a;
    try{
        b=document.getElementById("SWFUpload_Console");
        if(!b){
            a=document.createElement("form");
            document.getElementsByTagName("body")[0].appendChild(a);
            b=document.createElement("textarea");
            b.id="SWFUpload_Console";
            b.style.fontFamily="monospace";
            b.setAttribute("wrap","off");
            b.wrap="off";
            b.style.overflow="auto";
            b.style.width="700px";
            b.style.height="350px";
            b.style.margin="5px";
            a.appendChild(b)
            }
            b.value+=d+"\n";
        b.scrollTop=b.scrollHeight-b.clientHeight
        }catch(c){
        alert("Exception: "+c.name+" Message: "+c.message)
        }
    };

/*
Uploadify v3.2
Copyright (c) 2012 Reactive Apps, Ronnie Garcia
Released under the MIT License <http://www.opensource.org/licenses/mit-license.php> 
*/

(function($) {

    // These methods can be called by adding them as the first argument in the uploadify plugin call
    var methods = {

        init : function(options, swfUploadOptions) {
			
            return this.each(function() {

                // Create a reference to the jQuery DOM object
                var $this = $(this);

                // Clone the original DOM object
                var $clone = $this.clone();

                // Setup the default options
                var settings = $.extend({
                    // Required Settings
                    id       : $this.attr('id'), // The ID of the DOM object
                    swf      : 'uploadify.swf',  // The path to the uploadify SWF file
                    uploader : 'uploadify.php',  // The path to the server-side upload script
					
                    // Options
                    auto            : true,               // Automatically upload files when added to the queue
                    buttonClass     : '',                 // A class name to add to the browse button DOM object
                    buttonCursor    : 'hand',             // The cursor to use with the browse button
                    buttonImage     : null,               // (String or null) The path to an image to use for the Flash browse button if not using CSS to style the button
                    buttonText      : 'SELECT FILES',     // The text to use for the browse button
                    checkExisting   : false,              // The path to a server-side script that checks for existing files on the server
                    debug           : false,              // Turn on swfUpload debugging mode
                    fileObjName     : 'Filedata',         // The name of the file object to use in your server-side script
                    fileSizeLimit   : 0,                  // The maximum size of an uploadable file in KB (Accepts units B KB MB GB if string, 0 for no limit)
                    fileTypeDesc    : 'All Files',        // The description for file types in the browse dialog
                    fileTypeExts    : '*.*',              // Allowed extensions in the browse dialog (server-side validation should also be used)
                    height          : 30,                 // The height of the browse button
                    itemTemplate    : false,              // The template for the file item in the queue
                    method          : 'post',             // The method to use when sending files to the server-side upload script
                    multi           : true,               // Allow multiple file selection in the browse dialog
                    formData        : {},                 // An object with additional data to send to the server-side upload script with every file upload
                    preventCaching  : true,               // Adds a random value to the Flash URL to prevent caching of it (conflicts with existing parameters)
                    progressData    : 'percentage',       // ('percentage' or 'speed') Data to show in the queue item during a file upload
                    queueID         : false,              // The ID of the DOM object to use as a file queue (without the #)
                    queueSizeLimit  : 999,                // The maximum number of files that can be in the queue at one time
                    removeCompleted : true,               // Remove queue items from the queue when they are done uploading
                    removeTimeout   : 3,                  // The delay in seconds before removing a queue item if removeCompleted is set to true
                    requeueErrors   : false,              // Keep errored files in the queue and keep trying to upload them
                    successTimeout  : 30,                 // The number of seconds to wait for Flash to detect the server's response after the file has finished uploading
                    uploadLimit     : 0,                  // The maximum number of files you can upload
                    width           : 120,                // The width of the browse button
					
                    // Events
                    overrideEvents  : []             // (Array) A list of default event handlers to skip
                /*
					onCancel         // Triggered when a file is cancelled from the queue
					onClearQueue     // Triggered during the 'clear queue' method
					onDestroy        // Triggered when the uploadify object is destroyed
					onDialogClose    // Triggered when the browse dialog is closed
					onDialogOpen     // Triggered when the browse dialog is opened
					onDisable        // Triggered when the browse button gets disabled
					onEnable         // Triggered when the browse button gets enabled
					onFallback       // Triggered is Flash is not detected    
					onInit           // Triggered when Uploadify is initialized
					onQueueComplete  // Triggered when all files in the queue have been uploaded
					onSelectError    // Triggered when an error occurs while selecting a file (file size, queue size limit, etc.)
					onSelect         // Triggered for each file that is selected
					onSWFReady       // Triggered when the SWF button is loaded
					onUploadComplete // Triggered when a file upload completes (success or error)
					onUploadError    // Triggered when a file upload returns an error
					onUploadSuccess  // Triggered when a file is uploaded successfully
					onUploadProgress // Triggered every time a file progress is updated
					onUploadStart    // Triggered immediately before a file upload starts
					*/
                }, options);

                // Prepare settings for SWFUpload
                var swfUploadSettings = {
                    assume_success_timeout   : settings.successTimeout,
                    button_placeholder_id    : settings.id,
                    button_width             : settings.width,
                    button_height            : settings.height,
                    button_text              : null,
                    button_text_style        : null,
                    button_text_top_padding  : 0,
                    button_text_left_padding : 0,
                    button_action            : (settings.multi ? SWFUpload.BUTTON_ACTION.SELECT_FILES : SWFUpload.BUTTON_ACTION.SELECT_FILE),
                    button_disabled          : false,
                    button_cursor            : (settings.buttonCursor == 'arrow' ? SWFUpload.CURSOR.ARROW : SWFUpload.CURSOR.HAND),
                    button_window_mode       : SWFUpload.WINDOW_MODE.TRANSPARENT,
                    debug                    : settings.debug,						
                    requeue_on_error         : settings.requeueErrors,
                    file_post_name           : settings.fileObjName,
                    file_size_limit          : settings.fileSizeLimit,
                    file_types               : settings.fileTypeExts,
                    file_types_description   : settings.fileTypeDesc,
                    file_queue_limit         : settings.queueSizeLimit,
                    file_upload_limit        : settings.uploadLimit,
                    flash_url                : settings.swf,					
                    prevent_swf_caching      : settings.preventCaching,
                    post_params              : settings.formData,
                    upload_url               : settings.uploader,
                    use_query_string         : (settings.method == 'get'),
					
                    // Event Handlers 
                    file_dialog_complete_handler : handlers.onDialogClose,
                    file_dialog_start_handler    : handlers.onDialogOpen,
                    file_queued_handler          : handlers.onSelect,
                    file_queue_error_handler     : handlers.onSelectError,
                    swfupload_loaded_handler     : settings.onSWFReady,
                    upload_complete_handler      : handlers.onUploadComplete,
                    upload_error_handler         : handlers.onUploadError,
                    upload_progress_handler      : handlers.onUploadProgress,
                    upload_start_handler         : handlers.onUploadStart,
                    upload_success_handler       : handlers.onUploadSuccess
                }

                // Merge the user-defined options with the defaults
                if (swfUploadOptions) {
                    swfUploadSettings = $.extend(swfUploadSettings, swfUploadOptions);
                }
                // Add the user-defined settings to the swfupload object
                swfUploadSettings = $.extend(swfUploadSettings, settings);
				
                // Detect if Flash is available
                var playerVersion  = swfobject.getFlashPlayerVersion();
                var flashInstalled = (playerVersion.major >= 9);

                if (flashInstalled) {
                    // Create the swfUpload instance
                    window['uploadify_' + settings.id] = new SWFUpload(swfUploadSettings);
                    var swfuploadify = window['uploadify_' + settings.id];

                    // Add the SWFUpload object to the elements data object
                    $this.data('uploadify', swfuploadify);
					
                    // Wrap the instance
                    var $wrapper = $('<div />', {
                        'id'    : settings.id,
                        'class' : 'uploadify',
                        'css'   : {
                            'height'   : settings.height + 'px',
                            'width'    : settings.width + 'px'
                        }
                    });
                    $('#' + swfuploadify.movieName).wrap($wrapper);
                    // Recreate the reference to wrapper
                    $wrapper = $('#' + settings.id);
                    // Add the data object to the wrapper 
                    $wrapper.data('uploadify', swfuploadify);

                    // Create the button
                    var $button = $('<div />', {
                        'id'    : settings.id + '-button',
                        'class' : 'uploadify-button ' + settings.buttonClass
                    });
                    if (settings.buttonImage) {
                        $button.css({
                            'background-image' : "url('" + settings.buttonImage + "')",
                            'text-indent'      : '-9999px'
                        });
                    }
                    $button.html('<span class="uploadify-button-text">' + settings.buttonText + '</span>')
                    .css({
                        'height'      : settings.height + 'px',
                        'line-height' : settings.height + 'px',
                        'width'       : settings.width + 'px'
                    });
                    // Append the button to the wrapper
                    $wrapper.append($button);

                    // Adjust the styles of the movie
                    $('#' + swfuploadify.movieName).css({
                        'position' : 'absolute',
                        'z-index'  : 1
                    });
					
                    // Create the file queue
                    if (!settings.queueID) {
                        var $queue = $('<div />', {
                            'id'    : settings.id + '-queue',
                            'class' : 'uploadify-queue'
                        });
                        $wrapper.after($queue);
                        swfuploadify.settings.queueID      = settings.id + '-queue';
                        swfuploadify.settings.defaultQueue = true;
                    }
					
                    // Create some queue related objects and variables
                    swfuploadify.queueData = {
                        files              : {}, // The files in the queue
                        filesSelected      : 0, // The number of files selected in the last select operation
                        filesQueued        : 0, // The number of files added to the queue in the last select operation
                        filesReplaced      : 0, // The number of files replaced in the last select operation
                        filesCancelled     : 0, // The number of files that were cancelled instead of replaced
                        filesErrored       : 0, // The number of files that caused error in the last select operation
                        uploadsSuccessful  : 0, // The number of files that were successfully uploaded
                        uploadsErrored     : 0, // The number of files that returned errors during upload
                        averageSpeed       : 0, // The average speed of the uploads in KB
                        queueLength        : 0, // The number of files in the queue
                        queueSize          : 0, // The size in bytes of the entire queue
                        uploadSize         : 0, // The size in bytes of the upload queue
                        queueBytesUploaded : 0, // The size in bytes that have been uploaded for the current upload queue
                        uploadQueue        : [], // The files currently to be uploaded
                        errorMsg           : 'Some files were not added to the queue:'
                    };

                    // Save references to all the objects
                    swfuploadify.original = $clone;
                    swfuploadify.wrapper  = $wrapper;
                    swfuploadify.button   = $button;
                    swfuploadify.queue    = $queue;

                    // Call the user-defined init event handler
                    if (settings.onInit) settings.onInit.call($this, swfuploadify);

                } else {

                    // Call the fallback function
                    if (settings.onFallback) settings.onFallback.call($this);

                }
            });

        },

        // Stop a file upload and remove it from the queue 
        cancel : function(fileID, supressEvent) {

            var args = arguments;

            this.each(function() {
                // Create a reference to the jQuery DOM object
                var $this        = $(this),
                swfuploadify = $this.data('uploadify'),
                settings     = swfuploadify.settings,
                delay        = -1;

                if (args[0]) {
                    // Clear the queue
                    if (args[0] == '*') {
                        var queueItemCount = swfuploadify.queueData.queueLength;
                        $('#' + settings.queueID).find('.uploadify-queue-item').each(function() {
                            delay++;
                            if (args[1] === true) {
                                swfuploadify.cancelUpload($(this).attr('id'), false);
                            } else {
                                swfuploadify.cancelUpload($(this).attr('id'));
                            }
                            $(this).find('.data').removeClass('data').html(' - Cancelled');
                            $(this).find('.uploadify-progress-bar').remove();
                            $(this).delay(1000 + 100 * delay).fadeOut(500, function() {
                                $(this).remove();
                            });
                        });
                        swfuploadify.queueData.queueSize   = 0;
                        swfuploadify.queueData.queueLength = 0;
                        // Trigger the onClearQueue event
                        if (settings.onClearQueue) settings.onClearQueue.call($this, queueItemCount);
                    } else {
                        for (var n = 0; n < args.length; n++) {
                            swfuploadify.cancelUpload(args[n]);
                            $('#' + args[n]).find('.data').removeClass('data').html(' - Cancelled');
                            $('#' + args[n]).find('.uploadify-progress-bar').remove();
                            $('#' + args[n]).delay(1000 + 100 * n).fadeOut(500, function() {
                                $(this).remove();
                            });
                        }
                    }
                } else {
                    var item = $('#' + settings.queueID).find('.uploadify-queue-item').get(0);
                    $item = $(item);
                    swfuploadify.cancelUpload($item.attr('id'));
                    $item.find('.data').removeClass('data').html(' - Cancelled');
                    $item.find('.uploadify-progress-bar').remove();
                    $item.delay(1000).fadeOut(500, function() {
                        $(this).remove();
                    });
                }
            });

        },

        // Revert the DOM object back to its original state
        destroy : function() {

            this.each(function() {
                // Create a reference to the jQuery DOM object
                var $this        = $(this),
                swfuploadify = $this.data('uploadify'),
                settings     = swfuploadify.settings;

                // Destroy the SWF object and 
                swfuploadify.destroy();
				
                // Destroy the queue
                if (settings.defaultQueue) {
                    $('#' + settings.queueID).remove();
                }
				
                // Reload the original DOM element
                $('#' + settings.id).replaceWith(swfuploadify.original);

                // Call the user-defined event handler
                if (settings.onDestroy) settings.onDestroy.call(this);

                delete swfuploadify;
            });

        },

        // Disable the select button
        disable : function(isDisabled) {
			
            this.each(function() {
                // Create a reference to the jQuery DOM object
                var $this        = $(this),
                swfuploadify = $this.data('uploadify'),
                settings     = swfuploadify.settings;

                // Call the user-defined event handlers
                if (isDisabled) {
                    swfuploadify.button.addClass('disabled');
                    if (settings.onDisable) settings.onDisable.call(this);
                } else {
                    swfuploadify.button.removeClass('disabled');
                    if (settings.onEnable) settings.onEnable.call(this);
                }

                // Enable/disable the browse button
                swfuploadify.setButtonDisabled(isDisabled);
            });

        },

        // Get or set the settings data
        settings : function(name, value, resetObjects) {

            var args        = arguments;
            var returnValue = value;

            this.each(function() {
                // Create a reference to the jQuery DOM object
                var $this        = $(this),
                swfuploadify = $this.data('uploadify'),
                settings     = swfuploadify.settings;

                if (typeof(args[0]) == 'object') {
                    for (var n in value) {
                        setData(n,value[n]);
                    }
                }
                if (args.length === 1) {
                    returnValue =  settings[name];
                } else {
                    switch (name) {
                        case 'uploader':
                            swfuploadify.setUploadURL(value);
                            break;
                        case 'formData':
                            if (!resetObjects) {
                                value = $.extend(settings.formData, value);
                            }
                            swfuploadify.setPostParams(settings.formData);
                            break;
                        case 'method':
                            if (value == 'get') {
                                swfuploadify.setUseQueryString(true);
                            } else {
                                swfuploadify.setUseQueryString(false);
                            }
                            break;
                        case 'fileObjName':
                            swfuploadify.setFilePostName(value);
                            break;
                        case 'fileTypeExts':
                            swfuploadify.setFileTypes(value, settings.fileTypeDesc);
                            break;
                        case 'fileTypeDesc':
                            swfuploadify.setFileTypes(settings.fileTypeExts, value);
                            break;
                        case 'fileSizeLimit':
                            swfuploadify.setFileSizeLimit(value);
                            break;
                        case 'uploadLimit':
                            swfuploadify.setFileUploadLimit(value);
                            break;
                        case 'queueSizeLimit':
                            swfuploadify.setFileQueueLimit(value);
                            break;
                        case 'buttonImage':
                            swfuploadify.button.css('background-image', settingValue);
                            break;
                        case 'buttonCursor':
                            if (value == 'arrow') {
                                swfuploadify.setButtonCursor(SWFUpload.CURSOR.ARROW);
                            } else {
                                swfuploadify.setButtonCursor(SWFUpload.CURSOR.HAND);
                            }
                            break;
                        case 'buttonText':
                            $('#' + settings.id + '-button').find('.uploadify-button-text').html(value);
                            break;
                        case 'width':
                            swfuploadify.setButtonDimensions(value, settings.height);
                            break;
                        case 'height':
                            swfuploadify.setButtonDimensions(settings.width, value);
                            break;
                        case 'multi':
                            if (value) {
                                swfuploadify.setButtonAction(SWFUpload.BUTTON_ACTION.SELECT_FILES);
                            } else {
                                swfuploadify.setButtonAction(SWFUpload.BUTTON_ACTION.SELECT_FILE);
                            }
                            break;
                    }
                    settings[name] = value;
                }
            });
			
            if (args.length === 1) {
                return returnValue;
            }

        },

        // Stop the current uploads and requeue what is in progress
        stop : function() {

            this.each(function() {
                // Create a reference to the jQuery DOM object
                var $this        = $(this),
                swfuploadify = $this.data('uploadify');

                // Reset the queue information
                swfuploadify.queueData.averageSpeed  = 0;
                swfuploadify.queueData.uploadSize    = 0;
                swfuploadify.queueData.bytesUploaded = 0;
                swfuploadify.queueData.uploadQueue   = [];

                swfuploadify.stopUpload();
            });

        },

        // Start uploading files in the queue
        upload : function() {

            var args = arguments;

            this.each(function() {
                // Create a reference to the jQuery DOM object
                var $this        = $(this),
                swfuploadify = $this.data('uploadify');

                // Reset the queue information
                swfuploadify.queueData.averageSpeed  = 0;
                swfuploadify.queueData.uploadSize    = 0;
                swfuploadify.queueData.bytesUploaded = 0;
                swfuploadify.queueData.uploadQueue   = [];
				
                // Upload the files
                if (args[0]) {
                    if (args[0] == '*') {
                        swfuploadify.queueData.uploadSize = swfuploadify.queueData.queueSize;
                        swfuploadify.queueData.uploadQueue.push('*');
                        swfuploadify.startUpload();
                    } else {
                        for (var n = 0; n < args.length; n++) {
                            swfuploadify.queueData.uploadSize += swfuploadify.queueData.files[args[n]].size;
                            swfuploadify.queueData.uploadQueue.push(args[n]);
                        }
                        swfuploadify.startUpload(swfuploadify.queueData.uploadQueue.shift());
                    }
                } else {
                    swfuploadify.startUpload();
                }

            });

        }

    }

    // These functions handle all the events that occur with the file uploader
    var handlers = {

        // Triggered when the file dialog is opened
        onDialogOpen : function() {
            // Load the swfupload settings
            var settings = this.settings;

            // Reset some queue info
            this.queueData.errorMsg       = 'Some files were not added to the queue:';
            this.queueData.filesReplaced  = 0;
            this.queueData.filesCancelled = 0;

            // Call the user-defined event handler
            if (settings.onDialogOpen) settings.onDialogOpen.call(this);
        },

        // Triggered when the browse dialog is closed
        onDialogClose :  function(filesSelected, filesQueued, queueLength) {
            // Load the swfupload settings
            var settings = this.settings;

            // Update the queue information
            this.queueData.filesErrored  = filesSelected - filesQueued;
            this.queueData.filesSelected = filesSelected;
            this.queueData.filesQueued   = filesQueued - this.queueData.filesCancelled;
            this.queueData.queueLength   = queueLength;

            // Run the default event handler
            if ($.inArray('onDialogClose', settings.overrideEvents) < 0) {
                if (this.queueData.filesErrored > 0) {
                    alert(this.queueData.errorMsg);
                }
            }

            // Call the user-defined event handler
            if (settings.onDialogClose) settings.onDialogClose.call(this, this.queueData);

            // Upload the files if auto is true
            if (settings.auto) $('#' + settings.id).uploadify('upload', '*');
        },

        // Triggered once for each file added to the queue
        onSelect : function(file) {
            // Load the swfupload settings
            var settings = this.settings;

            // Check if a file with the same name exists in the queue
            var queuedFile = {};
            for (var n in this.queueData.files) {
                queuedFile = this.queueData.files[n];
                if (queuedFile.uploaded != true && queuedFile.name == file.name) {
                    var replaceQueueItem = confirm('The file named "' + file.name + '" is already in the queue.\nDo you want to replace the existing item in the queue?');
                    if (!replaceQueueItem) {
                        this.cancelUpload(file.id);
                        this.queueData.filesCancelled++;
                        return false;
                    } else {
                        $('#' + queuedFile.id).remove();
                        this.cancelUpload(queuedFile.id);
                        this.queueData.filesReplaced++;
                    }
                }
            }

            // Get the size of the file
            var fileSize = Math.round(file.size / 1024);
            var suffix   = 'KB';
            if (fileSize > 1000) {
                fileSize = Math.round(fileSize / 1000);
                suffix   = 'MB';
            }
            var fileSizeParts = fileSize.toString().split('.');
            fileSize = fileSizeParts[0];
            if (fileSizeParts.length > 1) {
                fileSize += '.' + fileSizeParts[1].substr(0,2);
            }
            fileSize += suffix;
			
            // Truncate the filename if it's too long
            var fileName = file.name;
            if (fileName.length > 25) {
                fileName = fileName.substr(0,25) + '...';
            }

            // Create the file data object
            itemData = {
                'fileID'     : file.id,
                'instanceID' : settings.id,
                'fileName'   : fileName,
                'fileSize'   : fileSize
            }

            // Create the file item template
            if (settings.itemTemplate == false) {
                settings.itemTemplate = '<div id="${fileID}" class="uploadify-queue-item">\
					<div class="cancel">\
						<a href="javascript:$(\'#${instanceID}\').uploadify(\'cancel\', \'${fileID}\')">X</a>\
					</div>\
					<span class="fileName">${fileName} (${fileSize})</span><span class="data"></span>\
					<div class="uploadify-progress">\
						<div class="uploadify-progress-bar"><!--Progress Bar--></div>\
					</div>\
				</div>';
            }

            // Run the default event handler
            if ($.inArray('onSelect', settings.overrideEvents) < 0) {
				
                // Replace the item data in the template
                itemHTML = settings.itemTemplate;
                for (var d in itemData) {
                    itemHTML = itemHTML.replace(new RegExp('\\$\\{' + d + '\\}', 'g'), itemData[d]);
                }

                // Add the file item to the queue
                $('#' + settings.queueID).append(itemHTML);
            }

            this.queueData.queueSize += file.size;
            this.queueData.files[file.id] = file;

            // Call the user-defined event handler
            if (settings.onSelect) settings.onSelect.apply(this, arguments);
        },

        // Triggered when a file is not added to the queue
        onSelectError : function(file, errorCode, errorMsg) {
            // Load the swfupload settings
            var settings = this.settings;

            // Run the default event handler
            if ($.inArray('onSelectError', settings.overrideEvents) < 0) {
                switch(errorCode) {
                    case SWFUpload.QUEUE_ERROR.QUEUE_LIMIT_EXCEEDED:
                        if (settings.queueSizeLimit > errorMsg) {
                            this.queueData.errorMsg += '\nThe number of files selected exceeds the remaining upload limit (' + errorMsg + ').';
                        } else {
                            this.queueData.errorMsg += '\nThe number of files selected exceeds the queue size limit (' + settings.queueSizeLimit + ').';
                        }
                        break;
                    case SWFUpload.QUEUE_ERROR.FILE_EXCEEDS_SIZE_LIMIT:
                        this.queueData.errorMsg += '\nThe file "' + file.name + '" exceeds the size limit (' + settings.fileSizeLimit + ').';
                        break;
                    case SWFUpload.QUEUE_ERROR.ZERO_BYTE_FILE:
                        this.queueData.errorMsg += '\nThe file "' + file.name + '" is empty.';
                        break;
                    case SWFUpload.QUEUE_ERROR.FILE_EXCEEDS_SIZE_LIMIT:
                        this.queueData.errorMsg += '\nThe file "' + file.name + '" is not an accepted file type (' + settings.fileTypeDesc + ').';
                        break;
                }
            }
            if (errorCode != SWFUpload.QUEUE_ERROR.QUEUE_LIMIT_EXCEEDED) {
                delete this.queueData.files[file.id];
            }

            // Call the user-defined event handler
            if (settings.onSelectError) settings.onSelectError.apply(this, arguments);
        },

        // Triggered when all the files in the queue have been processed
        onQueueComplete : function() {
            if (this.settings.onQueueComplete) this.settings.onQueueComplete.call(this, this.settings.queueData);
        },

        // Triggered when a file upload successfully completes
        onUploadComplete : function(file) {
            // Load the swfupload settings
            var settings     = this.settings,
            swfuploadify = this;

            // Check if all the files have completed uploading
            var stats = this.getStats();
            this.queueData.queueLength = stats.files_queued;
            if (this.queueData.uploadQueue[0] == '*') {
                if (this.queueData.queueLength > 0) {
                    this.startUpload();
                } else {
                    this.queueData.uploadQueue = [];

                    // Call the user-defined event handler for queue complete
                    if (settings.onQueueComplete) settings.onQueueComplete.call(this, this.queueData);
                }
            } else {
                if (this.queueData.uploadQueue.length > 0) {
                    this.startUpload(this.queueData.uploadQueue.shift());
                } else {
                    this.queueData.uploadQueue = [];

                    // Call the user-defined event handler for queue complete
                    if (settings.onQueueComplete) settings.onQueueComplete.call(this, this.queueData);
                }
            }

            // Call the default event handler
            if ($.inArray('onUploadComplete', settings.overrideEvents) < 0) {
                if (settings.removeCompleted) {
                    switch (file.filestatus) {
                        case SWFUpload.FILE_STATUS.COMPLETE:
                            setTimeout(function() { 
                                if ($('#' + file.id)) {
                                    swfuploadify.queueData.queueSize   -= file.size;
                                    swfuploadify.queueData.queueLength -= 1;
                                    delete swfuploadify.queueData.files[file.id]
                                    $('#' + file.id).fadeOut(500, function() {
                                        $(this).remove();
                                    });
                                }
                            }, settings.removeTimeout * 1000);
                            break;
                        case SWFUpload.FILE_STATUS.ERROR:
                            if (!settings.requeueErrors) {
                                setTimeout(function() {
                                    if ($('#' + file.id)) {
                                        swfuploadify.queueData.queueSize   -= file.size;
                                        swfuploadify.queueData.queueLength -= 1;
                                        delete swfuploadify.queueData.files[file.id];
                                        $('#' + file.id).fadeOut(500, function() {
                                            $(this).remove();
                                        });
                                    }
                                }, settings.removeTimeout * 1000);
                            }
                            break;
                    }
                } else {
                    file.uploaded = true;
                }
            }

            // Call the user-defined event handler
            if (settings.onUploadComplete) settings.onUploadComplete.call(this, file);
        },

        // Triggered when a file upload returns an error
        onUploadError : function(file, errorCode, errorMsg) {
            // Load the swfupload settings
            var settings = this.settings;

            // Set the error string
            var errorString = 'Error';
            switch(errorCode) {
                case SWFUpload.UPLOAD_ERROR.HTTP_ERROR:
                    errorString = 'HTTP Error (' + errorMsg + ')';
                    break;
                case SWFUpload.UPLOAD_ERROR.MISSING_UPLOAD_URL:
                    errorString = 'Missing Upload URL';
                    break;
                case SWFUpload.UPLOAD_ERROR.IO_ERROR:
                    errorString = 'IO Error';
                    break;
                case SWFUpload.UPLOAD_ERROR.SECURITY_ERROR:
                    errorString = 'Security Error';
                    break;
                case SWFUpload.UPLOAD_ERROR.UPLOAD_LIMIT_EXCEEDED:
                    alert('The upload limit has been reached (' + errorMsg + ').');
                    errorString = 'Exceeds Upload Limit';
                    break;
                case SWFUpload.UPLOAD_ERROR.UPLOAD_FAILED:
                    errorString = 'Failed';
                    break;
                case SWFUpload.UPLOAD_ERROR.SPECIFIED_FILE_ID_NOT_FOUND:
                    break;
                case SWFUpload.UPLOAD_ERROR.FILE_VALIDATION_FAILED:
                    errorString = 'Validation Error';
                    break;
                case SWFUpload.UPLOAD_ERROR.FILE_CANCELLED:
                    errorString = 'Cancelled';
                    this.queueData.queueSize   -= file.size;
                    this.queueData.queueLength -= 1;
                    if (file.status == SWFUpload.FILE_STATUS.IN_PROGRESS || $.inArray(file.id, this.queueData.uploadQueue) >= 0) {
                        this.queueData.uploadSize -= file.size;
                    }
                    // Trigger the onCancel event
                    if (settings.onCancel) settings.onCancel.call(this, file);
                    delete this.queueData.files[file.id];
                    break;
                case SWFUpload.UPLOAD_ERROR.UPLOAD_STOPPED:
                    errorString = 'Stopped';
                    break;
            }

            // Call the default event handler
            if ($.inArray('onUploadError', settings.overrideEvents) < 0) {

                if (errorCode != SWFUpload.UPLOAD_ERROR.FILE_CANCELLED && errorCode != SWFUpload.UPLOAD_ERROR.UPLOAD_STOPPED) {
                    $('#' + file.id).addClass('uploadify-error');
                }

                // Reset the progress bar
                $('#' + file.id).find('.uploadify-progress-bar').css('width','1px');

                // Add the error message to the queue item
                if (errorCode != SWFUpload.UPLOAD_ERROR.SPECIFIED_FILE_ID_NOT_FOUND && file.status != SWFUpload.FILE_STATUS.COMPLETE) {
                    $('#' + file.id).find('.data').html(' - ' + errorString);
                }
            }

            var stats = this.getStats();
            this.queueData.uploadsErrored = stats.upload_errors;

            // Call the user-defined event handler
            if (settings.onUploadError) settings.onUploadError.call(this, file, errorCode, errorMsg, errorString);
        },

        // Triggered periodically during a file upload
        onUploadProgress : function(file, fileBytesLoaded, fileTotalBytes) {
            // Load the swfupload settings
            var settings = this.settings;

            // Setup all the variables
            var timer            = new Date();
            var newTime          = timer.getTime();
            var lapsedTime       = newTime - this.timer;
            if (lapsedTime > 500) {
                this.timer = newTime;
            }
            var lapsedBytes      = fileBytesLoaded - this.bytesLoaded;
            this.bytesLoaded     = fileBytesLoaded;
            var queueBytesLoaded = this.queueData.queueBytesUploaded + fileBytesLoaded;
            var percentage       = Math.round(fileBytesLoaded / fileTotalBytes * 100);
			
            // Calculate the average speed
            var suffix = 'KB/s';
            var mbs = 0;
            var kbs = (lapsedBytes / 1024) / (lapsedTime / 1000);
            kbs = Math.floor(kbs * 10) / 10;
            if (this.queueData.averageSpeed > 0) {
                this.queueData.averageSpeed = Math.floor((this.queueData.averageSpeed + kbs) / 2);
            } else {
                this.queueData.averageSpeed = Math.floor(kbs);
            }
            if (kbs > 1000) {
                mbs = (kbs * .001);
                this.queueData.averageSpeed = Math.floor(mbs);
                suffix = 'MB/s';
            }
			
            // Call the default event handler
            if ($.inArray('onUploadProgress', settings.overrideEvents) < 0) {
                if (settings.progressData == 'percentage') {
                    $('#' + file.id).find('.data').html(' - ' + percentage + '%');
                } else if (settings.progressData == 'speed' && lapsedTime > 500) {
                    $('#' + file.id).find('.data').html(' - ' + this.queueData.averageSpeed + suffix);
                }
                $('#' + file.id).find('.uploadify-progress-bar').css('width', percentage + '%');
            }

            // Call the user-defined event handler
            if (settings.onUploadProgress) settings.onUploadProgress.call(this, file, fileBytesLoaded, fileTotalBytes, queueBytesLoaded, this.queueData.uploadSize);
        },

        // Triggered right before a file is uploaded
        onUploadStart : function(file) {
            // Load the swfupload settings
            var settings = this.settings;

            var timer        = new Date();
            this.timer       = timer.getTime();
            this.bytesLoaded = 0;
            if (this.queueData.uploadQueue.length == 0) {
                this.queueData.uploadSize = file.size;
            }
            if (settings.checkExisting) {
                $.ajax({
                    type    : 'POST',
                    async   : false,
                    url     : settings.checkExisting,
                    data    : {
                        filename: file.name
                        },
                    success : function(data) {
                        if (data == 1) {
                            var overwrite = confirm('A file with the name "' + file.name + '" already exists on the server.\nWould you like to replace the existing file?');
                            if (!overwrite) {
                                this.cancelUpload(file.id);
                                $('#' + file.id).remove();
                                if (this.queueData.uploadQueue.length > 0 && this.queueData.queueLength > 0) {
                                    if (this.queueData.uploadQueue[0] == '*') {
                                        this.startUpload();
                                    } else {
                                        this.startUpload(this.queueData.uploadQueue.shift());
                                    }
                                }
                            }
                        }
                    }
                });
            }

            // Call the user-defined event handler
            if (settings.onUploadStart) settings.onUploadStart.call(this, file); 
        },

        // Triggered when a file upload returns a successful code
        onUploadSuccess : function(file, data, response) {
            // Load the swfupload settings
            var settings = this.settings;
            var stats    = this.getStats();
            this.queueData.uploadsSuccessful = stats.successful_uploads;
            this.queueData.queueBytesUploaded += file.size;

            // Call the default event handler
            if ($.inArray('onUploadSuccess', settings.overrideEvents) < 0) {
                $('#' + file.id).find('.data').html(' - Complete');
            }

            // Call the user-defined event handler
            if (settings.onUploadSuccess) settings.onUploadSuccess.call(this, file, data, response); 
        }

    }

    $.fn.uploadify = function(method) {

        if (methods[method]) {
            return methods[method].apply(this, Array.prototype.slice.call(arguments, 1));
        } else if (typeof method === 'object' || !method) {
            return methods.init.apply(this, arguments);
        } else {
            $.error('The method ' + method + ' does not exist in $.uploadify');
        }

    }

})($);