/**
 * @fileoverview Common functions used in all southprojects widgets.
 *
 * <pre>
 * Copyright (c) 2006 by SouthProjects
 * http://www.southprojects.com
 * Santiago, Chile,
 * Version 1.2 Dec 2006.
 * All rights reserved.
 * </pre>
 */

/* $Id: utils.js 5148 2006-11-15 20:14:58Z jcastro $ */

if (typeof southprojects == 'undefined') {
  /**
   * Namespace definition.
   * @constructor
   */
  southprojects = {};
}

/**************************** ErrorHandler ****************************/
southprojects.ErrorHandler = {};

southprojects.ErrorHandler.setup = function(window, report_url) {
	this.window = window;
	this.report_url = report_url;

	this.window.onerror = southprojects.ErrorHandler.handleError;
}

southprojects.ErrorHandler.handleError = function(desc, path, line) {
	if (southprojects.ErrorHandler.err_stack == undefined) southprojects.ErrorHandler.err_stack = [];
	southprojects.ErrorHandler.err_stack.push([desc, path, line]);

	return false;
}

southprojects.ErrorHandler.getErrStack = function() {
	return southprojects.ErrorHandler.err_stack;
}

//southprojects.ErrorHandler.setup(self);
/************************** ErrorHandler end **************************/

/// define the Utils namespace
southprojects.Utils = {};

/// Deprecated. Use southprojects.Utils.getElementOffset instead.
/// Retrieves the absolute position (relative to <body>) of a given element.
///
/// @param el [HTMLElement] reference to the element.
/// @return [object] { x, y } containing the position.
southprojects.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
 */
southprojects.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 += southprojects.Utils.getPageScrollX() - 2;
    iTop += southprojects.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
 */
