function isIE()
{
    return navigator.appName.indexOf("Internet Explorer") >= 0;
}

function isIE6()
{
    // from http://ajaxian.com/archives/detecting-ie7-in-javascript
    return typeof document.body.style.maxHeight == "undefined";
}

function isIE7()
{
    return isIE() && !isIE6();
}

var IsSafari = null;

function tx_isSafari()
{
    if (IsSafari == null) {
        IsSafari = navigator.userAgent.indexOf("Safari") >= 0;
    }
    return IsSafari;
}

function isFirefox()
{
    return navigator.userAgent.indexOf("Firefox") >= 0;
}

// see http://www.bigbold.com/snippets/posts/show/701
String.prototype.trim = function()
{
    return this.replace(/^\s+|\s+$/g, "");
};

/*
 * Client side handler for DA ajax requests which update the dom.
 * Application must include prototype.js for this to work.
 */

function fireDirectActionAjax(element, url, afterEffect)
{
    var ajax = new Ajax.Request(
        url,
        {method: 'get',
         onSuccess: function(xmlhttp) {
                    var responseText = getResponseText(xmlhttp);
                    tx_handleUpdatesFromDirectAction(responseText, afterEffect);
                }
        }
    );
    return false;
}

/* handle the updates coming back from DirectActionService */
function tx_handleUpdatesFromDirectAction(responseText, afterEffect)
{
    if (!handleAjaxExceptionPage(responseText)) {
        //responseText = tx_stripHeadTagFromAjaxResponse(responseText);
        var domUpdates = eval(responseText);

        for (var elementId in domUpdates) {
            $(elementId).innerHTML = domUpdates[elementId];
        }

        if (afterEffect != undefined) {
            afterEffect();
        }
    }
}

/* Trick to execute embedded JS code in an AJAX response.  Norton sometimes strips <script> tags. */
function findAndEvalJavascript(reponseContents)
{
    /*  // XXX Make this work -- see Bug #355
    if (document.isDevMode && reponseContents.indexOf("<script") != -1) {
        alert("Inline script detected in dialog response.  Norton security prevents the use of such script tags -- use @@script@@");
        alert(reponseContents);
    }
    */
    var scriptMarker = "@@script@@";
    var indexOfStart = 0;
    var indexOfMarker = 0;
    while ((indexOfMarker = reponseContents.indexOf(scriptMarker, indexOfStart)) != -1) {
        indexOfStart = indexOfMarker + scriptMarker.length;
        var indexOfEnd = reponseContents.indexOf(scriptMarker, indexOfStart);
        var substring = reponseContents.substring(indexOfStart, indexOfEnd);
        eval(substring);
        indexOfStart = indexOfEnd + 1;
    }
}


/*
 * Some geometry utils.  This section should get replaced by Prototype.js
 */


// Returns the viewport height, not including any horiz scrollbar.
function windowInnerHeight()
{
    if (tx_isSafari()) {
        return window.innerHeight;
    }
    return document.documentElement.clientHeight;
}

// Returns the viewport width, not including any vertical scrollbar.
function windowInnerWidth()
{
    return document.documentElement.clientWidth;
}

// http://dev.conio.net/repos/prototype/src/position.js has alternative versions of these
function absoluteTop(element)
{
    var absoluteTop = 0;
    var parentElement = element;
    do {
        absoluteTop += parentElement.offsetTop;
        // See bug 1165.  Never adjust for scrolXXX on the topmost (HTML or BODY) because that is document scroll
        if (parentElement.offsetParent != null) {
            absoluteTop -= parentElement.scrollTop;
        }
    } while ((parentElement = parentElement.offsetParent) != null)
    return absoluteTop;
}

function absoluteLeft(element)
{
    var absoluteLeft = 0;
    var parentElement = element;
    do {
        absoluteLeft += parentElement.offsetLeft;
        // See bug 1165.  Never adjust for scrolXXX on the topmost (HTML or BODY) because that is document scroll
        if (parentElement.offsetParent != null) {
            absoluteLeft -= parentElement.scrollLeft;
        }
    } while ((parentElement = parentElement.offsetParent) != null)
    return absoluteLeft;
}

function absoluteRight(element)
{
    return absoluteLeft(element) + element.offsetWidth;
}

function absoluteBottom(element)
{
    return absoluteTop(element) + element.offsetHeight;
}

function tx_getDocumentElement()
{
    return tx_isSafari() ? document.body : document.documentElement;
}

function tx_windowScrollTop()
{
    var documentElement = tx_getDocumentElement();
    return documentElement.scrollTop;
}

function tx_windowScrollLeft()
{
    var documentElement = tx_getDocumentElement();
    return documentElement.scrollLeft;
}

function getWindowTopEdge()
{
    var topEdge = tx_windowScrollTop();
    return topEdge;
}

function getWindowBottomEdge()
{
    var topEdge = tx_windowScrollTop();
    var windowHeight = windowInnerHeight();
    var windowBottomEdge = windowHeight + topEdge;
    return windowBottomEdge;
}

