pageflow 0.8.2 → 0.9.0

data/app/assets/javascripts/pageflow/editor/views/scrolling_view.js

@@ -0,0 +1,24 @@
+pageflow.ScrollingView = Backbone.Marionette.View.extend({
+
+  events: {
+    scroll: function() {
+      if (this._isChapterView()) {
+        this.scrollpos = this.$el.scrollTop();
+      }
+    }
+  },
+
+  initialize: function() {
+    this.scrollpos = 0;
+
+    this.listenTo(this.options.region, 'show', function() {
+      if (this._isChapterView()) {
+        this.$el.scrollTop(this.scrollpos);
+      }
+    });
+  },
+
+  _isChapterView: function() {
+    return !Backbone.history.getFragment();
+  }
+});

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

@@ -0,0 +1,35 @@
+pageflow.EntryData = pageflow.Object.extend({
+  getThemingOption: function(name) {
+    throw 'Not implemented';
+  },
+
+  getPageConfiguration: function(permaId) {
+    throw 'Not implemented';
+  },
+
+  getChapterConfiguration: function(id) {
+    throw 'Not implemented';
+  },
+
+  getChapterIdByPagePermaId: function(permaId) {
+    throw 'Not implemented';
+  },
+
+  getChapterPagePermaIds: function(id) {
+    throw 'Not implemented';
+  },
+
+  getParentPagePermaIdByPagePermaId: function(permaId) {
+    var chapterId = this.getChapterIdByPagePermaId(permaId);
+    return this.getParentPagePermaId(chapterId);
+  },
+
+  getParentChapterId: function(chapterId) {
+    var pagePermaId = this.getParentPagePermaId(chapterId);
+    return pagePermaId && this.getChapterIdByPagePermaId(pagePermaId);
+  },
+
+  getParentPagePermaId: function(chapterId) {
+    return this.getChapterConfiguration(chapterId).parent_page_perma_id;
+  }
+});

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

@@ -1,98 +1,68 @@
-//= require_self
-//= require_tree ./features
-
-pageflow.features = (function(){
-  var tests = {},
-      results = {},
-      ready = new $.Deferred();
-
-  return {
-    off: {},
-    on: {},
-    unset: {},
-
-    add: function(name, test) {
-      var s = name.replace(/ /g, '_');
-
-      this.off[s] = function() {
-        window.localStorage['override ' + name] = 'off';
-        pageflow.log('Feature off: ' + name, {force: true});
-      };
-
-      this.on[s] = function() {
-        window.localStorage['override ' + name] = 'on';
-        pageflow.log('Feature on: ' + name, {force: true});
-      };
-
-      this.unset[s] = function() {
-        window.localStorage.removeItem('override ' + name);
-        pageflow.log('Feature unset: ' + name, {force: true});
-      };
-
-      tests[name] = test;
-    },
-
-    has: function(name) {
-      if (this.ready().state() != 'resolved') {
-        throw 'Feature detection has not finished yet.';
-      }
-
-      if (!results.hasOwnProperty(name)) {
-        throw 'Unknown feature "' + name +'".';
-      }
-
-      return results[name];
-    },
-
-    ready: function() {
-      return ready.promise();
-    },
-
-    detect: function() {
-      var promises = {};
-
-      var asyncHas = function(name) {
-        var runTest = function() {
-          if (pageflow.debugMode() &&
-              window.localStorage &&
-              typeof window.localStorage['override ' + name] !== 'undefined') {
-            var value = (window.localStorage['override ' + name] === 'on');
-            pageflow.log('FEATURE OVERRIDDEN ' + name + ': ' + value, {force: true});
-            return value;
-          }
-          else {
-            return tests[name](asyncHas);
-          }
-        };
-
-        promises[name] = promises[name] || $.when(runTest(name));
-        return promises[name];
-      };
-
-      asyncHas.not = function(name) {
-        return asyncHas(name).pipe(function(result) {
-          return !result;
-        });
-      };
-
-      asyncHas.all = function(/* arguments */) {
-        return $.when.apply(null, arguments).pipe(function(/* arguments */) {
-          return _.all(arguments);
-        });
-      };
-
-      $.when.apply(null, _.map(_.keys(tests), function(name) {
-        return asyncHas(name).then(function(result) {
-          var cssClassName = name.replace(/ /g, '_');
-
-          $('body').toggleClass('has_' + cssClassName, !!result);
-          $('body').toggleClass('has_no_' + cssClassName, !result);
-
-          results[name] = !!result;
-        });
-      })).then(ready.resolve);
-
-      return this.ready();
-    }
-  };
-}());
+/**
+ * Registry of functions which extend pageflow when a named feature is
+ * enabled.
+ *
+ * @since 0.9
+ */
+pageflow.Features = pageflow.Object.extend({
+  /** @api private */
+  initialize: function() {
+    this.registry = {};
+    this.enabledFeatureNames = [];
+  },
+
+  /**
+   * `pageflow.features` has been renamed to `pageflow.browser`.
+   * @deprecated
+   */
+  has: function(/* arguments */) {
+    return pageflow.browser.has.apply(pageflow.browser, arguments);
+  },
+
+  /**
+   * Register a function to configure a feature when it is active.
+   *
+   * @param scope [String] Name of the scope the passed function
+   *   shall be called in.
+   * @param name [String] Name of the feature
+   * @param fn [Function] Function to call when the given feature
+   *   is activate.
+   */
+  register: function(scope, name, fn) {
+    this.registry[scope] = this.registry[scope] || {};
+    this.registry[scope][name] = this.registry[scope][name] || [];
+    this.registry[scope][name].push(fn);
+  },
+
+  /**
+   * Check if a feature as been enabled.
+   *
+   * @param name [String]
+   * @return [Boolean]
+   */
+  isEnabled: function(name) {
+    return _(this.enabledFeatureNames).contains(name);
+  },
+
+  /** @api private */
+  enable: function(scope, names) {
+    var fns = this.registry[scope] || {};
+    this.enabledFeatureNames = this.enabledFeatureNames.concat(names);
+
+    _(names).each(function(name) {
+      _(fns[name] || []).each(function(fn) {
+        fn();
+      });
+    });
+  }
+});
+
+/**
+ * Let plugins register functions which extend the editor or
+ * slideshow with certain functionality when a named feature is
+ * enabled.
+ *
+ * @return [pageflow.Features]
+ * @since 0.9
+ */
+pageflow.features = new pageflow.Features();

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

