Type.registerNamespace('Pythagoras');

Pythagoras.ObjectBase = function()
{
}

Pythagoras.ObjectBase.prototype.Dispose = function()
{
    for(prop in this) {
        if(typeof(this[prop]) == "function") {
            this[prop] = Pythagoras.ObjectBase.ThrowUsingDisposed;
        } else {
            this[prop] = null;
        }                    
    }
    
    this.Dispose = function() {};
}

Pythagoras.ObjectBase.ThrowUsingDisposed = function()
{    
    alert("Using disposed object");    
}



////////// Platform dependency

Pythagoras.ID = function(strID) 
{
    return document.getElementById(strID);    
}


if(window.attachEvent) {

    Pythagoras.IE = true;


    Pythagoras.AttachEvent = function(eventName, code, target) 
    {
        if(!target) {
            target = window;
        }
        target.attachEvent("on"+eventName, code);
        
        return { tgt : target, hdlr : code, evt : eventName };
    }
    
    Pythagoras.StopBubble = function(evt)
    {
        //evt = evt || window.event;
        evt.cancelBubble = true;
    }
    
    Pythagoras.CancelEvent = function(evt)
    {
        //evt = evt || window.event;
        evt.returnValue  = false;
    }
        
    
    Pythagoras.EventSource = function(evt) 
    {
        return evt.srcElement;
    }
    
    Pythagoras.ParentNode = function(el)
    {
        return el.parentElement;
    }

    
} else {

    Pythagoras.IE = false;

    Pythagoras.AttachEvent = function(eventName, code, target) 
    {
        if(!target) {
            target = window;
        }
        target.addEventListener(eventName, code, false);
        
        return { tgt : target, evt : code, evt : eventName };
    }
    
    Pythagoras.StopBubble = function(evt)
    {
        evt.stopPropagation();
    }
    
    Pythagoras.CancelEvent = function(evt)
    {
        //evt = evt || window.event;
        evt.preventDefault();
    }

    
    Pythagoras.EventSource = function(evt) 
    {
        return evt.target;
    }
  
    Pythagoras.ParentNode = function(el)
    {
        return el.parentNode;
    }

}

if(window.detachEvent) {
    Pythagoras.DetachEvent = function(eventName, code, target) 
    {
        if(!target) {
            target = window;
        }
        target.detachEvent("on"+eventName, code);
    }
} else {
    Pythagoras.DetachEvent = function(eventName, code, target) 
    {
        if(!target) {
            target = window;
        }
        target.removeEventListener(eventName, code, false);
    }
}

Pythagoras.UnhookEvents = function(eventCollection)
{
    for(var i=0; i<eventCollection.length; i++) {
        var e = eventCollection[i];
        Pythagoras.DetachEvent(e.evt, e.hdlr, e.tgt);
    }
}

Pythagoras.DOM = function(strXml)
{
    if (!window.DOMParser) {
        var progIDs = [ 'Msxml2.DOMDocument.3.0', 'Msxml2.DOMDocument' ];
        
        for (var i = 0; i < progIDs.length; i++) {
            try {
                var xmlDOM = new ActiveXObject(progIDs[i]);
                xmlDOM.async = false;
                xmlDOM.loadXML(strXml);
                xmlDOM.setProperty('SelectionLanguage', 'XPath');
                
                return xmlDOM;
            }
            catch (ex) {
            }
        }        
        return null;
    }
    else {
        var domParser = new window.DOMParser();
        return domParser.parseFromString(strXml, 'text/xml');
    }
}

Pythagoras.DOM.GetXML = function(node)
{
    if(!window.XMLSerializer) {
        return node.xml;
    } else {
        var serializer = new XMLSerializer();
        return serializer.serializeToString(node);
    }
}

Pythagoras.DOM.GetTextContent = function(node)
{    
    
    if(node.nodeType == 3) {
        return node.nodeValue;
    } else if(node.hasChildNodes()) {
        var strTxt = ""; 
        
        for(var i=0; i<node.childNodes.length; ++i) {
            strTxt += Pythagoras.DOM.GetTextContent(node.childNodes.item(i));
        }
        
        return strTxt;
    } else {
        return "";
    }    
}