function getWindowLeftEdge()
{
    var leftEdge = tx_windowScrollLeft();
    return leftEdge;
}

function getWindowRightEdge()
{
    var leftEdge = tx_windowScrollLeft();
    var windowWidth = windowInnerWidth();
    var windowRightEdge = windowWidth + leftEdge;
    return windowRightEdge;
}

function availableSpaceRight(element, leftPos)
{
    var windowRightEdge = getWindowRightEdge();
    var elementRightEdge = element.clientWidth + leftPos;
    var availableSpace = windowRightEdge - elementRightEdge;
    return availableSpace;
}

function availableSpaceBottom(element, topPos)
{
    var windowBottomEdge = getWindowBottomEdge();
    var elementBottomEdge = element.clientHeight + topPos;
    var availableSpace = windowBottomEdge - elementBottomEdge;
    return availableSpace;
}

function availableSpaceLeft(element, leftPos)
{
    var windowLeftEdge = getWindowLeftEdge();
    var availableSpace = leftPos - windowLeftEdge;
    return availableSpace;
}

function availableSpaceTop(element, topPos)
{
    var windowTopEdge = getWindowTopEdge();
    var availableSpace = topPos - windowTopEdge;
    return availableSpace;
}

function isOffscreenRight(element, leftPos)
{
    var availableSpace = availableSpaceRight(element, leftPos);
    var isOffscreenRight = availableSpace < 0;
    return isOffscreenRight;
}

function isOffscreenBottom(element, topPos)
{
    var availableSpace = availableSpaceBottom(element, topPos);
    var isOffscreenBottom = availableSpace < 0;
    return isOffscreenBottom;
}

/**
*  The coverDivHeight/Width are used for computing the max width/height of a given document
*  and will use the windowInnerHeight/Width is that's greater than the document's width/height.
*/
function coverDivHeight()
{
    return Math.max(windowInnerHeight(), tx_getDocumentElement().scrollHeight) + 'px';
}

function coverDivWidth()
{
    return Math.max(windowInnerWidth(), tx_getDocumentElement().scrollWidth) + 'px';
}

function createCoverDiv(className, zIndex)
{
    var coverDiv = document.createElement('div');
    var coverDivStyle = coverDiv.style;
    if (className == null) {
        coverDivStyle.backgroundColor = 'white';
    }
    else {
        coverDiv.className = className;
    }
    coverDivStyle.position = 'absolute';
    coverDivStyle.width = coverDivWidth();
    coverDivStyle.height = coverDivHeight();
    coverDivStyle.top = '0px';
    coverDivStyle.left = '0px';
    coverDivStyle.zIndex = zIndex;

    return coverDiv;
}

/**
*  This function is used by Ajax hanlder routines to detect and display an ExceptionPage response.
*  If an ExceptionPage response is detected, this covers the existing page with a div and puts the
*  body of the ExceptionPage into this div.  You cannot viewSource to see the exception, so you can
*  shift-click in the upper-right corner of the page to see the exception.
*/
function handleAjaxExceptionPage(dialogContents)
{
    var isExceptionPage = false;
    var exceptionMarker = "<!-- ExceptionPage -->";
    var prefixSubstring = dialogContents.substring(0, exceptionMarker.length);
    if (prefixSubstring == exceptionMarker) {
        isExceptionPage = true;
        var bodyMarker = "<body>";
        var indexOfBodyStart = dialogContents.indexOf(bodyMarker);
        var indexOfBodyEnd = dialogContents.indexOf("</body>", indexOfBodyStart);
        var bodyContents = dialogContents.substring(indexOfBodyStart + bodyMarker.length, indexOfBodyEnd);
        var coverDiv = createCoverDiv(null, 1000);
        document.body.appendChild(coverDiv);
        coverDiv.innerHTML = bodyContents;
        window.scrollTo(0,0);
    }
    return isExceptionPage;
}

/**
 * ALWAYS use this to get the responseText from an XMLHttpRequest.
 * as it turns out safari sometimes returns null rather than empty string
 * for empty responses.  See bug 319.
 */
function getResponseText(xmlhttp)
{
    if (xmlhttp != null && xmlhttp.responseText != null) {
        return xmlhttp.responseText;
    }
    return "";
}

/**
 * Cookie utilities
 */
function setCookie(name, value, daysToExpire, domain)
{
    var cookieStr = name + "=" + value;
    var expires;
    if (daysToExpire) {
        var date = new Date();
        date.setTime(date.getTime() + daysToExpire*24*60*60*1000);
        cookieStr += "; expires="+date.toGMTString();
    }
    cookieStr += "; path=/";
    if (domain) {
        cookieStr += "; domain="+domain;
    }
    document.cookie = cookieStr;
}

function getCookie(name)
{
    var start = document.cookie.indexOf(name + "=")
    if (start > -1) {
        start += name.length + 1;
        var end = document.cookie.indexOf(";", start);
        if (end == -1)
            end = document.cookie.length;
        return unescape(document.cookie.substring(start, end));
    }
    return null;
}

function clearCookie(name, domain)
{
    setCookie(name, "", -365, domain)
}

