Type.registerNamespace('Ftn.Client');



////////////////////////////////////////////////////////////////////////////////
// MD5

/* md5.js - MD5 Message-Digest
* Copyright (C) 1999,2002 Masanao Izumo <mo@goice.co.jp>
* Version: 2.0.0
* LastModified: May 13 2002
*
* This program is free software.  You can redistribute it and/or modify
* it without any warranty.  This library calculates the MD5 based on RFC1321.
* See RFC1321 for more information and algorism.
*/

/* Interface:
* md5_128bits = MD5_hash(data);
* md5_hexstr = MD5_hexhash(data);
*/

/* ChangeLog
* 2002/05/13: Version 2.0.0 released
* NOTICE: API is changed.
* 2002/04/15: Bug fix about MD5 length.
*/


//	md5_T[i] = parseInt(Math.abs(Math.sin(i)) * 4294967296.0);
var MD5_T = new Array(0x00000000, 0xd76aa478, 0xe8c7b756, 0x242070db,
			  0xc1bdceee, 0xf57c0faf, 0x4787c62a, 0xa8304613,
			  0xfd469501, 0x698098d8, 0x8b44f7af, 0xffff5bb1,
			  0x895cd7be, 0x6b901122, 0xfd987193, 0xa679438e,
			  0x49b40821, 0xf61e2562, 0xc040b340, 0x265e5a51,
			  0xe9b6c7aa, 0xd62f105d, 0x02441453, 0xd8a1e681,
			  0xe7d3fbc8, 0x21e1cde6, 0xc33707d6, 0xf4d50d87,
			  0x455a14ed, 0xa9e3e905, 0xfcefa3f8, 0x676f02d9,
			  0x8d2a4c8a, 0xfffa3942, 0x8771f681, 0x6d9d6122,
			  0xfde5380c, 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60,
			  0xbebfbc70, 0x289b7ec6, 0xeaa127fa, 0xd4ef3085,
			  0x04881d05, 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8,
			  0xc4ac5665, 0xf4292244, 0x432aff97, 0xab9423a7,
			  0xfc93a039, 0x655b59c3, 0x8f0ccc92, 0xffeff47d,
			  0x85845dd1, 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314,
			  0x4e0811a1, 0xf7537e82, 0xbd3af235, 0x2ad7d2bb,
			  0xeb86d391);

var MD5_round1 = new Array(new Array(0, 7, 1), new Array(1, 12, 2),
			   new Array(2, 17, 3), new Array(3, 22, 4),
			   new Array(4, 7, 5), new Array(5, 12, 6),
			   new Array(6, 17, 7), new Array(7, 22, 8),
			   new Array(8, 7, 9), new Array(9, 12, 10),
			   new Array(10, 17, 11), new Array(11, 22, 12),
			   new Array(12, 7, 13), new Array(13, 12, 14),
			   new Array(14, 17, 15), new Array(15, 22, 16));

var MD5_round2 = new Array(new Array(1, 5, 17), new Array(6, 9, 18),
			   new Array(11, 14, 19), new Array(0, 20, 20),
			   new Array(5, 5, 21), new Array(10, 9, 22),
			   new Array(15, 14, 23), new Array(4, 20, 24),
			   new Array(9, 5, 25), new Array(14, 9, 26),
			   new Array(3, 14, 27), new Array(8, 20, 28),
			   new Array(13, 5, 29), new Array(2, 9, 30),
			   new Array(7, 14, 31), new Array(12, 20, 32));

var MD5_round3 = new Array(new Array(5, 4, 33), new Array(8, 11, 34),
			   new Array(11, 16, 35), new Array(14, 23, 36),
			   new Array(1, 4, 37), new Array(4, 11, 38),
			   new Array(7, 16, 39), new Array(10, 23, 40),
			   new Array(13, 4, 41), new Array(0, 11, 42),
			   new Array(3, 16, 43), new Array(6, 23, 44),
			   new Array(9, 4, 45), new Array(12, 11, 46),
			   new Array(15, 16, 47), new Array(2, 23, 48));

var MD5_round4 = new Array(new Array(0, 6, 49), new Array(7, 10, 50),
			   new Array(14, 15, 51), new Array(5, 21, 52),
			   new Array(12, 6, 53), new Array(3, 10, 54),
			   new Array(10, 15, 55), new Array(1, 21, 56),
			   new Array(8, 6, 57), new Array(15, 10, 58),
			   new Array(6, 15, 59), new Array(13, 21, 60),
			   new Array(4, 6, 61), new Array(11, 10, 62),
			   new Array(2, 15, 63), new Array(9, 21, 64));

function MD5_F(x, y, z) { return (x & y) | (~x & z); }
function MD5_G(x, y, z) { return (x & z) | (y & ~z); }
function MD5_H(x, y, z) { return x ^ y ^ z; }
function MD5_I(x, y, z) { return y ^ (x | ~z); }

var MD5_round = new Array(new Array(MD5_F, MD5_round1),
			  new Array(MD5_G, MD5_round2),
			  new Array(MD5_H, MD5_round3),
			  new Array(MD5_I, MD5_round4));

function MD5_pack(n32) {
    return String.fromCharCode(n32 & 0xff) +
	 String.fromCharCode((n32 >>> 8) & 0xff) +
	 String.fromCharCode((n32 >>> 16) & 0xff) +
	 String.fromCharCode((n32 >>> 24) & 0xff);
}

function MD5_unpack(s4) {
    return s4.charCodeAt(0) |
	 (s4.charCodeAt(1) << 8) |
	 (s4.charCodeAt(2) << 16) |
	 (s4.charCodeAt(3) << 24);
}

function MD5_number(n) {
    while (n < 0)
        n += 4294967296;
    while (n > 4294967295)
        n -= 4294967296;
    return n;
}

function MD5_apply_round(x, s, f, abcd, r) {
    var a, b, c, d;
    var kk, ss, ii;
    var t, u;

    a = abcd[0];
    b = abcd[1];
    c = abcd[2];
    d = abcd[3];
    kk = r[0];
    ss = r[1];
    ii = r[2];

    u = f(s[b], s[c], s[d]);
    t = s[a] + u + x[kk] + MD5_T[ii];
    t = MD5_number(t);
    t = ((t << ss) | (t >>> (32 - ss)));
    t += s[b];
    s[a] = MD5_number(t);
}

function MD5_hash(data) {
    var abcd, x, state, s;
    var len, index, padLen, f, r;
    var i, j, k;
    var tmp;

    state = new Array(0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476);
    len = data.length;
    index = len & 0x3f;
    padLen = (index < 56) ? (56 - index) : (120 - index);
    if (padLen > 0) {
        data += "\x80";
        for (i = 0; i < padLen - 1; i++)
            data += "\x00";
    }
    data += MD5_pack(len * 8);
    data += MD5_pack(0);
    len += padLen + 8;
    abcd = new Array(0, 1, 2, 3);
    x = new Array(16);
    s = new Array(4);

    for (k = 0; k < len; k += 64) {
        for (i = 0, j = k; i < 16; i++, j += 4) {
            x[i] = data.charCodeAt(j) |
		(data.charCodeAt(j + 1) << 8) |
		(data.charCodeAt(j + 2) << 16) |
		(data.charCodeAt(j + 3) << 24);
        }
        for (i = 0; i < 4; i++)
            s[i] = state[i];
        for (i = 0; i < 4; i++) {
            f = MD5_round[i][0];
            r = MD5_round[i][1];
            for (j = 0; j < 16; j++) {
                MD5_apply_round(x, s, f, abcd, r[j]);
                tmp = abcd[0];
                abcd[0] = abcd[3];
                abcd[3] = abcd[2];
                abcd[2] = abcd[1];
                abcd[1] = tmp;
            }
        }

        for (i = 0; i < 4; i++) {
            state[i] += s[i];
            state[i] = MD5_number(state[i]);
        }
    }

    return MD5_pack(state[0]) +
	 MD5_pack(state[1]) +
	 MD5_pack(state[2]) +
	 MD5_pack(state[3]);
}

