Aid:Jquery.imagemapster.js
From CODECS: Online Database and e-Resources for Celtic Studies
/* ImageMapster
Version: 1.2.10 (2/25/2013)
Copyright 2011-2012 James Treworgy
http://www.outsharked.com/imagemapster
https://github.com/jamietre/ImageMapster
A jQuery plugin to enhance image maps.
*/
;
/// LICENSE (MIT License)
///
/// Permission is hereby granted, free of charge, to any person obtaining
/// a copy of this software and associated documentation files (the
/// "Software"), to deal in the Software without restriction, including
/// without limitation the rights to use, copy, modify, merge, publish,
/// distribute, sublicense, and/or sell copies of the Software, and to
/// permit persons to whom the Software is furnished to do so, subject to
/// the following conditions:
///
/// The above copyright notice and this permission notice shall be
/// included in all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
/// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
/// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
/// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
/// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
/// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
/// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
///
/// January 19, 2011
/** @license MIT License (c) copyright B Cavalier & J Hann */
/**
* when
* A lightweight CommonJS Promises/A and when() implementation
*
* when is part of the cujo.js family of libraries (http://cujojs.com/)
*
* Licensed under the MIT License at:
* http://www.opensource.org/licenses/mit-license.php
*
* @version 1.2.0
*/
/*lint-ignore-start*/
(function (define) {
define(function () {
var freeze, reduceArray, slice, undef;
//
// Public API
//
when.defer = defer;
when.reject = reject;
when.isPromise = isPromise;
when.all = all;
when.some = some;
when.any = any;
when.map = map;
when.reduce = reduce;
when.chain = chain;
/** Object.freeze */
freeze = Object.freeze || function (o) { return o; };
/**
* Trusted Promise constructor. A Promise created from this constructor is
* a trusted when.js promise. Any other duck-typed promise is considered
* untrusted.
*
* @constructor
*/
function Promise() { }
Promise.prototype = freeze({
always: function (alwaysback, progback) {
return this.then(alwaysback, alwaysback, progback);
},
otherwise: function (errback) {
return this.then(undef, errback);
}
});
/**
* Create an already-resolved promise for the supplied value
* @private
*
* @param value anything
* @return {Promise}
*/
function resolved(value) {
var p = new Promise();
p.then = function (callback) {
var nextValue;
try {
if (callback) nextValue = callback(value);
return promise(nextValue === undef ? value : nextValue);
} catch (e) {
return rejected(e);
}
};
return freeze(p);
}
/**
* Create an already-rejected {@link Promise} with the supplied
* rejection reason.
* @private
*
* @param reason rejection reason
* @return {Promise}
*/
function rejected(reason) {
var p = new Promise();
p.then = function (callback, errback) {
var nextValue;
try {
if (errback) {
nextValue = errback(reason);
return promise(nextValue === undef ? reason : nextValue)
}
return rejected(reason);
} catch (e) {
return rejected(e);
}
};
return freeze(p);
}
/**
* Returns a rejected promise for the supplied promiseOrValue. If
* promiseOrValue is a value, it will be the rejection value of the
* returned promise. If promiseOrValue is a promise, its
* completion value will be the rejected value of the returned promise
*
* @param promiseOrValue {*} the rejected value of the returned {@link Promise}
*
* @return {Promise} rejected {@link Promise}
*/
function reject(promiseOrValue) {
return when(promiseOrValue, function (value) {
return rejected(value);
});
}
/**
* Creates a new, CommonJS compliant, Deferred with fully isolated
* resolver and promise parts, either or both of which may be given out
* safely to consumers.
* The Deferred itself has the full API: resolve, reject, progress, and
* then. The resolver has resolve, reject, and progress. The promise
* only has then.
*
* @memberOf when
* @function
*
* @returns {Deferred}
*/
function defer() {
var deferred, promise, listeners, progressHandlers, _then, _progress, complete;
listeners = [];
progressHandlers = [];
/**
* Pre-resolution then() that adds the supplied callback, errback, and progback
* functions to the registered listeners
*
* @private
*
* @param [callback] {Function} resolution handler
* @param [errback] {Function} rejection handler
* @param [progback] {Function} progress handler
*
* @throws {Error} if any argument is not null, undefined, or a Function
*/
_then = function unresolvedThen(callback, errback, progback) {
var deferred = defer();
listeners.push(function (promise) {
promise.then(callback, errback)
.then(deferred.resolve, deferred.reject, deferred.progress);
});
progback && progressHandlers.push(progback);
return deferred.promise;
};
/**
* Registers a handler for this {@link Deferred}'s {@link Promise}. Even though all arguments
* are optional, each argument that *is* supplied must be null, undefined, or a Function.
* Any other value will cause an Error to be thrown.
*
* @memberOf Promise
*
* @param [callback] {Function} resolution handler
* @param [errback] {Function} rejection handler
* @param [progback] {Function} progress handler
*
* @throws {Error} if any argument is not null, undefined, or a Function
*/
function then(callback, errback, progback) {
return _then(callback, errback, progback);
}
/**
* Resolves this {@link Deferred}'s {@link Promise} with val as the
* resolution value.
*
* @memberOf Resolver
*
* @param val anything
*/
function resolve(val) {
complete(resolved(val));
}
/**
* Rejects this {@link Deferred}'s {@link Promise} with err as the
* reason.
*
* @memberOf Resolver
*
* @param err anything
*/
function reject(err) {
complete(rejected(err));
}
/**
* @private
* @param update
*/
_progress = function (update) {
var progress, i = 0;
while (progress = progressHandlers[i++]) progress(update);
};
/**
* Emits a progress update to all progress observers registered with
* this {@link Deferred}'s {@link Promise}
*
* @memberOf Resolver
*
* @param update anything
*/
function progress(update) {
_progress(update);
}
/**
* Transition from pre-resolution state to post-resolution state, notifying
* all listeners of the resolution or rejection
*
* @private
*
* @param completed {Promise} the completed value of this deferred
*/
complete = function (completed) {
var listener, i = 0;
// Replace _then with one that directly notifies with the result.
_then = completed.then;
// Replace complete so that this Deferred can only be completed
// once. Also Replace _progress, so that subsequent attempts to issue
// progress throw.
complete = _progress = function alreadyCompleted() {
// TODO: Consider silently returning here so that parties who
// have a reference to the resolver cannot tell that the promise
// has been resolved using try/catch
throw new Error("already completed");
};
// Free progressHandlers array since we'll never issue progress events
// for this promise again now that it's completed
progressHandlers = undef;
// Notify listeners
// Traverse all listeners registered directly with this Deferred
while (listener = listeners[i++]) {
listener(completed);
}
listeners = [];
};
/**
* The full Deferred object, with both {@link Promise} and {@link Resolver}
* parts
* @class Deferred
* @name Deferred
*/
deferred = {};
// Promise and Resolver parts
// Freeze Promise and Resolver APIs
promise = new Promise();
promise.then = deferred.then = then;
/**
* The {@link Promise} for this {@link Deferred}
* @memberOf Deferred
* @name promise
* @type {Promise}
*/
deferred.promise = freeze(promise);
/**
* The {@link Resolver} for this {@link Deferred}
* @memberOf Deferred
* @name resolver
* @class Resolver
*/
deferred.resolver = freeze({
resolve: (deferred.resolve = resolve),
reject: (deferred.reject = reject),
progress: (deferred.progress = progress)
});
return deferred;
}
/**
* Determines if promiseOrValue is a promise or not. Uses the feature
* test from http://wiki.commonjs.org/wiki/Promises/A to determine if
* promiseOrValue is a promise.
*
* @param promiseOrValue anything
*
* @returns {Boolean} true if promiseOrValue is a {@link Promise}
*/
function isPromise(promiseOrValue) {
return promiseOrValue && typeof promiseOrValue.then === 'function';
}
/**
* Register an observer for a promise or immediate value.
*
* @function
* @name when
* @namespace
*
* @param promiseOrValue anything
* @param {Function} [callback] callback to be called when promiseOrValue is
* successfully resolved. If promiseOrValue is an immediate value, callback
* will be invoked immediately.
* @param {Function} [errback] callback to be called when promiseOrValue is
* rejected.
* @param {Function} [progressHandler] callback to be called when progress updates
* are issued for promiseOrValue.
*
* @returns {Promise} a new {@link Promise} that will complete with the return
* value of callback or errback or the completion value of promiseOrValue if
* callback and/or errback is not supplied.
*/
function when(promiseOrValue, callback, errback, progressHandler) {
// Get a promise for the input promiseOrValue
// See promise()
var trustedPromise = promise(promiseOrValue);
// Register promise handlers
return trustedPromise.then(callback, errback, progressHandler);
}
/**
* Returns promiseOrValue if promiseOrValue is a {@link Promise}, a new Promise if
* promiseOrValue is a foreign promise, or a new, already-resolved {@link Promise}
* whose resolution value is promiseOrValue if promiseOrValue is an immediate value.
*
* Note that this function is not safe to export since it will return its
* input when promiseOrValue is a {@link Promise}
*
* @private
*
* @param promiseOrValue anything
*
* @returns Guaranteed to return a trusted Promise. If promiseOrValue is a when.js {@link Promise}
* returns promiseOrValue, otherwise, returns a new, already-resolved, when.js {@link Promise}
* whose resolution value is:
* * the resolution value of promiseOrValue if it's a foreign promise, or
* * promiseOrValue if it's a value
*/
function promise(promiseOrValue) {
var promise, deferred;
if (promiseOrValue instanceof Promise) {
// It's a when.js promise, so we trust it
promise = promiseOrValue;
} else {
// It's not a when.js promise. Check to see if it's a foreign promise
// or a value.
deferred = defer();
if (isPromise(promiseOrValue)) {
// It's a compliant promise, but we don't know where it came from,
// so we don't trust its implementation entirely. Introduce a trusted
// middleman when.js promise
// IMPORTANT: This is the only place when.js should ever call .then() on
// an untrusted promise.
promiseOrValue.then(deferred.resolve, deferred.reject, deferred.progress);
promise = deferred.promise;
} else {
// It's a value, not a promise. Create an already-resolved promise
// for it.
deferred.resolve(promiseOrValue);
promise = deferred.promise;
}
}
return promise;
}
/**
* Return a promise that will resolve when howMany of the supplied promisesOrValues
* have resolved. The resolution value of the returned promise will be an array of
* length howMany containing the resolutions values of the triggering promisesOrValues.
*
* @memberOf when
*
* @param promisesOrValues {Array} array of anything, may contain a mix
* of {@link Promise}s and values
* @param howMany
* @param [callback]
* @param [errback]
* @param [progressHandler]
*
* @returns {Promise}
*/
function some(promisesOrValues, howMany, callback, errback, progressHandler) {
checkCallbacks(2, arguments);
return when(promisesOrValues, function (promisesOrValues) {
var toResolve, results, ret, deferred, resolver, rejecter, handleProgress, len, i;
len = promisesOrValues.length >>> 0;
toResolve = Math.max(0, Math.min(howMany, len));
results = [];
deferred = defer();
ret = when(deferred, callback, errback, progressHandler);
// Wrapper so that resolver can be replaced
function resolve(val) {
resolver(val);
}
// Wrapper so that rejecter can be replaced
function reject(err) {
rejecter(err);
}
// Wrapper so that progress can be replaced
function progress(update) {
handleProgress(update);
}
function complete() {
resolver = rejecter = handleProgress = noop;
}
// No items in the input, resolve immediately
if (!toResolve) {
deferred.resolve(results);
} else {
// Resolver for promises. Captures the value and resolves
// the returned promise when toResolve reaches zero.
// Overwrites resolver var with a noop once promise has
// be resolved to cover case where n < promises.length
resolver = function (val) {
// This orders the values based on promise resolution order
// Another strategy would be to use the original position of
// the corresponding promise.
results.push(val);
if (! --toResolve) {
complete();
deferred.resolve(results);
}
};
// Rejecter for promises. Rejects returned promise
// immediately, and overwrites rejecter var with a noop
// once promise to cover case where n < promises.length.
// TODO: Consider rejecting only when N (or promises.length - N?)
// promises have been rejected instead of only one?
rejecter = function (err) {
complete();
deferred.reject(err);
};
handleProgress = deferred.progress;
// TODO: Replace while with forEach
for (i = 0; i < len; ++i) {
if (i in promisesOrValues) {
when(promisesOrValues[i], resolve, reject, progress);
}
}
}
return ret;
});
}
/**
* Return a promise that will resolve only once all the supplied promisesOrValues
* have resolved. The resolution value of the returned promise will be an array
* containing the resolution values of each of the promisesOrValues.
*
* @memberOf when
*
* @param promisesOrValues {Array|Promise} array of anything, may contain a mix
* of {@link Promise}s and values
* @param [callback] {Function}
* @param [errback] {Function}
* @param [progressHandler] {Function}
*
* @returns {Promise}
*/
function all(promisesOrValues, callback, errback, progressHandler) {
checkCallbacks(1, arguments);
return when(promisesOrValues, function (promisesOrValues) {
return _reduce(promisesOrValues, reduceIntoArray, []);
}).then(callback, errback, progressHandler);
}
function reduceIntoArray(current, val, i) {
current[i] = val;
return current;
}
/**
* Return a promise that will resolve when any one of the supplied promisesOrValues
* has resolved. The resolution value of the returned promise will be the resolution
* value of the triggering promiseOrValue.
*
* @memberOf when
*
* @param promisesOrValues {Array|Promise} array of anything, may contain a mix
* of {@link Promise}s and values
* @param [callback] {Function}
* @param [errback] {Function}
* @param [progressHandler] {Function}
*
* @returns {Promise}
*/
function any(promisesOrValues, callback, errback, progressHandler) {
function unwrapSingleResult(val) {
return callback ? callback(val[0]) : val[0];
}
return some(promisesOrValues, 1, unwrapSingleResult, errback, progressHandler);
}
/**
* Traditional map function, similar to `Array.prototype.map()`, but allows
* input to contain {@link Promise}s and/or values, and mapFunc may return
* either a value or a {@link Promise}
*
* @memberOf when
*
* @param promise {Array|Promise} array of anything, may contain a mix
* of {@link Promise}s and values
* @param mapFunc {Function} mapping function mapFunc(value) which may return
* either a {@link Promise} or value
*
* @returns {Promise} a {@link Promise} that will resolve to an array containing
* the mapped output values.
*/
function map(promise, mapFunc) {
return when(promise, function (array) {
return _map(array, mapFunc);
});
}
/**
* Private map helper to map an array of promises
* @private
*
* @param promisesOrValues {Array}
* @param mapFunc {Function}
* @return {Promise}
*/
function _map(promisesOrValues, mapFunc) {
var results, len, i;
// Since we know the resulting length, we can preallocate the results
// array to avoid array expansions.
len = promisesOrValues.length >>> 0;
results = new Array(len);
// Since mapFunc may be async, get all invocations of it into flight
// asap, and then use reduce() to collect all the results
for (i = 0; i < len; i++) {
if (i in promisesOrValues)
results[i] = when(promisesOrValues[i], mapFunc);
}
// Could use all() here, but that would result in another array
// being allocated, i.e. map() would end up allocating 2 arrays
// of size len instead of just 1. Since all() uses reduce()
// anyway, avoid the additional allocation by calling reduce
// directly.
return _reduce(results, reduceIntoArray, results);
}
/**
* Traditional reduce function, similar to `Array.prototype.reduce()`, but
* input may contain {@link Promise}s and/or values, and reduceFunc
* may return either a value or a {@link Promise}, *and* initialValue may
* be a {@link Promise} for the starting value.
*
* @memberOf when
*
* @param promise {Array|Promise} array of anything, may contain a mix
* of {@link Promise}s and values. May also be a {@link Promise} for
* an array.
* @param reduceFunc {Function} reduce function reduce(currentValue, nextValue, index, total),
* where total is the total number of items being reduced, and will be the same
* in each call to reduceFunc.
* @param initialValue starting value, or a {@link Promise} for the starting value
*
* @returns {Promise} that will resolve to the final reduced value
*/
function reduce(promise, reduceFunc, initialValue) {
var args = slice.call(arguments, 1);
return when(promise, function (array) {
return _reduce.apply(undef, [array].concat(args));
});
}
/**
* Private reduce to reduce an array of promises
* @private
*
* @param promisesOrValues {Array}
* @param reduceFunc {Function}
* @param initialValue {*}
* @return {Promise}
*/
function _reduce(promisesOrValues, reduceFunc, initialValue) {
var total, args;
total = promisesOrValues.length;
// Skip promisesOrValues, since it will be used as 'this' in the call
// to the actual reduce engine below.
// Wrap the supplied reduceFunc with one that handles promises and then
// delegates to the supplied.
args = [
function (current, val, i) {
return when(current, function (c) {
return when(val, function (value) {
return reduceFunc(c, value, i, total);
});
});
}
];
if (arguments.length > 2) args.push(initialValue);
return reduceArray.apply(promisesOrValues, args);
}
/**
* Ensure that resolution of promiseOrValue will complete resolver with the completion
* value of promiseOrValue, or instead with resolveValue if it is provided.
*
* @memberOf when
*
* @param promiseOrValue
* @param resolver {Resolver}
* @param [resolveValue] anything
*
* @returns {Promise}
*/
function chain(promiseOrValue, resolver, resolveValue) {
var useResolveValue = arguments.length > 2;
return when(promiseOrValue,
function (val) {
if (useResolveValue) val = resolveValue;
resolver.resolve(val);
return val;
},
function (e) {
resolver.reject(e);
return rejected(e);
},
resolver.progress
);
}
//
// Utility functions
//
/**
* Helper that checks arrayOfCallbacks to ensure that each element is either
* a function, or null or undefined.
*
* @private
*
* @param arrayOfCallbacks {Array} array to check
* @throws {Error} if any element of arrayOfCallbacks is something other than
* a Functions, null, or undefined.
*/
function checkCallbacks(start, arrayOfCallbacks) {
var arg, i = arrayOfCallbacks.length;
while (i > start) {
arg = arrayOfCallbacks[--i];
if (arg != null && typeof arg != 'function') throw new Error('callback is not a function');
}
}
/**
* No-Op function used in method replacement
* @private
*/
function noop() { }
slice = [].slice;
// ES5 reduce implementation if native not available
// See: http://es5.github.com/#x15.4.4.21 as there are many
// specifics and edge cases.
reduceArray = [].reduce ||
function (reduceFunc /*, initialValue */) {
// ES5 dictates that reduce.length === 1
// This implementation deviates from ES5 spec in the following ways:
// 1. It does not check if reduceFunc is a Callable
var arr, args, reduced, len, i;
i = 0;
arr = Object(this);
len = arr.length >>> 0;
args = arguments;
// If no initialValue, use first item of array (we know length !== 0 here)
// and adjust i to start at second item
if (args.length <= 1) {
// Skip to the first real element in the array
for (; ;) {
if (i in arr) {
reduced = arr[i++];
break;
}
// If we reached the end of the array without finding any real
// elements, it's a TypeError
if (++i >= len) {
throw new TypeError();
}
}
} else {
// If initialValue provided, use it
reduced = args[1];
}
// Do the actual reduce
for (; i < len; ++i) {
// Skip holes
if (i in arr)
reduced = reduceFunc(reduced, arr[i], i, arr);
}
return reduced;
};
return when;
});
})(typeof define == 'function'
? define
: function (factory) {
typeof module != 'undefined'
? (module.exports = factory())
: (jQuery.mapster_when = factory());
}
// Boilerplate for AMD, Node, and browser global
);
/*lint-ignore-end*/
/* ImageMapster core */
/*jslint laxbreak: true, evil: true, unparam: true */
/*global jQuery: true, Zepto: true */
(function ($) {
// all public functions in $.mapster.impl are methods
$.fn.mapster = function (method) {
var m = $.mapster.impl;
if ($.isFunction(m[method])) {
return m[method].apply(this, Array.prototype.slice.call(arguments, 1));
} else if (typeof method === 'object' || !method) {
return m.bind.apply(this, arguments);
} else {
$.error('Method ' + method + ' does not exist on jQuery.mapster');
}
};
$.mapster = {
version: "1.2.10",
render_defaults: {
isSelectable: true,
isDeselectable: true,
fade: false,
fadeDuration: 150,
fill: true,
fillColor: '000000',
fillColorMask: 'FFFFFF',
fillOpacity: 0.7,
highlight: true,
stroke: false,
strokeColor: 'ff0000',
strokeOpacity: 1,
strokeWidth: 1,
includeKeys: '',
altImage: null,
altImageId: null, // used internally
altImages: {}
},
defaults: {
clickNavigate: false,
wrapClass: null,
wrapCss: null,
onGetList: null,
sortList: false,
listenToList: false,
mapKey: '',
mapValue: '',
singleSelect: false,
listKey: 'value',
listSelectedAttribute: 'selected',
listSelectedClass: null,
onClick: null,
onMouseover: null,
onMouseout: null,
mouseoutDelay: 0,
onStateChange: null,
boundList: null,
onConfigured: null,
configTimeout: 30000,
noHrefIsMask: true,
scaleMap: true,
safeLoad: false,
areas: []
},
shared_defaults: {
render_highlight: { fade: true },
render_select: { fade: false },
staticState: null,
selected: null
},
area_defaults:
{
includeKeys: '',
isMask: false
},
canvas_style: {
position: 'absolute',
left: 0,
top: 0,
padding: 0,
border: 0
},
hasCanvas: null,
isTouch: null,
map_cache: [],
hooks: {},
addHook: function (name, callback) {
this.hooks[name] = (this.hooks[name] || []).push(callback);
},
callHooks: function (name, context) {
$.each(this.hooks[name] || [], function (i, e) {
e.apply(context);
});
},
utils: {
when: $.mapster_when,
defer: $.mapster_when.defer,
// extends the constructor, returns a new object prototype. Does not refer to the
// original constructor so is protected if the original object is altered. This way you
// can "extend" an object by replacing it with its subclass.
subclass: function (BaseClass, constr) {
var Subclass = function () {
var me = this,
args = Array.prototype.slice.call(arguments, 0);
me.base = BaseClass.prototype;
me.base.init = function () {
BaseClass.prototype.constructor.apply(me, args);
};
constr.apply(me, args);
};
Subclass.prototype = new BaseClass();
Subclass.prototype.constructor = Subclass;
return Subclass;
},
asArray: function (obj) {
return obj.constructor === Array ?
obj : this.split(obj);
},
// clean split: no padding or empty elements
split: function (text, cb) {
var i, el, arr = text.split(',');
for (i = 0; i < arr.length; i++) {
el = $.trim(arr[i]);
if (el === '') {
arr.splice(i, 1);
} else {
arr[i] = cb ? cb(el) : el;
}
}
return arr;
},
// similar to $.extend but does not add properties (only updates), unless the
// first argument is an empty object, then all properties will be copied
updateProps: function (_target, _template) {
var onlyProps,
target = _target || {},
template = $.isEmptyObject(target) ? _template : _target;
//if (template) {
onlyProps = [];
$.each(template, function (prop) {
onlyProps.push(prop);
});
//}
$.each(Array.prototype.slice.call(arguments, 1), function (i, src) {
$.each(src || {}, function (prop) {
if (!onlyProps || $.inArray(prop, onlyProps) >= 0) {
var p = src[prop];
if ($.isPlainObject(p)) {
// not recursive - only copies 1 level of subobjects, and always merges
target[prop] = $.extend(target[prop] || {}, p);
} else if (p && p.constructor === Array) {
target[prop] = p.slice(0);
} else if (typeof p !== 'undefined') {
target[prop] = src[prop];
}
}
});
});
return target;
},
isElement: function (o) {
return (typeof HTMLElement === "object" ? o instanceof HTMLElement :
o && typeof o === "object" && o.nodeType === 1 && typeof o.nodeName === "string");
},
// finds element of array or object with a property "prop" having value "val"
// if prop is not defined, then just looks for property with value "val"
indexOfProp: function (obj, prop, val) {
var result = obj.constructor === Array ? -1 : null;
$.each(obj, function (i, e) {
if (e && (prop ? e[prop] : e) === val) {
result = i;
return false;
}
});
return result;
},
// returns "obj" if true or false, or "def" if not true/false
boolOrDefault: function (obj, def) {
return this.isBool(obj) ?
obj : def || false;
},
isBool: function (obj) {
return typeof obj === "boolean";
},
isUndef: function (obj) {
return typeof obj === "undefined";
},
// evaluates "obj", if function, calls it with args
// (todo - update this to handle variable lenght/more than one arg)
ifFunction: function (obj, that, args) {
if ($.isFunction(obj)) {
obj.call(that, args);
}
},
size: function (image, raw) {
var u = $.mapster.utils;
return {
width: raw ? (image.width || image.naturalWidth) : u.imgWidth(image, true),
height: raw ? (image.height || image.naturalHeight) : u.imgHeight(image, true),
complete: function () { return !!this.height && !!this.width; }
};
},
/**
* Set the opacity of the element. This is an IE<8 specific function for handling VML.
* When using VML we must override the "setOpacity" utility function (monkey patch ourselves).
* jQuery does not deal with opacity correctly for VML elements. This deals with that.
*
* @param {Element} el The DOM element
* @param {double} opacity A value between 0 and 1 inclusive.
*/
setOpacity: function (el, opacity) {
if ($.mapster.hasCanvas()) {
el.style.opacity = opacity;
} else {
$(el).each(function (i, e) {
if (typeof e.opacity !== 'undefined') {
e.opacity = opacity;
} else {
$(e).css("opacity", opacity);
}
});
}
},
// fade "el" from opacity "op" to "endOp" over a period of time "duration"
fader: (function () {
var elements = {},
lastKey = 0,
fade_func = function (el, op, endOp, duration) {
var index,
cbIntervals = duration / 15,
obj, u = $.mapster.utils;
if (typeof el === 'number') {
obj = elements[el];
if (!obj) {
return;
}
} else {
index = u.indexOfProp(elements, null, el);
if (index) {
delete elements[index];
}
elements[++lastKey] = obj = el;
el = lastKey;
}
endOp = endOp || 1;
op = (op + (endOp / cbIntervals) > endOp - 0.01) ? endOp : op + (endOp / cbIntervals);
u.setOpacity(obj, op);
if (op < endOp) {
setTimeout(function () {
fade_func(el, op, endOp, duration);
}, 15);
}
};
return fade_func;
}())
},
getBoundList: function (opts, key_list) {
if (!opts.boundList) {
return null;
}
var index, key, result = $(), list = $.mapster.utils.split(key_list);
opts.boundList.each(function (i, e) {
for (index = 0; index < list.length; index++) {
key = list[index];
if ($(e).is('[' + opts.listKey + '="' + key + '"]')) {
result = result.add(e);
}
}
});
return result;
},
// Causes changes to the bound list based on the user action (select or deselect)
// area: the jQuery area object
// returns the matching elements from the bound list for the first area passed (normally only one should be passed, but
// a list can be passed
setBoundListProperties: function (opts, target, selected) {
target.each(function (i, e) {
if (opts.listSelectedClass) {
if (selected) {
$(e).addClass(opts.listSelectedClass);
} else {
$(e).removeClass(opts.listSelectedClass);
}
}
if (opts.listSelectedAttribute) {
$(e).attr(opts.listSelectedAttribute, selected);
}
});
},
getMapDataIndex: function (obj) {
var img, id;
switch (obj.tagName && obj.tagName.toLowerCase()) {
case 'area':
id = $(obj).parent().attr('name');
img = $("img[usemap='#" + id + "']")[0];
break;
case 'img':
img = obj;
break;
}
return img ?
this.utils.indexOfProp(this.map_cache, 'image', img) : -1;
},
getMapData: function (obj) {
var index = this.getMapDataIndex(obj.length ? obj[0] : obj);
if (index >= 0) {
return index >= 0 ? this.map_cache[index] : null;
}
},
/**
* Queue a command to be run after the active async operation has finished
* @param {MapData} map_data The target MapData object
* @param {jQuery} that jQuery object on which the command was invoked
* @param {string} command the ImageMapster method name
* @param {object[]} args arguments passed to the method
* @return {bool} true if the command was queued, false if not (e.g. there was no need to)
*/
queueCommand: function (map_data, that, command, args) {
if (!map_data) {
return false;
}
if (!map_data.complete || map_data.currentAction) {
map_data.commands.push(
{
that: that,
command: command,
args: args
});
return true;
}
return false;
},
unload: function () {
this.impl.unload();
this.utils = null;
this.impl = null;
$.fn.mapster = null;
$.mapster = null;
$('*').unbind();
}
};
// Config for object prototypes
// first: use only first object (for things that should not apply to lists)
/// calls back one of two fuinctions, depending on whether an area was obtained.
// opts: {
// name: 'method name',
// key: 'key,
// args: 'args'
//
//}
// name: name of method (required)
// args: arguments to re-call with
// Iterates through all the objects passed, and determines whether it's an area or an image, and calls the appropriate
// callback for each. If anything is returned from that callback, the process is stopped and that data return. Otherwise,
// the object itself is returned.
var m = $.mapster,
u = m.utils,
ap = Array.prototype;
// jQuery's width() and height() are broken on IE9 in some situations. This tries everything.
$.each(["width", "height"], function (i, e) {
var capProp = e.substr(0, 1).toUpperCase() + e.substr(1);
// when jqwidth parm is passed, it also checks the jQuery width()/height() property
// the issue is that jQUery width() can report a valid size before the image is loaded in some browsers
// without it, we can read zero even when image is loaded in other browsers if its not visible
// we must still check because stuff like adblock can temporarily block it
// what a goddamn headache
u["img" + capProp] = function (img, jqwidth) {
return (jqwidth ? $(img)[e]() : 0) ||
img[e] || img["natural" + capProp] || img["client" + capProp] || img["offset" + capProp];
};
});
/**
* The Method object encapsulates the process of testing an ImageMapster method to see if it's being
* invoked on an image, or an area; then queues the command if the MapData is in an active state.
*
* @param {[jQuery]} that The target of the invocation
* @param {[function]} func_map The callback if the target is an imagemap
* @param {[function]} func_area The callback if the target is an area
* @param {[object]} opt Options: { key: a map key if passed explicitly
* name: the command name, if it can be queued,
* args: arguments to the method
* }
*/
m.Method = function (that, func_map, func_area, opts) {
var me = this;
me.name = opts.name;
me.output = that;
me.input = that;
me.first = opts.first || false;
me.args = opts.args ? ap.slice.call(opts.args, 0) : [];
me.key = opts.key;
me.func_map = func_map;
me.func_area = func_area;
//$.extend(me, opts);
me.name = opts.name;
me.allowAsync = opts.allowAsync || false;
};
m.Method.prototype = {
constructor: m.Method,
go: function () {
var i, data, ar, len, result, src = this.input,
area_list = [],
me = this;
len = src.length;
for (i = 0; i < len; i++) {
data = $.mapster.getMapData(src[i]);
if (data) {
if (!me.allowAsync && m.queueCommand(data, me.input, me.name, me.args)) {
if (this.first) {
result = '';
}
continue;
}
ar = data.getData(src[i].nodeName === 'AREA' ? src[i] : this.key);
if (ar) {
if ($.inArray(ar, area_list) < 0) {
area_list.push(ar);
}
} else {
result = this.func_map.apply(data, me.args);
}
if (this.first || typeof result !== 'undefined') {
break;
}
}
}
// if there were areas, call the area function for each unique group
$(area_list).each(function (i, e) {
result = me.func_area.apply(e, me.args);
});
if (typeof result !== 'undefined') {
return result;
} else {
return this.output;
}
}
};
$.mapster.impl = (function () {
var me = {},
addMap = function (map_data) {
return m.map_cache.push(map_data) - 1;
},
removeMap = function (map_data) {
m.map_cache.splice(map_data.index, 1);
for (var i = m.map_cache.length - 1; i >= this.index; i--) {
m.map_cache[i].index--;
}
};
/**
* Test whether the browser supports VML. Credit: google.
* http://stackoverflow.com/questions/654112/how-do-you-detect-support-for-vml-or-svg-in-a-browser
*
* @return {bool} true if vml is supported, false if not
*/
function hasVml() {
var a = $('<div />').appendTo('body');
a.html('<v:shape id="vml_flag1" adj="1" />');
var b = a[0].firstChild;
b.style.behavior = "url(#default#VML)";
var has = b ? typeof b.adj === "object" : true;
a.remove();
return has;
}
/**
* Return a reference to the IE namespaces object, if available, or an empty object otherwise
* @return {obkect} The document.namespaces object.
*/
function namespaces() {
return typeof (document.namespaces) === 'object' ?
document.namespaces :
null;
}
/**
* Test for the presence of HTML5 Canvas support. This also checks to see if excanvas.js has been
* loaded and is faking it; if so, we assume that canvas is not supported.
*
* @return {bool} true if HTML5 canvas support, false if not
*/
function hasCanvas() {
var d = namespaces();
// when g_vml_ is present, then we can be sure excanvas is active, meaning there's not a real canvas.
return d && d.g_vml_ ?
false :
$('<canvas />')[0].getContext ?
true :
false;
}
/**
* Merge new area data into existing area options on a MapData object. Used for rebinding.
*
* @param {[MapData]} map_data The MapData object
* @param {[object[]]} areas areas array to merge
*/
function merge_areas(map_data, areas) {
var ar, index,
map_areas = map_data.options.areas;
if (areas) {
$.each(areas, function (i, e) {
// Issue #68 - ignore invalid data in areas array
if (!e || !e.key) {
return;
}
index = u.indexOfProp(map_areas, "key", e.key);
if (index >= 0) {
$.extend(map_areas[index], e);
}
else {
map_areas.push(e);
}
ar = map_data.getDataForKey(e.key);
if (ar) {
$.extend(ar.options, e);
}
});
}
}
function merge_options(map_data, options) {
var temp_opts = u.updateProps({}, options);
delete temp_opts.areas;
u.updateProps(map_data.options, temp_opts);
merge_areas(map_data, options.areas);
// refresh the area_option template
u.updateProps(map_data.area_options, map_data.options);
}
// Most methods use the "Method" object which handles figuring out whether it's an image or area called and
// parsing key parameters. The constructor wants:
// this, the jQuery object
// a function that is called when an image was passed (with a this context of the MapData)
// a function that is called when an area was passed (with a this context of the AreaData)
// options: first = true means only the first member of a jQuery object is handled
// key = the key parameters passed
// defaultReturn: a value to return other than the jQuery object (if its not chainable)
// args: the arguments
// Returns a comma-separated list of user-selected areas. "staticState" areas are not considered selected for the purposes of this method.
me.get = function (key) {
var md = m.getMapData(this);
if (!(md && md.complete)) {
throw ("Can't access data until binding complete.");
}
return (new m.Method(this,
function () {
// map_data return
return this.getSelected();
},
function () {
return this.isSelected();
},
{
name: 'get',
args: arguments,
key: key,
first: true,
allowAsync: true,
defaultReturn: ''
}
)).go();
};
me.data = function (key) {
return (new m.Method(this,
null,
function () {
return this;
},
{
name: 'data',
args: arguments,
key: key
}
)).go();
};
// Set or return highlight state.
// $(img).mapster('highlight') -- return highlighted area key, or null if none
// $(area).mapster('highlight') -- highlight an area
// $(img).mapster('highlight','area_key') -- highlight an area
// $(img).mapster('highlight',false) -- remove highlight
me.highlight = function (key) {
return (new m.Method(this,
function () {
if (key === false) {
this.ensureNoHighlight();
} else {
var id = this.highlightId;
return id >= 0 ? this.data[id].key : null;
}
},
function () {
this.highlight();
},
{
name: 'highlight',
args: arguments,
key: key,
first: true
}
)).go();
};
// Return the primary keys for an area or group key.
// $(area).mapster('key')
// includes all keys (not just primary keys)
// $(area).mapster('key',true)
// $(img).mapster('key','group-key')
// $(img).mapster('key','group-key', true)
me.keys = function (key, all) {
var keyList = [],
md = m.getMapData(this);
if (!(md && md.complete)) {
throw ("Can't access data until binding complete.");
}
function addUniqueKeys(ad) {
var areas, keys = [];
if (!all) {
keys.push(ad.key);
} else {
areas = ad.areas();
$.each(areas, function (i, e) {
keys = keys.concat(e.keys);
});
}
$.each(keys, function (i, e) {
if ($.inArray(e, keyList) < 0) {
keyList.push(e);
}
});
}
if (!(md && md.complete)) {
return '';
}
if (typeof key === 'string') {
if (all) {
addUniqueKeys(md.getDataForKey(key));
} else {
keyList = [md.getKeysForGroup(key)];
}
} else {
all = key;
this.each(function (i, e) {
if (e.nodeName === 'AREA') {
addUniqueKeys(md.getDataForArea(e));
}
});
}
return keyList.join(',');
};
me.select = function () {
me.set.call(this, true);
};
me.deselect = function () {
me.set.call(this, false);
};
/**
* Select or unselect areas. Areas can be identified by a single string key, a comma-separated list of keys,
* or an array of strings.
*
*
* @param {boolean} selected Determines whether areas are selected or deselected
* @param {string|string[]} key A string, comma-separated string, or array of strings indicating
* the areas to select or deselect
* @param {object} options Rendering options to apply when selecting an area
*/
me.set = function (selected, key, options) {
var lastMap, map_data, opts = options,
key_list, area_list; // array of unique areas passed
function setSelection(ar) {
if (ar) {
switch (selected) {
case true:
ar.select(opts); break;
case false:
ar.deselect(true); break;
default:
ar.toggle(opts); break;
}
}
}
function addArea(ar) {
if (ar && $.inArray(ar, area_list) < 0) {
area_list.push(ar);
key_list += (key_list === '' ? '' : ',') + ar.key;
}
}
// Clean up after a group that applied to the same map
function finishSetForMap(map_data) {
$.each(area_list, function (i, el) {
setSelection(el);
});
if (!selected) {
map_data.removeSelectionFinish();
}
if (map_data.options.boundList) {
m.setBoundListProperties(map_data.options, m.getBoundList(map_data.options, key_list), selected);
}
}
this.filter('img,area').each(function (i, e) {
var keys;
map_data = m.getMapData(e);
if (map_data !== lastMap) {
if (lastMap) {
finishSetForMap(lastMap);
}
area_list = [];
key_list = '';
}
if (map_data) {
keys = '';
if (e.nodeName.toUpperCase() === 'IMG') {
if (!m.queueCommand(map_data, $(e), 'set', [selected, key, opts])) {
if (key instanceof Array) {
if (key.length) {
keys = key.join(",");
}
}
else {
keys = key;
}
if (keys) {
$.each(u.split(keys), function (i, key) {
addArea(map_data.getDataForKey(key.toString()));
lastMap = map_data;
});
}
}
} else {
opts = key;
if (!m.queueCommand(map_data, $(e), 'set', [selected, opts])) {
addArea(map_data.getDataForArea(e));
lastMap = map_data;
}
}
}
});
if (map_data) {
finishSetForMap(map_data);
}
return this;
};
me.unbind = function (preserveState) {
return (new m.Method(this,
function () {
this.clearEvents();
this.clearMapData(preserveState);
removeMap(this);
},
null,
{
name: 'unbind',
args: arguments
}
)).go();
};
// refresh options and update selection information.
me.rebind = function (options) {
return (new m.Method(this,
function () {
var me = this;
me.complete = false;
me.configureOptions(options);
me.bindImages().then(function () {
me.buildDataset(true);
me.complete = true;
});
//this.redrawSelections();
},
null,
{
name: 'rebind',
args: arguments
}
)).go();
};
// get options. nothing or false to get, or "true" to get effective options (versus passed options)
me.get_options = function (key, effective) {
var eff = u.isBool(key) ? key : effective; // allow 2nd parm as "effective" when no key
return (new m.Method(this,
function () {
var opts = $.extend({}, this.options);
if (eff) {
opts.render_select = u.updateProps(
{},
m.render_defaults,
opts,
opts.render_select);
opts.render_highlight = u.updateProps(
{},
m.render_defaults,
opts,
opts.render_highlight);
}
return opts;
},
function () {
return eff ? this.effectiveOptions() : this.options;
},
{
name: 'get_options',
args: arguments,
first: true,
allowAsync: true,
key: key
}
)).go();
};
// set options - pass an object with options to set,
me.set_options = function (options) {
return (new m.Method(this,
function () {
merge_options(this, options);
},
null,
{
name: 'set_options',
args: arguments
}
)).go();
};
me.unload = function () {
var i;
for (i = m.map_cache.length - 1; i >= 0; i--) {
if (m.map_cache[i]) {
me.unbind.call($(m.map_cache[i].image));
}
}
me.graphics = null;
};
me.snapshot = function () {
return (new m.Method(this,
function () {
$.each(this.data, function (i, e) {
e.selected = false;
});
this.base_canvas = this.graphics.createVisibleCanvas(this);
$(this.image).before(this.base_canvas);
},
null,
{ name: 'snapshot' }
)).go();
};
// do not queue this function
me.state = function () {
var md, result = null;
$(this).each(function (i, e) {
if (e.nodeName === 'IMG') {
md = m.getMapData(e);
if (md) {
result = md.state();
}
return false;
}
});
return result;
};
me.bind = function (options) {
return this.each(function (i, e) {
var img, map, usemap, md;
// save ref to this image even if we can't access it yet. commands will be queued
img = $(e);
md = m.getMapData(e);
// if already bound completely, do a total rebind
if (md) {
me.unbind.apply(img);
if (!md.complete) {
// will be queued
img.bind();
return true;
}
md = null;
}
// ensure it's a valid image
// jQuery bug with Opera, results in full-url#usemap being returned from jQuery's attr.
// So use raw getAttribute instead.
usemap = this.getAttribute('usemap');
map = usemap && $('map[name="' + usemap.substr(1) + '"]');
if (!(img.is('img') && usemap && map.size() > 0)) {
return true;
}
// sorry - your image must have border:0, things are too unpredictable otherwise.
img.css('border', 0);
if (!md) {
md = new m.MapData(this, options);
md.index = addMap(md);
md.map = map;
md.bindImages().then(function () {
md.initialize();
});
}
});
};
me.init = function (useCanvas) {
var style, shapes;
// for testing/debugging, use of canvas can be forced by initializing
// manually with "true" or "false". But generally we test for it.
m.hasCanvas = function () {
if (!u.isBool(m.hasCanvas.value)) {
m.hasCanvas.value = u.isBool(useCanvas) ?
useCanvas :
hasCanvas();
}
return m.hasCanvas.value;
};
m.hasVml = function () {
if (!u.isBool(m.hasVml.value)) {
// initialize VML the first time we detect its presence.
var d = namespaces();
if (d && !d.v) {
d.add("v", "urn:schemas-microsoft-com:vml");
style = document.createStyleSheet();
shapes = ['shape', 'rect', 'oval', 'circ', 'fill', 'stroke', 'imagedata', 'group', 'textbox'];
$.each(shapes,
function (i, el) {
style.addRule('v\\:' + el, "behavior: url(#default#VML); antialias:true");
});
}
m.hasVml.value = hasVml();
}
return m.hasVml.value;
};
m.isTouch = !!document.documentElement.ontouchstart;
$.extend(m.defaults, m.render_defaults, m.shared_defaults);
$.extend(m.area_defaults, m.render_defaults, m.shared_defaults);
};
me.test = function (obj) {
return eval(obj);
};
return me;
}());
$.mapster.impl.init();
}(jQuery));
/* graphics.js
Graphics object handles all rendering.
*/
(function ($) {
var p, m = $.mapster,
u = m.utils,
canvasMethods,
vmlMethods;
/**
* Implemenation to add each area in an AreaData object to the canvas
* @param {Graphics} graphics The target graphics object
* @param {AreaData} areaData The AreaData object (a collection of area elements and metadata)
* @param {object} options Rendering options to apply when rendering this group of areas
*/
function addShapeGroupImpl(graphics, areaData, options) {
var me = graphics,
md = me.map_data,
isMask = options.isMask;
// first get area options. Then override fade for selecting, and finally merge in the
// "select" effect options.
$.each(areaData.areas(), function (i, e) {
options.isMask = isMask || (e.nohref && md.options.noHrefIsMask);
me.addShape(e, options);
});
// it's faster just to manipulate the passed options isMask property and restore it, than to
// copy the object each time
options.isMask = isMask;
}
/**
* Convert a hex value to decimal
* @param {string} hex A hexadecimal toString
* @return {int} Integer represenation of the hex string
*/
function hex_to_decimal(hex) {
return Math.max(0, Math.min(parseInt(hex, 16), 255));
}
function css3color(color, opacity) {
return 'rgba(' + hex_to_decimal(color.substr(0, 2)) + ','
+ hex_to_decimal(color.substr(2, 2)) + ','
+ hex_to_decimal(color.substr(4, 2)) + ',' + opacity + ')';
}
/**
* An object associated with a particular map_data instance to manage renderin.
* @param {MapData} map_data The MapData object bound to this instance
*/
m.Graphics = function (map_data) {
//$(window).unload($.mapster.unload);
// create graphics functions for canvas and vml browsers. usage:
// 1) init with map_data, 2) call begin with canvas to be used (these are separate b/c may not require canvas to be specified
// 3) call add_shape_to for each shape or mask, 4) call render() to finish
var me = this;
me.active = false;
me.canvas = null;
me.width = 0;
me.height = 0;
me.shapes = [];
me.masks = [];
me.map_data = map_data;
};
p = m.Graphics.prototype = {
constructor: m.Graphics,
/**
* Initiate a graphics request for a canvas
* @param {Element} canvas The canvas element that is the target of this operation
* @param {string} [elementName] The name to assign to the element (VML only)
*/
begin: function (canvas, elementName) {
var c = $(canvas);
this.elementName = elementName;
this.canvas = canvas;
this.width = c.width();
this.height = c.height();
this.shapes = [];
this.masks = [];
this.active = true;
},
/**
* Add an area to be rendered to this canvas.
* @param {MapArea} mapArea The MapArea object to render
* @param {object} options An object containing any rendering options that should override the
* defaults for the area
*/
addShape: function (mapArea, options) {
var addto = options.isMask ? this.masks : this.shapes;
addto.push({ mapArea: mapArea, options: options });
},
/**
* Create a canvas that is sized and styled for the MapData object
* @param {MapData} mapData The MapData object that will receive this new canvas
* @return {Element} A canvas element
*/
createVisibleCanvas: function (mapData) {
return $(this.createCanvasFor(mapData))
.addClass('mapster_el')
.css(m.canvas_style)[0];
},
/**
* Add a group of shapes from an AreaData object to the canvas
*
* @param {AreaData} areaData An AreaData object (a set of area elements)
* @param {string} mode The rendering mode, "select" or "highlight". This determines the target
* canvas and which default options to use.
* @param {striong} options Rendering options
*/
addShapeGroup: function (areaData, mode, options) {
// render includeKeys first - because they could be masks
var me = this,
list, name, canvas,
map_data = this.map_data,
opts = areaData.effectiveRenderOptions(mode);
if (options) {
$.extend(opts, options);
}
if (mode === 'select') {
name = "static_" + areaData.areaId.toString();
canvas = map_data.base_canvas;
} else {
canvas = map_data.overlay_canvas;
}
me.begin(canvas, name);
if (opts.includeKeys) {
list = u.split(opts.includeKeys);
$.each(list, function (i, e) {
var areaData = map_data.getDataForKey(e.toString());
addShapeGroupImpl(me, areaData, areaData.effectiveRenderOptions(mode));
});
}
addShapeGroupImpl(me, areaData, opts);
me.render();
if (opts.fade) {
// fading requires special handling for IE. We must access the fill elements directly. The fader also has to deal with
// the "opacity" attribute (not css)
u.fader(m.hasCanvas() ?
canvas :
$(canvas).find('._fill').not('.mapster_mask'),
0,
m.hasCanvas() ?
1 :
opts.fillOpacity,
opts.fadeDuration);
}
}
// These prototype methods are implementation dependent
};
function noop() { }
// configure remaining prototype methods for ie or canvas-supporting browser
canvasMethods = {
renderShape: function (context, mapArea, offset) {
var i,
c = mapArea.coords(null, offset);
switch (mapArea.shape) {
case 'rect':
context.rect(c[0], c[1], c[2] - c[0], c[3] - c[1]);
break;
case 'poly':
context.moveTo(c[0], c[1]);
for (i = 2; i < mapArea.length; i += 2) {
context.lineTo(c[i], c[i + 1]);
}
context.lineTo(c[0], c[1]);
break;
case 'circ':
case 'circle':
context.arc(c[0], c[1], c[2], 0, Math.PI * 2, false);
break;
}
},
addAltImage: function (context, image, mapArea, options) {
context.beginPath();
this.renderShape(context, mapArea);
context.closePath();
context.clip();
context.globalAlpha = options.altImageOpacity || options.fillOpacity;
context.drawImage(image, 0, 0, mapArea.owner.scaleInfo.width, mapArea.owner.scaleInfo.height);
},
render: function () {
// firefox 6.0 context.save() seems to be broken. to work around, we have to draw the contents on one temp canvas,
// the mask on another, and merge everything. ugh. fixed in 1.2.2. unfortunately this is a lot more code for masks,
// but no other way around it that i can see.
var maskCanvas, maskContext,
me = this,
md = me.map_data,
hasMasks = me.masks.length,
shapeCanvas = me.createCanvasFor(md),
shapeContext = shapeCanvas.getContext('2d'),
context = me.canvas.getContext('2d');
if (hasMasks) {
maskCanvas = me.createCanvasFor(md);
maskContext = maskCanvas.getContext('2d');
maskContext.clearRect(0, 0, maskCanvas.width, maskCanvas.height);
$.each(me.masks, function (i, e) {
maskContext.save();
maskContext.beginPath();
me.renderShape(maskContext, e.mapArea);
maskContext.closePath();
maskContext.clip();
maskContext.lineWidth = 0;
maskContext.fillStyle = '#000';
maskContext.fill();
maskContext.restore();
});
}
$.each(me.shapes, function (i, s) {
shapeContext.save();
if (s.options.fill) {
if (s.options.altImageId) {
me.addAltImage(shapeContext, md.images[s.options.altImageId], s.mapArea, s.options);
} else {
shapeContext.beginPath();
me.renderShape(shapeContext, s.mapArea);
shapeContext.closePath();
//shapeContext.clip();
shapeContext.fillStyle = css3color(s.options.fillColor, s.options.fillOpacity);
shapeContext.fill();
}
}
shapeContext.restore();
});
// render strokes at end since masks get stroked too
$.each(me.shapes.concat(me.masks), function (i, s) {
var offset = s.options.strokeWidth === 1 ? 0.5 : 0;
// offset applies only when stroke width is 1 and stroke would render between pixels.
if (s.options.stroke) {
shapeContext.save();
shapeContext.strokeStyle = css3color(s.options.strokeColor, s.options.strokeOpacity);
shapeContext.lineWidth = s.options.strokeWidth;
shapeContext.beginPath();
me.renderShape(shapeContext, s.mapArea, offset);
shapeContext.closePath();
shapeContext.stroke();
shapeContext.restore();
}
});
if (hasMasks) {
// render the new shapes against the mask
maskContext.globalCompositeOperation = "source-out";
maskContext.drawImage(shapeCanvas, 0, 0);
// flatten into the main canvas
context.drawImage(maskCanvas, 0, 0);
} else {
context.drawImage(shapeCanvas, 0, 0);
}
me.active = false;
return me.canvas;
},
// create a canvas mimicing dimensions of an existing element
createCanvasFor: function (md) {
return $('<canvas width="' + md.scaleInfo.width + '" height="' + md.scaleInfo.height + '"></canvas>')[0];
},
clearHighlight: function () {
var c = this.map_data.overlay_canvas;
c.getContext('2d').clearRect(0, 0, c.width, c.height);
},
// Draw all items from selected_list to a new canvas, then swap with the old one. This is used to delete items when using canvases.
refreshSelections: function () {
var canvas_temp, map_data = this.map_data;
// draw new base canvas, then swap with the old one to avoid flickering
canvas_temp = map_data.base_canvas;
map_data.base_canvas = this.createVisibleCanvas(map_data);
$(map_data.base_canvas).hide();
$(canvas_temp).before(map_data.base_canvas);
map_data.redrawSelections();
$(map_data.base_canvas).show();
$(canvas_temp).remove();
}
};
vmlMethods = {
renderShape: function (mapArea, options, cssclass) {
var me = this, fill, stroke, e, t_fill, el_name, el_class, template, c = mapArea.coords();
el_name = me.elementName ? 'name="' + me.elementName + '" ' : '';
el_class = cssclass ? 'class="' + cssclass + '" ' : '';
t_fill = '<v:fill color="#' + options.fillColor + '" class="_fill" opacity="' +
(options.fill ?
options.fillOpacity :
0) +
'" /><v:stroke class="_fill" opacity="' +
options.strokeOpacity + '"/>';
stroke = options.stroke ?
' strokeweight=' + options.strokeWidth + ' stroked="t" strokecolor="#' +
options.strokeColor + '"' :
' stroked="f"';
fill = options.fill ?
' filled="t"' :
' filled="f"';
switch (mapArea.shape) {
case 'rect':
template = '<v:rect ' + el_class + el_name + fill + stroke +
' style="zoom:1;margin:0;padding:0;display:block;position:absolute;left:' +
c[0] + 'px;top:' + c[1] + 'px;width:' + (c[2] - c[0]) +
'px;height:' + (c[3] - c[1]) + 'px;">' + t_fill + '</v:rect>';
break;
case 'poly':
template = '<v:shape ' + el_class + el_name + fill + stroke + ' coordorigin="0,0" coordsize="' + me.width + ',' + me.height
+ '" path="m ' + c[0] + ',' + c[1] + ' l ' + c.slice(2).join(',')
+ ' x e" style="zoom:1;margin:0;padding:0;display:block;position:absolute;top:0px;left:0px;width:' + me.width + 'px;height:' + me.height + 'px;">' + t_fill + '</v:shape>';
break;
case 'circ':
case 'circle':
template = '<v:oval ' + el_class + el_name + fill + stroke
+ ' style="zoom:1;margin:0;padding:0;display:block;position:absolute;left:' + (c[0] - c[2]) + 'px;top:' + (c[1] - c[2])
+ 'px;width:' + (c[2] * 2) + 'px;height:' + (c[2] * 2) + 'px;">' + t_fill + '</v:oval>';
break;
}
e = $(template);
$(me.canvas).append(e);
return e;
},
render: function () {
var opts, me = this;
$.each(this.shapes, function (i, e) {
me.renderShape(e.mapArea, e.options);
});
if (this.masks.length) {
$.each(this.masks, function (i, e) {
opts = u.updateProps({},
e.options, {
fillOpacity: 1,
fillColor: e.options.fillColorMask
});
me.renderShape(e.mapArea, opts, 'mapster_mask');
});
}
this.active = false;
return this.canvas;
},
createCanvasFor: function (md) {
var w = md.scaleInfo.width,
h = md.scaleInfo.height;
return $('<var width="' + w + '" height="' + h
+ '" style="zoom:1;overflow:hidden;display:block;width:'
+ w + 'px;height:' + h + 'px;"></var>')[0];
},
clearHighlight: function () {
$(this.map_data.overlay_canvas).children().remove();
},
// remove single or all selections
removeSelections: function (area_id) {
if (area_id >= 0) {
$(this.map_data.base_canvas).find('[name="static_' + area_id.toString() + '"]').remove();
}
else {
$(this.map_data.base_canvas).children().remove();
}
}
};
// for all methods with two implemenatations, add a function that will automatically replace itself with the correct
// method on first invocation
$.each(['renderShape',
'addAltImage',
'render',
'createCanvasFor',
'clearHighlight',
'removeSelections',
'refreshSelections'],
function (i, e) {
p[e] = (function (method) {
return function () {
p[method] = (m.hasCanvas() ?
canvasMethods[method] :
vmlMethods[method]) || noop;
return p[method].apply(this, arguments);
};
}(e));
});
}(jQuery));
/* mapimage.js
the MapImage object, repesents an instance of a single bound imagemap
*/
(function ($) {
var m = $.mapster,
u = m.utils,
ap = [];
/**
* An object encapsulating all the images used by a MapData.
*/
m.MapImages = function (owner) {
this.owner = owner;
this.clear();
};
m.MapImages.prototype = {
constructor: m.MapImages,
/* interface to make this array-like */
slice: function () {
return ap.slice.apply(this, arguments);
},
splice: function () {
ap.slice.apply(this.status, arguments);
var result = ap.slice.apply(this, arguments);
return result;
},
/**
* a boolean value indicates whether all images are done loading
* @return {bool} true when all are done
*/
complete: function () {
return $.inArray(false, this.status) < 0;
},
/**
* Save an image in the images array and return its index
* @param {Image} image An Image object
* @return {int} the index of the image
*/
_add: function (image) {
var index = ap.push.call(this, image) - 1;
this.status[index] = false;
return index;
},
/**
* Return the index of an Image within the images array
* @param {Image} img An Image
* @return {int} the index within the array, or -1 if it was not found
*/
indexOf: function (image) {
return $.inArray(image, this);
},
/**
* Clear this object and reset it to its initial state after binding.
*/
clear: function () {
var me = this;
if (me.ids && me.ids.length > 0) {
$.each(me.ids, function (i, e) {
delete me[e];
});
}
/**
* A list of the cross-reference IDs bound to this object
* @type {string[]}
*/
me.ids = [];
/**
* Length property for array-like behavior, set to zero when initializing. Array prototype
* methods will update it after that.
*
* @type {int}
*/
me.length = 0;
/**
* the loaded status of the corresponding image
* @type {boolean[]}
*/
me.status = [];
// actually erase the images
me.splice(0);
},
/**
* Bind an image to the map and add it to the queue to be loaded; return an ID that
* can be used to reference the
*
* @param {Image|string} image An Image object or a URL to an image
* @param {string} [id] An id to refer to this image
* @returns {int} an ID referencing the index of the image object in
* map_data.images
*/
add: function (image, id) {
var index, src, me = this;
if (!image) { return; }
if (typeof image === 'string') {
src = image;
image = me[src];
if (typeof image === 'object') {
return me.indexOf(image);
}
image = $('<img />')
.addClass('mapster_el')
.hide();
index = me._add(image[0]);
image
.bind('load', function (e) {
me.imageLoaded.call(me, e);
})
.bind('error', function (e) {
me.imageLoadError.call(me, e);
});
image.attr('src', src);
} else {
// use attr because we want the actual source, not the resolved path the browser will return directly calling image.src
index = me._add($(image)[0]);
}
if (id) {
if (this[id]) {
throw (id + " is already used or is not available as an altImage alias.");
}
me.ids.push(id);
me[id] = me[index];
}
return index;
},
/**
* Bind the images in this object,
* @param {boolean} retry when true, indicates that the function is calling itself after failure
* @return {Promise} a promise that resolves when the images have finished loading
*/
bind: function (retry) {
var me = this,
promise,
triesLeft = me.owner.options.configTimeout / 200,
/* A recursive function to continue checking that the images have been
loaded until a timeout has elapsed */
check = function () {
var i;
// refresh status of images
i = me.length;
while (i-- > 0) {
if (!me.isLoaded(i)) {
break;
}
}
// check to see if every image has already been loaded
if (me.complete()) {
me.resolve();
} else {
// to account for failure of onLoad to fire in rare situations
if (triesLeft-- > 0) {
me.imgTimeout = window.setTimeout(function () {
check.call(me, true);
}, 50);
} else {
me.imageLoadError.call(me);
}
}
};
promise = me.deferred = u.defer();
check();
return promise;
},
resolve: function () {
var me = this,
resolver = me.deferred;
if (resolver) {
// Make a copy of the resolver before calling & removing it to ensure
// it is not called twice
me.deferred = null;
resolver.resolve();
}
},
/**
* Event handler for image onload
* @param {object} e jQuery event data
*/
imageLoaded: function (e) {
var me = this,
index = me.indexOf(e.target);
if (index >= 0) {
me.status[index] = true;
if ($.inArray(false, me.status) < 0) {
me.resolve();
}
}
},
/**
* Event handler for onload error
* @param {object} e jQuery event data
*/
imageLoadError: function (e) {
clearTimeout(this.imgTimeout);
this.triesLeft = 0;
var err = e ? 'The image ' + e.target.src + ' failed to load.' :
'The images never seemed to finish loading. You may just need to increase the configTimeout if images could take a long time to load.';
throw err;
},
/**
* Test if the image at specificed index has finished loading
* @param {int} index The image index
* @return {boolean} true if loaded, false if not
*/
isLoaded: function (index) {
var img,
me = this,
status = me.status;
if (status[index]) { return true; }
img = me[index];
if (typeof img.complete !== 'undefined') {
status[index] = img.complete;
} else {
status[index] = !!u.imgWidth(img);
}
// if complete passes, the image is loaded, but may STILL not be available because of stuff like adblock.
// make sure it is.
return status[index];
}
};
}(jQuery));
/* mapdata.js
the MapData object, repesents an instance of a single bound imagemap
*/
(function ($) {
var m = $.mapster,
u = m.utils;
/**
* Set default values for MapData object properties
* @param {MapData} me The MapData object
*/
function initializeDefaults(me) {
$.extend(me, {
complete: false, // (bool) when configuration is complete
map: null, // ($) the image map
base_canvas: null, // (canvas|var) where selections are rendered
overlay_canvas: null, // (canvas|var) where highlights are rendered
commands: [], // {} commands that were run before configuration was completed (b/c images weren't loaded)
data: [], // MapData[] area groups
mapAreas: [], // MapArea[] list. AreaData entities contain refs to this array, so options are stored with each.
_xref: {}, // (int) xref of mapKeys to data[]
highlightId: -1, // (int) the currently highlighted element.
currentAreaId: -1,
_tooltip_events: [], // {} info on events we bound to a tooltip container, so we can properly unbind them
scaleInfo: null, // {} info about the image size, scaling, defaults
index: -1, // index of this in map_cache - so we have an ID to use for wraper div
activeAreaEvent: null
});
}
/**
* Return an array of all image-containing options from an options object;
* that is, containers that may have an "altImage" property
*
* @param {object} obj An options object
* @return {object[]} An array of objects
*/
function getOptionImages(obj) {
return [obj, obj.render_highlight, obj.render_select];
}
/**
* Parse all the altImage references, adding them to the library so they can be preloaded
* and aliased.
*
* @param {MapData} me The MapData object on which to operate
*/
function configureAltImages(me) {
var opts = me.options,
mi = me.images;
// add alt images
if (m.hasCanvas()) {
// map altImage library first
$.each(opts.altImages || {}, function (i, e) {
mi.add(e, i);
});
// now find everything else
$.each([opts].concat(opts.areas), function (i, e) {
$.each(getOptionImages(e), function (i2, e2) {
if (e2 && e2.altImage) {
e2.altImageId = mi.add(e2.altImage);
}
});
});
}
// set area_options
me.area_options = u.updateProps({}, // default options for any MapArea
m.area_defaults,
opts);
}
/**
* Queue a mouse move action based on current delay settings
* (helper for mouseover/mouseout handlers)
*
* @param {MapData} me The MapData context
* @param {number} delay The number of milliseconds to delay the action
* @param {AreaData} area AreaData affected
* @param {Deferred} deferred A deferred object to return (instead of a new one)
* @return {Promise} A promise that resolves when the action is completed
*/
function queueMouseEvent(me, delay, area, deferred) {
deferred = deferred || u.when.defer();
function cbFinal(areaId) {
if (me.currentAreaId !== areaId && me.highlightId >= 0) {
deferred.resolve();
}
}
if (me.activeAreaEvent) {
window.clearTimeout(me.activeAreaEvent);
me.activeAreaEvent = 0;
}
if (delay < 0) {
return;
}
if (area.owner.currentAction || delay) {
me.activeAreaEvent = window.setTimeout((function () {
return function () {
queueMouseEvent(me, 0, area, deferred);
};
}(area)),
delay || 100);
} else {
cbFinal(area.areaId);
}
return deferred;
}
/**
* Mousedown event. This is captured only to prevent browser from drawing an outline around an
* area when it's clicked.
*
* @param {EventData} e jQuery event data
*/
function mousedown(e) {
if (!m.hasCanvas()) {
this.blur();
}
e.preventDefault();
}
/**
* Mouseover event. Handle highlight rendering and client callback on mouseover
*
* @param {MapData} me The MapData context
* @param {EventData} e jQuery event data
* @return {[type]} [description]
*/
function mouseover(me, e) {
var arData = me.getAllDataForArea(this),
ar = arData.length ? arData[0] : null;
// mouseover events are ignored entirely while resizing, though we do care about mouseout events
// and must queue the action to keep things clean.
if (!ar || ar.isNotRendered() || ar.owner.currentAction) {
return;
}
if (me.currentAreaId === ar.areaId) {
return;
}
if (me.highlightId !== ar.areaId) {
me.clearEffects();
ar.highlight();
if (me.options.showToolTip) {
$.each(arData, function (i, e) {
if (e.effectiveOptions().toolTip) {
e.showToolTip();
}
});
}
}
me.currentAreaId = ar.areaId;
if ($.isFunction(me.options.onMouseover)) {
me.options.onMouseover.call(this,
{
e: e,
options: ar.effectiveOptions(),
key: ar.key,
selected: ar.isSelected()
});
}
}
/**
* Mouseout event.
*
* @param {MapData} me The MapData context
* @param {EventData} e jQuery event data
* @return {[type]} [description]
*/
function mouseout(me, e) {
var newArea,
ar = me.getDataForArea(this),
opts = me.options;
if (me.currentAreaId < 0 || !ar) {
return;
}
newArea = me.getDataForArea(e.relatedTarget);
if (newArea === ar) {
return;
}
me.currentAreaId = -1;
ar.area = null;
queueMouseEvent(me, opts.mouseoutDelay, ar)
.then(me.clearEffects);
if ($.isFunction(opts.onMouseout)) {
opts.onMouseout.call(this,
{
e: e,
options: opts,
key: ar.key,
selected: ar.isSelected()
});
}
}
/**
* Clear any active tooltip or highlight
*
* @param {MapData} me The MapData context
* @param {EventData} e jQuery event data
* @return {[type]} [description]
*/
function clearEffects(me) {
var opts = me.options;
me.ensureNoHighlight();
if (opts.toolTipClose
&& $.inArray('area-mouseout', opts.toolTipClose) >= 0
&& me.activeToolTip) {
me.clearToolTip();
}
}
/**
* Mouse click event handler
*
* @param {MapData} me The MapData context
* @param {EventData} e jQuery event data
* @return {[type]} [description]
*/
function click(me, e) {
var selected, list, list_target, newSelectionState, canChangeState, cbResult,
that = this,
ar = me.getDataForArea(this),
opts = me.options;
function clickArea(ar) {
var areaOpts, target;
canChangeState = (ar.isSelectable() &&
(ar.isDeselectable() || !ar.isSelected()));
if (canChangeState) {
newSelectionState = !ar.isSelected();
} else {
newSelectionState = ar.isSelected();
}
list_target = m.getBoundList(opts, ar.key);
if ($.isFunction(opts.onClick)) {
cbResult = opts.onClick.call(that,
{
e: e,
listTarget: list_target,
key: ar.key,
selected: newSelectionState
});
if (u.isBool(cbResult)) {
if (!cbResult) {
return false;
}
target = $(ar.area).attr('href');
if (target !== '#') {
window.location.href = target;
return false;
}
}
}
if (canChangeState) {
selected = ar.toggle();
}
if (opts.boundList && opts.boundList.length > 0) {
m.setBoundListProperties(opts, list_target, ar.isSelected());
}
areaOpts = ar.effectiveOptions();
if (areaOpts.includeKeys) {
list = u.split(areaOpts.includeKeys);
$.each(list, function (i, e) {
var ar = me.getDataForKey(e.toString());
if (!ar.options.isMask) {
clickArea(ar);
}
});
}
}
mousedown.call(this, e);
if (opts.clickNavigate && ar.href) {
window.location.href = ar.href;
return;
}
if (ar && !ar.owner.currentAction) {
opts = me.options;
clickArea(ar);
}
}
/**
* Prototype for a MapData object, representing an ImageMapster bound object
* @param {Element} image an IMG element
* @param {object} options ImageMapster binding options
*/
m.MapData = function (image, options) {
var me = this;
// (Image) main map image
me.image = image;
me.images = new m.MapImages(me);
me.graphics = new m.Graphics(me);
// save the initial style of the image for unbinding. This is problematic, chrome
// duplicates styles when assigning, and cssText is apparently not universally supported.
// Need to do something more robust to make unbinding work universally.
me.imgCssText = image.style.cssText || null;
initializeDefaults(me);
me.configureOptions(options);
// create context-bound event handlers from our private functions
me.mouseover = function (e) { mouseover.call(this, me, e); };
me.mouseout = function (e) { mouseout.call(this, me, e); };
me.click = function (e) { click.call(this, me, e); };
me.clearEffects = function (e) { clearEffects.call(this, me, e); };
};
m.MapData.prototype = {
constructor: m.MapData,
/**
* Set target.options from defaults + options
* @param {[type]} target The target
* @param {[type]} options The options to merge
*/
configureOptions: function (options) {
this.options = u.updateProps({}, m.defaults, options);
},
/**
* Ensure all images are loaded
* @return {Promise} A promise that resolves when the images have finished loading (or fail)
*/
bindImages: function () {
var me = this,
mi = me.images;
// reset the images if this is a rebind
if (mi.length > 2) {
mi.splice(2);
} else if (mi.length === 0) {
// add the actual main image
mi.add(me.image);
// will create a duplicate of the main image, we need this to get raw size info
mi.add(me.image.src);
}
configureAltImages(me);
return me.images.bind();
},
/**
* Test whether an async action is currently in progress
* @return {Boolean} true or false indicating state
*/
isActive: function () {
return !this.complete || this.currentAction;
},
/**
* Return an object indicating the various states. This isn't really used by
* production code.
*
* @return {object} An object with properties for various states
*/
state: function () {
return {
complete: this.complete,
resizing: this.currentAction === 'resizing',
zoomed: this.zoomed,
zoomedArea: this.zoomedArea,
scaleInfo: this.scaleInfo
};
},
/**
* Get a unique ID for the wrapper of this imagemapster
* @return {string} A string that is unique to this image
*/
wrapId: function () {
return 'mapster_wrap_' + this.index;
},
_idFromKey: function (key) {
return typeof key === "string" && this._xref.hasOwnProperty(key) ?
this._xref[key] : -1;
},
/**
* Return a comma-separated string of all selected keys
* @return {string} CSV of all keys that are currently selected
*/
getSelected: function () {
var result = '';
$.each(this.data, function (i, e) {
if (e.isSelected()) {
result += (result ? ',' : '') + this.key;
}
});
return result;
},
/**
* Get an array of MapAreas associated with a specific AREA based on the keys for that area
* @param {Element} area An HTML AREA
* @param {number} atMost A number limiting the number of areas to be returned (typically 1 or 0 for no limit)
* @return {MapArea[]} Array of MapArea objects
*/
getAllDataForArea: function (area, atMost) {
var i, ar, result,
me = this,
key = $(area).filter('area').attr(me.options.mapKey);
if (key) {
result = [];
key = u.split(key);
for (i = 0; i < (atMost || key.length) ; i++) {
ar = me.data[me._idFromKey(key[i])];
ar.area = area.length ? area[0] : area;
// set the actual area moused over/selected
// TODO: this is a brittle model for capturing which specific area - if this method was not used,
// ar.area could have old data. fix this.
result.push(ar);
}
}
return result;
},
getDataForArea: function (area) {
var ar = this.getAllDataForArea(area, 1);
return ar ? ar[0] || null : null;
},
getDataForKey: function (key) {
return this.data[this._idFromKey(key)];
},
/**
* Get the primary keys associated with an area group.
* If this is a primary key, it will be returned.
*
* @param {string key An area key
* @return {string} A CSV of area keys
*/
getKeysForGroup: function (key) {
var ar = this.getDataForKey(key);
return !ar ? '' :
ar.isPrimary ?
ar.key :
this.getPrimaryKeysForMapAreas(ar.areas()).join(',');
},
/**
* given an array of MapArea object, return an array of its unique primary keys
* @param {MapArea[]} areas The areas to analyze
* @return {string[]} An array of unique primary keys
*/
getPrimaryKeysForMapAreas: function (areas) {
var keys = [];
$.each(areas, function (i, e) {
if ($.inArray(e.keys[0], keys) < 0) {
keys.push(e.keys[0]);
}
});
return keys;
},
getData: function (obj) {
if (typeof obj === 'string') {
return this.getDataForKey(obj);
} else if (obj && obj.mapster || u.isElement(obj)) {
return this.getDataForArea(obj);
} else {
return null;
}
},
// remove highlight if present, raise event
ensureNoHighlight: function () {
var ar;
if (this.highlightId >= 0) {
this.graphics.clearHighlight();
ar = this.data[this.highlightId];
ar.changeState('highlight', false);
this.setHighlightId(-1);
}
},
setHighlightId: function (id) {
this.highlightId = id;
},
/**
* Clear all active selections on this map
*/
clearSelections: function () {
$.each(this.data, function (i, e) {
if (e.selected) {
e.deselect(true);
}
});
this.removeSelectionFinish();
},
/**
* Set area options from an array of option data.
*
* @param {object[]} areas An array of objects containing area-specific options
*/
setAreaOptions: function (areas) {
var i, area_options, ar;
areas = areas || [];
// refer by: map_data.options[map_data.data[x].area_option_id]
for (i = areas.length - 1; i >= 0; i--) {
area_options = areas[i];
if (area_options) {
ar = this.getDataForKey(area_options.key);
if (ar) {
u.updateProps(ar.options, area_options);
// TODO: will not deselect areas that were previously selected, so this only works
// for an initial bind.
if (u.isBool(area_options.selected)) {
ar.selected = area_options.selected;
}
}
}
}
},
// keys: a comma-separated list
drawSelections: function (keys) {
var i, key_arr = u.asArray(keys);
for (i = key_arr.length - 1; i >= 0; i--) {
this.data[key_arr[i]].drawSelection();
}
},
redrawSelections: function () {
$.each(this.data, function (i, e) {
if (e.isSelectedOrStatic()) {
e.drawSelection();
}
});
},
///called when images are done loading
initialize: function () {
var imgCopy, base_canvas, overlay_canvas, wrap, parentId, css, i, size,
img, sort_func, sorted_list, scale,
me = this,
opts = me.options;
if (me.complete) {
return;
}
img = $(me.image);
parentId = img.parent().attr('id');
// create a div wrapper only if there's not already a wrapper, otherwise, own it
if (parentId && parentId.length >= 12 && parentId.substring(0, 12) === "mapster_wrap") {
wrap = img.parent();
wrap.attr('id', me.wrapId());
} else {
wrap = $('<div id="' + me.wrapId() + '"></div>');
if (opts.wrapClass) {
if (opts.wrapClass === true) {
wrap.addClass(img[0].className);
}
else {
wrap.addClass(opts.wrapClass);
}
}
}
me.wrapper = wrap;
// me.images[1] is the copy of the original image. It should be loaded & at its native size now so we can obtain the true
// width & height. This is needed to scale the imagemap if not being shown at its native size. It is also needed purely
// to finish binding in case the original image was not visible. It can be impossible in some browsers to obtain the
// native size of a hidden image.
me.scaleInfo = scale = u.scaleMap(me.images[0], me.images[1], opts.scaleMap);
me.base_canvas = base_canvas = me.graphics.createVisibleCanvas(me);
me.overlay_canvas = overlay_canvas = me.graphics.createVisibleCanvas(me);
// Now we got what we needed from the copy -clone from the original image again to make sure any other attributes are copied
imgCopy = $(me.images[1])
.addClass('mapster_el ' + me.images[0].className)
.attr({ id: null, usemap: null });
size = u.size(me.images[0]);
if (size.complete) {
imgCopy.css({
width: size.width,
height: size.height
});
}
me.buildDataset();
// now that we have processed all the areas, set css for wrapper, scale map if needed
css = {
display: 'block',
position: 'relative',
padding: 0,
width: scale.width,
height: scale.height
};
if (opts.wrapCss) {
$.extend(css, opts.wrapCss);
}
// if we were rebinding with an existing wrapper, the image will aready be in it
if (img.parent()[0] !== me.wrapper[0]) {
img.before(me.wrapper);
}
wrap.css(css);
// move all generated images into the wrapper for easy removal later
$(me.images.slice(2)).hide();
for (i = 1; i < me.images.length; i++) {
wrap.append(me.images[i]);
}
//me.images[1].style.cssText = me.image.style.cssText;
wrap.append(base_canvas)
.append(overlay_canvas)
.append(img.css(m.canvas_style));
// images[0] is the original image with map, images[1] is the copy/background that is visible
u.setOpacity(me.images[0], 0);
$(me.images[1]).show();
u.setOpacity(me.images[1], 1);
if (opts.isSelectable && opts.onGetList) {
sorted_list = me.data.slice(0);
if (opts.sortList) {
if (opts.sortList === "desc") {
sort_func = function (a, b) {
return a === b ? 0 : (a > b ? -1 : 1);
};
}
else {
sort_func = function (a, b) {
return a === b ? 0 : (a < b ? -1 : 1);
};
}
sorted_list.sort(function (a, b) {
a = a.value;
b = b.value;
return sort_func(a, b);
});
}
me.options.boundList = opts.onGetList.call(me.image, sorted_list);
}
me.complete = true;
me.processCommandQueue();
if (opts.onConfigured && typeof opts.onConfigured === 'function') {
opts.onConfigured.call(img, true);
}
},
// when rebind is true, the MapArea data will not be rebuilt.
buildDataset: function (rebind) {
var sel, areas, j, area_id, $area, area, curKey, mapArea, key, keys, mapAreaId, group_value, dataItem, href,
me = this,
opts = me.options,
default_group;
function addAreaData(key, value) {
var dataItem = new m.AreaData(me, key, value);
dataItem.areaId = me._xref[key] = me.data.push(dataItem) - 1;
return dataItem.areaId;
}
me._xref = {};
me.data = [];
if (!rebind) {
me.mapAreas = [];
}
default_group = !opts.mapKey;
if (default_group) {
opts.mapKey = 'data-mapster-key';
}
// the [attribute] selector is broken on old IE with jQuery. hasVml() is a quick and dirty
// way to test for that
sel = m.hasVml() ? 'area' :
(default_group ?
'area[coords]' :
'area[' + opts.mapKey + ']');
areas = $(me.map).find(sel).unbind('.mapster');
for (mapAreaId = 0; mapAreaId < areas.length; mapAreaId++) {
area_id = 0;
area = areas[mapAreaId];
$area = $(area);
// skip areas with no coords - selector broken for older ie
if (!area.coords) {
continue;
}
// Create a key if none was assigned by the user
if (default_group) {
curKey = String(mapAreaId);
$area.attr('data-mapster-key', curKey);
} else {
curKey = area.getAttribute(opts.mapKey);
}
// conditions for which the area will be bound to mouse events
// only bind to areas that don't have nohref. ie 6&7 cannot detect the presence of nohref, so we have to also not bind if href is missing.
if (rebind) {
mapArea = me.mapAreas[$area.data('mapster') - 1];
mapArea.configure(curKey);
} else {
mapArea = new m.MapArea(me, area, curKey);
me.mapAreas.push(mapArea);
}
keys = mapArea.keys; // converted to an array by mapArea
// Iterate through each mapKey assigned to this area
for (j = keys.length - 1; j >= 0; j--) {
key = keys[j];
if (opts.mapValue) {
group_value = $area.attr(opts.mapValue);
}
if (default_group) {
// set an attribute so we can refer to the area by index from the DOM object if no key
area_id = addAreaData(me.data.length, group_value);
dataItem = me.data[area_id];
dataItem.key = key = area_id.toString();
}
else {
area_id = me._xref[key];
if (area_id >= 0) {
dataItem = me.data[area_id];
if (group_value && !me.data[area_id].value) {
dataItem.value = group_value;
}
}
else {
area_id = addAreaData(key, group_value);
dataItem = me.data[area_id];
dataItem.isPrimary = j === 0;
}
}
mapArea.areaDataXref.push(area_id);
dataItem.areasXref.push(mapAreaId);
}
href = $area.attr('href');
if (href && href !== '#' && !dataItem.href) {
dataItem.href = href;
}
if (!mapArea.nohref) {
$area.bind('click.mapster', me.click);
if (!m.isTouch) {
$area.bind('mouseover.mapster', me.mouseover)
.bind('mouseout.mapster', me.mouseout)
.bind('mousedown.mapster', me.mousedown);
}
}
// store an ID with each area.
$area.data("mapster", mapAreaId + 1);
}
// TODO listenToList
// if (opts.listenToList && opts.nitG) {
// opts.nitG.bind('click.mapster', event_hooks[map_data.hooks_index].listclick_hook);
// }
// populate areas from config options
me.setAreaOptions(opts.areas);
me.redrawSelections();
},
processCommandQueue: function () {
var cur, me = this;
while (!me.currentAction && me.commands.length) {
cur = me.commands[0];
me.commands.splice(0, 1);
m.impl[cur.command].apply(cur.that, cur.args);
}
},
clearEvents: function () {
$(this.map).find('area')
.unbind('.mapster');
$(this.images)
.unbind('.mapster');
},
_clearCanvases: function (preserveState) {
// remove the canvas elements created
if (!preserveState) {
$(this.base_canvas).remove();
}
$(this.overlay_canvas).remove();
},
clearMapData: function (preserveState) {
var me = this;
this._clearCanvases(preserveState);
// release refs to DOM elements
$.each(this.data, function (i, e) {
e.reset();
});
this.data = null;
if (!preserveState) {
// get rid of everything except the original image
this.image.style.cssText = this.imgCssText;
$(this.wrapper).before(this.image).remove();
}
me.images.clear();
this.image = null;
u.ifFunction(this.clearTooltip, this);
},
// Compelete cleanup process for deslecting items. Called after a batch operation, or by AreaData for single
// operations not flagged as "partial"
removeSelectionFinish: function () {
var g = this.graphics;
g.refreshSelections();
// do not call ensure_no_highlight- we don't really want to unhilight it, just remove the effect
g.clearHighlight();
}
};
}(jQuery));
/* areadata.js
AreaData and MapArea protoypes
*/
(function ($) {
var m = $.mapster, u = m.utils;
/**
* Select this area
*
* @param {AreaData} me AreaData context
* @param {object} options Options for rendering the selection
*/
function select(options) {
// need to add the new one first so that the double-opacity effect leaves the current one highlighted for singleSelect
var me = this, o = me.owner;
if (o.options.singleSelect) {
o.clearSelections();
}
// because areas can overlap - we can't depend on the selection state to tell us anything about the inner areas.
// don't check if it's already selected
if (!me.isSelected()) {
if (options) {
// cache the current options, and map the altImageId if an altimage
// was passed
me.optsCache = $.extend(me.effectiveRenderOptions('select'),
options,
{
altImageId: o.images.add(options.altImage)
});
}
me.drawSelection();
me.selected = true;
me.changeState('select', true);
}
if (o.options.singleSelect) {
o.graphics.refreshSelections();
}
}
/**
* Deselect this area, optionally deferring finalization so additional areas can be deselected
* in a single operation
*
* @param {boolean} partial when true, the caller must invoke "finishRemoveSelection" to render
*/
function deselect(partial) {
var me = this;
me.selected = false;
me.changeState('select', false);
// release information about last area options when deselecting.
me.optsCache = null;
me.owner.graphics.removeSelections(me.areaId);
// Complete selection removal process. This is separated because it's very inefficient to perform the whole
// process for multiple removals, as the canvas must be totally redrawn at the end of the process.ar.remove
if (!partial) {
me.owner.removeSelectionFinish();
}
}
/**
* Toggle the selection state of this area
* @param {object} options Rendering options, if toggling on
* @return {bool} The new selection state
*/
function toggle(options) {
var me = this;
if (!me.isSelected()) {
me.select(options);
}
else {
me.deselect();
}
return me.isSelected();
}
/**
* An AreaData object; represents a conceptual area that can be composed of
* one or more MapArea objects
*
* @param {MapData} owner The MapData object to which this belongs
* @param {string} key The key for this area
* @param {string} value The mapValue string for this area
*/
m.AreaData = function (owner, key, value) {
$.extend(this, {
owner: owner,
key: key || '',
// means this represents the first key in a list of keys (it's the area group that gets highlighted on mouseover)
isPrimary: true,
areaId: -1,
href: '',
value: value || '',
options: {},
// "null" means unchanged. Use "isSelected" method to just test true/false
selected: null,
// xref to MapArea objects
areasXref: [],
// (temporary storage) - the actual area moused over
area: null,
// the last options used to render this. Cache so when re-drawing after a remove, changes in options won't
// break already selected things.
optsCache: null
});
};
/**
* The public API for AreaData object
*/
m.AreaData.prototype = {
constuctor: m.AreaData,
select: select,
deselect: deselect,
toggle: toggle,
areas: function () {
var i, result = [];
for (i = 0; i < this.areasXref.length; i++) {
result.push(this.owner.mapAreas[this.areasXref[i]]);
}
return result;
},
// return all coordinates for all areas
coords: function (offset) {
var coords = [];
$.each(this.areas(), function (i, el) {
coords = coords.concat(el.coords(offset));
});
return coords;
},
reset: function () {
$.each(this.areas(), function (i, e) {
e.reset();
});
this.areasXref = [];
this.options = null;
},
// Return the effective selected state of an area, incorporating staticState
isSelectedOrStatic: function () {
var o = this.effectiveOptions();
return u.isBool(o.staticState) ? o.staticState :
this.isSelected();
},
isSelected: function () {
return u.isBool(this.selected) ? this.selected :
u.isBool(this.owner.area_options.selected) ? this.owner.area_options.selected : false;
},
isSelectable: function () {
return u.isBool(this.effectiveOptions().staticState) ? false :
(u.isBool(this.owner.options.staticState) ? false : u.boolOrDefault(this.effectiveOptions().isSelectable, true));
},
isDeselectable: function () {
return u.isBool(this.effectiveOptions().staticState) ? false :
(u.isBool(this.owner.options.staticState) ? false : u.boolOrDefault(this.effectiveOptions().isDeselectable, true));
},
isNotRendered: function () {
var area = $(this.area);
return area.attr('nohref') ||
!area.attr('href') ||
this.effectiveOptions().isMask;
},
/**
* Return the overall options effective for this area.
* This should get the default options, and merge in area-specific options, finally
* overlaying options passed by parameter
*
* @param {[type]} options options which will supercede all other options for this area
* @return {[type]} the combined options
*/
effectiveOptions: function (options) {
var opts = u.updateProps({},
this.owner.area_options,
this.options,
options || {},
{
id: this.areaId
}
);
opts.selected = this.isSelected();
return opts;
},
/**
* Return the options effective for this area for a "render" or "highlight" mode.
* This should get the default options, merge in the areas-specific options,
* and then the mode-specific options.
* @param {string} mode 'render' or 'highlight'
* @param {[type]} options options which will supercede all other options for this area
* @return {[type]} the combined options
*/
effectiveRenderOptions: function (mode, options) {
var allOpts, opts = this.optsCache;
if (!opts || mode === 'highlight') {
allOpts = this.effectiveOptions(options);
opts = u.updateProps({},
allOpts,
allOpts["render_" + mode]
);
if (mode !== 'highlight') {
this.optsCache = opts;
}
}
return $.extend({}, opts);
},
// Fire callback on area state change
changeState: function (state_type, state) {
if ($.isFunction(this.owner.options.onStateChange)) {
this.owner.options.onStateChange.call(this.owner.image,
{
key: this.key,
state: state_type,
selected: state
}
);
}
},
// highlight this area
highlight: function (options) {
var o = this.owner;
if (this.effectiveOptions().highlight) {
o.graphics.addShapeGroup(this, "highlight", options);
}
o.setHighlightId(this.areaId);
this.changeState('highlight', true);
},
// select this area. if "callEvent" is true then the state change event will be called. (This method can be used
// during config operations, in which case no event is indicated)
drawSelection: function () {
this.owner.graphics.addShapeGroup(this, "select");
}
};
// represents an HTML area
m.MapArea = function (owner, areaEl, keys) {
if (!owner) {
return;
}
var me = this;
me.owner = owner; // a MapData object
me.area = areaEl;
me.areaDataXref = []; // a list of map_data.data[] id's for each areaData object containing this
me.originalCoords = [];
$.each(u.split(areaEl.coords), function (i, el) {
me.originalCoords.push(parseFloat(el));
});
me.length = me.originalCoords.length;
me.shape = areaEl.shape.toLowerCase();
me.nohref = areaEl.nohref || !areaEl.href;
me.configure(keys);
};
m.MapArea.prototype = {
constructor: m.MapArea,
configure: function (keys) {
this.keys = u.split(keys);
},
reset: function () {
this.area = null;
},
coords: function (offset) {
return $.map(this.originalCoords, function (e) {
return offset ? e : e + offset;
});
}
};
}(jQuery));
/* areacorners.js
determine the best place to put a box of dimensions (width,height) given a circle, rect or poly
*/
(function ($) {
var u = $.mapster.utils;
/**
* Compute positions that will place a target with dimensions [width,height] outside
* but near the boundaries of the elements "elements". When an imagemap is passed, the
*
* @param {Element|Element[]} elements An element or an array of elements (such as a jQuery object)
* @param {Element} image The image to which area elements are bound, if this is an image map.
* @param {Element} container The contianer in which the target must be constrained (or document, if missing)
* @param {int} width The width of the target object
* @return {object} a structure with the x and y positions
*/
u.areaCorners = function (elements, image, container, width, height) {
var pos, found, minX, minY, maxX, maxY, bestMinX, bestMaxX, bestMinY, bestMaxY, curX, curY, nest, j,
offsetx = 0,
offsety = 0,
rootx,
rooty,
iCoords, radius, angle, el,
coords = [];
// if a single element was passed, map it to an array
elements = elements.length ?
elements :
[elements];
container = container ?
$(container) :
$(document.body);
// get the relative root of calculation
pos = container.offset();
rootx = pos.left;
rooty = pos.top;
// with areas, all we know about is relative to the top-left corner of the image. We need to add an offset compared to
// the actual container. After this calculation, offsetx/offsety can be added to either the area coords, or the target's
// absolute position to get the correct top/left boundaries of the container.
if (image) {
pos = $(image).offset();
offsetx = pos.left;
offsety = pos.top;
}
// map the coordinates of any type of shape to a poly and use the logic. simpler than using three different
// calculation methods. Circles use a 20 degree increment for this estimation.
for (j = 0; j < elements.length; j++) {
el = elements[j];
if (el.nodeName === 'AREA') {
iCoords = u.split(el.coords, parseInt);
switch (el.shape) {
case 'circle':
curX = iCoords[0];
curY = iCoords[1];
radius = iCoords[2];
coords = [];
for (j = 0; j < 360; j += 20) {
angle = j * Math.PI / 180;
coords.push(curX + radius * Math.cos(angle), curY + radius * Math.sin(angle));
}
break;
case 'rect':
coords.push(iCoords[0], iCoords[1], iCoords[2], iCoords[1], iCoords[2], iCoords[3], iCoords[0], iCoords[3]);
break;
default:
coords = coords.concat(iCoords);
break;
}
// map area positions to it's real position in the container
for (j = 0; j < coords.length; j += 2) {
coords[j] = parseInt(coords[j], 10) + offsetx;
coords[j + 1] = parseInt(coords[j + 1], 10) + offsety;
}
} else {
el = $(el);
pos = el.position();
coords.push(pos.left, pos.top,
pos.left + el.width(), pos.top,
pos.left + el.width(), pos.top + el.height(),
pos.left, pos.top + el.height());
}
}
minX = minY = bestMinX = bestMinY = 999999;
maxX = maxY = bestMaxX = bestMaxY = -1;
for (j = coords.length - 2; j >= 0; j -= 2) {
curX = coords[j];
curY = coords[j + 1];
if (curX < minX) {
minX = curX;
bestMaxY = curY;
}
if (curX > maxX) {
maxX = curX;
bestMinY = curY;
}
if (curY < minY) {
minY = curY;
bestMaxX = curX;
}
if (curY > maxY) {
maxY = curY;
bestMinX = curX;
}
}
// try to figure out the best place for the tooltip
if (width && height) {
found = false;
$.each([[bestMaxX - width, minY - height], [bestMinX, minY - height],
[minX - width, bestMaxY - height], [minX - width, bestMinY],
[maxX, bestMaxY - height], [maxX, bestMinY],
[bestMaxX - width, maxY], [bestMinX, maxY]
], function (i, e) {
if (!found && (e[0] > rootx && e[1] > rooty)) {
nest = e;
found = true;
return false;
}
});
// default to lower-right corner if nothing fit inside the boundaries of the image
if (!found) {
nest = [maxX, maxY];
}
}
return nest;
};
}(jQuery));
/* scale.js: resize and zoom functionality
requires areacorners.js, when.js
*/
(function ($) {
var m = $.mapster, u = m.utils, p = m.MapArea.prototype;
m.utils.getScaleInfo = function (eff, actual) {
var pct;
if (!actual) {
pct = 1;
actual = eff;
} else {
pct = eff.width / actual.width || eff.height / actual.height;
// make sure a float error doesn't muck us up
if (pct > 0.98 && pct < 1.02) { pct = 1; }
}
return {
scale: (pct !== 1),
scalePct: pct,
realWidth: actual.width,
realHeight: actual.height,
width: eff.width,
height: eff.height,
ratio: eff.width / eff.height
};
};
// Scale a set of AREAs, return old data as an array of objects
m.utils.scaleMap = function (image, imageRaw, scale) {
// stunningly, jQuery width can return zero even as width does not, seems to happen only
// with adBlock or maybe other plugins. These must interfere with onload events somehow.
var vis = u.size(image),
raw = u.size(imageRaw, true);
if (!raw.complete()) {
throw ("Another script, such as an extension, appears to be interfering with image loading. Please let us know about this.");
}
if (!vis.complete()) {
vis = raw;
}
return this.getScaleInfo(vis, scale ? raw : null);
};
/**
* Resize the image map. Only one of newWidth and newHeight should be passed to preserve scale
*
* @param {int} width The new width OR an object containing named parameters matching this function sig
* @param {int} height The new height
* @param {int} effectDuration Time in ms for the resize animation, or zero for no animation
* @param {function} callback A function to invoke when the operation finishes
* @return {promise} NOT YET IMPLEMENTED
*/
m.MapData.prototype.resize = function (width, height, duration, callback) {
var p, promises, newsize, els, highlightId, ratio,
me = this;
// allow omitting duration
callback = callback || duration;
function sizeCanvas(canvas, w, h) {
if (m.hasCanvas()) {
canvas.width = w;
canvas.height = h;
} else {
$(canvas).width(w);
$(canvas).height(h);
}
}
// Finalize resize action, do callback, pass control to command queue
function cleanupAndNotify() {
me.currentAction = '';
if ($.isFunction(callback)) {
callback();
}
me.processCommandQueue();
}
// handle cleanup after the inner elements are resized
function finishResize() {
sizeCanvas(me.overlay_canvas, width, height);
// restore highlight state if it was highlighted before
if (highlightId >= 0) {
var areaData = me.data[highlightId];
areaData.tempOptions = { fade: false };
me.getDataForKey(areaData.key).highlight();
areaData.tempOptions = null;
}
sizeCanvas(me.base_canvas, width, height);
me.redrawSelections();
cleanupAndNotify();
}
function resizeMapData() {
$(me.image).css(newsize);
// start calculation at the same time as effect
me.scaleInfo = u.getScaleInfo({
width: width,
height: height
},
{
width: me.scaleInfo.realWidth,
height: me.scaleInfo.realHeight
});
$.each(me.data, function (i, e) {
$.each(e.areas(), function (i, e) {
e.resize();
});
});
}
if (me.scaleInfo.width === width && me.scaleInfo.height === height) {
return;
}
highlightId = me.highlightId;
if (!width) {
ratio = height / me.scaleInfo.realHeight;
width = Math.round(me.scaleInfo.realWidth * ratio);
}
if (!height) {
ratio = width / me.scaleInfo.realWidth;
height = Math.round(me.scaleInfo.realHeight * ratio);
}
newsize = { 'width': String(width) + 'px', 'height': String(height) + 'px' };
if (!m.hasCanvas()) {
$(me.base_canvas).children().remove();
}
// resize all the elements that are part of the map except the image itself (which is not visible)
// but including the div wrapper
els = $(me.wrapper).find('.mapster_el').add(me.wrapper);
if (duration) {
promises = [];
me.currentAction = 'resizing';
els.each(function (i, e) {
p = u.defer();
promises.push(p);
$(e).animate(newsize, {
duration: duration,
complete: p.resolve,
easing: "linear"
});
});
p = u.defer();
promises.push(p);
// though resizeMapData is not async, it needs to be finished just the same as the animations,
// so add it to the "to do" list.
u.when.all(promises).then(finishResize);
resizeMapData();
p.resolve();
} else {
els.css(newsize);
resizeMapData();
finishResize();
}
};
m.MapArea = u.subclass(m.MapArea, function () {
//change the area tag data if needed
this.base.init();
if (this.owner.scaleInfo.scale) {
this.resize();
}
});
p.coords = function (percent, coordOffset) {
var j, newCoords = [],
pct = percent || this.owner.scaleInfo.scalePct,
offset = coordOffset || 0;
if (pct === 1 && coordOffset === 0) {
return this.originalCoords;
}
for (j = 0; j < this.length; j++) {
//amount = j % 2 === 0 ? xPct : yPct;
newCoords.push(Math.round(this.originalCoords[j] * pct) + offset);
}
return newCoords;
};
p.resize = function () {
this.area.coords = this.coords().join(',');
};
p.reset = function () {
this.area.coords = this.coords(1).join(',');
};
m.impl.resize = function (width, height, duration, callback) {
if (!width && !height) {
return false;
}
var x = (new m.Method(this,
function () {
this.resize(width, height, duration, callback);
},
null,
{
name: 'resize',
args: arguments
}
)).go();
return x;
};
/*
m.impl.zoom = function (key, opts) {
var options = opts || {};
function zoom(areaData) {
// this will be MapData object returned by Method
var scroll, corners, height, width, ratio,
diffX, diffY, ratioX, ratioY, offsetX, offsetY, newWidth, newHeight, scrollLeft, scrollTop,
padding = options.padding || 0,
scrollBarSize = areaData ? 20 : 0,
me = this,
zoomOut = false;
if (areaData) {
// save original state on first zoom operation
if (!me.zoomed) {
me.zoomed = true;
me.preZoomWidth = me.scaleInfo.width;
me.preZoomHeight = me.scaleInfo.height;
me.zoomedArea = areaData;
if (options.scroll) {
me.wrapper.css({ overflow: 'auto' });
}
}
corners = $.mapster.utils.areaCorners(areaData.coords(1, 0));
width = me.wrapper.innerWidth() - scrollBarSize - padding * 2;
height = me.wrapper.innerHeight() - scrollBarSize - padding * 2;
diffX = corners.maxX - corners.minX;
diffY = corners.maxY - corners.minY;
ratioX = width / diffX;
ratioY = height / diffY;
ratio = Math.min(ratioX, ratioY);
offsetX = (width - diffX * ratio) / 2;
offsetY = (height - diffY * ratio) / 2;
newWidth = me.scaleInfo.realWidth * ratio;
newHeight = me.scaleInfo.realHeight * ratio;
scrollLeft = (corners.minX) * ratio - padding - offsetX;
scrollTop = (corners.minY) * ratio - padding - offsetY;
} else {
if (!me.zoomed) {
return;
}
zoomOut = true;
newWidth = me.preZoomWidth;
newHeight = me.preZoomHeight;
scrollLeft = null;
scrollTop = null;
}
this.resize({
width: newWidth,
height: newHeight,
duration: options.duration,
scroll: scroll,
scrollLeft: scrollLeft,
scrollTop: scrollTop,
// closure so we can be sure values are correct
callback: (function () {
var isZoomOut = zoomOut,
scroll = options.scroll,
areaD = areaData;
return function () {
if (isZoomOut) {
me.preZoomWidth = null;
me.preZoomHeight = null;
me.zoomed = false;
me.zoomedArea = false;
if (scroll) {
me.wrapper.css({ overflow: 'inherit' });
}
} else {
// just to be sure it wasn't canceled & restarted
me.zoomedArea = areaD;
}
};
} ())
});
}
return (new m.Method(this,
function (opts) {
zoom.call(this);
},
function () {
zoom.call(this.owner, this);
},
{
name: 'zoom',
args: arguments,
first: true,
key: key
}
)).go();
};
*/
}(jQuery));
/* tooltip.js - tooltip functionality
requires areacorners.js
*/
(function ($) {
var m = $.mapster, u = m.utils;
$.extend(m.defaults, {
toolTipContainer: '<div style="border: 2px solid black; background: #EEEEEE; width:160px; padding:4px; margin: 4px; -moz-box-shadow: 3px 3px 5px #535353; ' +
'-webkit-box-shadow: 3px 3px 5px #535353; box-shadow: 3px 3px 5px #535353; -moz-border-radius: 6px 6px 6px 6px; -webkit-border-radius: 6px; ' +
'border-radius: 6px 6px 6px 6px; opacity: 0.9;"></dteniv>',
showToolTip: false,
toolTipFade: true,
toolTipClose: ['area-mouseout', 'image-mouseout'],
onShowToolTip: null,
onHideToolTip: null
});
$.extend(m.area_defaults, {
toolTip: null,
toolTipClose: null
});
/**
* Show a tooltip positioned near this area.
*
* @param {string|jquery} html A string of html or a jQuery object containing the tooltip content.
* @param {string|jquery} [template] The html template in which to wrap the content
* @param {string|object} [css] CSS to apply to the outermost element of the tooltip
* @return {jquery} The tooltip that was created
*/
function createToolTip(html, template, css) {
var tooltip;
// wrap the template in a jQuery object, or clone the template if it's already one.
// This assumes that anything other than a string is a jQuery object; if it's not jQuery will
// probably throw an error.
if (template) {
tooltip = typeof template === 'string' ?
$(template) :
$(template).clone();
tooltip.append(html);
} else {
tooltip = $(html);
}
// always set display to block, or the positioning css won't work if the end user happened to
// use a non-block type element.
tooltip.css($.extend((css || {}), {
display: "block",
position: "absolute"
})).hide();
$('body').append(tooltip);
// we must actually add the tooltip to the DOM and "show" it in order to figure out how much space it
// consumes, and then reposition it with that knowledge.
// We also cache the actual opacity setting to restore finally.
tooltip.attr("data-opacity", tooltip.css("opacity"))
.css("opacity", 0);
// doesn't really show it because opacity=0
return tooltip.show();
}
/**
* Show a tooltip positioned near this area.
*
* @param {jquery} tooltip The tooltip
* @param {object} [options] options for displaying the tooltip.
* @config {int} [left] The 0-based absolute x position for the tooltip
* @config {int} [top] The 0-based absolute y position for the tooltip
* @config {string|object} [css] CSS to apply to the outermost element of the tooltip
* @config {bool} [fadeDuration] When non-zero, the duration in milliseconds of a fade-in effect for the tooltip.
*/
function showToolTipImpl(tooltip, options) {
var tooltipCss = {
"left": options.left + "px",
"top": options.top + "px"
},
actalOpacity = tooltip.attr("data-opacity") || 0,
zindex = tooltip.css("z-index");
if (parseInt(zindex, 10) === 0
|| zindex === "auto") {
tooltipCss["z-index"] = 9999;
}
tooltip.css(tooltipCss)
.addClass('mapster_tooltip');
if (options.fadeDuration && options.fadeDuration > 0) {
u.fader(tooltip[0], 0, actalOpacity, options.fadeDuration);
} else {
u.setOpacity(tooltip[0], actalOpacity);
}
}
/**
* Hide and remove active tooltips
*
* @param {MapData} this The mapdata object to which the tooltips belong
*/
m.MapData.prototype.clearToolTip = function () {
if (this.activeToolTip) {
this.activeToolTip.stop().remove();
this.activeToolTip = null;
this.activeToolTipID = null;
u.ifFunction(this.options.onHideToolTip, this);
}
};
/**
* Configure the binding between a named tooltip closing option, and a mouse event.
*
* If a callback is passed, it will be called when the activating event occurs, and the tooltip will
* only closed if it returns true.
*
* @param {MapData} [this] The MapData object to which this tooltip belongs.
* @param {String} option The name of the tooltip closing option
* @param {String} event UI event to bind to this option
* @param {Element} target The DOM element that is the target of the event
* @param {Function} [beforeClose] Callback when the tooltip is closed
* @param {Function} [onClose] Callback when the tooltip is closed
*/
function bindToolTipClose(options, bindOption, event, target, beforeClose, onClose) {
var event_name = event + '.mapster-tooltip';
if ($.inArray(bindOption, options) >= 0) {
target.unbind(event_name)
.bind(event_name, function (e) {
if (!beforeClose || beforeClose.call(this, e)) {
target.unbind('.mapster-tooltip');
if (onClose) {
onClose.call(this);
}
}
});
return {
object: target,
event: event_name
};
}
}
/**
* Show a tooltip.
*
* @param {string|jquery} [tooltip] A string of html or a jQuery object containing the tooltip content.
*
* @param {string|jquery} [target] The target of the tooltip, to be used to determine positioning. If null,
* absolute position values must be passed with left and top.
*
* @param {string|jquery} [image] If target is an [area] the image that owns it
*
* @param {string|jquery} [container] An element within which the tooltip must be bounded
*
*
*
* @param {object|string|jQuery} [options] options to apply when creating this tooltip - OR -
* The markup, or a jquery object, containing the data for the tooltip
*
* @config {string} [closeEvents] A string with one or more comma-separated values that determine when the tooltip
* closes: 'area-click','tooltip-click','image-mouseout' are valid values
* then no template will be used.
* @config {int} [offsetx] the horizontal amount to offset the tooltip
* @config {int} [offsety] the vertical amount to offset the tooltip
* @config {string|object} [css] CSS to apply to the outermost element of the tooltip
*/
function showToolTip(tooltip, target, image, container, options) {
var corners,
ttopts = {};
options = options || {};
if (target) {
corners = u.areaCorners(target, image, container,
tooltip.outerWidth(true),
tooltip.outerHeight(true));
// Try to upper-left align it first, if that doesn't work, change the parameters
ttopts.left = corners[0];
ttopts.top = corners[1];
} else {
ttopts.left = options.left;
ttopts.top = options.top;
}
ttopts.left += (options.offsetx || 0);
ttopts.top += (options.offsety || 0);
ttopts.css = options.css;
ttopts.fadeDuration = options.fadeDuration;
showToolTipImpl(tooltip, ttopts);
return tooltip;
}
/**
* Show a tooltip positioned near this area.
*
* @param {string|jquery} [content] A string of html or a jQuery object containing the tooltip content.
* @param {object|string|jQuery} [options] options to apply when creating this tooltip - OR -
* The markup, or a jquery object, containing the data for the tooltip
* @config {string|jquery} [container] An element within which the tooltip must be bounded
* @config {bool} [template] a template to use instead of the default. If this property exists and is null,
* then no template will be used.
* @config {string} [closeEvents] A string with one or more comma-separated values that determine when the tooltip
* closes: 'area-click','tooltip-click','image-mouseout' are valid values
* then no template will be used.
* @config {int} [offsetx] the horizontal amount to offset the tooltip
* @config {int} [offsety] the vertical amount to offset the tooltip
* @config {string|object} [css] CSS to apply to the outermost element of the tooltip
*/
m.AreaData.prototype.showToolTip = function (content, options) {
var tooltip, closeOpts, target, tipClosed, template,
ttopts = {},
ad = this,
md = ad.owner,
areaOpts = ad.effectiveOptions();
// copy the options object so we can update it
options = options ? $.extend({}, options) : {};
content = content || areaOpts.toolTip;
closeOpts = options.closeEvents || areaOpts.toolTipClose || md.options.toolTipClose || 'tooltip-click';
template = typeof options.template !== 'undefined' ?
options.template :
md.options.toolTipContainer;
options.closeEvents = typeof closeOpts === 'string' ?
closeOpts = u.split(closeOpts) :
closeOpts;
options.fadeDuration = options.fadeDuration ||
(md.options.toolTipFade ?
(md.options.fadeDuration || areaOpts.fadeDuration) : 0);
target = ad.area ?
ad.area :
$.map(ad.areas(),
function (e) {
return e.area;
});
if (md.activeToolTipID === ad.areaId) {
return;
}
md.clearToolTip();
md.activeToolTip = tooltip = createToolTip(content,
template,
options.css);
md.activeToolTipID = ad.areaId;
tipClosed = function () {
md.clearToolTip();
};
bindToolTipClose(closeOpts, 'area-click', 'click', $(md.map), null, tipClosed);
bindToolTipClose(closeOpts, 'tooltip-click', 'click', tooltip, null, tipClosed);
bindToolTipClose(closeOpts, 'image-mouseout', 'mouseout', $(md.image), function (e) {
return (e.relatedTarget && e.relatedTarget.nodeName !== 'AREA' && e.relatedTarget !== ad.area);
}, tipClosed);
showToolTip(tooltip,
target,
md.image,
options.container,
template,
options);
u.ifFunction(md.options.onShowToolTip, ad.area,
{
toolTip: tooltip,
options: ttopts,
areaOptions: areaOpts,
key: ad.key,
selected: ad.isSelected()
});
return tooltip;
};
/**
* Parse an object that could be a string, a jquery object, or an object with a "contents" property
* containing html or a jQuery object.
*
* @param {object|string|jQuery} options The parameter to parse
* @return {string|jquery} A string or jquery object
*/
function getHtmlFromOptions(options) {
// see if any html was passed as either the options object itself, or the content property
return (options ?
((typeof options === 'string' || options.jquery) ?
options :
options.content) :
null);
}
/**
* Activate or remove a tooltip for an area. When this method is called on an area, the
* key parameter doesn't apply and "options" is the first parameter.
*
* When called with no parameters, or "key" is a falsy value, any active tooltip is cleared.
*
* When only a key is provided, the default tooltip for the area is used.
*
* When html is provided, this is used instead of the default tooltip.
*
* When "noTemplate" is true, the default tooltip template will not be used either, meaning only
* the actual html passed will be used.
*
* @param {string|AreaElement} key The area for which to activate a tooltip, or a DOM element.
*
* @param {object|string|jquery} [options] options to apply when creating this tooltip - OR -
* The markup, or a jquery object, containing the data for the tooltip
* @config {string|jQuery} [content] the inner content of the tooltip; the tooltip text or HTML
* @config {Element|jQuery} [container] the inner content of the tooltip; the tooltip text or HTML
* @config {bool} [template] a template to use instead of the default. If this property exists and is null,
* then no template will be used.
* @config {int} [offsetx] the horizontal amount to offset the tooltip.
* @config {int} [offsety] the vertical amount to offset the tooltip.
* @config {string|object} [css] CSS to apply to the outermost element of the tooltip
* @config {string|object} [css] CSS to apply to the outermost element of the tooltip
* @config {bool} [fadeDuration] When non-zero, the duration in milliseconds of a fade-in effect for the tooltip.
* @return {jQuery} The jQuery object
*/
m.impl.tooltip = function (key, options) {
return (new m.Method(this,
function mapData() {
var tooltip, target, md = this;
if (!key) {
md.clearToolTip();
} else {
target = $(key);
if (md.activeToolTipID === target[0]) {
return;
}
md.clearToolTip();
md.activeToolTip = tooltip = createToolTip(getHtmlFromOptions(options),
options.template || md.options.toolTipContainer,
options.css);
md.activeToolTipID = target[0];
bindToolTipClose(['tooltip-click'], 'tooltip-click', 'click', tooltip, null, function () {
md.clearToolTip();
});
md.activeToolTip = tooltip = showToolTip(tooltip,
target,
md.image,
options.container,
options);
}
},
function areaData() {
if ($.isPlainObject(key) && !options) {
options = key;
}
this.showToolTip(getHtmlFromOptions(options), options);
},
{
name: 'tooltip',
args: arguments,
key: key
}
)).go();
};
}(jQuery));
