monocle-rails 0.0.1

data/vendor/assets/javascripts/compat/stubs.js

@@ -0,0 +1,50 @@
+// STUBS - simple debug functions and polyfills to normalise client
+// execution environments.
+
+
+// A little console stub if not initialized in a console-equipped browser.
+//
+if (typeof window.console == "undefined") {
+  window.console = { messages: [] }
+  window.console.log = function (msg) {
+    this.messages.push(msg);
+  }
+  window.console.warn = window.console.log;
+}
+
+
+// A simple version of console.dir that works on iOS.
+//
+window.console.compatDir = function (obj) {
+  var stringify = function (o) {
+    var parts = [];
+    for (var x in o) {
+      parts.push(x + ": " + o[x]);
+    }
+    return parts.join(";\n");
+  }
+
+  var out = stringify(obj);
+  window.console.log(out);
+  return out;
+}
+
+
+// This is called by Monocle methods and practices that are no longer
+// recommended and will soon be removed.
+//
+window.console.deprecation = function (msg) {
+  console.warn("[DEPRECATION]: "+msg);
+  if (typeof console.trace == "function") {
+    console.trace();
+  }
+}
+
+
+// A convenient alias for setTimeout that assumes 0 if no timeout is specified.
+//
+Monocle.defer = function (fn, time) {
+  if (typeof fn == "function") {
+    return setTimeout(fn, time || 0);
+  }
+}

data/vendor/assets/javascripts/controls/contents.js

@@ -0,0 +1,59 @@
+Monocle.Controls.Contents = function (reader) {
+
+  var API = { constructor: Monocle.Controls.Contents }
+  var k = API.constants = API.constructor;
+  var p = API.properties = {
+    reader: reader
+  }
+
+
+  function createControlElements() {
+    var div = reader.dom.make('div', 'controls_contents_container');
+    contentsForBook(div, reader.getBook());
+    return div;
+  }
+
+
+  function contentsForBook(div, book) {
+    while (div.hasChildNodes()) {
+      div.removeChild(div.firstChild);
+    }
+    var list = div.dom.append('ol', 'controls_contents_list');
+
+    var contents = book.properties.contents;
+    for (var i = 0; i < contents.length; ++i) {
+      chapterBuilder(list, contents[i], 0);
+    }
+  }
+
+
+  function chapterBuilder(list, chp, padLvl) {
+    var index = list.childNodes.length;
+    var li = list.dom.append('li', 'controls_contents_chapter', index);
+    var span = li.dom.append(
+      'span',
+      'controls_contents_chapterTitle',
+      index,
+      { html: chp.title }
+    );
+    span.style.paddingLeft = padLvl + "em";
+
+    var invoked = function () {
+      p.reader.skipToChapter(chp.src);
+      p.reader.hideControl(API);
+    }
+
+    Monocle.Events.listenForTap(li, invoked, 'controls_contents_chapter_active');
+
+    if (chp.children) {
+      for (var i = 0; i < chp.children.length; ++i) {
+        chapterBuilder(list, chp.children[i], padLvl + 1);
+      }
+    }
+  }
+
+
+  API.createControlElements = createControlElements;
+
+  return API;
+}

data/vendor/assets/javascripts/controls/magnifier.js

@@ -0,0 +1,51 @@
+Monocle.Controls.Magnifier = function (reader) {
+
+  var API = { constructor: Monocle.Controls.Magnifier }
+  var k = API.constants = API.constructor;
+  var p = API.properties = {
+    buttons: [],
+    magnified: false
+  }
+
+
+  function initialize() {
+    p.reader = reader;
+  }
+
+
+  function createControlElements(holder) {
+    var btn = holder.dom.make('div', 'controls_magnifier_button');
+    btn.smallA = btn.dom.append('span', 'controls_magnifier_a', { text: 'A' });
+    btn.largeA = btn.dom.append('span', 'controls_magnifier_A', { text: 'A' });
+    p.buttons.push(btn);
+    Monocle.Events.listenForTap(btn, toggleMagnification);
+    return btn;
+  }
+
+
+  function toggleMagnification(evt) {
+    var opacities;
+    p.magnified = !p.magnified;
+    if (p.magnified) {
+      opacities = [0.3, 1];
+      p.reader.formatting.setFontScale(k.MAGNIFICATION, true);
+    } else {
+      opacities = [1, 0.3];
+      p.reader.formatting.setFontScale(null, true);
+    }
+
+    for (var i = 0; i < p.buttons.length; i++) {
+      p.buttons[i].smallA.style.opacity = opacities[0];
+      p.buttons[i].largeA.style.opacity = opacities[1];
+    }
+  }
+
+  API.createControlElements = createControlElements;
+
+  initialize();
+
+  return API;
+}
+
+
+Monocle.Controls.Magnifier.MAGNIFICATION = 1.2;