function MD5_hexhash(data) {
    var i, out, c;
    var bit128;

    bit128 = MD5_hash(data);
    out = "";
    for (i = 0; i < 16; i++) {
        c = bit128.charCodeAt(i);
        out += "0123456789abcdef".charAt((c >> 4) & 0xf);
        out += "0123456789abcdef".charAt(c & 0xf);
    }
    return out;
}
////////////////////////////////////////////////////////////////////////////////
// Ftn.Client.Global


Ftn.Client.Global = {
    get_baseUrl: function() {
        return this._baseUrl;
    },

    get_currentTheme: function() {
        return this._currentTheme;
    },

    set_baseUrl: function(baseUrl, currentTheme) {
        this._baseUrl = baseUrl;
        this._currentTheme = currentTheme;
    },

    resolveUrl: function(relativeUrl) {
        if (relativeUrl.charAt(0) == '~') return relativeUrl.replace('~', Ftn.Client.Global.get_baseUrl());
        return relativeUrl;
    },

    resolveThemeUrl: function(relativeUrl) {
        if (relativeUrl.charAt(0) == '~') {
            var base = Ftn.Client.Global.get_baseUrl() + '/Main/' + Ftn.Client.Global.get_currentTheme();
            return relativeUrl.replace('~', base);
        }
        return relativeUrl;
    },

    registerDefaultButton: function(button) {
        var button = typeof (button) === 'string' ? $get(button) : button;
        button.click = function() {
            var result = true;
            if (button.onclick) result = button.onclick();
            if (typeof (result) == 'undefined' || result) {
                var func = button.href.replace('javascript:', '').replace(/%20/g, ' ');
                eval(decodeURI(func));
            }

        }
    },

    disableOnPostBack: function(button, callback) {
        var button = typeof (button) === 'string' ? $get(button) : button;
        if (button.disabled) return false;

        var oldStyle = button.className;
        button.className = button.className + ' ' + button.className + '-disabled';
        button.disabled = true;

        var result = callback.apply(button);
        if (typeof (result) == 'undefined' || result) {
            var func = button.href.replace('javascript:', '').replace(/%20/g, ' ');
            eval(decodeURI(func));
            if (typeof (Page_IsValid) != 'undefined' && !Page_IsValid) {
                button.className = oldStyle;
                button.disabled = false;
            }
        } else {
            button.className = oldStyle;
            button.disabled = false;
        }
        return false;
    },

    enableAfterPostBack: function(button) {
        var button = typeof (button) === 'string' ? $get(button) : button;
        if (!button.disabled) return false;

        var diasabledStyle = button.className;
        var indexOf = diasabledStyle.indexOf(' ');
        button.className = diasabledStyle.substring(0, indexOf);
        button.disabled = false;

        return false;
    }
}

var $url = Ftn.Client.Global.resolveUrl;
var $themeUrl = Ftn.Client.Global.resolveThemeUrl;
var $registerDefaultButton = Ftn.Client.Global.registerDefaultButton;
var $disableOnPostBack = Ftn.Client.Global.disableOnPostBack;
var $enableAfterPostBack = Ftn.Client.Global.enableAfterPostBack;


////////////////////////////////////////////////////////////////////////////////////////////


// Class ctor

Ftn.Client.MarkupBuilder = function Ftn$Client$MarkupBuilder(header, footer) {
    Ftn.Client.MarkupBuilder.initializeBase(this);

    // Initializes the private members
    this._header = header;
    this._footer = footer;
    this._itemTemplate = "";
    this._emptyTemplate = "";
}

// PROPERTY:: header (String)
function Ftn$Client$MarkupBuilder$get_header() {
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._header;
}
function Ftn$Client$MarkupBuilder$set_header(value) {
    var e = Function._validateParams(arguments, [{ name: 'value',
        type: String}]);
        if (e) throw e;

        this._header = value;
    }

    // PROPERTY:: footer (String)
    function Ftn$Client$MarkupBuilder$get_footer() {
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._footer;
    }
    function Ftn$Client$MarkupBuilder$set_footer(value) {
        var e = Function._validateParams(arguments, [{ name: 'value',
            type: String}]);
            if (e) throw e;

            this._footer = value;
        }

        // PROPERTY:: itemTemplate (String)
        function Ftn$Client$MarkupBuilder$get_itemTemplate() {
            if (arguments.length !== 0) throw Error.parameterCount();
            return this._itemTemplate;
        }
        function Ftn$Client$MarkupBuilder$set_itemTemplate(value) {
            var e = Function._validateParams(arguments, [{ name: 'value',
                type: String}]);
                if (e) throw e;

                this._itemTemplate = value;
            }

            // METHOD:: bind()
            function Ftn$Client$MarkupBuilder$bind(data,previousResponse) {
                var temp = this._generate(data, previousResponse);
                return temp;
            }
            // METHOD:: loadHeader()
            function Ftn$Client$MarkupBuilder$loadHeader(domElement) {
                var temp = domElement.innerHTML;
                this._header = temp;
            }

            // METHOD:: loadFooter()
            function Ftn$Client$MarkupBuilder$loadFooter(domElement) {
                var temp = domElement.innerHTML;
                this._footer = temp;
            }

            // METHOD:: loadItemTemplate()
            function Ftn$Client$MarkupBuilder$loadItemTemplate(domElement,emptyTemplate) {
                var temp = domElement.innerHTML;
                this._itemTemplate = temp;
                if(emptyTemplate){
                    var temp = emptyTemplate.innerHTML;
                    this._emptyTemplate = temp;
                }
            }

            ///////                     ///////
            ///////  PRIVATE members    ///////
            ///////                     ///////

            function Ftn$Client$MarkupBuilder$_generate(data, previousResponse) {
                var _builder = new Sys.StringBuilder(this._header);
                if (data.length) {
                    for (i = 0; i < data.length; i++) {
                        if (previousResponse)
                            this._createItem(_builder, data[i], previousResponse[i]);
                        else
                                this._createItem(_builder, data[i], null);
                      
                    }
                } 
                else if(data!=null && data.length!=0)
                    this._createItem(_builder, data, previousResponse);
                else{ 
                if(this._emptyTemplate)
                    _builder.append(this._emptyTemplate);
                else
                    _builder.append('<div class="empty">No Data</div>');
                }
                _builder.append(this._footer);
                return _builder.toString();
            }
            function Ftn$Client$MarkupBuilder$_createItem(_builder, dataItem, previousResponseItem) {
                var template = this._itemTemplate;
                var pattern = /#\w+/g;  // Finds all #word occurrences
                var matches = template.match(pattern);
                var equialsValues;
                if (previousResponseItem)
                    equialsValues = previousResponseItem["$$equals$Value$Container$"];
                if (equialsValues == null)
                    equialsValues = new Object();
                for (var j = 0; j < matches.length; j++) {

                    var name = matches[j];
                    name = name.slice(1);
                    if (equialsValues[name] == null)
                        equialsValues[name] = true;
                    var value = dataItem[name];
                    var previosValue;
                    if (previousResponseItem) {
                        previosValue = previousResponseItem[name];
                    }

                    var handlers = this.get_events().updated;
                    if (handlers) {
                        for (var i = handlers.length - 1; i >= 0; i--) {
                            var tmpValue = handlers[i].handler(dataItem[name], matches[j], previosValue, equialsValues[name]);
                            if (tmpValue) {
                                value = tmpValue;
                                break;
                            }
                        }
                    }
                    if (previosValue != null && previosValue != dataItem[name])
                        equialsValues[name] = false;
                    else
                        equialsValues[name] = true;
                    //  template = template.replace(matches[j],  dataItem[name]);
                    template = template.replace(matches[j], value);
                    
                    value = null;

                }
                dataItem["$$equals$Value$Container$"] = equialsValues;
                _builder.append(template);
            }
            function Ftn$Client$MarkupBuilder$add_updated(handler) {
                this.get_events().addHandler('updated', handler);
            }
            function Ftn$Client$MarkupBuilder$remove_updated(handler) {
                this.get_events().updated = null;
                
               /*  if (this._events) {
                     var handler = this._events.getHandler("updated");
                    if (handler) {
                        handler(this, Sys.EventArgs.Empty);
                    }
                 } */
            }
            // PROTOTYPE
            Ftn.Client.MarkupBuilder.prototype =
{
    get_header: Ftn$Client$MarkupBuilder$get_header,
    set_header: Ftn$Client$MarkupBuilder$set_header,
    get_footer: Ftn$Client$MarkupBuilder$get_footer,
    set_footer: Ftn$Client$MarkupBuilder$set_footer,
    get_itemTemplate: Ftn$Client$MarkupBuilder$get_itemTemplate,
    set_itemTemplate: Ftn$Client$MarkupBuilder$set_itemTemplate,
    bind: Ftn$Client$MarkupBuilder$bind,
    _generate: Ftn$Client$MarkupBuilder$_generate,
    _createItem: Ftn$Client$MarkupBuilder$_createItem,
    loadHeader: Ftn$Client$MarkupBuilder$loadHeader,
    loadFooter: Ftn$Client$MarkupBuilder$loadFooter,
    loadItemTemplate: Ftn$Client$MarkupBuilder$loadItemTemplate,
    // Bind and unbind to select event.
    add_updated: Ftn$Client$MarkupBuilder$add_updated,
    remove_updated: Ftn$Client$MarkupBuilder$remove_updated,
    dispose: function() {
        this.remove_updated();
      //  Ftn.Client.MarkupBuilder.callBaseMethod(this, 'dispose');
    }
}

