/**
* @fileoverview Common functions used in all Zapatec widgets.
*
*
* Copyright (c) 2004-2006 by Zapatec, Inc.
* http://www.zapatec.com
* 1700 MLK Way, Berkeley, California,
* 94709, U.S.A.
* All rights reserved.
*
*/
/* $Id: utils.js 5148 2006-11-15 20:14:58Z vkulov $ */
if (typeof Zapatec == 'undefined') {
/**
* Namespace definition.
* @constructor
*/
Zapatec = {};
}
/**************************** ErrorHandler ****************************/
Zapatec.ErrorHandler = {};
Zapatec.ErrorHandler.setup = function(window, report_url) {
this.window = window;
this.report_url = report_url;
this.window.onerror = Zapatec.ErrorHandler.handleError;
}
Zapatec.ErrorHandler.handleError = function(desc, path, line) {
if (Zapatec.ErrorHandler.err_stack == undefined) Zapatec.ErrorHandler.err_stack = [];
Zapatec.ErrorHandler.err_stack.push([desc, path, line]);
return false;
}
Zapatec.ErrorHandler.getErrStack = function() {
return Zapatec.ErrorHandler.err_stack;
}
//Zapatec.ErrorHandler.setup(self);
/************************** ErrorHandler end **************************/
/// define the Utils namespace
Zapatec.Utils = {};
/// Deprecated. Use Zapatec.Utils.getElementOffset instead.
/// Retrieves the absolute position (relative to ) of a given element.
///
/// @param el [HTMLElement] reference to the element.
/// @return [object] { x, y } containing the position.
Zapatec.Utils.getAbsolutePos = function(el, scrollOff) {
var SL = 0, ST = 0;
if (!scrollOff) {
var is_div = /^div$/i.test(el.tagName);
if (is_div && el.scrollLeft)
SL = el.scrollLeft;
if (is_div && el.scrollTop)
ST = el.scrollTop;
}
var r = { x: el.offsetLeft - SL, y: el.offsetTop - ST };
if (el.offsetParent) {
var tmp = this.getAbsolutePos(el.offsetParent);
r.x += tmp.x;
r.y += tmp.y;
}
return r;
};
/**
* Returns absolute position of an element on the page and its width and height.
*
* @private
* @param {object} objElement Element object
* @return Offset: left or x - left offset; top or y - top offset
* @object
*/
Zapatec.Utils.getElementOffset = function(objElement) {
var iLeft = iTop = iWidth = iHeight = 0;
if (objElement.getBoundingClientRect) {
// IE
var objRectangle = objElement.getBoundingClientRect();
iLeft = objRectangle.left;
iTop = objRectangle.top;
iWidth = objRectangle.right - iLeft;
iHeight = objRectangle.bottom - iTop;
// getBoundingClientRect returns coordinates relative to the window
iLeft += Zapatec.Utils.getPageScrollX() - 2;
iTop += Zapatec.Utils.getPageScrollY() - 2;
} else if (document.getBoxObjectFor) {
// Mozilla
var objRectangle = document.getBoxObjectFor(objElement);
iLeft = objRectangle.x;
iTop = objRectangle.y;
iWidth = objRectangle.width;
iHeight = objRectangle.height;
} else {
// Others
iWidth = objElement.offsetWidth;
iHeight = objElement.offsetHeight;
while (objElement.offsetParent) {
iLeft += objElement.offsetLeft;
iTop += objElement.offsetTop;
objElement = objElement.offsetParent;
}
}
return {
left: iLeft,
top: iTop,
x: iLeft,
y: iTop,
width: iWidth,
height: iHeight
};
};
/**
* Returns offset of content of a scrollable element relative to the document
* body. Offset is calulated as offset of an element minus scrollLeft/scrollTop
* value.
*
* @private
* @param {object} objElement Element object
* @return Offset: left or x - left offset; top or y - top offset
* @object
*/
Zapatec.Utils.getElementOffsetScrollable = function(objElement) {
var objPos = Zapatec.Utils.getElementOffset(objElement);
var iLeft = objPos.left;
if (objElement.scrollLeft) {
iLeft -= objElement.scrollLeft;
}
var iTop = objPos.top;
if (objElement.scrollTop) {
iTop -= objElement.scrollTop;
}
return {left: iLeft, top: iTop, x: iLeft, y: iTop};
};
/// Modify the position of a box to fit in browser's view. This function will
/// modify the passed object itself, so it doesn't need to return a value.
///
/// @param [object] box { x, y, width, height } specifying the area.
Zapatec.Utils.fixBoxPosition = function(box) {
if (box.x < 0)
box.x = 0;
if (box.y < 0)
box.y = 0;
var cp = Zapatec.Utils.createElement("div");
var s = cp.style;
s.position = "absolute";
s.right = s.bottom = s.width = s.height = "0px";
window.document.body.appendChild(cp);
var br = Zapatec.Utils.getAbsolutePos(cp);
window.document.body.removeChild(cp);
if (Zapatec.is_ie) {
br.y += window.document.body.scrollTop;
br.x += window.document.body.scrollLeft;
} else {
br.y += window.scrollY;
br.x += window.scrollX;
}
var tmp = box.x + box.width - br.x;
if (tmp > 0) box.x -= tmp;
tmp = box.y + box.height - br.y;
if (tmp > 0) box.y -= tmp;
};
/// Determines if an event is related to a certain element. This is a poor
/// substitute for some events that are missing from DOM since forever (like
/// onenter, onleave, which MSIE provides). Basically onmouseover and
/// onmouseout are fired even if the mouse was already in the element but moved
/// from text to a blank area, so in order not to close a popup element when
/// onmouseout occurs in this situation, one would need to first check if the
/// event is not related to that popup element:
///
/// \code
/// function handler_onMouseOut(event) {
/// if (!Zapatec.Utils.isRelated(this, event)) {
/// /// can safely hide it now
/// this.style.display = "none";
/// }
/// }
/// \endcode
///
/// @param el [HTMLElement] reference to the element to check the event against
/// @param evt [Event] reference to the Event object
/// @return [boolean] true if the event is related to the element
Zapatec.Utils.isRelated = function (el, evt) {
evt || (evt = window.event);
var related = evt.relatedTarget;
if (!related) {
var type = evt.type;
if (type == "mouseover") {
related = evt.fromElement;
} else if (type == "mouseout") {
related = evt.toElement;
}
}
try {
while (related) {
if (related == el) {
return true;
}
related = related.parentNode;
}
} catch(e) {};
return false;
};
/// Remove a certain [CSS] class from the given element.
/// @param el [HTMLElement] reference to the element.
/// @param className [string] the class to remove.
Zapatec.Utils.removeClass = function(el, className) {
if (!(el && el.className)) {
return;
}
var cls = el.className.split(" ");
var ar = [];
for (var i = cls.length; i > 0;) {
if (cls[--i] != className) {
ar[ar.length] = cls[i];
}
}
el.className = ar.join(" ");
};
/// Appends a certain [CSS] class to the given element.
/// @param el [HTMLElement] reference to the element.
/// @param className [string] the class to append.
Zapatec.Utils.addClass = function(el, className) {
Zapatec.Utils.removeClass(el, className);
el.className += " " + className;
};
/// Retrieves the current target element for some event (useful when bubbling).
/// This function is not actually very useful, but it's legacy from the old calendar code.
/// @param ev [Event] the event object.
/// @return [HTMLElement] window.event.srcElement for MSIE, ev.currentTarget for other browsers.
Zapatec.Utils.getElement = function(ev) {
if (Zapatec.is_ie) {
return window.event.srcElement;
} else {
return ev.currentTarget;
}
};
/// Retrieves the target element for some event (useful when bubbling).
/// This function is not actually very useful, but it's legacy from the old calendar code.
/// @param ev [Event] the event object.
/// @return [HTMLElement] window.event.srcElement for MSIE, ev.target for other browsers.
Zapatec.Utils.getTargetElement = function(ev) {
if (Zapatec.is_ie) {
return window.event.srcElement;
} else {
return ev.target;
}
};
/**
* Returns mouse position during the event.
*
* @param {object} objEvent Optional. Event object
* @return Mouse position during the event:
*
* {
* pageX: [number] x coordinate relative to the document,
* pageY: [number] y coordinate relative to the document,
* clientX: [number] x coordinate relative to the window,
* clientY: [number] y coordinate relative to the window
* }
*
* @type object
*/
Zapatec.Utils.getMousePos = function(objEvent) {
var objPos = {
pageX: 0,
pageY: 0,
clientX: 0,
clientY: 0
};
var boolIsPageX = (typeof objEvent.pageX != 'undefined');
var boolIsClientX = (typeof objEvent.clientX != 'undefined');
objEvent || (objEvent = window.event);
if (objEvent && (boolIsPageX || boolIsClientX)) {
if (boolIsPageX) {
objPos.pageX = objEvent.pageX;
objPos.pageY = objEvent.pageY;
} else {
objPos.pageX = objEvent.clientX + Zapatec.Utils.getPageScrollX();
objPos.pageY = objEvent.clientY + Zapatec.Utils.getPageScrollY();
}
if (boolIsClientX) {
objPos.clientX = objEvent.clientX;
objPos.clientY = objEvent.clientY;
} else {
objPos.clientX = objEvent.pageX - Zapatec.Utils.getPageScrollX();
objPos.clientY = objEvent.pageY - Zapatec.Utils.getPageScrollY();
}
}
return objPos;
};
/// Stops bubbling and propagation of some event.
/// @param ev [Event] the event object
/// @return false
Zapatec.Utils.stopEvent = function(ev) {
ev || (ev = window.event);
if (ev) {
if (Zapatec.is_ie) {
ev.cancelBubble = true;
ev.returnValue = false;
} else {
ev.preventDefault();
ev.stopPropagation();
}
}
return false;
};
Zapatec.Utils.removeOnUnload = [];
/// Adds an event handler to a certain element. This function adds a handler
/// using the DOM2 addEventListener (or attachEvent for MSIE). Doing this
/// means that you can add multiple handlers for the same element and same
/// event name, and they will be called in order.
///
/// WARNING: for really old browsers that don't support attachEvent nor
/// addEventListener, it falls back to the default way: el.onclick = func.
/// This means that you CANNOT add multiple handlers in those browsers, as a
/// new one will override the old one.
///
/// @param el [HTMLElement] reference to the element.
/// @param evname [string] the event name, excluding the "on" prefix.
/// @param func event handler function.
/// @param useCapture [boolean, optional] default: false, see
/// http://www.w3.org/TR/2000/REC-DOM-Level-2-Events-20001113/events.html#Events-EventTarget-addEventListener
/// for details
Zapatec.Utils.addEvent = function(el, evname, func, useCapture) {
if (el.addEventListener) { // Gecko / W3C
if (!useCapture) {
useCapture = false;
}
el.addEventListener(evname, func, useCapture);
} else if (el.attachEvent) { // IE
el.detachEvent("on" + evname, func);
el.attachEvent("on" + evname, func);
if (useCapture) {el.setCapture(false);}
} else {
el["on" + evname] = func;
}
Zapatec.Utils.removeOnUnload.push({"element" : el, "event" : evname, "listener" : func});
};
/// Removes an event handler added with Zapatec.Utils.addEvent(). The
/// prototype scheme is the same.
Zapatec.Utils.removeEvent = function(el, evname, func) {
if (el.detachEvent) { // IE
el.detachEvent("on" + evname, func);
} else if (el.removeEventListener) { // Gecko / W3C
el.removeEventListener(evname, func, false);
} else {
el["on" + evname] = null;
}
};
/// Create an element of a certain type using document.createElement(). A
/// function was needed in order to add some common attributes to all created
/// elements, but also in order to be able to use it in XHTML too (Gecko and
/// other W3C-compliant browsers).
///
/// This function will create an element of the given type and set certain
/// properties to it: unselectable for IE, and the CSS "-moz-user-select" for
/// Gecko, in order to make the element unselectable in these browsers.
/// Optionally, if the second argument is passed, it will appendChild() the
/// newly created element to its parent.
///
/// @param type [string] the tag name of the new element.
/// @param parent [HTMLElement, optional] a parent for the new element.
/// @param selectable [boolean] the flag to indicate wether element is selectable(rather usefull).
/// @return [HTMLElement] reference to the new element.
Zapatec.Utils.createElement = function(type, parent, selectable) {
var el = null;
if (window.self.document.createElementNS)
// use the XHTML namespace; IE won't normally get here unless
// _they_ "fix" the DOM2 implementation.
el = window.self.document.createElementNS("http://www.w3.org/1999/xhtml", type);
else
el = document.createElement(type);
if (typeof parent != "undefined" && parent != null)
parent.appendChild(el);
if (!selectable) {
if (Zapatec.is_ie)
el.setAttribute("unselectable", true);
if (Zapatec.is_gecko)
el.style.setProperty("-moz-user-select", "none", "");
}
return el;
};
// Cookie management
/// Sets a cooke given certain specifications. It overrides any existing
/// cookie with the same name.
///
/// @param name [string] the cookie name.
/// @param value [string] the cookie value.
/// @param domain [string, optional] the cookie domain.
/// @param path [string, optional] the cookie path.
/// @param exp_days [number, optional] number of days of cookie validity.
Zapatec.Utils.writeCookie = function(name, value, domain, path, exp_days) {
value = escape(value);
var ck = name + "=" + value, exp;
if (domain)
ck += ";domain=" + domain;
if (path)
ck += ";path=" + path;
if (exp_days) {
exp = new Date();
exp.setTime(exp_days * 86400000 + exp.getTime());
ck += ";expires=" + exp.toGMTString();
}
document.cookie = ck;
};
/**
* Retrieves the value of a cookie.
*
* @param name [string] the cookie name
* @return [string or null] a string with the cookie value, or null if it can't be found.
*/
/* ? inside regular expression is not supported in IE 5.0
Zapatec.Utils.getCookie = function(name) {
var re = new RegExp("(^|;\\s*)" + name + "\\s*=(.*?)(;|$)");
if (re.test(document.cookie)) {
var value = RegExp.$2;
value = unescape(value);
return (value);
}
return null;
};
*/
Zapatec.Utils.getCookie = function(name) {
var pattern = name + "=";
var tokenPos = 0;
while (tokenPos < document.cookie.length) {
var valuePos = tokenPos + pattern.length;
if (document.cookie.substring(tokenPos, valuePos) == pattern) {
var endValuePos = document.cookie.indexOf(";", valuePos);
if (endValuePos == -1) { // Last cookie
endValuePos = document.cookie.length;
}
return unescape(document.cookie.substring(valuePos, endValuePos));
}
tokenPos=document.cookie.indexOf(" ",tokenPos)+1;
if (tokenPos == 0) { // No more tokens
break;
}
}
return null;
};
/**
* Given an object, create a string suitable for saving the object in a cookie.
* This is similar to serialization. WARNING: it does not support nested
* objects.
*
* @param obj [Object] reference to the object to serialize.
* @return [string] the serialized object.
*/
Zapatec.Utils.makePref = function(obj) {
function stringify(val) {
if (typeof val == "object" && !val)
return "null";
else if (typeof val == "number" || typeof val == "boolean")
return val;
else if (typeof val == "string")
return '"' + val.replace(/\x22/, "\\22") + '"';
else return null;
};
var txt = "", i;
for (i in obj)
txt += (txt ? ",'" : "'") + i + "':" + stringify(obj[i]);
return txt;
};
/**
* The reverse of Zapatec.Utils.makePref(), this function unserializes the
* given string and creates an object from it.
*
* @param txt [string] the serialized value.
* @return [Object] a new object if it was created successfully or null otherwise.
*/
Zapatec.Utils.loadPref = function(txt) {
var obj = null;
try {
eval("obj={" + txt + "}");
} catch(e) {}
return obj;
};
/**
* Merges the values of the source object into the destination object.
*
* @param dest [Object] the destination object.
* @param src [Object] the source object.
*/
Zapatec.Utils.mergeObjects = function(dest, src) {
for (var i in src)
dest[i] = src[i];
};
// based on the WCH idea
// http://www.aplus.co.yu/WCH/code3/WCH.js
/// \defgroup WCH functions
//@{
Zapatec.Utils.__wch_id = 0; /**< [number, static] used to create ID-s for the WCH objects */
/**
* Create an WCH object. This function does nothing if the browser is not
* IE5.5 or IE6.0. A WCH object is one of the most bizarre tricks to avoid a
* notorious IE bug: IE normally shows "windowed controls" on top of any HTML
* elements, regardless of any z-index that might be specified in CSS. This
* technique is described at: http://www.aplus.co.yu/WCH/
*
* A "WCH object" is actually an HTMLIFrame element having a certain "CSS
* filter" (proprietary MSIE extension) that forces opacity zero. This object,
* displayed on top of a windowed control such as a select box, will completely
* hide the select box, allowing us to place other HTMLElement objects above.
*
* WCH stands for "Windowed Controls Hider".
*
* @param element [HTMLElement, optional] -- Create the WCH IFRAME inside this.
*
*
* @return [HTMLIFrame or null] a new WCH object if the browser is "supported", null otherwise.
*/
Zapatec.Utils.createWCH = function(element) {
var f = null;
element = element || window.self.document.body;
if (Zapatec.is_ie && !Zapatec.is_ie5) {
var filter = 'filter:progid:DXImageTransform.Microsoft.alpha(style=0,opacity=0);';
var id = "WCH" + (++Zapatec.Utils.__wch_id);
element.insertAdjacentHTML
('beforeEnd', '');
f = window.self.document.getElementById(id);
}
return f;
};
/**
* Configure a given WCH object to be displayed on top of the given element.
* Optionally, a second element can be passed, and in this case it will setup
* the WCH object to cover both elements.
*
* @param f [HTMLIFrame] the WCH object
* @param el [HTMLElement] the element to cover.
* @param el2 [HTMLElement, optional] another element to cover.
*/
Zapatec.Utils.setupWCH_el = function(f, el, el2) {
if (f) {
var pos = Zapatec.Utils.getAbsolutePos(el),
X1 = pos.x,
Y1 = pos.y,
X2 = X1 + el.offsetWidth,
Y2 = Y1 + el.offsetHeight;
if (el2) {
var p2 = Zapatec.Utils.getAbsolutePos(el2),
XX1 = p2.x,
YY1 = p2.y,
XX2 = XX1 + el2.offsetWidth,
YY2 = YY1 + el2.offsetHeight;
if (X1 > XX1)
X1 = XX1;
if (Y1 > YY1)
Y1 = YY1;
if (X2 < XX2)
X2 = XX2;
if (Y2 < YY2)
Y2 = YY2;
}
Zapatec.Utils.setupWCH(f, X1, Y1, X2-X1, Y2-Y1);
}
};
/**
* Configure a WCH object to cover a certain part of the screen.
*
* @param f [HTMLIFrame] the WCH object.
* @param x [number] the X coordinate.
* @param y [number] the Y coordinate.
* @param w [number] the width of the area.
* @param h [number] the height of the area.
*/
Zapatec.Utils.setupWCH = function(f, x, y, w, h) {
if (f) {
var s = f.style;
(typeof x != "undefined") && (s.left = x + "px");
(typeof y != "undefined") && (s.top = y + "px");
(typeof w != "undefined") && (s.width = w + "px");
(typeof h != "undefined") && (s.height = h + "px");
s.visibility = "inherit";
}
};
/**
* Hide a WCH object.
*
* @param f [HTMLIFrame] object to hide.
*/
Zapatec.Utils.hideWCH = function(f) {
if (f)
f.style.visibility = "hidden";
};
//@}
/// \defgroup Scroll-with-window functions
//@{
/**
* Returns current document vertical scroll position.
*/
Zapatec.Utils.getPageScrollY = function() {
if (window.pageYOffset) {
return window.pageYOffset;
} else if (document.body && document.body.scrollTop) {
return document.body.scrollTop;
} else if (document.documentElement && document.documentElement.scrollTop) {
return document.documentElement.scrollTop;
}
return 0;
};
/**
* Returns current document horizontal scroll position.
*/
Zapatec.Utils.getPageScrollX = function() {
if (window.pageXOffset) {
return window.pageXOffset;
} else if (document.body && document.body.scrollLeft) {
return document.body.scrollLeft;
} else if (document.documentElement && document.documentElement.scrollLeft) {
return document.documentElement.scrollLeft;
}
return 0;
};
// Object setup.
Zapatec.ScrollWithWindow = {};
Zapatec.ScrollWithWindow.list = [];
// Set to a number between 0 and 1, lower means longer scrolling.
Zapatec.ScrollWithWindow.stickiness = 0.25;
/**
* Registers a given object to have its style.top set equal to the window
* scroll position as the browser scrolls.
*
* @param node [HTMLElement] -- a reference to the node to scroll.
*/
Zapatec.ScrollWithWindow.register = function(node) {
var top = node.offsetTop || 0;
var left = node.offsetLeft || 0;
Zapatec.ScrollWithWindow.list[Zapatec.ScrollWithWindow.list.length] = {
node: node,
origTop: top,
origleft: left
};
};
/**
* Unregisters a given object.
*
* @param node [HTMLElement] -- a reference to the node to scroll.
*/
Zapatec.ScrollWithWindow.unregister = function(node) {
for (var count = 0; count < Zapatec.ScrollWithWindow.list.length; count++) {
var elm = Zapatec.ScrollWithWindow.list[count];
if (node == elm.node) {
Zapatec.ScrollWithWindow.list.splice(count, 1);
return;
}
}
};
/**
* \internal Called each time the window is scrolled to set objects' positions.
*
* @param newScrollY [number] -- the new window scroll position.
* @param direction [string] - "vertical"/"horizontal" controlls which scrolling we are handling
*/
Zapatec.ScrollWithWindow.handler = function(newScroll, direction) {
// Move oldScrollY towards newScrollY, evening up if the difference is small.
if (direction == "vertical") {
var newScrollY = newScroll;
oldScrollY += ((newScrollY - oldScrollY) * this.stickiness);
if (Math.abs(oldScrollY - newScrollY) <= 1) oldScrollY = newScrollY;
} else {
var newScrollX = newScroll;
oldScrollX += ((newScrollX - oldScrollX) * this.stickiness);
if (Math.abs(oldScrollX - newScrollX) <= 1) oldScrollX = newScrollX;
}
for (var count = 0; count < Zapatec.ScrollWithWindow.list.length; count++) {
var elm = Zapatec.ScrollWithWindow.list[count];
var node = elm.node;
node.style.position = 'absolute';
if (!elm.origTop && elm.origTop !== 0 && (direction == "vertical")) {
elm.origTop = parseInt(node.style.top) || 0;
}
if (!elm.origLeft && elm.origLeft !== 0 && (direction == "horizontal")) {
elm.origLeft = parseInt(node.style.left) || 0;
}
if (direction == "vertical") {
node.style.top = (elm.origTop + parseInt(oldScrollY)) + 'px';
} else {
node.style.left = (elm.origLeft + parseInt(oldScrollX)) + 'px';
}
}
};
// Processed scroll position & Event hook.
var oldScrollY = Zapatec.Utils.getPageScrollY();
var oldScrollX = Zapatec.Utils.getPageScrollX();
setInterval(
'var newScrollY = Zapatec.Utils.getPageScrollY(); ' +
'var newScrollX = Zapatec.Utils.getPageScrollX(); ' +
'if (newScrollY != oldScrollY) { ' +
'Zapatec.ScrollWithWindow.handler(newScrollY, "vertical"); ' +
'}' +
'if (newScrollX != oldScrollX) { ' +
'Zapatec.ScrollWithWindow.handler(newScrollX, "horizontal"); ' +
'}', 50);
//@}
/**
* Destroys the given element (remove it from the DOM tree) if it's not null
* and it's parent is not null.
*
* @param el [HTMLElement] the element to destroy.
*/
Zapatec.Utils.destroy = function(el) {
if (el && el.parentNode)
el.parentNode.removeChild(el);
};
/**
* Opens a new window at a certain URL and having some properties.
*
* @param url [string] the URL to open a new window to.
* @param windowName [string] the name of the new window (as for target attribute).
* @param width [number] the width of the new window in pixels.
* @param height [number] the height of the new window in pixels.
* @param scrollbars [string] "yes" or "no" for scrollbars.
*
* @return [object] the new window
*/
Zapatec.Utils.newCenteredWindow = function(url, windowName, width, height, scrollbars){
var leftPosition = 0;
var topPosition = 0;
if (screen.width)
leftPosition = (screen.width - width)/2;
if (screen.height)
topPosition = (screen.height - height)/2;
var winArgs =
'height=' + height +
',width=' + width +
',top=' + topPosition +
',left=' + leftPosition +
',scrollbars=' + scrollbars +
',resizable';
var win = window.open(url,windowName,winArgs);
return win;
};
/**
* Finds the size of the current web page. This is the usable size
* and does not include the browser's menu and buttons.
*
* @return [object] dimension with the height and width of the window
*/
Zapatec.Utils.getWindowSize = function() {
var iWidth = 0;
var iHeight = 0;
if (Zapatec.is_opera) {
iWidth = document.body.clientWidth || 0;
iHeight = document.body.clientHeight || 0;
} else if (Zapatec.is_khtml) {
iWidth = window.innerWidth || 0;
iHeight = window.innerHeight || 0;
} else if (document.compatMode && document.compatMode == 'CSS1Compat') {
// Standards-compliant mode
iWidth = document.documentElement.clientWidth || 0;
iHeight = document.documentElement.clientHeight || 0;
} else {
// Non standards-compliant mode
iWidth = document.body.clientWidth || 0;
iHeight = document.body.clientHeight || 0;
}
return {
width: iWidth,
height: iHeight
};
};
/**
* Given a reference to a select element, this function will select the option
* having the given value and optionally will call the default handler for
* "onchange".
*
* @param sel [HTMLSelectElement] reference to the SELECT element.
* @param val [string] the value that we should select.
* @param call_default [boolean] true if the default onchange should be called.
*/
Zapatec.Utils.selectOption = function(sel, val, call_default) {
var a = sel.options, i, o;
for (i = a.length; --i >= 0;) {
o = a[i];
o.selected = (o.val == val);
}
sel.value = val;
if (call_default) {
if (typeof sel.onchange == "function")
sel.onchange();
else if (typeof sel.onchange == "string")
eval(sel.onchange);
}
};
/**
* A more flexible way to get the "nextSibling" of a given element. If the
* "tag" argument is passed, then this function will return the next sibling
* that has a certain tag. Otherwise it will simply return el.nextSibling.
*
* @param {object} el Element object
* @param {string} tag Optional. Tag name of the returned element
* @param {string} alternateTag Optional. Alternate tag name of the returned
* element
* @return First element after el having the specified tag; null if element
* is not found; nextSibling if tag is not specified
* @type object
*/
Zapatec.Utils.getNextSibling = function(el, tag, alternateTag) {
el = el.nextSibling;
if (!tag) {
return el;
}
tag = tag.toLowerCase();
if (alternateTag) alternateTag = alternateTag.toLowerCase();
while (el) {
if (el.nodeType == 1 && (el.tagName.toLowerCase() == tag ||
(alternateTag && el.tagName.toLowerCase() == alternateTag))) {
return el;
}
el = el.nextSibling;
}
return el;
};
/**
* A more flexible way to get the "previousSibling" of a given element. If the
* "tag" argument is passed, then this function will return the previous sibling
* that has a certain tag. Otherwise it will simply return el.previousSibling.
*
* @param {object} el Element object
* @param {string} tag Optional. Tag name of the returned element
* @param {string} alternateTag Optional. Alternate tag name of the returned
* element
* @return First element before el having the specified tag; previousSibling if
* tag is not specified; null if desired element is not found
* @type object
*/
Zapatec.Utils.getPreviousSibling = function(el, tag, alternateTag) {
el = el.previousSibling;
if (!tag) {
return el;
}
tag = tag.toLowerCase();
if (alternateTag) alternateTag = alternateTag.toLowerCase();
while (el) {
if (el.nodeType == 1 && (el.tagName.toLowerCase() == tag ||
(alternateTag && el.tagName.toLowerCase() == alternateTag))) {
return el;
}
el = el.previousSibling;
}
return el;
};
/**
* Returns first child of the given element that has a specified tag.
*
* @param {object} el Element object
* @param {string} tag Optional. Tag name of the returned element
* @param {string} alternateTag Optional. Alternate tag name of the returned
* element
* @return First child of the element that has a specified tag; firstChild if
* tag is not specified; null if desired element is not found
* @type object
*/
Zapatec.Utils.getFirstChild = function(el, tag, alternateTag) {
if (!el) {
return null;
}
el = el.firstChild;
if (!el) {
return null;
}
if (!tag) {
return el;
}
tag = tag.toLowerCase();
if (el.nodeType == 1) {
if (el.tagName.toLowerCase() == tag) {
return el;
} else if (alternateTag) {
alternateTag = alternateTag.toLowerCase();
if (el.tagName.toLowerCase() == alternateTag) {
return el;
}
}
}
return Zapatec.Utils.getNextSibling(el, tag, alternateTag);
};
/**
* Returns last child of the given element that has a specified tag.
*
* @param {object} el Element object
* @param {string} tag Optional. Tag name of the returned element
* @param {string} alternateTag Optional. Alternate tag name of the returned
* element
* @return Last child of the element that has a specified tag; lastChild if
* tag is not specified; null if desired element is not found
* @type object
*/
Zapatec.Utils.getLastChild = function(el, tag, alternateTag) {
if (!el) {
return null;
}
el = el.lastChild;
if (!el) {
return null;
}
if (!tag) {
return el;
}
tag = tag.toLowerCase();
if (el.nodeType == 1) {
if (el.tagName.toLowerCase() == tag) {
return el;
} else if (alternateTag) {
alternateTag = alternateTag.toLowerCase();
if (el.tagName.toLowerCase() == alternateTag) {
return el;
}
}
}
return Zapatec.Utils.getPreviousSibling(el, tag, alternateTag);
};
/**
* Function that concatenates and returns all text child nodes of the
* specified node.
*
* @param objNode [Node] -- reference to the node.
* @return [string] -- concatenated text child nodes
*/
Zapatec.Utils.getChildText = function(objNode) {
if (objNode == null) {
return '';
}
var arrText = [];
var objChild = objNode.firstChild;
while (objChild != null) {
if (objChild.nodeType == 3) { // Node.TEXT_NODE
arrText.push(objChild.data);
}
objChild = objChild.nextSibling;
}
return arrText.join(' ');
};
/**
* Similar to the DOM's built in insertBefore.
* Insert a node after an existing node.
*
* @param el [oldNode] The existing element
* @param el [newNode] the new element to insert after the old one.
*
*/
Zapatec.Utils.insertAfter = function(oldNode, newNode) {
if(oldNode.nextSibling) {
oldNode.parentNode.insertBefore(newNode, oldNode.nextSibling);
} else {
oldNode.parentNode.appendChild(newNode);
}
}
Zapatec.Utils._ids = {}; /**< [number, static] maintains a list of generated IDs */
/**
* Generates an unique ID, for a certain code (let's say "class"). If the
* optional "id" argument is passed, then it just returns the id for that code
* (no generation). This function is sometimes useful when we need to create
* elements and be able to access them later by ID.
*
* @param code [string] the class of ids. User defined, can be anything.
* @param id [string, optional] specify if the ID is already known.
*
* @return [string] the unique ID
*/
Zapatec.Utils.generateID = function(code, id) {
if (typeof id == "undefined") {
if (typeof this._ids[code] == "undefined")
this._ids[code] = 0;
id = ++this._ids[code];
}
return "zapatec-" + code + "-" + id;
};
/**
* Add a tooltip to the specified element.
*
* Function that adds a custom tooltip for an element. The "target" is the
* element to where the tooltip should be added to, and the "tooltip" is a DIV
* that contains the tooltip text. Optionally, the tooltip DIV can have the
* "title" attribute set; if so, its value will be displayed highlighted as
* the title of the tooltip.
*
* @param target reference to or ID of the target element
* @param tooltip reference to or ID of the tooltip content element
*/
Zapatec.Utils.addTooltip = function(target, tooltip) {
return new Zapatec.Tooltip(target, tooltip);
};
Zapatec.isLite=true;
Zapatec.Utils.checkActivation = function() {
if (!Zapatec.isLite) return true;
var arrProducts=[]
add_product=function(script, webdir_in, name_in)
{
arrProducts[script]={webdir:webdir_in, name:name_in, bActive:false}
}
add_product('calendar.js', 'prod1', 'Calendar')
add_product('zpmenu.js', 'prod2', 'Menu')
add_product('tree.js', 'prod3', 'Tree')
add_product('form.js', 'forms', 'Forms')
add_product('effects.js', 'effects', 'Effects')
add_product('hoverer.js', 'effects', 'Effects - Hoverer')
add_product('slideshow.js','effects', 'Effects - Slidshow')
add_product('zpgrid.js', 'grid', 'Grid')
add_product('slider.js', 'slider', 'Slider')
add_product('zptabs.js', 'tabs', 'Tabs')
add_product('zptime.js', 'time', 'Time')
add_product('window.js', 'windows', 'Window')
var strName, arrName, i
var bProduct=false // Flag yes if we have a zapatec script
var scripts = document.getElementsByTagName('script');
for (i=0; i= len; i--) {
this[i] = this[i - len];
}
for (i = 0; i < len; i++) {
this[i] = arguments[i];
}
}
return this.length;
};
}
/**
* Simulation of Array splice() method that is missing in IE 5.0.
*/
if (!Array.prototype.splice) {
Array.prototype.splice = function(index, howMany) {
var elements = [], removed = [], i;
for (i = 2; i < arguments.length; i++) {
elements.push(arguments[i]);
}
for (i = index; (i < index + howMany) && (i < this.length); i++) {
removed.push(this[i]);
}
for (i = index + howMany; i < this.length; i++) {
this[i - howMany] = this[i];
}
this.length -= removed.length;
for (i = this.length + elements.length - 1; i >= index + elements.length;
i--) {
this[i] = this[i - elements.length];
}
for (i = 0; i < elements.length; i++) {
this[index + i] = elements[i];
}
return removed;
};
}
/**
* Crossbrowser replacement for Array indexOf() method. See:
* http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Objects:Array:indexOf
*
* @param {object} arr Array to search in
* @param {any} searchElement Element to locate in the array
* @param {any} fromIndex The index at which to begin the search
* @return The first index at which a given element can be found in the array,
* or -1 if it is not present
* @type number
*/
Zapatec.Utils.arrIndexOf = function(arr, searchElement, fromIndex) {
if (Array.prototype.indexOf) {
return arr.indexOf(searchElement, fromIndex);
}
if (!fromIndex) {
fromIndex = 0;
}
for (var iElement = fromIndex; iElement < arr.length; iElement++) {
if (arr[iElement] == searchElement) {
return iElement;
}
}
return -1;
};
/**
* Displays error message. Override this if needed.
*
* \param objArgs [number] error object:
* {
* severity: [string, optional] error severity,
* description: [string] human readable error description
* }
*/
Zapatec.Log = function(objArgs) {
// Check arguments
if (!objArgs) {
return;
}
// Form error message
var strMessage = objArgs.description;
if (objArgs.severity) {
strMessage = objArgs.severity + ':\n' + strMessage;
}
// Display error message
alert(strMessage);
};
/// Zapatec.Utils.Array object which contains additional for arrays method
Zapatec.Utils.Array = {};
/**
* Inserts the element into array.
* It influences the order in which the elements will be iterated in the for...in cycle.
*
* @param arr [array] array to work with.
* @param el [mixed] element to insert.
* @param key [string] element to insert.
* @param nextKey [string] element to be inserted before.
* @return [string] new Array.
*/
Zapatec.Utils.Array.insertBefore = function (arr, el, key, nextKey) {
var tmp = new Array();
for(var i in arr) {
if (i == nextKey) {
if (key) {
tmp[key] = el;
} else {
tmp.push(el);
}
}
tmp[i] = arr[i];
}
return tmp;
}
/**
* Extends one class with another. Gives ability to access properties and
* methods of the superclass having the same names as in subclass.
*
*
* Zapatec.Widget specific feature: If superclass has static property "path",
* subclass will get path to js file from which this function is called into
* "path" property instead of value from superclass.
*
* To determine path correctly when widget module is included using
* Zapatec#include, static property "id" should be set in widget class. Value of
* this property must be passed to Zapatec#include as script id.
*
* Should be used as follows:
*
* // Define SuperClass and its methods
* Zapatec.SuperClass = function(objArgs) {
* ...
* };
*
* Zapatec.SuperClass.prototype.init = function(objArgs) {
* ...
* };
*
* // Define SubClass and its methods
* Zapatec.SubClass = function(objArgs) {
* ...
* // Call constructor of superclass
* Zapatec.SubClass.SUPERconstructor.call(this, objArgs);
* ...
* };
*
* // Unique static id of the widget class to determine path correctly
* // Neded only if class is derived from Zapatec.Widget class
* Zapatec.SubClass.id = 'Zapatec.SubClass';
*
* // Inherit SuperClass
* Zapatec.inherit(Zapatec.SubClass, Zapatec.SuperClass);
*
* Zapatec.SubClass.prototype.init = function(objArgs) {
* ...
* // Call method of superclass
* Zapatec.SubClass.SUPERclass.init.call(this, objArgs);
* ...
* };
*
* Note: This function must be invoked during page load to determine path to js
* file from which it is called correctly.
*
*
* @param {object} objSubClass Inheriting class
* @param {object} objSuperClass Class from which to inherit
*/
Zapatec.inherit = function(objSubClass, objSuperClass) {
// Duplicate prototype of superclass
var Inheritance = function() {};
Inheritance.prototype = objSuperClass.prototype;
objSubClass.prototype = new Inheritance();
// Fix constructor property to point to the self constructor because it is
// pointing to the nested Inheritance function
objSubClass.prototype.constructor = objSubClass;
// Reference to constructor of superclass to be able to invoke it
objSubClass.SUPERconstructor = objSuperClass;
// Reference to prototype of superclass to be able to invoke its methods
objSubClass.SUPERclass = objSuperClass.prototype;
// Path to js file from which this function is called
if (typeof objSuperClass.path != 'undefined') {
objSubClass.path = Zapatec.getPath(objSubClass.id);
}
};
/**
* Returns path from the script element with specified id. If id is not
* specified or specified id is not found on the page, returns path from the
* last loaded script element. Splits src attribute value and returns path
* without js file name. Returns empty string if path is not found.
*
*
* If specified id is not found on the page, returns last script element instead
* of alerting. This gives ability for developer to include script using
* Zapatec#include and specify id because in some cases it may be needed to get
* correct path; and for user to include script directly into the page without
* remembering internal Zapatec ids because id is not needed to determine path
* correctly in this case.
*
* Developer is responsible for checking that the same script id is passed to
* Zapatec#include and Zapatec#getPath because there is no alert if they are
* different and result may be wrong.
*
* Note: This function must be invoked during page load to determine path to js
* file from which it is called correctly.
*
*
* @param {string} strId Optional. Id of the script element
* @return Path to the script, e.g. '../src/' or '' if path is not found
* @type string
*/
Zapatec.getPath = function(strId) {
// Get script element
var objScript;
if (typeof strId == 'string') {
// Try to use element with specified id
objScript = document.getElementById(strId);
}
if (!objScript) {
if(Zapatec.lastLoadedModule != null){
return Zapatec.lastLoadedModule;
}
// Get last script element
var objContainer = document.body;
if (!objContainer) {
objContainer = document.getElementsByTagName('head')[0];
if (!objContainer) {
objContainer = document;
}
}
objScript = Zapatec.Utils.getLastChild(objContainer, 'script');
}
if (!objScript) {
// Not found
return '';
}
// Get path
var strSrc = objScript.getAttribute('src');
if (!strSrc) {
return '';
}
var arrTokens = strSrc.split('/');
// Remove last token
arrTokens = arrTokens.slice(0, -1);
if (!arrTokens.length) {
return '';
}
return arrTokens.join('/') + '/';
};
/**
* This is some kind of indicator that window has already loaded.
*/
Zapatec.windowLoaded = typeof(document.readyState) != 'undefined' ?
(
document.readyState == 'loaded' || // Konqueror
document.readyState == 'complete' // IE/Opera
) :
// Mozilla
document.getElementsByTagName != null && typeof(document.getElementsByTagName('body')[0]) != 'undefined'
;
Zapatec.Utils.addEvent(window, "load", function() {Zapatec.windowLoaded = true;});
/*
* Use this method to display your custom message before unload event.
* For example you could warn user that he has some unsaved changes
* on page.
*
* \param msg [string] - message to display. Default value - "All your changes will be lost.":
* \param win [object] - reference to window object. By default - current window
*/
Zapatec.Utils.warnUnload = function(msg, win){
Zapatec.Utils.warnUnloadFlag = true;
if(typeof(msg) != "string"){
msg = "All your changes will be lost.";
}
if(typeof(win) == 'undefined'){
win = window;
}
Zapatec.Utils.addEvent(win, 'beforeunload', function(ev){
if(Zapatec.Utils.warnUnloadFlag != true){
return true;
}
if(typeof(ev) == 'undefined'){
ev = window.event;
}
ev.returnValue = msg;
return false;
});
}
/*
* Using this method you can remove displaying of your message on page unload.
*/
Zapatec.Utils.unwarnUnload = function(msg, win){
Zapatec.Utils.warnUnloadFlag = false;
}
/*
* \internal Variable that determines if unload handler should be used.
*/
Zapatec.Utils.warnUnloadFlag = false;
/**
* @return Max z-index value
* @type number
*/
Zapatec.Utils.getMaxZindex = function() {
if (window.opera || Zapatec.is_khtml) {
return 2147483583;
} else if (Zapatec.is_ie){
return 2147483647;
} else {
return 10737418239;
}
};
/**
* Corrects CSS length.
*
* @param {any} val Value to correct
* @return Valid CSS length
* @type string
*/
Zapatec.Utils.correctCssLength = function(val) {
if (typeof val == 'undefined' || (typeof val == 'object' && !val)) {
// Undefined or null
return 'auto';
}
// Convert to string
val += '';
if (!val.length) {
// Empty
return 'auto';
}
if (/\d$/.test(val)) {
// Number
val += 'px';
}
return val;
};
/**
* @ignore Holds properties of DOM objects that must be set to null on window
* unload event to prevent memory leaks in IE.
*/
Zapatec.Utils.destroyOnUnload = [];
/**
* Saves a property that must be set to null on window unload event. Should be
* used for properties that can't be destroyed by garbage collector due to
* circular references.
*
* @param {object} objElement DOM object
* @param {string} strProperty Property name
*/
Zapatec.Utils.addDestroyOnUnload = function(objElement, strProperty) {
Zapatec.Utils.destroyOnUnload.push([objElement, strProperty]);
};
/**
* Assigns a value to a custom property of DOM object. This property will be
* set to null on window unload event. Use this function to create properties
* that can't be destroyed by garbage collector due to circular references.
*
* @param {object} objElement DOM object
* @param {string} strProperty Property name
* @param {any} val Property value
*/
Zapatec.Utils.createProperty = function(objElement, strProperty, val) {
objElement[strProperty] = val;
Zapatec.Utils.addDestroyOnUnload(objElement, strProperty);
};
// Remove circular references to prevent memory leaks in IE
Zapatec.Utils.addEvent(window, 'unload', function() {
for (var iObj = Zapatec.Utils.destroyOnUnload.length - 1; iObj >= 0; iObj--) {
var objDestroy = Zapatec.Utils.destroyOnUnload[iObj];
objDestroy[0][objDestroy[1]] = null;
objDestroy[0] = null;
}
for (var iLis = Zapatec.Utils.removeOnUnload.length - 1; iLis >= 0; iLis--) {
var listener = Zapatec.Utils.removeOnUnload[iLis];
Zapatec.Utils.removeEvent(listener["element"], listener["event"], listener["listener"]);
}
});
/**
* Escapes all special HTML characters so string can be added via innerHTML property as-is
*
* @param {string} str String to escape
* @return escaped string
* @type string
*/
Zapatec.Utils.htmlEncode = function(str) {
// we don't need regexp for that, but.. so be it for now.
str = str.replace(/&/ig, "&");
str = str.replace(//ig, ">");
str = str.replace(/\x22/ig, """);
// \x22 means '"' -- we use hex reprezentation so that we don't disturb
// JS compressors (well, at least mine fails.. ;)
return str;
};
/**
* Applies given style to given element.
* @param {any} elRef reference to target element. Required.
* @param {string} style string value of style. Required.
*/
Zapatec.Utils.applyStyle = function(elRef, style){
if(typeof(elRef) == 'string'){
elRef = document.getElementById(elRef);
}
if(elRef == null || style == null || elRef.style == null){
return null;
}
if(Zapatec.is_opera){
var pairs = style.split(";");
for(var ii =0; ii < pairs.length; ii++){
var kv = pairs[ii].split(":");
// trim value
if (!kv[1]) {
continue;
}
var value = kv[1].replace(/^\s*/, '').replace(/\s*$/, '');
var key = "";
for(var jj = 0; jj < kv[0].length; jj++){
if(kv[0].charAt(jj) == "-"){
jj++;
if(jj < kv[0].length){
key += kv[0].charAt(jj).toUpperCase();
}
continue;
}
key += kv[0].charAt(jj);
}
switch(key){
case "float":
key = "cssFloat";
break;
}
try{
elRef.style[key] = value;
} catch(e){}
}
} else {
elRef.style.cssText = style;
}
return true;
}
/**
* Retrieves computed CSS property values from an element.
*
* @param {object} Element object
* @param {string} Property name of element's style, e.g. "borderLeftWidth"
* @return Computed CSS property value
* @type string
*/
Zapatec.Utils.getStyleProperty = function(objElement, strProperty) {
if (document.defaultView && document.defaultView.getComputedStyle) {
// Standard
strProperty = strProperty.replace(/([A-Z])/g, '-$1').toLowerCase();
return document.defaultView.getComputedStyle(objElement, '')
.getPropertyValue(strProperty);
} else if (objElement.currentStyle) {
// IE
return objElement.currentStyle[strProperty];
}
// None
return objElement.style[strProperty];
};
/**
* Returns precision of a number with floating point.
*
* @param {number} fFloat Number with floating point
* @return Precision
* @type number
*/
Zapatec.Utils.getPrecision = function(fFloat){
return (fFloat + '').replace(/^\d*\.*/, '').length;
};
/**
* Reduces precision of a number with floating point. Useful to correct
* precision before displaying the result of arithmetic operation. E.g.
* 1.1 + 2.22 == 3.3200000000000003 and
* Zapatec.Utils.setPrecision(1.1 + 2.22) == 3.32 .
*
* Unlike Number.prototype.toPrecision, returns integer if param iPrecision
* is 0.
*
* @param {number} fFloat Number with floating point
* @param {number} iPrecision Desired precision
* @return Number with floating point with desired precision
* @type number
*/
Zapatec.Utils.setPrecision = function(fFloat, iPrecision){
var iPow = Math.pow(10, iPrecision);
return parseInt(fFloat * iPow, 10) / iPow;
};