bookreader 1.0.1

data/vendor/assets/javascripts/BookReaderJSAdvanced.js

@@ -0,0 +1,115 @@
+//
+// This file shows the minimum you need to provide to BookReader to display a book
+//
+// Copyright(c)2008-2009 Internet Archive. Software license AGPL version 3.
+
+// Create the BookReader object
+var options = {
+  // Total number of leafs
+  getNumLeafs: function() {
+      return 15;
+  },
+
+  // Return the width of a given page.  Here we assume all images are 800 pixels wide
+  getPageWidth: function(index) {
+      return 800;
+  },
+
+  // Return the height of a given page.  Here we assume all images are 1200 pixels high
+  getPageHeight: function(index) {
+      return 1200;
+  },
+
+  // We load the images from archive.org -- you can modify this function to retrieve images
+  // using a different URL structure
+  getPageURI: function(index, reduce, rotate) {
+      // reduce and rotate are ignored in this simple implementation, but we
+      // could e.g. look at reduce and load images from a different directory
+      // or pass the information to an image server
+      var leafStr = '000';
+      var imgStr = (index+1).toString();
+      var re = new RegExp("0{"+imgStr.length+"}$");
+      var url = 'http://archive.org/download/BookReader/img/page'+leafStr.replace(re, imgStr) + '.jpg';
+      return url;
+  },
+
+  // Return which side, left or right, that a given page should be displayed on
+  getPageSide: function(index) {
+      if (0 == (index & 0x1)) {
+          return 'R';
+      } else {
+          return 'L';
+      }
+  },
+
+  // This function returns the left and right indices for the user-visible
+  // spread that contains the given index.  The return values may be
+  // null if there is no facing page or the index is invalid.
+  getSpreadIndices: function(pindex) {
+      var spreadIndices = [null, null];
+      if ('rl' == this.pageProgression) {
+          // Right to Left
+          if (this.getPageSide(pindex) == 'R') {
+              spreadIndices[1] = pindex;
+              spreadIndices[0] = pindex + 1;
+          } else {
+              // Given index was LHS
+              spreadIndices[0] = pindex;
+              spreadIndices[1] = pindex - 1;
+          }
+      } else {
+          // Left to right
+          if (this.getPageSide(pindex) == 'L') {
+              spreadIndices[0] = pindex;
+              spreadIndices[1] = pindex + 1;
+          } else {
+              // Given index was RHS
+              spreadIndices[1] = pindex;
+              spreadIndices[0] = pindex - 1;
+          }
+      }
+      return spreadIndices;
+  },
+
+  // For a given "accessible page index" return the page number in the book.
+  //
+  // For example, index 5 might correspond to "Page 1" if there is front matter such
+  // as a title page and table of contents.
+  getPageNum: function(index) {
+      return index+1;
+  },
+
+  // Book title and the URL used for the book title link
+  bookTitle: 'BookReader Advanced Demo',
+  bookUrl: '/BookReaderDemo/index.html',
+  bookUrlText: 'Back to Demos',
+  bookUrlTitle: 'This is the book URL title',
+  // thumbnail is optional, but it is used in the info dialog
+  thumbnail: '//archive.org/download/BookReader/img/page014.jpg',
+  // Metadata is optional, but it is used in the info dialog
+  metadata: [
+    {label: 'Title', value: 'Open Library BookReader Presentation'},
+    {label: 'Author', value: 'Internet Archive'},
+    {label: 'Demo Info', value: 'This demo shows how one could use BookReader with their own content.'},
+  ],
+  // This toggles the mobile drawer (not shown in 'embed' mode)
+  enableMobileNav: false,
+  mobileNavTitle: 'BookReader demo',
+
+  // Override the path used to find UI images
+  imagesBaseURL: '../BookReader/images/',
+
+  getEmbedCode: function(frameWidth, frameHeight, viewParams) {
+      return "Embed code not supported in bookreader demo.";
+  },
+
+  // Note previously the UI param was used for mobile, but it's going to be responsive
+  // embed === iframe
+
+  ui: 'full', // embed, full (responsive)
+
+};
+var br = new BookReader(options);
+
+// Let's go!
+br.init();