// removes duplicates from a SORTED array
Array.prototype.unique = function(valueFunc)
{
    if (this.length < 2) {
        return;
    }

    if (valueFunc == null) {
        valueFunc = function(x) {return x;};
    }

    var prev = valueFunc(this[0]);
    for (var i = 1; i < this.length; ) {
        var curr = valueFunc(this[i]);
        if (prev == curr) {
            this.splice(i, 1);
        } else {
            prev = curr;
            i++;
        }
    }
}

// Ported from http://googleresearch.blogspot.com/2006/06/extra-extra-read-all-about-it-nearly.html.
// NOTE this assumes distinct values.  If there are duplicates, is might not return the first one.
Array.prototype.binarySearch = function(key)
{
    var low = 0;
    var high = this.length - 1;

    while (low <= high) {
        var mid = (low + high) >>> 1;
        var midVal = this[mid];

        if (midVal < key)
            low = mid + 1;
        else if (midVal > key)
            high = mid - 1;
        else
            return mid; // key found
    }
    return -(low + 1);  // key not found.
}

// Returns the first text field in a form element or null if none exists.
function findFirstTextField(formElement)
{
    var firstTextField = null;
    var inputElementsArray = formElement.getElementsByTagName('INPUT');
    var arrayLength = inputElementsArray.length;
    for (var index = 0; index < arrayLength; index++) {
        var inputElement = inputElementsArray[index];
        var inputElementType = inputElement.type;
        if (inputElementType == 'text') {
            firstTextField = inputElement;
            break;
        }
    }
    return firstTextField;
}

function findChildTagWithId(element, tagName, targetId)
{
    var childArray = element.getElementsByTagName(tagName);
    if (childArray !== null && childArray !== undefined) {
        var childArrayLength = childArray.length;
        for (var index = 0; index < childArrayLength; index++) {
            var child = childArray[index];
            if (child.id == targetId) {
                return child;
            }
        }
    }
    return null;
}

function findChildWithId(element, targetId)
{
    var targetChild = null;
    var childArray = element.childNodes;
    if (childArray !== null && childArray !== undefined) {
        var childArrayLength = childArray.length;
        for (var index = 0; index < childArrayLength; index++) {
            var child = childArray[index];
            var childId = child.id;
            if (childId == targetId) {
                targetChild = child;
                break;
            }
            else {
                // recurse to the lext level
                targetChild = findChildWithId(child, targetId);
                if (targetChild != null) {
                    break;
                }
            }
        }
    }
    return targetChild;
}

function findChildWithClass(element, className)
{
    var targetChild = null;
    var childArray = element.childNodes;
    if (childArray !== null && childArray !== undefined) {
        var childArrayLength = childArray.length;
        for (var index = 0; index < childArrayLength; index++) {
            var child = childArray[index];
            if (child.className == className) {
                targetChild = child;
                break;
            }
            else {
                // recurse to the lext level
                targetChild = findChildWithClass(child, className);
                if (targetChild != null) {
                    break;
                }
            }
        }
    }
    return targetChild;
}

function findNontextChildren(element)
{
    var nontextChildren = new Array();
    var children = element.childNodes;
    var childrenLength = children.length;
    for (var index = 0; index < childrenLength; index++) {
        var child = children[index];
        if (child.nodeName != "#text") {
            nontextChildren.push(child);
        }
    }
    return nontextChildren;
}

function findFirstNontextChild(element)
{
    var children = element.childNodes;
    var childrenLength = children.length;
    for (var index = 0; index < childrenLength; index++) {
        var child = children[index];
        if (child.nodeName != "#text") {
            return child;
        }
    }
    return null;
}

function findParentWithClass(element, className)
{
    var parent = null;
    while (element != null) {
        parent = element.parentNode;
        if (parent.className == className) {
            return parent;
        }
        element = parent;
    }

    return null;
}

/**
* This function works for getting the window height info when setting the cookie.  The function windowInnerHeight()
* does not work properly for the inline js code which is emitted in BrowsePage.html.  We must use this same function
* for all comparisons of window height where the product cell size is involved.
*/
function tx_windowSizeForCookie()
{
    // Note that windowInnerHeight() doesn't work properly when used in this context (probably too early for things to be setup properly).
    return isIE() ? document.documentElement.offsetHeight : window.innerHeight;
}

function tx_resetWindowSizeCookie(domain)
{
    var innerHeight = tx_windowSizeForCookie();
    // Note that "win.h='" must be kept in sync with same token in UserState.java
    // Note that closing token ';' must be kept in sync with same token in UserState.java
    // Note that cookie name 'sc5' must be kept in sync with same token in StoreUtil.WindowInfoCookieName
    setCookie('sc5', "win.h='" + innerHeight + "'", 0, domain);
}