@@ -0,0 +1,24 @@
+pageflow.Fullscreen = pageflow.Object.extend({
+  toggle: function() {
+    var fullscreen = this;
+
+    if ($.support.fullscreen) {
+      $('#outer_wrapper').fullScreen({
+        callback: function(active) {
+          fullscreen._active = active;
+          fullscreen.trigger('change');
+        }
+      });
+    }
+  },
+
+  isSupported: function() {
+    return $.support.fullscreen;
+  },
+
+  isActive: function() {
+    return this._active;
+  }
+});
+
+pageflow.fullscreen = new pageflow.Fullscreen();

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

@@ -0,0 +1,48 @@
+pageflow.HighlightedPage = pageflow.Object.extend({
+  initialize: function(entryData) {
+    this.entry = entryData;
+  },
+
+  getPagePermaId: function(currentPagePermaId) {
+    var chapterId = this.entry.getChapterIdByPagePermaId(currentPagePermaId);
+
+    if (this.getNavigationBarMode(chapterId) === 'inherit_from_parent') {
+      var parentPagePermaId = this.entry.getParentPagePermaId(chapterId);
+
+      return parentPagePermaId &&
+        this.getPagePermaId(parentPagePermaId);
+    }
+    else {
+      return this.getDisplayedPageInChapter(currentPagePermaId);
+    }
+  },
+
+  getDisplayedPageInChapter: function(pagePermaId) {
+    return _(this.getChapterPagesUntil(pagePermaId).reverse()).find(function(permaId) {
+      return this.pageIsDisplayedInNavigation(permaId);
+    }, this);
+  },
+
+  pageIsDisplayedInNavigation: function(permaId) {
+    return this.entry.getPageConfiguration(permaId).display_in_navigation !== false;
+  },
+
+  getNavigationBarMode: function(chapterId) {
+    return this.entry.getChapterConfiguration(chapterId).navigation_bar_mode;
+  },
+
+  getChapterPagesUntil: function(pagePermaId) {
+    var found = false;
+    var chapterId = this.entry.getChapterIdByPagePermaId(pagePermaId);
+
+    return _.filter(this.entry.getChapterPagePermaIds(chapterId), function(other) {
+      var result = !found;
+      found = found || (pagePermaId === other);
+      return result;
+    });
+  }
+});
+
+pageflow.HighlightedPage.create = function() {
+  return new pageflow.HighlightedPage(pageflow.entryData);
+};

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