Ftn.Client.MarkupBuilder.registerClass('Ftn.Client.MarkupBuilder', Sys.Component);
globalMarkupBuilder = new Ftn.Client.MarkupBuilder();
////////////////////////////////////////////////////////////////////////////////////////////

function DragObject(dropPanel, element) {
    element.dragObjects = this

    element.dropContainer = dropPanel
    element.containerIdndex
    for (i = 0; i < DragAndDropColumns.length; i++) {
        if (element.dropContainer.parentNode == DragAndDropColumns[i]) {
            element.containerIdndex = i;
            break;
        }
    }
    element.delta = 5
    
    dragMaster.makeDraggable(element)
    var rememberPosition
    var mouseOffset
    this.onDragStart = function(offset, zindex) {
        var s = element.dropContainer.style
        rememberPosition = { top: s.top, left: s.left, position: s.position,
            width: s.width, height: s.height,
            containerOverflow: DragAndDropContainer.style.overflow,
            parentOverflow: element.dropContainer.parentNode.style.overflow
        }
        s.zIndex = zindex
        mouseOffset = offset

        s.width = element.dropContainer.offsetWidth + 'px'
        s.height = element.dropContainer.offsetHeight + 'px'
        s.position = 'absolute'
        element.dropContainer.parentNode.style.overflow = 'visible'
        DragAndDropContainer.style.overflow = 'visible'
    }
    this.hide = function() {
        element.dropContainer.style.display = 'none'
    }
    this.show = function() {
        element.dropContainer.style.display = ''
    }
    this.onDragMove = function(x, y) {
        var parentOffset = getOffset(element.dropContainer.offsetParent)

        element.dropContainer.style.top = y - mouseOffset.y - parentOffset.top + 'px'
        element.dropContainer.style.left = x - mouseOffset.x - parentOffset.left + 'px'
    }
    this.onDragSuccess = function() {
        var s = element.dropContainer.style
        var left = parseInt(s.left.replace('px', ''))
        var width = parseInt(s.width.replace('px', ''))

        /*if ((left >= -2 * element.delta - width / 2 && left <= 2 * element.delta + width / 2)
        || (left <  -2 * element.delta - width / 2 && element.containerIdndex == 0)
        || (left >   2 * element.delta + width / 2 && element.containerIdndex == 2))
        this.AppendToColumn(element.dropContainer, element.containerIdndex)
        else if (left >= -(width*(3/2) + 2 * element.delta) && left < -2 * element.delta-width/2)
        this.AppendToColumn(element.dropContainer, element.containerIdndex - 1)
        else if (left < -(width*(3/2) + 2 * element.delta))
        this.AppendToColumn(element.dropContainer, 0)
        else if (left > 2 * element.delta + width / 2 && left <= 2 * element.delta + width * (3 / 2))
        this.AppendToColumn(element.dropContainer, element.containerIdndex + 1)
        else
        this.AppendToColumn(element.dropContainer, 2) */
        this.AppendToColumn(element.dropContainer, this.ResolveContainer(width, left + element.containerIdndex*DragAndDropColumns[element.containerIdndex].offsetWidth));
        var s = element.dropContainer.style
        s.position = rememberPosition.position
        s.width = rememberPosition.width
        s.height = rememberPosition.height
        element.dropContainer.parentNode.style.overflow = rememberPosition.parentOverflow
        DragAndDropContainer.style.overflow = rememberPosition.containerOverflow

    }
    this.ResolveContainer = function(width, left) {
        if (0 > left + element.delta) {
            return 0;
        }
        for (var i = 0; i < DragAndDropColumns.length; i++) {
            if (i * DragAndDropColumns[i].offsetWidth < left + element.delta && (i + 1) * DragAndDropColumns[i].offsetWidth > left + element.delta)
                return i;
        }
        return DragAndDropColumns.length - 1;
    }
    this.getElementsByNameIE=function (tag, name) {
     
     var elem = document.getElementsByTagName(tag);
     var arr = new Array();
     for(i = 0,iarr = 0; i < elem.length; i++) {
          att = elem[i].getAttribute("name");
          if(att == name) {
               arr[iarr] = elem[i];
               iarr++;
          }
     }
     return arr;
}
    this.AppendToColumn = function(node, ind) {
        var child = DragAndDropColumns[ind].childNodes;
        var top = parseInt(node.style.top.replace('px', ''));
        var inserted = false;      
         
        var matches = document.cookie.match(new RegExp("\\w*:"+DragAndDropColumns[ind].id+"\\$+\\d",'g'));
        if(matches){
            var indexes= new Array();
            matches.sort(sortcookies);
            for (var j = 0; j < matches.length; j++) {
                var indStr=matches[j].match("\\$\\d")[0];
                indexes.push(parseInt(indStr.substring(1)));
                if(inserted == false){
                    var dragObject = this.getElementsByNameIE('div', matches[j].substring(0,matches[j].indexOf(':')))[0];            
                    if (dragObject && node!=dragObject && dragObject.offsetTop){
                        var topChild = dragObject.offsetTop
                        if (topChild > top) {
                            this.ChangeCookie(node.attributes["name"].nodeValue, DragAndDropColumns[ind].id, indexes[indexes.length-1], true);
                            DragAndDropColumns[ind].insertBefore(node, dragObject)
                            inserted = true
                        }
                    }
                 }
             }
         }
         if (inserted == false){
            var row=0;
            if(indexes)
                row=indexes[indexes.length-1];
            this.ChangeCookie(node.attributes["name"].nodeValue, DragAndDropColumns[ind].id, row+1);
            DragAndDropColumns[ind].appendChild(node, false)            
         }
         element.containerIdndex = ind
      //  document.cookie=element.dropContainer.attributes["name"].nodeValue+ "=" +DragAndDropColumns[ind].id+"X"+2;
    }
    this.ChangeCookie = function(name, container, value, withMooveDown) {
        var panelsLocation = this.getCookie('PanelsLocation');
        var allMatch = panelsLocation.match(name + ":\\w*\\$+\\d");
        if (allMatch!=null &&allMatch.length > 0)
            var currentnodeCookie = panelsLocation.match(name + ":\\w*\\$+\\d")[0];
        var newCookValue = container + '$' + value;
        if (withMooveDown == true) {

            var lowerElementsCookies = panelsLocation.match(new RegExp('\\w*:' + container + '\\$\\d', 'g'));
            for (var i = 0; i < lowerElementsCookies.length; i++) {
                var ind = parseInt(lowerElementsCookies[i].substring(lowerElementsCookies[i].lastIndexOf('$') + 1));
                var nodeName = lowerElementsCookies[i].substring(0, lowerElementsCookies[i].indexOf(':'));
                if (ind >= value)
                    document.cookie = 'PanelsLocation=' + this.getCookie('PanelsLocation').replace(lowerElementsCookies[i], nodeName + ':' + container + '$' + (ind + 1)) + ";path=/";
            }
        }
        if (currentnodeCookie)
            document.cookie = 'PanelsLocation=' + this.getCookie('PanelsLocation').replace(currentnodeCookie, name + ':' + newCookValue) + ";path=/";
        else
            document.cookie = 'PanelsLocation=' + this.getCookie('PanelsLocation')+ name + ':' + newCookValue + ";path=/";
    }
    this.getCookie= function(name) {
	    var cookie = " " + document.cookie;
	    var search = " " + name + "=";
	    var setStr = null;
	    var offset = 0;
	    var end = 0;
	    if (cookie.length > 0) {
		    offset = cookie.indexOf(search);
		    if (offset != -1) {
			    offset += search.length;
			    end = cookie.indexOf(";", offset)
			    if (end == -1) {
				    end = cookie.length;
			    }
			    setStr = unescape(cookie.substring(offset, end));
		    }
	    }
	    return(setStr);
    }
    this.onDragFail = function() {
        var s = element.dropContainer.style
        s.top = rememberPosition.top
        s.left = rememberPosition.left
        s.position = rememberPosition.position
        s.widht = rememberPosition.width
        s.height = rememberPosition.height
        element.dropContainer.parentNode.style.overflow = rememberPosition.parentOverflow
        DragAndDropContainer.style.overflow = rememberPosition.containerOverflow
    }
    this.toString = function() {
        return element.id
    }
}
function sortcookies(a, b){
    var indexA=parseInt(a.substring(a.lastIndexOf('\\$')+1));
    var indexB=parseInt(b.substring(b.lastIndexOf('\\$')+1));
    return (indexA- indexB);
}
/*---------------------------------Drag Manager---------------------------------------------------------------------------*/
var dragMaster = (function() {
    var dragObject
    var mouseDownAt
    var zindex = 1
    function mouseDown(e) {
        e = fixEvent(e)
        if (e.which != 1) return false
        mouseDownAt = { x: e.pageX, y: e.pageY, element: this }
        addDocumentEventHandlers()
        return false
    }
    function mouseMove(e) {
        if (typeof (event)!="undefined" && window.navigator.appName == "Microsoft Internet Explorer") {
            if (event.button != 1) {
                mouseUp();
                return false;
            } 
        }
        e = fixEvent(e)
        // (1)
        if (mouseDownAt) {
            if (Math.abs(mouseDownAt.x - e.pageX) < 10 && Math.abs(mouseDownAt.y - e.pageY) < 10) {
                return false
            }
            // Начать перенос
            var elem = mouseDownAt.element
            // текущий объект для переноса
            dragObject = elem.dragObjects
            // запомнить, с каких относительных координат начался перенос
            var mouseOffset = getMouseOffset(elem.dropContainer, mouseDownAt.x, mouseDownAt.y)
            mouseDownAt = null // запомненное значение больше не нужно, сдвиг уже вычислен
            dragObject.onDragStart(mouseOffset, zindex++) // начали
        }
        // (2)
        dragObject.onDragMove(e.pageX, e.pageY)
        // (5)
        return false
    }
    function mouseUp() {
        if (!dragObject) { // (1)
            mouseDownAt = null
        } else {
            dragObject.onDragSuccess()
            dragObject = null
        }
        // (3)
        removeDocumentEventHandlers()
        return false;
    }
    function getMouseOffset(target, x, y) {
        var docPos = getOffset(target)
        return { x: x - docPos.left, y: y - docPos.top }
    }
    function addDocumentEventHandlers() {
        document.onmousemove = mouseMove
        document.onmouseup = mouseUp
        document.ondragstart = document.body.onselectstart = function() { return false }
    }
    function removeDocumentEventHandlers() {
        document.onmousemove = document.onmouseup = document.ondragstart = document.body.onselectstart = null
    }
    return {
        makeDraggable: function(element) {
        element.onmousedown = mouseDown
        }
    }
} ())
function fixEvent(e) {
    // получить объект событие для IE
    e = e || window.event
    // добавить pageX/pageY для IE
    if (e.pageX == null && e.clientX != null) {
        var html = document.documentElement
        var body = document.body
        e.pageX = e.clientX + (html && html.scrollLeft || body && body.scrollLeft || 0) - (html.clientLeft || 0)
        e.pageY = e.clientY + (html && html.scrollTop || body && body.scrollTop || 0) - (html.clientTop || 0)
    }
    // добавить which для IE
    if (!e.which && e.button) {
        e.which = e.button & 1 ? 1 : (e.button & 2 ? 3 : (e.button & 4 ? 2 : 0))
    }
    return e
}
function getOffset(elem) {
    if (elem.getBoundingClientRect) {
        return getOffsetRect(elem)
    } else {
        return getOffsetSum(elem)
    }
}
function getOffsetRect(elem) {
    var box = elem.getBoundingClientRect()
    var body = document.body
    var docElem = document.documentElement
    var scrollTop = window.pageYOffset || docElem.scrollTop || body.scrollTop
    var scrollLeft = window.pageXOffset || docElem.scrollLeft || body.scrollLeft
    var clientTop = docElem.clientTop || body.clientTop || 0
    var clientLeft = docElem.clientLeft || body.clientLeft || 0
    var top = box.top + scrollTop - clientTop
    var left = box.left + scrollLeft - clientLeft
    return { top: Math.round(top), left: Math.round(left) }
}
function getOffsetSum(elem) {
    var top = 0, left = 0
    while (elem) {
        top = top + parseInt(elem.offsetTop)
        left = left + parseInt(elem.offsetLeft)
        elem = elem.offsetParent
    }
    return { top: top, left: left }
};
////////////////////////////////////////////////////////////////////////////////////////////