data/vendor/assets/javascripts/BookReaderJSSimple.js

@@ -0,0 +1,56 @@
+//
+// This file shows the minimum you need to provide to BookReader to display a book
+//
+// Copyright(c)2008-2009 Internet Archive. Software license AGPL version 3.
+
+// Create the BookReader object
+function instantiateBookReader(selector, extraOptions) {
+  selector = selector || '#BookReader';
+  extraOptions = extraOptions || {};
+  var options = {
+    data: [
+      [
+        { width: 800, height: 1200,
+          uri: '//archive.org/download/BookReader/img/page001.jpg' },
+      ],
+      [
+        { width: 800, height: 1200,
+          uri: '//archive.org/download/BookReader/img/page002.jpg' },
+        { width: 800, height: 1200,
+          uri: '//archive.org/download/BookReader/img/page003.jpg' },
+      ],
+      [
+        { width: 800, height: 1200,
+          uri: '//archive.org/download/BookReader/img/page004.jpg' },
+        { width: 800, height: 1200,
+          uri: '//archive.org/download/BookReader/img/page005.jpg' },
+      ]
+    ],
+
+    // Book title and the URL used for the book title link
+    bookTitle: 'BookReader Demo',
+    bookUrl: '/BookReaderDemo/index.html',
+    bookUrlText: 'Back to Demos',
+    bookUrlTitle: 'This is the book URL title',
+
+    // thumbnail is optional, but it is used in the info dialog
+    thumbnail: '//archive.org/download/BookReader/img/page014.jpg',
+    // Metadata is optional, but it is used in the info dialog
+    metadata: [
+      {label: 'Title', value: 'Open Library BookReader Presentation'},
+      {label: 'Author', value: 'Internet Archive'},
+      {label: 'Demo Info', value: 'This demo shows how one could use BookReader with their own content.'},
+    ],
+
+    // Override the path used to find UI images
+    imagesBaseURL: '../BookReader/images/',
+
+    ui: 'full', // embed, full (responsive)
+
+    el: selector,
+  };
+  Object.assign(options, extraOptions);
+  var br = new BookReader(options);
+  br.init();
+}
+

data/vendor/assets/javascripts/IIIFBookReader.js