@@ -1,28 +1,60 @@
-pageflow.History = function(slideshow) {
-  slideshow.on('slideshowchangepage', function() {
-    if(pageflow.features.has('hashchange support')) {
-      window.location.hash = '#' + slideshow.currentPage().attr('id');
+//= require_self
+//= require_tree ./history
+
+pageflow.History = function(slideshow, adapter) {
+  slideshow.on('slideshowchangepage', function(event, options) {
+    var hash = slideshow.currentPage().attr('id');
+
+    if (options.back) {
+      adapter.replaceState(null, '', adapter.hash());
+    }
+    else {
+      adapter.replaceState(options, '', adapter.hash());
+      adapter.pushState(null, '', hash);
     }
   });
 
-  $(window).on('hashchange', function() {
-    slideshow.goToByPermaId(getHash());
+  adapter.on('popstate', function(event) {
+    if (!adapter.state()) {
+      return;
+    }
+
+    slideshow.goToByPermaId(adapter.hash(), _.extend({
+      back: true
+    }, _.pick(adapter.state(), 'direction', 'transition')));
+  });
+
+  adapter.on('hashchange', function() {
+    slideshow.goToByPermaId(adapter.hash());
   });
 
-  slideshow.goToByPermaId(getPermaId());
+  this.start = function() {
+    slideshow.goToByPermaId(adapter.hash() || pageParameter());
+    adapter.replaceState(null, '', slideshow.currentPage().attr('id'));
+  };
+
+  this.back = _.bind(adapter.back, adapter);
 
-  function getHash() {
-    var match = window.location.href.match(/#(.*)$/);
+  function pageParameter() {
+    var match = window.location.href.match(/page=([^&]*)/);
     return match ? match[1] : '';
   }
+};
 
-  function getPermaId() {
-    if (getHash().length) {
-      return getHash();
-    }
-    else {
-      var match = window.location.href.match(/page=([^&]*)/);
-      return match ? match[1] : '';
-    }
+pageflow.History.create = function(slideshow, options) {
+  options = options || {};
+
+  var adapter;
+
+  if (options.simulate || !pageflow.browser.has('hashchange support')) {
+    adapter = new pageflow.History.SimulatedAdapter();
+  }
+  else if (pageflow.browser.has('pushstate support')) {
+    adapter = new pageflow.History.PushStateAdapter();
   }
-};
+  else {
+    adapter = new pageflow.History.HashAdapter();
+  }
+
+  return new pageflow.History(slideshow, adapter);
+};

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

@@ -0,0 +1,36 @@
+pageflow.History.HashAdapter = function() {
+  var counter = 0;
+
+  this.back = function() {
+    if (counter > 0) {
+      window.history.back();
+      counter -= 1;
+      return true;
+    }
+    return false;
+  };
+
+  this.pushState = function(state, title, hash) {
+    if (window.location.hash !== hash) {
+      counter += 1;
+      window.location.hash = hash;
+    }
+  };
+
+  this.replaceState = function(state, title, hash) {
+    window.location.hash = hash;
+  };
+
+  this.state = function() {
+    return {};
+  };
+
+  this.hash = function() {
+    var match = window.location.href.match(/#(.*)$/);
+    return match ? match[1] : '';
+  };
+
+  this.on = function(event, listener) {
+    return $(window).on(event, listener);
+  };
+};

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

@@ -0,0 +1,37 @@
+pageflow.History.PushStateAdapter = function() {
+  var counter = 0;
+
+  this.back = function() {
+    if (counter > 0) {
+      window.history.back();
+      return true;
+    }
+    return false;
+  };
+
+  this.pushState = function(state, title, hash) {
+    counter += 1;
+    window.history.pushState(state, title, '#' + hash);
+  };
+
+  this.replaceState = function(state, title, hash) {
+    window.history.replaceState(state, title, '#' + hash);
+  };
+
+  this.state = function() {
+    return history.state;
+  };
+
+  this.hash = function() {
+    var match = window.location.href.match(/#(.*)$/);
+    return match ? match[1] : '';
+  };
+
+  this.on = function(event, listener) {
+    return $(window).on(event, listener);
+  };
+
+  $(window).on('popstate', function() {
+    counter -= 1;
+  });
+};