← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to src/library_browser.js

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-09-20 22:44:35 UTC
  • mfrom: (4.1.1 sid)
  • Revision ID: package-import@ubuntu.com-20130920224435-apuwj4fsl3fqv1a6
Tags: 1.5.6~20130920~6010666-1
http://bugs.debian.org/723129
* New snapshot release
* Update the list of supported architectures to the same as libv8
  (Closes: #723129)
* emlibtool has been removed from upstream.
* Fix warning syntax-error-in-dep5-copyright
* Refresh of the patches

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/library_browser.js
3
3
// Utilities for browser environments
4
4
 
5
5
mergeInto(LibraryManager.library, {
 
6
  $Browser__deps: ['$PATH'],
6
7
  $Browser__postset: 'Module["requestFullScreen"] = function(lockPointer, resizeCanvas) { Browser.requestFullScreen(lockPointer, resizeCanvas) };\n' + // exports
7
8
                     'Module["requestAnimationFrame"] = function(func) { Browser.requestAnimationFrame(func) };\n' +
 
9
                     'Module["setCanvasSize"] = function(width, height, noUpdates) { Browser.setCanvasSize(width, height, noUpdates) };\n' +
8
10
                     'Module["pauseMainLoop"] = function() { Browser.mainLoop.pause() };\n' +
9
11
                     'Module["resumeMainLoop"] = function() { Browser.mainLoop.resume() };\n' +
10
12
                     'Module["getUserMedia"] = function() { Browser.getUserMedia() }',
47
49
    workers: [],
48
50
 
49
51
    init: function() {
50
 
      if (Browser.initted) return;
 
52
      if (!Module["preloadPlugins"]) Module["preloadPlugins"] = []; // needs to exist even in workers
 
53
 
 
54
      if (Browser.initted || ENVIRONMENT_IS_WORKER) return;
51
55
      Browser.initted = true;
 
56
 
52
57
      try {
53
58
        new Blob();
54
59
        Browser.hasBlobConstructor = true;
57
62
        console.log("warning: no blob constructor, cannot create blobs with mimetypes");
58
63
      }
59
64
      Browser.BlobBuilder = typeof MozBlobBuilder != "undefined" ? MozBlobBuilder : (typeof WebKitBlobBuilder != "undefined" ? WebKitBlobBuilder : (!Browser.hasBlobConstructor ? console.log("warning: no BlobBuilder") : null));
60
 
      Browser.URLObject = typeof window != "undefined" ? (window.URL ? window.URL : window.webkitURL) : console.log("warning: cannot create object URLs");
 
65
      Browser.URLObject = typeof window != "undefined" ? (window.URL ? window.URL : window.webkitURL) : undefined;
 
66
      if (!Module.noImageDecoding && typeof Browser.URLObject === 'undefined') {
 
67
        console.log("warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available.");
 
68
        Module.noImageDecoding = true;
 
69
      }
61
70
 
62
71
      // Support for plugins that can process preloaded files. You can add more of these to
63
72
      // your app by creating and appending to Module.preloadPlugins.
67
76
      // (possibly modified) data. For example, a plugin might decompress a file, or it
68
77
      // might create some side data structure for use later (like an Image element, etc.).
69
78
 
70
 
      function getMimetype(name) {
71
 
        return {
72
 
          'jpg': 'image/jpeg',
73
 
          'jpeg': 'image/jpeg',
74
 
          'png': 'image/png',
75
 
          'bmp': 'image/bmp',
76
 
          'ogg': 'audio/ogg',
77
 
          'wav': 'audio/wav',
78
 
          'mp3': 'audio/mpeg'
79
 
        }[name.substr(name.lastIndexOf('.')+1)];
80
 
      }
81
 
 
82
 
      if (!Module["preloadPlugins"]) Module["preloadPlugins"] = [];
83
 
 
84
79
      var imagePlugin = {};
85
80
      imagePlugin['canHandle'] = function(name) {
86
 
        return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/.exec(name);
 
81
        return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name);
87
82
      };
88
83
      imagePlugin['handle'] = function(byteArray, name, onload, onerror) {
89
84
        var b = null;
90
85
        if (Browser.hasBlobConstructor) {
91
86
          try {
92
 
            b = new Blob([byteArray], { type: getMimetype(name) });
 
87
            b = new Blob([byteArray], { type: Browser.getMimetype(name) });
 
88
            if (b.size !== byteArray.length) { // Safari bug #118630
 
89
              // Safari's Blob can only take an ArrayBuffer
 
90
              b = new Blob([(new Uint8Array(byteArray)).buffer], { type: Browser.getMimetype(name) });
 
91
            }
93
92
          } catch(e) {
94
93
            Runtime.warnOnce('Blob constructor present but fails: ' + e + '; falling back to blob builder');
95
94
          }
143
142
        }
144
143
        if (Browser.hasBlobConstructor) {
145
144
          try {
146
 
            var b = new Blob([byteArray], { type: getMimetype(name) });
 
145
            var b = new Blob([byteArray], { type: Browser.getMimetype(name) });
147
146
          } catch(e) {
148
147
            return fail();
149
148
          }
386
385
      }, timeout);
387
386
    },
388
387
 
 
388
    getMimetype: function(name) {
 
389
      return {
 
390
        'jpg': 'image/jpeg',
 
391
        'jpeg': 'image/jpeg',
 
392
        'png': 'image/png',
 
393
        'bmp': 'image/bmp',
 
394
        'ogg': 'audio/ogg',
 
395
        'wav': 'audio/wav',
 
396
        'mp3': 'audio/mpeg'
 
397
      }[name.substr(name.lastIndexOf('.')+1)];
 
398
    },
 
399
    
389
400
    getUserMedia: function(func) {
390
401
      if(!window.getUserMedia) {
391
402
        window.getUserMedia = navigator['getUserMedia'] ||
394
405
      window.getUserMedia(func);
395
406
    },
396
407
 
 
408
 
397
409
    getMovementX: function(event) {
398
410
      return event['movementX'] ||
399
411
             event['mozMovementX'] ||
425
437
          Browser.mouseMovementX = Browser.getMovementX(event);
426
438
          Browser.mouseMovementY = Browser.getMovementY(event);
427
439
        }
428
 
        Browser.mouseX = SDL.mouseX + Browser.mouseMovementX;
429
 
        Browser.mouseY = SDL.mouseY + Browser.mouseMovementY;
 
440
        
 
441
        // check if SDL is available
 
442
        if (typeof SDL != "undefined") {
 
443
                Browser.mouseX = SDL.mouseX + Browser.mouseMovementX;
 
444
                Browser.mouseY = SDL.mouseY + Browser.mouseMovementY;
 
445
        } else {
 
446
                // just add the mouse delta to the current absolut mouse position
 
447
                // FIXME: ideally this should be clamped against the canvas size and zero
 
448
                Browser.mouseX += Browser.mouseMovementX;
 
449
                Browser.mouseY += Browser.mouseMovementY;
 
450
        }        
430
451
      } else {
431
452
        // Otherwise, calculate the movement based on the changes
432
453
        // in the coordinates.
433
454
        var rect = Module["canvas"].getBoundingClientRect();
434
 
        var x = event.pageX - (window.scrollX + rect.left);
435
 
        var y = event.pageY - (window.scrollY + rect.top);
 
455
        var x, y;
 
456
        if (event.type == 'touchstart' ||
 
457
            event.type == 'touchend' ||
 
458
            event.type == 'touchmove') {
 
459
          var t = event.touches.item(0);
 
460
          if (t) {
 
461
            x = t.pageX - (window.scrollX + rect.left);
 
462
            y = t.pageY - (window.scrollY + rect.top);
 
463
          } else {
 
464
            return;
 
465
          }
 
466
        } else {
 
467
          x = event.pageX - (window.scrollX + rect.left);
 
468
          y = event.pageY - (window.scrollY + rect.top);
 
469
        }
436
470
 
437
471
        // the canvas might be CSS-scaled compared to its backbuffer;
438
472
        // SDL-using content will want mouse coordinates in terms
503
537
      this.windowedHeight = canvas.height;
504
538
      canvas.width = screen.width;
505
539
      canvas.height = screen.height;
506
 
      var flags = {{{ makeGetValue('SDL.screen+Runtime.QUANTUM_SIZE*0', '0', 'i32', 0, 1) }}};
507
 
      flags = flags | 0x00800000; // set SDL_FULLSCREEN flag
508
 
      {{{ makeSetValue('SDL.screen+Runtime.QUANTUM_SIZE*0', '0', 'flags', 'i32') }}}
 
540
      // check if SDL is available   
 
541
      if (typeof SDL != "undefined") {
 
542
        var flags = {{{ makeGetValue('SDL.screen+Runtime.QUANTUM_SIZE*0', '0', 'i32', 0, 1) }}};
 
543
        flags = flags | 0x00800000; // set SDL_FULLSCREEN flag
 
544
        {{{ makeSetValue('SDL.screen+Runtime.QUANTUM_SIZE*0', '0', 'flags', 'i32') }}}
 
545
      }
509
546
      Browser.updateResizeListeners();
510
547
    },
511
548
 
513
550
      var canvas = Module['canvas'];
514
551
      canvas.width = this.windowedWidth;
515
552
      canvas.height = this.windowedHeight;
516
 
      var flags = {{{ makeGetValue('SDL.screen+Runtime.QUANTUM_SIZE*0', '0', 'i32', 0, 1) }}};
517
 
      flags = flags & ~0x00800000; // clear SDL_FULLSCREEN flag
518
 
      {{{ makeSetValue('SDL.screen+Runtime.QUANTUM_SIZE*0', '0', 'flags', 'i32') }}}
 
553
      // check if SDL is available       
 
554
      if (typeof SDL != "undefined") {
 
555
        var flags = {{{ makeGetValue('SDL.screen+Runtime.QUANTUM_SIZE*0', '0', 'i32', 0, 1) }}};
 
556
        flags = flags & ~0x00800000; // clear SDL_FULLSCREEN flag
 
557
        {{{ makeSetValue('SDL.screen+Runtime.QUANTUM_SIZE*0', '0', 'flags', 'i32') }}}
 
558
      }
519
559
      Browser.updateResizeListeners();
520
560
    }
521
561
 
524
564
  emscripten_async_wget: function(url, file, onload, onerror) {
525
565
    var _url = Pointer_stringify(url);
526
566
    var _file = Pointer_stringify(file);
527
 
    var index = _file.lastIndexOf('/');
528
567
    FS.createPreloadedFile(
529
 
      _file.substr(0, index),
530
 
      _file.substr(index +1),
 
568
      PATH.dirname(_file),
 
569
      PATH.basename(_file),
531
570
      _url, true, true,
532
571
      function() {
533
572
        if (onload) Runtime.dynCall('vi', onload, [file]);
602
641
    var _file = Pointer_stringify(file);
603
642
    var data = FS.analyzePath(_file);
604
643
    if (!data.exists) return -1;
605
 
    var index = _file.lastIndexOf('/');
606
644
    FS.createPreloadedFile(
607
 
      _file.substr(0, index),
608
 
      _file.substr(index +1),
 
645
      PATH.dirname(_file),
 
646
      PATH.basename(_file),
609
647
      new Uint8Array(data.object.contents), true, true,
610
648
      function() {
611
649
        if (onload) Runtime.dynCall('vi', onload, [file]);
625
663
    var cname = _malloc(name.length+1);
626
664
    writeStringToMemory(name, cname);
627
665
    FS.createPreloadedFile(
628
 
      '',
 
666
      '/',
629
667
      name,
630
668
      {{{ makeHEAPView('U8', 'data', 'data + size') }}},
631
669
      true, true,
686
724
        Module['preMainLoop']();
687
725
      }
688
726
 
689
 
      Runtime.dynCall('v', func);
 
727
      try {
 
728
        Runtime.dynCall('v', func);
 
729
      } catch (e) {
 
730
        if (e instanceof ExitStatus) {
 
731
          return;
 
732
        } else {
 
733
          throw e;
 
734
        }
 
735
      }
690
736
 
691
737
      if (Module['postMainLoop']) {
692
738
        Module['postMainLoop']();
783
829
  emscripten_set_canvas_size: function(width, height) {
784
830
    Browser.setCanvasSize(width, height);
785
831
  },
 
832
  
 
833
  emscripten_get_canvas_size: function(width, height, isFullscreen) {
 
834
    var canvas = Module['canvas'];
 
835
    {{{ makeSetValue('width', '0', 'canvas.width', 'i32') }}};
 
836
    {{{ makeSetValue('height', '0', 'canvas.height', 'i32') }}};
 
837
    {{{ makeSetValue('isFullscreen', '0', 'Browser.isFullScreen ? 1 : 0', 'i32') }}};
 
838
  },
786
839
 
787
840
  emscripten_get_now: function() {
788
 
    if (ENVIRONMENT_IS_NODE) {
789
 
        var t = process['hrtime']();
790
 
        return t[0] * 1e3 + t[1] / 1e6;
791
 
    }
792
 
    else if (window['performance'] && window['performance']['now']) {
793
 
      return window['performance']['now']();
794
 
    } else {
795
 
      return Date.now();
796
 
    }
 
841
    if (!_emscripten_get_now.actual) {
 
842
      if (ENVIRONMENT_IS_NODE) {
 
843
          _emscripten_get_now.actual = function() {
 
844
            var t = process['hrtime']();
 
845
            return t[0] * 1e3 + t[1] / 1e6;
 
846
          }
 
847
      } else if (typeof dateNow !== 'undefined') {
 
848
        _emscripten_get_now.actual = dateNow;
 
849
      } else if (ENVIRONMENT_IS_WEB && window['performance'] && window['performance']['now']) {
 
850
        _emscripten_get_now.actual = function() { return window['performance']['now'](); };
 
851
      } else {
 
852
        _emscripten_get_now.actual = Date.now;
 
853
      }
 
854
    }
 
855
    return _emscripten_get_now.actual();
797
856
  },
798
857
 
799
858
  emscripten_create_worker: function(url) {