data/vendor/assets/javascripts/controls/panel.js

@@ -0,0 +1,136 @@
+// A panel is an invisible column of interactivity. When contact occurs
+// (mousedown, touchstart), the panel expands to the full width of its
+// container, to catch all interaction events and prevent them from hitting
+// other things.
+//
+// Panels are used primarily to provide hit zones for page flipping
+// interactions, but you can do whatever you like with them.
+//
+// After instantiating a panel and adding it to the reader as a control,
+// you can call listenTo() with a hash of methods for any of 'start', 'move'
+// 'end' and 'cancel'.
+//
+Monocle.Controls.Panel = function () {
+
+  var API = { constructor: Monocle.Controls.Panel }
+  var k = API.constants = API.constructor;
+  var p = API.properties = {
+    evtCallbacks: {}
+  }
+
+  function createControlElements(cntr) {
+    p.div = cntr.dom.make('div', k.CLS.panel);
+    p.div.dom.setStyles(k.DEFAULT_STYLES);
+    Monocle.Events.listenForContact(
+      p.div,
+      {
+        'start': start,
+        'move': move,
+        'end': end,
+        'cancel': cancel
+      },
+      { useCapture: false }
+    );
+    return p.div;
+  }
+
+
+  function setDirection(dir) {
+    p.direction = dir;
+  }
+
+
+  function listenTo(evtCallbacks) {
+    p.evtCallbacks = evtCallbacks;
+  }
+
+
+  function deafen() {
+    p.evtCallbacks = {}
+  }
+
+
+  function start(evt) {
+    p.contact = true;
+    evt.m.offsetX += p.div.offsetLeft;
+    evt.m.offsetY += p.div.offsetTop;
+    expand();
+    invoke('start', evt);
+  }
+
+
+  function move(evt) {
+    if (!p.contact) {
+      return;
+    }
+    invoke('move', evt);
+  }
+
+
+  function end(evt) {
+    if (!p.contact) {
+      return;
+    }
+    Monocle.Events.deafenForContact(p.div, p.listeners);
+    contract();
+    p.contact = false;
+    invoke('end', evt);
+  }
+
+
+  function cancel(evt) {
+    if (!p.contact) {
+      return;
+    }
+    Monocle.Events.deafenForContact(p.div, p.listeners);
+    contract();
+    p.contact = false;
+    invoke('cancel', evt);
+  }
+
+
+  function invoke(evtType, evt) {
+    if (p.evtCallbacks[evtType]) {
+      p.evtCallbacks[evtType](p.direction, evt.m.offsetX, evt.m.offsetY, API);
+    }
+    evt.preventDefault();
+  }
+
+
+  function expand() {
+    if (p.expanded) {
+      return;
+    }
+    p.div.dom.addClass(k.CLS.expanded);
+    p.expanded = true;
+  }
+
+
+  function contract(evt) {
+    if (!p.expanded) {
+      return;
+    }
+    p.div.dom.removeClass(k.CLS.expanded);
+    p.expanded = false;
+  }
+
+
+  API.createControlElements = createControlElements;
+  API.listenTo = listenTo;
+  API.deafen = deafen;
+  API.expand = expand;
+  API.contract = contract;
+  API.setDirection = setDirection;
+
+  return API;
+}
+
+
+Monocle.Controls.Panel.CLS = {
+  panel: 'panel',
+  expanded: 'controls_panel_expanded'
+}
+Monocle.Controls.Panel.DEFAULT_STYLES = {
+  position: 'absolute',
+  height: '100%'
+}