Ftn.Client.Collapse = function(element) {
    Ftn.Client.Collapse.initializeBase(this, [element]);
    this.CollapseButtonId = null;
    this.CollapseCss = null;
    this.ExpandCss = null;
    this.CollapseButton = null;
    this.LazyPanelsClientId = null;
    this.RefreshButtonId = null;
    this.RefreshCss = null;
    this.ReloadCss = null;
    this.Panels = new Array();
}
Ftn.Client.Collapse.prototype =
{
    initialize: function() {
        Ftn.Client.Collapse.callBaseMethod(this, 'initialize');
        this.CollapseButton = $get(this.CollapseButtonId);
        this._onSendHandler = Function.createDelegate(this, this.send);
        $addHandler(this.CollapseButton, 'click', this._onSendHandler);
        this._onRefreshHandler = Function.createDelegate(this, this.refresh);
        if (this.RefreshButtonId) {
            var refreshButton = $get(this.RefreshButtonId);
            if (refreshButton) {
                $addHandler(refreshButton, 'click', this._onRefreshHandler);
            }
        }
        if (this.LazyPanelsClientId) {
            this.Panels = Sys.Serialization.JavaScriptSerializer.deserialize(this.LazyPanelsClientId, false);
            for (var i = this.Panels.length - 1; i >= 0; i--) {
                var lazyPanel = $find(this.Panels[i]);
                if (lazyPanel) {
                    this._onUpdatingHandler = Function.createDelegate(this, this.updaiting);
                    this._onUpdatedHandler = Function.createDelegate(this, this.updaited);
                    $addHandler(lazyPanel, 'updating', this._onUpdatingHandler);
                    $addHandler(lazyPanel, 'updated', this._onUpdatedHandler);
                }
            }
        }
    },
    updaiting: function() {

        if (this.get_element().style.display == 'none')
            return false;
        else {
            $get(this.RefreshButtonId).className = this.ReloadCss;
            return true;
        }
    },
    updaited: function() {
        $get(this.RefreshButtonId).className = this.RefreshCss;
    },
    dispose: function() {
        $removeHandler($get(this.CollapseButtonId), 'click', this._onSendHandler);
        if (this.RefreshButtonId) {
            var refreshButton = $get(this.RefreshButtonId);
            if (refreshButton) {
                $removeHandler(refreshButton, 'click', this._onRefreshHandler);
            }
        }

        for (var i = this.Panels.length - 1; i >= 0; i--) {
            var lazyPanel = $find(this.Panels[i]);
            if (lazyPanel) {
                this._onUpdatingHandler = Function.createDelegate(this, this.updaiting);
                this._onUpdatedHandler = Function.createDelegate(this, this.updaited);
                $removeHandler(lazyPanel, 'updating', this._onUpdatingHandler);
                $removeHandler(lazyPanel, 'updated', this._onUpdatedHandler);
            }
        }
        this.Panels = new Array();
        this.LazyPanelsClientId = null;
        this.CollapseButtonId = null;
        this.CollapseCss = null;
        this.ExpandCss = null;
        this.CollapseButton = null;
        this.RefreshButtonId = null;
        this.RefreshCss = null;
        this.ReloadCss = null;

        Ftn.Client.Collapse.callBaseMethod(this, 'dispose');
    },
    send: function(e) {
        if (this.CollapseButton.className == this.CollapseCss) {
            this.CollapseButton.className = this.ExpandCss;
            this.get_element().style.display = 'none';
        } else {
            this.CollapseButton.className = this.CollapseCss;
            this.get_element().style.display = 'block';
        }
    },
    refresh: function(e) {
        for (var i = this.Panels.length - 1; i >= 0; i--) {
            var lazyPanel = $find(this.Panels[i]);
            if (lazyPanel) {
                lazyPanel.update();
            }
        }
    }
}
Ftn.Client.Collapse.registerClass('Ftn.Client.Collapse', Sys.UI.Control);
/////////////////////////////////////////////////////////////////////////////////////


