1 /**

     2  * Copyright (c)2005-2009 Matt Kruse (javascripttoolbox.com)

     3  * 

     4  * Dual licensed under the MIT and GPL licenses. 

     5  * This basically means you can use this code however you want for

     6  * free, but don't claim to have written it yourself!

     7  * Donations always accepted: http://www.JavascriptToolbox.com/donate/

     8  * 

     9  * Please do not link to the .js files on javascripttoolbox.com from

    10  * your site. Copy the files locally to your server instead.

    11  * 

    12  */

    13 /* ******************************************************************* */

    14 /*   UTIL FUNCTIONS                                                    */

    15 /* ******************************************************************* */

    16 var Util = {'$VERSION':1.06};

    17 

    18 // Util functions - these are GLOBAL so they

    19 // look like built-in functions.

    20 

    21 // Determine if an object is an array

    22 function isArray(o) {

    23 	return (o!=null && typeof(o)=="object" && typeof(o.length)=="number" && (o.length==0 || defined(o[0])));

    24 };

    25 

    26 // Determine if an object is an Object

    27 function isObject(o) {

    28 	return (o!=null && typeof(o)=="object" && defined(o.constructor) && o.constructor==Object && !defined(o.nodeName));

    29 };

    30 

    31 // Determine if a reference is defined

    32 function defined(o) {

    33 	return (typeof(o)!="undefined");

    34 };

    35 

    36 // Iterate over an array, object, or list of items and run code against each item

    37 // Similar functionality to Perl's map() function

    38 function map(func) {

    39 	var i,j,o;

    40 	var results = [];

    41 	if (typeof(func)=="string") {

    42 		func = new Function('$_',func);

    43 	}

    44 	for (i=1; i<arguments.length; i++) {

    45 		o = arguments[i];

    46 		if (isArray(o)) {

    47 			for (j=0; j<o.length; j++) {

    48 				results[results.length] = func(o[j]);

    49 			}

    50 		}

    51 		else if (isObject(o)) {

    52 			for (j in o) {

    53 				results[results.length] = func(o[j]);

    54 			}

    55 		}

    56 		else {

    57 			results[results.length] = func(o);

    58 		}

    59 	}

    60 	return results;

    61 };

    62 

    63 // Set default values in an object if they are undefined

    64 function setDefaultValues(o,values) {

    65 	if (!defined(o) || o==null) {

    66 		o = {};

    67 	}

    68 	if (!defined(values) || values==null) {

    69 		return o;

    70 	}

    71 	for (var val in values) {

    72 		if (!defined(o[val])) {

    73 			o[val] = values[val];

    74 		}

    75 	}

    76 	return o;

    77 };

    78 

    79 /* ******************************************************************* */

    80 /*   DEFAULT OBJECT PROTOTYPE ENHANCEMENTS                             */

    81 /* ******************************************************************* */

    82 // These functions add useful functionality to built-in objects

    83 Array.prototype.contains = function(o) {

    84 	var i,l;

    85 	if (!(l = this.length)) { return false; }

    86 	for (i=0; i<l; i++) {

    87 		if (o==this[i]) {

    88 			return true;

    89 		}

    90 	}

    91 };

    92 

    93 /* ******************************************************************* */

    94 /*   DOM FUNCTIONS                                                     */

    95 /* ******************************************************************* */

    96 var DOM = (function() { 

    97 	var dom = {};

    98 	

    99 	// Get a parent tag with a given nodename

   100 	dom.getParentByTagName = function(o,tagNames) {

   101 		if(o==null) { return null; }

   102 		if (isArray(tagNames)) {

   103 			tagNames = map("return $_.toUpperCase()",tagNames);

   104 			while (o=o.parentNode) {

   105 				if (o.nodeName && tagNames.contains(o.nodeName)) {

   106 					return o;

   107 				}

   108 			}

   109 		}

   110 		else {

   111 			tagNames = tagNames.toUpperCase();

   112 			while (o=o.parentNode) {

   113 				if (o.nodeName && tagNames==o.nodeName) {

   114 					return o;

   115 				}

   116 			}

   117 		}

   118 		return null;

   119 	};

   120 	

   121 	// Remove a node from its parent

   122 	dom.removeNode = function(o) {

   123 		if (o!=null && o.parentNode && o.parentNode.removeChild) {

   124 			// First remove all attributes which are func references, to avoid memory leaks

   125 			for (var i in o) {

   126 				if (typeof(o[i])=="function") {

   127 					o[i] = null;

   128 				}

   129 			}

   130 			o.parentNode.removeChild(o);

   131 			return true;

   132 		}

   133 		return false;

   134 	};

   135 

   136 	// Get the outer width in pixels of an object, including borders, padding, and margin

   137 	dom.getOuterWidth = function(o) {

   138 		if (defined(o.offsetWidth)) {

   139 			return o.offsetWidth;

   140 		}

   141 		return null;

   142 	};

   143 

   144 	// Get the outer height in pixels of an object, including borders, padding, and margin

   145 	dom.getOuterHeight = function(o) {

   146 		if (defined(o.offsetHeight)) {

   147 			return o.offsetHeight;

   148 		}

   149 		return null;

   150 	};

   151 

   152 	// Resolve an item, an array of items, or an object of items

   153 	dom.resolve = function() {

   154 		var results = new Array();

   155 		var i,j,o;

   156 		for (var i=0; i<arguments.length; i++) {

   157 			var o = arguments[i];

   158 			if (o==null) {

   159 				if (arguments.length==1) {

   160 					return null;

   161 				}

   162 				results[results.length] = null;

   163 			}

   164 			else if (typeof(o)=='string') {

   165 				if (document.getElementById) {

   166 					o = document.getElementById(o);

   167 				}

   168 				else if (document.all) {

   169 					o = document.all[o];

   170 				}

   171 				if (arguments.length==1) {

   172 					return o;

   173 				}

   174 				results[results.length] = o;

   175 			}

   176 			else if (isArray(o)) {

   177 				for (j=0; j<o.length; j++) {

   178 					results[results.length] = o[j];

   179 				}

   180 			}

   181 			else if (isObject(o)) {

   182 				for (j in o) {

   183 					results[results.length] = o[j];

   184 				}

   185 			}

   186 			else if (arguments.length==1) {

   187 				return o;

   188 			}

   189 			else {

   190 				results[results.length] = o;

   191 			}

   192 	  }

   193 	  return results;

   194 	};

   195 	dom.$ = dom.resolve;

   196 	

   197 	return dom;

   198 })();

   199 

   200 /* ******************************************************************* */

   201 /*   CSS FUNCTIONS                                                     */

   202 /* ******************************************************************* */

   203 var CSS = (function(){

   204 	var css = {};

   205 

   206 	// Convert an RGB string in the form "rgb (255, 255, 255)" to "#ffffff"

   207 	css.rgb2hex = function(rgbString) {

   208 		if (typeof(rgbString)!="string" || !defined(rgbString.match)) { return null; }

   209 		var result = rgbString.match(/^\s*rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*/);

   210 		if (result==null) { return rgbString; }

   211 		var rgb = +result[1] << 16 | +result[2] << 8 | +result[3];

   212 		var hex = "";

   213 		var digits = "0123456789abcdef";

   214 		while(rgb!=0) { 

   215 			hex = digits.charAt(rgb&0xf)+hex; 

   216 			rgb>>>=4; 

   217 		} 

   218 		while(hex.length<6) { hex='0'+hex; }

   219 		return "#" + hex;

   220 	};

   221 

   222 	// Convert hyphen style names like border-width to camel case like borderWidth

   223 	css.hyphen2camel = function(property) {

   224 		if (!defined(property) || property==null) { return null; }

   225 		if (property.indexOf("-")<0) { return property; }

   226 		var str = "";

   227 		var c = null;

   228 		var l = property.length;

   229 		for (var i=0; i<l; i++) {

   230 			c = property.charAt(i);

   231 			str += (c!="-")?c:property.charAt(++i).toUpperCase();

   232 		}

   233 		return str;

   234 	};

   235 	

   236 	// Determine if an object or class string contains a given class.

   237 	css.hasClass = function(obj,className) {

   238 		if (!defined(obj) || obj==null || !RegExp) { return false; }

   239 		var re = new RegExp("(^|\\s)" + className + "(\\s|$)");

   240 		if (typeof(obj)=="string") {

   241 			return re.test(obj);

   242 		}

   243 		else if (typeof(obj)=="object" && obj.className) {

   244 			return re.test(obj.className);

   245 		}

   246 		return false;

   247 	};

   248 	

   249 	// Add a class to an object

   250 	css.addClass = function(obj,className) {

   251 		if (typeof(obj)!="object" || obj==null || !defined(obj.className)) { return false; }

   252 		if (obj.className==null || obj.className=='') { 

   253 			obj.className = className; 

   254 			return true; 

   255 		}

   256 		if (css.hasClass(obj,className)) { return true; }

   257 		obj.className = obj.className + " " + className;

   258 		return true;

   259 	};

   260 	

   261 	// Remove a class from an object

   262 	css.removeClass = function(obj,className) {

   263 		if (typeof(obj)!="object" || obj==null || !defined(obj.className) || obj.className==null) { return false; }

   264 		if (!css.hasClass(obj,className)) { return false; }

   265 		var re = new RegExp("(^|\\s+)" + className + "(\\s+|$)");

   266 		obj.className = obj.className.replace(re,' ');

   267 		return true;

   268 	};

   269 	

   270 	// Fully replace a class with a new one

   271 	css.replaceClass = function(obj,className,newClassName) {

   272 		if (typeof(obj)!="object" || obj==null || !defined(obj.className) || obj.className==null) { return false; }

   273 		css.removeClass(obj,className);

   274 		css.addClass(obj,newClassName);

   275 		return true;

   276 	};

   277 	

   278 	// Get the currently-applied style of an object

   279 	css.getStyle = function(o, property) {

   280 		if (o==null) { return null; }

   281 		var val = null;

   282 		var camelProperty = css.hyphen2camel(property);

   283 		// Handle "float" property as a special case

   284 		if (property=="float") {

   285 			val = css.getStyle(o,"cssFloat");

   286 			if (val==null) { 

   287 				val = css.getStyle(o,"styleFloat"); 

   288 			}

   289 		}

   290 		else if (o.currentStyle && defined(o.currentStyle[camelProperty])) {

   291 			val = o.currentStyle[camelProperty];

   292 		}

   293 		else if (window.getComputedStyle) {

   294 			val = window.getComputedStyle(o,null).getPropertyValue(property);

   295 		}

   296 		else if (o.style && defined(o.style[camelProperty])) {

   297 			val = o.style[camelProperty];

   298 		}

   299 		// For color values, make the value consistent across browsers

   300 		// Convert rgb() colors back to hex for consistency

   301 		if (/^\s*rgb\s*\(/.test(val)) {

   302 			val = css.rgb2hex(val);

   303 		}

   304 		// Lowercase all #hex values

   305 		if (/^#/.test(val)) {

   306 			val = val.toLowerCase();

   307 		}

   308 		return val;

   309 	};

   310 	css.get = css.getStyle;

   311 

   312 	// Set a style on an object

   313 	css.setStyle = function(o, property, value) {

   314 		if (o==null || !defined(o.style) || !defined(property) || property==null || !defined(value)) { return false; }

   315 		if (property=="float") {

   316 			o.style["cssFloat"] = value;

   317 			o.style["styleFloat"] = value;

   318 		}

   319 		else if (property=="opacity") {

   320 			o.style['-moz-opacity'] = value;

   321 			o.style['-khtml-opacity'] = value;

   322 			o.style.opacity = value;

   323 			if (defined(o.style.filter)) {

   324 				o.style.filter = "alpha(opacity=" + value*100 + ")";

   325 			}

   326 		}

   327 		else {

   328 			o.style[css.hyphen2camel(property)] = value;

   329 		}

   330 		return true;

   331 	};

   332 	css.set = css.setStyle;

   333 	

   334 	// Get a unique ID which doesn't already exist on the page

   335 	css.uniqueIdNumber=1000;

   336 	css.createId = function(o) {

   337 		if (defined(o) && o!=null && defined(o.id) && o.id!=null && o.id!="") { 

   338 			return o.id;

   339 		}

   340 		var id = null;

   341 		while (id==null || document.getElementById(id)!=null) {

   342 			id = "ID_"+(css.uniqueIdNumber++);

   343 		}

   344 		if (defined(o) && o!=null && (!defined(o.id)||o.id=="")) {

   345 			o.id = id;

   346 		}

   347 		return id;

   348 	};

   349 	

   350 	return css;

   351 })();

   352 

   353 /* ******************************************************************* */

   354 /*   EVENT FUNCTIONS                                                   */

   355 /* ******************************************************************* */

   356 

   357 var Event = (function(){

   358 	var ev = {};

   359 	

   360 	// Resolve an event using IE's window.event if necessary

   361 	// --------------------------------------------------------------------

   362 	ev.resolve = function(e) {

   363 		if (!defined(e) && defined(window.event)) {

   364 			e = window.event;

   365 		}

   366 		return e;

   367 	};

   368 	

   369 	// Add an event handler to a function

   370 	// Note: Don't use 'this' within functions added using this method, since

   371 	// the attachEvent and addEventListener models differ.

   372 	// --------------------------------------------------------------------

   373 	ev.add = function( obj, type, fn, capture ) {

   374 		if (obj.addEventListener) {

   375 			obj.addEventListener( type, fn, capture );

   376 			return true;

   377 		}

   378 		else if (obj.attachEvent) {

   379 			obj.attachEvent( "on"+type, fn );

   380 			return true;

   381 		}

   382 		return false;

   383 	};

   384 

   385 	// Get the mouse position of an event

   386 	// --------------------------------------------------------------------

   387 	// PageX/Y, where they exist, are more reliable than ClientX/Y because 

   388 	// of some browser bugs in Opera/Safari

   389 	ev.getMouseX = function(e) {

   390 		e = ev.resolve(e);

   391 		if (defined(e.pageX)) {

   392 			return e.pageX;

   393 		}

   394 		if (defined(e.clientX)) {

   395 			return e.clientX+Screen.getScrollLeft();

   396 		}

   397 		return null;

   398 	};

   399 	ev.getMouseY = function(e) {

   400 		e = ev.resolve(e);

   401 		if (defined(e.pageY)) {

   402 			return e.pageY;

   403 		}

   404 		if (defined(e.clientY)) {

   405 			return e.clientY+Screen.getScrollTop();

   406 		}

   407 		return null;

   408 	};

   409 

   410 	// Stop the event from bubbling up to parent elements.

   411 	// Two method names map to the same function

   412 	// --------------------------------------------------------------------

   413 	ev.cancelBubble = function(e) {

   414 		e = ev.resolve(e);

   415 		if (typeof(e.stopPropagation)=="function") { e.stopPropagation(); } 

   416 		if (defined(e.cancelBubble)) { e.cancelBubble = true; }

   417 	};

   418 	ev.stopPropagation = ev.cancelBubble;

   419 

   420 	// Prevent the default handling of the event to occur

   421 	// --------------------------------------------------------------------

   422 	ev.preventDefault = function(e) {

   423 		e = ev.resolve(e);

   424 		if (typeof(e.preventDefault)=="function") { e.preventDefault(); } 

   425 		if (defined(e.returnValue)) { e.returnValue = false; }

   426 	};

   427 	

   428 	return ev;

   429 })();

   430 

   431 /* ******************************************************************* */

   432 /*   SCREEN FUNCTIONS                                                  */

   433 /* ******************************************************************* */

   434 var Screen = (function() {

   435 	var screen = {};

   436 

   437 	// Get a reference to the body

   438 	// --------------------------------------------------------------------

   439 	screen.getBody = function() {

   440 		if (document.body) {

   441 			return document.body;

   442 		}

   443 		if (document.getElementsByTagName) {

   444 			var bodies = document.getElementsByTagName("BODY");

   445 			if (bodies!=null && bodies.length>0) {

   446 				return bodies[0];

   447 			}

   448 		}

   449 		return null;

   450 	};

   451 

   452 	// Get the amount that the main document has scrolled from top

   453 	// --------------------------------------------------------------------

   454 	screen.getScrollTop = function() {

   455 		if (document.documentElement && defined(document.documentElement.scrollTop) && document.documentElement.scrollTop>0) {

   456 			return document.documentElement.scrollTop;

   457 		}

   458 		if (document.body && defined(document.body.scrollTop)) {

   459 			return document.body.scrollTop;

   460 		}

   461 		return null;

   462 	};

   463 	

   464 	// Get the amount that the main document has scrolled from left

   465 	// --------------------------------------------------------------------

   466 	screen.getScrollLeft = function() {

   467 		if (document.documentElement && defined(document.documentElement.scrollLeft) && document.documentElement.scrollLeft>0) {

   468 			return document.documentElement.scrollLeft;

   469 		}

   470 		if (document.body && defined(document.body.scrollLeft)) {

   471 			return document.body.scrollLeft;

   472 		}

   473 		return null;

   474 	};

   475 	

   476 	// Util function to default a bad number to 0

   477 	// --------------------------------------------------------------------

   478 	screen.zero = function(n) {

   479 		return (!defined(n) || isNaN(n))?0:n;

   480 	};

   481 

   482 	// Get the width of the entire document

   483 	// --------------------------------------------------------------------

   484 	screen.getDocumentWidth = function() {

   485 		var width = 0;

   486 		var body = screen.getBody();

   487 		if (document.documentElement && (!document.compatMode || document.compatMode=="CSS1Compat")) {

   488 		    var rightMargin = parseInt(CSS.get(body,'marginRight'),10) || 0;

   489 		    var leftMargin = parseInt(CSS.get(body,'marginLeft'), 10) || 0;

   490 			width = Math.max(body.offsetWidth + leftMargin + rightMargin, document.documentElement.clientWidth);

   491 		}

   492 		else {

   493 			width =  Math.max(body.clientWidth, body.scrollWidth);

   494 		}

   495 		if (isNaN(width) || width==0) {

   496 			width = screen.zero(self.innerWidth);

   497 		}

   498 		return width;

   499 	};

   500 	

   501 	// Get the height of the entire document

   502 	// --------------------------------------------------------------------

   503 	screen.getDocumentHeight = function() {

   504 		var body = screen.getBody();

   505 		var innerHeight = (defined(self.innerHeight)&&!isNaN(self.innerHeight))?self.innerHeight:0;

   506 		if (document.documentElement && (!document.compatMode || document.compatMode=="CSS1Compat")) {

   507 		    var topMargin = parseInt(CSS.get(body,'marginTop'),10) || 0;

   508 		    var bottomMargin = parseInt(CSS.get(body,'marginBottom'), 10) || 0;

   509 			return Math.max(body.offsetHeight + topMargin + bottomMargin, document.documentElement.clientHeight, document.documentElement.scrollHeight, screen.zero(self.innerHeight));

   510 		}

   511 		return Math.max(body.scrollHeight, body.clientHeight, screen.zero(self.innerHeight));

   512 	};

   513 	

   514 	// Get the width of the viewport (viewable area) in the browser window

   515 	// --------------------------------------------------------------------

   516 	screen.getViewportWidth = function() {

   517 		if (document.documentElement && (!document.compatMode || document.compatMode=="CSS1Compat")) {

   518 			return document.documentElement.clientWidth;

   519 		}

   520 		else if (document.compatMode && document.body) {

   521 			return document.body.clientWidth;

   522 		}

   523 		return screen.zero(self.innerWidth);

   524 	};

   525 	

   526 	// Get the height of the viewport (viewable area) in the browser window

   527 	// --------------------------------------------------------------------

   528 	screen.getViewportHeight = function() {

   529 		if (!window.opera && document.documentElement && (!document.compatMode || document.compatMode=="CSS1Compat")) {

   530 			return document.documentElement.clientHeight;

   531 		}

   532 		else if (document.compatMode && !window.opera && document.body) {

   533 			return document.body.clientHeight;

   534 		}

   535 		return screen.zero(self.innerHeight);

   536 	};

   537 

   538 	return screen;

   539 })();var Sort = (function(){

   540 	var sort = {};

   541 	sort.AlphaNumeric = function(a,b) {

   542 		if (a==b) { return 0; }

   543 		if (a<b) { return -1; }

   544 		return 1;

   545 	};

   546 

   547 	sort.Default = sort.AlphaNumeric;

   548 	

   549 	sort.NumericConversion = function(val) {

   550 		if (typeof(val)!="number") {

   551 			if (typeof(val)=="string") {

   552 				val = parseFloat(val.replace(/,/g,''));

   553 				if (isNaN(val) || val==null) { val=0; }

   554 			}

   555 			else {

   556 				val = 0;

   557 			}

   558 		}

   559 		return val;

   560 	};

   561 	

   562 	sort.Numeric = function(a,b) {

   563 		return sort.NumericConversion(a)-sort.NumericConversion(b);

   564 	};

   565 

   566 	sort.IgnoreCaseConversion = function(val) {

   567 		if (val==null) { val=""; }

   568 		return (""+val).toLowerCase();

   569 	};

   570 

   571 	sort.IgnoreCase = function(a,b) {

   572 		return sort.AlphaNumeric(sort.IgnoreCaseConversion(a),sort.IgnoreCaseConversion(b));

   573 	};

   574 

   575 	sort.CurrencyConversion = function(val) {

   576 		if (typeof(val)=="string") {

   577 			val = val.replace(/^[^\d\.]/,'');

   578 		}

   579 		return sort.NumericConversion(val);

   580 	};

   581 	

   582 	sort.Currency = function(a,b) {

   583 		return sort.Numeric(sort.CurrencyConversion(a),sort.CurrencyConversion(b));

   584 	};

   585 	

   586 	sort.DateConversion = function(val) {

   587 		// inner util function to parse date formats

   588 		function getdate(str) {

   589 			// inner util function to convert 2-digit years to 4

   590 			function fixYear(yr) {

   591 				yr = +yr;

   592 				if (yr<50) { yr += 2000; }

   593 				else if (yr<100) { yr += 1900; }

   594 				return yr;

   595 			};

   596 			var ret;

   597 			// YYYY-MM-DD

   598 			if (ret=str.match(/(\d{2,4})-(\d{1,2})-(\d{1,2})/)) {

   599 				return (fixYear(ret[1])*10000) + (ret[2]*100) + (+ret[3]);

   600 			}

   601 			// MM/DD/YY[YY] or MM-DD-YY[YY]

   602 			if (ret=str.match(/(\d{1,2})[\/-](\d{1,2})[\/-](\d{2,4})/)) {

   603 				return (fixYear(ret[3])*10000) + (ret[1]*100) + (+ret[2]);

   604 			}

   605 			return 99999999; // So non-parsed dates will be last, not first

   606 		};

   607 		return getdate(val);

   608 	};

   609 

   610 	sort.Date = function(a,b) {

   611 		return sort.Numeric(sort.DateConversion(a),sort.DateConversion(b));

   612 	};

   613 

   614 	return sort;

   615 })();

   616 

   617 var Position = (function() {

   618 	// Resolve a string identifier to an object

   619 	// ========================================

   620 	function resolveObject(s) {

   621 		if (document.getElementById && document.getElementById(s)!=null) {

   622 			return document.getElementById(s);

   623 		}

   624 		else if (document.all && document.all[s]!=null) {

   625 			return document.all[s];

   626 		}

   627 		else if (document.anchors && document.anchors.length && document.anchors.length>0 && document.anchors[0].x) {

   628 			for (var i=0; i<document.anchors.length; i++) {

   629 				if (document.anchors[i].name==s) { 

   630 					return document.anchors[i]

   631 				}

   632 			}

   633 		}

   634 	}

   635 	

   636 	var pos = {};

   637 	pos.$VERSION = 1.0;

   638 	

   639 	// Set the position of an object

   640 	// =============================

   641 	pos.set = function(o,left,top) {

   642 		if (typeof(o)=="string") {

   643 			o = resolveObject(o);

   644 		}

   645 		if (o==null || !o.style) {

   646 			return false;

   647 		}

   648 		

   649 		// If the second parameter is an object, it is assumed to be the result of getPosition()

   650 		if (typeof(left)=="object") {

   651 			var pos = left;

   652 			left = pos.left;

   653 			top = pos.top;

   654 		}

   655 		

   656 		o.style.left = left + "px";

   657 		o.style.top = top + "px";

   658 		return true;

   659 	};

   660 	

   661 	// Retrieve the position and size of an object

   662 	// ===========================================

   663 	pos.get = function(o) {

   664 		var fixBrowserQuirks = true;

   665 			// If a string is passed in instead of an object ref, resolve it

   666 		if (typeof(o)=="string") {

   667 			o = resolveObject(o);

   668 		}

   669 		

   670 		if (o==null) {

   671 			return null;

   672 		}

   673 		

   674 		var left = 0;

   675 		var top = 0;

   676 		var width = 0;

   677 		var height = 0;

   678 		var parentNode = null;

   679 		var offsetParent = null;

   680 	

   681 		

   682 		offsetParent = o.offsetParent;

   683 		var originalObject = o;

   684 		var el = o; // "el" will be nodes as we walk up, "o" will be saved for offsetParent references

   685 		while (el.parentNode!=null) {

   686 			el = el.parentNode;

   687 			if (el.offsetParent==null) {

   688 			}

   689 			else {

   690 				var considerScroll = true;

   691 				/*

   692 				In Opera, if parentNode of the first object is scrollable, then offsetLeft/offsetTop already 

   693 				take its scroll position into account. If elements further up the chain are scrollable, their 

   694 				scroll offsets still need to be added in. And for some reason, TR nodes have a scrolltop value

   695 				which must be ignored.

   696 				*/

   697 				if (fixBrowserQuirks && window.opera) {

   698 					if (el==originalObject.parentNode || el.nodeName=="TR") {

   699 						considerScroll = false;

   700 					}

   701 				}

   702 				if (considerScroll) {

   703 					if (el.scrollTop && el.scrollTop>0) {

   704 						top -= el.scrollTop;

   705 					}

   706 					if (el.scrollLeft && el.scrollLeft>0) {

   707 						left -= el.scrollLeft;

   708 					}

   709 				}

   710 			}

   711 			// If this node is also the offsetParent, add on the offsets and reset to the new offsetParent

   712 			if (el == offsetParent) {

   713 				left += o.offsetLeft;

   714 				if (el.clientLeft && el.nodeName!="TABLE") { 

   715 					left += el.clientLeft;

   716 				}

   717 				top += o.offsetTop;

   718 				if (el.clientTop && el.nodeName!="TABLE") {

   719 					top += el.clientTop;

   720 				}

   721 				o = el;

   722 				if (o.offsetParent==null) {

   723 					if (o.offsetLeft) {

   724 						left += o.offsetLeft;

   725 					}

   726 					if (o.offsetTop) {

   727 						top += o.offsetTop;

   728 					}

   729 				}

   730 				offsetParent = o.offsetParent;

   731 			}

   732 		}

   733 		

   734 	

   735 		if (originalObject.offsetWidth) {

   736 			width = originalObject.offsetWidth;

   737 		}

   738 		if (originalObject.offsetHeight) {

   739 			height = originalObject.offsetHeight;

   740 		}

   741 		

   742 		return {'left':left, 'top':top, 'width':width, 'height':height

   743 				};

   744 	};

   745 	

   746 	// Retrieve the position of an object's center point

   747 	// =================================================

   748 	pos.getCenter = function(o) {

   749 		var c = this.get(o);

   750 		if (c==null) { return null; }

   751 		c.left = c.left + (c.width/2);

   752 		c.top = c.top + (c.height/2);

   753 		return c;

   754 	};

   755 	

   756 	return pos;

   757 })();// CLASS CONSTRUCTOR

   758 // --------------------------------------------------------------------

   759 var Popup = function(div, options) {

   760 	this.div = defined(div)?div:null;

   761 	this.index = Popup.maxIndex++;

   762 	this.ref = "Popup.objects["+this.index+"]";

   763 	Popup.objects[this.index] = this;

   764 	// Store a reference to the DIV by id, also

   765 	if (typeof(this.div)=="string") {

   766 		Popup.objectsById[this.div] = this;

   767 	}

   768 	if (defined(this.div) && this.div!=null && defined(this.div.id)) {

   769 		Popup.objectsById[this.div.id] = this.div.id;

   770 	}

   771 	// Apply passed-in options

   772 	if (defined(options) && options!=null && typeof(options)=="object") {

   773 		for (var i in options) {

   774 			this[i] = options[i];

   775 		}

   776 	}

   777 	return this;

   778 };

   779 

   780 // CLASS PROPERTIES

   781 // --------------------------------------------------------------------

   782 // Index of popup objects, to maintain a global reference if necessary

   783 Popup.maxIndex = 0;

   784 Popup.objects = {};

   785 Popup.objectsById = {};

   786 

   787 // The z-index value that popups will start at

   788 Popup.minZIndex = 101;

   789 

   790 // Class names to assign to other objects

   791 Popup.screenClass = "PopupScreen";

   792 Popup.iframeClass = "PopupIframe";

   793 Popup.screenIframeClass = "PopupScreenIframe";

   794 

   795 // CLASS METHODS

   796 // --------------------------------------------------------------------

   797 

   798 // Hide all currently-visible non-modal dialogs

   799 Popup.hideAll = function() {

   800 	for (var i in Popup.objects) {

   801 		var p = Popup.objects[i];

   802 		if (!p.modal && p.autoHide) {

   803 			p.hide();

   804 		}

   805 	}

   806 };

   807 // Catch global events as a trigger to hide auto-hide popups

   808 Event.add(document, "mouseup", Popup.hideAll, false);

   809 

   810 // A simple class method to show a popup without creating an instance

   811 Popup.show = function(divObject, referenceObject, position, options, modal) {

   812 	var popup;

   813 	if (defined(divObject)) { 

   814 		popup = new Popup(divObject);

   815 	}

   816 	else {

   817 		popup = new Popup();

   818 		popup.destroyDivOnHide = true;

   819 	}

   820 	if (defined(referenceObject)) { popup.reference = DOM.resolve(referenceObject); }

   821 	if (defined(position)) { popup.position = position; }

   822 	if (defined(options) && options!=null && typeof(options)=="object") {

   823 		for (var i in options) {

   824 			popup[i] = options[i];

   825 		}

   826 	}

   827 	if (typeof(modal)=="boolean") {

   828 		popup.modal = modal;

   829 	}

   830 	popup.destroyObjectsOnHide = true;

   831 	popup.show();

   832 	return popup;

   833 };

   834 

   835 // A simple class method to show a modal popup

   836 Popup.showModal = function(divObject, referenceObject, position, options) {

   837 	Popup.show(divObject, referenceObject, position, options, true);

   838 };

   839 

   840 // A method to retrieve a popup object based on a div ID

   841 Popup.get = function(divId) {

   842 	if (defined(Popup.objectsById[divId])) {

   843 		return Popup.objectsById[divId];

   844 	}

   845 	return null;

   846 };

   847 

   848 // A method to hide a popup based on a div id

   849 Popup.hide = function(divId) {

   850 	var popup = Popup.get(divId);

   851 	if (popup!=null) {

   852 		popup.hide();

   853 	}

   854 };

   855 

   856 // PROTOTYPE PROPERTIES

   857 // --------------------------------------------------------------------

   858 Popup.prototype.content = null;

   859 Popup.prototype.className = "PopupDiv";

   860 Popup.prototype.style = null; // Styles to be applied to the DIV

   861 Popup.prototype.width = null;

   862 Popup.prototype.height = null;

   863 Popup.prototype.top = null;

   864 Popup.prototype.left = null;

   865 Popup.prototype.offsetLeft = 0;

   866 Popup.prototype.offsetTop = 0;

   867 Popup.prototype.constrainToScreen = true;

   868 Popup.prototype.autoHide = true;

   869 Popup.prototype.useIframeShim = false; /*@cc_on @*/ /*@if (@_win32) {Popup.prototype.useIframeShim = true;} @end @*/ 

   870 Popup.prototype.iframe = null;

   871 Popup.prototype.position = null; // vertical: "above top center bottom below", horizontal: "adjacent-left,left,center,right,adjacent-right"

   872 Popup.prototype.reference = null;

   873 Popup.prototype.modal = false;

   874 Popup.prototype.destroyDivOnHide = false;

   875 Popup.prototype.destroyObjectsOnHide = false;

   876 Popup.prototype.screen = null;

   877 Popup.prototype.screenIframeShim = null;

   878 Popup.prototype.screenOpacity=.4;

   879 Popup.prototype.screenColor="#cccccc";

   880 

   881 // INSTANCE METHODS

   882 // --------------------------------------------------------------------

   883 

   884 // Show the popup

   885 // --------------------------------------------------------------------

   886 Popup.prototype.show = function(options, modal) {

   887 	this.modal = this.modal || (typeof(modal)=="boolean" && modal);

   888 	if (defined(options) && options!=null && typeof(options)=="object") {

   889 		for (var i in options) {

   890 			this[i] = options[i];

   891 		}

   892 	}

   893 	this.div = DOM.resolve(this.div);

   894 	CSS.setStyle(this.div,'position','absolute');

   895 	

   896 	// If there is no div pre-defined to use, create one

   897 	if (this.div==null) {

   898 		this.div = this.createDiv();

   899 	}

   900 	if (this.content!=null) {

   901 		this.div.innerHTML = this.content;

   902 		this.content = null;

   903 	}

   904 	if (this.className!=null) {

   905 		this.div.className = this.className;

   906 	}

   907 	if (this.style!=null) {

   908 		this.applyStyle();

   909 	}

   910 	if (this.width!=null) {

   911 		this.div.style.width = this.width+"px";

   912 		this.div.style.overflowX="auto";

   913 	}

   914 	if (this.height!=null) {

   915 		this.div.style.height = this.height+"px";

   916 		this.div.style.overflowY="auto";

   917 	}

   918 

   919 	// Do the actual display - this is a separate method so display transitions can be implemented

   920 	this.transition();

   921 	

   922 	// Make sure clicks on the DIV don't bubble up to the document

   923 	this.div.onclick = function(e) { 

   924 		Event.cancelBubble(Event.resolve(e));

   925 	};

   926 	this.div.onmouseup = this.div.onclick;

   927 	

   928 	// Focus to the DIV if possible	

   929 	if (this.modal && this.div.focus) {

   930 		this.div.focus();

   931 	}

   932 };

   933 

   934 // Show the popup but make it modal

   935 // --------------------------------------------------------------------

   936 Popup.prototype.transition = function() {

   937 	if (this.modal) {

   938 		this.addScreen();

   939 	}

   940 	

   941 	// Make the DIV displayed but hidden so its size can be measured

   942 	CSS.setStyle(this.div,'visibility','hidden');

   943 	CSS.setStyle(this.div,'display','block');

   944 

   945 	// Position the popup

   946 	this.setPosition();

   947 

   948 	// Add the shim if necessary	

   949 	if (this.useIframeShim) {

   950 		this.addIframeShim();

   951 	}

   952 

   953 	// Make sure the DIV is higher than the shim

   954 	this.div.style.zIndex = Popup.minZIndex++;

   955 

   956 	CSS.setStyle(this.div,'display','block');

   957 	CSS.setStyle(this.div,'visibility','visible');

   958 };

   959 

   960 // Show the popup but make it modal

   961 // --------------------------------------------------------------------

   962 Popup.prototype.showModal = function(options) {

   963 	this.show(options,true);

   964 };

   965 

   966 // Apply user styles to the DIV

   967 // --------------------------------------------------------------------

   968 Popup.prototype.applyStyle = function() {

   969 	if (this.div!=null && this.style!=null && typeof(this.style)=="object") {

   970 		for (var i in this.style) {

   971 			this.div.style[i] = this.style[i];

   972 		}

   973 	}

   974 };

   975 

   976 // Hide the popup

   977 // --------------------------------------------------------------------

   978 Popup.prototype.hide = function() {

   979 	// If this was a temp object creating on-the-fly, then remove objects from the DOM so

   980 	// The document doesn't get littered with extra objects

   981 	if (this.destroyDivOnHide) {

   982 		DOM.removeNode(this.div);

   983 		this.div = null;

   984 		delete Popup.objects[this.id];

   985 	}

   986 	else if (this.div!=null) {

   987 		CSS.setStyle(this.div,'display','none');

   988 	}

   989 

   990 	if (this.destroyObjectsOnHide) {

   991 		DOM.removeNode(this.iframe);

   992 		DOM.removeNode(this.screen);

   993 		DOM.removeNode(this.screenIframeShim);

   994 	}

   995 	else {

   996 		if (this.iframe!=null) {

   997 			this.iframe.style.display = "none";

   998 		}

   999 		if (this.screen!=null) {

  1000 			this.screen.style.display = "none";

  1001 		}

  1002 		if (this.screenIframeShim!=null) {

  1003 			this.screenIframeShim.style.display = "none";

  1004 		}

  1005 	}

  1006 };

  1007 

  1008 // Util funcs for position

  1009 // --------------------------------------------------------------------

  1010 Popup.prototype.setTop = function(top) {

  1011 	this.div.style.top = top+"px";

  1012 };

  1013 Popup.prototype.setLeft = function(left) {

  1014 	this.div.style.left = left+"px";

  1015 };

  1016 Popup.prototype.getTop = function() {

  1017 	return parseInt(CSS.getStyle(this.div,"top"),10);

  1018 };

  1019 Popup.prototype.getLeft = function() {

  1020 	return parseInt(CSS.getStyle(this.div,"left"),10);

  1021 };

  1022 

  1023 // All the logic to position the popup based on various criteria

  1024 // --------------------------------------------------------------------

  1025 Popup.prototype.setPosition = function() {

  1026 	if (this.position!=null) {

  1027 		var m = this.position.match(/^(\S+)\s+(\S+)/); 

  1028 		if (m!=null && m.length==3) {

  1029 			var v = m[1];

  1030 			var h = m[2];

  1031 

  1032 			var ref = this.reference;

  1033 			if (ref==null) { ref = Screen.getBody(); }

  1034 			var p = Position.get(ref);

  1035 			var refTop = p.top;

  1036 			var refLeft = p.left;

  1037 			var refWidth = DOM.getOuterWidth(ref);

  1038 			var refHeight = DOM.getOuterHeight(ref);

  1039 			

  1040 			var width = DOM.getOuterWidth(this.div);

  1041 			var height = DOM.getOuterHeight(this.div);

  1042 			

  1043 			var scrollLeft = Screen.getScrollLeft();

  1044 			var scrollTop = Screen.getScrollTop();

  1045 

  1046 			// Set vertical position relative to reference object

  1047 			if (v=="above") { this.setTop(refTop-height+this.offsetTop); }

  1048 			else if (v=="top") { this.setTop(refTop+this.offsetTop); }

  1049 			else if (v=="center") { this.setTop(refTop+(refHeight/2)-(height/2)+this.offsetTop); }

  1050 			else if (v=="bottom") { this.setTop(refTop+refHeight-height+this.offsetTop); }

  1051 			else if (v=="below") { this.setTop(refTop+refHeight+this.offsetTop); }

  1052 

  1053 			// Set horizontal position relative to reference object

  1054 			if (h=="adjacent-left") { this.setLeft(refLeft-width+this.offsetLeft); }

  1055 			else if (h=="left") { this.setLeft(refLeft+this.offsetLeft); }

  1056 			else if (h=="center") { this.setLeft(refLeft+(refWidth/2)-(width/2)+this.offsetLeft); }

  1057 			else if (h=="right") { this.setLeft(refLeft+refWidth-width+this.offsetLeft); }

  1058 			else if (h=="adjacent-right") { this.setLeft(refLeft+refWidth+this.offsetLeft); }

  1059 		}

  1060 	}

  1061 	else if (this.top==null && this.left==null) {

  1062 		this.center();

  1063 	}

  1064 	else {

  1065 		if (this.top==null) { this.top=0; }

  1066 		if (this.left==null) { this.left=0; }

  1067 		this.div.style.top = this.top+this.offsetTop+"px";

  1068 		this.div.style.left = this.left+this.offsetLeft+"px";

  1069 	}

  1070 

  1071 	// Re-position to make sure it stays on the screen

  1072 	if (this.constrainToScreen) {

  1073 		this.fitToScreen();

  1074 	}

  1075 };

  1076 

  1077 // Append an object to the body

  1078 // --------------------------------------------------------------------

  1079 Popup.prototype.appendToBody = function(o) {

  1080 	var body = Screen.getBody();

  1081 	if (body && body.appendChild) {

  1082 		body.appendChild(o);

  1083 	}

  1084 };

  1085 

  1086 // Create a new DIV object to be used for a popup

  1087 // --------------------------------------------------------------------

  1088 Popup.prototype.createDiv = function() {

  1089 	if (document.createElement) {

  1090 		var d = document.createElement("DIV");

  1091 		d.style.position="absolute";

  1092 		d.style.display="block";

  1093 		d.style.visibility="hidden";

  1094 		this.appendToBody(d);

  1095 		return d;

  1096 	}

  1097 	alert("ERROR: Couldn't create DIV element in Popup.prototype.createDiv()");

  1098 	return null;

  1099 };

  1100 

  1101 // Create a new IFRAME object to be used behind the popup

  1102 // --------------------------------------------------------------------

  1103 Popup.prototype.createIframe = function() {

  1104 	if (document.createElement) {

  1105 		var i= document.createElement("IFRAME");

  1106 		i.style.position="absolute";

  1107 		i.style.display="block";

  1108 		i.style.visibility="hidden";

  1109 		i.style.background="none";

  1110 		this.appendToBody(i);

  1111 		return i;

  1112 	}

  1113 	else {

  1114 		alert("ERROR: Couldn't create IFRAME object in Popup.prototype.createIframe()");

  1115 	}

  1116 };

  1117 

  1118 // Add an IFRAME shim for the DIV

  1119 // --------------------------------------------------------------------

  1120 Popup.prototype.addIframeShim = function() {

  1121 	if (this.iframe==null) {

  1122 		this.iframe = this.createIframe();

  1123 	}

  1124 	this.iframe.className = Popup.iframeClass;

  1125 	CSS.setStyle(this.iframe,'top',this.getTop()+"px");

  1126 	CSS.setStyle(this.iframe,'left',this.getLeft()+"px");

  1127 	CSS.setStyle(this.iframe,'width',DOM.getOuterWidth(this.div) + "px");

  1128 	CSS.setStyle(this.iframe,'height',DOM.getOuterHeight(this.div) + "px");

  1129 	CSS.setStyle(this.iframe,'zIndex',Popup.minZIndex++);

  1130 	CSS.setStyle(this.iframe,'opacity',0);

  1131 	CSS.setStyle(this.iframe,'visibility','visible');

  1132 	CSS.setStyle(this.iframe,'display','block');

  1133 };

  1134 

  1135 // Create a "screen" to make a popup modal