rhet-butler 0.13.0 → 0.14.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ODZlMjBlZjY5N2JhNjhiNjkwYjA0MWE0YjBmNDhmZTRiY2M5MTVhNA==
-  data.tar.gz: !binary |-
-    ZWI4OWU5YzZlZWM3ODdjYzBlOTA1NTE5MTAwYTEyYmUyMzJlMWVlYQ==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    MTJjYjA1Nzg4NGI5ZWQyYTczZGYwOTViNWIxYTc5OTJiYmMwODNkN2RkNDFh
-    MDRjZDIzNTVlNzE2MTVkOGFiNDljYTdhMTZkYWZjMTk2ZTNmMzQ5ODc3MmNh
-    NDg0Yzc5YzRkM2VmN2UxMDBlOGU2YTVjYTVkMDJkZjNhYzI0YzI=
-  data.tar.gz: !binary |-
-    Mzg5OTE4YzNjYjc5ZjliZmU1MGJjNzFkN2M2MTBkMjBiNGNiZTEwZjdjZmRj
-    ZTFkOGVhYzc3ODFjZDY3MGRiOGY2NGU4NWUwY2VlNGI3NWQxMDQ0NjdkYTll
-    NzNhMTFiOWFiYmZkOTU4MzQ5YzhiODk0N2Q2YmIyYTkxYmRkM2Q=
+SHA256:
+  metadata.gz: bccbe00728c9002f8abfc509425b4f5b24fa4ccb8ea4dd11fad668101284542f
+  data.tar.gz: 98aa2c7300f207844ae64039baf9546c909ab802230b143f5c4e3f1660a2f1b6
+SHA512:
+  metadata.gz: b0a5639408cde011d9a841d81ae1442d6e10468ab56c825b4fea0179337feed6408c50cb9ed5be3d6316b2c7736f3093ca70f208c03087ffa46ce3b9df079953
+  data.tar.gz: 2fc6cee2a0a4ae09629e8c18c6f7b16f7ada43d6877780cb410b28553d7fe7b85a637b0e760afe97efb5064b035fac9b2c2ad5d57e761f16da20d3814cd7c506

data/default-configuration/assets/fonts.googleapis.com/css/family=Arimo:700|Droid Sans Mono|Cinzel Decorative:700,900|Slackey,subset=latin,latin-ext

@@ -0,0 +1,30 @@
+@font-face {
+  font-family: 'Arimo';
+  font-style: normal;
+  font-weight: 700;
+  src: local('Arimo Bold'), local('Arimo-Bold'), url(../../fonts.gstatic.com/s/arimo/v12/P5sBzZCDf9_T_1Wi4TRNrZc.ttf) format('truetype');
+}
+@font-face {
+  font-family: 'Cinzel Decorative';
+  font-style: normal;
+  font-weight: 700;
+  src: local('Cinzel Decorative Bold'), local('CinzelDecorative-Bold'), url(../../fonts.gstatic.com/s/cinzeldecorative/v7/daaHSScvJGqLYhG8nNt8KPPswUAPniZoadlESTQ.ttf) format('truetype');
+}
+@font-face {
+  font-family: 'Cinzel Decorative';
+  font-style: normal;
+  font-weight: 900;
+  src: local('Cinzel Decorative Black'), local('CinzelDecorative-Black'), url(../../fonts.gstatic.com/s/cinzeldecorative/v7/daaHSScvJGqLYhG8nNt8KPPswUAPniZQa9lESTQ.ttf) format('truetype');
+}
+@font-face {
+  font-family: 'Droid Sans Mono';
+  font-style: normal;
+  font-weight: 400;
+  src: local('Droid Sans Mono Regular'), local('DroidSansMono-Regular'), url(../../fonts.gstatic.com/s/droidsansmono/v10/6NUO8FuJNQ2MbkrZ5-J8lKFrp7pRef2u.ttf) format('truetype');
+}
+@font-face {
+  font-family: 'Slackey';
+  font-style: normal;
+  font-weight: 400;
+  src: local('Slackey Regular'), local('Slackey-Regular'), url(../../fonts.gstatic.com/s/slackey/v9/N0bV2SdQO-5yM0-dGlNQIQ.ttf) format('truetype');
+}

