pageflow 0.8.2 → 0.9.0

data/app/assets/javascripts/pageflow/history/simulated_adapter.js

@@ -0,0 +1,44 @@
+/*global console*/
+
+pageflow.History.SimulatedAdapter = function() {
+  var stack = [{
+    hash: null,
+    state: null
+  }];
+
+  this.back = function() {
+    if (stack.length > 1) {
+      stack.pop();
+      this.trigger('popstate');
+
+      return true;
+    }
+    return false;
+  };
+
+  this.pushState = function(state, title, hash) {
+    stack.push({
+      state: state,
+      hash: hash
+    });
+  };
+
+  this.replaceState = function(state, title, hash) {
+    peek().state = state;
+    peek().hash = hash;
+  };
+
+  this.state = function() {
+    return peek().state;
+  };
+
+  this.hash = function() {
+    return peek().hash;
+  };
+
+  function peek() {
+    return stack[stack.length - 1];
+  }
+};
+
+_.extend(pageflow.History.SimulatedAdapter.prototype, Backbone.Events);

data/app/assets/javascripts/pageflow/media_player.js

@@ -0,0 +1,25 @@
+//= require_self
+//= require ./media_player/volume_fading
+//= require ./media_player/volume_binding
+//= require ./media_player/load_waiting
+//= require ./media_player/hooks
+//= require ./media_player/async_play
+
+pageflow.mediaPlayer = {
+  enhance: function(player, options) {
+    pageflow.mediaPlayer.asyncPlay(player);
+
+    if (options.hooks) {
+      pageflow.mediaPlayer.hooks(player, options.hooks);
+    }
+
+    if (options.volumeFading) {
+      pageflow.mediaPlayer.volumeFading(player);
+      pageflow.mediaPlayer.volumeBinding(player, pageflow.settings, options);
+    }
+
+    if (options.loadWaiting) {
+      pageflow.mediaPlayer.loadWaiting(player);
+    }
+  }
+};

data/app/assets/javascripts/pageflow/media_player/async_play.js

@@ -0,0 +1,54 @@
+pageflow.mediaPlayer.asyncPlay = function(player) {
+  var originalPlay = player.play;
+  var originalPause = player.pause;
+
+  var intendingToPlay = false;
+  var intendingToPause = false;
+
+  player.play = function(/* arguments */) {
+    player.intendToPlay();
+    return originalPlay.apply(player, arguments);
+  };
+
+  player.pause = function(/* arguments */) {
+    player.intendToPause();
+    return originalPause.apply(player, arguments);
+  };
+
+  player.intendToPlay = function() {
+    intendingToPlay = true;
+    intendingToPause = false;
+  };
+
+  player.intendToPause = function() {
+    intendingToPause = true;
+    intendingToPlay = false;
+  };
+
+  player.intendingToPlay = function() {
+    return intendingToPlay;
+  };
+
+  player.intendingToPause = function() {
+    return intendingToPause;
+  };
+
+  player.ifIntendingToPause = function() {
+    return promiseFromBoolean(intendingToPause);
+  };
+
+  player.ifIntendingToPlay = function() {
+    return promiseFromBoolean(intendingToPlay);
+  };
+
+  function promiseFromBoolean(value) {
+    return new $.Deferred(function(deferred) {
+      if (value) {
+        deferred.resolve();
+      }
+      else {
+        deferred.reject('aborted');
+      }
+    }).promise();
+  }
+};

data/app/assets/javascripts/pageflow/media_player/hooks.js

@@ -0,0 +1,24 @@
+pageflow.mediaPlayer.hooks = function(player, hooks) {
+  var originalPlay = player.play;
+  var originalPlayAndFadeIn = player.play;
+
+  if (hooks.before) {
+    player.play = function(/* args */) {
+      var args = arguments;
+
+      player.trigger('beforeplay');
+      player.intendToPlay();
+
+      return $.when(hooks.before()).then(function() {
+        return player.ifIntendingToPlay().then(function() {
+          return originalPlay.apply(player, args);
+        });
+      });
+    };
+  }
+
+  if (hooks.after) {
+    player.on('pause', hooks.after);
+    player.on('ended', hooks.after);
+  }
+};

data/app/assets/javascripts/pageflow/media_player/load_waiting.js

@@ -0,0 +1,11 @@
+pageflow.mediaPlayer.loadWaiting = function(player) {
+  var originalFadeVolume = player.fadeVolume;
+
+  player.fadeVolume = function(/* args */) {
+    var args = arguments;
+
+    return jQuery.when(this.loadedPromise).then(function() {
+      return originalFadeVolume.apply(player, args);
+    });
+  };
+};

data/app/assets/javascripts/pageflow/media_player/volume_binding.js