Pythagoras.SetSelectValue = function(lstSelect, value)
{
    var idx = -1;
    for(var i=0; i<lstSelect.options.length; ++i) {
        if(lstSelect.options[i].value == value) {
            idx = i;
            break;
        }
    }
    
    lstSelect.selectedIndex = idx;
}

Pythagoras.GetSelectValue = function(lstSelect)
{
    var idx = lstSelect.selectedIndex;
    return idx < 0 ? null : lstSelect.options[idx].value;
}

Pythagoras.SelectElement = function(xeParent, strNamespace, strLocalName)
{
    if(xeParent.hasChildNodes()) {
        for(var i=0; i<xeParent.childNodes.length; ++i) {
            var nd = xeParent.childNodes[i];
            if((nd.nodeType == 1) && (Pythagoras.LocalName(nd.tagName) == strLocalName) && (nd.namespaceURI == strNamespace)) {
                return nd;
            }
        }        
        return null;
    } else {
        return null;
    }
}

Pythagoras.SelectElementByAttributeValue = function(xeParent, strAttrName, strAttrValue)
{
    // try this level
    if(xeParent.getAttribute(strAttrName) == strAttrValue) {
        return xeParent;
    }
    
    // ok, go deep
    
    if(xeParent.hasChildNodes()) {
        for(var i=0; i<xeParent.childNodes.length; ++i) {
            var nd = xeParent.childNodes[i];
            if(nd.nodeType == 1) {
                var ret = Pythagoras.SelectElementByAttributeValue(nd, strAttrName, strAttrValue);
                if(ret) {
                    return ret;
                }
            }
        }        
    }
    
    return null;
}

Pythagoras.SelectElementById = function(xeParent, strId)
{
    return Pythagoras.SelectElementByAttributeValue(xeParent, "id", strId);
}

Pythagoras.ImportNode = function(xeSource, docDestination)
{       
    if(xeSource.namespaceURI == null || xeSource.namespaceURI == "") {
        
        if(xeSource.nodeType == 1) {
            // element
            var xeTgt = docDestination.createElement(xeSource.tagName);
            var atts = xeSource.attributes;
            if(atts != null) {
                for(var i=0; i<atts.length; ++i) {
                    var attr = atts.item(i);
                    if(attr.namespaceURI == null || attr.namespaceURI == "") {                       
                        var attNew = docDestination.createAttribute(attr.name);
                        attNew.value  = attr.value;                                                
                        try {
                            xeTgt.attributes.setNamedItem(attNew);
                        } catch(e) {
                            if(attr.name == "style") {
                                xeTgt.style.cssText = attr.value;
                            } else {
                                Pythagoras.Diag.WriteError("Nejde mi nastavit attribut +" + attr.name);    
                            }
                        }
                        

                    }
                }
            }
            
            return xeTgt;            
        } else if(xeSource.nodeType == 3 || xeSource.nodeType == 4) {
            var txtTxt = docDestination.createTextNode(xeSource.nodeValue);
            return txtTxt
        } else {
            return null;
        }
    
    } else {
        return null;
    }        
}


Pythagoras.ImportNodeDeep = function(xeSource, docDestination)
{
    var cloneElement = Pythagoras.ImportNode(xeSource, docDestination);
    
        if(cloneElement) {
        for(var i=0; i<xeSource.childNodes.length; ++i) {
            var sub = xeSource.childNodes.item(i);
            var cloneSub = Pythagoras.ImportNodeDeep(sub, docDestination);
            if(cloneSub) {
                cloneElement.appendChild(cloneSub);
            }
        }
    
    }
    
    return cloneElement;
}


Pythagoras.ClearChildren = function(node)
{
    while(node.hasChildNodes()) {
        node.removeChild(node.firstChild);
    }
}

Pythagoras.InsertFirst = function(node, child)
{
    if(node.hasChildNodes()) {
        node.insertBefore(child, node.firstChild);
    } else {
        node.appendChild(node);
    }
}


Pythagoras.LocalName = function(strQName)
{
    var m = /^([\w]+:)?([\w\.]+)$/.exec(strQName);
    return m.length ==3 ? m[2] : strQName;
}

