/**
 * Point v1.2.0.644
 * Copyright (c) 2009 Widgit Software
 */

var Point = (function() {
	var isIE = /*@cc_on!@*/false;

	var pointAllSpanCssClass = "point_sym_span";

	var pointSpanCssClass = "point_sym_hover_span";
	var pointSpanHighlightCssClass = "point_sym_hover_span_hl";
	var pointSpanNoSymbolCssClass = "point_sym_hover_span_nosymbol";
	var pointSpanNoSymbolHighlightCssClass = "point_sym_hover_span_nosymbol_hl";
	var pointDisabledSpanCssClass = "point_sym_hover_span_disabled";
	var pointDisabledSpanNoSymbolCssClass = "point_sym_hover_span_nosymbol_disabled";
	var pointVariableContentCssClass = "point_variable_content";
	var pointSelectCssClass = "point_select";
	var pointInputCssClass = "point_input";
	var pointImageCssClass = "point_img";
	var pointEnabledCookieName = "point_enabled";

	
	/*------------------------------------------------------------------------*/

	var httpClient;
	var xhrClient = (function() {
		var currentRequest = null;

		var createXMLHTTPObject = function() {
			var XMLHttpFactories = [
				function () {return new XMLHttpRequest();},
				function () {return new ActiveXObject("Msxml2.XMLHTTP");},
				function () {return new ActiveXObject("Msxml3.XMLHTTP");},
				function () {return new ActiveXObject("Microsoft.XMLHTTP");}
			];
			
			for (var i = 0, len = XMLHttpFactories.length; i < len; i++) {
				try {
					createXMLHTTPObject = XMLHttpFactories[i];
					return createXMLHTTPObject();
				} catch (e) {
				}
			}
			return null;
		};

		function abort() {
			if (currentRequest) {
				currentRequest.onreadystatechange = function() {};
				currentRequest.abort();
			}
		}
		
		return {
			sendRequest: function() {
				abort();

				currentRequest = createXMLHTTPObject();
				if (!currentRequest) {
					return;
				}

				var url = Point.proxyUrl + "?word=" + Point.requestedWord + "&lang=" + Point.requestedWordLang;
				if (Point.httpsImageUrls) {
					url += "&https=1";
				}
				currentRequest.open("GET", url, true);
				currentRequest.setRequestHeader('User-Agent','XMLHTTP/1.0');
				currentRequest.onreadystatechange = function () {
					if (currentRequest.readyState === 4) {
						if (currentRequest.status === 200 || currentRequest.status === 304) {
							Point.processTipData(currentRequest.responseText);
						}
						currentRequest = null;
					}
				};
				if (currentRequest.readyState == 4) {
					return;
				}
				currentRequest.send(null);
			},

			checkSupported: function() {
				var xmlHttp = createXMLHTTPObject();
				if (!xmlHttp) {
					Point.notSupported = true;
					return false;
				}
				return true;
			},

			abort: abort,
			
			init: function() {
			}
		};
	})();


	
	/*------------------------------------------------------------------------*/
	
	// Initialise Point when the page has loaded

	function addOnloadEventListener(listener) {
		if (typeof window.addEventListener != "undefined") {
			window.addEventListener("load", listener, false);
		} else if (typeof document.addEventListener != "undefined") {
			document.addEventListener("load", listener, false);
		} else if (typeof window.attachEvent != "undefined") {
			window.attachEvent("onload", listener);
		} else if (typeof win.onload == "function") {
			var oldOnload = window.onload;
			window.onload = function() {
				oldOnload();
				listener();
			};
		} else {
			window.onload = listener;
		}
		listener = null;
	}

	addOnloadEventListener(
		function() {
			Point.enablePoint(!!Point.enableImmediately);
		}
	);
	
	/*------------------------------------------------------------------------*/
	
	// CSS property inheritance
	
	var cssJsPropertyNames = {};
	
	var jsPropertyNameSpecialCases = {};

	function convertJsPropertyNameToCss(propName) {
		var cachedValue = cssJsPropertyNames[propName];
		if (!cachedValue) {
			var specialCase = jsPropertyNameSpecialCases[propName];
			cachedValue = specialCase || propName.replace(/([A-Z])/g, "-$1".toLowerCase());
			cssJsPropertyNames[propName] = cachedValue;
		}
		return cachedValue;
	}
	
	var pointSpanInheritStyles = [
		"backgroundColor",
		"color",
		"fontFamily",
		"cursor",
		"direction",
		"fontStyle",
		"fontVariant",
		"fontWeight",
		"letterSpacing",
		"lineHeight",
		"opacity",
		"textDecoration",
		"textTransform",
		"whiteSpace",
		"wordSpacing",
		"wordWrap"
	];
	
	var getEffectiveStyle, getEffectiveStyleValue;
	
	if (isIE) {
		getEffectiveStyle = function(el) {
			return el.currentStyle;
		};

		getEffectiveStyleValue = function(styleObj, propName) {
			return styleObj[propName];
		};
	} else {
		getEffectiveStyle = function(el) {
			return el.ownerDocument.defaultView.getComputedStyle(el, "");
		};

		getEffectiveStyleValue = function(styleObj, propName) {
			return styleObj.getPropertyValue( convertJsPropertyNameToCss(propName) );
		};
	}
	
	function inheritParentStyles(el, cssPropertyNames) {
		var parentStyle = getEffectiveStyle(el.parentNode);
		
		var cssPropertyName;
		for (var i = 0, len = cssPropertyNames.length; i < len; i++) {
			cssPropertyName = cssPropertyNames[i];
			el.style[cssPropertyName] = getEffectiveStyleValue(parentStyle, cssPropertyName);
		}
	}
	
	/*------------------------------------------------------------------------*/

	// CSS rules
	var addStyleRule = function(selector, rule, styleSheet) {
		var el, heads;
		if (!styleSheet) {
			heads = document.getElementsByTagName("head");
			if (heads[0]) {
				el = document.createElement("style");
				if (el) {
					el.setAttribute("type", "text/css");
					el.setAttribute("media", "screen");
					heads[0].appendChild(el);
					if (document.styleSheets && document.styleSheets.length) {
						styleSheet = document.styleSheets[document.styleSheets.length - 1];
					}
					el = null;
				}
			}
		}
		if (styleSheet) {
			if (styleSheet.addRule) {
				styleSheet.addRule(selector, rule);
			} else {
				if (typeof styleSheet.cssText == "string") { // IE Mac, which throws "permission denied" on insertRule
					styleSheet.cssText = selector + " {" + rule + "}";
				} else {
					if (styleSheet.insertRule) { // old Mozilla versions, which don't support cssText property for style sheet objects
						styleSheet.insertRule(selector + " {" + rule + "}", styleSheet.cssRules.length);
					}
				}
			}
		}
		return styleSheet;
	};
	
	function createNonValidatingCssRules() {
		addStyleRule("span.point_sym_span", [
			"behavior: none;",
			"filter: none;",
			"-moz-border-radius: 0;",
			"-moz-opacity: 1;",
			"opacity: 1;",
			"overflow-x: visible;",
			"overflow-y: visible;",
			"word-wrap: inherit;",
			"zoom: normal;"
		].join("\n") );
	}

	function isDescendantOf(descendant, ancestor) {
		var node = descendant;
		while (node) {
			if (node === ancestor) {
				return true;
			}
			node = node.parentNode;
		}
		return false;
	}

	var currentWordSpan;

	/*------------------------------------------------------------------------*/

	return {
		version: "1.2.0.644",
		lastEventTarget: null,
		lastSpan: null,
		lastMousePosX: 0,
		lastMousePosY: 0,
		tooltipTargetX: 0,
		tooltipTargetY: 0,
		timeoutId: 0,
		tooltipDiv: null,
		imageLoadTimer: 0,
		waitIconDiv: null,
		pointActive: false,
		requestedWord: "",
		requestPending: false,
		hoveringOverWord: false,
		defaultLanguage: "English_UK",
		languageCssClasses: {},
		
		languageCssClasses: {},
		getDocumentScroll: function(win, doc) {
			if (typeof win.pageYOffset === "number") {
				return [win.pageXOffset, win.pageYOffset];
			} else if ( (typeof doc.compatMode === "string") &&
					   (doc.compatMode.indexOf("CSS") >= 0) &&
					   doc.documentElement &&
					   (typeof doc.documentElement.scrollTop == "number")) {
				return [doc.documentElement.scrollLeft, doc.documentElement.scrollTop];
			} else if (doc.body && (typeof doc.body.scrollTop == "number")) {
				return [doc.body.scrollLeft, doc.body.scrollTop];
			}
			
			return [0,0];
		},

        getObjectPosition: function(o) {
            // Thanks, http://www.javascripttoolbox.com/lib/objectposition/source.php
            // This function is taken from the above library and is dual-licensed under the MIT and GPL licenses
            // Copyright (c)2005-2009 Matt Kruse (javascripttoolbox.com)
            var fixBrowserQuirks = true;

            var left = 0;
            var top = 0;
            var width = 0;
            var height = 0;
            var parentNode = null;
            var offsetParent = null;

            offsetParent = o.offsetParent;
            var originalObject = o;
            var el = o; // "el" will be nodes as we walk up, "o" will be saved for offsetParent references
            while (el.parentNode!=null) {
              el = el.parentNode;
              if (el.offsetParent==null) {
              }
              else {
                var considerScroll = true;
                /*
                In Opera, if parentNode of the first object is scrollable, then offsetLeft/offsetTop already
                take its scroll position into account. If elements further up the chain are scrollable, their
                scroll offsets still need to be added in. And for some reason, TR nodes have a scrolltop value
                which must be ignored.
                */
                if (fixBrowserQuirks && window.opera) {
                  if (el==originalObject.parentNode || el.nodeName=="TR") {
                    considerScroll = false;
                  }
                }
                if (considerScroll) {
                  if (el.scrollTop && el.scrollTop>0) {
                    top -= el.scrollTop;
                  }
                  if (el.scrollLeft && el.scrollLeft>0) {
                    left -= el.scrollLeft;
                  }
                }
              }
              // If this node is also the offsetParent, add on the offsets and reset to the new offsetParent
              if (el == offsetParent) {
                left += o.offsetLeft;
                if (el.clientLeft && el.nodeName!="TABLE") {
                  left += el.clientLeft;
                }
                top += o.offsetTop;
                if (el.clientTop && el.nodeName!="TABLE") {
                  top += el.clientTop;
                }
                o = el;
                if (o.offsetParent==null) {
                  if (o.offsetLeft) {
                    left += o.offsetLeft;
                  }
                  if (o.offsetTop) {
                    top += o.offsetTop;
                  }
                }
                offsetParent = o.offsetParent;
              }
            }


            if (originalObject.offsetWidth) {
              width = originalObject.offsetWidth;
            }
            if (originalObject.offsetHeight) {
              height = originalObject.offsetHeight;
            }

            return {'left':left, 'top':top, 'width':width, 'height':height
                };
        },

        getFrameForDocument: function(searchDocument) {
			var documents = Point.findAllDocuments();
			for (var iDoc = 0; iDoc < documents.length; iDoc++) {
				tags = ["frame","iframe"];
				for (var iTag = 0; iTag < tags.length; iTag++) {
					var frames = documents[iDoc].getElementsByTagName(tags[iTag]);
					for (var i = 0; i < frames.length; i++) {
						var frame = frames[i];
						var frameDoc = Point.getFrameDocument(frame);
						if (searchDocument == frameDoc) {
							return frame;
						}
					}
				}
			}
            return null;
        },
		
		array_contains: function(arr, val) {
				for (var i = 0, len = arr.length; i < len; i++) {
						if (arr[i] === val) {
								return true;
						}
				}
				return false;
		},
	
		// CSS utility functions
		hasClass: function(el, cssClass) {
				if (el.className) {
						var classNames = el.className.split(" ");
						return Point.array_contains(classNames, cssClass);
				}
				return false;
		},
		
		addClass: function(el, cssClass) {
			if (!Point.hasClass(el, cssClass)) {
				if (el.className) {
					el.className += " " + cssClass;
				} else {
					el.className = cssClass;
				}
			}
		},
	
		removeClass: function(el, cssClass) {
			if (Point.hasClass(el, cssClass)) {
				// Rebuild the className property
				var existingClasses = el.className.split(" ");
				var newClasses = [];
				for (var i = 0, len = existingClasses.length; i < len; i++) {
					if (existingClasses[i] != cssClass) {
						newClasses[newClasses.length] = existingClasses[i];
					}
				}
				el.className = newClasses.join(" ");
			}
		},

		replaceClass: function(el, newCssClass, oldCssClass) {
			Point.removeClass(el, oldCssClass);
			Point.addClass(el, newCssClass);
		},

		createCookie: function(name,value,days) {
			var expires = "";
			if (days) {
				var date = new Date();
				date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
				expires = "; expires=" + date.toGMTString();
			}
			document.cookie = name + "=" + value + expires + "; path=/";
		},
		
		readCookie: function(name) {
			var nameEQ = name + "=";
			var ca = document.cookie.split(';');
			for (var i = 0, len = ca.length; i < len; i++) {
				var c = ca[i];
				while (c.charAt(0) == " ") {
					c = c.substring(1, c.length);
				}
				if (c.indexOf(nameEQ) === 0) {
					return c.substring(nameEQ.length, c.length);
				}
			}
			return null;
		},
		
		eraseCookie: function(name) {
			Point.createCookie(name, "", -1);
		},
		
		addNode: function(parent, node, next) {
			if (next === null) {
				parent.appendChild(node);
			} else {
				parent.insertBefore(node,next);
			}
		},
		
		stripPunctuation: function(word) {
			return word.replace(/^[^\w]+/, "").replace(/[^\w]$/, "");
		},
		
		wrapInSpan: function(node, extraCssClass) {
			// Create the span
			var newSpan = node.ownerDocument.createElement("span");
			newSpan.className = pointAllSpanCssClass + " " + pointSpanCssClass;
			if (extraCssClass) {
				newSpan.className += " " + extraCssClass;
			}

			newSpan.onmouseover = Point.mouseOverWord;
			newSpan.onmouseout = Point.mouseOutWord;
			newSpan.onmouseenter = Point.highlightSpan;
			newSpan.onmouseleave = Point.unhighlightSpan;

			// Add the span to the DOM directly before the node it's going to wrap
			Point.addNode(node.parentNode, newSpan, node);
			
			// Remove the node from its current place and put it inside the span
			node.parentNode.removeChild(node);
			newSpan.appendChild(node);
			
			// Force span to inherit all style values from its parent
			if (Point.spansInheritParentStyles) {
				inheritParentStyles(newSpan, pointSpanInheritStyles);
			}
			return newSpan;
		},
		
		isNodeBlacklisted: function(node) {
			return node.nodeType === 1 && ( Point.array_contains( Point.blacklistedElements, node.tagName.toLowerCase() ) );
		},
		
		spanify: function(node) {
			if (node !== null) {
				// Check if the node is a blacklisted element
				var blacklisted = Point.isNodeBlacklisted(node);
				var c = node.childNodes;
				for (var i = 0; i < c.length; i++) {
					var child = c[i];
					var nextNode = null;
					if (i < c.length - 1) {
						nextNode = c[i + 1];
					}
					if (child.nodeType == 3) { // node is a text node. put spans around the words, unless the parent element is blacklisted
						if (blacklisted) {
							continue;
						}
						child.parentNode.removeChild(child);
						--i;
						var str = child.data;
						//var words = str.split(/(\s+)/); <-- doesn't return the whitespace in IE, ugh
						while (str.length > 0) {
							var wordmatch = str.match(/^[^\s]+/);
							if (wordmatch !== null) {
								var word = wordmatch[0];
								var newText = node.ownerDocument.createTextNode(word);
								Point.addNode(node, newText, nextNode);
								Point.wrapInSpan(newText);
								
								++i;
								str = str.slice(word.length);
							}
							var spacematch = str.match(/^\s+/);
							if (spacematch !== null) {
								var spacetext = spacematch[0];
								var space = node.ownerDocument.createTextNode(spacetext);
								Point.addNode(node, space, nextNode);

								++i;
								str = str.slice(space.length);
							}
						}
					} else if (child.nodeType == 1) {
						var childBlackListed = Point.isNodeBlacklisted(child);
						switch (child.nodeName.toLowerCase()) {
							case "select":
								if (!childBlackListed) {
									Point.wrapInSpan(child, pointSelectCssClass);
								}
								break;
							case "input":
								if (!childBlackListed) {
									var span = Point.wrapInSpan(child, pointInputCssClass);
									if (child.type === "text") {
										Point.addClass(span, pointVariableContentCssClass);
									}
								}
								break;
							case "img":
								if (!childBlackListed) {
									if (child.alt) {
										Point.wrapInSpan(child, pointImageCssClass);
									}
								}
								break;
                            case "frame":
							case "iframe":
                                if (!childBlackListed) {
                                    if (child.addEventListener) {
                                        child.addEventListener('load', function () {Point.spanifyFrame(this);}, false);
                                    } else if (child.attachEvent) {
                                        child.attachEvent('onload', function () {Point.spanifyFrame(this);});
                                    }
                                    Point.spanifyFrame(child);    
                                }
								break;
							case "div":
								if (child.className != "htmlarea") { Point.spanify(child); }
								break;
							default:
								Point.spanify(child);
								break;
						}
					} else {
						Point.spanify(child);
					}
				}
			}
		},

        getFrameDocument: function(frame) {
            var doc = frame.contentWindow || frame.contentDocument || frame.document;
            if (doc.document) {
                doc = doc.document;
            }
            return doc;
        },

        spanifyFrame: function(frame) {
            var doc = Point.getFrameDocument(frame);
            var bodies = doc.getElementsByTagName('body');
            if (bodies[0]) {
                Point.spanify(bodies[0]);
            }
            var framesets = doc.getElementsByTagName('frameset');
			if (framesets[0]) {
				Point.spanify(framesets[0]);
			}
            var heads = doc.getElementsByTagName('head');
            if (heads[0]) {
                var links = Point.findPointCssLinks();
                for (var i = 0; i < links.length; i++) {
                    var elem = doc.createElement('link');
                    elem.setAttribute('rel', 'stylesheet');
                    elem.setAttribute('media', 'screen');
                    elem.setAttribute('href', links[i]);
                    heads[0].appendChild(elem);
                }
            }
        },
		
		setSpanClasses: function (node) {
			if (node !== null) {
				var c = node.childNodes;
				for (var i = 0; i < c.length; i++) {
					var child = c[i];
					var nextNode = null;
					if (i < c.length - 1) {
						nextNode = c[i + 1];
					}
					if (child.nodeType == 1) {
						if (Point.pointActive) {
							if (Point.hasClass(child, pointDisabledSpanCssClass)) {
								Point.replaceClass(child, pointSpanCssClass, pointDisabledSpanCssClass);
							}
							if (Point.hasClass(child, pointDisabledSpanNoSymbolCssClass)) {
								Point.replaceClass(child, pointSpanNoSymbolCssClass, pointDisabledSpanNoSymbolCssClass);
							}
						} else {
							if (Point.hasClass(child, pointSpanCssClass)) {
								Point.replaceClass(child, pointDisabledSpanCssClass, pointSpanCssClass);
							}
							if (Point.hasClass(child, pointSpanNoSymbolCssClass)) {
								Point.replaceClass(child, pointDisabledSpanNoSymbolCssClass, pointSpanNoSymbolCssClass);
							}
						}
					}
					Point.setSpanClasses(child);
				}
			}
		},
		
		enablePointForNode: function(node) {
			Point.spanify(node);
		},
		
		findElements: function (node) {
			if (node !== null) {
				var processChildren = true;
				if (node.nodeType == 1) { // if node is an element
					if (Point.hasClass(node, Point.pointEnabledDivClass)) {
						Point.enablePointForNode(node);
						processChildren = false;
					}
				}
				
				if (processChildren) {
					var c = node.childNodes;
					for (var i = 0; i < c.length; i++) {
						Point.findElements(c[i]);
					}
				}
			}
		},
		
		nodeText: function(node) {
			var str = "", select, c, i, len;
			if (node !== null) {
				if (Point.hasClass(node, pointSelectCssClass)) {
					select = node.firstChild;
					str = select.options[select.selectedIndex].text;
				} else if (Point.hasClass(node, pointInputCssClass)) {
					str = node.firstChild.value;
				} else if (Point.hasClass(node, pointImageCssClass)) {
					str = node.firstChild.alt;
				} else {
					c = node.childNodes;
					for (i = 0, len = c.length; i < len; ++i) {
						if (c[i].nodeType == 3) {
							str += c[i].data;
						}
					}
				}
			}
			return str;
		},
		
		processTipData: function(data) {
			var str = data;
			if (str.replace(/^\s+|\s+$/g, "") === "") {
				str = "No Symbol";
			}
			Point.showTip(str, Point.lastMousePosX, Point.lastMousePosY);
		},
		
		startHover: function() {
			if (Point.findContentById) {
				var node = document.getElementById(Point.pointEnabledDivId); 
				Point.spanify(node);
			} else {
				Point.findElements(document);
			}
			Point.addWaitIcon();
		},
		
		unloadedImageCount: function(node, count) {
			var ct = count;
			if (node !== null) {
				var c = node.childNodes;
				for (var i = 0; i < c.length; i++) {
					var child = c[i];
					if (child.nodeType == 1) {
						if (child.tagName == "IMG") {
							if (child.complete !== true) {
								ct++;
							}
						}
					}
					ct = Point.unloadedImageCount(child, ct);
				}
			}
			return ct;
		},
		
		disableSpansForWord: function(node, word) {
			if (node !== null) {
				var c = node.childNodes;
				for (var i = 0; i < c.length; i++) {
					var child = c[i];
					if ((child.nodeType == 1) && (Point.hasClass(child, pointSpanCssClass) || Point.hasClass(child, pointSpanHighlightCssClass)) &&
							!Point.hasClass(child, pointVariableContentCssClass) && (Point.stripPunctuation(Point.nodeText(child)) == word)) {
						if (Point.hasClass(child, pointSpanHighlightCssClass)) {
							Point.replaceClass(child, pointSpanNoSymbolHighlightCssClass, pointSpanHighlightCssClass);
						} else {
							Point.replaceClass(child, pointSpanNoSymbolCssClass, pointSpanCssClass);
						}
					}
					Point.disableSpansForWord(child, word);
				}
			}
		},
		
		showTip: function (content, x, y) {
			if (Point.hoveringOverWord) {
				if (Point.tooltipDiv) {
					document.body.removeChild(Point.tooltipDiv);
					Point.tooltipDiv = null;
				}

				if (content.indexOf("<img") > -1) {
					Point.tooltipDiv = document.createElement("div");
					Point.tooltipDiv.id = "point_Point.tooltipDiv";
					Point.tooltipDiv.className = "point_sym_tooltip";
					Point.tooltipDiv.innerHTML = content;
					Point.imageLoadTimer = setInterval(Point.checkSymbolsLoaded, 50);
					Point.tooltipDiv.style.left = "0px";
					Point.tooltipDiv.style.top = "0px";
					Point.tooltipDiv.style.visibility = "hidden";
					Point.tooltipTargetX = x + 10 ;
					Point.tooltipTargetY = y + 4 ;
					Point.waitIconDiv.style.left = (x + 10) + "px";
					Point.waitIconDiv.style.top = (y + 4) + "px";
					Point.waitIconDiv.style.display = "";
					document.body.appendChild(Point.tooltipDiv);
				} else {
					documents = Point.findAllDocuments();
					for (var i = 0; i < documents.length; i++) {
						Point.disableSpansForWord(documents[i], Point.requestedWord);
					}
				}
			}
		},
		
		findAllDocuments: function (wnd, docs) {
			if (!docs)
				docs = [];
			if (!wnd)
				wnd = window;
			docs.push(wnd.document);
			for (var i = 0; i < wnd.frames.length; i++) {
				Point.findAllDocuments(wnd.frames[i], docs);
			}
			return docs;
		},
		
		addWaitIcon: function () {
			Point.waitIconDiv = document.createElement("div");
			Point.waitIconDiv.id = "point_waiticon";
			Point.waitIconDiv.className = "point_waiticon";
			Point.waitIconDiv.style.display = "none" ;
			document.body.appendChild(Point.waitIconDiv);
		},
		
		setPointState: function (enabled) {
			Point.pointActive = enabled;
			Point.setSpanClasses(document);
		},
		
		enablePoint: function (startImmediately) {
			httpClient = xhrClient;
			if (!Point.enablePointCalled) {
				if (httpClient.checkSupported()) {
					var start = startImmediately ;
					if (typeof(startImmediately) == 'undefined') {
						start = true;
					}
					
					var pointEnabled = Point.readCookie(pointEnabledCookieName);
					
					if (pointEnabled === "true") {
						start = true ;
					} else if (pointEnabled === "false") {
						start = false ;
					}
					
					createNonValidatingCssRules();
					Point.startHover();
					
					Point.setPointState(start);
					Point.updatePointImage();
					
					httpClient.init();
				}
				Point.enablePointCalled = true;
			}
		},
		
		updatePointImage: function () {
			var image = document.getElementById("point_togglebutton");
			if (image) {
				image.src = Point.pointActive ? Point.enabledPointImage : Point.disabledPointImage;
			}
		},
		
		togglePoint: function () {
			Point.setPointState(!Point.pointActive);
			Point.updatePointImage();
			Point.createCookie(pointEnabledCookieName, Point.pointActive ? "true" : "false", 90);
		},
		
		getAncestorWithCssClass: function(node, cssClass) {
			for (var n = node; n !== null; n = n.parentNode) {
				if (n.nodeType === 1 && Point.hasClass(n, cssClass)) {
					return n;
				}
			}
			return null;
		},
		
		doHover: function () {
			if (Point.pointActive) {
				var targ = Point.lastEventTarget;
				var span = Point.getAncestorWithCssClass(targ, pointAllSpanCssClass);

				if (Point.hasClass(span, pointSpanCssClass) || Point.hasClass(span, pointSpanHighlightCssClass)) {
					if (Point.hasClass(span, pointSelectCssClass)) {
						var select = span.firstChild;
						Point.requestedWord = select.options[select.selectedIndex].text;
					} else if (Point.hasClass(span, pointInputCssClass)) {
						var input = span.firstChild;
						Point.requestedWord = input.value;
					} else {
						Point.requestedWord = Point.stripPunctuation(Point.nodeText(span));
					}
					Point.requestedWordLang = Point.getLang(targ);
					httpClient.sendRequest(Point.requestedWord, Point.requestedWordLang);
					Point.requestPending = true;
				}
			}
		},
		
		getLang: function(el) {
			var langForCssClass, classNames, node = el, i;
			while (node) {
				if (node.className) {
					classNames = node.className.split(" ");
					i = classNames.length;
					while (i--) {
						langForCssClass = Point.languageCssClasses[ classNames[i] ];
						if (langForCssClass) {
							return langForCssClass;
						}
					}
				}
				node = node.parentNode;
			}
			return Point.defaultLanguage;
		},
		
		highlightSpan: function() {
			var span = this.ownerDocument.parentWindow.event.srcElement;
			if (Point.hasClass(span, pointSpanCssClass)) {
				Point.replaceClass(span, pointSpanHighlightCssClass, pointSpanCssClass);
			} else if (Point.hasClass(span, pointSpanNoSymbolCssClass)) {
				Point.replaceClass(span, pointSpanNoSymbolHighlightCssClass, pointSpanNoSymbolCssClass);
			}
		},
		
		unhighlightSpan: function() {
			var span = this.ownerDocument.parentWindow.event.srcElement;
			if (Point.hasClass(span, pointSpanHighlightCssClass)) {
				Point.replaceClass(span, pointSpanCssClass, pointSpanHighlightCssClass);
			} else if (Point.hasClass(span, pointSpanNoSymbolHighlightCssClass)) {
				Point.replaceClass(span, pointSpanNoSymbolCssClass, pointSpanNoSymbolHighlightCssClass);
			}
		},
		
		mouseOverWord: function(e) {
			var posx = 0, posy = 0;
			Point.hoveringOverWord = true;
			if (currentWordSpan !== this) {
				currentWordSpan = this;
				if (Point.pointActive && Point.tooltipDiv === null) {
					e = e || this.ownerDocument.parentWindow.event;

					Point.lastEventTarget = e.target || e.srcElement;
                    Point.lastElementTarget = this;
					
					var pos = Point.getObjectPosition(this);
					posx = pos['left'] + pos['width'];
					posy = pos['top'];
					
					var childDocument = this.ownerDocument;
					while (childDocument != document)
					{
						var frame = frame = Point.getFrameForDocument(childDocument);
						if (frame) {
							var framePos = Point.getObjectPosition(frame);
							posx += framePos['left'];
							posy += framePos['top'];
                            var wnd = Point.getFrameForDocument(childDocument).contentWindow;
							var scroll = Point.getDocumentScroll(wnd, childDocument);
							posx -= scroll[0];
							posy -= scroll[1];
							childDocument = frame.ownerDocument;
						} else {
							break;
						}
					}

					//if ( (Point.lastMousePosX != posx) || (Point.lastMousePosY != posy) ) {
						Point.lastMousePosX = posx;
						Point.lastMousePosY = posy;

						Point.cancelHover();

						Point.timeoutId = setTimeout(Point.doHover, Point.hoverTimeout);
					//}
				}
			}
		},

		mouseOutWord: function(e) {
			e = e || this.ownerDocument.parentWindow.event;
			var toElement = e.relatedTarget || e.toElement;
			if ( !isDescendantOf(toElement, this) ) {
				currentWordSpan = null;
				Point.cancelHover();
				Point.hoveringOverWord = false;
			}
		},

		cancelHover: function () {
			if (Point.tooltipDiv) {
				document.body.removeChild(Point.tooltipDiv);
				Point.tooltipDiv = null;
			}
			Point.waitIconDiv.style.display = "none" ;
			if (Point.timeoutId) {
				clearTimeout(Point.timeoutId);
				Point.timeoutId = null;
			}
			httpClient.abort();
			Point.requestPending = false;
			clearInterval(Point.imageLoadTimer);
		},
		
		checkSymbolsLoaded: function () {
			var imageLoadCount = Point.unloadedImageCount(Point.tooltipDiv, 0);
			if ( Point.tooltipDiv !== null && imageLoadCount === 0 && Point.hoveringOverWord ) {
				clearInterval(Point.imageLoadTimer);
				var windowwidth = 0, windowheight = 0;
				if( typeof( window.innerWidth ) == 'number' ) {
					//Non-IE
					windowwidth = window.innerWidth;
					windowheight = window.innerHeight;
				} else if( document.documentElement && ( document.documentElement.clientWidth || document.documentElement.clientHeight ) ) {
					//IE 6+ in 'standards compliant mode'
					windowwidth = document.documentElement.clientWidth;
					windowheight = document.documentElement.clientHeight;
				} else if( document.body && ( document.body.clientWidth || document.body.clientHeight ) ) {
					//IE 4 compatible
					windowwidth = document.body.clientWidth;
					windowheight = document.body.clientHeight;
				}
	
				Point.waitIconDiv.style.display = "none" ;
				var divbase = Point.tooltipTargetY + Point.tooltipDiv.clientHeight;
				var divright = Point.tooltipTargetX + Point.tooltipDiv.clientWidth;
				var vistop = document.documentElement.scrollTop + document.body.scrollTop;
				var visleft = document.documentElement.scrollLeft + document.body.scrollLeft;
				var visbase = vistop + windowheight;
				var visright = visleft + windowwidth;
				var baseoverlap = divbase - visbase ;
				var rightoverlap = divright - visright;
				if ( baseoverlap > 0 ) {
					var newtop = Point.tooltipTargetY - baseoverlap - 20 ;
					if (newtop < vistop) {
						newtop = vistop + 5;
					}
					Point.tooltipTargetY = newtop ;
				}
				if (rightoverlap > 0) {
					var pos = Point.getObjectPosition(Point.lastElementTarget);
					var newleft = Point.tooltipTargetX - Point.tooltipDiv.offsetWidth - pos['width'] - 20;
					if (newleft >= visleft) {
						Point.tooltipTargetX = newleft ;
					}
				}
				Point.tooltipDiv.style.left = Point.tooltipTargetX + "px";
				Point.tooltipDiv.style.top = Point.tooltipTargetY + "px";
				Point.tooltipDiv.style.visibility = "";
			}
		},

        findPointCssLinks: function() {
            var links = document.getElementsByTagName("link");
            var hrefs = [];
            for (var i = 0; i < links.length; i++) {
                if (links[i].rel.toLowerCase() == "stylesheet" &&
                    links[i].href.toLowerCase().search(/point/) != -1 &&
                    ((!links[i].media) || links[i].media == "" || links[i].media.toLowerCase() == "screen")) {

                    hrefs.push(links[i].href);
                }
            }

            return hrefs;
        }
	};
})();