data/default-configuration/assets/javascript/presenter.js

@@ -0,0 +1,317 @@
+//Presenter
+//  The overall interface to the application
+//  Maintains some state, receives method calls to e.g. move between slides
+//  Builds the step-tree
+//  Builds StationLists
+
+import * as utils from "./utils.js";
+import TreeBuilder from "./rhet-butler/tree-builder.js";
+import TransitionStations from "./rhet-butler/transition-stations.js";
+import Step from './rhet-butler/step.js';
+
+export default class {
+  constructor(document, window, rootId){
+    this.document = document;
+    this.body = document.body;
+    this.window = window;
+    this.stepsById = {};
+
+    this.previousSlideIndex = 0;
+    this.nextStepIndex = 0;
+
+    this.root = utils.byId(rootId);
+    this.body.classList.remove("rhet-disabled");
+    this.body.classList.add("rhet-enabled");
+
+    // get and init steps
+    var stepElements = utils.arrayify(this.root.getElementsByClassName("rhet-butler"));
+    var treeBuilder = new TreeBuilder(this.root, "rhet-butler");
+    this.rootStep = treeBuilder.buildTree();
+    this.rootStep.eachStep(function (step) {
+        step.addClass("future");
+      });
+
+    var prev = this.rootStep.firstItem;
+
+    this.currentTransition = new TransitionStations(this, prev, prev, prev);
+    this.currentTransition.forceFinish();
+
+    this.unbinders = [];
+    this.bindHandlers();
+
+    utils.triggerEvent(this.root, "rhet:init", { api: this });
+  }
+
+  //    updateBeforeAndAfter(previousStep, nextStep){
+  //      this.markRange(0, previousStep.indexes.step, "before");
+  //      this.markRange(nextStep.indexes.step, undefined, "after");
+  //      previousStep.eachParent(function(step){ step.removeClass("before"); });
+  //      nextStep.eachParent(function(step){ step.removeClass("after"); });
+  //    }
+
+  teardown(){
+    this.unbindHandlers();
+  }
+
+  markRange(start, end, mark){
+    this.stepsList.slice(start, end).forEach(function(elem){
+        var containers;
+        containers = this.containingElements(elem);
+        containers.steps.forEach(function(step){ this.thisClassNotThose(step, mark, "before", "after", "passing"); }, this);
+        containers.slides.forEach(function(slide){ this.thisClassNotThose(slide, mark, "before", "after", "passing"); }, this);
+      }, this);
+  }
+
+  bindHandler(target, event, funk, capture) {
+    this.unbinders.push(() => {
+        target.removeEventListener(event, funk, capture);
+      })
+
+    target.addEventListener(event, funk, capture);
+  }
+
+  unbindHandlers() {
+    for(let f of this.unbinders){
+      f();
+    }
+  }
+
+  bindHandlers(){
+    var presenter = this;
+
+    this.unbindHandlers();
+
+    //Our own :init event
+    var initListener = function(){
+      // last hash detected
+      var lastHash = "";
+
+      // STEP CLASSES
+//        this.root.addEventListener("rhet:stepenter", function (event) {
+//            this.thisClassNotThose(event.target, "present", "past", "future");
+//          }, false);
+//
+//        this.root.addEventListener("rhet:stepleave", function (event) {
+//            this.thisClassNotThose(event.target, "past", "present", "future");
+//          }, false);
+
+      // `#/step-id` is used instead of `#step-id` to prevent default browser
+      // scrolling to element in hash.
+      //
+      // And it has to be set after animation finishes, because in Chrome it
+      // makes transtion laggy.
+      // BUG: http://code.google.com/p/chromium/issues/detail?id=62820
+
+      presenter.bindHandler(presenter.root, "rhet:stepenter", function (event) {
+          window.location.hash = lastHash = "#/" + event.target.id;
+        }, false);
+
+
+      presenter.bindHandler(window, "hashchange",
+        function(event){
+          if(window.location.hash !== lastHash) {
+            presenter.moveTo( presenter.getElementFromHash() );
+          }
+        }, false);
+
+      // START
+      // by selecting step defined in url or first step of the presentation
+
+      presenter.teleport(presenter.getElementFromHash() || presenter.rootStep.firstItem);
+    }
+
+    this.bindHandler(this.root, "rhet:init", initListener, false);
+  }
+
+  resolveStep(reference, thing){
+    // find by id
+    // find by relavtive pos (next,prev)*(slide,item)
+    if(reference instanceof Step){
+      return reference;
+    } else {
+      switch(reference){
+      case 'next':
+        switch(thing){
+        case 'slide':
+          return this.currentTransition.lastStep.nextSlide;
+          break;
+        case 'item':
+          return this.currentTransition.lastStep.nextItem;
+          break
+        default:
+          throw "Bad step reference: '" + reference +","+ thing +"'";
+        }
+        break;
+      case 'prev':
+      case 'previous':
+        switch(thing){
+        case 'slide':
+          return this.currentTransition.lastStep.prevSlide;
+          break;
+        case 'item':
+          return this.currentTransition.lastStep.prevItem;
+          break
+        default:
+          throw "Bad step reference: '" + reference +","+ thing +"'";
+        }
+
+        break;
+      default:
+        if(reference in this.rootStep.childrenById){
+          return this.rootStep.childrenById[reference];
+        }else{
+          throw "Bad slide direction: '" + reference +"'";
+        }
+      }
+    }
+  }
+
+  currentStep(){
+    return this.currentTransition.currentStep;
+  }
+
+  buildTransition(nextStep){
+    var previousStep = this.currentTransition.resumeStep();
+    var currentStep = this.currentTransition.currentStep;
+    if(typeof quiet_console == "undefined") {
+      console.log("New transition list: " +
+          "S/C/E: " + previousStep.toString() +
+          " / " + currentStep.toString() +
+          " / " + nextStep.toString());
+      }
+
+    this.currentTransition.cancel();
+    this.currentTransition = new TransitionStations(this, previousStep, currentStep, nextStep);
+  }
+
+  teleport(reference, thing){
+    var nextStep = this.resolveStep(reference, thing);
+    if(nextStep){
+      this.buildTransition(nextStep);
+      this.currentTransition.forceFinish();
+    }
+  }
+
+  moveTo(reference, thing){
+    var nextStep = this.resolveStep(reference, thing);
+    if(nextStep){
+      this.buildTransition(nextStep);
+      this.currentTransition.start();
+    }
+  }
+
+  completeTransition(){
+    var elem = document.getElementById(this.currentTransition.currentStep.element.id);
+    utils.triggerEvent(elem, "rhet:stepenter", { api: this });
+  }
+
+  ///// METHODS BELOW HERE STILL IN NEED OF REFACTORING
+
+  checkSupport (){
+    var ua = navigator.userAgent.toLowerCase();
+    var impressSupported = ( pfx("perspective") !== null ) && ( body.classList ) && ( body.dataset )
+    //also should check getComputedStyle
+
+    if (!impressSupported) {
+      // we can't be sure that `classList` is supported
+      this.body.className += " rhet-not-supported ";
+      return false
+    } else {
+      this.body.classList.remove("rhet-not-supported");
+      this.body.classList.add("rhet-supported");
+      return true
+    }
+  }
+
+  // `getElementFromHash` returns an element located by id from hash part of
+  // window location.
+  getElementFromHash () {
+    // get id from url # by removing `#` or `#/` from the beginning,
+    // so both "fallback" `#slide-id` and "enhanced" `#/slide-id` will work
+    return window.location.hash.replace(/^#\/?/,"");
+  }
+
+  // `getStep` is a helper function that returns a step element defined by
+  // parameter.
+  // If a number is given, step with index given by the number is returned, if a string
+  // is given step element with such id is returned, if DOM element is given it is returned
+  // if it is a correct step element.
+  getStep ( step ) {
+    if (typeof step === "number") {
+      step = step < 0 ? this.stepsList[ stepsList.length + step] : this.stepsList[ step ];
+    } else if (typeof step === "string") {
+      step = utils.byId(step);
+    }
+    return (step && step.id && this.stepsData[step.id]) ? step : null;
+  }
+
+  // `prev` API function goes to previous step (in document order)
+  prev () {
+    var prev = this.steps.indexOf( this.activeStep ) - 1;
+    prev = prev >= 0 ? this.steps[ prev ] : this.getStep(-1);
+
+    return this.moveTo(prev);
+  }
+
+  // `next` API function goes to next step (in document order)
+  next () {
+    var next = steps.indexOf( activeStep ) + 1;
+    next = next < steps.length ? steps[ next ] : steps[ 0 ];
+
+    return this.moveTo(next);
+  }
+
+  //thisClassNotThose(someEl, "setMe", "unsetMe", "unsetMeToo")
+  //e.g.
+  //thisClassNotThose(event.target, "present", "past", "future")
+  thisClassNotThose(element, setClass) { //...exclusiveClasses
+    var idx, length = arguments.length;
+    for(idx=2; idx < arguments.length; idx++){
+      element.classList.remove(arguments[idx]);
+    }
+    element.classList.add(setClass);
+  }
+
+  //General classes:
+  //past: we have visited this
+  //present: we're currently here
+  //future: we have never visited
+  //
+  //previous: we're "leaving" this one
+  //next: we're "going to" this one
+  //before: the current index > this one
+  //after: the current index < this one
+  //passing: index between next and previous index
+  //
+  //XXX Move to stationList
+  //Relation between current/next/etc step and slide and group
+  unmarkEndpoint(stepIndex, mark){
+    var containers = this.containingElements(this.steps[stepIndex]);
+    var slide = containers.slides[0];
+
+    containers.all.forEach(function(elem){ elem.classList.remove(mark); })
+
+    this.root.classList.remove(mark + "-" + slide.id)
+  }
+
+  markTime(stepIndex, mark){
+    var containers = this.containingElements(this.steps[stepIndex]);
+    var slide = containers.slides[0];
+
+    containers.all.forEach(function(elem){
+        this.thisClassNotThose(elem, mark, "past", "present", "future");
+      }, this)
+  }
+
+  markEndpoint(stepIndex, mark){
+    var containers = this.containingElements(this.steps[stepIndex]);
+    var slide = containers.slides[0];
+
+    containers.all.forEach(function(elem){
+        this.thisClassNotThose(elem, mark, "before", "after", "passing");
+      }, this)
+
+    this.root.classList.add(mark + "-" + slide.id);
+    return containers
+  }
+}

data/default-configuration/assets/javascript/rhet-butler/child-step.js

@@ -0,0 +1,13 @@
+import Step from './step.js';
+
+export default class extends Step {
+  constructor(parent, element, indexes){
+    super(element, indexes);
+    this.parent = parent;
+    this.parent.addChild(this);
+  };
+
+  propagateDescendant(newChild){
+    this.parent.addDescendant(newChild);
+  };
+}

data/default-configuration/assets/javascript/rhet-butler/step.js

@@ -0,0 +1,197 @@
+//
+//  Able to relate selves to other steps in order to calculate motions
+//    - "which step is <motion> from you?"
+//    - "where is <step> in relation to you?"
+//
+//import Slide from './steps/slide.js';
+
+export default class {
+  constructor(element, indexes){
+    this.element = element;
+    this.groups = [];
+    this.steps = [];
+
+    this.children = [];
+    this.indexes = {};
+    this.childrenById = {};
+
+    for(let field in indexes) {
+      this.indexes[field] = indexes[field];
+    };
+
+    this.element.classList.add("future");
+
+    this.firstSlide = null;
+    this.lastSlide = null;
+
+    this.prevSlide = null;
+    this.nextSlide = null;
+
+    this.firstItem = null;
+    this.lastItem = null;
+
+    this.prevItem = null;
+    this.nextItem = null;
+  }
+
+  toString() {
+    return "A Step " + this.element.id
+  }
+
+  treeFinished() {
+  }
+
+  addClass(name){
+    this.element.classList.add(name);
+  }
+
+  removeClass(name){
+    if(name instanceof RegExp){
+      Array.prototype.forEach.call(this.element.classList, function(klass){
+          if(name.test(klass)){
+            this.element.classList.remove(klass);
+          }
+        }, this)
+    } else {
+      this.element.classList.remove(name);
+    }
+  }
+
+  hasClass(name){
+    return this.element.classList.contains(name);
+  }
+
+  beginDeparture(){
+    this.addClass("previous");
+    this.removeClass("current");
+    this.parent.beginDeparture();
+  }
+
+  completeDeparture(){
+    this.removeClass("previous");
+
+    this.removeClass("present");
+    this.removeClass("future");
+    this.removeClass("current");
+    this.addClass("past");
+    this.parent.completeDeparture();
+  }
+
+  beginArrival(){
+    this.addClass("next");
+    this.parent.beginArrival();
+  }
+
+  completeArrival(){
+    this.removeClass("next");
+    this.addClass("current");
+
+    this.removeClass("future");
+    this.removeClass("past");
+    this.addClass("present");
+    this.parent.completeArrival();
+  }
+
+  cancelArrival(){
+    this.removeClass("next");
+  }
+
+  eachStep(dothis){
+    dothis(this);
+    this.children.forEach(function(step){
+        step.eachStep(dothis);
+      });
+  }
+
+  // Given a structure level, return the kind and direction of transition to another step
+  relativeLevelPosition(level, target){
+    if(!target){ return ["none", "same", level]; };
+    var difference = target.indexes[level] - this.indexes[level];
+
+    if(difference < -1){
+      return ["jump", "backwards", "by-" + level];
+    } else if(difference == -1){
+      return ["advance", "backwards", "by-" + level];
+    } else if(difference == 1){
+      return ["advance", "forwards", "by-" + level];
+    } else if(difference > 1){
+      return ["jump", "forwards", "by-" + level];
+    }
+
+    return ["none", "same", "by-" + level];
+  }
+
+  relativePosition(target){
+    var relPos = this.relativeLevelPosition("slide", target);
+    if(relPos[0] == "none"){
+      relPos = this.relativeLevelPosition("item", target);
+    }
+    return relPos;
+  }
+
+  addChild(newChild){
+    this.debugAssoc("Xanc", newChild);
+    var lastChild = this.children.slice(-1)[0];
+    if(lastChild){
+      this.debugAssoc("Xalc", lastChild);
+      newChild.addPrevStep(lastChild);
+      lastChild.addNextStep(newChild);
+    }
+    this.children.push(newChild);
+    this.addDescendant(newChild);
+  }
+
+  addDescendant(newChild){
+    this.childrenById[newChild.element.id] = newChild;
+
+    newChild.joinParent(this);
+
+    this.propagateDescendant(newChild);
+  }
+
+  joinParent(parent){}
+
+  lastChild(){
+    if(this.children.length > 0){
+      return this.children.slice(-1)[0];
+    } else {
+      return this
+    }
+  }
+
+  debugAssoc(assoc, other){
+    //console.log(assoc, this.toString(), other.toString());
+  }
+
+  addNextRoot(root){
+    this.debugAssoc("Xnr", root)
+  }
+
+  addPrevRoot(root){
+    this.debugAssoc("Xpr", root)
+  }
+
+  addNextGroup(group){
+    this.debugAssoc("Xng", group)
+  }
+
+  addPrevGroup(group){
+    this.debugAssoc("Xpg", group)
+  }
+
+  addNextSlide(slide){
+    this.debugAssoc("Xns", slide)
+  }
+
+  addPrevSlide(slide){
+    this.debugAssoc("Xps", slide)
+  }
+
+  addNextItem(item){
+    this.debugAssoc("Xni", item)
+  }
+
+  addPrevItem(item){
+    this.debugAssoc("Xpi", item)
+  }
+}