@@ -0,0 +1,207 @@
+// Bind to the BookReader object providing facilities to set the necessary
+// BookReader functions from a IIIF endpoint URL.
+// author: @aeschylus
+
+// TODO enable passing in manifest and sequence id directly
+// TODO convert this to be a v3 plugin. Use simplified options.data
+
+(function(BR){
+
+    BR.prototype.IIIF = function (config) {
+        // config should have the url of a sequence
+        // within a passed-in manifest.
+        var brInstance = this;
+        brInstance.IIIFsequence = {
+            title: null,
+            imagesList: [],
+            numPages: null,
+            bookUrl: null
+        };
+        oldInit = brInstance.init;
+        oldMode = brInstance.mode;
+        brInstance.init = function() {
+            load(config);
+        };
+        brInstance.mode = 2;
+
+        function bindBRMethods(){
+            brInstance.getPageNum = function(index) {
+                return index+1;
+            };
+
+            brInstance.getSpreadIndices = function(pindex) {
+                var spreadIndices = [null, null];
+                if ('rl' == brInstance.pageProgression) {
+                    // Right to Left
+                    if (brInstance.getPageSide(pindex) == 'R') {
+                        spreadIndices[1] = pindex;
+                        spreadIndices[0] = pindex + 1;
+                    } else {
+                        // Given index was LHS
+                        spreadIndices[0] = pindex;
+                        spreadIndices[1] = pindex - 1;
+                    }
+                } else {
+                    // Left to right
+                    if (brInstance.getPageSide(pindex) == 'L') {
+                        spreadIndices[0] = pindex;
+                        spreadIndices[1] = pindex + 1;
+                    } else {
+                        // Given index was RHS
+                        spreadIndices[1] = pindex;
+                        spreadIndices[0] = pindex - 1;
+                    }
+                }
+
+                return spreadIndices;
+            };
+
+            brInstance.getPageSide = function(index) {
+                if (0 == (index & 0x1)) {
+                    return 'R';
+                } else {
+                    return 'L';
+                }
+            };
+
+            brInstance.getPageHeight = function(index) {
+                // console.log(index);
+                var fullWidth = brInstance.IIIFsequence.imagesList[index].width,
+                fullHeight = brInstance.IIIFsequence.imagesList[index].height,
+                scaleRatio = config.maxWidth/fullWidth;
+
+                return fullHeight*scaleRatio;
+            };
+
+            brInstance.getPageWidth = function(index) {
+                var fullWidth = brInstance.IIIFsequence.imagesList[index].width,
+                scaleRatio = config.maxWidth/fullWidth;
+
+                return fullWidth*scaleRatio;
+            };
+
+            brInstance.getPageURI = function(index) {
+                // Finds the image info.json url
+                // from the loaded sequence and returns the
+                // IIIF-formatted url for the page image
+                // based on the provided configuration object
+                // (adjusting for width, etc.).
+                var infoJsonUrl = brInstance.IIIFsequence.imagesList[index].imageUrl;
+                var url = infoJsonUrl + "/full/" + config.maxWidth + ",/0/native.jpg";
+                return url;
+            };
+
+        }
+
+        function load(config) {
+
+            endpointUrl = config.url,
+            sequenceId = config.sequenceId;
+
+            jQuery.ajax({
+                url: endpointUrl.replace(/^\s+|\s+$/g, ''),
+                dataType: 'json',
+                async: true,
+
+                success: function(jsonLd) {
+                    brInstance.jsonLd = jsonLd;
+                    brInstance.bookTitle = jsonLd.label;
+                    brInstance.bookUrl = '#';
+                    brInstance.thumbnail = jsonLd.thumbnail['@id'];
+                    brInstance.metadata = jsonLd.metadata;
+                    parseSequence(sequenceId);
+                    bindBRMethods();
+
+                    // Call the old initialisation after
+                    // the urls are finished. A better implementation
+                    // would be to employ promises (Likely by including
+                    // the Q Promises/A+ implementation. See issue #1 at
+                    // github.
+                    oldInit.call(brInstance);
+
+                    if (config.initCallback) {
+                      config.initCallback.apply();
+                    }
+
+                    // // The following is an attrocious hack and must not
+                    // // be allowed to persist. See issue #2 at github.com
+                    // setTimeout(function() { jQuery(window).trigger('resize'); console.log("resize event fired")}, 2500);
+                },
+
+                error: function() {
+                    console.log('Failed loading ' + brInstance.uri);
+                }
+
+            });
+
+        }
+
+        function parseSequence(sequenceId) {
+
+            jQuery.each(brInstance.jsonLd.sequences, function(index, sequence) {
+                if (sequence['@id'] === sequenceId) {
+                    brInstance.IIIFsequence.title = "here's a sequence";
+                    brInstance.IIIFsequence.bookUrl = "http://iiif.io";
+                    brInstance.IIIFsequence.imagesList = getImagesList(sequence);
+                    brInstance.numLeafs = brInstance.IIIFsequence.imagesList.length;
+                }
+            });
+
+            delete brInstance.jsonLd;
+
+        }
+
+        function getImagesList(sequence) {
+            var imagesList = [];
+
+            jQuery.each(sequence.canvases, function(index, canvas) {
+                var imageObj;
+
+                if (canvas['@type'] === 'sc:Canvas') {
+                    var images = canvas.resources || canvas.images;
+
+                    jQuery.each(images, function(index, image) {
+                        if (image['@type'] === 'oa:Annotation') {
+                            imageObj = getImageObject(image);
+                            imageObj.canvasWidth = canvas.width;
+                            imageObj.canvasHeight = canvas.height;
+
+                            if (!(/#xywh/).test(image.on)) {
+                                imagesList.push(imageObj);
+                            }
+                        }
+                    });
+
+                }
+            });
+
+            return imagesList;
+        }
+
+        function getImageObject (image) {
+            var resource = image.resource;
+
+            if (resource.hasOwnProperty('@type') && resource['@type'] === 'oa:Choice') {
+                var imageObj = getImageProperties(resource.default);
+            } else {
+                imageObj = getImageProperties(resource);
+            }
+
+            return(imageObj);
+        }
+
+        function getImageProperties(image) {
+            var imageObj = {
+                height:       image.height || 0,
+                width:        image.width || 0,
+                imageUrl:     image.service['@id'].replace(/\/$/, ''),
+            };
+
+            imageObj.aspectRatio  = (imageObj.width / imageObj.height) || 1;
+
+            return imageObj;
+        }
+
+    };
+
+})(BookReader);

data/vendor/assets/javascripts/demo-iiif.js

@@ -0,0 +1,26 @@
+// This demo uses a slightly modified version of
+// https://github.com/aeschylus/IIIFBookReader
+//
+// It is intended as a rapid proof of concept.
+// More development could be done.
+
+var br = new BookReader({
+    // Book title and the URL used for the book title link
+    bookTitle: 'Open Library BookReader Presentation',
+    bookUrl: 'http://openlibrary.org',
+
+    // Override the path used to find UI images
+    imagesBaseURL: '../BookReader/images/',
+    enableMobileNav: false,
+});
+
+br.IIIF({
+    url: 'https://iiif.archivelab.org/iiif/platowithenglish04platuoft/manifest.json',
+    sequenceId : 'https://iiif.archivelab.org/iiif/platowithenglish04platuoft/canvas/default',
+    maxWidth: 800,
+    initCallback: function() {
+    }
+});
+
+// Let's go!
+br.init();

data/vendor/assets/javascripts/dragscrollable-br.js

@@ -0,0 +1,261 @@
+/*
+ * jQuery dragscrollable Plugin
+ * version: 1.0 (25-Jun-2009)
+ * Copyright (c) 2009 Miquel Herrera
+ *
+ * Portions Copyright (c) 2010 Reg Braithwaite
+ *          Copyright (c) 2010 Internet Archive / Michael Ang
+ *          Copyright (c) 2016 Internet Archive / Richard Caceres
+ *
+ * Dual licensed under the MIT and GPL licenses:
+ *   http://www.opensource.org/licenses/mit-license.php
+ *   http://www.gnu.org/licenses/gpl.html
+ *
+ * Modified by richard@archive.org 2016
+ * - Added check to disable on touch enabled devices
+ * - Change dragend handler to bind using event "capturing" instead of "bubbling"
+ */
+;(function($){ // secure $ jQuery alias
+
+/**
+ * Adds the ability to manage elements scroll by dragging
+ * one or more of its descendant elements. Options parameter
+ * allow to specifically select which inner elements will
+ * respond to the drag events.
+ *
+ * options properties:
+ * ------------------------------------------------------------------------
+ *  dragSelector         | jquery selector to apply to each wrapped element
+ *                       | to find which will be the dragging elements.
+ *                       | Defaults to '>:first' which is the first child of
+ *                       | scrollable element
+ * ------------------------------------------------------------------------
+ *  acceptPropagatedEvent| Will the dragging element accept propagated
+ *	                     | events? default is yes, a propagated mouse event
+ *	                     | on a inner element will be accepted and processed.
+ *	                     | If set to false, only events originated on the
+ *	                     | draggable elements will be processed.
+ * ------------------------------------------------------------------------
+ *  preventDefault       | Prevents the event to propagate further effectivey
+ *                       | dissabling other default actions. Defaults to true
+ * ------------------------------------------------------------------------
+ *  scrollWindow         | Scroll the window rather than the element
+ *                       | Defaults to false
+ * ------------------------------------------------------------------------
+ *
+ *  usage examples:
+ *
+ *  To add the scroll by drag to the element id=viewport when dragging its
+ *  first child accepting any propagated events
+ *	$('#viewport').dragscrollable();
+ *
+ *  To add the scroll by drag ability to any element div of class viewport
+ *  when dragging its first descendant of class dragMe responding only to
+ *  evcents originated on the '.dragMe' elements.
+ *	$('div.viewport').dragscrollable({dragSelector:'.dragMe:first',
+ *									  acceptPropagatedEvent: false});
+ *
+ *  Notice that some 'viewports' could be nested within others but events
+ *  would not interfere as acceptPropagatedEvent is set to false.
+ *
+ */
+
+var append_namespace = function (string_of_events, ns) {
+
+    /* IE doesn't have map
+	return string_of_events
+		.split(' ')
+			.map(function (name) { return name + ns; })
+				.join(' ');
+    */
+    var pieces = string_of_events.split(' ');
+    var ret = new Array();
+    for (var i = 0; i < pieces.length; i++) {
+        ret.push(pieces[i] + ns);
+    }
+    return ret.join(' ');
+};
+
+var left_top = function(event) {
+
+	var x;
+	var y;
+	if (typeof(event.clientX) != 'undefined') {
+		x = event.clientX;
+		y = event.clientY;
+	}
+	else if (typeof(event.screenX) != 'undefined') {
+		x = event.screenX;
+		y = event.screenY;
+	}
+	else if (typeof(event.targetTouches) != 'undefined') {
+		x = event.targetTouches[0].pageX;
+		y = event.targetTouches[0].pageY;
+	}
+	else if (typeof(event.originalEvent) == 'undefined') {
+		var str = '';
+		for (i in event) {
+			str += ', ' + i + ': ' + event[i];
+		}
+		console.error("don't understand x and y for " + event.type + ' event: ' + str);
+	}
+	else if (typeof(event.originalEvent.clientX) != 'undefined') {
+		x = event.originalEvent.clientX;
+		y = event.originalEvent.clientY;
+	}
+	else if (typeof(event.originalEvent.screenX) != 'undefined') {
+		x = event.originalEvent.screenX;
+		y = event.originalEvent.screenY;
+	}
+	else if (typeof(event.originalEvent.targetTouches) != 'undefined') {
+		x = event.originalEvent.targetTouches[0].pageX;
+		y = event.originalEvent.targetTouches[0].pageY;
+	}
+
+	return {left: x, top:y};
+};
+
+$.fn.dragscrollable = function( options ) {
+
+	var handling_element = $(this);
+
+	var settings = $.extend(
+		{
+			dragSelector:'>:first',
+			acceptPropagatedEvent: true,
+            preventDefault: true,
+			dragstart: 'mousedown touchstart',
+			dragcontinue: 'mousemove touchmove',
+			dragend: 'mouseup touchend', // mouseleave
+			dragMinDistance: 5,
+			namespace: '.ds',
+			scrollWindow: false,
+		},options || {});
+
+	settings.dragstart = append_namespace(settings.dragstart, settings.namespace);
+	settings.dragcontinue = append_namespace(settings.dragcontinue, settings.namespace);
+	//settings.dragend = append_namespace(settings.dragend, settings.namespace);
+
+	var shouldAbort = function() {
+		var isTouchDevice = !!('ontouchstart' in window) || !!('msmaxtouchpoints' in window.navigator);
+		return isTouchDevice;
+	};
+
+  var dragContinueHandlerProxy;
+
+	var dragscroll= {
+		dragStartHandler : function(event) {
+			if (shouldAbort()) { return true; }
+
+			// mousedown, left click, check propagation
+			if (event.which > 1 ||
+				(!event.data.acceptPropagatedEvent && event.target != this)){
+				return false;
+			}
+
+			event.data.firstCoord = left_top(event);
+			// Initial coordinates will be the last when dragging
+			event.data.lastCoord = event.data.firstCoord;
+
+			handling_element
+				.bind(settings.dragcontinue, event.data, dragscroll.dragContinueHandler)
+				//.bind(settings.dragend, event.data, dragscroll.dragEndHandler)
+			;
+
+			// Note, we bind using addEventListener so we can use "capture" binding
+			// instead of "bubble" binding
+			dragContinueHandlerProxy = function(e){
+				e.data = event.data;
+				dragscroll.dragEndHandler(e);
+			};
+			$.each(settings.dragend.split(' '), function(idx, val) {
+				handling_element.get(0).addEventListener(val, dragContinueHandlerProxy, true);
+			});
+
+			if (event.data.preventDefault) {
+				event.preventDefault();
+				return false;
+			}
+		},
+		dragContinueHandler : function(event) { // User is dragging
+			// console.log('drag continue');
+			if (shouldAbort()) { return true; }
+
+			var lt = left_top(event);
+
+			// How much did the mouse move?
+			var delta = {left: (lt.left - event.data.lastCoord.left),
+						 top: (lt.top - event.data.lastCoord.top)};
+
+			var scrollTarget = event.data.scrollable;
+			if (event.data.scrollWindow) {
+				scrollTarget = $(window);
+			}
+			// Set the scroll position relative to what ever the scroll is now
+			scrollTarget.scrollLeft( scrollTarget.scrollLeft() - delta.left );
+			scrollTarget.scrollTop(	scrollTarget.scrollTop() - delta.top );
+
+			// Save where the cursor is
+			event.data.lastCoord = lt;
+
+			if (event.data.preventDefault) {
+				event.preventDefault();
+				return false;
+			}
+		},
+		dragEndHandler : function(event) { // Stop scrolling
+			//console.log('dragEndHandler');
+
+			if (shouldAbort()) { return true; }
+
+			handling_element
+				.unbind(settings.dragcontinue)
+				// Note, for some reason, even though I removeEventListener below,
+        // this call to unbind is still necessary. I don't know why.
+				.unbind(settings.dragend)
+			;
+
+			// Note, we bind using addEventListener so we can use "capture" binding
+			// instead of "bubble" binding
+			$.each(settings.dragend.split(' '), function(idx, val) {
+				handling_element.get(0).removeEventListener(val, dragContinueHandlerProxy, true);
+			});
+
+			// How much did the mouse move total?
+			var delta = {left: Math.abs(event.data.lastCoord.left - event.data.firstCoord.left),
+						 top: Math.abs(event.data.lastCoord.top - event.data.firstCoord.top)};
+			var distance = Math.max(delta.left, delta.top);
+
+			// Allow event to propage if min distance was not achieved
+			if (event.data.preventDefault && distance > settings.dragMinDistance) {
+				event.preventDefault();
+				event.stopImmediatePropagation();
+				event.stopPropagation();
+				return false;
+			}
+		}
+	};
+
+	// set up the initial events
+	return this.each(function() {
+		// closure object data for each scrollable element
+		var data = {scrollable : $(this),
+					acceptPropagatedEvent : settings.acceptPropagatedEvent,
+					preventDefault : settings.preventDefault,
+					scrollWindow : settings.scrollWindow };
+		// Set mouse initiating event on the desired descendant
+		$(this).find(settings.dragSelector).
+						bind(settings.dragstart, data, dragscroll.dragStartHandler);
+	});
+}; //end plugin dragscrollable
+
+// Note, this probably doesn't work anymore with our modifications - Nov/8/2016
+$.fn.removedragscrollable = function (namespace) {
+	if (typeof(namespace) == 'undefined')
+		namespace = '.ds';
+	return this.each(function() {
+		var x = $(document).find('*').andSelf().unbind(namespace);
+	});
+};
+
+})( jQuery ); // confine scope