@@ -0,0 +1,72 @@
+pageflow.mediaPlayer.volumeBinding = function(player, settings, options) {
+  options = options || {};
+
+  var originalPlay = player.play;
+  var originalPause = player.pause;
+
+  var volumeFactor = 'volumeFactor' in options ? options.volumeFactor : 1;
+
+  player.play = function() {
+    player.volume(player.targetVolume());
+    listenToVolumeSetting();
+
+    return originalPlay.call(player);
+  };
+
+  player.playAndFadeIn = function(duration) {
+    if (!player.paused() && !player.intendingToPause()) {
+      return new jQuery.Deferred().resolve().promise();
+    }
+
+    player.intendToPlay();
+    player.volume(0);
+
+    return $.when(originalPlay.call(player)).then(function() {
+      listenToVolumeSetting();
+      return player.fadeVolume(player.targetVolume(), duration).then(null, function() {
+        return new jQuery.Deferred().resolve().promise();
+      });
+    });
+  };
+
+  player.pause = function() {
+    stopListeningToVolumeSetting();
+    originalPause.call(player);
+  };
+
+  player.fadeOutAndPause = function(duration) {
+    if (player.paused() && !player.intendingToPlay()) {
+      return new jQuery.Deferred().resolve().promise();
+    }
+
+    player.intendToPause();
+    stopListeningToVolumeSetting();
+
+    return player.fadeVolume(0, duration).always(function() {
+      return player.ifIntendingToPause().then(function() {
+        originalPause.call(player);
+      });
+    });
+  };
+
+  player.changeVolumeFactor = function(factor, duration) {
+    volumeFactor = factor;
+    return player.fadeVolume(player.targetVolume(), duration);
+  };
+
+  player.targetVolume = function() {
+    return settings.get('volume') * volumeFactor;
+  };
+
+  function listenToVolumeSetting() {
+    settings.on('change:volume', onVolumeChange);
+  }
+
+  function stopListeningToVolumeSetting() {
+    settings.off('change:volume', onVolumeChange);
+  }
+
+  function onVolumeChange(model, value) {
+    player.fadeVolume(player.targetVolume(), 40);
+  }
+};

data/app/assets/javascripts/pageflow/media_player/volume_fading.js

@@ -0,0 +1,62 @@
+pageflow.mediaPlayer.volumeFading = function(player) {
+  var originalVolume = player.volume;
+  var fadeVolumeDeferred;
+  var fadeVolumeInterval;
+
+  player.volume = function(value) {
+    if (typeof value !== 'undefined') {
+      cancelFadeVolume();
+    }
+
+    return originalVolume.apply(player, arguments);
+  };
+
+  player.fadeVolume = function(value, duration) {
+    cancelFadeVolume();
+
+    return new $.Deferred(function(deferred) {
+      var resolution = 10;
+      var startValue = volume();
+      var steps = duration / resolution;
+      var leap = (value - startValue) / steps;
+
+      if (value === startValue) {
+        deferred.resolve();
+      }
+      else {
+        fadeVolumeDeferred = deferred;
+        fadeVolumeInterval = setInterval(function() {
+          volume(volume() + leap);
+
+          if ((volume() >= value && value >= startValue) ||
+              (volume() <= value && value <= startValue)) {
+
+            resolveFadeVolume();
+          }
+        }, resolution);
+      }
+    });
+
+    function volume(/* arguments */) {
+      return originalVolume.apply(player, arguments);
+    }
+  };
+
+  function resolveFadeVolume() {
+    clearInterval(fadeVolumeInterval);
+    fadeVolumeDeferred.resolve();
+
+    fadeVolumeInterval = null;
+    fadeVolumeDeferred = null;
+  }
+
+  function cancelFadeVolume() {
+    if (fadeVolumeInterval) {
+      clearInterval(fadeVolumeInterval);
+      fadeVolumeDeferred.reject();
+
+      fadeVolumeInterval = null;
+      fadeVolumeDeferred = null;
+    }
+  }
+};

data/app/assets/javascripts/pageflow/multimedia_alert.js

@@ -0,0 +1,13 @@
+/**
+ * Manual interaction with the multimedia alert.
+ *
+ * @since 0.9
+ */
+pageflow.multimediaAlert = {
+  /**
+   * Display the multimedia alert.
+   */
+  show: function() {
+    pageflow.events.trigger('request:multimedia_alert');
+  }
+};

data/app/assets/javascripts/pageflow/object.js

@@ -0,0 +1,14 @@
+(function() {
+  // Class-y constructor by github.com/opensas
+  // https://github.com/jashkenas/backbone/issues/2601
+
+  pageflow.Object = function(options) {
+      this.initialize.apply(this, arguments);
+  };
+  _.extend(pageflow.Object.prototype, Backbone.Events, {
+      initialize: function(options) {}
+  });
+
+  // The self-propagating extend function that Backbone classes use.
+  pageflow.Object.extend = Backbone.Model.extend;
+}());

data/app/assets/javascripts/pageflow/page_transitions.js