function tx_stripHeadTagFromAjaxResponse(responseText)
{
    if (responseText == null) {
        return responseText;
    }

    // To avoid searches on big strings
    var responsePrefix = responseText.length > 30 ? responseText.substring(0, 30) : responseText;
    var openHeadTagIndex = responsePrefix.indexOf('<head>');
    if (openHeadTagIndex == -1) {
        openHeadTagIndex = responsePrefix.indexOf('<HEAD>');
    }

    if (openHeadTagIndex == -1) {
        return responseText;
    }

    var closeHeadTagIndex = responseText.indexOf('</head>');
    if (closeHeadTagIndex == -1) {
        closeHeadTagIndex = responseText.indexOf('</HEAD>');
    }

    if (closeHeadTagIndex == -1) {
        return responseText;
    }

    closeHeadTagIndex += 7;

    var strippedResponse = responseText.substring(0, openHeadTagIndex) + responseText.substring(closeHeadTagIndex);
    return strippedResponse;
}

function tx_setLocationAnchor(newAnchor)
{
    if (tx_isSafari()) { // See bug 1132, 1464 re safari anchor support
        return;
    }
    var url = window.location.href;
    var hashIndex = url.indexOf("#");
    var newUrl = hashIndex == -1 ? url : url.substring(0, hashIndex);

    // We never remove the hash because this will cause a reload.
    newUrl += "#";
    if (newAnchor && newAnchor.length > 0) {
        newUrl += newAnchor;
    }
    window.location.replace(newUrl);
}

function tx_setLocationToChildLink(aparent,event)
{
    var links = aparent.getElementsByTagName("a");
    if (links !== null && links !== undefined && links.length > 0) {
        window.location = links[0].href;
    }
    // in case the click was on the contained anchor, don't let it do normal action
    Event.stop(event);
}

function tx_getParameter(param)
{
    var i = window.location.search.indexOf(param + "=");
    if (i > -1) {
        i += param.length + 1;
        var j = window.location.search.indexOf("&", i);
        if (j == -1)
            j = window.location.search.length;
        return window.location.search.substring(i, j);
    }
    return null;
}

// Replace a URL param, appending to existing value if present, or clearing if new value is empty
// E.g. given 'shopstyle.com?a=123&b=456', 'a', 'xyz', returns 'shopstyle.com?a=xyz+123&b=456'
function tx_updateParam(url, param, value)
{
    var start = url.indexOf(param + '=');
    if (start > -1) {
        var end = url.indexOf('&', start);
        var paramLen = param.length + 1;
        var newValue = value == '' ? '' : value + '+' + (end > -1 ? url.substring(start + paramLen, end) : url.substring(start + paramLen));
        return url.substring(0, start) + param + '=' + newValue + (end > -1 ? url.substring(end) : '');
    }
    else {
        return url + (url.indexOf('?') > -1 ? '&' : '?') + param + '=' + value;
    }
}

// Replace a URL param, replacing an existing value if present, or clearing if new value is empty
// E.g. given 'shopstyle.com?a=123&b=456', 'a', 'xyz', returns 'shopstyle.com?a=xyz&b=456'
function tx_replaceParam(url, param, value)
{
    var start = url.indexOf(param + '=');
    if (start > -1) {
        var end = url.indexOf('&', start);
        return url.substring(0, start) + param + '=' + value + (end > -1 ? url.substring(end) : '');
    }
    else {
        return url + (url.indexOf('?') > -1 ? '&' : '?') + param + '=' + value;
    }
}

function tx_setAllCheckboxes(root, flag)
{
    var inputs = root.getElementsByTagName('input');
    for (var i = 0; i != inputs.length; i++) {
        if (inputs[i].type == "checkbox") {
            inputs[i].checked = flag;
        }
    }
}

function TX_PopupContext()
{
    this._popupParent = null;
    this._timeout = null;
    this._popupChildId = null;
    this._popEnterTime = 0;
    this._topOffset = 0;
    this._leftOffset = 0;
    this._popupParentClass = null;
    // for observers of menu events
    this.observers = new TxEventObserver();
}

TX_PopupContext.prototype.mdescription = "TX_PopupContext class";

TX_PopupContext.prototype.initiatePopup = function(popupParent, event, childId, topOffset, leftOffset, popupDelay)
{
    //trace('tx_ initiate popup on ' + event.target);
    if (this._popupParent != null && popupDelay != 0) {
        if (this._popupParent == popupParent) {
            Event.stop(event);
            return;
        } else {
            this.closePopup();
        }
    }
    if ($(childId) == null) {
        return;
    }
    this._popupParent = popupParent;
    this._popupChildId = childId;
    this._topOffset = topOffset;
    this._leftOffset = leftOffset;
    this._popupParentClass = popupParent.className;

    if (popupDelay > 0) {
        Event.observe(document.body, "mouseover", popup_handleMouseOverBody, false);
        Event.observe(this._popupChildId, "mouseover", popup_handleMouseOverPopup, false);
    }

    var handlerFunction = function() {
        //trace('tx_ handler');
        document.popupContext.openPopup();
        document.popupContext._timeout = null;
    }

    if (popupDelay > 0) {
        this._timeout = window.setTimeout(handlerFunction, popupDelay);
    } else {
        document.popupContext.openPopup();
    }

    Event.stop(event);
}

