/**
 * A base library for Shadowbox used as a standalone (without another base
 * library/adapter combination).
 *
 * This file is part of Shadowbox.
 *
 * Shadowbox is an online media viewer application that supports all of the
 * web's most popular media publishing formats. Shadowbox is written entirely
 * in JavaScript and CSS and is highly customizable. Using Shadowbox, website
 * authors can showcase a wide assortment of media in all major browsers without
 * navigating users away from the linking page.
 *
 * Shadowbox is released under version 3.0 of the Creative Commons Attribution-
 * Noncommercial-Share Alike license. This means that it is absolutely free
 * for personal, noncommercial use provided that you 1) make attribution to the
 * author and 2) release any derivative work under the same or a similar
 * license.
 *
 * If you wish to use Shadowbox for commercial purposes, licensing information
 * can be found at http://mjijackson.com/shadowbox/.
 *
 * @author      Michael J. I. Jackson <mjijackson@gmail.com>
 * @copyright   2007-2008 Michael J. I. Jackson
 * @license     http://creativecommons.org/licenses/by-nc-sa/3.0/
 * @version     SVN: $Id: shadowbox-base.js 103 2008-06-27 06:19:21Z mjijackson $
 */

// create the Shadowbox object first
var Shadowbox = {};

Shadowbox.lib = function() {

	// local style camelizing for speed
	var styleCache = {};
	var camelRe = /(-[a-z])/gi;
	var camelFn = function(m, a) {
		return a.charAt(1).toUpperCase();
	};
	var toCamel = function(style) {
		var camel;
		if (!(camel = styleCache[style])) {
			camel = styleCache[style] = style.replace(camelRe, camelFn);
		}
		return camel;
	};

	var view = document.defaultView;
	var alphaRe = /alpha\([^\)]*\)/gi;

	/**
	 * Sets the opacity of the given element to the specified level.
	 *
	 * @param   {HTMLElement}   el          The element
	 * @param   {Number}        opacity     The opacity to use
	 * @return  void
	 * @private
	 * @static
	 */
	var setOpacity = function(el, opacity) {
		var s = el.style;
		if (window.ActiveXObject) { // IE
			s.zoom = 1; // give "layout"
			s.filter = (s.filter || '').replace(alphaRe, '') +
			           (opacity == 1 ? '' : ' alpha(opacity=' + (opacity * 100) + ')');
		} else {
			s.opacity = opacity;
		}
	};

	return {

		adapter: 'standalone',

		/**
		 * Gets the value of the style on the given element. This function
		 * adapted from Ext.Element.getStyle().
		 *
		 * @param   {HTMLElement}   el      The DOM element
		 * @param   {String}        style   The name of the style (e.g. margin-top)
		 * @return  {mixed}                 The value of the given style
		 * @public
		 * @static
		 */
		getStyle: function() {
			return view && view.getComputedStyle
					? function(el, style) {
				var v, cs, camel;
				if (style == 'float') style = 'cssFloat';
				if (v = el.style[style]) return v;
				if (cs = view.getComputedStyle(el, '')) {
					return cs[toCamel(style)];
				}
				return null;
			}
					: function(el, style) {
				var v, cs, camel;
				if (style == 'opacity') {
					if (typeof el.style.filter == 'string') {
						var m = el.style.filter.match(/alpha\(opacity=(.+)\)/i);
						if (m) {
							var fv = parseFloat(m[1]);
							if (!isNaN(fv)) return (fv ? fv / 100 : 0);
						}
					}
					return 1;
				} else if (style == 'float') {
					style = 'styleFloat';
				}
				var camel = toCamel(style);
				if (v = el.style[camel]) return v;
				if (cs = el.currentStyle) return cs[camel];
				return null;
			};
		}(),

		/**
		 * Sets the style on the given element to the given value. May be an
		 * object to specify multiple values. This function adapted from
		 * Ext.Element.setStyle().
		 *
		 * @param   {HTMLElement}   el      The DOM element
		 * @param   {String/Object} style   The name of the style to set if a
		 *                                  string, or an object of name =>
		 *                                  value pairs
		 * @param   {String}        value   The value to set the given style to
		 * @return  void
		 * @public
		 * @static
		 */
		setStyle: function(el, style, value) {
			if (typeof style == 'string') {
				var camel = toCamel(style);
				if (camel == 'opacity') {
					setOpacity(el, value);
				} else {
					el.style[camel] = value;
				}
			} else {
				for (var s in style) {
					this.setStyle(el, s, style[s]);
				}
			}
		},

		/**
		 * Gets a reference to the given element.
		 *
		 * @param   {String/HTMLElement}    el      The element to fetch
		 * @return  {HTMLElement}                   A reference to the element
		 * @public
		 * @static
		 */
		get: function(el) {
			return typeof el == 'string' ? document.getElementById(el) : el;
		},

		/**
		 * Removes an element from the DOM.
		 *
		 * @param   {HTMLElement}       el      The element to remove
		 * @return  void
		 * @public
		 * @static
		 */
		remove: function(el) {
			el.parentNode.removeChild(el);
		},

		/**
		 * Gets the target of the given event. The event object passed will be
		 * the same object that is passed to listeners registered with
		 * addEvent().
		 *
		 * @param   {mixed}             e       The event object
		 * @return  {HTMLElement}               The event's target element
		 * @public
		 * @static
		 */
		getTarget: function(e) {
			var t = e.target ? e.target : e.srcElement;
			return t.nodeType == 3 ? t.parentNode : t;
		},

		/**
		 * Gets the page X/Y coordinates of the mouse event in an [x, y] array.
		 * The page coordinates should be relative to the document, and not the
		 * viewport. The event object provided here will be the same object that
		 * is passed to listeners registered with addEvent().
		 *
		 * @param   {mixed}         e       The event object
		 * @return  {Array}                 The page X/Y coordinates
		 * @public
		 * @static
		 */
		getPageXY: function(e) {
			var x = e.pageX || (e.clientX +
			                    (document.documentElement.scrollLeft || document.body.scrollLeft));
			var y = e.pageY || (e.clientY +
			                    (document.documentElement.scrollTop || document.body.scrollTop));
			return [x, y];
		},

		/**
		 * Prevents the event's default behavior. The event object here will
		 * be the same object that is passed to listeners registered with
		 * addEvent().
		 *
		 * @param   {mixed}             e       The event object
		 * @return  void
		 * @public
		 * @static
		 */
		preventDefault: function(e) {
			if (e.preventDefault) {
				e.preventDefault();
			} else {
				e.returnValue = false;
			}
		},

		/**
		 * Gets the key code of the given event object (keydown). The event
		 * object here will be the same object that is passed to listeners
		 * registered with addEvent().
		 *
		 * @param   {mixed}         e       The event object
		 * @return  {Number}                The key code of the event
		 * @public
		 * @static
		 */
		keyCode: function(e) {
			return e.which ? e.which : e.keyCode;
		},

		/**
		 * Adds an event listener to the given element. It is expected that this
		 * function will be passed the event as its first argument.
		 *
		 * @param   {HTMLElement}   el          The DOM element to listen to
		 * @param   {String}        name        The name of the event to register
		 *                                      (i.e. 'click', 'scroll', etc.)
		 * @param   {Function}      handler     The event handler function
		 * @return  void
		 * @public
		 * @static
		 */
		addEvent: function(el, name, handler) {
			if (el.addEventListener) {
				el.addEventListener(name, handler, false);
			} else if (el.attachEvent) {
				el.attachEvent('on' + name, handler);
			}
		},

		/**
		 * Removes an event listener from the given element.
		 *
		 * @param   {HTMLElement}   el          The DOM element to stop listening to
		 * @param   {String}        name        The name of the event to stop
		 *                                      listening for (i.e. 'click')
		 * @param   {Function}      handler     The event handler function
		 * @return  void
		 * @public
		 * @static
		 */
		removeEvent: function(el, name, handler) {
			if (el.removeEventListener) {
				el.removeEventListener(name, handler, false);
			} else if (el.detachEvent) {
				el.detachEvent('on' + name, handler);
			}
		},

		/**
		 * Appends an HTML fragment to the given element.
		 *
		 * @param   {HTMLElement}       el      The element to append to
		 * @param   {String}            html    The HTML fragment to use
		 * @return  void
		 * @public
		 * @static
		 */
		append: function(el, html) {
			if (el.insertAdjacentHTML) {
				el.insertAdjacentHTML('BeforeEnd', html);
			} else if (el.lastChild) {
				var range = el.ownerDocument.createRange();
				range.setStartAfter(el.lastChild);
				var frag = range.createContextualFragment(html);
				el.appendChild(frag);
			} else {
				el.innerHTML = html;
			}
		}

	};

}();