@@ -0,0 +1,27 @@
+pageflow.pageTransitions = {
+  repository: {},
+
+  register: function(name, options) {
+    this.repository[name] = options;
+  },
+
+  get: function(name) {
+    if (!this.repository.hasOwnProperty(name)) {
+      throw 'Unknown page transition "' + name + '"';
+    }
+
+    return this.repository[name];
+  },
+
+  names: function() {
+    return _.keys(this.repository);
+  }
+};
+
+pageflow.pageTransitions.register('fade', {duration: 1100});
+pageflow.pageTransitions.register('crossfade', {duration: 1100});
+pageflow.pageTransitions.register('fade_to_black', {duration: 2100});
+pageflow.pageTransitions.register('cut', {duration: 1100});
+pageflow.pageTransitions.register('scroll', {duration: 1100});
+pageflow.pageTransitions.register('scroll_right', {duration: 1100});
+pageflow.pageTransitions.register('scroll_left', {duration: 1100});

data/app/assets/javascripts/pageflow/page_type.js

@@ -6,6 +6,7 @@ pageflow.pageType = (function() {
   var base = {
     enhance: function(pageElement, configuarion) {},
     prepare: function(pageElement, configuarion) {},
+    unprepare: function(pageElement, configuarion) {},
     preload: function(pageElement, configuarion) {},
     resize: function(pageElement, configuarion) {},
     activating: function(pageElement, configuarion) {},
@@ -14,6 +15,11 @@ pageflow.pageType = (function() {
     deactivated: function(pageElement, configuarion) {},
     update: function(pageElement, configuarion) {},
     embeddedEditorViews: function() {},
+
+    linkedPages: function() {
+      return [];
+    },
+
     prepareNextPageTimeout: 200
   };
 

data/app/assets/javascripts/pageflow/page_types/audio.js

@@ -19,19 +19,10 @@ pageflow.pageType.register('audio', _.extend({
     $(firstContentElement[0]).attr('id','firstContent');
     //
 
-    this._ensureAudioPlayer(pageElement);
+    this._ensureAudioPlayer(pageElement, configuration);
 
     var that = this;
 
-    this.audioPlayer.readyPromise.then(function() {
-      that.audioPlayer.volume(pageflow.settings.get('volume'));
-      that.listenTo(pageflow.settings, "change:volume", function(model, value) {
-        that.audioPlayer.loadedPromise.then(function() {
-          that.fadeSound(that.audioPlayer, value, 40);
-        });
-      });
-    });
-
     $('body').on('keyup', function(e) {
       if(e.keyCode == 32){
         if(!that.audioPlayer.playing) {
@@ -48,18 +39,12 @@ pageflow.pageType.register('audio', _.extend({
     this.active = true;
     var that = this;
 
-    if(!pageflow.features.has('mobile platform')) {
-      if (configuration.autoplay === false) {
-        that.audioPlayer.volume(pageflow.settings.get('volume'));
-      } else {
+    if (!pageflow.browser.has('mobile platform')) {
+      if (configuration.autoplay !== false) {
         this.fadeInTimeout = setTimeout(function() {
           that.audioPlayer.readyPromise.then(function() {
             if (that.active) {
-              that.audioPlayer.volume(0);
-              that.audioPlayer.play();
-              that.audioPlayer.loadedPromise.then(function() {
-                that.fadeSound(that.audioPlayer, pageflow.settings.get('volume'), 1000);
-              });
+              that.audioPlayer.playAndFadeIn(1000);
             }
           });
         }, 1000);
@@ -96,7 +81,7 @@ pageflow.pageType.register('audio', _.extend({
       opacity: configuration.get('gradient_opacity') / 100
     });
 
-    this._ensureAudioPlayer(pageElement);
+    this._ensureAudioPlayer(pageElement, configuration.attributes);
     this.audioPlayer.src(configuration.getAudioFileSources('audio_file_id'));
   },
 
@@ -110,10 +95,14 @@ pageflow.pageType.register('audio', _.extend({
     };
   },
 
-  _ensureAudioPlayer: function(pageElement) {
+  _ensureAudioPlayer: function(pageElement, configuration) {
     this.audioPlayer = this.audioPlayer ||
       pageflow.AudioPlayer.fromScriptTag(pageElement.find('script[data-audio]'), {
         mediaEvents: true,
+
+        volumeFading: true,
+        hooks: pageflow.atmo.createMediaPlayerHooks(configuration),
+
         context: {
           page: pageElement.page('instance')
         }
@@ -122,5 +111,12 @@ pageflow.pageType.register('audio', _.extend({
     pageElement.find('.vjs-controls').playerControls({
       player: this.audioPlayer
     });
+
+    pageElement.find('.volume-control').volumeSlider({
+      orientation: 'v'
+    });
+
+    pageElement.find('.player_mute').muteButton();
+    pageElement.find('.player_skip').skipPageButton();
   }
 }, pageflow.volumeFade, pageflow.infoBox, pageflow.commonPageCssClasses));