/**
    Make the child popup div visible, and position directly beneath the parent.
*/
TX_PopupContext.prototype.openPopup = function()
{
    var parentElement = this._popupParent;
    menuElement = $(this._popupChildId);
    if (menuElement == null) {
        return;
    }
    //trace('tx_ show popup child');
    menuElement.style.position = 'absolute';
    var isAbsolute = (this._topOffset == 0 && this._leftOffset == 0);

    menuElement.style.top = (isAbsolute ? absoluteBottom(parentElement) : parentElement.offsetTop + parentElement.offsetHeight + this._topOffset) + 'px';
    var parentLeft = (isAbsolute ? absoluteLeft(parentElement) : parentElement.offsetLeft + this._leftOffset);
    var windowEdgeRight = windowInnerWidth() + tx_windowScrollLeft();
    var elementWidth = absoluteRight(menuElement) - absoluteLeft(menuElement);
    if (parentLeft + elementWidth < windowEdgeRight) {
        menuElement.style.left = parentLeft+'px';
    }
    else {
        menuElement.style.left = (windowEdgeRight - elementWidth - 2)+'px';
    }

    menuElement.style.visibility='visible';

    // add a style to parent to show its current selection
    parentElement.className = this._popupParentClass + ' selected';

    this.observers.notify("openPopup", menuElement);
}

TX_PopupContext.prototype.closePopup = function()
{
    //trace('txp.closePopup');

    // cancel the timeout
    var popupContext = this;
    if (popupContext._timeout != null) {
        window.clearTimeout(popupContext._timeout);
        popupContext._timeout = null;
    }

    if (popupContext._popupParent != null) {
        // hide the menu
    	popupContext._popupParent.className = popupContext._popupParentClass;
        menuElement = $(this._popupChildId);
        Event.stopObserving(this._popupChildId, "mouseover", popup_handleMouseOverPopup, false);
        popupContext._popupParent = null;
        popupContext._popupChildId = null;
        popupContext._popupParentClass = null;
        if (menuElement != null) {
            menuElement.style.visibility = 'hidden';
        }
    }
}

function popup_handleMouseOverBody(event)
{
    var tDelta = new Date().getTime() - document.popupContext._popEnterTime;
    //trace('tx_ mouseoverbody ' + tDelta);
    document.popupContext._popEnterTime = 0;
    // if the body mouse-over happens immediately after popup mouse-over we want to ignore it because it is just a move from one item to another
    if (tDelta > 20) {
        Event.stopObserving(document.body, "mouseover", popup_handleMouseOverBody, false);
        document.popupContext.closePopup();
    }
}

function popup_handleMouseOverPopup(event)
{
    //trace('tx_ mouseoverpopup');
    document.popupContext._popEnterTime = new Date().getTime();
}

document.popupContext = new TX_PopupContext();

function tx_addEventListenerToElement(element, eventName, handlerFunction, useCapture)
{
    if (element.addEventListener == undefined) {
        element.attachEvent("on" + eventName, handlerFunction);
    }
    else {
        element.addEventListener(eventName, handlerFunction, useCapture);
    }
}

// for handling our own named events
function TxEventObserver()
{
}

// add an observer specified for a given event name
TxEventObserver.prototype.addObserver = function(eventName, observer)
{
    if (this[eventName] == null) {
        this[eventName] = [];
    }
    this[eventName].push(observer);
    // return the index as the id of the observer, for possible removal
    return this[eventName].length-1;
}

TxEventObserver.prototype.removeObserver = function(eventName, obsIndex)
{
    var observers = this[eventName];
    if (observers != null) {
        observers[obsIndex] = null;
    }
}

TxEventObserver.prototype.notify = function(eventName, arg)
{
    var observers = this[eventName];
    if (observers != null) {
        for (var ii = 0; ii < observers.length; ii++) {
            if (observers[ii] != null) {
                observers[ii](arg);
            }
        }
    }
}




///////////////////
// MDetailsContext
///////////////////

function MDetailsContext()
{
    this._currentDetailsFetcherDiv = null;
    this._pendingShowDetailsTimeout = 0;
    this._pendingTimeoutPurpose = null;  // if a div, we are showing.  if null, we are hiding
    this._extraDelay = 0;
    this._isEmbedded = false;
    this._disabled = false;
    this._isClickToClose = false;  // if true, there are buttons for open and close instead of mouseover-ing
    // for observing hide and show events
    this.observers = new TxEventObserver();
}

MDetailsContext.prototype.mdescription = "MDetailsContext class";

MDetailsContext.prototype.findMegaphoneImage = function(detailsFetcherDiv, isOverBottomEdge, isOverRightEdge)
{
    var detailsDiv = this.getDetailsDiv(detailsFetcherDiv);
    var megaphoneId = (isOverBottomEdge ? "b" : "t") + (isOverRightEdge ? "r" : "l");
    var megaphoneImage = findChildTagWithId(detailsDiv, "IMG", megaphoneId);
    if (megaphoneImage != null && megaphoneImage.initialTop === undefined) {
        megaphoneImage.initialTop = megaphoneImage.style.top;
    }
    return megaphoneImage;
}

