.
+ * #L%
+ * Authors: Robert Casties, Martin Raspe
+ */
+/** required digilib geometry plugin
+ */
+
+(function($) {
+//var dlGeometry = function() {
+ /*
+ * Size class
+ */
+ var size = function(w, h) {
+ var that;
+ if (typeof w === "object") {
+ // assume an object having width and height
+ that = {
+ width : w.width,
+ height : w.height
+ };
+ } else {
+ that = {
+ width : parseFloat(w),
+ height : parseFloat(h)
+ };
+ }
+ // returns true if both sizes are equal
+ that.equals = function(other) {
+ return (this.width === other.width && this.height === other.height);
+ };
+ // returns the aspect ratio of this size
+ that.getAspect = function() {
+ return (this.width / this.height);
+ };
+ // returns a size of a given aspect ratio that fits into this one
+ that.fitAspect = function(aspect) {
+ var s = size(this);
+ if (aspect > this.getAspect()) {
+ // size is more horizontally stretched than this
+ s.height = s.width / aspect;
+ } else {
+ s.width = s.height * aspect;
+ }
+ return s;
+ };
+ // adjusts size of jQuery element "$elem" to this size
+ that.adjustDiv = function($elem) {
+ $elem.width(this.width).height(this.height);
+ };
+ that.toString = function() {
+ return (this.width + "x" + this.height);
+ };
+ return that;
+ };
+
+ /*
+ * Position class
+ */
+ var position = function(x, y) {
+ var that;
+ if (typeof x === "object") {
+ if (x instanceof jQuery) {
+ // jQuery object
+ var pos = x.offset();
+ that = {
+ x : pos.left,
+ y : pos.top
+ };
+ } else if ($.isArray(x)) {
+ that = {
+ x : x[0],
+ y : x[1]
+ };
+ } else {
+ if (x.x != null) {
+ // position object
+ that = {
+ x : parseFloat(x.x),
+ y : parseFloat(x.y)
+ };
+ }
+ if (x.pageX != null) {
+ // event object
+ that = {
+ x : x.pageX,
+ y : x.pageY
+ };
+ }
+ }
+ } else {
+ that = {
+ x : parseFloat(x),
+ y : parseFloat(y)
+ };
+ };
+ // return a copy of this position
+ that.copy = function() {
+ return position(this);
+ };
+ // compare function
+ that.equals = function(other) {
+ return (this.x === other.x && this.y === other.y);
+ };
+ // add vector or position to this
+ that.add = function(other) {
+ if ($.isArray(other)) {
+ this.x += other[0];
+ this.y += other[1];
+ } else {
+ this.x += other.x;
+ this.y += other.y;
+ }
+ return this;
+ };
+ // returns negative position
+ that.neg = function() {
+ return position({
+ x : -this.x,
+ y : -this.y
+ });
+ };
+ // returns new position that is the difference between this and other
+ that.delta = function(other) {
+ return position({
+ x : other.x - this.x,
+ y : other.y - this.y
+ });
+ };
+ // returns other position scaled by ratio with regard to this point
+ that.scale = function(other, ratio) {
+ var d = this.delta(other);
+ return position({
+ x : this.x + d.x * ratio,
+ y : this.y + d.y * ratio
+ });
+ };
+ // adjusts CSS position of $elem to this position
+ that.adjustDiv = function($elem) {
+ $elem.offset({
+ left : this.x,
+ top : this.y
+ });
+ };
+ // move this position to another
+ that.moveTo = function(other) {
+ this.x = other.x;
+ this.y = other.y;
+ return this;
+ };
+ // adjust this position so that is is inside rect
+ that.clipTo = function (rect) {
+ var p1 = rect.getPt1();
+ var p2 = rect.getPt2();
+ this.x = Math.max(this.x, p1.x);
+ this.y = Math.max(this.y, p1.y);
+ this.x = Math.min(this.x, p2.x);
+ this.y = Math.min(this.y, p2.y);
+ return this;
+ };
+ // returns distance of this position to pos (length if pos == null)
+ that.distance = function(pos) {
+ if (pos == null) {
+ pos = {
+ x : 0,
+ y : 0
+ };
+ }
+ var dx = pos.x - this.x;
+ var dy = pos.y - this.y;
+ return Math.sqrt(dx * dx + dy * dy);
+ };
+ // nearest of several points
+ that.nearest = function (points) {
+ var nearest = points[0];
+ var dist = this.distance(nearest);
+ $.each(points, function(index, item) {
+ var len = this.distance(item);
+ if (len < dist) {
+ dist = len;
+ nearest = item;
+ }
+ });
+ return nearest;
+ };
+ // midpoint of this and other pos
+ that.mid = function (pos) {
+ return position({
+ x : (this.x + pos.x)/2,
+ y : (this.y + pos.y)/2
+ });
+ };
+ // radians of angle between line and the positive X axis
+ that.rad = function (pos) {
+ return Math.atan2(pos.y - this.y, pos.x - this.x);
+ };
+
+ // degree of angle between line and the positive X axis
+ that.deg = function (pos) {
+ return this.rad(pos) / Math.PI * 180;
+ };
+
+ // returns position in css-compatible format
+ that.getAsCss = function() {
+ return {
+ left : this.x,
+ top : this.y
+ };
+ };
+ // return as string
+ that.toString = function() {
+ return (this.x + "," + this.y);
+ };
+ // return as array
+ that.toArray = function() {
+ return [this.x, this.y];
+ };
+ return that;
+ };
+
+ /*
+ * Line class (for on-screen geometry)
+ */
+ var line = function(p, q) {
+ var that = { // definition point
+ x : p.x,
+ y : p.y
+ };
+ if (q.x != null) { // second point
+ that.dx = q.x - that.x;
+ that.dy = q.y - that.y;
+ } else if ($.isArray(q)) { // vector
+ that.dx = q[0];
+ that.dy = q[1];
+ } else if (q === 0) { // slope
+ that.dx = 0;
+ that.dy = 1;
+ } else if (q === Infinity) {
+ that.dx = 1;
+ that.dy = 0;
+ } else if (q === -Infinity) {
+ that.dx = -1;
+ that.dy = 0;
+ } else if (typeof q === 'number' && isFinite(q)) {
+ that.dx = 1;
+ that.dy = 1/q;
+ } else {
+ that.dx = 1;
+ that.dy = 1;
+ }
+ // get/set origin of line
+ that.origin = function(p) {
+ if (p == null) {
+ return position(this.x, this.y);
+ }
+ this.x = p.x;
+ this.y = p.y;
+ return this;
+ };
+ // get/set vector
+ that.vector = function(vector) {
+ if (vector == null) {
+ return [this.dx, this.dy];
+ }
+ this.dx = vector[0];
+ this.dy = vector[1];
+ return this;
+ };
+ // return a vector with the contrary direction
+ that.invertedVector = function() {
+ return [-this.dx, -this.dy];
+ };
+ // return a vector that is perpendicular to this line
+ that.perpendicularVector = function(clockwise) {
+ return clockwise ? [-this.dy, this.dx] : [this.dy, -this.dx];
+ };
+ // return vector distance
+ that.dist = function() {
+ return Math.sqrt(this.dx * this.dx + this.dy * this.dy);
+ };
+ // multiply vector with a ratio
+ that.scale = function(ratio) {
+ this.dx *= ratio;
+ this.dy *= ratio
+ return this;
+ };
+ // get/set vector length
+ that.length = function(length) {
+ var dist = this.dist();
+ if (length == null) {
+ return dist;
+ }
+ return this.scale(length/dist);
+ };
+ // return the slope
+ that.slope = function() {
+ return this.dx/this.dy;
+ };
+ // return a copy of this line
+ that.copy = function() {
+ return line(position(this.x, this.y), this.vector());
+ };
+ // invert direction
+ that.invert = function() {
+ this.vector(this.invertedVector);
+ return this;
+ };
+ // return a parallel line through a point (with the same vector)
+ that.parallel = function(p) {
+ return line(position(p.x, p.y), this.vector());
+ };
+ // return a perpendicular line from the origin (optionally from another point) with direction
+ that.perpendicular = function(p, clockwise) {
+ var point = (p == null || p.x == null)
+ ? position(this.x, this.y) : p;
+ return line(point, this.perpendicularVector(clockwise));
+ };
+ // return the intersection with a perpendicular line through a point
+ that.perpendicularPoint = function(p) {
+ return this.intersection(this.perpendicular(p));
+ };
+ // return perpendicular line from point
+ that.perpendicularLine = function(p) {
+ return line(p, this.perpendicularPoint(p));
+ };
+ // return point in mirrored position (with regard to this line)
+ that.mirror = function(p) {
+ var line = this.perpendicularLine(p);
+ return line.addEnd(line.vector());
+ };
+ // return a position by adding a vector/position/distance to origin
+ that.add = function(item) {
+ if (item == null) {
+ return this.origin();
+ } else if ($.isArray(item)) { // add a vector
+ return position(this.x + item[0], this.y + item[1])
+ } else if (item.x != null) { // add a position
+ return position(this.x + item.x, this.y + item.y);
+ } else if (typeof item === 'number' && isFinite(item)) { // add a distance
+ ratio = item/this.dist();
+ return position(this.x + this.dx*ratio, this.y + this.dy*ratio);
+ } else {
+ return this.origin();
+ }
+ };
+ // return a position by adding a vector/position/distance to end point
+ that.addEnd = function(item) {
+ return this.add(item).add(this.vector());
+ };
+ // end point on the line (pointed to by vector)
+ that.point = function(factor) {
+ if (factor == null) { factor = 1; }
+ var vector = [factor*this.dx, factor*this.dy];
+ return this.add(vector);
+ };
+ // midpoint on the line (half of vector distance, multiplied by factor)
+ that.mid = function(factor) {
+ return this.origin().mid(this.point(factor));
+ };
+ // factor of point (assuming it is on the line)
+ that.factor = function(p) {
+ return (dx === 0)
+ ? (p.y - this.y)/this.dy
+ : (p.x - this.x)/this.dx;
+ };
+ // intersection point with other line
+ that.intersection = function(line) {
+ var denominator = this.dy*line.dx - this.dx*line.dy
+ if (denominator === 0) { // parallel
+ return null; }
+ var num = this.dx*(line.y - this.y) + this.dy*(this.x - line.x);
+ return line.point(num/denominator);
+ };
+ return that;
+ };
+
+ /*
+ * Rectangle class
+ */
+ var rectangle = function(x, y, w, h) {
+ var that = {};
+ if (typeof x === "object") {
+ if (x instanceof jQuery) {
+ // jQuery object
+ var pos = x.offset();
+ that = {
+ x : pos.left,
+ y : pos.top,
+ width : x.width(),
+ height : x.height()
+ };
+ } else if (y == null) {
+ // assume x is rectangle
+ that = {
+ x : parseFloat(x.x) || 0,
+ y : parseFloat(x.y) || 0,
+ width : parseFloat(x.width) || 0,
+ height : parseFloat(x.height) || 0
+ };
+ } else {
+ // assume x and y are Position
+ that = {
+ x : Math.min(x.x, y.x),
+ y : Math.min(x.y, y.y),
+ width : Math.abs(y.x - x.x),
+ height : Math.abs(y.y - x.y)
+ };
+ }
+ } else {
+ that = {
+ x : parseFloat(x),
+ y : parseFloat(y),
+ width : parseFloat(w),
+ height : parseFloat(h)
+ };
+ }
+ // returns a copy of this Rectangle
+ that.copy = function() {
+ return rectangle(this);
+ };
+ // returns the position of this Rectangle
+ that.getPosition = function() {
+ return position(this);
+ };
+ // returns the size of this Rectangle
+ that.getSize = function() {
+ return size(this);
+ };
+ // returns the upper left corner position
+ that.getPt1 = that.getPosition;
+ // returns the lower right corner position of this Rectangle
+ that.getPt2 = function() {
+ return position({
+ x : this.x + this.width,
+ y : this.y + this.height
+ });
+ };
+ // sets the upper left corner position to pos
+ that.setPosition = function(pos) {
+ this.x = pos.x;
+ this.y = pos.y;
+ return this;
+ };
+ // adds pos to the position
+ that.setPt1 = that.setPosition; // TODO: not really the same
+ that.addPosition = function(pos) {
+ this.x += pos.x;
+ this.y += pos.y;
+ return this;
+ };
+ // adds pos to the dimensions
+ that.enlarge = function(pos) {
+ this.width += pos.x;
+ this.height += pos.y;
+ return this;
+ };
+ // sets the lower right corner to position pos
+ that.setPt2 = function(pos) {
+ this.width = pos.x - this.x;
+ this.height = pos.y - this.y;
+ return this;
+ };
+ // returns the center position of this Rectangle
+ that.getCenter = function() {
+ return position({
+ x : this.x + this.width / 2,
+ y : this.y + this.height / 2
+ });
+ };
+ // moves this rectangle's center to position pos
+ that.setCenter = function(pos) {
+ this.x = pos.x - this.width / 2;
+ this.y = pos.y - this.height / 2;
+ return this;
+ };
+ // returns true if both rectangles have equal position and size
+ that.equals = function(other) {
+ var eq = (this.x === other.x && this.y === other.y && this.width === other.width);
+ return eq;
+ };
+ // returns a rectangle with the difference width, height and position
+ that.delta = function(other) {
+ return rectangle(other.x - this.x, other.y - this.y,
+ other.width - this.width, other.height - this.height);
+ };
+ // returns the area of this Rectangle
+ that.getArea = function() {
+ return (this.width * this.height);
+ };
+ // returns the aspect ratio of this Rectangle
+ that.getAspect = function() {
+ return (this.width / this.height);
+ };
+ // eliminates negative width and height
+ that.normalize = function() {
+ var p = this.getPt2();
+ this.x = Math.min(this.x, p.x);
+ this.y = Math.min(this.y, p.y);
+ this.width = Math.abs(this.width);
+ this.height = Math.abs(this.height);
+ return this;
+ };
+ // returns if Position "pos" lies inside of this rectangle
+ that.containsPosition = function(pos) {
+ var ct = ((pos.x >= this.x) && (pos.y >= this.y)
+ && (pos.x <= this.x + this.width) && (pos.y <= this.y
+ + this.height));
+ return ct;
+ };
+ // returns true if rectangle "rect" is contained in this rectangle
+ that.containsRect = function(rect) {
+ return (this.containsPosition(rect.getPt1()) && this
+ .containsPosition(rect.getPt2()));
+ };
+ // returns true if rectangle "rect" and this rectangle overlap
+ that.overlapsRect = function(rect) {
+ return this.intersect(rect) != null;
+ };
+ // returns the ratio of height to width
+ that.getProportion = function() {
+ return this.height/this.width;
+ };
+ // shrink/grow rectangle until it has the given proportion
+ that.setProportion = function(ratio, canGrow) {
+ var prop = this.getProportion();
+ if (ratio < prop == canGrow) {
+ this.width = this.height / ratio;
+ } else {
+ this.height = this.width * ratio;
+ }
+ return this;
+ };
+ // changes this rectangle's x/y values so it stays inside of rectangle
+ // "rect", keeping the proportions
+ that.stayInside = function(rect) {
+ this.x = Math.max(this.x, rect.x);
+ this.y = Math.max(this.y, rect.y);
+ if (this.x + this.width > rect.x + rect.width) {
+ this.x = rect.x + rect.width - this.width;
+ }
+ if (this.y + this.height > rect.y + rect.height) {
+ this.y = rect.y + rect.height - this.height;
+ }
+ return this;
+ };
+ // clips this rectangle so it stays inside of rectangle "rect"
+ that.clipTo = function(rect) {
+ var p1 = rect.getPt1();
+ var p2 = rect.getPt2();
+ var this2 = this.getPt2();
+ this.setPosition(position(Math.max(this.x, p1.x), Math.max(this.y, p1.y)));
+ this.setPt2(position(Math.min(this2.x, p2.x), Math.min(this2.y, p2.y)));
+ return this;
+ };
+ // returns the intersection of rectangle "rect" and this one
+ that.intersect = function(rect) {
+ var r = rect.copy();
+ var result = r.clipTo(this);
+ if (result.width < 0 || result.height < 0) result = null;
+ return result;
+ };
+
+ // returns a copy of rectangle "rect" that fits into this one
+ // (moving it first)
+ that.fit = function(rect) {
+ var r = rect.copy();
+ r.x = Math.max(r.x, this.x);
+ r.y = Math.max(r.y, this.x);
+ if (r.x + r.width > this.x + this.width) {
+ r.x = this.x + this.width - r.width;
+ }
+ if (r.y + r.height > this.y + this.height) {
+ r.y = this.y + this.height - r.height;
+ }
+ return r.intersect(this);
+ };
+
+ // adjusts position and size of jQuery element "$elem" to this rectangle
+ that.adjustDiv = function($elem) {
+ $elem.offset({
+ left : this.x,
+ top : this.y
+ });
+ $elem.width(this.width).height(this.height);
+ };
+ // returns position and size of this rectangle in css-compatible format
+ that.getAsCss = function() {
+ return {
+ left : this.x,
+ top : this.y,
+ width : this.width,
+ height : this.height
+ };
+ };
+ // returns position and size of this rectangle formatted for SVG attributes
+ that.getAsSvg = function() {
+ return [this.x, this.y, this.width, this.height].join(" ");
+ };
+ // returns if this rectangle is a rectangle
+ that.isRectangle = function () {
+ return this.width > 0 && this.height > 0;
+ };
+ // returns size and position of this rectangle formatted for ??? (w x h@x,y)
+ that.toString = function() {
+ return this.width + "x" + this.height + "@" + this.x + "," + this.y;
+ };
+ return that;
+ };
+
+ /*
+ * Transform class
+ *
+ * defines a class of affine transformations
+ */
+ var transform = function(spec) {
+ var that = {
+ m00 : 1.0,
+ m01 : 0.0,
+ m02 : 0.0,
+ m10 : 0.0,
+ m11 : 1.0,
+ m12 : 0.0,
+ m20 : 0.0,
+ m21 : 0.0,
+ m22 : 1.0
+ };
+ if (spec) {
+ jQuery.extend(that, spec);
+ }
+ ;
+ that.concat = function(trafA) {
+ // add Transform trafA to this Transform (i.e. this = trafC = trafA * this)
+ var trafC = {};
+ for ( var i = 0; i < 3; i++) {
+ for ( var j = 0; j < 3; j++) {
+ var c = 0.0;
+ for ( var k = 0; k < 3; k++) {
+ c += trafA["m" + i + k] * this["m" + k + j];
+ }
+ trafC["m" + i + j] = c;
+ }
+ }
+ jQuery.extend(this, trafC);
+ return this;
+ };
+ that.transform = function(rect) {
+ // returns transformed Rectangle or Position with this Transform
+ // applied
+ var x = this.m00 * rect.x + this.m01 * rect.y + this.m02;
+ var y = this.m10 * rect.x + this.m11 * rect.y + this.m12;
+ var pt = position(x, y);
+ if (rect.width != null) {
+ // transform the other corner point
+ var pt2 = this.transform(rect.getPt2());
+ return rectangle(pt, pt2);
+ }
+ return pt;
+ };
+ that.invtransform = function(rect) {
+ // returns transformed Rectangle or Position with the inverse of
+ // this Transform applied
+ var det = this.m00 * this.m11 - this.m01 * this.m10;
+ var x = (this.m11 * rect.x - this.m01 * rect.y - this.m11
+ * this.m02 + this.m01 * this.m12)
+ / det;
+ var y = (-this.m10 * rect.x + this.m00 * rect.y + this.m10
+ * this.m02 - this.m00 * this.m12)
+ / det;
+ var pt = position(x, y);
+ if (rect.width != null) {
+ // transform the other corner point
+ var pt2 = this.invtransform(rect.getPt2());
+ return rectangle(pt, pt2);
+ }
+ return pt;
+ };
+ that.toString = function(pretty) {
+ var s = '[';
+ if (pretty)
+ s += '\n';
+ for ( var i = 0; i < 3; ++i) {
+ s += '[';
+ for ( var j = 0; j < 3; ++j) {
+ if (j)
+ s += ',';
+ s += this['m' + i + j];
+ }
+ s += ']';
+ if (pretty)
+ s += '\n';
+ }
+ s += ']';
+ if (pretty)
+ s += '\n';
+ return s;
+ };
+ // add class methods to instance
+ that.getRotation = transform.getRotation;
+ that.getRotationAround = transform.getRotationAround;
+ that.getTranslation = transform.getTranslation;
+ that.getMirror = transform.getMirror;
+ that.getScale = transform.getScale;
+
+ return that;
+ };
+
+ transform.getRotation = function(angle) {
+ // returns a Transform that is a rotation by angle degrees around [0,0]
+ if (angle !== 0) {
+ var t = Math.PI * parseFloat(angle) / 180.0;
+ var cost = Math.cos(t);
+ var sint = Math.sin(t);
+ var traf = {
+ m00 : cost,
+ m01 : -sint,
+ m10 : sint,
+ m11 : cost
+ };
+ return transform(traf);
+ }
+ return transform();
+ };
+
+ transform.getRotationAround = function(angle, pos) {
+ // returns a Transform that is a rotation by angle degrees around pos
+ var traf = transform.getTranslation(pos.neg());
+ traf.concat(transform.getRotation(angle));
+ traf.concat(transform.getTranslation(pos));
+ return traf;
+ };
+
+ transform.getTranslation = function(pos) {
+ // returns a Transform that is a translation by [pos.x, pos,y]
+ var traf = {
+ m02 : pos.x,
+ m12 : pos.y
+ };
+ return transform(traf);
+ };
+
+ transform.getMirror = function(type) {
+ // returns a Transform that is a mirror about the axis type
+ if (type === 'x') {
+ var traf = {
+ m00 : 1,
+ m11 : -1
+ };
+ } else {
+ var traf = {
+ m00 : -1,
+ m11 : 1
+ };
+ }
+ return transform(traf);
+ };
+
+ transform.getScale = function(size) {
+ // returns a Transform that is a scale by [size.width, size.height]
+ var traf = {
+ m00 : size.width,
+ m11 : size.height
+ };
+ return transform(traf);
+ };
+
+ // export constructor functions to digilib plugin
+ var geometry = {
+ size : size,
+ position : position,
+ line : line,
+ rectangle : rectangle,
+ transform : transform
+ };
+
+ // install function called by digilib on plugin object
+ var install = function() {
+ // add constructor object to fn
+ this.fn.geometry = geometry;
+ };
+
+ // digilib plugin object
+ var plugin = {
+ name : 'geometry',
+ install : install,
+ fn : {},
+ };
+
+ // plug into digilib
+ if ($.fn.digicat == null) {
+ $.error("jquery.digicat.geometry must be loaded after jquery.digicat!");
+ } else {
+ $.fn.digicat('plugin', plugin);
+ }
+})(jQuery);
diff -r 684632a23c80 -r 49a5b1e73098 webapp/src/main/webapp/jquery/jquery.digicat.js
--- a/webapp/src/main/webapp/jquery/jquery.digicat.js Fri Feb 26 17:44:52 2016 +0100
+++ b/webapp/src/main/webapp/jquery/jquery.digicat.js Fri Feb 26 18:57:43 2016 +0100
@@ -50,17 +50,33 @@
'scalerBaseUrl' : null,
// prefix of digilib classes in CSS styles
'cssPrefix' : 'dl-',
- // Scaler parameter defaults
- 'pn' : 1,
+ // parameter defaults
+ 'pg' : 1,
+ 'rows' : 5,
+ 'cols' : 4,
+ // list of digicat parameters
+ 'digicatParamNames' : [ 'fn', 'pg', 'rows', 'cols' ],
// list of additional parameters (for page outside of digilib)
'additionalParamNames' : [],
// list of parameters to suppress when generating page URL
'suppressParamNames' : null,
// list of Scaler parameters
- 'scalerParamNames' : ['fn','pn','dw','dh','ww','wh','wx','wy','ws','mo',
- 'rot','cont','brgt','rgbm','rgba','ddpi','ddpix','ddpiy','colop'],
+ 'scalerParamNames' : ['fn', 'pn', 'dw', 'dh', 'ww', 'wh', 'wx', 'wy', 'ws', 'mo', 'rot', 'cont', 'brgt', 'rgbm', 'rgba',
+ 'ddpi', 'ddpix', 'ddpiy', 'colop'],
+ // list of digilib parameters
+ 'digilibParamNames' : ['fn','pn','ww','wh','wx','wy','ws','mo','rot','cont','brgt','rgbm','rgba','ddpi','colop','mk','clop'],
// reserved space in full page display (default value accounts for body margins)
- 'pageInsets' : { 'x' : 26, 'y': 20 }
+ 'pageInsets' : {
+ 'x' : 26,
+ 'y' : 20
+ },
+ // reserved space for each image
+ 'imageInsets' : {
+ 'x' : 4,
+ 'y' : 20
+ },
+ // TODO: do we need this?
+ 'interactionMode' : 'fullscreen'
};
// affine geometry plugin stub
@@ -82,7 +98,7 @@
init : function(options) {
// import geometry classes
if (plugins.geometry == null) {
- $.error("jquery.digilib.geometry plugin not found!");
+ $.error("jquery.digicat.geometry plugin not found!");
} else {
// geometry plugin puts classes in the shared fn
geom = fn.geometry;
@@ -95,7 +111,7 @@
queryParams = parseQueryParams();
// filter additional parameters
for ( var p in queryParams) {
- if ($.inArray(p, settings.digilibParamNames) < 0) {
+ if ($.inArray(p, settings.digicatParamNames) < 0) {
settings.additionalParamNames.push(p);
}
}
@@ -126,6 +142,10 @@
elemSettings = data.settings;
}
unpackParams(data);
+ // list of current insets (dynamic for buttons etc.)
+ data.currentInsets = {
+ 'static' : elemSettings.pageInsets
+ };
// check digilib base URL
if (elemSettings.digilibBaseUrl == null) {
// take current host
@@ -168,7 +188,41 @@
// send setup event
$(data).trigger('setup');
});
- }
+ },
+
+ /**
+ * goto given page nr (+/-: relative)
+ *
+ * @param data
+ * @param pageNr
+ * @returns {Boolean}
+ */
+ gotoPage : function(data, pageNr) {
+ var settings = data.settings;
+ var oldpg = settings.pg;
+ if (pageNr == null) {
+ pageNr = window.prompt("Goto page number", oldpg);
+ }
+ var pg = setNumValue(settings, "pg", pageNr);
+ if (pg == null)
+ return false; // nothing happened
+ if (pg < 1) {
+ alert("no such page (page number too low)");
+ settings.pg = oldpg;
+ return false;
+ }
+ // TODO: how do we get pt?
+ if (settings.pt != null) {
+ if (pg > settings.pt) {
+ alert("no such page (page number too high)");
+ settings.pg = oldpg;
+ return false;
+ }
+ }
+ // then reload
+ redisplay(data);
+ },
+
};
/**
@@ -218,13 +272,14 @@
// retrieveOptions(data);
};
- /** put objects back into parameters
+ /**
+ * put objects back into parameters
*
*/
- var packParams = function (data) {
+ var packParams = function(data) {
var settings = data.settings;
// store user interface options in cookie
- //storeOptions(data);
+ // storeOptions(data);
// trigger pack handlers
$(data).trigger('pack');
};
@@ -254,12 +309,12 @@
return geom.size(imgW, imgH);
};
- /**
- * return a query string from key names from a parameter hash
- * (ignores keys if the same value is in defaults)
+ /**
+ * return a query string from key names from a parameter hash (ignores keys
+ * if the same value is in defaults)
*
*/
- var getParamString = function (settings, keys, defaults) {
+ var getParamString = function(settings, keys, defaults) {
var paramString = '';
var nx = false;
for (var i = 0; i < keys.length; ++i) {
@@ -279,21 +334,103 @@
};
/**
+ * returns URL and query string for current digicat.
+ * if digilibPage != null returns URL to page in digilib installation with digilib parameters,
+ * otherwise using current URL and parameters.
+ *
+ */
+ var getDigicatUrl = function (data, digilibPage) {
+ packParams(data);
+ var settings = data.settings;
+ var paramList = settings.digicatParamNames;
+ if (digilibPage != null) {
+ var baseUrl = data.settings.digilibBaseUrl + digilibPage;
+ } else {
+ paramList = settings.additionalParamNames.concat(settings.digicatParamNames);
+ if (settings.suppressParamNames != null) {
+ // eliminate suppressed parameters from list
+ paramList = $.map(paramList, function(e, idx) {
+ if ($.inArray(e, settings.suppressParamNames) >= 0) {
+ return null;
+ } else {
+ return e;
+ }
+ });
+ }
+ // take url from current location
+ var baseUrl = window.location.href;
+ var pos = baseUrl.indexOf('?');
+ if (pos > -1) {
+ baseUrl = baseUrl.substring(0, pos);
+ }
+ }
+ var queryString = getParamString(settings, paramList, defaults);
+ return baseUrl + '?' + queryString;
+ };
+
+ /**
+ * returns URL and query string for current digilib.
+ * if digilibPage != null returns URL to page in digilib installation with digilib parameters,
+ * otherwise using current URL and parameters.
+ *
+ */
+ var getDigilibUrl = function (data, digilibPage) {
+ packParams(data);
+ var settings = data.settings;
+ var paramList = settings.digilibParamNames;
+ if (digilibPage != null) {
+ var baseUrl = data.settings.digilibBaseUrl + digilibPage;
+ } else {
+ paramList = settings.additionalParamNames.concat(settings.digilibParamNames);
+ if (settings.suppressParamNames != null) {
+ // eliminate suppressed parameters from list
+ paramList = $.map(paramList, function(e, idx) {
+ if ($.inArray(e, settings.suppressParamNames) >= 0) {
+ return null;
+ } else {
+ return e;
+ }
+ });
+ }
+ // take url from current location
+ var baseUrl = window.location.href;
+ var pos = baseUrl.indexOf('?');
+ if (pos > -1) {
+ baseUrl = baseUrl.substring(0, pos);
+ }
+ }
+ var queryString = getParamString(settings, paramList, defaults);
+ return baseUrl + '?' + queryString;
+ };
+
+ /**
* returns URL and query string for Scaler
*/
- var getScalerUrl = function (data) {
+ var getScalerUrl = function(data) {
packParams(data);
var settings = data.settings;
if (settings.scalerBaseUrl == null) {
alert("ERROR: URL of digilib Scaler servlet missing!");
- }
+ }
var keys = settings.scalerParamNames;
var queryString = getParamString(settings, keys, defaults);
var url = settings.scalerBaseUrl + '?' + queryString;
return url;
};
- var handleScalerImgError = function (data, evt, a, b) {
+ /**
+ * (re)load the page with the current settings.
+ *
+ */
+ var redisplay = function(data) {
+ var settings = data.settings;
+ // update location.href (browser URL) in fullscreen mode
+ var url = getDigicatUrl(data);
+ // reload window
+ window.location = url;
+ };
+
+ var handleScalerImgError = function(data, evt, a, b) {
console.error("error loading scaler image:", evt);
$(data).trigger('imgerror');
};
@@ -307,29 +444,39 @@
var cssPrefix = settings.cssPrefix;
$elem.addClass(cssPrefix + 'digicat');
var scalerUrl;
- var rows = 4;
- var cols = 5;
- var pn = 1;
+ var dlUrl;
+ var pg = settings.pg;
+ var rows = settings.rows;
+ var cols = settings.cols;
+ var pn = (pg - 1) * rows * cols + 1;
var tblSize = getFullscreenImgSize(data);
- tblSize.width -= settings.pageInsets.x;
- tblSize.height -= settings.pageInsets.y;
- settings.dw = Math.floor(tblSize.width / cols);
- settings.dh = Math.floor(tblSize.height / rows);
+ var tdw = Math.floor(tblSize.width / cols);
+ var tdh = Math.floor(tblSize.height / rows);
+ settings.dw = tdw - settings.imageInsets.x;
+ settings.dh = tdh - settings.imageInsets.y;
var $tbl = $('');
var $tr;
var $td;
+ var $link;
var $img;
- for (var ridx=0; ridx < rows; ++ridx) {
+ for (var ridx = 0; ridx < rows; ++ridx) {
$tr = $('|
');
- for (var cidx=0; cidx < cols; ++cidx) {
+ for (var cidx = 0; cidx < cols; ++cidx) {
$td = $('');
+ settings.pn = pn;
+ /*
+ * link
+ */
+ dlUrl = getDigilibUrl(data, '/digilib.html');
+ $link = $('');
/*
* scaler image
*/
$img = $('![]() ');
- $img.addClass(cssPrefix+'pic');
- $img.on('error', function (evt, a, b) { handleScalerImgError(data, evt, a, b); });
- settings.pn = pn;
+ $img.addClass(cssPrefix + 'pic');
+ $img.on('error', function(evt, a, b) {
+ handleScalerImgError(data, evt, a, b);
+ });
scalerUrl = getScalerUrl(data);
$img.attr('src', scalerUrl);
/*
@@ -340,21 +487,56 @@
/*
* assemble element
*/
- $td.append($img);
- $td.append($cap);
+ $td.css('width', tdw + 'px');
+ $td.css('height', tdh + 'px');
+ $link.append($img);
+ $link.append($cap);
+ $td.append($link);
$tr.append($td);
pn += 1;
}
$tbl.append($tr);
}
- // create new inner html, keeping buttons and content marked with "keep" class
- $elem.contents(':not(.'+cssPrefix+'keep)').remove();
+ // create new inner html, keeping buttons and content marked with class "keep"
+ $elem.contents(':not(.' + cssPrefix + 'keep)').remove();
// scaler should be the first child element?
$elem.prepend($tbl);
data.$tbl = $tbl;
};
/**
+ * sets a key to a value (relative values with +/- if relative=true).
+ *
+ */
+ var setNumValue = function(settings, key, value) {
+ if (value == null)
+ return null;
+ if (isNumber(value)) {
+ settings[key] = value;
+ return value;
+ }
+ var sign = value[0];
+ if (sign === '+' || sign === '-') {
+ if (settings[key] == null) {
+ // this isn't perfect but still...
+ settings[key] = 0;
+ }
+ settings[key] = parseFloat(settings[key]) + parseFloat(value);
+ } else {
+ settings[key] = value;
+ }
+ return settings[key];
+ };
+
+ /**
+ * return if the argument is a number. from Douglas Crockford, A.10. this is
+ * different from $.isNumeric().
+ */
+ var isNumber = function(value) {
+ return typeof value === 'number' && isFinite(value);
+ };
+
+ /**
* functions to export to plugins.
*/
fn = {
diff -r 684632a23c80 -r 49a5b1e73098 webapp/src/main/webapp/jquery/jquery.digilib.geometry.js
--- a/webapp/src/main/webapp/jquery/jquery.digilib.geometry.js Fri Feb 26 17:44:52 2016 +0100
+++ b/webapp/src/main/webapp/jquery/jquery.digilib.geometry.js Fri Feb 26 18:57:43 2016 +0100
@@ -804,12 +804,7 @@
// plug into digilib
if ($.fn.digilib == null) {
- if ($.fn.digicat == null) {
- $.error("jquery.digilib.geometry must be loaded after jquery.digilib!");
- } else {
- // plug into digicat (somewhat ugly)
- $.fn.digicat('plugin', plugin);
- }
+ $.error("jquery.digilib.geometry must be loaded after jquery.digilib!");
} else {
$.fn.digilib('plugin', plugin);
}
| 
+