////////

Pythagoras.Point = function(x, y)
{
    this.x = x;
    this.y = y;
}

Pythagoras.Point.prototype.toString = function()
{
    return "(" + this.x.toString() +";" + this.y.toString() + ")";
}

Pythagoras.Point.prototype.distance = function(pt1)
{
    var dx = this.x - pt1.x;
    var dy = this.y - pt1.y;
    
    return Math.sqrt(dx*dx + dy*dy);
}

///////

Pythagoras.DOMTree = new Object();

Pythagoras.DOMTree.CalcDocumentPosition = function(el)
{    
    var pos = new Pythagoras.Point(0, 0);
    var currentEl = el;
    var offsetParent = el;
     
    
    while(currentEl) {        
                    
        if((currentEl == offsetParent)) {
            pos.x += currentEl.offsetLeft;
            pos.y += currentEl.offsetTop;
            offsetParent = currentEl.offsetParent;
        }
        
        
        if(currentEl != el && currentEl.offsetParent) {
            pos.x -= currentEl.scrollLeft;
            pos.y -= currentEl.scrollTop;
        }
                
        currentEl = Pythagoras.ParentNode(currentEl);        
        
    }

    //pos.x += document.documentElement.scrollLeft;
    //pos.y += document.documentElement.scrollTop;
            
    return pos;
}

Pythagoras.DOMTree.CalcParentOffset = function(el)
{
    var directParent = Pythagoras.ParentNode(el);
    var offsetParent = el.offsetParent;
    var pt = new Pythagoras.Point(0,0);
    
    if(directParent == offsetParent) {
        pt.x = el.offsetLeft;
        pt.y = el.offsetTop;
    } else {
        pt.x = el.offsetLeft - directParent.offsetLeft;
        pt.y = el.offsetTop - directParent.offsetTop;
    }
        
    return pt;
}

Pythagoras.DOMTree.IsDescendant = function(elObject, elRoot)
{
    var el = elObject;
    while(el) {
        if(el == elRoot) {
            return true;
        }
        el = Pythagoras.ParentNode(el);
    }
    
    return false;
}

Pythagoras.DOMTree.MouseFrom = 
    Pythagoras.IE ?
    function(ev) {
        return ev.fromElement;
    } 
    :    
    function(ev) {
        return ev.relatedTarget;
    };
    
Pythagoras.DOMTree.MouseTo = 
    Pythagoras.IE ?
    function(ev) {
        return ev.toElement;
    } 
    :    
    function(ev) {
        return ev.relatedTarget;
    };
    
Pythagoras.DOMTree.FindDescWithProp = function(src, propName)
{
    while(src) {
        if(src[propName]) {
            return src;
        }
        src = Pythagoras.ParentNode(src);
    }
}



//////// Diagnostics

Pythagoras.Diag = {

    divDiag : null,
    
    GetFrame : function()
    {
        if(this.divDiag == null) {
            this.divDiag = document.createElement("div");
            this.divDiag.className = "pg_diagframe";
            document.body.appendChild(this.divDiag);
        }
        
        return this.divDiag;
    },
    
    WriteLine : function(strMessage) 
    {
        this.AppendTexLine(strMessage, "info");
    },
    
    WriteError : function(strMessage) 
    {
        this.AppendTexLine(strMessage, "error");
    },
    
    AppendTexLine : function(strMessage, style)
    {
        var divFrame = this.GetFrame();
        if((strMessage == null) || (strMessage == "")) {
            strMessage = "-";
        }
        var txtEl = document.createTextNode(strMessage);
        var divLine = document.createElement("div");
        
        divLine.appendChild(txtEl);
        
        var firstNode = divFrame.firstChild;
        if(firstNode == null) {
            divFrame.appendChild(divLine);        
        } else {
            divFrame.insertBefore(divLine, firstNode);        
        }
                
    }
    
};




////////// Misc

Pythagoras.StandardResources = new Object();


//if(typeof(Sys)!=='undefined')Sys.Application.notifyScriptLoaded();
if(typeof(Sys)!=='undefined')Sys.Application.notifyScriptLoaded();