MDetailsContext.prototype.clearPendingTimeout = function()
{
   // if (this._pendingShowDetailsTimeout != 0) {
   // alert(this._pendingShowDetailsTimeout);
        //trace("clearTimeout");
        window.clearTimeout(this._pendingShowDetailsTimeout);
        this._pendingShowDetailsTimeout = 0;
   // }
    this._pendingTimeoutPurpose = null;
}

MDetailsContext.prototype.getDetailsDiv = function(detailsFetcherDiv)
{
    return detailsFetcherDiv ? detailsFetcherDiv._detailsDiv : null;
}

MDetailsContext.prototype.clearCachedDetailsDiv = function(detailsFetcherDiv)
{
    if (detailsFetcherDiv) {
        if (detailsFetcherDiv == this._currentDetailsFetcherDiv) {
            this.clearPendingTimeout();
            this.hideCurrentDetails();
        }
        detailsFetcherDiv._detailsDiv = null;
        detailsFetcherDiv._isFetching = null;
    }
}

MDetailsContext.prototype.findContainingFetcherDiv = function(node)
{
    while (node != null) {
        if (node.tagName == 'DIV') {
            var detailsUrlTag = findChildTagWithId(node, "a", "rawDetailsUrl");
            if (detailsUrlTag != null) {
                return node;
            }
        }
        node = node.parentNode;
    }
    return null;
}

// Used by pages that present a "static" details view instead of using the DetailsPopup
MDetailsContext.prototype.installStaticDetails = function(detailsFetcherDiv)
{
    this._currentDetailsFetcherDiv = detailsFetcherDiv;
    this._fakeDetailsInstalled = true;
}

////****************
MDetailsContext.prototype.positionAndDisplayDetailsPopup = function(detailsFetcherDiv, event)
{
    var detailsDiv = this.getDetailsDiv(detailsFetcherDiv);

    if (detailsDiv == null && detailsFetcherDiv._isFetching == null) {
        detailsFetcherDiv._isFetching = true;
        // We cache the detailsDiv on the detailsFetcher object.  If not there, we haven't been down
        // this path yet for this instance.  Locate the detailsDiv, yank it out of the detailsPopupHolder
        // and attach it to the document.body for document-relative positioning.
        var detailsContext = this;
        var tempDiv = document.createElement("div");
        var handleAjaxResponse = function(xmlhttp) {
            var dialogContents = getResponseText(xmlhttp);
            if (!handleAjaxExceptionPage(dialogContents)) {
                //dialogContents = tx_stripHeadTagFromAjaxResponse(dialogContents);
                tempDiv.innerHTML = dialogContents;
                //findAndEvalJavascript(dialogContents);
                detailsDiv = findFirstNontextChild(tempDiv);
                detailsFetcherDiv._detailsDiv = detailsDiv;
                detailsDiv.detailsFetcherDiv = detailsFetcherDiv;
                document.body.appendChild(detailsDiv);
                // check to make sure that the user hasn't moved their mouse to another cell while
                // we were waiting for the reponse from the server (this check prevents multiple popups from showing
                // at the same time with some being stuck on the screen).
                if (detailsContext._pendingTimeoutPurpose == detailsFetcherDiv) {
                    detailsContext._positionAndDisplayDetailsPopup(detailsFetcherDiv, detailsDiv);
                }
            } else {
            }
        };
        var optionsDict = {
                asynchronous: true,
                method: 'get',
                onSuccess: handleAjaxResponse
        };
        var rawDetailsUrlTag = findChildTagWithId(detailsFetcherDiv, "a", "rawDetailsUrl");
        var url = rawDetailsUrlTag.href;
        new Ajax.Request(url, optionsDict);
    }
    else {
        this._positionAndDisplayDetailsPopup(detailsFetcherDiv, detailsDiv);
    }
}