Ftn.Client.LayzyLoad = function(element) {
    Ftn.Client.LayzyLoad.initializeBase(this, [element]);
    this.ServiceMethod = null;
    this.ServiceUrl = null;
    this.Context = null;
    this.TimeOut = null;
    this.Template = null;
    this.LoadingContainerID = null;
    this.EmptyContainerID = null;
    this.PreviousResponse = null;
}
Ftn.Client.LayzyLoad.prototype =
{
    initialize: function () {
        //  Sys.UI.DomEvent.addHandler(element, 'change', this._updatingDelegate);
        Ftn.Client.LayzyLoad.callBaseMethod(this, 'initialize');
        this.Template = this.get_element().cloneNode(true);
        if (this.EmptyContainerID)
            this.EmptyTemplate = $get(this.EmptyContainerID);
        this.CacheKey = null;
        this.update();
    },
    dispose: function () {
        var element = this.get_element();
        this.ServiceMethod = null;
        this.ServiceUrl = null;
        this.Context = null;
        this.TimeOut = null;
        this.Template = null;
        this.EmptyTemplate = null;
        this.LoadingContainerID = null;
        this.EmptyContainerID = null;
        this.CacheKey = null;
        this.PreviousResponse = null;
        $clearHandlers(element);
        Ftn.Client.LayzyLoad.callBaseMethod(this, 'dispose');
    },
    update: function () {
        if (this.ServiceUrl) {
            var canUpdate = true;
            var handlers = this.get_events().updating;
            if (handlers) {
                for (var i = handlers.length - 1; i >= 0; i--) {
                    var retval = handlers[i].handler(this, Sys.EventArgs.Empty);
                    if (retval == false) {
                        canUpdate = false;
                        break;
                    }
                }
            }
            if (canUpdate == true) {
                var params = null;
                if (this.Context)
                    params = Sys.Serialization.JavaScriptSerializer.deserialize(this.Context)
                params["cacheKey"] = this.CacheKey;
                var self = this;
                Sys.Net.WebServiceProxy.invoke($url(this.ServiceUrl), this.ServiceMethod, false, params,
					Function.createDelegate(this, this._succeededDelegate), function(error) {
					    setTimeout("$find('" + self.get_element().id + "').update();", self.TimeOut);
					});
                return;
            }
        }
        if (this.get_element())
            setTimeout("$find('" + this.get_element().id + "').update();", this.TimeOut);


    },
    // Bind and unbind to select event.
    add_updating: function (handler) {
        this.get_events().addHandler('updating', handler);
    },
    remove_updating: function (handler) {
        this.get_events().removeHandler('updating', handler);
    },
    // Bind and unbind to select event.
    add_updated: function (handler) {
        this.get_events().addHandler('updated', handler);
    },
    remove_updated: function (handler) {
        this.get_events().removeHandler('updated', handler);
    },
    _succeededDelegate: function (response) {
        var contentHolder = this.get_element();
        if (contentHolder) {
            if (this.CacheKey == null || this.CacheKey != response.CacheStamp) {

                this.CacheKey = response.CacheStamp;
                globalMarkupBuilder.loadItemTemplate(this.Template, this.EmptyTemplate);
                var temp;
                if (response.Data) {
                    temp = globalMarkupBuilder.bind(response.Data, this.PreviousResponse);
                    this.PreviousResponse = response.Data;
                }
                else {
                    temp = globalMarkupBuilder.bind(response, this.PreviousResponse);
                    this.PreviousResponse = response.Data;
                }
                
                contentHolder.innerHTML = temp;
                contentHolder.style.display = "block"


            }
            var handlers = this.get_events().updated;
            if (handlers) {
                for (var i = handlers.length - 1; i >= 0; i--) {
                    handlers[i].handler(this, Sys.EventArgs.Empty);
                }
            }
            var loadingContainer = $get(this.LoadingContainerID);
            if (loadingContainer)
                loadingContainer.style.display = "none";

            setTimeout("$find('" + this.get_element().id + "').update();", this.TimeOut);
        }
    }
}
Ftn.Client.LayzyLoad.registerClass('Ftn.Client.LayzyLoad', Sys.UI.Control);
////////////////////////////////////////////////////////////////////////////////////////////
Ftn.Client.FildUpdatedHandler = function(element) {
    Ftn.Client.FildUpdatedHandler.initializeBase(this);
    this.HandlerLogic = null;
    this.FildName = null;
}
Ftn.Client.FildUpdatedHandler.prototype =
{
    initialize: function() {
        Ftn.Client.FildUpdatedHandler.callBaseMethod(this, 'initialize');
        this._onUpdaited = Function.createDelegate(this, this.updaited);
        $addHandler(globalMarkupBuilder, 'updated', this._onUpdaited);
    },
    updaited: function(newvalue, fildname, previouseValue, equialsValues) {
        if (this.FildName == fildname) {
            if (this.HandlerLogic) {
                if (!previouseValue)
                    previouseValue = 'null';
                return eval(String.format(this.HandlerLogic, newvalue, previouseValue, equialsValues));
            }
        }
        return null;
    },
    dispose: function() {
        //      $removeHandler(globalMarkupBuilder, 'updated', this._onUpdaited);
        this.HandlerLogic = null;
        this.FildName = null;
        Ftn.Client.FildUpdatedHandler.callBaseMethod(this, 'dispose');
    }
}
Ftn.Client.FildUpdatedHandler.registerClass('Ftn.Client.FildUpdatedHandler', Sys.Component);




