monocle-rails 0.0.1

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

@@ -0,0 +1,99 @@
+Monocle.Controls.Spinner = function (reader) {
+
+  var API = { constructor: Monocle.Controls.Spinner }
+  var k = API.constants = API.constructor;
+  var p = API.properties = {
+    reader: reader,
+    divs: [],
+    repeaters: {},
+    showForPages: []
+  }
+
+
+  function createControlElements(cntr) {
+    var anim = cntr.dom.make('div', 'controls_spinner_anim');
+    anim.dom.append('div', 'controls_spinner_inner');
+    p.divs.push(anim);
+    return anim;
+  }
+
+
+  function registerSpinEvent(startEvtType, stopEvtType) {
+    var label = startEvtType;
+    p.reader.listen(startEvtType, function (evt) { spin(label, evt) });
+    p.reader.listen(stopEvtType, function (evt) { spun(label, evt) });
+  }
+
+
+  // Registers spin/spun event handlers for certain time-consuming events.
+  //
+  function listenForUsualDelays() {
+    registerSpinEvent('monocle:componentloading', 'monocle:componentloaded');
+    registerSpinEvent('monocle:componentchanging', 'monocle:componentchange');
+    registerSpinEvent('monocle:resizing', 'monocle:resize');
+    registerSpinEvent('monocle:jumping', 'monocle:jump');
+    registerSpinEvent('monocle:recalculating', 'monocle:recalculated');
+    p.reader.listen('monocle:notfound', forceSpun);
+    p.reader.listen('monocle:componentfailed', forceSpun);
+  }
+
+
+  // Displays the spinner. Both arguments are optional.
+  //
+  function spin(label, evt) {
+    label = label || k.GENERIC_LABEL;
+    p.repeaters[label] = true;
+    p.reader.showControl(API);
+
+    // If the delay is on a page other than the page we've been assigned to,
+    // don't show the animation. p.global ensures that if an event affects
+    // all pages, the animation is always shown, even if other events in this
+    // spin cycle are page-specific.
+    var page = (evt && evt.m && evt.m.page) ? evt.m.page : null;
+    if (page && p.divs.length > 1) {
+      p.showForPages[page.m.pageIndex] = true;
+    } else {
+      p.global = true;
+      p.reader.dispatchEvent('monocle:modal:on');
+    }
+    for (var i = 0; i < p.divs.length; ++i) {
+      var show = (p.global || p.showForPages[i]) ? true : false;
+      p.divs[i].dom[show ? 'removeClass' : 'addClass']('dormant');
+    }
+  }
+
+
+  // Stops displaying the spinner. Both arguments are optional.
+  //
+  function spun(label, evt) {
+    label = label || k.GENERIC_LABEL;
+    p.repeaters[label] = false;
+    for (var l in p.repeaters) {
+      if (p.repeaters[l]) { return; }
+    }
+    forceSpun();
+  }
+
+
+  function forceSpun() {
+    if (p.global) { p.reader.dispatchEvent('monocle:modal:off'); }
+    p.global = false;
+    p.repeaters = {};
+    p.showForPages = [];
+    for (var i = 0; i < p.divs.length; ++i) {
+      p.divs[i].dom.addClass('dormant');
+    }
+  }
+
+
+  API.createControlElements = createControlElements;
+  API.registerSpinEvent = registerSpinEvent;
+  API.listenForUsualDelays = listenForUsualDelays;
+  API.spin = spin;
+  API.spun = spun;
+  API.forceSpun = forceSpun;
+
+  return API;
+}
+
+Monocle.Controls.Spinner.GENERIC_LABEL = "generic";

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