southprojects.Utils.getElementOffsetScrollable = function(objElement) {
  var objPos = southprojects.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.
southprojects.Utils.fixBoxPosition = function(box) {
	if (box.x < 0)
		box.x = 0;
	if (box.y < 0)
		box.y = 0;
	var cp = southprojects.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 = southprojects.Utils.getAbsolutePos(cp);
	window.document.body.removeChild(cp);
	if (southprojects.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 (!southprojects.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
southprojects.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.
southprojects.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.
southprojects.Utils.addClass = function(el, className) {
	southprojects.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.
southprojects.Utils.getElement = function(ev) {
	if (southprojects.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.
southprojects.Utils.getTargetElement = function(ev) {
	if (southprojects.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:
 * <pre>
 * {
 *   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
 * }
 * </pre>
 * @type object
 */
southprojects.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 + southprojects.Utils.getPageScrollX();
      objPos.pageY = objEvent.clientY + southprojects.Utils.getPageScrollY();
    }
    if (boolIsClientX) {
      objPos.clientX = objEvent.clientX;
      objPos.clientY = objEvent.clientY;
    } else {
      objPos.clientX = objEvent.pageX - southprojects.Utils.getPageScrollX();
      objPos.clientY = objEvent.pageY - southprojects.Utils.getPageScrollY();
    }
  }
  return objPos;
};

/// Stops bubbling and propagation of some event.
/// @param ev [Event] the event object
/// @return false
southprojects.Utils.stopEvent = function(ev) {
	ev || (ev = window.event);
	if (ev) {
		if (southprojects.is_ie) {
			ev.cancelBubble = true;
			ev.returnValue = false;
		} else {
			ev.preventDefault();
			ev.stopPropagation();
		}
	}
	return false;
};

southprojects.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
southprojects.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;
	}
	southprojects.Utils.removeOnUnload.push({"element" : el, "event" : evname, "listener" : func});
};

/// Removes an event handler added with southprojects.Utils.addEvent().  The
/// prototype scheme is the same.
southprojects.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.
southprojects.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 (southprojects.is_ie)
			el.setAttribute("unselectable", true);
		if (southprojects.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.
southprojects.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
southprojects.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;
};
*/

southprojects.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.
 */
southprojects.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 southprojects.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.
 */
southprojects.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.
 */
southprojects.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
//@{

southprojects.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.
 */
southprojects.Utils.createWCH = function(element) {
	var f = null;
	element = element || window.self.document.body;
	if (southprojects.is_ie && !southprojects.is_ie5) {
		var filter = 'filter:progid:DXImageTransform.Microsoft.alpha(style=0,opacity=0);';
		var id = "WCH" + (++southprojects.Utils.__wch_id);
		element.insertAdjacentHTML
			('beforeEnd', '<iframe id="' + id + '" scroll="no" frameborder="0" ' +
			 'style="z-index:0;position:absolute;visibility:hidden;' + filter +
			 'border:0;top:0;left:0;width:0;height:0;" ' +
			 'src="javascript:false;"></iframe>');
		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.
 */
southprojects.Utils.setupWCH_el = function(f, el, el2) {
	if (f) {
		var pos = southprojects.Utils.getAbsolutePos(el),
			X1 = pos.x,
			Y1 = pos.y,
			X2 = X1 + el.offsetWidth,
			Y2 = Y1 + el.offsetHeight;
		if (el2) {
			var p2 = southprojects.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;
		}
		southprojects.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.
 */
southprojects.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.
 */
southprojects.Utils.hideWCH = function(f) {
	if (f)
		f.style.visibility = "hidden";
};

//@}

/// \defgroup Scroll-with-window functions
//@{

/**
 * Returns current document vertical scroll position.
 */
southprojects.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.
 */
southprojects.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.
southprojects.ScrollWithWindow = {};
southprojects.ScrollWithWindow.list = [];
// Set to a number between 0 and 1, lower means longer scrolling.
southprojects.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.
 */
southprojects.ScrollWithWindow.register = function(node) {
	var top = node.offsetTop || 0;
	var left = node.offsetLeft || 0;
	southprojects.ScrollWithWindow.list[southprojects.ScrollWithWindow.list.length] = {
		node: node,
		origTop: top,
		origleft: left
	};
};

/**
 * Unregisters a given object.
 *
 * @param node [HTMLElement] -- a reference to the node to scroll.
 */
southprojects.ScrollWithWindow.unregister = function(node) {
	for (var count = 0; count < southprojects.ScrollWithWindow.list.length; count++) {
		var elm = southprojects.ScrollWithWindow.list[count];
		if (node == elm.node) {
			southprojects.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
 */
southprojects.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 < southprojects.ScrollWithWindow.list.length; count++) {
		var elm = southprojects.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 = southprojects.Utils.getPageScrollY();
var oldScrollX = southprojects.Utils.getPageScrollX();
setInterval(
	'var newScrollY = southprojects.Utils.getPageScrollY(); ' +
	'var newScrollX = southprojects.Utils.getPageScrollX(); ' +
	'if (newScrollY != oldScrollY) { ' +
		'southprojects.ScrollWithWindow.handler(newScrollY, "vertical"); ' +
	'}' +
	'if (newScrollX != oldScrollX) { ' +
		'southprojects.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.
 */
southprojects.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
 */
southprojects.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
 */
southprojects.Utils.getWindowSize = function() {
	var iWidth = 0;
	var iHeight = 0;

	if (southprojects.is_opera) {
		iWidth = document.body.clientWidth || 0;
		iHeight = document.body.clientHeight || 0;
	} else if (southprojects.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.
 */
southprojects.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
 */
southprojects.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
 */
southprojects.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
 */
southprojects.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 southprojects.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
 */
southprojects.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 southprojects.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
 */
southprojects.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.
 *
 */
southprojects.Utils.insertAfter = function(oldNode, newNode) {
	if(oldNode.nextSibling) {
		oldNode.parentNode.insertBefore(newNode, oldNode.nextSibling);
	} else {
		oldNode.parentNode.appendChild(newNode);
	}
}

southprojects.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
 */
southprojects.Utils.generateID = function(code, id) {
	if (typeof id == "undefined") {
		if (typeof this._ids[code] == "undefined")
			this._ids[code] = 0;
		id = ++this._ids[code];
	}
	return "southprojects-" + 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
*/

southprojects.Utils.addTooltip = function(target, tooltip) {
return new southprojects.Tooltip(target, tooltip);
};

southprojects.isLite=false;

southprojects.Utils.checkActivation = function() {
	if (!southprojects.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('spgrid.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 southprojects script
	var scripts = document.getElementsByTagName('script');
	for (i=0; i<scripts.length; i++)
	{
		// If wizard then do NOT do link back check, which makes wizard err out
		if (/wizard.js/i.test(scripts[i].src))
			return true

		arrName=scripts[i].src.split('/')
		if (arrName.length==0)
			strName=scripts[i]
		else
			strName=arrName[arrName.length-1]
		strName=strName.toLowerCase()
		// Get each active product
		if (typeof arrProducts[strName] != 'undefined')
			{
			bProduct=true
			arrProducts[strName].bActive=true
			}
	}

	
	return true;
	// Is a LITE product even being used?
	
	
	// no usado de momento.
	if (!bProduct) return true;


	var anchors = document.getElementsByTagName('A');
	
	for(i = 0; i < anchors.length; i++)
		if (/(dev|www)\.southprojects\.com/i.test(anchors[i].href))
			return true;

	var strMsg='Error interno del sistema.\n'+'Datos no encontrado.';

	for (i in arrProducts)
		// Get each active product
		if (arrProducts[i].bActive==true)
			strMsg+='\nProblemas en libreria: ' + arrProducts[i].name ;

	alert(strMsg)

	return false;
	
}

/**
 * Makes a copy of an object.
 *
 * @param {object} objSource Source object to clone
 */
southprojects.Utils.clone = function(objSource) {
  var objClone;
  if ((objSource instanceof String) || (objSource instanceof Number) ||
   (objSource instanceof Boolean)) {
    objClone = new objSource.constructor(objSource.valueOf());
  } else {
    objClone = new objSource.constructor();
  }
  for (var strProperty in objSource) {
    if (typeof objSource[strProperty] == 'object') {
      objClone[strProperty] = southprojects.Utils.clone(objSource[strProperty], true);
    } else {
      objClone[strProperty] = objSource[strProperty];
    }
  }
  return objClone;
};

// Browser sniffing

/// detect Opera browser
southprojects.is_opera = /opera/i.test(navigator.userAgent);

/// detect a special case of "web browser"
southprojects.is_ie = ( /msie/i.test(navigator.userAgent) && !southprojects.is_opera );

/// detect IE5.0/Win
southprojects.is_ie5 = ( southprojects.is_ie && /msie 5\.0/i.test(navigator.userAgent) );

/// detect IE7.0/Win
southprojects.is_ie7 = ( southprojects.is_ie && /msie 7\.0/i.test(navigator.userAgent) );

/// detect IE for Macintosh
southprojects.is_mac_ie = ( /msie.*mac/i.test(navigator.userAgent) && !southprojects.is_opera );

/// detect KHTML-based browsers
southprojects.is_khtml = /Konqueror|Safari|KHTML/i.test(navigator.userAgent);

/// detect Konqueror
southprojects.is_konqueror = /Konqueror/i.test(navigator.userAgent);

/// detect Gecko
southprojects.is_gecko = /Gecko/i.test(navigator.userAgent);

/**
 * Simulation of Object hasOwnProperty() method that is missing in IE 5.0.
 */
if (!Object.prototype.hasOwnProperty) {
  Object.prototype.hasOwnProperty = function(strProperty) {
    try {
      var objPrototype = this.constructor.prototype;
      while (objPrototype) {
        if (objPrototype[strProperty] == this[strProperty]) {
          return false;
        }
        objPrototype = objPrototype.prototype;
      }
    } catch (objException) {}
    return true;
  };
}

/**
 * Simulation of Function call() method that is missing in IE 5.0.
 */
if (!Function.prototype.call) {
	Function.prototype.call = function() {
		var objThis = arguments[0];
		objThis._this_func = this;
		var arrArgs = [];
		for (var iArg = 1; iArg < arguments.length; iArg++) {
			arrArgs[arrArgs.length] = 'arguments[' + iArg + ']';
		}
		var ret = eval('objThis._this_func(' + arrArgs.join(',') + ')');
		objThis._this_func = null;
		return ret;
	};
}

/**
 * Simulation of Function apply() method that is missing in IE 5.0.
 */
if (!Function.prototype.apply) {
	Function.prototype.apply = function() {
		var objThis = arguments[0];
		var objArgs = arguments[1];
		objThis._this_func = this;
		var arrArgs = [];
		if (objArgs) {
			for (var iArg = 0; iArg < objArgs.length; iArg++) {
				arrArgs[arrArgs.length] = 'objArgs[' + iArg + ']';
			}
		}
		var ret = eval('objThis._this_func(' + arrArgs.join(',') + ')');
		objThis._this_func = null;
		return ret;
	};
}

/**
 * Simulation of Array pop() method that is missing in IE 5.0.
 */
if (!Array.prototype.pop) {
	Array.prototype.pop = function() {
		var last;
		if (this.length) {
			last = this[this.length - 1];
			this.length -= 1;
		}
		return last;
	};
}

/**
 * Simulation of Array push() method that is missing in IE 5.0
 */
if (!Array.prototype.push) {
	Array.prototype.push = function() {
		for (var i = 0; i < arguments.length; i++) {
			this[this.length] = arguments[i];
		}
		return this.length;
	};
}

/**
 * Simulation of Array shift() method that is missing in IE 5.0.
 */
if (!Array.prototype.shift) {
	Array.prototype.shift = function() {
		var first;
		if (this.length) {
			first = this[0];
			for (var i = 0; i < this.length - 1; i++) {
				this[i] = this[i + 1];
			}
			this.length -= 1;
		}
		return first;
	};
}

/**
 * Simulation of Array unshift() method that is missing in IE 5.0.
 */
if (!Array.prototype.unshift) {
	Array.prototype.unshift = function() {
		if (arguments.length) {
			var i, len = arguments.length;
			for (i = this.length + len - 1; 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
 */
southprojects.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
 * }
 */
southprojects.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);
};

/// southprojects.Utils.Array object which contains additional for arrays method
southprojects.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.
 */
southprojects.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.
 *
 * <pre>
 * southprojects.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
 * southprojects#include, static property "id" should be set in widget class. Value of
 * this property must be passed to southprojects#include as script id.
 *
 * Should be used as follows:
 *
 * // Define SuperClass and its methods
 * southprojects.SuperClass = function(objArgs) {
 *   ...
 * };
 *
 * southprojects.SuperClass.prototype.init = function(objArgs) {
 *   ...
 * };
 *
 * // Define SubClass and its methods
 * southprojects.SubClass = function(objArgs) {
 *   ...
 *   // Call constructor of superclass
 *   southprojects.SubClass.SUPERconstructor.call(this, objArgs);
 *   ...
 * };
 *
 * // Unique static id of the widget class to determine path correctly
 * // Neded only if class is derived from southprojects.Widget class
 * southprojects.SubClass.id = 'southprojects.SubClass';
 *
 * // Inherit SuperClass
 * southprojects.inherit(southprojects.SubClass, southprojects.SuperClass);
 *
 * southprojects.SubClass.prototype.init = function(objArgs) {
 *   ...
 *   // Call method of superclass
 *   southprojects.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.
 * </pre>
 *
 * @param {object} objSubClass Inheriting class
 * @param {object} objSuperClass Class from which to inherit
 */
southprojects.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 = southprojects.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.
 *
 * <pre>
 * 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
 * southprojects#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 southprojects 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
 * southprojects#include and southprojects#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.
 * </pre>
 *
 * @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
 */
southprojects.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(southprojects.lastLoadedModule != null){
      return southprojects.lastLoadedModule;
    }
    // Get last script element
    var objContainer = document.body;
    if (!objContainer) {
      objContainer = document.getElementsByTagName('head')[0];
      if (!objContainer) {
        objContainer = document;
      }
    }
    objScript = southprojects.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.
 */
southprojects.windowLoaded = typeof(document.readyState) != 'undefined' ?
	(
		document.readyState == 'loaded' || // Konqueror
		document.readyState == 'complete' // IE/Opera
	) :
	// Mozilla
	document.getElementsByTagName != null && typeof(document.getElementsByTagName('body')[0]) != 'undefined'
;

southprojects.Utils.addEvent(window, "load", function() {southprojects.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
 */
southprojects.Utils.warnUnload = function(msg, win){
    southprojects.Utils.warnUnloadFlag = true;
	if(typeof(msg) != "string"){
		msg = "All your changes will be lost.";
	}

	if(typeof(win) == 'undefined'){
		win = window;
	}

	southprojects.Utils.addEvent(win, 'beforeunload', function(ev){
		if(southprojects.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.
 */
southprojects.Utils.unwarnUnload = function(msg, win){
    southprojects.Utils.warnUnloadFlag = false;
}

/*
 * \internal Variable that determines if unload handler should be used.
 */
southprojects.Utils.warnUnloadFlag = false;

/**
 * @return Max z-index value
 * @type number
 */
southprojects.Utils.getMaxZindex = function() {
  if (window.opera || southprojects.is_khtml) {
    return 2147483583;
  } else if (southprojects.is_ie){
    return 2147483647;
  } else {
    return 10737418239;
  }
};

/**
 * Corrects CSS length.
 *
 * @param {any} val Value to correct
 * @return Valid CSS length
 * @type string
 */
southprojects.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.
 */
southprojects.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
 */
southprojects.Utils.addDestroyOnUnload = function(objElement, strProperty) {
  southprojects.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
 */
southprojects.Utils.createProperty = function(objElement, strProperty, val) {
  objElement[strProperty] = val;
  southprojects.Utils.addDestroyOnUnload(objElement, strProperty);
};

// Remove circular references to prevent memory leaks in IE
southprojects.Utils.addEvent(window, 'unload', function() {
  for (var iObj = southprojects.Utils.destroyOnUnload.length - 1; iObj >= 0; iObj--) {
    var objDestroy = southprojects.Utils.destroyOnUnload[iObj];
    objDestroy[0][objDestroy[1]] = null;
    objDestroy[0] = null;
  }
  for (var iLis = southprojects.Utils.removeOnUnload.length - 1; iLis >= 0; iLis--) {
  	var listener = southprojects.Utils.removeOnUnload[iLis];
	southprojects.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
 */
southprojects.Utils.htmlEncode = function(str) {
	// we don't need regexp for that, but.. so be it for now.
	str = str.replace(/&/ig, "&amp;");
	str = str.replace(/</ig, "&lt;");
	str = str.replace(/>/ig, "&gt;");
	str = str.replace(/\x22/ig, "&quot;");
	// \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.
 */
southprojects.Utils.applyStyle = function(elRef, style){
	if(typeof(elRef) == 'string'){
		elRef = document.getElementById(elRef);
	}

	if(elRef == null || style == null || elRef.style == null){
		return null;
	}

	if(southprojects.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
 */
southprojects.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
 */
southprojects.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
 * southprojects.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
 */
southprojects.Utils.setPrecision = function(fFloat, iPrecision){
  var iPow = Math.pow(10, iPrecision);
  return parseInt(fFloat * iPow, 10) / iPow;
};