//////lastest news control

var timeOut = 4000;
var currItem = 0;
var timerId = null;
var isNewsChange = true;
function showNewsItem() {
    document.getElementById('tickprevnews').onclick = buttonClick;
    document.getElementById('ticknextnews').onclick = buttonClick;


    
    document.getElementById("lastestnews").onmouseover = stopTimer;
    document.getElementById("lastestnews").onmouseout = startTimer;
    setText();
}
function stopTimer(e) {
    isNewsChange = false;
}
function startTimer(e) {
   
    isNewsChange = true;
}
function buttonClick(e) {
    if (this.id == "tickprevnews") {
        prevArticle();
    } else if (this.id == "ticknextnews") {
        nextArticle();
    }
}

function prevArticle() {
    clearTimeout(timerId);
    currItem = currItem - 3;
    if (currItem < 0)
        currItem = 0;

    setText();


}

function nextArticle() {
    clearTimeout(timerId);
    currItem = currItem + 1;
    if (currItem >= arrNewsItems.length / 2)
        currItem = 0;
    setText();

}

function setText() {
    if (!isNewsChange) {
        timerId = setTimeout('setText()', timeOut);
        return;
    }
    var tickElem = document.getElementById("lastestnews");
    var tickFirstChild = tickElem.firstChild;
    if (tickFirstChild) {
        var tickLinkElem = document.createElement("a");
        tickLinkElem.setAttribute('href', arrNewsItems[currItem * 2]);
        tickLinkElem.setAttribute('target', '_top');
        tickText = document.createTextNode(arrNewsItems[currItem * 2 + 1]);
        tickLinkElem.appendChild(tickText);
        tickElem.replaceChild(tickLinkElem, tickFirstChild);

        currItem++;
        if (currItem >= arrNewsItems.length / 2)
            currItem = 0;
        timerId = setTimeout('setText()', timeOut);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Login/Registration crypt functions

function loginCryptFunction(passwordId, cryptPassword, seedId) {

    var hdnSeed = document.getElementById(seedId);
    var seedValue = hdnSeed.value;
    if (typeof (seedValue) !== "undefined") {
        var pos = seedValue.indexOf("$");
        var seed = seedValue.substring(0, pos);
        var seedId = seedValue.substr(pos + 1);
        var c = document.getElementById(cryptPassword);
        var c2 = document.getElementById(passwordId);
        c.value = seed + '$' + MD5_hexhash(seedId + MD5_hexhash(c2.value));
        c2.value = '';
    }
}

function registerCryptFunction(passwordID, cryptPasswordID, confirmID, cryptConfirmID) {
    var seed = cryptGetSeed();
    if (seed) {
        var p1 = document.getElementById(passwordID);
        var p2 = document.getElementById(cryptPasswordID);
        var c1 = document.getElementById(confirmID);
        var c2 = document.getElementById(cryptConfirmID);

        p2.value = seed.Seed + '$' + MD5_hexhash(p1.value);
        c2.value = seed.Seed + '$' + MD5_hexhash(c1.value);
    }
}

function changePasswordCryptFunction(currentPasswordID, cryptCurrentPasswordID, newPasswordID, cryptNewPasswordID, confirmID, cryptConfirmID) {
    var seed = cryptGetSeed();
    if (seed) {
        var p1 = document.getElementById(currentPasswordID);
        var p2 = document.getElementById(cryptCurrentPasswordID);
        var n1 = document.getElementById(newPasswordID);
        var n2 = document.getElementById(cryptNewPasswordID);
        var c1 = document.getElementById(confirmID);
        var c2 = document.getElementById(cryptConfirmID);


        // Crypt current password field
        p2.value = seed.Seed + '$' + MD5_hexhash(seed.SeedId + MD5_hexhash(p1.value));
        // Crypt new password field
        n2.value = seed.Seed + '$' + MD5_hexhash(n1.value);
        // Crypt confirm password field
        c2.value = seed.Seed + '$' + MD5_hexhash(c1.value);

        /*
        // Crypt current password field
        p2.value = MD5_hexhash(p1.value);
        // Crypt new password field
        n2.value = MD5_hexhash(n1.value);
        // Crypt confirm password field
        c2.value = MD5_hexhash(c1.value);
        */
    }
}

function cryptGetSeed() {
    // Instantiate a WebRequest.
    var wRequest = new Sys.Net.WebRequest();
    // Set the request URL.
    wRequest.set_url($url('~/Services/login.asmx') + '/GenerateSeed');
    // Set the request verb.
    wRequest.set_httpVerb('POST');

    wRequest.get_headers()['Content-Type'] = 'application/json; charset=utf-8';

    var executor = new Sys.Net.XMLHttpSyncExecutor();
    wRequest.set_executor(executor);
    // Execute the request.
    wRequest.invoke();

    if (executor.get_responseAvailable()) {
        return executor.get_object().d;     //for .net 3.5. compatibility
    }
    return false;
}

function cleanupPasswordField(val) {
    var id = val.controltocleanup;
    var el = document.getElementById(id);
    if (el) el.value = '';
    return true;
}

Ftn.Client.CompanyPeerValuation = {
    initialize: function(hiddenId) {
        this.HiddenField = $get(hiddenId);
        this.ComanyArray = eval('[' + this.HiddenField.value + ']');
    },
    removeCompany: function(id, parentRowId) {
        Array.remove(Ftn.Client.CompanyPeerValuation.ComanyArray, id);
        var srt = "";
        Array.forEach(Ftn.Client.CompanyPeerValuation.ComanyArray, function(element) { srt = srt + element + ","; });
        Ftn.Client.CompanyPeerValuation.HiddenField.value = srt.substr(0, srt.length - 1);
        var parentRow = $get(parentRowId);
        parentRow.parentNode.removeChild(parentRow);
    }
}
//check box manager
Ftn.Client.CheckBoxManager = function(element) {
    Ftn.Client.CheckBoxManager.initializeBase(this, [element]);
    this.SelectAllControlID = null;
    this.UnSelectAllControlID = null;
    this.CheckBoxes = new Array();
}
Ftn.Client.CheckBoxManager.prototype =
{
    initialize: function() {
        Ftn.Client.CheckBoxManager.callBaseMethod(this, 'initialize');
        this._onSelectAllHandler = Function.createDelegate(this, this.selectAll);
        $addHandler($get(this.SelectAllControlID), 'click', this._onSelectAllHandler);

        this._onUnselectAllHandler = Function.createDelegate(this, this.unselectAll);
        $addHandler($get(this.UnSelectAllControlID), 'click', this._onUnselectAllHandler);

        this._onItemCheckedHandler = Function.createDelegate(this, this.itemChecked);
        for (var k = 0; k < this.CheckBoxes.length; k++) {
            var checkbox = $get(this.CheckBoxes[k]);
            if (checkbox) {
                $addHandler(checkbox, 'click', this._onItemCheckedHandler);
            }
        }
    },
    dispose: function() {
        $removeHandler($get(this.SelectAllControlID), 'click', this._onSelectAllHandler);
        $removeHandler($get(this.UnSelectAllControlID), 'click', this._onUnselectAllHandler);
        for (var k = 0; k < this.CheckBoxes.length; k++) {
            var checkbox = $get(this.CheckBoxes[k]);
            if (checkbox) {
                $removeHandler(checkbox, 'click', this._onItemCheckedHandler);
            }
        }
        this.SelectAllControlID = null;
        this.UnSelectAllControlID = null;
        this.CheckBoxes = new Array();

        this._onSelectAllHandler = null;
        this._onUnselectAllHandler = null;
        this._onItemCheckedHandler = null;
        Ftn.Client.CheckBoxManager.callBaseMethod(this, 'dispose');
    },
    selectAll: function() {
        for (var k = 0; k < this.CheckBoxes.length; k++) {
            $get(this.CheckBoxes[k]).checked = true;
        }
        this.get_element().value = this.CheckBoxes;
    },
    unselectAll: function() {
        for (var k = 0; k < this.CheckBoxes.length; k++) {
            $get(this.CheckBoxes[k]).checked = false;
        }
        this.get_element().value = null;
    },
    itemChecked: function(e) {
        var idArray = this.createArrayFromString();
        if (e.target.checked == true)
            idArray.push(e.target.id);
        else
            idArray.pop(e.target.id);
        this.get_element().value = idArray;
    },
    createArrayFromString: function() {
        return this.get_element().value.split(',');
    },
    get_CheckBoxes: function() {
        return this.RadiusDropDownID;
    },
    set_CheckBoxes: function(value) {
        if (this.CheckBoxes != value)
            this.CheckBoxes = value;
    }
}
Ftn.Client.CheckBoxManager.descriptor =
{
    properties: [{ name: 'SelectAllControlID', type: String },
                    { name: 'UnSelectAllControlID', type: String },
                    { name: 'CheckBoxes', type: Array}]
}
Ftn.Client.CheckBoxManager.registerClass('Ftn.Client.CheckBoxManager', Sys.UI.Control);

////////////////////////////////////////////////////////////////////////////////
// Sys.Net.XMLHttpSyncExecutor

Sys.Net.XMLHttpSyncExecutor = function() {
    if (arguments.length !== 0) throw Error.parameterCount();
    Sys.Net.XMLHttpSyncExecutor.initializeBase(this);

    var _this = this;
    this._xmlHttpRequest = null;
    this._webRequest = null;
    this._responseAvailable = false;
    this._timedOut = false;
    this._timer = null;
    this._aborted = false;
    this._started = false;

    this._responseData = null;
    this._statusCode = null;
    this._statusText = null;
    this._headers = null;

    this._onReadyStateChange = function() {
        if (_this._xmlHttpRequest.readyState === 4) {
            _this._clearTimer();
            _this._responseAvailable = true;

            _this._responseData = _this._xmlHttpRequest.responseText;
            _this._statusCode = _this._xmlHttpRequest.status;
            _this._statusText = _this._xmlHttpRequest.statusText;
            _this._headers = _this._xmlHttpRequest.getAllResponseHeaders();

            _this._webRequest.completed(Sys.EventArgs.Empty);
            if (_this._xmlHttpRequest != null) {
                _this._xmlHttpRequest.onreadystatechange = Function.emptyMethod;
                _this._xmlHttpRequest = null;
            }
        }
    }

    this._clearTimer = function this$_clearTimer() {
        if (_this._timer != null) {
            window.clearTimeout(_this._timer);
            _this._timer = null;
        }
    }

    this._onTimeout = function this$_onTimeout() {
        if (!_this._responseAvailable) {
            _this._clearTimer();
            _this._timedOut = true;
            _this._xmlHttpRequest.onreadystatechange = Function.emptyMethod;
            _this._xmlHttpRequest.abort();
            _this._webRequest.completed(Sys.EventArgs.Empty);
            _this._xmlHttpRequest = null;
        }
    }
}

function Sys$Net$XMLHttpSyncExecutor$get_timedOut() {
    /// <value type="Boolean"></value>
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._timedOut;
}

function Sys$Net$XMLHttpSyncExecutor$get_started() {
    /// <value type="Boolean"></value>
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._started;
}

function Sys$Net$XMLHttpSyncExecutor$get_responseAvailable() {
    /// <value type="Boolean"></value>
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._responseAvailable;
}

function Sys$Net$XMLHttpSyncExecutor$get_aborted() {
    /// <value type="Boolean"></value>
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._aborted;
}

function Sys$Net$XMLHttpSyncExecutor$executeRequest() {
    if (arguments.length !== 0) throw Error.parameterCount();
    this._webRequest = this.get_webRequest();

    if (this._started) {
        throw Error.invalidOperation(String.format(Sys.Res.cannotCallOnceStarted, 'executeRequest'));
    }
    if (this._webRequest === null) {
        throw Error.invalidOperation(Sys.Res.nullWebRequest);
    }

    var body = this._webRequest.get_body();
    var headers = this._webRequest.get_headers();
    this._xmlHttpRequest = new XMLHttpRequest();
    var verb = this._webRequest.get_httpVerb();
    this._xmlHttpRequest.open(verb, this._webRequest.getResolvedUrl(), false); // False to call Synchronously
    if (headers) {
        for (var header in headers) {
            var val = headers[header];
            if (typeof (val) !== "function")
                this._xmlHttpRequest.setRequestHeader(header, val);
        }
    }

    if (verb.toLowerCase() === "post") {
        if ((headers === null) || !headers['Content-Type']) {
            this._xmlHttpRequest.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
        }

        if (!body) {
            body = "";
        }
    }

    var timeout = this._webRequest.get_timeout();
    if (timeout > 0) {
        this._timer = window.setTimeout(Function.createDelegate(this, this._onTimeout), timeout);
    }
    this._xmlHttpRequest.send(body);
    this._started = true;
    this._onReadyStateChange();
}

function Sys$Net$XMLHttpSyncExecutor$getAllResponseHeaders() {
    /// <returns type="String"></returns>
    if (arguments.length !== 0) throw Error.parameterCount();
    if (!this._responseAvailable) {
        throw Error.invalidOperation(String.format(Sys.Res.cannotCallBeforeResponse, 'getAllResponseHeaders'));
    }

    return this._headers;
}

function Sys$Net$XMLHttpSyncExecutor$get_responseData() {
    /// <value type="String"></value>
    if (arguments.length !== 0) throw Error.parameterCount();
    if (!this._responseAvailable) {
        throw Error.invalidOperation(String.format(Sys.Res.cannotCallBeforeResponse, 'get_responseData'));
    }

    return this._responseData;
}

function Sys$Net$XMLHttpSyncExecutor$get_statusCode() {
    /// <value type="Number"></value>
    if (arguments.length !== 0) throw Error.parameterCount();
    if (!this._responseAvailable) {
        throw Error.invalidOperation(String.format(Sys.Res.cannotCallBeforeResponse, 'get_statusCode'));
    }

    return this._statusCode;
}

function Sys$Net$XMLHttpSyncExecutor$get_statusText() {
    /// <value type="String"></value>
    if (arguments.length !== 0) throw Error.parameterCount();
    if (!this._responseAvailable) {
        throw Error.invalidOperation(String.format(Sys.Res.cannotCallBeforeResponse, 'get_statusText'));
    }

    return this._statusText;
}

function Sys$Net$XMLHttpSyncExecutor$get_xml() {
    /// <value></value>
    if (arguments.length !== 0) throw Error.parameterCount();
    if (!this._responseAvailable) {
        throw Error.invalidOperation(String.format(Sys.Res.cannotCallBeforeResponse, 'get_xml'));
    }

    var xml = this._responseData;
    if ((!xml) || (!xml.documentElement)) {
        xml = new XMLDOM(this._responseData);
        if ((!xml) || (!xml.documentElement)) {
            return null;
        }
    }
    else if (navigator.userAgent.indexOf('MSIE') !== -1) {
        xml.setProperty('SelectionLanguage', 'XPath');
    }

    if ((xml.documentElement.namespaceURI === "http://www.mozilla.org/newlayout/xml/parsererror.xml") &&
			(xml.documentElement.tagName === "parsererror")) {
        return null;
    }

    if (xml.documentElement.firstChild && xml.documentElement.firstChild.tagName === "parsererror") {
        return null;
    }

    return xml;
}

function Sys$Net$XMLHttpSyncExecutor$abort() {
    if (arguments.length !== 0) throw Error.parameterCount();
    if (!this._started) {
        throw Error.invalidOperation(Sys.Res.cannotAbortBeforeStart);
    }

    if (this._aborted || this._responseAvailable || this._timedOut)
        return;

    this._aborted = true;

    this._clearTimer();

    if (this._xmlHttpRequest && !this._responseAvailable) {
        this._xmlHttpRequest.onreadystatechange = Function.emptyMethod;
        this._xmlHttpRequest.abort();

        this._xmlHttpRequest = null;
        var handler = this._webRequest._get_eventHandlerList().getHandler("completed");
        if (handler) {
            handler(this, Sys.EventArgs.Empty);
        }
    }
}

Sys.Net.XMLHttpSyncExecutor.prototype = {
    get_timedOut: Sys$Net$XMLHttpSyncExecutor$get_timedOut,
    get_started: Sys$Net$XMLHttpSyncExecutor$get_started,
    get_responseAvailable: Sys$Net$XMLHttpSyncExecutor$get_responseAvailable,
    get_aborted: Sys$Net$XMLHttpSyncExecutor$get_aborted,
    executeRequest: Sys$Net$XMLHttpSyncExecutor$executeRequest,
    getAllResponseHeaders: Sys$Net$XMLHttpSyncExecutor$getAllResponseHeaders,
    get_responseData: Sys$Net$XMLHttpSyncExecutor$get_responseData,
    get_statusCode: Sys$Net$XMLHttpSyncExecutor$get_statusCode,
    get_statusText: Sys$Net$XMLHttpSyncExecutor$get_statusText,
    get_xml: Sys$Net$XMLHttpSyncExecutor$get_xml,
    abort: Sys$Net$XMLHttpSyncExecutor$abort
}

Sys.Net.XMLHttpSyncExecutor.registerClass('Sys.Net.XMLHttpSyncExecutor', Sys.Net.WebRequestExecutor);

////////////////////////////////////////////////////////////////////////////////



Ftn.Client.Portfolio = {

    show: function(showId, hideId) {
        var show = $get(showId);
        var hide = $get(hideId);
        show.style.display = "block";
        hide.style.display = "none";
    },
    initSell: function(open, close, popup, id, hf, event) {
        var hidden = $get(hf);
        hidden.value = id;
        var hover = $find(open);
        if (hover == null) {
            hover = $create(Ftn.Client.HoverMenu, { "Mode": "Popup", "MoveToBottom": false,
                "PopupControlID": popup, "PopupPosition": "Bottom", "X": 0, "Y": 0, "id": open
            }, null, null, $get(open));
            var cl = $get(close);
            cl.onclick = function() { hover.hide(); return false; };
            if (event.stopPropagation) {
                event.stopPropagation();
            } else {
                event.cancelBubble = true;
            }
            hover.show();
        }
    }
}
Ftn.Client.FastTabManager = function(element) {
    Ftn.Client.FastTabManager.initializeBase(this, [element]);
}

Ftn.Client.FastTabManager.prototype = {
    initialize: function() {
        Ftn.Client.FastTabManager.callBaseMethod(this, 'initialize');
        var tabs = this._getAllTabs();
        this._tabClickHandlerDelegate = Function.createDelegate(this, this.tabClick);
        for (var i = tabs.length; i--; ) {
            tabs[i].oldOnClick = tabs[i].onclick;
            tabs[i].onclick = null;
            $addHandler(tabs[i], 'click', this._tabClickHandlerDelegate);
        }
    },
    dispose: function() {
        Ftn.Client.FastTabManager.callBaseMethod(this, 'dispose');
    },
    tabClick: function(e) {
        e.stopPropagation();
        e.preventDefault();

        var element = this.get_element();
        var tab = e.target;
        while (tab && tab.tagName != 'A') tab = tab.parentNode;
        var tabIndex = parseInt(tab.id.replace(element.id + '_t_lb', ''));
        this.selectTab(tabIndex);
    },
    selectTab: function(tabIndex) {

        var tabIndexInCollection = tabIndex;
        var element = this.get_element();

        var tabs = this._getAllTabs();
        for (var i = tabs.length; i--; ) {
            var tabIndexCurrent = parseInt(tabs[i].id.replace(element.id + '_t_lb', ''));
            var currentContent = $get(element.id + '_wr' + i);
            if (tabIndexCurrent == tabIndex) {
                tabs[i].parentNode.className = 'current';
                tabIndexInCollection = i;
                currentContent.style.display = 'block';
            }
            else {
                tabs[i].parentNode.className = '';

                currentContent.style.display = 'none';
            }
        }
    },
    _getAllTabs: function() {
        var element = this.get_element();
        var ul = element.getElementsByTagName('UL')[0];
        return ul.getElementsByTagName('A');
    },
    getCurrentTabIndex: function() {
        var tabs = this._getAllTabs();
        var currentTab;
        for (var i = tabs.length; i--; ) {
            if (tabs[i].parentNode.className == 'current') {
                return i;
            }
        }
        return 0;
    },
    getTabCount: function() {
        return this._getAllTabs().length;
    }
}
Ftn.Client.FastTabManager.registerClass('Ftn.Client.FastTabManager', Sys.UI.Control);
////////////////////////////////////////////////////////////////////////////////////////////
if (typeof (Sys) !== 'undefined') Sys.Application.notifyScriptLoaded();