include/javascript/yui/build/uploader/uploader.js

   1 /*
   2 Copyright (c) 2011, Yahoo! Inc. All rights reserved.
   3 Code licensed under the BSD License:
   4 http://developer.yahoo.com/yui/license.html
   5 version: 2.9.0
   6 */
   7 /*extern ActiveXObject, __flash_unloadHandler, __flash_savedUnloadHandler */
   8 /*!
   9  * SWFObject v1.5: Flash Player detection and embed - http://blog.deconcept.com/swfobject/
  10  *
  11  * SWFObject is (c) 2007 Geoff Stearns and is released under the MIT License:
  12  * http://www.opensource.org/licenses/mit-license.php
  13  * @namespace YAHOO
  14  */
  15
  16 YAHOO.namespace("deconcept");
  17
  18 YAHOO.deconcept = YAHOO.deconcept || {};
  19
  20 if(typeof YAHOO.deconcept.util == "undefined" || !YAHOO.deconcept.util)
  21 {
  22         YAHOO.deconcept.util = {};
  23 }
  24
  25 if(typeof YAHOO.deconcept.SWFObjectUtil == "undefined" || !YAHOO.deconcept.SWFObjectUtil)
  26 {
  27         YAHOO.deconcept.SWFObjectUtil = {};
  28 }
  29
  30 YAHOO.deconcept.SWFObject = function(swf, id, w, h, ver, c, quality, xiRedirectUrl, redirectUrl, detectKey)
  31 {
  32         if(!document.getElementById) { return; }
  33         this.DETECT_KEY = detectKey ? detectKey : 'detectflash';
  34         this.skipDetect = YAHOO.deconcept.util.getRequestParameter(this.DETECT_KEY);
  35         this.params = {};
  36         this.variables = {};
  37         this.attributes = [];
  38         if(swf) { this.setAttribute('swf', swf); }
  39         if(id) { this.setAttribute('id', id); }
  40         if(w) { this.setAttribute('width', w); }
  41         if(h) { this.setAttribute('height', h); }
  42         if(ver) { this.setAttribute('version', new YAHOO.deconcept.PlayerVersion(ver.toString().split("."))); }
  43         this.installedVer = YAHOO.deconcept.SWFObjectUtil.getPlayerVersion();
  44         if (!window.opera && document.all && this.installedVer.major > 7)
  45         {
  46                 // only add the onunload cleanup if the Flash Player version supports External Interface and we are in IE
  47                 YAHOO.deconcept.SWFObject.doPrepUnload = true;
  48         }
  49         if(c)
  50         {
  51                 this.addParam('bgcolor', c);
  52         }
  53         var q = quality ? quality : 'high';
  54         this.addParam('quality', q);
  55         this.setAttribute('useExpressInstall', false);
  56         this.setAttribute('doExpressInstall', false);
  57         var xir = (xiRedirectUrl) ? xiRedirectUrl : window.location;
  58         this.setAttribute('xiRedirectUrl', xir);
  59         this.setAttribute('redirectUrl', '');
  60         if(redirectUrl)
  61         {
  62                 this.setAttribute('redirectUrl', redirectUrl);
  63         }
  64 };
  65
  66 YAHOO.deconcept.SWFObject.prototype =
  67 {
  68         useExpressInstall: function(path)
  69         {
  70                 this.xiSWFPath = !path ? "expressinstall.swf" : path;
  71                 this.setAttribute('useExpressInstall', true);
  72         },
  73         setAttribute: function(name, value){
  74                 this.attributes[name] = value;
  75         },
  76         getAttribute: function(name){
  77                 return this.attributes[name];
  78         },
  79         addParam: function(name, value){
  80                 this.params[name] = value;
  81         },
  82         getParams: function(){
  83                 return this.params;
  84         },
  85         addVariable: function(name, value){
  86                 this.variables[name] = value;
  87         },
  88         getVariable: function(name){
  89                 return this.variables[name];
  90         },
  91         getVariables: function(){
  92                 return this.variables;
  93         },
  94         getVariablePairs: function(){
  95                 var variablePairs = [];
  96                 var key;
  97                 var variables = this.getVariables();
  98                 for(key in variables)
  99                 {
 100                         if(variables.hasOwnProperty(key))
 101                         {
 102                                 variablePairs[variablePairs.length] = YAHOO.lang.escapeHTML(key || '') +"="+ YAHOO.lang.escapeHTML(encodeURIComponent(variables[key]  || ''));
 103                         }
 104                 }
 105                 return variablePairs;
 106         },
 107         getSWFHTML: function() {
 108                 var swfNode = "";
 109                 var params = {};
 110                 var key = "";
 111                 var pairs = "";
 112                 if (navigator.plugins && navigator.mimeTypes && navigator.mimeTypes.length) { // netscape plugin architecture
 113                         if (this.getAttribute("doExpressInstall")) {
 114                                 this.addVariable("MMplayerType", "PlugIn");
 115                                 this.setAttribute('swf', this.xiSWFPath);
 116                         }
 117                         swfNode = '<embed type="application/x-shockwave-flash" src="'+ YAHOO.lang.escapeHTML(this.getAttribute('swf') || '') +'" width="'+ YAHOO.lang.escapeHTML(this.getAttribute('width') || '') +'" height="'+ YAHOO.lang.escapeHTML(this.getAttribute('height') || '') +'" style="'+ YAHOO.lang.escapeHTML(this.getAttribute('style') || '') +'"';
 118                         swfNode += ' id="'+ YAHOO.lang.escapeHTML(this.getAttribute('id') || '') +'" name="'+ YAHOO.lang.escapeHTML(this.getAttribute('id') || '') +'" ';
 119                         params = this.getParams();
 120                         for(key in params)
 121                         {
 122                                 if(params.hasOwnProperty(key))
 123                                 {
 124                                         swfNode += YAHOO.lang.escapeHTML(key || '') +'="'+ YAHOO.lang.escapeHTML(params[key] || '') +'" ';
 125                                 }
 126                         }
 127                         pairs = this.getVariablePairs().join("&");
 128                         if (pairs.length > 0){ swfNode += 'flashvars="'+ pairs +'"'; }
 129                         swfNode += '/>';
 130                 } else { // PC IE
 131                         if (this.getAttribute("doExpressInstall")) {
 132                                 this.addVariable("MMplayerType", "ActiveX");
 133                                 this.setAttribute('swf', this.xiSWFPath);
 134                         }
 135                         swfNode = '<object id="'+ YAHOO.lang.escapeHTML(this.getAttribute('id') || '') +'" classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" width="'+ YAHOO.lang.escapeHTML(this.getAttribute('width') || '') +'" height="'+ YAHOO.lang.escapeHTML(this.getAttribute('height') || '') +'" style="'+ YAHOO.lang.escapeHTML(this.getAttribute('style') || '') +'">';
 136                         swfNode += '<param name="movie" value="'+ YAHOO.lang.escapeHTML(this.getAttribute('swf') || '') +'" />';
 137                         params = this.getParams();
 138                         for(key in params)
 139                         {
 140                                 if(params.hasOwnProperty(key))
 141                                 {
 142                                         swfNode += '<param name="'+ YAHOO.lang.escapeHTML(key || '') +'" value="'+ YAHOO.lang.escapeHTML(params[key] || '') +'" />';
 143                                 }
 144                         }
 145                         pairs = this.getVariablePairs().join("&");
 146                         if(pairs.length > 0) {swfNode += '<param name="flashvars" value="'+ pairs +'" />';}
 147                         swfNode += "</object>";
 148                 }
 149                 return swfNode;
 150         },
 151         write: function(elementId)
 152         {
 153                 if(this.getAttribute('useExpressInstall')) {
 154                         // check to see if we need to do an express install
 155                         var expressInstallReqVer = new YAHOO.deconcept.PlayerVersion([6,0,65]);
 156                         if (this.installedVer.versionIsValid(expressInstallReqVer) && !this.installedVer.versionIsValid(this.getAttribute('version'))) {
 157                                 this.setAttribute('doExpressInstall', true);
 158                                 this.addVariable("MMredirectURL", escape(this.getAttribute('xiRedirectUrl')));
 159                                 document.title = document.title.slice(0, 47) + " - Flash Player Installation";
 160                                 this.addVariable("MMdoctitle", document.title);
 161                         }
 162                 }
 163                 if(this.skipDetect || this.getAttribute('doExpressInstall') || this.installedVer.versionIsValid(this.getAttribute('version')))
 164                 {
 165                         var n = (typeof elementId == 'string') ? document.getElementById(elementId) : elementId;
 166                         n.innerHTML = this.getSWFHTML();
 167                         return true;
 168                 }
 169                 else
 170                 {
 171                         if(this.getAttribute('redirectUrl') !== "")
 172                         {
 173                                 document.location.replace(this.getAttribute('redirectUrl'));
 174                         }
 175                 }
 176                 return false;
 177         }
 178 };
 179
 180 /* ---- detection functions ---- */
 181 YAHOO.deconcept.SWFObjectUtil.getPlayerVersion = function()
 182 {
 183         var axo = null;
 184         var PlayerVersion = new YAHOO.deconcept.PlayerVersion([0,0,0]);
 185         if(navigator.plugins && navigator.mimeTypes.length)
 186         {
 187                 var x = navigator.plugins["Shockwave Flash"];
 188                 if(x && x.description)
 189                 {
 190                         PlayerVersion = new YAHOO.deconcept.PlayerVersion(x.description.replace(/([a-zA-Z]|\s)+/, "").replace(/(\s+r|\s+b[0-9]+)/, ".").split("."));
 191                 }
 192         }
 193         else if (navigator.userAgent && navigator.userAgent.indexOf("Windows CE") >= 0)
 194         { // if Windows CE
 195                 var counter = 3;
 196                 while(axo)
 197                 {
 198                         try
 199                         {
 200                                 counter++;
 201                                 axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash."+ counter);
 202 //                              document.write("player v: "+ counter);
 203                                 PlayerVersion = new YAHOO.deconcept.PlayerVersion([counter,0,0]);
 204                         }
 205                         catch(e)
 206                         {
 207                                 axo = null;
 208                         }
 209                 }
 210         }
 211         else
 212         { // Win IE (non mobile)
 213                 // do minor version lookup in IE, but avoid fp6 crashing issues
 214                 // see http://blog.deconcept.com/2006/01/11/getvariable-setvariable-crash-internet-explorer-flash-6/
 215                 try
 216                 {
 217                         axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.7");
 218                 }
 219                 catch(e)
 220                 {
 221                         try
 222                         {
 223                                 axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.6");
 224                                 PlayerVersion = new YAHOO.deconcept.PlayerVersion([6,0,21]);
 225                                 axo.AllowScriptAccess = "always"; // error if player version < 6.0.47 (thanks to Michael Williams @ Adobe for this code)
 226                         }
 227                         catch(e)
 228                         {
 229                                 if(PlayerVersion.major == 6)
 230                                 {
 231                                         return PlayerVersion;
 232                                 }
 233                         }
 234                         try
 235                         {
 236                                 axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash");
 237                         }
 238                         catch(e) {}
 239                 }
 240
 241                 if(axo !== null)
 242                 {
 243                         PlayerVersion = new YAHOO.deconcept.PlayerVersion(axo.GetVariable("$version").split(" ")[1].split(","));
 244                 }
 245         }
 246         return PlayerVersion;
 247 };
 248
 249 YAHOO.deconcept.PlayerVersion = function(arrVersion)
 250 {
 251         this.major = arrVersion[0] !== null ? parseInt(arrVersion[0], 0) : 0;
 252         this.minor = arrVersion[1] !== null ? parseInt(arrVersion[1], 0) : 0;
 253         this.rev = arrVersion[2] !== null ? parseInt(arrVersion[2], 0) : 0;
 254 };
 255
 256 YAHOO.deconcept.PlayerVersion.prototype.versionIsValid = function(fv)
 257 {
 258         if(this.major < fv.major)
 259         {
 260                 return false;
 261         }
 262         if(this.major > fv.major)
 263         {
 264                 return true;
 265         }
 266         if(this.minor < fv.minor)
 267         {
 268                 return false;
 269         }
 270         if(this.minor > fv.minor)
 271         {
 272                 return true;
 273         }
 274         if(this.rev < fv.rev)
 275         {
 276                 return false;
 277         }
 278         return true;
 279 };
 280
 281 /* ---- get value of query string param ---- */
 282 YAHOO.deconcept.util =
 283 {
 284         getRequestParameter: function(param)
 285         {
 286                 var q = document.location.search || document.location.hash;
 287                 if(param === null) { return q; }
 288                 if(q)
 289                 {
 290                         var pairs = q.substring(1).split("&");
 291                         for(var i=0; i < pairs.length; i++)
 292                         {
 293                                 if (pairs[i].substring(0, pairs[i].indexOf("=")) == param)
 294                                 {
 295                                         return pairs[i].substring((pairs[i].indexOf("=") + 1));
 296                                 }
 297                         }
 298                 }
 299                 return "";
 300         }
 301 };
 302
 303 /* fix for video streaming bug */
 304 YAHOO.deconcept.SWFObjectUtil.cleanupSWFs = function()
 305 {
 306         var objects = document.getElementsByTagName("OBJECT");
 307         for(var i = objects.length - 1; i >= 0; i--)
 308         {
 309                 objects[i].style.display = 'none';
 310                 for(var x in objects[i])
 311                 {
 312                         if(typeof objects[i][x] == 'function')
 313                         {
 314                                 objects[i][x] = function(){};
 315                         }
 316                 }
 317         }
 318 };
 319
 320 // fixes bug in some fp9 versions see http://blog.deconcept.com/2006/07/28/swfobject-143-released/
 321 if(YAHOO.deconcept.SWFObject.doPrepUnload)
 322 {
 323         if(!YAHOO.deconcept.unloadSet)
 324         {
 325                 YAHOO.deconcept.SWFObjectUtil.prepUnload = function()
 326                 {
 327                         __flash_unloadHandler = function(){};
 328                         __flash_savedUnloadHandler = function(){};
 329                         window.attachEvent("onunload", YAHOO.deconcept.SWFObjectUtil.cleanupSWFs);
 330                 };
 331                 window.attachEvent("onbeforeunload", YAHOO.deconcept.SWFObjectUtil.prepUnload);
 332                 YAHOO.deconcept.unloadSet = true;
 333         }
 334 }
 335
 336 /* add document.getElementById if needed (mobile IE < 5) */
 337 if(!document.getElementById && document.all)
 338 {
 339         document.getElementById = function(id) { return document.all[id]; };
 340 }
 341 /**
 342  * Wraps Flash embedding functionality and allows communication with SWF through
 343  * attributes.
 344  *
 345  * @namespace YAHOO.widget
 346  * @class FlashAdapter
 347  * @uses YAHOO.util.AttributeProvider
 348  */
 349 YAHOO.widget.FlashAdapter = function(swfURL, containerID, attributes, buttonSkin)
 350 {
 351
 352         this._queue = this._queue || [];
 353         this._events = this._events || {};
 354         this._configs = this._configs || {};
 355         attributes = attributes || {};
 356
 357         //the Flash Player external interface code from Adobe doesn't play nicely
 358         //with the default value, yui-gen, in IE
 359         this._id = attributes.id = attributes.id || YAHOO.util.Dom.generateId(null, "yuigen");
 360         attributes.version = attributes.version || "9.0.45";
 361         attributes.backgroundColor = attributes.backgroundColor || "#ffffff";
 362
 363         //we can't use the initial attributes right away
 364         //so save them for once the SWF finishes loading
 365         this._attributes = attributes;
 366
 367         this._swfURL = swfURL;
 368         this._containerID = containerID;
 369
 370         //embed the SWF file in the page
 371         this._embedSWF(this._swfURL, this._containerID, attributes.id, attributes.version,
 372                 attributes.backgroundColor, attributes.expressInstall, attributes.wmode, buttonSkin);
 373
 374         /**
 375          * Fires when the SWF is initialized and communication is possible.
 376          * @event contentReady
 377          */
 378         //Fix for iframe cross-domain issue with FF2x
 379         try
 380         {
 381                 this.createEvent("contentReady");
 382         }
 383         catch(e){}
 384 };
 385
 386 YAHOO.widget.FlashAdapter.owners = YAHOO.widget.FlashAdapter.owners || {};
 387
 388 YAHOO.extend(YAHOO.widget.FlashAdapter, YAHOO.util.AttributeProvider,
 389 {
 390         /**
 391          * The URL of the SWF file.
 392          * @property _swfURL
 393          * @type String
 394          * @private
 395          */
 396         _swfURL: null,
 397
 398         /**
 399          * The ID of the containing DIV.
 400          * @property _containerID
 401          * @type String
 402          * @private
 403          */
 404         _containerID: null,
 405
 406         /**
 407          * A reference to the embedded SWF file.
 408          * @property _swf
 409          * @private
 410          */
 411         _swf: null,
 412
 413         /**
 414          * The id of this instance.
 415          * @property _id
 416          * @type String
 417          * @private
 418          */
 419         _id: null,
 420
 421         /**
 422          * Indicates whether the SWF has been initialized and is ready
 423          * to communicate with JavaScript
 424          * @property _initialized
 425          * @type Boolean
 426          * @private
 427          */
 428         _initialized: false,
 429
 430         /**
 431          * The initializing attributes are stored here until the SWF is ready.
 432          * @property _attributes
 433          * @type Object
 434          * @private
 435          */
 436         _attributes: null, //the intializing attributes
 437
 438         /**
 439          * Public accessor to the unique name of the FlashAdapter instance.
 440          *
 441          * @method toString
 442          * @return {String} Unique name of the FlashAdapter instance.
 443          */
 444         toString: function()
 445         {
 446                 return "FlashAdapter " + this._id;
 447         },
 448
 449         /**
 450          * Nulls out the entire FlashAdapter instance and related objects and removes attached
 451          * event listeners and clears out DOM elements inside the container. After calling
 452          * this method, the instance reference should be expliclitly nulled by implementer,
 453          * as in myChart = null. Use with caution!
 454          *
 455          * @method destroy
 456          */
 457         destroy: function()
 458         {
 459                 //kill the Flash Player instance
 460                 if(this._swf)
 461                 {
 462                         var container = YAHOO.util.Dom.get(this._containerID);
 463                         container.removeChild(this._swf);
 464                 }
 465
 466                 var instanceName = this._id;
 467
 468                 //null out properties
 469                 for(var prop in this)
 470                 {
 471                         if(YAHOO.lang.hasOwnProperty(this, prop))
 472                         {
 473                                 this[prop] = null;
 474                         }
 475                 }
 476
 477         },
 478
 479         /**
 480          * Embeds the SWF in the page and associates it with this instance.
 481          *
 482          * @method _embedSWF
 483          * @private
 484          */
 485         _embedSWF: function(swfURL, containerID, swfID, version, backgroundColor, expressInstall, wmode, buttonSkin)
 486         {
 487                 //standard SWFObject embed
 488                 var swfObj = new YAHOO.deconcept.SWFObject(swfURL, swfID, "100%", "100%", version, backgroundColor);
 489
 490                 if(expressInstall)
 491                 {
 492                         swfObj.useExpressInstall(expressInstall);
 493                 }
 494
 495                 //make sure we can communicate with ExternalInterface
 496                 swfObj.addParam("allowScriptAccess", "always");
 497
 498                 if(wmode)
 499                 {
 500                         swfObj.addParam("wmode", wmode);
 501                 }
 502
 503                 swfObj.addParam("menu", "false");
 504
 505                 //again, a useful ExternalInterface trick
 506                 swfObj.addVariable("allowedDomain", document.location.hostname);
 507
 508                 //tell the SWF which HTML element it is in
 509                 swfObj.addVariable("YUISwfId", swfID);
 510
 511                 // set the name of the function to call when the swf has an event
 512                 swfObj.addVariable("YUIBridgeCallback", "YAHOO.widget.FlashAdapter.eventHandler");
 513                 if (buttonSkin) {
 514                 swfObj.addVariable("buttonSkin", buttonSkin);
 515                 }
 516                 var container = YAHOO.util.Dom.get(containerID);
 517                 var result = swfObj.write(container);
 518                 if(result)
 519                 {
 520                         this._swf = YAHOO.util.Dom.get(swfID);
 521                         YAHOO.widget.FlashAdapter.owners[swfID] = this;
 522                 }
 523                 else
 524                 {
 525                 }
 526         },
 527
 528         /**
 529          * Handles or re-dispatches events received from the SWF.
 530          *
 531          * @method _eventHandler
 532          * @private
 533          */
 534         _eventHandler: function(event)
 535         {
 536                 var type = event.type;
 537                 switch(type)
 538                 {
 539                         case "swfReady":
 540                                 this._loadHandler();
 541                                 return;
 542                         case "log":
 543                                 return;
 544                 }
 545
 546
 547                 //be sure to return after your case or the event will automatically fire!
 548                 this.fireEvent(type, event);
 549         },
 550
 551         /**
 552          * Called when the SWF has been initialized.
 553          *
 554          * @method _loadHandler
 555          * @private
 556          */
 557         _loadHandler: function()
 558         {
 559                 this._initialized = false;
 560                 this._initAttributes(this._attributes);
 561                 this.setAttributes(this._attributes, true);
 562
 563                 this._initialized = true;
 564                 this.fireEvent("contentReady");
 565         },
 566
 567         set: function(name, value)
 568         {
 569                 //save all the attributes in case the swf reloads
 570                 //so that we can pass them in again
 571                 this._attributes[name] = value;
 572                 YAHOO.widget.FlashAdapter.superclass.set.call(this, name, value);
 573         },
 574
 575         /**
 576          * Initializes the attributes.
 577          *
 578          * @method _initAttributes
 579          * @private
 580          */
 581         _initAttributes: function(attributes)
 582         {
 583                 //should be overridden if other attributes need to be set up
 584
 585                 /**
 586                  * @attribute wmode
 587                  * @description Sets the window mode of the Flash Player control. May be
 588                  *              "window", "opaque", or "transparent". Only available in the constructor
 589                  *              because it may not be set after Flash Player has been embedded in the page.
 590                  * @type String
 591                  */
 592
 593                 /**
 594                  * @attribute expressInstall
 595                  * @description URL pointing to a SWF file that handles Flash Player's express
 596                  *              install feature. Only available in the constructor because it may not be
 597                  *              set after Flash Player has been embedded in the page.
 598                  * @type String
 599                  */
 600
 601                 /**
 602                  * @attribute version
 603                  * @description Minimum required version for the SWF file. Only available in the constructor because it may not be
 604                  *              set after Flash Player has been embedded in the page.
 605                  * @type String
 606                  */
 607
 608                 /**
 609                  * @attribute backgroundColor
 610                  * @description The background color of the SWF. Only available in the constructor because it may not be
 611                  *              set after Flash Player has been embedded in the page.
 612                  * @type String
 613                  */
 614
 615                 /**
 616                  * @attribute altText
 617                  * @description The alternative text to provide for screen readers and other assistive technology.
 618                  * @type String
 619                  */
 620                 this.getAttributeConfig("altText",
 621                 {
 622                         method: this._getAltText
 623                 });
 624                 this.setAttributeConfig("altText",
 625                 {
 626                         method: this._setAltText
 627                 });
 628
 629                 /**
 630                  * @attribute swfURL
 631                  * @description Absolute or relative URL to the SWF displayed by the FlashAdapter. Only available in the constructor because it may not be
 632                  *              set after Flash Player has been embedded in the page.
 633                  * @type String
 634                  */
 635                 this.getAttributeConfig("swfURL",
 636                 {
 637                         method: this._getSWFURL
 638                 });
 639         },
 640
 641         /**
 642          * Getter for swfURL attribute.
 643          *
 644          * @method _getSWFURL
 645          * @private
 646          */
 647         _getSWFURL: function()
 648         {
 649                 return this._swfURL;
 650         },
 651
 652         /**
 653          * Getter for altText attribute.
 654          *
 655          * @method _getAltText
 656          * @private
 657          */
 658         _getAltText: function()
 659         {
 660                 return this._swf.getAltText();
 661         },
 662
 663         /**
 664          * Setter for altText attribute.
 665          *
 666          * @method _setAltText
 667          * @private
 668          */
 669         _setAltText: function(value)
 670         {
 671                 return this._swf.setAltText(value);
 672         }
 673 });
 674
 675
 676 /**
 677  * Receives event messages from SWF and passes them to the correct instance
 678  * of FlashAdapter.
 679  *
 680  * @method YAHOO.widget.FlashAdapter.eventHandler
 681  * @static
 682  * @private
 683  */
 684 YAHOO.widget.FlashAdapter.eventHandler = function(elementID, event)
 685 {
 686
 687         if(!YAHOO.widget.FlashAdapter.owners[elementID])
 688         {
 689                 //fix for ie: if owner doesn't exist yet, try again in a moment
 690                 setTimeout(function() { YAHOO.widget.FlashAdapter.eventHandler( elementID, event ); }, 0);
 691         }
 692         else
 693         {
 694                 YAHOO.widget.FlashAdapter.owners[elementID]._eventHandler(event);
 695         }
 696 };
 697
 698 /**
 699  * The number of proxy functions that have been created.
 700  * @static
 701  * @private
 702  */
 703 YAHOO.widget.FlashAdapter.proxyFunctionCount = 0;
 704
 705 /**
 706  * Creates a globally accessible function that wraps a function reference.
 707  * Returns the proxy function's name as a string for use by the SWF through
 708  * ExternalInterface.
 709  *
 710  * @method YAHOO.widget.FlashAdapter.createProxyFunction
 711  * @static
 712  * @private
 713  */
 714 YAHOO.widget.FlashAdapter.createProxyFunction = function(func)
 715 {
 716         var index = YAHOO.widget.FlashAdapter.proxyFunctionCount;
 717         YAHOO.widget.FlashAdapter["proxyFunction" + index] = function()
 718         {
 719                 return func.apply(null, arguments);
 720         };
 721         YAHOO.widget.FlashAdapter.proxyFunctionCount++;
 722         return "YAHOO.widget.FlashAdapter.proxyFunction" + index.toString();
 723 };
 724
 725 /**
 726  * Removes a function created with createProxyFunction()
 727  *
 728  * @method YAHOO.widget.FlashAdapter.removeProxyFunction
 729  * @static
 730  * @private
 731  */
 732 YAHOO.widget.FlashAdapter.removeProxyFunction = function(funcName)
 733 {
 734         //quick error check
 735         if(!funcName || funcName.indexOf("YAHOO.widget.FlashAdapter.proxyFunction") < 0)
 736         {
 737                 return;
 738         }
 739
 740         funcName = funcName.substr(26);
 741         YAHOO.widget.FlashAdapter[funcName] = null;
 742 };
 743 /**
 744  * The YUI Uploader Control
 745  * @module uploader
 746  * @description <p>YUI Uploader provides file upload functionality that goes beyond the basic browser-based methods.
 747  * Specifically, the YUI Uploader allows for:
 748  * <ol>
 749  * <li> Multiple file selection in a single "Open File" dialog.</li>
 750  * <li> File extension filters to facilitate the user's selection.</li>
 751  * <li> Progress tracking for file uploads.</li>
 752  * <li> A range of file metadata: filename, size, date created, date modified, and author.</li>
 753  * <li> A set of events dispatched on various aspects of the file upload process: file selection, upload progress, upload completion, etc.</li>
 754  * <li> Inclusion of additional data in the file upload POST request.</li>
 755  * <li> Faster file upload on broadband connections due to the modified SEND buffer size.</li>
 756  * <li> Same-page server response upon completion of the file upload.</li>
 757  * </ol>
 758  * </p>
 759  * @title Uploader
 760  * @namespace YAHOO.widget
 761  * @requires yahoo, dom, element, event
 762  */
 763 /**
 764  * Uploader class for the YUI Uploader component.
 765  *
 766  * @namespace YAHOO.widget
 767  * @class Uploader
 768  * @uses YAHOO.widget.FlashAdapter
 769  * @constructor
 770  * @param containerId {HTMLElement} Container element for the Flash Player instance.
 771  * @param buttonSkin {String} [optional]. If defined, the uploader is
 772  * rendered as a button. This parameter must provide the URL of a button
 773  * skin sprite image. Acceptable types are: jpg, gif, png and swf. The
 774  * sprite is divided evenly into four sections along its height (e.g., if
 775  * the sprite is 200 px tall, it's divided into four sections 50px each).
 776  * Each section is used as a skin for a specific state of the button: top
 777  * section is "up", second section is "over", third section is "down", and
 778  * fourth section is "disabled".
 779  * If the parameter is not supplied, the uploader is rendered transparent,
 780  * and it's the developer's responsibility to create a visible UI below it.
 781  * @param forceTransparent {Boolean} This parameter, if true, forces the Flash
 782  * UI to be rendered with wmode set to "transparent". This behavior is useful
 783  * in conjunction with non-rectangular button skins with PNG transparency.
 784  * The parameter is false by default, and ignored if no buttonSkin is defined.
 785   */
 786 YAHOO.widget.Uploader = function(containerId, buttonSkin, forceTransparent)
 787 {
 788         var newWMode = "window";
 789
 790         if (!(buttonSkin) || (buttonSkin && forceTransparent)) {
 791                 newWMode = "transparent";
 792         }
 793
 794
 795         YAHOO.widget.Uploader.superclass.constructor.call(this, YAHOO.widget.Uploader.SWFURL, containerId, {wmode:newWMode}, buttonSkin);
 796
 797         /**
 798          * Fires when the mouse is pressed over the Uploader.
 799          * Only fires when the Uploader UI is enabled and
 800          * the render type is 'transparent'.
 801          *
 802          * @event mouseDown
 803          * @param event.type {String} The event type
 804          */
 805         this.createEvent("mouseDown");
 806
 807         /**
 808          * Fires when the mouse is released over the Uploader.
 809          * Only fires when the Uploader UI is enabled and
 810          * the render type is 'transparent'.
 811          *
 812          * @event mouseUp
 813          * @param event.type {String} The event type
 814          */
 815         this.createEvent("mouseUp");
 816
 817         /**
 818          * Fires when the mouse rolls over the Uploader.
 819          *
 820          * @event rollOver
 821          * @param event.type {String} The event type
 822          */
 823         this.createEvent("rollOver");
 824
 825         /**
 826          * Fires when the mouse rolls out of the Uploader.
 827          *
 828          * @event rollOut
 829          * @param event.type {String} The event type
 830          */
 831         this.createEvent("rollOut");
 832
 833         /**
 834          * Fires when the uploader is clicked.
 835          *
 836          * @event click
 837          * @param event.type {String} The event type
 838          */
 839         this.createEvent("click");
 840
 841         /**
 842          * Fires when the user has finished selecting files in the "Open File" dialog.
 843          *
 844          * @event fileSelect
 845          * @param event.type {String} The event type
 846          * @param event.fileList {Object} A dictionary of objects with file information
 847          * @param event.fileList[].size {Number} File size in bytes for a specific file in fileList
 848          * @param event.fileList[].cDate {Date} Creation date for a specific file in fileList
 849          * @param event.fileList[].mDate {Date} Modification date for a specific file in fileList
 850          * @param event.fileList[].name {String} File name for a specific file in fileList
 851          * @param event.fileList[].id {String} Unique file id of a specific file in fileList
 852          */
 853         this.createEvent("fileSelect");
 854
 855         /**
 856          * Fires when an upload of a specific file has started.
 857          *
 858          * @event uploadStart
 859          * @param event.type {String} The event type
 860          * @param event.id {String} The id of the file that's started to upload
 861          */
 862         this.createEvent("uploadStart");
 863
 864         /**
 865          * Fires when new information about the upload progress for a specific file is available.
 866          *
 867          * @event uploadProgress
 868          * @param event.type {String} The event type
 869          * @param event.id {String} The id of the file with which the upload progress data is associated
 870          * @param bytesLoaded {Number} The number of bytes of the file uploaded so far
 871          * @param bytesTotal {Number} The total size of the file
 872          */
 873         this.createEvent("uploadProgress");
 874
 875         /**
 876          * Fires when an upload for a specific file is cancelled.
 877          *
 878          * @event uploadCancel
 879          * @param event.type {String} The event type
 880          * @param event.id {String} The id of the file with which the upload has been cancelled.
 881          */
 882         this.createEvent("uploadCancel");
 883
 884         /**
 885          * Fires when an upload for a specific file is complete.
 886          *
 887          * @event uploadComplete
 888          * @param event.type {String} The event type
 889          * @param event.id {String} The id of the file for which the upload has been completed.
 890          */
 891         this.createEvent("uploadComplete");
 892
 893         /**
 894          * Fires when the server sends data in response to a completed upload.
 895          *
 896          * @event uploadCompleteData
 897          * @param event.type {String} The event type
 898          * @param event.id {String} The id of the file for which the upload has been completed.
 899          * @param event.data {String} The raw data returned by the server in response to the upload.
 900          */
 901         this.createEvent("uploadCompleteData");
 902
 903         /**
 904          * Fires when an upload error occurs.
 905          *
 906          * @event uploadError
 907          * @param event.type {String} The event type
 908          * @param event.id {String} The id of the file that was being uploaded when the error has occurred.
 909          * @param event.status {String} The status message associated with the error.
 910          */
 911         this.createEvent("uploadError");
 912 }
 913
 914 /**
 915  * Location of the Uploader SWF
 916  *
 917  * @property Chart.SWFURL
 918  * @private
 919  * @static
 920  * @final
 921  * @default "assets/uploader.swf"
 922  */
 923 YAHOO.widget.Uploader.SWFURL = "assets/uploader.swf";
 924
 925 YAHOO.extend(YAHOO.widget.Uploader, YAHOO.widget.FlashAdapter,
 926 {
 927 /**
 928  * Starts the upload of the file specified by fileID to the location specified by uploadScriptPath.
 929  *
 930  * @param fileID {String} The id of the file to start uploading.
 931  * @param uploadScriptPath {String} The URL of the upload location.
 932  * @param method {String} Either "GET" or "POST", specifying how the variables accompanying the file upload POST request should be submitted. "GET" by default.
 933  * @param vars {Object} The object containing variables to be sent in the same request as the file upload.
 934  * @param fieldName {String} The name of the variable in the POST request containing the file data. "Filedata" by default.
 935  * </code>
 936  */
 937         upload: function(fileID, uploadScriptPath, method, vars, fieldName)
 938         {
 939                 this._swf.upload(fileID, uploadScriptPath, method, vars, fieldName);
 940         },
 941
 942 /**
 943  * Starts the upload of the files specified by fileIDs, or adds them to a currently running queue. The upload queue is automatically managed.
 944  *
 945  * @param fileIDs {Array} The ids of the files to start uploading.
 946  * @param uploadScriptPath {String} The URL of the upload location.
 947  * @param method {String} Either "GET" or "POST", specifying how the variables accompanying the file upload POST request should be submitted. "GET" by default.
 948  * @param vars {Object} The object containing variables to be sent in the same request as the file upload.
 949  * @param fieldName {String} The name of the variable in the POST request containing the file data. "Filedata" by default.
 950  * </code>
 951  */
 952         uploadThese: function(fileIDs, uploadScriptPath, method, vars, fieldName)
 953         {
 954                 this._swf.uploadThese(fileIDs, uploadScriptPath, method, vars, fieldName);
 955         },
 956
 957 /**
 958  * Starts uploading all files in the queue. If this function is called, the upload queue is automatically managed.
 959  *
 960  * @param uploadScriptPath {String} The URL of the upload location.
 961  * @param method {String} Either "GET" or "POST", specifying how the variables accompanying the file upload POST request should be submitted. "GET" by default.
 962  * @param vars {Object} The object containing variables to be sent in the same request as the file upload.
 963  * @param fieldName {String} The name of the variable in the POST request containing the file data. "Filedata" by default.
 964  * </code>
 965  */
 966         uploadAll: function(uploadScriptPath, method, vars, fieldName)
 967         {
 968                 this._swf.uploadAll(uploadScriptPath, method, vars, fieldName);
 969         },
 970
 971 /**
 972  * Cancels the upload of a specified file. If no file id is specified, all ongoing uploads are cancelled.
 973  *
 974  * @param fileID {String} The ID of the file whose upload should be cancelled.
 975  */
 976         cancel: function(fileID)
 977         {
 978                 this._swf.cancel(fileID);
 979         },
 980
 981 /**
 982  * Clears the list of files queued for upload.
 983  *
 984  */
 985         clearFileList: function()
 986         {
 987                 this._swf.clearFileList();
 988         },
 989
 990 /**
 991  * Removes the specified file from the upload queue.
 992  *
 993  * @param fileID {String} The id of the file to remove from the upload queue.
 994  */
 995         removeFile: function (fileID)
 996         {
 997                 this._swf.removeFile(fileID);
 998         },
 999
1000 /**
1001  * Turns the logging functionality on.
1002  * Uses Flash internal trace logging, as well as YUI Logger, if available.
1003  *
1004  * @param allowLogging {Boolean} If true, logs are output; otherwise, no logs are produced.
1005  */
1006     setAllowLogging: function (allowLogging)
1007     {
1008         this._swf.setAllowLogging(allowLogging);
1009     },
1010
1011 /**
1012  * Sets the number of simultaneous uploads when using uploadAll()
1013  * The minimum value is 1, and maximum value is 5. The default value is 2.
1014  *
1015  * @param simUploadLimit {int} Number of simultaneous uploads, between 1 and 5.
1016  */
1017     setSimUploadLimit : function (simUploadLimit)
1018     {
1019        this._swf.setSimUploadLimit(simUploadLimit);
1020     },
1021
1022 /**
1023  * Sets the flag allowing users to select multiple files for the upload.
1024  *
1025  * @param allowMultipleFiles {Boolean} If true, multiple files can be selected. False by default.
1026  */
1027     setAllowMultipleFiles : function (allowMultipleFiles)
1028     {
1029        this._swf.setAllowMultipleFiles(allowMultipleFiles);
1030     },
1031
1032 /**
1033  * Sets the file filters for the "Browse" dialog.
1034  *
1035  *  @param newFilterArray An array of sets of key-value pairs of the form
1036  *  {extensions: extensionString, description: descriptionString, [optional]macType: macTypeString}
1037  *  The extensions string is a semicolon-delimited list of elements of the form "*.xxx",
1038  *  e.g. "*.jpg;*.gif;*.png".
1039  */
1040     setFileFilters : function (fileFilters)
1041     {
1042        this._swf.setFileFilters(fileFilters);
1043     },
1044
1045         /**
1046          * Enables the mouse events on the Uploader.
1047          * If the uploader is being rendered as a button,
1048          * then the button's skin is set to "up"
1049          * (first section of the button skin sprite).
1050          *
1051          */
1052         enable : function ()
1053         {
1054                 this._swf.enable();
1055         },
1056
1057         /**
1058          * Disables the mouse events on the Uploader.
1059          * If the uploader is being rendered as a button,
1060          * then the button's skin is set to "disabled"
1061          * (fourth section of the button skin sprite).
1062          *
1063          */
1064         disable : function ()
1065         {
1066                 this._swf.disable();
1067         }
1068 });
1069 YAHOO.register("uploader", YAHOO.widget.Uploader, {version: "2.9.0", build: "2800"});