data/vendor/assets/javascripts/controls/placesaver.js

@@ -0,0 +1,100 @@
+Monocle.Controls.PlaceSaver = function (bookId) {
+
+  var API = { constructor: Monocle.Controls.PlaceSaver }
+  var k = API.constants = API.constructor;
+  var p = API.properties = {}
+
+
+  function initialize() {
+    applyToBook(bookId);
+  }
+
+
+  function assignToReader(reader) {
+    p.reader = reader;
+    p.reader.listen('monocle:turn', savePlaceToCookie);
+  }
+
+
+  function applyToBook(bookId) {
+    p.bkTitle = bookId.toLowerCase().replace(/[^a-z0-9]/g, '');
+    p.prefix = k.COOKIE_NAMESPACE + p.bkTitle + ".";
+  }
+
+
+  function setCookie(key, value, days) {
+    var expires = "";
+    if (days) {
+      var d = new Date();
+      d.setTime(d.getTime() + (days * 24 * 60 * 60 * 1000));
+      expires = "; expires="+d.toGMTString();
+    }
+    var path = "; path=/";
+    document.cookie = p.prefix + key + "=" + value + expires + path;
+    return value;
+  }
+
+
+  function getCookie(key) {
+    if (!document.cookie) {
+      return null;
+    }
+    var regex = new RegExp(p.prefix + key + "=(.+?)(;|$)");
+    var matches = document.cookie.match(regex);
+    if (matches) {
+      return matches[1];
+    } else {
+      return null;
+    }
+  }
+
+
+  function savePlaceToCookie() {
+    var place = p.reader.getPlace();
+    setCookie(
+      "component",
+      encodeURIComponent(place.componentId()),
+      k.COOKIE_EXPIRES_IN_DAYS
+    );
+    setCookie(
+      "percent",
+      place.percentageThrough(),
+      k.COOKIE_EXPIRES_IN_DAYS
+    );
+  }
+
+
+  function savedPlace() {
+    var locus = {
+      componentId: getCookie('component'),
+      percent: getCookie('percent')
+    }
+    if (locus.componentId && locus.percent) {
+      locus.componentId = decodeURIComponent(locus.componentId);
+      locus.percent = parseFloat(locus.percent);
+      return locus;
+    } else {
+      return null;
+    }
+  }
+
+
+  function restorePlace() {
+    var locus = savedPlace();
+    if (locus) {
+      p.reader.moveTo(locus);
+    }
+  }
+
+
+  API.assignToReader = assignToReader;
+  API.savedPlace = savedPlace;
+  API.restorePlace = restorePlace;
+
+  initialize();
+
+  return API;
+}
+
+Monocle.Controls.PlaceSaver.COOKIE_NAMESPACE = "monocle.controls.placesaver.";
+Monocle.Controls.PlaceSaver.COOKIE_EXPIRES_IN_DAYS = 7; // Set to 0 for session-based expiry.

data/vendor/assets/javascripts/controls/scrubber.js