@@ -0,0 +1,410 @@
+Monocle.Controls.Stencil = function (reader, behaviorClasses) {
+
+  var API = { constructor: Monocle.Controls.Stencil }
+  var k = API.constants = API.constructor;
+  var p = API.properties = {
+    reader: reader,
+    behaviors: [],
+    components: {},
+    masks: []
+  }
+
+
+  // Create the stencil container and listen for draw/update events.
+  //
+  function createControlElements(holder) {
+    behaviorClasses = behaviorClasses || k.DEFAULT_BEHAVIORS;
+    for (var i = 0, ii = behaviorClasses.length; i < ii; ++i) {
+      addBehavior(behaviorClasses[i]);
+    }
+    p.container = holder.dom.make('div', k.CLS.container);
+    p.reader.listen('monocle:turning', hide);
+    p.reader.listen('monocle:turn:cancel', show);
+    p.reader.listen('monocle:turn', update);
+    p.reader.listen('monocle:stylesheetchange', update);
+    p.reader.listen('monocle:resize', update);
+    update();
+    return p.container;
+  }
+
+
+  // Pass this method an object that responds to 'findElements(doc)' with
+  // an array of DOM elements for that document, and to 'fitMask(elem, mask)'.
+  //
+  // After you have added all your behaviors this way, you would typically
+  // call update() to make them take effect immediately.
+  //
+  function addBehavior(bhvrClass) {
+    var bhvr = new bhvrClass(API);
+    if (typeof bhvr.findElements != 'function') {
+      console.warn('Missing "findElements" method for behavior: %o', bhvr);
+    }
+    if (typeof bhvr.fitMask != 'function') {
+      console.warn('Missing "fitMask" method for behavior: %o', bhvr);
+    }
+    p.behaviors.push(bhvr);
+  }
+
+
+  // Resets any pre-calculated rectangles for the active component,
+  // recalculates them, and forces masks to be "drawn" (moved into the new
+  // rectangular locations).
+  //
+  function update() {
+    var visPages = p.reader.visiblePages();
+    if (!visPages || !visPages.length) { return; }
+    var pageDiv = visPages[0];
+    var cmptId = pageComponentId(pageDiv);
+    if (!cmptId) { return; }
+    p.components[cmptId] = null;
+    calculateRectangles(pageDiv);
+    draw();
+  }
+
+
+  function hide() {
+    p.container.style.display = 'none';
+  }
+
+
+  function show() {
+    p.container.style.display = 'block';
+  }
+
+
+  // Removes any existing masks.
+  function clear() {
+    while (p.container.childNodes.length) {
+      p.container.removeChild(p.container.lastChild);
+    }
+  }
+
+
+  // Aligns the stencil container to the shape of the page, then moves the
+  // masks to sit above any currently visible rectangles.
+  //
+  function draw() {
+    var pageDiv = p.reader.visiblePages()[0];
+    var cmptId = pageComponentId(pageDiv);
+    if (!p.components[cmptId]) {
+      return;
+    }
+
+    // Position the container.
+    alignToComponent(pageDiv);
+
+    // Clear old masks.
+    clear();
+
+    // Layout the masks.
+    if (!p.disabled) {
+      show();
+      var rects = p.components[cmptId];
+      if (rects && rects.length) {
+        layoutRectangles(pageDiv, rects);
+      }
+    }
+  }
+
+
+  // Iterate over all the <a> elements in the active component, and
+  // create an array of rectangular points corresponding to their positions.
+  //
+  function calculateRectangles(pageDiv) {
+    var cmptId = pageComponentId(pageDiv);
+    if (!p.components[cmptId]) {
+      p.components[cmptId] = [];
+    } else {
+      return;
+    }
+
+    var doc = pageDiv.m.activeFrame.contentDocument;
+    var offset = getOffset(pageDiv);
+
+    for (var b = 0, bb = p.behaviors.length; b < bb; ++b) {
+      var bhvr = p.behaviors[b];
+      var elems = bhvr.findElements(doc);
+      for (var i = 0; i < elems.length; ++i) {
+        var elem = elems[i];
+        if (elem.getClientRects) {
+          var r = elem.getClientRects();
+          for (var j = 0; j < r.length; j++) {
+            p.components[cmptId].push({
+              element: elem,
+              behavior: bhvr,
+              left: Math.ceil(r[j].left + offset.l),
+              top: Math.ceil(r[j].top),
+              width: Math.floor(r[j].width),
+              height: Math.floor(r[j].height)
+            });
+          }
+        }
+      }
+    }
+
+    return p.components[cmptId];
+  }
+
+
+  // Update location of visible rectangles - creating as required.
+  //
+  function layoutRectangles(pageDiv, rects) {
+    var offset = getOffset(pageDiv);
+    var visRects = [];
+    for (var i = 0; i < rects.length; ++i) {
+      if (rectVisible(rects[i], offset.l, offset.l + offset.w)) {
+        visRects.push(rects[i]);
+      }
+    }
+
+    for (i = 0; i < visRects.length; ++i) {
+      var r = visRects[i];
+      var cr = {
+        left: r.left - offset.l,
+        top: r.top,
+        width: r.width,
+        height: r.height
+      };
+      var mask = createMask(r.element, r.behavior);
+      mask.dom.setStyles({
+        display: 'block',
+        left: cr.left+"px",
+        top: cr.top+"px",
+        width: cr.width+"px",
+        height: cr.height+"px",
+        position: 'absolute'
+      });
+      mask.stencilRect = cr;
+    }
+  }
+
+
+  // Find the offset position in pixels from the left of the current page.
+  //
+  function getOffset(pageDiv) {
+    return {
+      l: pageDiv.m.offset || 0,
+      w: pageDiv.m.dimensions.properties.width
+    };
+  }
+
+
+  // Is this area presently on the screen?
+  //
+  function rectVisible(rect, l, r) {
+    var mid = rect.left + (rect.width * 0.5);
+    return mid >= l && mid < r;
+  }
+
+
+  // Returns the active component id for the given page, or the current
+  // page if no argument passed in.
+  //
+  function pageComponentId(pageDiv) {
+    pageDiv = pageDiv || p.reader.visiblePages()[0];
+    if (!pageDiv.m.activeFrame.m.component) { return; }
+    return pageDiv.m.activeFrame.m.component.properties.id;
+  }
+
+
+  // Positions the stencil container over the active frame.
+  //
+  function alignToComponent(pageDiv) {
+    var cmpt = pageDiv.m.activeFrame.parentNode;
+    p.container.dom.setStyles({
+      left: cmpt.offsetLeft+"px",
+      top: cmpt.offsetTop+"px"
+    });
+  }
+
+
+  function createMask(element, bhvr) {
+    var mask = p.container.dom.append(bhvr.maskTagName || 'div', k.CLS.mask);
+    Monocle.Events.listenForContact(mask, {
+      start: function () { p.reader.dispatchEvent('monocle:magic:halt'); },
+      move: function (evt) { evt.preventDefault(); },
+      end: function () { p.reader.dispatchEvent('monocle:magic:init'); }
+    });
+    bhvr.fitMask(element, mask);
+    return mask;
+  }
+
+
+  // Make the active masks visible (by giving them a class -- override style
+  // in monoctrl.css).
+  //
+  function toggleHighlights() {
+    var cls = k.CLS.highlights;
+    if (p.container.dom.hasClass(cls)) {
+      p.container.dom.removeClass(cls);
+    } else {
+      p.container.dom.addClass(cls);
+    }
+  }
+
+
+  function disable() {
+    p.disabled = true;
+    draw();
+  }
+
+
+  function enable() {
+    p.disabled = false;
+    draw();
+  }
+
+
+  function filterElement(elem, behavior) {
+    if (typeof behavior.filterElement == 'function') {
+      return behavior.filterElement(elem);
+    }
+    return elem;
+  }
+
+
+  function maskAssigned(elem, mask, behavior) {
+    if (typeof behavior.maskAssigned == 'function') {
+      return behavior.maskAssigned(elem, mask);
+    }
+    return false;
+  }
+
+
+  API.createControlElements = createControlElements;
+  API.addBehavior = addBehavior;
+  API.draw = draw;
+  API.update = update;
+  API.toggleHighlights = toggleHighlights;
+
+  return API;
+}
+
+
+Monocle.Controls.Stencil.CLS = {
+  container: 'controls_stencil_container',
+  mask: 'controls_stencil_mask',
+  highlights: 'controls_stencil_highlighted'
+}
+
+
+
+Monocle.Controls.Stencil.Links = function (stencil) {
+  var API = { constructor: Monocle.Controls.Stencil.Links }
+
+  // Optionally specify the HTML tagname of the mask.
+  API.maskTagName = 'a';
+
+  // Returns an array of all the elements in the given doc that should
+  // be covered with a stencil mask for interactivity.
+  //
+  // (Hint: doc.querySelectorAll() is your friend.)
+  //
+  API.findElements = function (doc) {
+    return doc.querySelectorAll('a[href]');
+  }
+
+
+  // Return an element. It should usually be a child of the container element,
+  // with a className of the given maskClass. You set up the interactivity of
+  // the mask element here.
+  //
+  API.fitMask = function (link, mask) {
+    var hrefObject = deconstructHref(link);
+    var rdr = stencil.properties.reader;
+    var evtData = { href: hrefObject, link: link, mask: mask }
+
+    if (hrefObject.pass) {
+      mask.onclick = function (evt) { return link.click(); }
+    } else {
+      link.onclick = function (evt) {
+        evt.preventDefault();
+        return false;
+      }
+      if (hrefObject.internal) {
+        mask.setAttribute('href', 'javascript:"Skip to chapter"');
+        mask.onclick = function (evt) {
+          if (rdr.dispatchEvent('monocle:link:internal', evtData, true)) {
+            rdr.skipToChapter(hrefObject.internal);
+          }
+          evt.preventDefault();
+          return false;
+        }
+      } else {
+        mask.setAttribute('href', hrefObject.external);
+        mask.setAttribute('target', '_blank');
+        mask.onclick = function (evt) {
+          return rdr.dispatchEvent('monocle:link:external', evtData, true);
+        }
+      }
+    }
+  }
+
+
+  // Returns an object with either:
+  //
+  // - an 'external' property -- an absolute URL with a protocol,
+  // host & etc, which should be treated as an external resource (eg,
+  // open in new window)
+  //
+  //   OR
+  //
+  // - an 'internal' property -- a relative URL (with optional hash anchor),
+  //  that is treated as a link to component in the book
+  //
+  // A weird but useful property of <a> tags is that while
+  // link.getAttribute('href') will return the actual string value of the
+  // attribute (eg, 'foo.html'), link.href will return the absolute URL (eg,
+  // 'http://example.com/monocles/foo.html').
+  //
+  function deconstructHref(elem) {
+    var loc = document.location;
+    var origin = loc.protocol+'//'+loc.host;
+    var href = elem.href;
+    var path = href.substring(origin.length);
+    var ext = { external: href };
+
+    if (href.toLowerCase().match(/^javascript:/)) {
+      return { pass: true };
+    }
+
+    // Anchor tags with 'target' attributes are always external URLs.
+    if (elem.getAttribute('target')) {
+      return ext;
+    }
+    // URLs with a different protocol or domain are always external.
+    //console.log("Domain test: %s <=> %s", origin, href);
+    if (href.indexOf(origin) !== 0) {
+      return ext;
+    }
+
+    // If it is in a sub-path of the current path, it's internal.
+    var topPath = loc.pathname.replace(/[^\/]*\.[^\/]+$/,'');
+    if (topPath[topPath.length - 1] != '/') {
+      topPath += '/';
+    }
+    //console.log("Sub-path test: %s <=> %s", topPath, path);
+    if (path.indexOf(topPath) === 0) {
+      return { internal: path.substring(topPath.length) }
+    }
+
+    // If it's a root-relative URL and it's in our list of component ids,
+    // it's internal.
+    var cmptIds = stencil.properties.reader.getBook().properties.componentIds;
+    for (var i = 0, ii = cmptIds.length; i < ii; ++i) {
+      //console.log("Component test: %s <=> %s", cmptIds[i], path);
+      if (path.indexOf(cmptIds[i]) === 0) {
+        return { internal: path }
+      }
+    }
+
+    // Otherwise it's external.
+    return ext;
+  }
+
+
+  return API;
+}
+
+
+Monocle.Controls.Stencil.DEFAULT_BEHAVIORS = [Monocle.Controls.Stencil.Links];