← Back to branch summary

~bcsaller/juju-gui/charmFind

« back to all changes in this revision

Viewing changes to lib/yui/build/uploader-flash/uploader-flash-debug.js

  • Committer: kapil.foss at gmail
  • Date: 2012-07-13 18:45:59 UTC
  • Revision ID: kapil.foss@gmail.com-20120713184559-2xl7be17egsrz0c9
reshape

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/yui/build/uploader-flash/uploader-flash-debug.js
1
 
/*
2
 
YUI 3.5.1 (build 22)
3
 
Copyright 2012 Yahoo! Inc. All rights reserved.
4
 
Licensed under the BSD License.
5
 
http://yuilibrary.com/license/
6
 
*/
7
 
YUI.add('uploader-flash', function(Y) {
8
 
 
9
 
 
10
 
    /**
11
 
     * This module provides a UI for file selection and multiple file upload capability using
12
 
     * Flash as a transport engine.
13
 
     * The supported features include: automatic upload queue management, upload progress
14
 
     * tracking, file filtering, server response retrieval and error reporting.
15
 
     *
16
 
     * @module uploader-flash
17
 
     */     
18
 
 
19
 
// Shorthands for external modules
20
 
var  substitute            = Y.substitute,
21
 
     UploaderQueue         = Y.Uploader.Queue,
22
 
     getCN                 = Y.ClassNameManager.getClassName,
23
 
     UPLOADER              = 'uploader',
24
 
     SELECT_FILES          = getCN(UPLOADER, 'selectfiles-button');
25
 
 
26
 
 
27
 
    /**
28
 
     * This module provides a UI for file selection and multiple file upload capability
29
 
     * using Flash as a transport engine.
30
 
     * @class UploaderFlash
31
 
     * @extends Widget
32
 
     * @constructor
33
 
     * @param {Object} config Configuration object.
34
 
     */
35
 
 
36
 
function UploaderFlash(config) {
37
 
  UploaderFlash.superclass.constructor.apply ( this, arguments );
38
 
}
39
 
 
40
 
 
41
 
 
42
 
Y.UploaderFlash = Y.extend(UploaderFlash, Y.Widget, {
43
 
 
44
 
  /**
45
 
   * Stored value of the current button state (based on 
46
 
   * mouse events dispatched by the Flash player)
47
 
   * @property _buttonState
48
 
   * @type {String}
49
 
   * @protected
50
 
   */
51
 
  _buttonState: "up",
52
 
 
53
 
  /**
54
 
   * Stored value of the current button focus state (based 
55
 
   * on keyboard and mouse events).
56
 
   * @property _buttonFocus
57
 
   * @type {Boolean}
58
 
   * @protected
59
 
   */
60
 
  _buttonFocus: false,
61
 
 
62
 
  /**
63
 
   * Stored value of the unique id for the container that holds the 
64
 
   * Flash uploader.
65
 
   *
66
 
   * @property _swfContainerId
67
 
   * @type {String}
68
 
   * @protected
69
 
   */
70
 
  _swfContainerId: null,
71
 
 
72
 
  /**
73
 
   * Stored reference to the instance of SWF used to host the
74
 
   * Flash uploader.
75
 
   *
76
 
   * @property _swfReference
77
 
   * @type {SWF}
78
 
   * @protected
79
 
   */
80
 
  _swfReference: null,
81
 
 
82
 
  /**
83
 
   * Stored reference to the instance of Uploader.Queue used to manage
84
 
   * the upload process. This is a read-only property that only exists
85
 
   * during an active upload process. Only one queue can be active at
86
 
   * a time; if an upload start is attempted while a queue is active,
87
 
   * it will be ignored.
88
 
   *
89
 
   * @property queue
90
 
   * @type {Y.Uploader.Queue}
91
 
   */
92
 
   queue: null,
93
 
 
94
 
  /**
95
 
   * Stored event bindings for keyboard navigation to and from the uploader.
96
 
   *
97
 
   * @property _tabElementBindings
98
 
   * @type {Object}
99
 
   * @protected
100
 
   */
101
 
  _tabElementBindings: null,
102
 
 
103
 
 
104
 
/**
105
 
 * Construction logic executed during UploaderFlash instantiation.
106
 
 *
107
 
 * @method initializer
108
 
 * @protected
109
 
 */
110
 
  initializer : function () {
111
 
 
112
 
    // Assign protected variable values
113
 
    this._swfContainerId = Y.guid("uploader");
114
 
    this._swfReference = null;
115
 
    this.queue = null;
116
 
    this._buttonState = "up";
117
 
    this._buttonFocus = null;
118
 
    this._tabElementBindings = null;
119
 
 
120
 
    // Publish available events
121
 
 
122
 
   /**
123
 
    * Signals that files have been selected. 
124
 
    *
125
 
    * @event fileselect
126
 
    * @param event {Event} The event object for the `fileselect` with the
127
 
    *                      following payload:
128
 
    *  <dl>
129
 
    *      <dt>fileList</dt>
130
 
    *          <dd>An `Array` of files selected by the user, encapsulated
131
 
    *              in Y.FileFlash objects.</dd>
132
 
    *  </dl>
133
 
    */
134
 
    this.publish("fileselect");
135
 
 
136
 
   /**
137
 
    * Signals that an upload of multiple files has been started. 
138
 
    *
139
 
    * @event uploadstart
140
 
    * @param event {Event} The event object for the `uploadstart`.
141
 
    */
142
 
    this.publish("uploadstart");
143
 
 
144
 
   /**
145
 
    * Signals that an upload of a specific file has started. 
146
 
    *
147
 
    * @event fileuploadstart
148
 
    * @param event {Event} The event object for the `fileuploadstart` with the
149
 
    *                      following payload:
150
 
    *  <dl>
151
 
    *      <dt>file</dt>
152
 
    *          <dd>A reference to the Y.File that dispatched the event.</dd>
153
 
    *      <dt>originEvent</dt>
154
 
    *          <dd>The original event dispatched by Y.File.</dd>
155
 
    *  </dl>
156
 
    */
157
 
    this.publish("fileuploadstart");
158
 
 
159
 
   /**
160
 
    * Reports on upload progress of a specific file. 
161
 
    *
162
 
    * @event uploadprogress
163
 
    * @param event {Event} The event object for the `uploadprogress` with the
164
 
    *                      following payload:
165
 
    *  <dl>
166
 
    *      <dt>bytesLoaded</dt>
167
 
    *          <dd>The number of bytes of the file that has been uploaded</dd>
168
 
    *      <dt>bytesTotal</dt>
169
 
    *          <dd>The total number of bytes in the file</dd>
170
 
    *      <dt>percentLoaded</dt>
171
 
    *          <dd>The fraction of the file that has been uploaded, out of 100</dd>
172
 
    *      <dt>originEvent</dt>
173
 
    *          <dd>The original event dispatched by the SWF uploader</dd>
174
 
    *  </dl>
175
 
    */
176
 
    this.publish("uploadprogress");
177
 
 
178
 
   /**
179
 
    * Reports on the total upload progress of the file list. 
180
 
    *
181
 
    * @event totaluploadprogress
182
 
    * @param event {Event} The event object for the `totaluploadprogress` with the
183
 
    *                      following payload:
184
 
    *  <dl>
185
 
    *      <dt>bytesLoaded</dt>
186
 
    *          <dd>The number of bytes of the file list that has been uploaded</dd>
187
 
    *      <dt>bytesTotal</dt>
188
 
    *          <dd>The total number of bytes in the file list</dd>
189
 
    *      <dt>percentLoaded</dt>
190
 
    *          <dd>The fraction of the file list that has been uploaded, out of 100</dd>
191
 
    *  </dl>
192
 
    */
193
 
    this.publish("totaluploadprogress");
194
 
 
195
 
   /**
196
 
    * Signals that a single file upload has been completed. 
197
 
    *
198
 
    * @event uploadcomplete
199
 
    * @param event {Event} The event object for the `uploadcomplete` with the
200
 
    *                      following payload:
201
 
    *  <dl>
202
 
    *      <dt>file</dt>
203
 
    *          <dd>The pointer to the instance of `Y.File` whose upload has been completed.</dd>
204
 
    *      <dt>originEvent</dt>
205
 
    *          <dd>The original event fired by the SWF Uploader</dd>
206
 
    *      <dt>data</dt>
207
 
    *          <dd>Data returned by the server.</dd>
208
 
    *  </dl>
209
 
    */
210
 
    this.publish("uploadcomplete");
211
 
 
212
 
   /**
213
 
    * Signals that the upload process of the entire file list has been completed. 
214
 
    *
215
 
    * @event alluploadscomplete
216
 
    * @param event {Event} The event object for the `alluploadscomplete`.
217
 
    */
218
 
    this.publish("alluploadscomplete");
219
 
 
220
 
   /**
221
 
    * Signals that a error has occurred in a specific file's upload process. 
222
 
    *
223
 
    * @event uploaderror
224
 
    * @param event {Event} The event object for the `uploaderror` with the
225
 
    *                      following payload:
226
 
    *  <dl>
227
 
    *      <dt>originEvent</dt>
228
 
    *          <dd>The original error event fired by the SWF Uploader. </dd>
229
 
    *      <dt>file</dt>
230
 
    *          <dd>The pointer at the instance of Y.FileFlash that returned the error.</dd>
231
 
    *      <dt>source</dt>
232
 
    *          <dd>The source of the upload error, either "io" or "http"</dd>       
233
 
    *      <dt>message</dt>
234
 
    *          <dd>The message that accompanied the error. Corresponds to the text of
235
 
    *              the error in cases where source is "io", and to the HTTP status for
236
 
                   cases where source is "http".</dd>     
237
 
    *  </dl>
238
 
    */
239
 
    this.publish("uploaderror");
240
 
 
241
 
   /**
242
 
    * Signals that a mouse has begun hovering over the `Select Files` button. 
243
 
    *
244
 
    * @event mouseenter
245
 
    * @param event {Event} The event object for the `mouseenter` event.
246
 
    */
247
 
    this.publish("mouseenter");
248
 
 
249
 
   /**
250
 
    * Signals that a mouse has stopped hovering over the `Select Files` button. 
251
 
    *
252
 
    * @event mouseleave
253
 
    * @param event {Event} The event object for the `mouseleave` event.
254
 
    */
255
 
    this.publish("mouseleave");
256
 
 
257
 
   /**
258
 
    * Signals that a mouse button has been pressed over the `Select Files` button. 
259
 
    *
260
 
    * @event mousedown
261
 
    * @param event {Event} The event object for the `mousedown` event.
262
 
    */
263
 
    this.publish("mousedown");
264
 
 
265
 
   /**
266
 
    * Signals that a mouse button has been released over the `Select Files` button. 
267
 
    *
268
 
    * @event mouseup
269
 
    * @param event {Event} The event object for the `mouseup` event.
270
 
    */
271
 
    this.publish("mouseup");
272
 
 
273
 
   /**
274
 
    * Signals that a mouse has been clicked over the `Select Files` button. 
275
 
    *
276
 
    * @event click
277
 
    * @param event {Event} The event object for the `click` event.
278
 
    */
279
 
    this.publish("click");
280
 
  },
281
 
 
282
 
  /**
283
 
   * Creates the DOM structure for the UploaderFlash.
284
 
   * UploaderFlash's DOM structure consists of two layers: the base "Select Files"
285
 
   * button that can be replaced by the developer's widget of choice; and a transparent
286
 
   * Flash overlay positoned above the button that captures all input events.
287
 
   * The `position` style attribute of the `boundingBox` of the `Uploader` widget
288
 
   * is forced to be `relative`, in order to accommodate the Flash player overlay
289
 
   * (which is `position`ed `absolute`ly).
290
 
   *
291
 
   * @method renderUI
292
 
   * @protected
293
 
   */
294
 
  renderUI : function () {
295
 
     var boundingBox = this.get("boundingBox"),
296
 
         contentBox = this.get('contentBox'),
297
 
         selFilesButton = this.get("selectFilesButton");
298
 
 
299
 
     boundingBox.setStyle("position", "relative");
300
 
     selFilesButton.setStyles({width: "100%", height: "100%"});
301
 
     contentBox.append(selFilesButton);
302
 
     contentBox.append(Y.Node.create(substitute(UploaderFlash.FLASH_CONTAINER, 
303
 
                                              {swfContainerId: this._swfContainerId})));
304
 
     var flashContainer = Y.one("#" + this._swfContainerId);
305
 
     var params = {version: "10.0.45",
306
 
                     fixedAttributes: {wmode: "transparent", 
307
 
                                       allowScriptAccess:"always", 
308
 
                                       allowNetworking:"all", 
309
 
                                       scale: "noscale"
310
 
                                      }
311
 
                    };
312
 
     this._swfReference = new Y.SWF(flashContainer, this.get("swfURL"), params);
313
 
  },
314
 
 
315
 
  /**
316
 
   * Binds handlers to the UploaderFlash UI events and propagates attribute
317
 
   * values to the Flash player.
318
 
   * The propagation of initial values is set to occur once the Flash player 
319
 
   * instance is ready (as indicated by the `swfReady` event.)
320
 
   *
321
 
   * @method bindUI
322
 
   * @protected
323
 
   */
324
 
  bindUI : function () {
325
 
 
326
 
    this._swfReference.on("swfReady", function () {
327
 
      this._setMultipleFiles();
328
 
      this._setFileFilters();
329
 
      this._triggerEnabled();
330
 
      this.after("multipleFilesChange", this._setMultipleFiles, this);
331
 
      this.after("fileFiltersChange", this._setFileFilters, this);
332
 
      this.after("enabledChange", this._triggerEnabled, this);
333
 
    }, this);
334
 
        
335
 
    this._swfReference.on("fileselect", this._updateFileList, this);
336
 
 
337
 
        this.after("tabElementsChange", this._attachTabElements);
338
 
        this._attachTabElements();
339
 
 
340
 
        // this._swfReference.on("trace", function (ev) {console.log(ev.message);});
341
 
 
342
 
        this._swfReference.on("mouseenter", function () {
343
 
            this.fire("mouseenter");
344
 
            this._setButtonClass("hover", true);
345
 
            if (this._buttonState == "down") {
346
 
                this._setButtonClass("active", true);
347
 
            }
348
 
        }, this);
349
 
        this._swfReference.on("mouseleave", function () {
350
 
            this.fire("mouseleave");
351
 
            this._setButtonClass("hover", false);
352
 
            this._setButtonClass("active", false);
353
 
            
354
 
        }, this);
355
 
        this._swfReference.on("mousedown", function () {
356
 
            this.fire("mousedown");
357
 
            this._buttonState = "down";
358
 
            this._setButtonClass("active", true);
359
 
        }, this);
360
 
        this._swfReference.on("mouseup", function () {
361
 
            this.fire("mouseup");
362
 
            this._buttonState = "up";
363
 
            this._setButtonClass("active", false);
364
 
        }, this);
365
 
        this._swfReference.on("click", function () {
366
 
            this.fire("click");
367
 
            this._buttonFocus = true;
368
 
            this._setButtonClass("focus", true);
369
 
            Y.one("body").focus();
370
 
            this._swfReference._swf.focus();
371
 
        }, this);
372
 
  },
373
 
 
374
 
  /**
375
 
   * Attaches keyboard bindings to enabling tabbing to and from the instance of the Flash
376
 
   * player in the Uploader widget. If the previous and next elements are specified, the
377
 
   * keyboard bindings enable the user to tab from the `tabElements["from"]` node to the 
378
 
   * Flash-powered "Select Files" button, and to the `tabElements["to"]` node. 
379
 
   *
380
 
   * @method _attachTabElements
381
 
   * @protected
382
 
   * @param ev {Event} Optional event payload if called as a `tabElementsChange` handler.
383
 
   */
384
 
  _attachTabElements : function (ev) {
385
 
      if (this.get("tabElements") !== null && this.get("tabElements").from !== null && this.get("tabElements").to !== null) {
386
 
 
387
 
        if (this._tabElementBindings !== null) {
388
 
          this._tabElementBindings.from.detach();
389
 
          this._tabElementBindings.to.detach();
390
 
          this._tabElementBindings.tabback.detach();
391
 
          this._tabElementBindings.tabforward.detach();
392
 
          this._tabElementBindings.focus.detach();
393
 
          this._tabElementBindings.blur.detach();
394
 
        }
395
 
        else {
396
 
          this._tabElementBindings = {};
397
 
        }
398
 
 
399
 
          var fromElement = Y.one(this.get("tabElements").from);
400
 
          var toElement = Y.one(this.get("tabElements").to);
401
 
 
402
 
 
403
 
          this._tabElementBindings.from = fromElement.on("keydown", function (ev) { 
404
 
                                                    if (ev.keyCode == 9 && !ev.shiftKey) {
405
 
                                                        ev.preventDefault();
406
 
                                                        this._swfReference._swf.setAttribute("tabindex", 0); 
407
 
                                                        this._swfReference._swf.setAttribute("role", "button");
408
 
                                                        this._swfReference._swf.setAttribute("aria-label", this.get("selectButtonLabel"));
409
 
                                                        this._swfReference._swf.focus();
410
 
                                                    }
411
 
                                                  }, this);
412
 
          this._tabElementBindings.to = toElement.on("keydown", function (ev) { 
413
 
                                                    if (ev.keyCode == 9 && ev.shiftKey) {
414
 
                                                        ev.preventDefault();
415
 
                                                        this._swfReference._swf.setAttribute("tabindex", 0); 
416
 
                                                        this._swfReference._swf.setAttribute("role", "button");
417
 
                                                        this._swfReference._swf.setAttribute("aria-label", this.get("selectButtonLabel"));
418
 
                                                        this._swfReference._swf.focus();
419
 
                                                    }
420
 
                                                  }, this);
421
 
          this._tabElementBindings.tabback = this._swfReference.on("tabback", function (ev) {this._swfReference._swf.blur(); setTimeout(function () {fromElement.focus();}, 30);}, this);
422
 
          this._tabElementBindings.tabforward = this._swfReference.on("tabforward", function (ev) {this._swfReference._swf.blur(); setTimeout(function () {toElement.focus();}, 30);}, this);
423
 
 
424
 
          this._tabElementBindings.focus = this._swfReference._swf.on("focus", function (ev) {this._buttonFocus = true; this._setButtonClass("focus", true);}, this);
425
 
          this._tabElementBindings.blur = this._swfReference._swf.on("blur", function (ev) {this._buttonFocus = false; this._setButtonClass("focus", false);}, this);
426
 
      }
427
 
      else if (this._tabElementBindings !== null) {
428
 
          this._tabElementBindings.from.detach();
429
 
          this._tabElementBindings.to.detach();
430
 
          this._tabElementBindings.tabback.detach();
431
 
          this._tabElementBindings.tabforward.detach();
432
 
          this._tabElementBindings.focus.detach();
433
 
          this._tabElementBindings.blur.detach();
434
 
      }
435
 
  },
436
 
 
437
 
 
438
 
  /**
439
 
   * Adds or removes a specified state CSS class to the underlying uploader button. 
440
 
   *
441
 
   * @method _setButtonClass
442
 
   * @protected
443
 
   * @param state {String} The name of the state enumerated in `buttonClassNames` attribute
444
 
   * from which to derive the needed class name.
445
 
   * @param add {Boolean} A Boolean indicating whether to add or remove the class.
446
 
   */
447
 
  _setButtonClass : function (state, add) {
448
 
      if (add) {
449
 
          this.get("selectFilesButton").addClass(this.get("buttonClassNames")[state]);
450
 
      }
451
 
      else {
452
 
          this.get("selectFilesButton").removeClass(this.get("buttonClassNames")[state]);
453
 
      }
454
 
  },
455
 
 
456
 
 
457
 
  /**
458
 
   * Syncs the state of the `fileFilters` attribute between the instance of UploaderFlash
459
 
   * and the Flash player.
460
 
   * 
461
 
   * @method _setFileFilters
462
 
   * @private
463
 
   */
464
 
  _setFileFilters : function () {
465
 
          if (this._swfReference && this.get("fileFilters") !== null) {
466
 
            this._swfReference.callSWF("setFileFilters", [this.get("fileFilters")]);
467
 
          } 
468
 
 
469
 
  },
470
 
 
471
 
 
472
 
 
473
 
  /**
474
 
   * Syncs the state of the `multipleFiles` attribute between this class
475
 
   * and the Flash uploader.
476
 
   * 
477
 
   * @method _setMultipleFiles
478
 
   * @private
479
 
   */
480
 
  _setMultipleFiles : function () {
481
 
        if (this._swfReference) {
482
 
      this._swfReference.callSWF("setAllowMultipleFiles", [this.get("multipleFiles")]);
483
 
    }
484
 
  },
485
 
 
486
 
  /**
487
 
   * Syncs the state of the `enabled` attribute between this class
488
 
   * and the Flash uploader.
489
 
   * 
490
 
   * @method _triggerEnabled
491
 
   * @private
492
 
   */
493
 
  _triggerEnabled : function () {
494
 
      if (this.get("enabled")) {
495
 
        this._swfReference.callSWF("enable");
496
 
        this._swfReference._swf.setAttribute("aria-disabled", "false");
497
 
        this._setButtonClass("disabled", false);
498
 
      }
499
 
      else {
500
 
        this._swfReference.callSWF("disable");
501
 
        this._swfReference._swf.setAttribute("aria-disabled", "true");
502
 
        this._setButtonClass("disabled", true);
503
 
      }
504
 
  },
505
 
 
506
 
  /**
507
 
   * Adjusts the content of the `fileList` based on the results of file selection
508
 
   * and the `appendNewFiles` attribute. If the `appendNewFiles` attribute is true,
509
 
   * then selected files are appended to the existing list; otherwise, the list is
510
 
   * cleared and populated with the newly selected files.
511
 
   * 
512
 
   * @method _updateFileList
513
 
   * @param ev {Event} The file selection event received from the uploader.
514
 
   * @private
515
 
   */
516
 
  _updateFileList : function (ev) {
517
 
     
518
 
     Y.one("body").focus();
519
 
     this._swfReference._swf.focus();
520
 
 
521
 
 
522
 
     var newfiles = ev.fileList,
523
 
         fileConfObjects = [],
524
 
         parsedFiles = [],
525
 
         swfRef = this._swfReference;
526
 
 
527
 
     Y.each(newfiles, function (value) {
528
 
       var newFileConf = {};
529
 
       newFileConf.id = value.fileId;
530
 
       newFileConf.name = value.fileReference.name;
531
 
       newFileConf.size = value.fileReference.size;
532
 
       newFileConf.type = value.fileReference.type;
533
 
       newFileConf.dateCreated = value.fileReference.creationDate;
534
 
       newFileConf.dateModified = value.fileReference.modificationDate;
535
 
       newFileConf.uploader = swfRef;
536
 
 
537
 
       fileConfObjects.push(newFileConf);
538
 
     });
539
 
 
540
 
     Y.each(fileConfObjects, function (value) {
541
 
       parsedFiles.push(new Y.FileFlash(value));
542
 
     });
543
 
 
544
 
     this.fire("fileselect", {fileList: parsedFiles});
545
 
 
546
 
     var oldfiles = this.get("fileList");
547
 
 
548
 
   this.set("fileList", 
549
 
             this.get("appendNewFiles") ? oldfiles.concat(parsedFiles) : parsedFiles );
550
 
 
551
 
  },
552
 
 
553
 
 
554
 
 
555
 
  /**
556
 
   * Handles and retransmits events fired by `Y.FileFlash` and `Y.Uploader.Queue`.
557
 
   * 
558
 
   * @method _uploadEventHandler
559
 
   * @param event The event dispatched during the upload process.
560
 
   * @private
561
 
   */
562
 
  _uploadEventHandler : function (event) {
563
 
  
564
 
    switch (event.type) {
565
 
                case "file:uploadstart":
566
 
                   this.fire("fileuploadstart", event);
567
 
                break;
568
 
                case "file:uploadprogress":
569
 
                   this.fire("uploadprogress", event);
570
 
                break;
571
 
                case "uploaderqueue:totaluploadprogress":
572
 
                   this.fire("totaluploadprogress", event);
573
 
                break;
574
 
                case "file:uploadcomplete":
575
 
                   this.fire("uploadcomplete", event);
576
 
                break;
577
 
                case "uploaderqueue:alluploadscomplete":
578
 
                   this.queue = null;
579
 
                   this.fire("alluploadscomplete", event);
580
 
                break;
581
 
                case "uploaderqueue:uploaderror":
582
 
                   this.fire("uploaderror", event);
583
 
    }   
584
 
 
585
 
  },
586
 
 
587
 
 
588
 
 
589
 
  /**
590
 
   * Starts the upload of a specific file.
591
 
   *
592
 
   * @method upload
593
 
   * @param file {Y.FileFlash} Reference to the instance of the file to be uploaded.
594
 
   * @param url {String} The URL to upload the file to.
595
 
   * @param postVars {Object} (optional) A set of key-value pairs to send as variables along with the file upload HTTP request.
596
 
   *                          If not specified, the values from the attribute `postVarsPerFile` are used instead. 
597
 
   */
598
 
 
599
 
  upload : function (file, url, postvars) {
600
 
        
601
 
        var uploadURL = url || this.get("uploadURL"),
602
 
            postVars = postvars || this.get("postVarsPerFile"),
603
 
            fileId = file.get("id");
604
 
 
605
 
            postVars = postVars.hasOwnProperty(fileId) ? postVars[fileId] : postVars;
606
 
 
607
 
        if (file instanceof Y.FileFlash) {
608
 
           
609
 
            file.on("uploadstart", this._uploadStartHandler, this);
610
 
            file.on("uploadprogress", this._uploadProgressHandler, this);
611
 
            file.on("uploadcomplete", this._uploadCompleteHandler, this);
612
 
            file.on("uploaderror", this._uploadErrorHandler, this);
613
 
 
614
 
            file.startUpload(uploadURL, postVars, this.get("fileFieldName"));
615
 
        }
616
 
  },
617
 
 
618
 
  /**
619
 
   * Starts the upload of all files on the file list, using an automated queue.
620
 
   *
621
 
   * @method uploadAll
622
 
   * @param url {String} The URL to upload the files to.
623
 
   * @param postVars {Object} (optional) A set of key-value pairs to send as variables along with the file upload HTTP request.
624
 
   *                          If not specified, the values from the attribute `postVarsPerFile` are used instead. 
625
 
   */
626
 
  uploadAll : function (url, postvars) {
627
 
        this.uploadThese(this.get("fileList"), url, postvars);
628
 
  },
629
 
 
630
 
  /**
631
 
   * Starts the upload of the files specified in the first argument, using an automated queue.
632
 
   *
633
 
   * @method uploadThese
634
 
   * @param files {Array} The list of files to upload.
635
 
   * @param url {String} The URL to upload the files to.
636
 
   * @param postVars {Object} (optional) A set of key-value pairs to send as variables along with the file upload HTTP request.
637
 
   *                          If not specified, the values from the attribute `postVarsPerFile` are used instead. 
638
 
   */
639
 
  uploadThese : function (files, url, postvars) {
640
 
    if (!this.queue) {
641
 
        var uploadURL = url || this.get("uploadURL"),
642
 
            postVars = postvars || this.get("postVarsPerFile");
643
 
 
644
 
           this.queue = new UploaderQueue({simUploads: this.get("simLimit"), 
645
 
                                                errorAction: this.get("errorAction"),
646
 
                                                fileFieldName: this.get("fileFieldName"),
647
 
                                                fileList: files,
648
 
                                                uploadURL: uploadURL,
649
 
                                                perFileParameters: postVars
650
 
                                               });
651
 
           this.queue.on("uploadstart", this._uploadEventHandler, this);
652
 
           this.queue.on("uploadprogress", this._uploadEventHandler, this);
653
 
           this.queue.on("totaluploadprogress", this._uploadEventHandler, this);
654
 
           this.queue.on("uploadcomplete", this._uploadEventHandler, this);
655
 
           this.queue.on("alluploadscomplete", this._uploadEventHandler, this);
656
 
           this.queue.on("alluploadscancelled", function (ev) {this.queue = null;}, this);
657
 
           this.queue.on("uploaderror", this._uploadEventHandler, this);
658
 
           this.queue.startUpload();  
659
 
           
660
 
           this.fire("uploadstart"); 
661
 
    }
662
 
  }
663
 
},
664
 
 
665
 
{
666
 
  /**
667
 
   * The template for the Flash player container. Since the Flash player container needs
668
 
   * to completely overlay the &lquot;Select Files&rqot; control, it's positioned absolutely,
669
 
   * with width and height set to 100% of the parent.
670
 
   *
671
 
   * @property FLASH_CONTAINER
672
 
   * @type {String}
673
 
   * @static
674
 
   * @default "<div id='{swfContainerId}' style='position:absolute; top:0px; left: 0px; margin: 0; padding: 0; border: 0; width:100%; height:100%'></div>"
675
 
   */
676
 
  FLASH_CONTAINER: "<div id='{swfContainerId}' style='position:absolute; top:0px; left: 0px; margin: 0; padding: 0; border: 0; width:100%; height:100%'></div>",
677
 
 
678
 
  /**
679
 
   * The template for the "Select Files" button.
680
 
   *
681
 
   * @property SELECT_FILES_BUTTON
682
 
   * @type {String}
683
 
   * @static
684
 
   * @default "<button type='button' class='yui3-button' tabindex='-1'>{selectButtonLabel}</button>"
685
 
   */
686
 
  SELECT_FILES_BUTTON: "<button type='button' class='yui3-button' tabindex='-1'>{selectButtonLabel}</button>",
687
 
 
688
 
   /**
689
 
   * The static property reflecting the type of uploader that `Y.Uploader`
690
 
   * aliases. The UploaderFlash value is `"flash"`.
691
 
   * 
692
 
   * @property TYPE
693
 
   * @type {String}
694
 
   * @static
695
 
   */
696
 
  TYPE: "flash",
697
 
 
698
 
  /**
699
 
   * The identity of the widget.
700
 
   *
701
 
   * @property NAME
702
 
   * @type String
703
 
   * @default 'uploader'
704
 
   * @readOnly
705
 
   * @protected
706
 
   * @static
707
 
   */
708
 
  NAME: "uploader",
709
 
 
710
 
  /**
711
 
   * Static property used to define the default attribute configuration of
712
 
   * the Widget.
713
 
   *
714
 
   * @property ATTRS
715
 
   * @type {Object}
716
 
   * @protected
717
 
   * @static
718
 
   */
719
 
  ATTRS: {
720
 
 
721
 
        /**
722
 
         * A Boolean indicating whether newly selected files should be appended 
723
 
         * to the existing file list, or whether they should replace it.
724
 
         *
725
 
         * @attribute appendNewFiles
726
 
         * @type {Boolean}
727
 
         * @default true
728
 
         */
729
 
         appendNewFiles : {
730
 
            value: true
731
 
         },
732
 
 
733
 
        /**
734
 
         * The names of CSS classes that correspond to different button states
735
 
         * of the "Select Files" control. These classes are assigned to the 
736
 
         * "Select Files" control based on the mouse states reported by the
737
 
         * Flash player. The keys for the class names are:
738
 
         * <ul>
739
 
         *   <li> <strong>`hover`</strong>: the class corresponding to mouse hovering over
740
 
         *      the "Select Files" button.</li>
741
 
         *   <li> <strong>`active`</strong>: the class corresponding to mouse down state of
742
 
         *      the "Select Files" button.</li>
743
 
         *   <li> <strong>`disabled`</strong>: the class corresponding to the disabled state
744
 
         *      of the "Select Files" button.</li>
745
 
         *   <li> <strong>`focus`</strong>: the class corresponding to the focused state of
746
 
         *      the "Select Files" button.</li>
747
 
         * </ul>
748
 
         * @attribute buttonClassNames
749
 
         * @type {Object}
750
 
         * @default { hover: "yui3-button-hover",
751
 
         *            active: "yui3-button-active",
752
 
         *            disabled: "yui3-button-disabled",
753
 
         *            focus: "yui3-button-selected"
754
 
         *          }
755
 
         */
756
 
        buttonClassNames: {
757
 
            value: {
758
 
                "hover": "yui3-button-hover",
759
 
                "active": "yui3-button-active",
760
 
                "disabled": "yui3-button-disabled",
761
 
                "focus": "yui3-button-selected"
762
 
            }
763
 
        },
764
 
 
765
 
        /**
766
 
         * A Boolean indicating whether the uploader is enabled or disabled for user input.
767
 
         *
768
 
         * @attribute enabled
769
 
         * @type {Boolean}
770
 
         * @default true
771
 
         */
772
 
        enabled : {
773
 
            value: true
774
 
        },
775
 
 
776
 
        /**
777
 
         * The action  performed when an upload error occurs for a specific file being uploaded.
778
 
         * The possible values are: 
779
 
         * <ul>
780
 
         *   <li> <strong>`UploaderQueue.CONTINUE`</strong>: the error is ignored and the upload process is continued.</li>
781
 
         *   <li> <strong>`UploaderQueue.STOP`</strong>: the upload process is stopped as soon as any other parallel file
782
 
         *     uploads are finished.</li>
783
 
         *   <li> <strong>`UploaderQueue.RESTART_ASAP`</strong>: the file is added back to the front of the queue.</li>
784
 
         *   <li> <strong>`UploaderQueue.RESTART_AFTER`</strong>: the file is added to the back of the queue.</li>
785
 
         * </ul>
786
 
         * @attribute errorAction
787
 
         * @type {String}
788
 
         * @default UploaderQueue.CONTINUE
789
 
         */
790
 
        errorAction: {
791
 
            value: "continue",
792
 
            validator: function (val, name) {
793
 
                 return (val === UploaderQueue.CONTINUE || val === UploaderQueue.STOP || val === UploaderQueue.RESTART_ASAP || val === UploaderQueue.RESTART_AFTER);           
794
 
             }
795
 
        },
796
 
 
797
 
        /**
798
 
         * An array indicating what fileFilters should be applied to the file
799
 
         * selection dialog. Each element in the array should be an object with
800
 
         * the following key-value pairs:
801
 
         * {
802
 
         *   description : String           
803
 
             extensions: String of the form &lquot;*.ext1;*.ext2;*.ext3;...&rquot;
804
 
         * }
805
 
         * @attribute fileFilters
806
 
         * @type {Array}
807
 
         * @default null
808
 
         */
809
 
        fileFilters: {
810
 
          value: null
811
 
        },
812
 
         
813
 
        /**
814
 
         * A String specifying what should be the POST field name for the file
815
 
         * content in the upload request.
816
 
         *
817
 
         * @attribute fileFieldName
818
 
         * @type {String}
819
 
         * @default Filedata
820
 
         */
821
 
        fileFieldName: {
822
 
          value: "Filedata"
823
 
        },
824
 
 
825
 
        /**
826
 
         * The array of files to be uploaded. All elements in the array
827
 
       * must be instances of `Y.FileFlash` and be instantiated with a `fileId`
828
 
       * retrieved from an instance of the uploader.
829
 
         *
830
 
         * @attribute fileList
831
 
         * @type {Array}
832
 
         * @default []
833
 
         */
834
 
        fileList: {
835
 
          value: []
836
 
        },
837
 
 
838
 
        /**
839
 
         * A Boolean indicating whether multiple file selection is enabled.
840
 
         *
841
 
         * @attribute multipleFiles
842
 
         * @type {Boolean}
843
 
         * @default false
844
 
         */
845
 
        multipleFiles: {
846
 
          value: false
847
 
        },
848
 
 
849
 
        /**
850
 
         * An object, keyed by `fileId`, containing sets of key-value pairs
851
 
         * that should be passed as POST variables along with each corresponding
852
 
         * file. This attribute is only used if no POST variables are specifed
853
 
         * in the upload method call.
854
 
         *
855
 
         * @attribute postVarsPerFile
856
 
         * @type {Object}
857
 
         * @default {}
858
 
         */
859
 
        postVarsPerFile: {
860
 
          value: {}
861
 
        },
862
 
 
863
 
        /**
864
 
         * The label for the "Select Files" widget. This is the value that replaces the
865
 
         * `{selectButtonLabel}` token in the `SELECT_FILES_BUTTON` template.
866
 
         * 
867
 
         * @attribute selectButtonLabel
868
 
         * @type {String}
869
 
         * @default "Select Files"
870
 
         */
871
 
        selectButtonLabel: {
872
 
            value: "Select Files"
873
 
        },
874
 
 
875
 
        /**
876
 
         * The widget that serves as the "Select Files" control for the file uploader
877
 
         * 
878
 
         *
879
 
         * @attribute selectFilesButton
880
 
         * @type {Node | Widget}
881
 
         * @default A standard HTML button with YUI CSS Button skin.
882
 
         */
883
 
        selectFilesButton : {
884
 
           valueFn: function () {
885
 
                     return Y.Node.create(substitute(Y.UploaderFlash.SELECT_FILES_BUTTON, {selectButtonLabel: this.get("selectButtonLabel")}));
886
 
                 }
887
 
         },
888
 
     
889
 
        /**
890
 
         * The number of files that can be uploaded
891
 
         * simultaneously if the automatic queue management
892
 
         * is used. This value can be in the range between 2
893
 
         * and 5.
894
 
         *
895
 
         * @attribute simLimit
896
 
         * @type {Number}
897
 
         * @default 2
898
 
         */
899
 
        simLimit: {
900
 
                value: 2,
901
 
                validator: function (val, name) {
902
 
                    return (val >= 2 && val <= 5);
903
 
                }
904
 
            },
905
 
 
906
 
        /**
907
 
         * The URL to the SWF file of the flash uploader. A copy local to
908
 
         * the server that hosts the page on which the uploader appears is
909
 
         * recommended.
910
 
         *
911
 
         * @attribute swfURL
912
 
         * @type {String}
913
 
         * @default "CDN Prefix + uploader/assets/flashuploader.swf" with a 
914
 
         * random GET parameter for IE (to prevent buggy behavior when the SWF 
915
 
         * is cached).
916
 
         */
917
 
        swfURL: {
918
 
          valueFn: function () {
919
 
            var prefix = Y.Env.cdn + "uploader/assets/flashuploader.swf";
920
 
 
921
 
            if (Y.UA.ie > 0) {
922
 
              return (prefix + "?t=" + Y.guid("uploader"));
923
 
            }
924
 
            return prefix;
925
 
          }
926
 
        },
927
 
 
928
 
        /**
929
 
         * The id's or `Node` references of the DOM elements that precede
930
 
         * and follow the `Select Files` button in the tab order. Specifying
931
 
         * these allows keyboard navigation to and from the Flash player
932
 
         * layer of the uploader.
933
 
         * The two keys corresponding to the DOM elements are:
934
 
           <ul>
935
 
         *   <li> `from`: the id or the `Node` reference corresponding to the
936
 
         *     DOM element that precedes the `Select Files` button in the tab order.</li>
937
 
         *   <li> `to`: the id or the `Node` reference corresponding to the
938
 
         *     DOM element that follows the `Select Files` button in the tab order.</li>
939
 
         * </ul>
940
 
         * @attribute tabElements
941
 
         * @type {Object}
942
 
         * @default null
943
 
         */
944
 
        tabElements: {
945
 
            value: null
946
 
        },
947
 
 
948
 
        /**
949
 
         * The URL to which file upload requested are POSTed. Only used if a different url is not passed to the upload method call.
950
 
         *
951
 
         * @attribute uploadURL
952
 
         * @type {String}
953
 
         * @default ""
954
 
         */
955
 
        uploadURL: {
956
 
          value: ""
957
 
        }
958
 
  }
959
 
});
960
 
 
961
 
Y.UploaderFlash.Queue = UploaderQueue;
962
 
 
963
 
 
964
 
 
965
 
 
966
 
}, '3.5.1' ,{requires:['swf', 'widget', 'substitute', 'base', 'cssbutton', 'node', 'event-custom', 'file-flash', 'uploader-queue']});