MDetailsContext.prototype._positionAndDisplayDetailsPopup = function(detailsFetcherDiv, detailsDiv)
{
//alert("display");
    // Note: cannot cache these values as they change when user scrolls the CellBrowser
    var cellTop = absoluteTop(detailsFetcherDiv);
    var cellLeft = absoluteLeft(detailsFetcherDiv);
    var cellWidth = detailsFetcherDiv.offsetWidth;
    var cellHeight = detailsFetcherDiv.offsetHeight;

    var megaphoneHeight = 50;
    var megaphoneWidth = 48;
    var lowerMegaphoneOffset = 15;
    var horizontalOffset = 0.33;
    var verticalOffset = 0.50;
    var isSmallCell = cellHeight < 45;
    if (isSmallCell) {
        horizontalOffset = 0.28;
        verticalOffset = 0.38;
    }
    var popupTop = cellTop + ((1 - verticalOffset) * cellHeight);
    var popupLeft = cellLeft + ((1 - horizontalOffset) * cellWidth) + megaphoneWidth + 25;

    // position offscreen and make visible so we can get width/height info
    detailsDiv.style.top = "-1000px";
    detailsDiv.style.left = "0px";
    detailsDiv.className = "visible";

    if (this._isEmbedded) {
        popupTop = cellTop + cellHeight - 18;
        popupLeft = cellLeft + (cellWidth - detailsDiv.offsetWidth) / 2;
        if (popupLeft <= 2)
            popupLeft = 3;
    }

    var topAdjustment = 0;
    var bottomAdjustment = 0;
    var isOverBottomEdge = false;
    var availableBottom = availableSpaceBottom(detailsDiv, popupTop) - 8; // gives extra margin at bottom of window
    if (availableBottom < 0) {
        // we only allow another 35% on top of the already 50% so we leave at least 15% of the cell showing.
        // also, if we only allow for a max movement of 25% of the height of the details to avoid placing the megaphone in weird place.
        if ((-availableBottom) < (0.35 * cellHeight) && ((-availableBottom) < (0.25 * detailsDiv.clientHeight))) {
           bottomAdjustment = availableBottom;
           popupTop += bottomAdjustment;
        }
        else {
            isOverBottomEdge = true;
            // if the bottomAdjustment leaves to little space of the cell showing, we throw it to the top.
            popupTop = cellTop + (verticalOffset * cellHeight) - detailsDiv.offsetHeight + lowerMegaphoneOffset;
            var availableTop = availableSpaceTop(detailsDiv, popupTop);
            if (availableTop < 0) {
                topAdjustment = -availableTop;
                popupTop += topAdjustment;
            }
        }
    }
    var isOverRightEdge = isOffscreenRight(detailsDiv, popupLeft);
    if (isOverRightEdge) {
        if (this._isEmbedded) {
            popupLeft += (availableSpaceRight(detailsDiv, popupLeft) - 2);
        }
        else {
            popupLeft = cellLeft - (detailsDiv.offsetWidth + megaphoneWidth) + (horizontalOffset * cellWidth);
            var availableLeft = availableSpaceLeft(detailsDiv, popupLeft);
            if (availableLeft < 0) {
                popupLeft -= availableLeft;
            }
        }
    }

    // show or hide the close button
    var closeButton = findChildWithId(detailsDiv, 'closeDetailsButton');
    if (closeButton) {
        closeButton.style.display = this._isClickToClose ? 'block' : 'none';
    }

    // show megaphone
    var megaphoneImage = this.findMegaphoneImage(detailsFetcherDiv, isOverBottomEdge, isOverRightEdge);
    if (megaphoneImage != null) {
        if (topAdjustment > 0) {
            var newMegaphoneTop = (parseInt(megaphoneImage.initialTop) - topAdjustment) + "px";
            megaphoneImage.style.top = newMegaphoneTop;
        }
        else if (bottomAdjustment < 0) {
            // we multiply the bottomAdjustment * 0.5 to allow the megphone to move slightly with the details
            // otherwise it looks a bit funny coming in from the bottom half of the details popup
            var newMegaphoneTop = (parseInt(megaphoneImage.initialTop) - (bottomAdjustment * .5)) + "px";
            megaphoneImage.style.top = newMegaphoneTop;
        }
        else {
            // this is required in case we altered it in a previous cycle
            megaphoneImage.style.top = megaphoneImage.initialTop;
        }
        megaphoneImage.className = "visible";
    }
    // stash the megaphoneImage for later hiding in hideCurrentDetails()
    detailsDiv.megaphoneImage = megaphoneImage;

    detailsDiv.style.top =  popupTop + "px";
    detailsDiv.style.left = popupLeft + "px";

    if (isIE6()) {      // for widget popup; see MCell.adjustTwoLineDivHeight
        var twoLineDiv = findChildTagWithId(detailsDiv, 'DIV', 'twoLineDiv');
        if (twoLineDiv != null) {
            twoLineDiv.style.height = "";
            if (twoLineDiv.offsetHeight > 24)
                twoLineDiv.style.height = "24px";
        }
    }

    this.observers.notify("show");
}

MDetailsContext.prototype.showDetailsPopup = function(detailsFetcherDiv, event, clickToClose)
{
		if (document.popupContext != null) {
				// hide the generic popup when we kick off
				document.popupContext.closePopup();
		}

		if(clickToClose == "undefined")
		{
			clickToClose = false;
		}
    //alert("showDetailsPopup " + detailsFetcherDiv + " " + clickToClose);

    if (this._disabled) {
        return;
    }

    // if this._currentDetailsFetcherDiv == null, we're not showing details.
    var normalDelay = clickToClose ? 10 : 800;
    var delay = this._currentDetailsFetcherDiv == null ? 800 + this._extraDelay : normalDelay;

/*
		if(clickToClose){
			delay = 0;
			normalDelay = 0;
		} else {
			//10000 = 10 sec
			delay = 3000;
			normalDelay = 3000;
		}
*/

    this._extraDelay = 0;
    var detailsContext = this;
    detailsContext._isClickToClose = clickToClose;

    if (detailsContext._pendingShowDetailsTimeout != 0 && detailsContext._pendingTimeoutPurpose == detailsFetcherDiv) {
        // The work we would do is already scheduled, so nothing for us to do
        return;
    }

    detailsContext.clearPendingTimeout();

    if (detailsFetcherDiv != this._currentDetailsFetcherDiv) {
        var handlerFunction = function() {

            //detailsContext._pendingShowDetailsTimeout = 0;
            //detailsContext.hideCurrentDetails();
            detailsContext._currentDetailsFetcherDiv = detailsFetcherDiv;
            if (!detailsContext._isClickToClose) {
                Event.observe(document.body, "mouseover", details_handleMouseOverBody, false);
            }
            detailsContext.positionAndDisplayDetailsPopup(detailsFetcherDiv, event);
        }

		detailsContext._pendingShowDetailsTimeout = 0;
        detailsContext.hideCurrentDetails();
        this._pendingShowDetailsTimeout = window.setTimeout(handlerFunction, delay);
        this._pendingTimeoutPurpose = detailsFetcherDiv;

        if (document.popupContext != null) {
            // hide the generic popup when we kick off
            document.popupContext.closePopup();
        }
    }
}

