| Current Path : /home1/savoy/public_html/savoyeducation.com/Backup23-11-16/assets/js/gallery/ |
Linux gator3171.hostgator.com 4.19.286-203.ELK.el7.x86_64 #1 SMP Wed Jun 14 04:33:55 CDT 2023 x86_64 |
| Current File : /home1/savoy/public_html/savoyeducation.com/Backup23-11-16/assets/js/gallery/jssor.utils.js |
/// <reference path="Jssor.Core.js" />
/*
* Jssor.Utils 17.0
* http://www.jssor.com/
*
* TERMS OF USE - Jssor.Utils
*
* Copyright 2014 Jssor
*
* 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.
*/
//$JssorPoint$
var $JssorPoint$;
(function () {
$JssorPoint$ = function (x, y) {
// Properties
this.x = typeof (x) == "number" ? x : 0;
this.y = typeof (y) == "number" ? y : 0;
};
// Methods
var SDPointPrototype = $JssorPoint$.prototype;
SDPointPrototype.$Plus = function (point) {
return new $JssorPoint$(this.x + point.x, this.y + point.y);
};
SDPointPrototype.$Minus = function (point) {
return new $JssorPoint$(this.x - point.x, this.y - point.y);
};
SDPointPrototype.$Times = function (factor) {
return new $JssorPoint$(this.x * factor, this.y * factor);
};
SDPointPrototype.$Divide = function (factor) {
return new $JssorPoint$(this.x / factor, this.y / factor);
};
SDPointPrototype.$Negate = function () {
return new $JssorPoint$(-this.x, -this.y);
};
SDPointPrototype.$DistanceTo = function (point) {
return Math.sqrt(Math.pow(this.x - point.x, 2) +
Math.pow(this.y - point.y, 2));
};
SDPointPrototype.$Apply = function (func) {
return new $JssorPoint$(func(this.x), func(this.y));
};
SDPointPrototype.$Equals = function (point) {
return (point instanceof $JssorPoint$) &&
(this.x === point.x) && (this.y === point.y);
};
SDPointPrototype.$ToString = function () {
return "(" + this.x + "," + this.y + ")";
};
})();
//$JssorEasing$
var $JssorEasing$ = window.$JssorEasing$ = {
$EaseLinear: function (t) {
return t;
},
$EaseGoBack: function (t) {
return 1 - Math.abs((t *= 2) - 1);
},
$EaseSwing: function (t) {
return -Math.cos(t * Math.PI) / 2 + .5;
},
$EaseInQuad: function (t) {
return t * t;
},
$EaseOutQuad: function (t) {
return -t * (t - 2);
},
$EaseInOutQuad: function (t) {
return (t *= 2) < 1 ? 1 / 2 * t * t : -1 / 2 * (--t * (t - 2) - 1);
},
$EaseInCubic: function (t) {
return t * t * t;
},
$EaseOutCubic: function (t) {
return (t -= 1) * t * t + 1;
},
$EaseInOutCubic: function (t) {
return (t *= 2) < 1 ? 1 / 2 * t * t * t : 1 / 2 * ((t -= 2) * t * t + 2);
},
$EaseInQuart: function (t) {
return t * t * t * t;
},
$EaseOutQuart: function (t) {
return -((t -= 1) * t * t * t - 1);
},
$EaseInOutQuart: function (t) {
return (t *= 2) < 1 ? 1 / 2 * t * t * t * t : -1 / 2 * ((t -= 2) * t * t * t - 2);
},
$EaseInQuint: function (t) {
return t * t * t * t * t;
},
$EaseOutQuint: function (t) {
return (t -= 1) * t * t * t * t + 1;
},
$EaseInOutQuint: function (t) {
return (t *= 2) < 1 ? 1 / 2 * t * t * t * t * t : 1 / 2 * ((t -= 2) * t * t * t * t + 2);
},
$EaseInSine: function (t) {
return 1 - Math.cos(t * Math.PI / 2)
},
$EaseOutSine: function (t) {
return Math.sin(t * Math.PI / 2);
},
$EaseInOutSine: function (t) {
return -1 / 2 * (Math.cos(Math.PI * t) - 1);
},
$EaseInExpo: function (t) {
return t == 0 ? 0 : Math.pow(2, 10 * (t - 1));
},
$EaseOutExpo: function (t) {
return t == 1 ? 1 : -Math.pow(2, -10 * t) + 1;
},
$EaseInOutExpo: function (t) {
return t == 0 || t == 1 ? t : (t *= 2) < 1 ? 1 / 2 * Math.pow(2, 10 * (t - 1)) : 1 / 2 * (-Math.pow(2, -10 * --t) + 2);
},
$EaseInCirc: function (t) {
return -(Math.sqrt(1 - t * t) - 1);
},
$EaseOutCirc: function (t) {
return Math.sqrt(1 - (t -= 1) * t);
},
$EaseInOutCirc: function (t) {
return (t *= 2) < 1 ? -1 / 2 * (Math.sqrt(1 - t * t) - 1) : 1 / 2 * (Math.sqrt(1 - (t -= 2) * t) + 1);
},
$EaseInElastic: function (t) {
if (!t || t == 1)
return t;
var p = .3, s = .075;
return -(Math.pow(2, 10 * (t -= 1)) * Math.sin((t - s) * 2 * Math.PI / p));
},
$EaseOutElastic: function (t) {
if (!t || t == 1)
return t;
var p = .3, s = .075;
return Math.pow(2, -10 * t) * Math.sin((t - s) * 2 * Math.PI / p) + 1;
},
$EaseInOutElastic: function (t) {
if (!t || t == 1)
return t;
var p = .45, s = .1125;
return (t *= 2) < 1 ? -.5 * Math.pow(2, 10 * (t -= 1)) * Math.sin((t - s) * 2 * Math.PI / p) : Math.pow(2, -10 * (t -= 1)) * Math.sin((t - s) * 2 * Math.PI / p) * .5 + 1;
},
$EaseInBack: function (t) {
var s = 1.70158;
return t * t * ((s + 1) * t - s);
},
$EaseOutBack: function (t) {
var s = 1.70158;
return (t -= 1) * t * ((s + 1) * t + s) + 1;
},
$EaseInOutBack: function (t) {
var s = 1.70158;
return (t *= 2) < 1 ? 1 / 2 * t * t * (((s *= 1.525) + 1) * t - s) : 1 / 2 * ((t -= 2) * t * (((s *= 1.525) + 1) * t + s) + 2);
},
$EaseInBounce: function (t) {
return 1 - $JssorEasing$.$EaseOutBounce(1 - t)
},
$EaseOutBounce: function (t) {
return t < 1 / 2.75 ? 7.5625 * t * t : t < 2 / 2.75 ? 7.5625 * (t -= 1.5 / 2.75) * t + .75 : t < 2.5 / 2.75 ? 7.5625 * (t -= 2.25 / 2.75) * t + .9375 : 7.5625 * (t -= 2.625 / 2.75) * t + .984375;
},
$EaseInOutBounce: function (t) {
return t < 1 / 2 ? $JssorEasing$.$EaseInBounce(t * 2) * .5 : $JssorEasing$.$EaseOutBounce(t * 2 - 1) * .5 + .5;
},
$EaseInWave: function (t) {
return 1 - Math.cos(t * Math.PI * 2)
},
$EaseOutWave: function (t) {
return Math.sin(t * Math.PI * 2);
},
$EaseOutJump: function (t) {
return 1 - (((t *= 2) < 1) ? (t = 1 - t) * t * t : (t -= 1) * t * t);
},
$EaseInJump: function (t) {
return ((t *= 2) < 1) ? t * t * t : (t = 2 - t) * t * t;
}
};
var $JssorDirection$ = window.$JssorDirection$ = {
$TO_LEFT: 0x0001,
$TO_RIGHT: 0x0002,
$TO_TOP: 0x0004,
$TO_BOTTOM: 0x0008,
$HORIZONTAL: 0x0003,
$VERTICAL: 0x000C,
$LEFTRIGHT: 0x0003,
$TOPBOTOM: 0x000C,
$TOPLEFT: 0x0005,
$TOPRIGHT: 0x0006,
$BOTTOMLEFT: 0x0009,
$BOTTOMRIGHT: 0x000A,
$AROUND: 0x000F,
$GetDirectionHorizontal: function (direction) {
return direction & 0x0003;
},
$GetDirectionVertical: function (direction) {
return direction & 0x000C;
},
$ChessHorizontal: function (direction) {
return (~direction & 0x0003) + (direction & 0x000C);
},
$ChessVertical: function (direction) {
return (~direction & 0x000C) + (direction & 0x0003);
},
$IsToLeft: function (direction) {
return (direction & 0x0003) == 0x0001;
},
$IsToRight: function (direction) {
return (direction & 0x0003) == 0x0002;
},
$IsToTop: function (direction) {
return (direction & 0x000C) == 0x0004;
},
$IsToBottom: function (direction) {
return (direction & 0x000C) == 0x0008;
},
$IsHorizontal: function (direction) {
return (direction & 0x0003) > 0;
},
$IsVertical: function (direction) {
return (direction & 0x000C) > 0;
}
};
var $JssorKeyCode$ = {
$BACKSPACE: 8,
$COMMA: 188,
$DELETE: 46,
$DOWN: 40,
$END: 35,
$ENTER: 13,
$ESCAPE: 27,
$HOME: 36,
$LEFT: 37,
$NUMPAD_ADD: 107,
$NUMPAD_DECIMAL: 110,
$NUMPAD_DIVIDE: 111,
$NUMPAD_ENTER: 108,
$NUMPAD_MULTIPLY: 106,
$NUMPAD_SUBTRACT: 109,
$PAGE_DOWN: 34,
$PAGE_UP: 33,
$PERIOD: 190,
$RIGHT: 39,
$SPACE: 32,
$TAB: 9,
$UP: 38
};
var $JssorAlignment$ = {
$TopLeft: 0x11,
$TopCenter: 0x12,
$TopRight: 0x14,
$MiddleLeft: 0x21,
$MiddleCenter: 0x22,
$MiddleRight: 0x24,
$BottomLeft: 0x41,
$BottomCenter: 0x42,
$BottomRight: 0x44,
$IsTop: function (aligment) {
return aligment & 0x10 > 0;
},
$IsMiddle: function (alignment) {
return alignment & 0x20 > 0;
},
$IsBottom: function (alignment) {
return alignment & 0x40 > 0;
},
$IsLeft: function (alignment) {
return alignment & 0x01 > 0;
},
$IsCenter: function (alignment) {
return alignment & 0x02 > 0;
},
$IsRight: function (alignment) {
return alignment & 0x04 > 0;
}
};
var $JssorMatrix$;
var $JssorBrowser$ = {
$UNKNOWN: 0,
$IE: 1,
$FIREFOX: 2,
$SAFARI: 3,
$CHROME: 4,
$OPERA: 5
};
var $ROWSER_UNKNOWN$ = 0;
var $ROWSER_IE$ = 1;
var $ROWSER_FIREFOX$ = 2;
var $ROWSER_SAFARI$ = 3;
var $ROWSER_CHROME$ = 4;
var $ROWSER_OPERA$ = 5;
var $JssorAnimator$;
// $JssorUtils$ is a static class, so make it singleton instance
var $JssorUtils$ = window.$JssorUtils$ = new function () {
// Fields
var self = this;
var arrActiveX = ["Msxml2.XMLHTTP", "Msxml3.XMLHTTP", "Microsoft.XMLHTTP"];
var supportedImageFormats = {
"bmp": false,
"jpeg": true,
"jpg": true,
"png": true,
"tif": false,
"wdp": false
};
var browser = $JssorBrowser$.$UNKNOWN;
var browserRuntimeVersion = 0;
var browserEngineVersion = 0;
var browserJavascriptVersion = 0;
var webkitVersion = 0;
var app = navigator.appName;
var ver = navigator.appVersion;
var ua = navigator.userAgent;
var urlParams = {};
function DetectBrowser() {
if (!browser) {
if (app == "Microsoft Internet Explorer" &&
!!window.attachEvent && !!window.ActiveXObject) {
var ieOffset = ua.indexOf("MSIE");
browser = $JssorBrowser$.$IE;
browserEngineVersion = parseFloat(ua.substring(ieOffset + 5, ua.indexOf(";", ieOffset)));
//check IE javascript version
/*@cc_on
browserJavascriptVersion = @_jscript_version;
@*/
// update: for intranet sites and compat view list sites, IE sends
// an IE7 User-Agent to the server to be interoperable, and even if
// the page requests a later IE version, IE will still report the
// IE7 UA to JS. we should be robust to self.
//var docMode = document.documentMode;
//if (typeof docMode !== "undefined") {
// browserRuntimeVersion = docMode;
//}
browserRuntimeVersion = document.documentMode || browserEngineVersion;
}
else if (app == "Netscape" && !!window.addEventListener) {
var ffOffset = ua.indexOf("Firefox");
var saOffset = ua.indexOf("Safari");
var chOffset = ua.indexOf("Chrome");
var webkitOffset = ua.indexOf("AppleWebKit");
if (ffOffset >= 0) {
browser = $JssorBrowser$.$FIREFOX;
browserRuntimeVersion = parseFloat(ua.substring(ffOffset + 8));
}
else if (saOffset >= 0) {
var slash = ua.substring(0, saOffset).lastIndexOf("/");
browser = (chOffset >= 0) ? $JssorBrowser$.$CHROME : $JssorBrowser$.$SAFARI;
browserRuntimeVersion = parseFloat(ua.substring(slash + 1, saOffset));
}
if (webkitOffset >= 0)
webkitVersion = parseFloat(ua.substring(webkitOffset + 12));
}
else {
var match = /(opera)(?:.*version|)[ \/]([\w.]+)/i.exec(ua);
if (match) {
browser = $JssorBrowser$.$OPERA;
browserRuntimeVersion = parseFloat(match[2]);
}
}
}
}
function IsBrowserIE() {
DetectBrowser();
return browser == $ROWSER_IE$;
}
function IsBrowserIeQuirks() {
return IsBrowserIE() && (browserRuntimeVersion < 6 || document.compatMode == "BackCompat"); //Composite to "CSS1Compat"
}
function IsBrowserFireFox() {
DetectBrowser();
return browser == $ROWSER_FIREFOX$;
}
function IsBrowserSafari() {
DetectBrowser();
return browser == $ROWSER_SAFARI$;
}
function IsBrowserChrome() {
DetectBrowser();
return browser == $ROWSER_CHROME$;
}
function IsBrowserOpera() {
DetectBrowser();
return browser == $ROWSER_OPERA$;
}
function IsBrowserBadTransform() {
return IsBrowserSafari() && (webkitVersion > 534) && (webkitVersion < 535);
}
function IsBrowserSafeHWA() {
return IsBrowserSafari() && (webkitVersion < 535);
}
function IsBrowserIe9Earlier() {
//IE 8- and chrome 1 won't fade well
return IsBrowserIE() && browserRuntimeVersion < 9; // || (IsBrowserChrome() && browserRuntimeVersion < 2);
}
var _TransformProperty;
function GetTransformProperty(elmt) {
if (!_TransformProperty) {
// Note that in some versions of IE9 it is critical that
// msTransform appear in this list before MozTransform
each(['transform', 'WebkitTransform', 'msTransform', 'MozTransform', 'OTransform'], function (property) {
if (!self.$IsUndefined(elmt.style[property])) {
_TransformProperty = property;
return true;
}
});
_TransformProperty = _TransformProperty || "transform";
}
return _TransformProperty;
}
// Constructor
{
//Ignore urlParams
// // Url parameters
// var query = window.location.search.substring(1); // ignore '?'
// var parts = query.split('&');
// for (var i = 0; i < parts.length; i++) {
// var part = parts[i];
// var sep = part.indexOf('=');
// if (sep > 0) {
// urlParams[part.substring(0, sep)] =
// decodeURIComponent(part.substring(sep + 1));
// }
// }
// Browser behaviors
}
// Helpers
function getOffsetParent(elmt, isFixed) {
// IE and Opera "fixed" position elements don't have offset parents.
// regardless, if it's fixed, its offset parent is the body.
if (isFixed && elmt != document.body) {
return document.body;
} else {
return elmt.offsetParent;
}
}
function toString(obj) {
return Object.prototype.toString.call(obj);
}
// [[Class]] -> type pairs
var class2type;
function each(object, callback) {
if (toString(object) == "[object Array]") {
for (var i = 0; i < object.length; i++) {
if (callback(object[i], i, object)) {
break;
}
}
} else {
for (var name in object) {
if (callback(object[name], name, object)) {
break;
}
}
}
}
function GetClass2Type() {
if (!class2type) {
class2type = {};
each(["Boolean", "Number", "String", "Function", "Array", "Date", "RegExp", "Object"], function (name) {
class2type["[object " + name + "]"] = name.toLowerCase();
});
}
return class2type;
}
function type(obj) {
return obj == null ? String(obj) : GetClass2Type()[toString(obj)] || "object";
}
function isPlainObject(obj) {
// Must be an Object.
// Because of IE, we also have to check the presence of the constructor property.
// Make sure that DOM nodes and window objects don't pass through, as well
if (!obj || type(obj) !== "object" || obj.nodeType || self.$IsWindow(obj)) {
return false;
}
var hasOwn = Object.prototype.hasOwnProperty;
try {
// Not own constructor property must be Object
if (obj.constructor &&
!hasOwn.call(obj, "constructor") &&
!hasOwn.call(obj.constructor.prototype, "isPrototypeOf")) {
return false;
}
} catch (e) {
// IE8,9 Will throw exceptions on certain host objects #9897
return false;
}
// Own properties are enumerated firstly, so to speed up,
// if last one is own, then all properties are own.
var key;
for (key in obj) { }
return key === undefined || hasOwn.call(obj, key);
}
function Delay(code, delay) {
setTimeout(code, delay || 0);
}
function RemoveByReg(str, reg) {
var m = reg.exec(str);
if (m) {
var header = str.substr(0, m.index);
var tailer = str.substr(m.lastIndex + 1, str.length - (m.lastIndex + 1));
str = header + tailer;
}
return str;
}
function BuildNewCss(oldCss, removeRegs, replaceValue) {
var css = (!oldCss || oldCss == "inherit") ? "" : oldCss;
each(removeRegs, function (removeReg) {
var m = removeReg.exec(css);
if (m) {
var header = css.substr(0, m.index);
var tailer = css.substr(m.lastIndex + 1, css.length - (m.lastIndex + 1));
css = header + tailer;
}
});
css = replaceValue + (css.indexOf(" ") != 0 ? " " : "") + css;
return css;
}
function SetStyleFilterIE(elmt, value) {
if (browserRuntimeVersion < 9) {
elmt.style.filter = value;
}
}
function SetStyleMatrixIE(elmt, matrix, offset) {
//matrix is not for ie9+ running in ie8- mode
if (browserJavascriptVersion < 9) {
var oldFilterValue = elmt.style.filter;
var matrixReg = new RegExp(/[\s]*progid:DXImageTransform\.Microsoft\.Matrix\([^\)]*\)/g);
var matrixValue = matrix ? "progid:DXImageTransform.Microsoft.Matrix(" + "M11=" + matrix[0][0] + ", M12=" + matrix[0][1] + ", M21=" + matrix[1][0] + ", M22=" + matrix[1][1] + ", SizingMethod='auto expand')" : "";
var newFilterValue = BuildNewCss(oldFilterValue, [matrixReg], matrixValue);
SetStyleFilterIE(elmt, newFilterValue);
self.$CssMarginTop(elmt, offset.y);
self.$CssMarginLeft(elmt, offset.x);
}
}
// Methods
self.$IsBrowserIE = IsBrowserIE;
self.$IsBrowserIeQuirks = IsBrowserIeQuirks;
self.$IsBrowserFireFox = IsBrowserFireFox;
self.$IsBrowserSafari = IsBrowserSafari;
self.$IsBrowserChrome = IsBrowserChrome;
self.$IsBrowserOpera = IsBrowserOpera;
self.$IsBrowserBadTransform = IsBrowserBadTransform;
self.$IsBrowserSafeHWA = IsBrowserSafeHWA;
self.$IsBrowserIe9Earlier = IsBrowserIe9Earlier;
self.$GetBrowserVersion = function () {
return browserRuntimeVersion;
};
self.$GetBrowserEngineVersion = function () {
return browserEngineVersion || browserRuntimeVersion;
};
self.$GetWebKitVersion = function () {
return webkitVersion;
};
self.$Delay = Delay;
self.$GetElement = function (elmt) {
if (self.$IsString(elmt)) {
elmt = document.getElementById(elmt);
}
return elmt;
};
self.$GetElementPosition = function (elmt) {
elmt = self.$GetElement(elmt);
var result = new $JssorPoint$();
// technique from:
// http://www.quirksmode.org/js/findpos.html
// with special check for "fixed" elements.
while (elmt) {
result.x += elmt.offsetLeft;
result.y += elmt.offsetTop;
var isFixed = self.$GetElementStyle(elmt).position == "fixed";
if (isFixed) {
result = result.$Plus(self.$GetPageScroll(window));
}
elmt = getOffsetParent(elmt, isFixed);
}
return result;
};
self.$GetElementSize = function (elmt) {
elmt = self.$GetElement(elmt);
return new $JssorPoint$(elmt.clientWidth, elmt.clientHeight);
};
self.$GetEvent = function (event) {
return event ? event : window.event;
};
self.$GetEventSrcElement = function (event) {
event = self.$GetEvent(event);
return event.target || event.srcElement || document;
};
self.$GetEventDstElement = function (event) {
event = self.$GetEvent(event);
return event.relatedTarget || event.toElement;
};
self.$GetMousePosition = function (event) {
event = self.$GetEvent(event);
var result = new $JssorPoint$();
// technique from:
// http://www.quirksmode.org/js/events_properties.html
if (event.type == "DOMMouseScroll" &&
IsBrowserFireFox() && browserRuntimeVersion < 3) {
// hack for FF2 which reports incorrect position for mouse scroll
result.x = event.screenX;
result.y = event.screenY;
} else if (typeof (event.pageX) == "number") {
result.x = event.pageX;
result.y = event.pageY;
} else if (typeof (event.clientX) == "number") {
result.x = event.clientX + document.body.scrollLeft + document.documentElement.scrollLeft;
result.y = event.clientY + document.body.scrollTop + document.documentElement.scrollTop;
} else {
$JssorDebug$.$Fail("Unknown event mouse position, no known technique.");
}
return result;
};
self.$GetMouseScroll = function (event) {
event = self.$GetEvent(event);
var delta = 0; // default value
// technique from:
// http://blog.paranoidferret.com/index.php/2007/10/31/javascript-tutorial-the-scroll-wheel/
if (typeof (event.wheelDelta) == "number") {
delta = event.wheelDelta;
} else if (typeof (event.detail) == "number") {
delta = event.detail * -1;
} else {
$JssorDebug$.$Fail("Unknown event mouse scroll, no known technique.");
}
// normalize value to [-1, 1]
return delta ? delta / Math.abs(delta) : 0;
};
self.$GetPageScroll = function (window) {
var result = new $JssorPoint$();
var docElmt = window.document.documentElement || {};
var body = window.document.body || {};
// technique from:
// http://www.howtocreate.co.uk/tutorials/javascript/browserwindow
if (typeof (window.pageXOffset) == "number") {
// most browsers
result.x = window.pageXOffset;
result.y = window.pageYOffset;
} else if (body.scrollLeft || body.scrollTop) {
// W3C spec, IE6+ in quirks mode
result.x = body.scrollLeft;
result.y = body.scrollTop;
} else if (docElmt.scrollLeft || docElmt.scrollTop) {
// IE6+ in standards mode
result.x = docElmt.scrollLeft;
result.y = docElmt.scrollTop;
}
// note: we specifically aren't testing for typeof here, because IE sets
// the appropriate variables undefined instead of 0 under certain
// conditions. self means we also shouldn't fail if none of the three
// cases are hit; we'll just assume the page scroll is 0.
return result;
};
self.$GetWindowSize = function (window) {
var result = new $JssorPoint$();
// technique from:
// http://www.howtocreate.co.uk/tutorials/javascript/browserwindow
//jQuery way to get window size, but support ie quirks mode
var checkElement = (IsBrowserIeQuirks() ? window.document.body : window.document.documentElement);
result.x = checkElement.clientWidth;
result.y = checkElement.clientHeight;
return result;
};
//self.$MakeAjaxRequest = function (url, callback) {
// var async = typeof (callback) == "function";
// var req = null;
// if (async) {
// var actual = callback;
// var callback = function () {
// Delay($JssorUtils$.$CreateCallback(null, actual, req), 1);
// };
// }
// if (window.ActiveXObject) {
// for (var i = 0; i < arrActiveX.length; i++) {
// try {
// req = new ActiveXObject(arrActiveX[i]);
// break;
// } catch (e) {
// continue;
// }
// }
// } else if (window.XMLHttpRequest) {
// req = new XMLHttpRequest();
// }
// if (!req) {
// $JssorDebug$.$Fail("Browser doesn't support XMLHttpRequest.");
// }
// if (async) {
// req.onreadystatechange = function () {
// if (req.readyState == 4) {
// // prevent memory leaks by breaking circular reference now
// req.onreadystatechange = new Function();
// callback();
// }
// };
// }
// try {
// req.open("GET", url, async);
// req.send(null);
// } catch (e) {
// $JssorDebug$.$Log(e.name + " while making AJAX request: " + e.message);
// req.onreadystatechange = null;
// req = null;
// if (async) {
// callback();
// }
// }
// return async ? null : req;
//};
//self.$ParseXml = function (string) {
// var xmlDoc = null;
// if (window.ActiveXObject) {
// try {
// xmlDoc = new ActiveXObject("Microsoft.XMLDOM");
// xmlDoc.async = false;
// xmlDoc.loadXML(string);
// } catch (e) {
// $JssorDebug$.$Log(e.name + " while parsing XML (ActiveX): " + e.message);
// }
// } else if (window.DOMParser) {
// try {
// var parser = new DOMParser();
// xmlDoc = parser.parseFromString(string, "text/xml");
// } catch (e) {
// $JssorDebug$.$Log(e.name + " while parsing XML (DOMParser): " + e.message);
// }
// } else {
// $JssorDebug$.$Fail("Browser doesn't support XML DOM.");
// }
// return xmlDoc;
//};
function Css(elmt, name, value) {
/// <summary>
/// access css
/// $JssorUtils$.$Css(elmt, name); //get css value
/// $JssorUtils$.$Css(elmt, name, value); //set css value
/// </summary>
/// <param name="elmt" type="HTMLElement">
/// the element to access css
/// </param>
/// <param name="name" type="String">
/// the name of css property
/// </param>
/// <param name="value" type="Number" optional="true">
/// the value to set
/// </param>
if (value != undefined) {
elmt.style[name] = value;
}
else {
var style = elmt.currentStyle || elmt.style;
value = style[name];
if(value == "" && window.getComputedStyle) {
style = elmt.ownerDocument.defaultView.getComputedStyle(elmt, null);
style && (value = style.getPropertyValue(name) || style[name]);
}
return value;
}
}
function CssN(elmt, name, value, isDimensional) {
/// <summary>
/// access css as numeric
/// $JssorUtils$.$CssN(elmt, name); //get css value
/// $JssorUtils$.$CssN(elmt, name, value); //set css value
/// </summary>
/// <param name="elmt" type="HTMLElement">
/// the element to access css
/// </param>
/// <param name="name" type="String">
/// the name of css property
/// </param>
/// <param name="value" type="Number" optional="true">
/// the value to set
/// </param>
if (value != undefined) {
isDimensional && (value += "px");
Css(elmt, name, value);
}
else {
return parseFloat(Css(elmt, name));
}
}
function CssP(elmt, name, value) {
/// <summary>
/// access css in pixel as numeric, like 'top', 'left', 'width', 'height'
/// $JssorUtils$.$CssP(elmt, name); //get css value
/// $JssorUtils$.$CssP(elmt, name, value); //set css value
/// </summary>
/// <param name="elmt" type="HTMLElement">
/// the element to access css
/// </param>
/// <param name="name" type="String">
/// the name of css property
/// </param>
/// <param name="value" type="Number" optional="true">
/// the value to set
/// </param>
return CssN(elmt, name, value, true);
}
function CssProxy(name, numericOrDimension) {
/// <summary>
/// create proxy to access css, CssProxy(name[, numericOrDimension]);
/// </summary>
/// <param name="elmt" type="HTMLElement">
/// the element to access css
/// </param>
/// <param name="numericOrDimension" type="Number" optional="true">
/// not set: access original css, 1: access css as numeric, 2: access css in pixel as numeric
/// </param>
var isDimensional = numericOrDimension & 2;
var cssAccessor = numericOrDimension ? CssN : Css;
return function (elmt, value) {
return cssAccessor(elmt, name, value, isDimensional);
};
}
function GetStyleOpacity(elmt) {
if (IsBrowserIE() && browserEngineVersion < 9) {
var match = /opacity=([^)]*)/.exec(elmt.style.filter || "");
return match ? (parseFloat(match[1]) / 100) : 1;
}
else
return parseFloat(elmt.style.opacity || "1");
}
function SetStyleOpacity(elmt, opacity, ie9EarlierForce) {
if (IsBrowserIE() && browserEngineVersion < 9) {
//var filterName = "filter"; // browserEngineVersion < 8 ? "filter" : "-ms-filter";
var finalFilter = elmt.style.filter || "";
// for CSS filter browsers (IE), remove alpha filter if it's unnecessary.
// update: doing self always since IE9 beta seems to have broken the
// behavior if we rely on the programmatic filters collection.
var alphaReg = new RegExp(/[\s]*alpha\([^\)]*\)/g);
// important: note the lazy star! self protects against
// multiple filters; we don't want to delete the other ones.
// update: also trimming extra whitespace around filter.
var ieOpacity = Math.round(100 * opacity);
var alphaFilter = "";
if (ieOpacity < 100 || ie9EarlierForce) {
alphaFilter = "alpha(opacity=" + ieOpacity + ") ";
//elmt.style["-ms-filter"] = "progid:DXImageTransform.Microsoft.Alpha(opacity=" + ieOpacity + ") ";
}
var newFilterValue = BuildNewCss(finalFilter, [alphaReg], alphaFilter);
SetStyleFilterIE(elmt, newFilterValue);
}
//if (!IsBrowserIE() || browserEngineVersion >= 9)
else {
elmt.style.opacity = opacity == 1 ? "" : Math.round(opacity * 100) / 100;
}
}
function SetStyleTransformInternal(elmt, transform) {
var rotate = transform.$Rotate || 0;
var scale = transform.$Scale || 1;
if (IsBrowserIe9Earlier()) {
var matrix = self.$CreateMatrix(rotate / 180 * Math.PI, scale, scale);
SetStyleMatrixIE(elmt, (!rotate && scale == 1) ? null : matrix, self.$GetMatrixOffset(matrix, transform.$OriginalWidth, transform.$OriginalHeight));
}
else {
//rotate(15deg) scale(.5) translateZ(0)
var transformProperty = GetTransformProperty(elmt);
if (transformProperty) {
var transformValue = "rotate(" + rotate % 360 + "deg) scale(" + scale + ")";
if ($JssorUtils$.$IsBrowserChrome() && webkitVersion > 535)
transformValue += " perspective(2000px)";
elmt.style[transformProperty] = transformValue;
}
}
}
self.$SetStyleTransform = function (elmt, transform) {
if (IsBrowserBadTransform()) {
Delay(self.$CreateCallback(null, SetStyleTransformInternal, elmt, transform));
}
else {
SetStyleTransformInternal(elmt, transform);
}
};
self.$SetStyleTransformOrigin = function (elmt, transformOrigin) {
var transformProperty = GetTransformProperty(elmt);
if (transformProperty)
elmt.style[transformProperty + "Origin"] = transformOrigin;
};
self.$SetStyleScale = function (elmt, scale) {
if (IsBrowserIE() && browserEngineVersion < 9 || (browserEngineVersion < 10 && IsBrowserIeQuirks())) {
elmt.style.zoom = (scale == 1) ? "" : scale;
}
else {
var transformProperty = GetTransformProperty(elmt);
if (transformProperty) {
//rotate(15deg) scale(.5)
var transformValue = "scale(" + scale + ")";
var oldTransformValue = elmt.style[transformProperty];
var scaleReg = new RegExp(/[\s]*scale\(.*?\)/g);
var newTransformValue = BuildNewCss(oldTransformValue, [scaleReg], transformValue);
elmt.style[transformProperty] = newTransformValue;
}
}
};
self.$EnableHWA = function (elmt) {
if (!elmt.style[GetTransformProperty(elmt)] || elmt.style[GetTransformProperty(elmt)] == "none")
elmt.style[GetTransformProperty(elmt)] = "perspective(2000px)";
};
self.$DisableHWA = function (elmt) {
//if (force || elmt.style[GetTransformProperty(elmt)] == "perspective(2000px)")
elmt.style[GetTransformProperty(elmt)] = "none";
};
var ie8OffsetWidth = 0;
var ie8OffsetHeight = 0;
var ie8WindowResizeCallbackHandlers;
//var ie8LastVerticalScrollbar;
//var toggleInfo = "";
function Ie8WindowResizeFilter(window) {
var trigger = true;
var checkElement = (IsBrowserIeQuirks() ? window.document.body : window.document.documentElement);
if (checkElement) {
//check vertical bar
//var hasVerticalBar = checkElement.scrollHeight > checkElement.clientHeight;
//var verticalBarToggle = hasVerticalBar != ie8LastVerticalScrollbar;
//ie8LastVerticalScrollbar = hasVerticalBar;
var widthChange = checkElement.offsetWidth - ie8OffsetWidth;
var heightChange = checkElement.offsetHeight - ie8OffsetHeight;
if (widthChange || heightChange) {
ie8OffsetWidth += widthChange;
ie8OffsetHeight += heightChange;
}
else
trigger = false;
}
trigger && each(ie8WindowResizeCallbackHandlers, function (handler) {
handler();
});
}
self.$OnWindowResize = function (window, handler) {
if (IsBrowserIE() && browserEngineVersion < 9) {
if (!ie8WindowResizeCallbackHandlers) {
ie8WindowResizeCallbackHandlers = [handler];
handler = self.$CreateCallback(null, Ie8WindowResizeFilter, window);
}
else {
ie8WindowResizeCallbackHandlers.push(handler);
return;
}
}
self.$AddEvent(window, "resize", handler);
};
self.$AddEvent = function (elmt, eventName, handler, useCapture) {
elmt = self.$GetElement(elmt);
// technique from:
// http://blog.paranoidferret.com/index.php/2007/08/10/javascript-working-with-events/
if (elmt.addEventListener) {
if (eventName == "mousewheel") {
elmt.addEventListener("DOMMouseScroll", handler, useCapture);
}
// we are still going to add the mousewheel -- not a mistake!
// self is for opera, since it uses onmousewheel but needs addEventListener.
elmt.addEventListener(eventName, handler, useCapture);
}
else if (elmt.attachEvent) {
elmt.attachEvent("on" + eventName, handler);
if (useCapture && elmt.setCapture) {
elmt.setCapture();
}
}
$JssorDebug$.$Execute(function () {
if (!elmt.addEventListener && !elmt.attachEvent) {
$JssorDebug$.$Fail("Unable to attach event handler, no known technique.");
}
});
};
self.$RemoveEvent = function (elmt, eventName, handler, useCapture) {
elmt = self.$GetElement(elmt);
// technique from:
// http://blog.paranoidferret.com/index.php/2007/08/10/javascript-working-with-events/
if (elmt.removeEventListener) {
if (eventName == "mousewheel") {
elmt.removeEventListener("DOMMouseScroll", handler, useCapture);
}
// we are still going to remove the mousewheel -- not a mistake!
// self is for opera, since it uses onmousewheel but needs removeEventListener.
elmt.removeEventListener(eventName, handler, useCapture);
}
else if (elmt.detachEvent) {
elmt.detachEvent("on" + eventName, handler);
if (useCapture && elmt.releaseCapture) {
elmt.releaseCapture();
}
}
$JssorDebug$.$Execute(function () {
if (!elmt.removeEventListener && !elmt.detachEvent) {
$JssorDebug$.$Fail("Unable to detach event handler, no known technique.");
}
});
};
self.$FireEvent = function (elmt, eventName) {
//var document = elmt.document;
$JssorDebug$.$Execute(function () {
if (!document.createEvent && !document.createEventObject) {
$JssorDebug$.$Fail("Unable to fire event, no known technique.");
}
if (!elmt.dispatchEvent && !elmt.fireEvent) {
$JssorDebug$.$Fail("Unable to fire event, no known technique.");
}
});
var evento;
if (document.createEvent) {
evento = document.createEvent("HTMLEvents");
evento.initEvent(eventName, false, false);
elmt.dispatchEvent(evento);
}
else {
var ieEventName = "on" + eventName;
evento = document.createEventObject();
//event.eventType = ieEventName;
//event.eventName = ieEventName;
elmt.fireEvent(ieEventName, evento);
}
};
self.$AddEventBrowserMouseUp = function (handler, userCapture) {
self.$AddEvent((IsBrowserIe9Earlier()) ? document : window, "mouseup", handler, userCapture);
};
self.$RemoveEventBrowserMouseUp = function (handler, userCapture) {
self.$RemoveEvent((IsBrowserIe9Earlier()) ? document : window, "mouseup", handler, userCapture);
};
self.$AddEventBrowserMouseDown = function (handler, userCapture) {
self.$AddEvent((IsBrowserIe9Earlier()) ? document : window, "mousedown", handler, userCapture);
};
self.$RemoveEventBrowserMouseDown = function (handler, userCapture) {
self.$RemoveEvent((IsBrowserIe9Earlier()) ? document : window, "mousedown", handler, userCapture);
};
self.$CancelEvent = function (event) {
event = self.$GetEvent(event);
// technique from:
// http://blog.paranoidferret.com/index.php/2007/08/10/javascript-working-with-events/
if (event.preventDefault) {
event.preventDefault(); // W3C for preventing default
}
event.cancel = true; // legacy for preventing default
event.returnValue = false; // IE for preventing default
};
self.$StopEvent = function (event) {
event = self.$GetEvent(event);
// technique from:
// http://blog.paranoidferret.com/index.php/2007/08/10/javascript-working-with-events/
if (event.stopPropagation) {
event.stopPropagation(); // W3C for stopping propagation
}
event.cancelBubble = true; // IE for stopping propagation
};
self.$CreateCallback = function (object, method) {
// create callback args
var initialArgs = [];
for (var i = 2; i < arguments.length; i++) {
initialArgs.push(arguments[i]);
}
// create closure to apply method
var callback = function () {
// concatenate new args, but make a copy of initialArgs first
var args = initialArgs.concat([]);
for (var i = 0; i < arguments.length; i++) {
args.push(arguments[i]);
}
return method.apply(object, args);
};
$JssorDebug$.$LiveStamp(callback, "callback_" + ($JssorUtils$.$GetNow() & 11111111));
return callback;
};
var _Freeer;
self.$FreeElement = function (elmt) {
if (!_Freeer)
_Freeer = self.$CreateDivElement();
if (elmt) {
$JssorUtils$.$AppendChild(_Freeer, elmt);
$JssorUtils$.$ClearInnerHtml(_Freeer);
}
};
self.$SetInnerText = function (elmt, text) {
var textNode = document.createTextNode(text);
self.$ClearInnerHtml(elmt);
elmt.appendChild(textNode);
};
self.$GetInnerText = function (elmt) {
return elmt.textContent || elmt.innerText;
};
self.$GetInnerHtml = function (elmt) {
return elmt.innerHTML;
};
self.$SetInnerHtml = function (elmt, html) {
elmt.innerHTML = html;
};
self.$ClearInnerHtml = function (elmt) {
elmt.innerHTML = "";
};
self.$EncodeHtml = function (text) {
var div = self.$CreateDivElement();
self.$SetInnerText(div, text);
return self.$GetInnerHtml(div);
};
self.$DecodeHtml = function (html) {
var div = self.$CreateDivElement();
self.$SetInnerHtml(div, html);
return self.$GetInnerText(div);
};
self.$SelectElement = function (elmt) {
var userSelection;
if (window.getSelection) {
//W3C default
userSelection = window.getSelection();
}
var theRange = null;
if (document.createRange) {
theRange = document.createRange();
theRange.selectNode(elmt);
}
else {
theRange = document.body.createTextRange();
theRange.moveToElementText(elmt);
theRange.select();
}
//set user selection
if (userSelection)
userSelection.addRange(theRange);
};
self.$DeselectElements = function () {
if (document.selection) {
document.selection.empty();
} else if (window.getSelection) {
window.getSelection().removeAllRanges();
}
};
self.$GetChildren = function (elmt) {
var children = [];
for (var tmpEl = elmt.firstChild; tmpEl; tmpEl = tmpEl.nextSibling) {
if (tmpEl.nodeType == 1) {
children.push(tmpEl);
}
}
return children;
};
function FindFirstChildByAttribute(elmt, attrValue, attrName, deep) {
if (!attrName)
attrName = "u";
for (elmt = elmt ? elmt.firstChild : null; elmt; elmt = elmt.nextSibling) {
if (elmt.nodeType == 1) {
if (self.$GetAttributeEx(elmt, attrName) == attrValue)
return elmt;
if (deep) {
var childRet = FindFirstChildByAttribute(elmt, attrValue, attrName, deep);
if (childRet)
return childRet;
}
}
}
}
self.$FindFirstChildByAttribute = FindFirstChildByAttribute;
function FindChildrenByAttribute(elmt, attrValue, attrName, deep) {
if (!attrName)
attrName = "u";
var ret = [];
for (elmt = elmt ? elmt.firstChild : null; elmt; elmt = elmt.nextSibling) {
if (elmt.nodeType == 1) {
if (self.$GetAttributeEx(elmt, attrName) == attrValue)
ret.push(elmt);
if (deep) {
var childRet = FindChildrenByAttribute(elmt, attrValue, attrName, deep);
if (childRet.length)
ret = ret.concat(childRet);
}
}
}
return ret;
}
self.$FindChildrenByAttribute = FindChildrenByAttribute;
function FindFirstChildByTag(elmt, tagName, deep) {
for (elmt = elmt ? elmt.firstChild : null; elmt; elmt = elmt.nextSibling) {
if (elmt.nodeType == 1) {
if (elmt.tagName == tagName)
return elmt;
if (deep) {
var childRet = FindFirstChildByTag(elmt, tagName, deep);
if (childRet)
return childRet;
}
}
}
}
self.$FindFirstChildByTag = FindFirstChildByTag;
function FindChildrenByTag(elmt, tagName, deep) {
var ret = [];
for (elmt = elmt ? elmt.firstChild : null; elmt; elmt = elmt.nextSibling) {
if (elmt.nodeType == 1) {
if (!tagName || elmt.tagName == tagName)
ret.push(elmt);
if (deep) {
var childRet = FindChildrenByTag(elmt, tagName, true);
if (childRet.length)
ret = ret.concat(childRet);
}
}
}
return ret;
}
self.$FindChildrenByTag = FindChildrenByTag;
self.$GetElementsByTagName = function (elmt, tagName) {
return elmt.getElementsByTagName(tagName);
};
self.$Extend = function (target) {
for (var i = 1; i < arguments.length; i++) {
var options = arguments[i];
// Only deal with non-null/undefined values
if (options) {
// Extend the base object
for (var name in options) {
target[name] = options[name];
}
}
}
// Return the modified object
return target;
};
self.$Unextend = function (target, options) {
$JssorDebug$.$Assert(options);
var unextended = {};
// Extend the base object
for (var name in target) {
if (target[name] != options[name]) {
unextended[name] = target[name];
}
}
// Return the modified object
return unextended;
};
self.$IsUndefined = function (obj) {
return type(obj) == "undefined";
};
self.$IsFunction = function (obj) {
return type(obj) == "function";
};
self.$IsArray = Array.isArray || function (obj) {
return type(obj) == "array";
};
self.$IsString = function (obj) {
return type(obj) == "string";
};
self.$IsNumeric = function (obj) {
return !isNaN(parseFloat(obj)) && isFinite(obj);
};
self.$IsWindow = function (obj) {
return obj != null && obj == obj.window;
};
self.$Type = type;
// args is for internal usage only
self.$Each = each;
self.$IsPlainObject = isPlainObject;
self.$CreateDivElement = function (doc) {
return self.$CreateElement("DIV", doc);
};
self.$CreateSpanElement = function (doc) {
return self.$CreateElement("SPAN", doc);
};
self.$CreateElement = function (tagName, doc) {
doc = doc || document;
return doc.createElement(tagName);
};
self.$EmptyFunction = function () { };
self.$GetAttribute = function (elmt, name) {
return elmt.getAttribute(name);
};
self.$GetAttributeEx = function (elmt, name) {
return self.$GetAttribute(elmt, name) || self.$GetAttribute(elmt, "data-" + name);
};
self.$SetAttribute = function (elmt, name, value) {
elmt.setAttribute(name, value);
};
self.$GetClassName = function (elmt) {
return elmt.className;
};
self.$SetClassName = function (elmt, className) {
elmt.className = className || "";
};
self.$GetParentNode = function (elmt) {
return elmt.parentNode;
};
self.$HideElement = function (elmt) {
self.$CssDisplay(elmt, "none");
};
self.$HideElements = function (elmts) {
for (var i = 0; i < elmts.length; i++) {
self.$HideElement(elmts[i]);
}
};
self.$ShowElement = function (elmt, show) {
self.$CssDisplay(elmt, show == false ? "none" : "");
};
self.$ShowElements = function (elmts) {
for (var i = 0; i < elmts.length; i++) {
self.$ShowElement(elmts[i]);
}
};
self.$RemoveAttribute = function (elmt, attrbuteName) {
elmt.removeAttribute(attrbuteName);
};
self.$CanClearClip = function () {
//return !IsBrowserIE() || browserEngineVersion > 9 || (browserRuntimeVersion > 7 && !IsBrowserIeQuirks());
return IsBrowserIE() && browserRuntimeVersion < 10;
};
self.$SetStyleClip = function (elmt, clip) {
if (clip) {
elmt.style.clip = "rect(" + Math.round(clip.$Top) + "px " + Math.round(clip.$Right) + "px " + Math.round(clip.$Bottom) + "px " + Math.round(clip.$Left) + "px)";
}
else {
var cssText = elmt.style.cssText;
var clipRegs = [
new RegExp(/[\s]*clip: rect\(.*?\)[;]?/i),
new RegExp(/[\s]*cliptop: .*?[;]?/i),
new RegExp(/[\s]*clipright: .*?[;]?/i),
new RegExp(/[\s]*clipbottom: .*?[;]?/i),
new RegExp(/[\s]*clipleft: .*?[;]?/i)
];
var newCssText = BuildNewCss(cssText, clipRegs, "");
$JssorUtils$.$CssCssText(elmt, newCssText);
}
};
self.$GetNow = function () {
return new Date().getTime();
};
self.$AppendChild = function (elmt, child) {
elmt.appendChild(child);
};
self.$AppendChildren = function (elmt, children) {
each(children, function (child) {
self.$AppendChild(elmt, child);
});
};
self.$InsertBefore = function (elmt, child, refObject) {
elmt.insertBefore(child, refObject);
};
self.$InsertAdjacentHtml = function (elmt, where, text) {
elmt.insertAdjacentHTML(where, text);
};
self.$RemoveChild = function (elmt, child) {
elmt.removeChild(child);
};
self.$RemoveChildren = function (elmt, children) {
each(children, function (child) {
self.$RemoveChild(elmt, child);
});
};
self.$ClearChildren = function (elmt) {
self.$RemoveChildren(elmt, self.$GetChildren(elmt));
};
self.$ParseInt = function (str, radix) {
return parseInt(str, radix || 10);
};
self.$ParseFloat = function (str) {
return parseFloat(str);
};
self.$IsChild = function (elmtA, elmtB) {
var body = document.body;
while (elmtB && elmtA != elmtB && body != elmtB) {
try {
elmtB = elmtB.parentNode;
} catch (e) {
// Firefox sometimes fires events for XUL elements, which throws
// a "permission denied" error. so this is not a child.
return false;
}
}
return elmtA == elmtB;
};
self.$ToLowerCase = function (value) {
if (value)
value = value.toLowerCase();
return value;
};
self.$CloneNode = function (elmt, deep) {
return elmt.cloneNode(deep);
};
function LoadImageCallback(callback, image, abort) {
image.onload = null;
image.abort = null;
if (callback)
callback(image, abort);
}
self.$LoadImage = function (src, callback) {
if (self.$IsBrowserOpera() && browserRuntimeVersion < 11.6 || !src) {
LoadImageCallback(callback, null);
}
else {
var image = new Image();
image.onload = self.$CreateCallback(null, LoadImageCallback, callback, image);
image.onabort = self.$CreateCallback(null, LoadImageCallback, callback, image, true);
image.src = src;
}
};
self.$LoadImages = function (imageElmts, mainImageElmt, callback) {
var _ImageLoading = imageElmts.length + 1;
function LoadImageCompleteEventHandler(image, abort) {
_ImageLoading--;
if (mainImageElmt && image && image.src == mainImageElmt.src)
mainImageElmt = image;
!_ImageLoading && callback && callback(mainImageElmt);
}
$JssorUtils$.$Each(imageElmts, function (imageElmt) {
$JssorUtils$.$LoadImage(imageElmt.src, LoadImageCompleteEventHandler);
});
LoadImageCompleteEventHandler();
};
self.$BuildElement = function (template, tagName, replacer, createCopy) {
if (createCopy)
template = $JssorUtils$.$CloneNode(template, true);
var templateHolders = $JssorUtils$.$GetElementsByTagName(template, tagName);
for (var j = templateHolders.length - 1; j > -1; j--) {
var templateHolder = templateHolders[j];
var replaceItem = $JssorUtils$.$CloneNode(replacer, true);
$JssorUtils$.$SetClassName(replaceItem, $JssorUtils$.$GetClassName(templateHolder));
$JssorUtils$.$CssCssText(replaceItem, templateHolder.style.cssText);
var thumbnailPlaceHolderParent = $JssorUtils$.$GetParentNode(templateHolder);
$JssorUtils$.$InsertBefore(thumbnailPlaceHolderParent, replaceItem, templateHolder);
$JssorUtils$.$RemoveChild(thumbnailPlaceHolderParent, templateHolder);
}
return template;
};
var _MouseDownButtons;
var _MouseOverButtons = [];
function JssorButtonEx(elmt) {
var _Self = this;
var _OriginClassName;
var _IsMouseDown; //class name 'dn'
var _IsActive; //class name 'av'
function Highlight() {
var className = _OriginClassName;
if (_IsMouseDown) {
className += 'dn';
}
else if (_IsActive) {
className += "av";
}
$JssorUtils$.$SetClassName(elmt, className);
}
function OnMouseDown(event) {
_MouseDownButtons.push(_Self);
_IsMouseDown = true;
Highlight();
}
_Self.$MouseUp = function () {
/// <summary>
/// Internal member function, do not use it.
/// </summary>
/// <private />
_IsMouseDown = false;
Highlight();
};
_Self.$Activate = function (activate) {
_IsActive = activate;
Highlight();
};
//JssorButtonEx Constructor
{
elmt = self.$GetElement(elmt);
if (!_MouseDownButtons) {
self.$AddEventBrowserMouseUp(function () {
var oldMouseDownButtons = _MouseDownButtons;
_MouseDownButtons = [];
each(oldMouseDownButtons, function (button) {
button.$MouseUp();
});
});
_MouseDownButtons = [];
}
_OriginClassName = self.$GetClassName(elmt);
$JssorUtils$.$AddEvent(elmt, "mousedown", OnMouseDown);
}
}
self.$Buttonize = function (elmt) {
return new JssorButtonEx(elmt);
};
self.$Css = Css;
self.$CssN = CssN;
self.$CssP = CssP;
self.$CssOverflow = CssProxy("overflow");
self.$CssTop = CssProxy("top", 2);
self.$CssLeft = CssProxy("left", 2);
self.$CssWidth = CssProxy("width", 2);
self.$CssHeight = CssProxy("height", 2);
self.$CssMarginLeft = CssProxy("marginLeft", 2);
self.$CssMarginTop = CssProxy("marginTop", 2);
self.$CssPosition = CssProxy("position");
self.$CssDisplay = CssProxy("display");
self.$CssZIndex = CssProxy("zIndex", 1);
self.$CssFloat = function (elmt, float) {
return Css(elmt, IsBrowserIE() ? "styleFloat" : "cssFloat", float);
};
self.$CssOpacity = function (elmt, opacity, ie9EarlierForce) {
if (opacity != undefined) {
SetStyleOpacity(elmt, opacity, ie9EarlierForce);
}
else {
return GetStyleOpacity(elmt);
}
};
self.$CssCssText = function (elmt, text) {
if (text != undefined) {
elmt.style.cssText = text;
}
else {
return elmt.style.cssText;
}
};
var _StyleGetter = {
$Opacity: self.$CssOpacity,
$Top: self.$CssTop,
$Left: self.$CssLeft,
$Width: self.$CssWidth,
$Height: self.$CssHeight,
$Position: self.$CssPosition,
$Display: self.$CssDisplay,
$ZIndex: self.$CssZIndex
};
//var _StyleGetter = {
// $Opacity: self.$GetStyleOpacity,
// $Top: self.$GetStyleTop,
// $Left: self.$GetStyleLeft,
// $Width: self.$GetStyleWidth,
// $Height: self.$GetStyleHeight,
// $Position: self.$GetStylePosition,
// $Display: self.$GetStyleDisplay,
// $ZIndex: self.$GetStyleZIndex
//};
var _StyleSetterReserved;
//var _StyleSetterReserved = {
// $Opacity: self.$SetStyleOpacity,
// $Top: self.$SetStyleTop,
// $Left: self.$SetStyleLeft,
// $Width: self.$SetStyleWidth,
// $Height: self.$SetStyleHeight,
// $Display: self.$SetStyleDisplay,
// $Clip: self.$SetStyleClip,
// $MarginLeft: self.$SetStyleMarginLeft,
// $MarginTop: self.$SetStyleMarginTop,
// $Transform: self.$SetStyleTransform,
// $Position: self.$SetStylePosition,
// $ZIndex: self.$SetStyleZIndex
//};
function GetStyleSetter() {
if (!_StyleSetterReserved) {
_StyleSetterReserved = self.$Extend({
$MarginTop: self.$CssMarginTop,
$MarginLeft: self.$CssMarginLeft,
$Clip: self.$SetStyleClip,
$Transform: self.$SetStyleTransform
}, _StyleGetter);
}
return _StyleSetterReserved;
}
function GetStyleSetterEx() {
GetStyleSetter();
//For Compression Only
_StyleSetterReserved.$Transform = _StyleSetterReserved.$Transform;
return _StyleSetterReserved;
}
self.$GetStyleSetter = GetStyleSetter;
self.$GetStyleSetterEx = GetStyleSetterEx;
self.$GetStyles = function (elmt, originStyles) {
GetStyleSetter();
var styles = {};
each(originStyles, function (value, key) {
if (_StyleGetter[key]) {
styles[key] = _StyleGetter[key](elmt);
}
});
return styles;
};
self.$SetStyles = function (elmt, styles) {
var styleSetter = GetStyleSetter();
each(styles, function (value, key) {
styleSetter[key] && styleSetter[key](elmt, value);
});
};
self.$SetStylesEx = function (elmt, styles) {
GetStyleSetterEx();
self.$SetStyles(elmt, styles);
};
$JssorMatrix$ = new function () {
var _This = this;
function Multiply(ma, mb) {
var acs = ma[0].length;
var rows = ma.length;
var cols = mb[0].length;
var matrix = [];
for (var r = 0; r < rows; r++) {
var row = matrix[r] = [];
for (var c = 0; c < cols; c++) {
var unitValue = 0;
for (var ac = 0; ac < acs; ac++) {
unitValue += ma[r][ac] * mb[ac][c];
}
row[c] = unitValue;
}
}
return matrix;
}
_This.$ScaleX = function (matrix, sx) {
return _This.$ScaleXY(matrix, sx, 0);
};
_This.$ScaleY = function (matrix, sy) {
return _This.$ScaleXY(matrix, 0, sy);
};
_This.$ScaleXY = function (matrix, sx, sy) {
return Multiply(matrix, [[sx, 0], [0, sy]]);
};
_This.$TransformPoint = function (matrix, p) {
var pMatrix = Multiply(matrix, [[p.x], [p.y]]);
return new $JssorPoint$(pMatrix[0][0], pMatrix[1][0]);
};
};
self.$CreateMatrix = function (alpha, scaleX, scaleY) {
var cos = Math.cos(alpha);
var sin = Math.sin(alpha);
//var r11 = cos;
//var r21 = sin;
//var r12 = -sin;
//var r22 = cos;
//var m11 = cos * scaleX;
//var m12 = -sin * scaleY;
//var m21 = sin * scaleX;
//var m22 = cos * scaleY;
return [[cos * scaleX, -sin * scaleY], [sin * scaleX, cos * scaleY]];
};
self.$GetMatrixOffset = function (matrix, width, height) {
var p1 = $JssorMatrix$.$TransformPoint(matrix, new $JssorPoint$(-width / 2, -height / 2));
var p2 = $JssorMatrix$.$TransformPoint(matrix, new $JssorPoint$(width / 2, -height / 2));
var p3 = $JssorMatrix$.$TransformPoint(matrix, new $JssorPoint$(width / 2, height / 2));
var p4 = $JssorMatrix$.$TransformPoint(matrix, new $JssorPoint$(-width / 2, height / 2));
return new $JssorPoint$(Math.min(p1.x, p2.x, p3.x, p4.x) + width / 2, Math.min(p1.y, p2.y, p3.y, p4.y) + height / 2);
};
};
$JssorAnimator$ = function (delay, duration, options, elmt, fromStyles, toStyles) {
delay = delay || 0;
var _This = this;
var _AutoPlay;
var _Hiden;
var _CombineMode;
var _PlayToPosition;
var _PlayDirection;
var _NoStop;
var _TimeStampLastFrame = 0;
var _SubEasings;
var _SubRounds;
var _SubDurings;
var _Callback;
var _Position_Current = 0;
var _Position_Display = 0;
var _Hooked;
var _Position_InnerBegin = delay;
var _Position_InnerEnd = delay + duration;
var _Position_OuterBegin;
var _Position_OuterEnd;
var _LoopLength;
var _NestedAnimators = [];
var _StyleSetter;
function GetPositionRange(position, begin, end) {
var range = 0;
if (position < begin)
range = -1;
else if (position > end)
range = 1;
return range;
}
function GetInnerPositionRange(position) {
return GetPositionRange(position, _Position_InnerBegin, _Position_InnerEnd);
}
function GetOuterPositionRange(position) {
return GetPositionRange(position, _Position_OuterBegin, _Position_OuterEnd);
}
function Shift(offset) {
_Position_OuterBegin += offset;
_Position_OuterEnd += offset;
_Position_InnerBegin += offset;
_Position_InnerEnd += offset;
_Position_Current += offset;
_Position_Display += offset;
$JssorUtils$.$Each(_NestedAnimators, function (animator) {
animator, animator.$Shift(offset);
});
}
function Locate(position, relative) {
var offset = position - _Position_OuterBegin + delay * relative;
Shift(offset);
//$JssorDebug$.$Execute(function () {
// _This.$Position_InnerBegin = _Position_InnerBegin;
// _This.$Position_InnerEnd = _Position_InnerEnd;
// _This.$Position_OuterBegin = _Position_OuterBegin;
// _This.$Position_OuterEnd = _Position_OuterEnd;
//});
return _Position_OuterEnd;
}
function GoToPosition(positionOuter, force) {
var trimedPositionOuter = positionOuter;
if (_LoopLength && (trimedPositionOuter >= _Position_OuterEnd || trimedPositionOuter <= _Position_OuterBegin)) {
trimedPositionOuter = ((trimedPositionOuter - _Position_OuterBegin) % _LoopLength + _LoopLength) % _LoopLength + _Position_OuterBegin;
}
if (!_Hooked || _NoStop || force || _Position_Current != trimedPositionOuter) {
var positionToDisplay = Math.min(trimedPositionOuter, _Position_OuterEnd);
positionToDisplay = Math.max(positionToDisplay, _Position_OuterBegin);
if (!_Hooked || _NoStop || force || positionToDisplay != _Position_Display) {
if (toStyles) {
var currentStyles = toStyles;
if (fromStyles) {
var interPosition = (positionToDisplay - _Position_InnerBegin) / (duration || 1);
if (options.$Optimize && $JssorUtils$.$IsBrowserChrome() && duration)
interPosition = Math.round(interPosition * duration / 16) / duration * 16;
if (options.$Reverse)
interPosition = 1 - interPosition;
currentStyles = {};
for (var key in toStyles) {
var round = _SubRounds[key] || 1;
var during = _SubDurings[key] || [0, 1];
var propertyInterPosition = (interPosition - during[0]) / during[1];
propertyInterPosition = Math.min(Math.max(propertyInterPosition, 0), 1);
propertyInterPosition = propertyInterPosition * round;
var floorPosition = Math.floor(propertyInterPosition);
if (propertyInterPosition != floorPosition)
propertyInterPosition -= floorPosition;
var easing = _SubEasings[key] || _SubEasings.$Default;
var easingValue = easing(propertyInterPosition);
var currentPropertyValue;
var value = fromStyles[key];
var toValue = toStyles[key];
if ($JssorUtils$.$IsNumeric(toValue)) {
currentPropertyValue = value + (toValue - value) * easingValue;
}
else {
currentPropertyValue = $JssorUtils$.$Extend({ $Offset: {} }, fromStyles[key]);
$JssorUtils$.$Each(toValue.$Offset, function (rectX, n) {
var offsetValue = rectX * easingValue;
currentPropertyValue.$Offset[n] = offsetValue;
currentPropertyValue[n] += offsetValue;
});
}
currentStyles[key] = currentPropertyValue;
}
}
if (fromStyles.$Zoom) {
currentStyles.$Transform = { $Rotate: currentStyles.$Rotate || 0, $Scale: currentStyles.$Zoom, $OriginalWidth: options.$OriginalWidth, $OriginalHeight: options.$OriginalHeight };
}
if (toStyles.$Clip && options.$Move) {
var styleFrameNClipOffset = currentStyles.$Clip.$Offset;
var offsetY = (styleFrameNClipOffset.$Top || 0) + (styleFrameNClipOffset.$Bottom || 0);
var offsetX = (styleFrameNClipOffset.$Left || 0) + (styleFrameNClipOffset.$Right || 0);
currentStyles.$Left = (currentStyles.$Left || 0) + offsetX;
currentStyles.$Top = (currentStyles.$Top || 0) + offsetY;
currentStyles.$Clip.$Left -= offsetX;
currentStyles.$Clip.$Right -= offsetX;
currentStyles.$Clip.$Top -= offsetY;
currentStyles.$Clip.$Bottom -= offsetY;
}
if (currentStyles.$Clip && $JssorUtils$.$CanClearClip() && !currentStyles.$Clip.$Top && !currentStyles.$Clip.$Left && (currentStyles.$Clip.$Right == options.$OriginalWidth) && (currentStyles.$Clip.$Bottom == options.$OriginalHeight))
currentStyles.$Clip = null;
$JssorUtils$.$Each(currentStyles, function (value, key) {
_StyleSetter[key] && _StyleSetter[key](elmt, value);
});
}
_This.$OnInnerOffsetChange(_Position_Display - _Position_InnerBegin, positionToDisplay - _Position_InnerBegin);
}
_Position_Display = positionToDisplay;
$JssorUtils$.$Each(_NestedAnimators, function (animator, i) {
var nestedAnimator = positionOuter < _Position_Current ? _NestedAnimators[_NestedAnimators.length - i - 1] : animator;
nestedAnimator.$GoToPosition(positionOuter, force);
});
var positionOld = _Position_Current;
var positionNew = positionOuter;
_Position_Current = trimedPositionOuter;
_Hooked = true;
_This.$OnPositionChange(positionOld, positionNew);
}
}
function Join(animator, combineMode) {
/// <summary>
/// Combine another animator as nested animator
/// </summary>
/// <param name="animator" type="$JssorAnimator$">
/// An instance of $JssorAnimator$
/// </param>
/// <param name="combineMode" type="int">
/// 0: parallel - place the animator parallel to this animator.
/// 1: chain - chain the animator at the _Position_InnerEnd of this animator.
/// </param>
$JssorDebug$.$Execute(function () {
if (combineMode !== 0 && combineMode !== 1)
$JssorDebug$.$Fail("Argument out of range, the value of 'combineMode' should be either 0 or 1.");
});
if (combineMode)
animator.$Locate(_Position_OuterEnd, 1);
_Position_OuterEnd = Math.max(_Position_OuterEnd, animator.$GetPosition_OuterEnd());
_NestedAnimators.push(animator);
}
function PlayFrame() {
if (_AutoPlay) {
var now = $JssorUtils$.$GetNow();
var timeOffset = Math.min(now - _TimeStampLastFrame, $JssorUtils$.$IsBrowserOpera() ? 80 : 20);
var timePosition = _Position_Current + timeOffset * _PlayDirection;
_TimeStampLastFrame = now;
if (timePosition * _PlayDirection >= _PlayToPosition * _PlayDirection)
timePosition = _PlayToPosition;
GoToPosition(timePosition);
if (!_NoStop && timePosition * _PlayDirection >= _PlayToPosition * _PlayDirection) {
Stop(_Callback);
}
else {
$JssorUtils$.$Delay(PlayFrame, options.$Interval);
}
}
}
function PlayToPosition(toPosition, callback, noStop) {
if (!_AutoPlay) {
_AutoPlay = true;
_NoStop = noStop
_Callback = callback;
toPosition = Math.max(toPosition, _Position_OuterBegin);
toPosition = Math.min(toPosition, _Position_OuterEnd);
_PlayToPosition = toPosition;
_PlayDirection = _PlayToPosition < _Position_Current ? -1 : 1;
_This.$OnStart();
_TimeStampLastFrame = $JssorUtils$.$GetNow();
PlayFrame();
}
}
function Stop(callback) {
if (_AutoPlay) {
_NoStop = _AutoPlay = _Callback = false;
_This.$OnStop();
if (callback)
callback();
}
}
_This.$Play = function (positionLength, callback, noStop) {
PlayToPosition(positionLength ? _Position_Current + positionLength : _Position_OuterEnd, callback, noStop);
};
_This.$PlayToPosition = function (position, callback, noStop) {
PlayToPosition(position, callback, noStop);
};
_This.$PlayToBegin = function (callback, noStop) {
PlayToPosition(_Position_OuterBegin, callback, noStop);
};
_This.$PlayToEnd = function (callback, noStop) {
PlayToPosition(_Position_OuterEnd, callback, noStop);
};
_This.$Stop = function () {
Stop();
};
_This.$Continue = function (toPosition) {
PlayToPosition(toPosition);
};
_This.$GetPosition = function () {
return _Position_Current;
};
_This.$GetPlayToPosition = function () {
return _PlayToPosition;
};
_This.$GetPosition_Display = function () {
return _Position_Display;
};
_This.$GoToPosition = GoToPosition;
_This.$GoToBegin = function () {
GoToPosition(_Position_OuterBegin, true);
};
_This.$GoToEnd = function () {
GoToPosition(_Position_OuterEnd, true);
};
_This.$Move = function (offset) {
GoToPosition(_Position_Current + offset);
};
_This.$CombineMode = function () {
return _CombineMode;
};
_This.$GetDuration = function () {
return duration;
};
_This.$IsPlaying = function () {
return _AutoPlay;
};
_This.$IsOnTheWay = function () {
return _Position_Current > _Position_InnerBegin && _Position_Current <= _Position_InnerEnd;
};
_This.$SetLoopLength = function (length) {
_LoopLength = length;
};
_This.$Locate = Locate;
_This.$Shift = Shift;
_This.$Join = Join;
_This.$Combine = function (animator) {
/// <summary>
/// Combine another animator parallel to this animator
/// </summary>
/// <param name="animator" type="$JssorAnimator$">
/// An instance of $JssorAnimator$
/// </param>
Join(animator, 0);
};
_This.$Chain = function (animator) {
/// <summary>
/// Chain another animator at the _Position_InnerEnd of this animator
/// </summary>
/// <param name="animator" type="$JssorAnimator$">
/// An instance of $JssorAnimator$
/// </param>
Join(animator, 1);
};
_This.$GetPosition_InnerBegin = function () {
/// <summary>
/// Internal member function, do not use it.
/// </summary>
/// <private />
/// <returns type="int" />
return _Position_InnerBegin;
};
_This.$GetPosition_InnerEnd = function () {
/// <summary>
/// Internal member function, do not use it.
/// </summary>
/// <private />
/// <returns type="int" />
return _Position_InnerEnd;
};
_This.$GetPosition_OuterBegin = function () {
/// <summary>
/// Internal member function, do not use it.
/// </summary>
/// <private />
/// <returns type="int" />
return _Position_OuterBegin;
};
_This.$GetPosition_OuterEnd = function () {
/// <summary>
/// Internal member function, do not use it.
/// </summary>
/// <private />
/// <returns type="int" />
return _Position_OuterEnd;
};
_This.$OnPositionChange = $JssorUtils$.$EmptyFunction;
_This.$OnStart = $JssorUtils$.$EmptyFunction;
_This.$OnStop = $JssorUtils$.$EmptyFunction;
_This.$OnInnerOffsetChange = $JssorUtils$.$EmptyFunction;
_This.$Version = $JssorUtils$.$GetNow();
//Constructor` 1
{
options = $JssorUtils$.$Extend({
$Interval: 15
}, options);
//Sodo statement, for development time intellisence only
$JssorDebug$.$Execute(function () {
options = $JssorUtils$.$Extend({
$LoopLength: undefined,
$Setter: undefined,
$Easing: undefined
}, options);
});
_LoopLength = options.$LoopLength;
_StyleSetter = $JssorUtils$.$Extend({}, $JssorUtils$.$GetStyleSetter(), options.$Setter);
_Position_OuterBegin = _Position_InnerBegin = delay;
_Position_OuterEnd = _Position_InnerEnd = delay + duration;
var _SubRounds = options.$Round || {};
var _SubDurings = options.$During || {};
_SubEasings = $JssorUtils$.$Extend({ $Default: $JssorUtils$.$IsFunction(options.$Easing) && options.$Easing || $JssorEasing$.$EaseSwing }, options.$Easing);
}
};
function $JssorPlayerClass$() {
var _SelfPlayer = this;
var _PlayerControllers = [];
function PlayerController(playerElement) {
var _SelfPlayerController = this;
var _PlayerInstance;
var _PlayerInstantces = [];
function OnPlayerInstanceDataAvailable(event) {
var srcElement = $JssorUtils$.$GetEventSrcElement(event);
_PlayerInstance = srcElement.pInstance;
$JssorUtils$.$RemoveEvent(srcElement, "dataavailable", OnPlayerInstanceDataAvailable);
$JssorUtils$.$Each(_PlayerInstantces, function (playerInstance) {
if (playerInstance != _PlayerInstance) {
playerInstance.$Remove();
}
});
playerElement.pTagName = _PlayerInstance.tagName;
_PlayerInstantces = null;
}
function HandlePlayerInstance(playerInstanceElement) {
var playerHandler;
if (!playerInstanceElement.pInstance) {
var playerHandlerAttribute = $JssorUtils$.$GetAttributeEx(playerInstanceElement, "pHandler");
if ($JssorPlayer$[playerHandlerAttribute]) {
$JssorUtils$.$AddEvent(playerInstanceElement, "dataavailable", OnPlayerInstanceDataAvailable);
playerHandler = new $JssorPlayer$[playerHandlerAttribute](playerElement, playerInstanceElement);
_PlayerInstantces.push(playerHandler);
$JssorDebug$.$Execute(function () {
if ($JssorUtils$.$Type(playerHandler.$Remove) != "function") {
$JssorDebug$.$Fail("'pRemove' interface not implemented for player handler '" + playerHandlerAttribute + "'.");
}
});
}
}
return playerHandler;
}
_SelfPlayerController.$InitPlayerController = function () {
if (!playerElement.pInstance && !HandlePlayerInstance(playerElement)) {
var playerInstanceElements = $JssorUtils$.$GetChildren(playerElement);
$JssorUtils$.$Each(playerInstanceElements, function (playerInstanceElement) {
HandlePlayerInstance(playerInstanceElement);
});
}
};
}
_SelfPlayer.$EVT_SWITCH = 21;
_SelfPlayer.$FetchPlayers = function (elmt) {
elmt = elmt || document.body;
var playerElements = $JssorUtils$.$FindChildrenByAttribute(elmt, "player", null, true);
$JssorUtils$.$Each(playerElements, function (playerElement) {
if (!_PlayerControllers[playerElement.pId]) {
playerElement.pId = _PlayerControllers.length;
_PlayerControllers.push(new PlayerController(playerElement));
}
var playerController = _PlayerControllers[playerElement.pId];
playerController.$InitPlayerController();
});
};
}