@@ -0,0 +1,140 @@
+Monocle.Controls.Scrubber = function (reader) {
+
+  var API = { constructor: Monocle.Controls.Scrubber }
+  var k = API.constants = API.constructor;
+  var p = API.properties = {}
+
+
+  function initialize() {
+    p.reader = reader;
+    p.reader.listen('monocle:turn', updateNeedles);
+    updateNeedles();
+  }
+
+
+  function pixelToPlace(x, cntr) {
+    if (!p.componentIds) {
+      p.componentIds = p.reader.getBook().properties.componentIds;
+      p.componentWidth = 100 / p.componentIds.length;
+    }
+    var pc = (x / cntr.offsetWidth) * 100;
+    var cmpt = p.componentIds[Math.floor(pc / p.componentWidth)];
+    var cmptPc = ((pc % p.componentWidth) / p.componentWidth);
+    return { componentId: cmpt, percentageThrough: cmptPc };
+  }
+
+
+  function placeToPixel(place, cntr) {
+    if (!p.componentIds) {
+      p.componentIds = p.reader.getBook().properties.componentIds;
+      p.componentWidth = 100 / p.componentIds.length;
+    }
+    var componentIndex = p.componentIds.indexOf(place.componentId());
+    var pc = p.componentWidth * componentIndex;
+    pc += place.percentageThrough() * p.componentWidth;
+    return Math.round((pc / 100) * cntr.offsetWidth);
+  }
+
+
+  function updateNeedles() {
+    if (p.hidden || !p.reader.dom.find(k.CLS.container)) {
+      return;
+    }
+    var place = p.reader.getPlace();
+    var x = placeToPixel(place, p.reader.dom.find(k.CLS.container));
+    for (var i = 0, needle; needle = p.reader.dom.find(k.CLS.needle, i); ++i) {
+      setX(needle, x - needle.offsetWidth / 2);
+      p.reader.dom.find(k.CLS.trail, i).style.width = x + "px";
+    }
+  }
+
+
+  function setX(node, x) {
+    var cntr = p.reader.dom.find(k.CLS.container);
+    x = Math.min(cntr.offsetWidth - node.offsetWidth, x);
+    x = Math.max(x, 0);
+    Monocle.Styles.setX(node, x);
+  }
+
+
+  function createControlElements(holder) {
+    var cntr = holder.dom.make('div', k.CLS.container);
+    var track = cntr.dom.append('div', k.CLS.track);
+    var needleTrail = cntr.dom.append('div', k.CLS.trail);
+    var needle = cntr.dom.append('div', k.CLS.needle);
+    var bubble = cntr.dom.append('div', k.CLS.bubble);
+
+    var cntrListeners, bodyListeners;
+
+    var moveEvt = function (evt, x) {
+      evt.preventDefault();
+      x = (typeof x == "number") ? x : evt.m.registrantX;
+      var place = pixelToPlace(x, cntr);
+      setX(needle, x - needle.offsetWidth / 2);
+      var book = p.reader.getBook();
+      var chps = book.chaptersForComponent(place.componentId);
+      var cmptIndex = p.componentIds.indexOf(place.componentId);
+      var chp = chps[Math.floor(chps.length * place.percentageThrough)];
+      if (cmptIndex > -1 && book.properties.components[cmptIndex]) {
+        var actualPlace = Monocle.Place.FromPercentageThrough(
+          book.properties.components[cmptIndex],
+          place.percentageThrough
+        );
+        chp = actualPlace.chapterInfo() || chp;
+      }
+
+      if (chp) {
+        bubble.innerHTML = chp.title;
+      }
+      setX(bubble, x - bubble.offsetWidth / 2);
+
+      p.lastX = x;
+      return place;
+    }
+
+    var endEvt = function (evt) {
+      var place = moveEvt(evt, p.lastX);
+      p.reader.moveTo({
+        percent: place.percentageThrough,
+        componentId: place.componentId
+      });
+      Monocle.Events.deafenForContact(cntr, cntrListeners);
+      Monocle.Events.deafenForContact(document.body, bodyListeners);
+      bubble.style.display = "none";
+    }
+
+    var startFn = function (evt) {
+      evt.stopPropagation();
+      bubble.style.display = "block";
+      moveEvt(evt);
+      cntrListeners = Monocle.Events.listenForContact(
+        cntr,
+        { move: moveEvt }
+      );
+      bodyListeners = Monocle.Events.listenForContact(
+        document.body,
+        { end: endEvt }
+      );
+    }
+
+    Monocle.Events.listenForContact(cntr, { start: startFn });
+
+    return cntr;
+  }
+
+
+  API.createControlElements = createControlElements;
+  API.updateNeedles = updateNeedles;
+
+  initialize();
+
+  return API;
+}
+
+Monocle.Controls.Scrubber.CLS = {
+  container: 'controls_scrubber_container',
+  track: 'controls_scrubber_track',
+  needle: 'controls_scrubber_needle',
+  trail: 'controls_scrubber_trail',
+  bubble: 'controls_scrubber_bubble'
+}