// general routine to close the details, closes the popup and takes care of outstanding timeouts
MDetailsContext.prototype.closeDetailsPopup = function()
{
    //trace("closeDetailsPopup start " + this._isClickToClose);
    if (this._pendingShowDetailsTimeout != 0 && this._pendingTimeoutPurpose == null) {
        // The work we would do is already scheduled, so nothing for us to do
        return;
    }
    this.clearPendingTimeout();
    var detailsContext = this;
    var handlerFunction = function() {
        //trace("closeDetailsPopup handler " + detailsContext._isClickToClose);
        detailsContext._pendingShowDetailsTimeout = 0;
        detailsContext.hideCurrentDetails();
        if (!detailsContext._isClickToClose) {
            Event.stopObserving(document.body, "mouseover", details_handleMouseOverBody, false);
        }
        else {
            // reset to default
            detailsContext._isClickToClose = false;
        }
    }
    if (this._isClickToClose) {
        // do work immediately
        handlerFunction();
    }
    else {
        this._pendingShowDetailsTimeout = window.setTimeout(handlerFunction, 800);
        this._pendingTimeoutPurpose = null;
    }
}

MDetailsContext.prototype.hideCurrentDetails = function()
{
    //alert("hiding details ");
    this.observers.notify("hide");
    var detailsFetcherDiv = this._currentDetailsFetcherDiv;
    if (detailsFetcherDiv != null && !this._fakeDetailsInstalled) {
        var currentDetailsDiv = this.getDetailsDiv(detailsFetcherDiv);
        if (currentDetailsDiv != null) {
            var megaphoneImage = currentDetailsDiv.megaphoneImage;
            if (megaphoneImage != null) {
                megaphoneImage.className = "hidden";
                currentDetailsDiv.megaphoneImage = null;
            }
            currentDetailsDiv.className = "hidden";
            this._currentDetailsFetcherDiv = null;
        }
    }
}

//////////////////////////////
// Cell-Based Mouse Handling
//////////////////////////////

MDetailsContext.prototype.handleMouseOverBody = function(event)
{
    this.closeDetailsPopup();
}

function details_handleMouseOverBody(event)
{
    document.detailsContext.handleMouseOverBody(event);
}

MDetailsContext.prototype.handleMouseOutDetails = function(detailsDiv, event)
{
    Event.stop(event);
}

MDetailsContext.prototype.handleMouseOverDetails = function(detailsDiv, event)
{
    //alert("handleMouseOverDetails" + detailsDiv.detailsFetcherDiv);
    if (!this._isClickToClose) {
        this.showDetailsPopup(detailsDiv.detailsFetcherDiv, event);
    }
    Event.stop(event);
}

MDetailsContext.prototype.handleMouseOverDetailsFetcher = function(detailsFetcherDiv, event)
{
    //alert("handleMouseOverDetailsFetcher" + detailsFetcherDiv + " " + this._isClickToClose);
    if (!this._isClickToClose) {
        this.showDetailsPopup(detailsFetcherDiv, event);
    }
    Event.stop(event);
}

MDetailsContext.prototype.handleMouseOutDetailsFetcher = function(detailsFetcherDiv, event)
{
    //alert("handleMouseOutDetailsFetcher" + detailsFetcherDiv);
    this.clearPendingTimeout();
    Event.stop(event);
}

MDetailsContext.prototype.handleMegaphoneClick = function(megaphoneImg, event)
{
    //trace("handleMegaphoneClick" + detailsFetcherDiv);
    var detailsFetcherDiv = this._currentDetailsFetcherDiv;
    var links = detailsFetcherDiv.getElementsByTagName('A');
    // note: the 0th link is always the rawDetailsUrl
    var link = links[1];
    if (link != null) {
        if (link.onclick != null) {
            link.onclick();
        }
        else {
            window.location.href = link.href;
        }
    }
    Event.stop(event);
}

//////////////////////////////////////////////////////////////////////////////////////
// Below this point code executes upon parsing.  Above are all functions definitions.
//////////////////////////////////////////////////////////////////////////////////////

document.detailsContext = new MDetailsContext();