/// <reference name="MicrosoftAjax.js" />
/// <reference name="MicrosoftAjaxWebForms.js" />

if (typeof(Sb) === "undefined")
{
	Type.registerNamespace("Sb");
}



Sb.ImageCache = function()
{
	Sb.ImageCache.initializeBase(this);
	
	this.images = [];
}
Sb.ImageCache.prototype =
{
	add: function(imageSource)
	{
		var image = new Image();
		image.src = imageSource;
		Array.add(this.images, image);
	}
}
Sb.ImageCache.registerClass("Sb.ImageCache");



Sb.CssButton = function(initObject)
{
    Sb.CssButton.initializeBase(this, [initObject.panel]);
    
    this.initObject = initObject;
}
Sb.CssButton.prototype =
{
	toggleClass: function(isHover)
	{
		var element = this.get_element();
		element.className = (isHover) ? this.initObject.classHover : this.initObject.classNormal;
	},

	buttonOver: function()
	{
		try
		{
			this.toggleClass(true);
		}
		catch (exception)
		{
			window.errorManager.handleException(exception);
		}
	},
	
	buttonOut: function()
	{
		try
		{
			this.toggleClass(false);
		}
		catch (exception)
		{
			window.errorManager.handleException(exception);
		}

	},

    initialize: function()
    {
		this.toggleClass(false);
		
		$addHandler(this.initObject.button, "mouseover", Function.createDelegate(this, this.buttonOver));
		$addHandler(this.initObject.button, "mouseout", Function.createDelegate(this, this.buttonOut));
    
        Sb.CssButton.callBaseMethod(this, 'initialize');
    },

    dispose: function()
    {
        Sb.CssButton.callBaseMethod(this, 'dispose');
    }
}
Sb.CssButton.registerClass('Sb.CssButton', Sys.UI.Control);



Sb.DataControl = function(element)
{
	Sb.DataControl.initializeBase(this, [element]);
}
Sb.DataControl.prototype =
{
	initialize: function(settings)
	{
		this.settings = (settings || { });
		
		this.onInitializing();		
		Sb.DataControl.callBaseMethod(this, "initialize");
		this.onInit();
	},

	onInitializing: function() { },
	
	onInit: function()
	{
		var settings = this.get_settings();
		
		if (settings.childControls && Array.isInstanceOfType(settings.childControls))
		{
			var controls = this.get_controls();
			Array.forEach(controls, Function.createDelegate(this, function(item)
			{
				this.addControl(item);
			}));
		}
	},
	
	raiseControlEvent: function(eventName, e)
	{
		var events = this.get_events();
		var handler = events.getHandler(eventName);
		if (handler)
		{
			handler(this, e);
		}
	},

	get_settings: function()
	{
		return this.settings;
	},
	
	get_dataSource: function()
	{
		return this.dataSource;
	},
	
	onDataSourceSet: function() { },
	
	set_dataSource: function(value)
	{
		this.dataSource = value;
		this.onDataSourceSet();
	},
	
	onDataBinding: function() { },
	
	dataBind: function()
	{
		this.onDataBinding();
		
		var controls = this.get_controls();
		Array.forEach(controls, function(item)
		{
			if (Sb.DataControl.isInstanceOfType(item))
			{
				item.dataBind();
			}
		});
	},
	
	get_controls: function()
	{
		if (!this.controls)
		{
			this.controls = [ ];
		}
		
		return this.controls;
	},
	
	addControl: function(control)
	{
		if ((!control) || (!Sys.UI.Control.isInstanceOfType(control)))
		{
			throw Error.argument("control", "Argument is not a Sys.UI.Control");
		}
		
		if (!Sys.UI.DomElement.getElementById(control.get_id(), this.get_element()))
		{
			throw Error.argument("control",
				"Element associated with control is not a child element of the parent control's associated element.");
		}
		
		control.set_parent(this);
		
		var controls = this.get_controls();
		Array.add(controls, control);
		
	},
	
	getControl: function(id)
	{
		var controls = this.get_controls();
		Array.forEach(controls, function(item)
		{
			if (item.get_id() == id)
			{
				return item;
			}
		});
		
		return null;
	},
	
	getControlAt: function(index)
	{
		var controls = this.get_controls();
		return controls[index];
	},
	
	removeControl: function(control)
	{
		var controls = this.get_controls();
		if (control && (control.get_parent() == this) && Array.contains(controls, control))
		{
			control.set_parent(null);
			Array.remove(controls, control);
			return true;
		}
		
		return false;
	},
	
	removeControlAt: function(index)
	{
		var control = this.getControlAt(index);
		return this.removeControl(control);
	},
	
	setElementEnabled: function(element, value)
	{
		if (typeof(element.disabled) != "undefined")
		{
			element.disabled = (!value);
		}
		
		var child = element.firstChild;
		while (child)
		{
			this.setElementEnabled(child, value);
			child = child.nextSibling;
		}
		
	},

	get_enabled: function()
	{
		if (typeof(this.enabled) == "undefined")
		{
			this.enabled = true;
		}
		
		return this.enabled;
	},
	
	set_enabled: function(value)
	{
		var element = this.get_element();
		this.setElementEnabled(element, value);
		this.enabled = value;
		
	}
	
}
Sb.DataControl.registerClass("Sb.DataControl", Sys.UI.Control);



Sb.ActiveControl = function(element)
{
	Sb.ActiveControl.initializeBase(this, [element]);
}
Sb.ActiveControl.prototype =
{
	onInit: function()
	{
		var element = this.get_element();
		var settings = this.get_settings();

		if (!settings.mouseOverOff)
		{
			$addHandler(element, "mouseover", Function.createDelegate(this, this.elementOver));
			$addHandler(element, "mouseout", Function.createDelegate(this, this.elementOut));
		}
	
		if (settings.focusControlOn)
		{
			$addHandler(element, "focus", Function.createDelegate(this, this.elementFocus));
			$addHandler(element, "blur", Function.createDelegate(this, this.elementBlur));
		}
		
		Sb.ActiveControl.callBaseMethod(this, "onInit");
		
	},
	
	doOver: function(settings)
	{
		if (settings.mouseOverOff)
		{
			return;
		}
	
		var element = (settings.targetElement || this.get_element());
		if ((!settings.isOver) && (!settings.isFocus) && settings.classOver && (!element.disabled))
		{
			settings.isOver = true;
			element.className = settings.classOver;
		}
	},
	
	doOut: function(settings)
	{
		if (settings.mouseOverOff)
		{
			return;
		}
	
		var element = (settings.targetElement || this.get_element());
		settings.isOver = false;
		if (!settings.isFocus && settings.classNormal)
		{
			element.className = settings.classNormal;
		}
	},
	
	doFocus: function(settings)
	{
		if (!settings.isFocus)
		{
			var element = (settings.targetElement || this.get_element());
		
			settings.isFocus = true;
			
			if (settings.classOver)
			{
				element.className = settings.classOver;
			}
			
			if (element.select)
			{
				element.select();
			}
		}
	},
	
	doBlur: function(settings)
	{
		settings.isFocus = false;
		if (!settings.isOver)
		{
			var element = (settings.targetElement || this.get_element());
		
			if (settings.classNormal)
			{
				element.className = settings.classNormal;
			}
			
			var currentValue = element.value;
			element.value = "";
			element.value = currentValue;
		}
	},

	elementOver: function()
	{
		try
		{
			this.doOver(this.get_settings());
		}
		catch (exception)
		{
			window.errorManager.handleException(exception);
		}

	},
	
	elementOut: function()
	{
		try
		{
			this.doOut(this.get_settings());
		}
		catch (exception)
		{
			window.errorManager.handleException(exception);
		}

	},

	elementFocus: function()
	{
		try
		{
			this.doFocus(this.get_settings());
		}
		catch (exception)
		{
			window.errorManager.handleException(exception);
		}

	},
	
	elementBlur: function()
	{
		try
		{
			this.doBlur(this.get_settings());
		
		}
		catch (exception)
		{
			window.errorManager.handleException(exception);
		}

	}
}
Sb.ActiveControl.registerClass("Sb.ActiveControl", Sb.DataControl);



Sb.MultiTargetControl = function(element)
{
	Sb.MultiTargetControl.initializeBase(this, [element]);
	
	this.targetSettings = [ ];
	this.targetElements = [ ];
}
Sb.MultiTargetControl.prototype = 
{
	elementOver: function()
	{
		try
		{
			Array.forEach(this.targetSettings, function(item, index, array)
			{
				this.doOver(item);
			}, this);
		}
		catch (exception)
		{
			window.errorManager.handleException(exception);
		}

	},
	
	elementOut: function(e)
	{
		try
		{
			Array.forEach(this.targetSettings, function(item)
			{
				this.doOut(item);
			}, this);
		}
		catch (exception)
		{
			window.errorManager.handleException(exception);
		}

	},
	
	elementFocus: function(e)
	{
		Array.forEach(this.targetSettings, function(item)
		{
			this.doFocus(item);

		}, this);
	},
	
	elementBlur: function(e)
	{
		Array.forEach(this.targetSettings, function(item)
		{
			this.doBlur(item);
		
		}, this);
	},
	
	getSettingsOfElement: function(element)
	{
		return this.targetSettings[Array.indexOf(this.targetElements, element)];
	},
	
	addTarget: function(targetSetting)
	{
		Array.add(this.targetSettings, targetSetting);
		Array.add(this.targetElements, targetSetting.targetElement);
		
		if (targetSetting.focusControlOn)
		{
			$addHandler(targetSetting.targetElement, "focus", Function.createDelegate(this, this.elementFocus));
			$addHandler(targetSetting.targetElement, "blur", Function.createDelegate(this, this.elementBlur));
		}
		
	}
	
}
Sb.MultiTargetControl.registerClass("Sb.MultiTargetControl", Sb.ActiveControl);



Sb.ErrorPopup = function(element)
{
	Sb.ErrorPopup.initializeBase(this, [element]);
}
Sb.ErrorPopup.prototype =
{
	onInit: function()
	{
		var settings = this.get_settings();
	
		var okButton = this.get_okButton();
		$addHandler(okButton, "click", Function.createDelegate(this, this.closeClick));
		
		var element = this.get_element();
		var closeButton = $get(settings.closeButton, element);
		$addHandler(closeButton, "click", Function.createDelegate(this, this.closeClick));
	
		Sb.ErrorPopup.callBaseMethod(this, "onInit");
	},
	
	closeClick: function()
	{
		try
		{
			var modalBehavior = this.get_modalBehavior();
			modalBehavior.hide();
		}
		catch (exception)
		{
			window.errorManager.handleException(exception);
		}

	},
	
	get_modalBehavior: function()
	{
		if (!this.modalBehavior)
		{
			this.modalBehavior = $find("errorModal");
		}
		
		return this.modalBehavior;
	},

	get_contentPanel: function()
	{
		 if (!this.contentPanel)
		 {
			var element = this.get_element();
			this.contentPanel = $get("errorMessageContent", element);
		 }
		 
		 return this.contentPanel;
	},
	
	get_okButton: function()
	{
		if (!this.okButton)
		{
			var element = this.get_element();
			this.okButton = $get("errorMessageOk", element);
		}
		
		return this.okButton;
	},
	
	show: function(message)
	{
		if (message)
		{
			var contentPanel = this.get_contentPanel();
			contentPanel.innerHTML = message.toString();
		}
	
		var modalBehavior = this.get_modalBehavior();
		modalBehavior.show();

		var okButton = this.get_okButton();
		okButton.focus();

	},
	
	showServer: function()
	{
		window.setTimeout(Function.createDelegate(this, function()
		{
			if (!window.cacheChecker.get_isLoadedFromCache())
			{
				this.show();
			}
			
		}), 0);
	}
	
}
Sb.ErrorPopup.registerClass("Sb.ErrorPopup", Sb.DataControl);

Sb.ConfirmationPopup = function(element)
{
	Sb.ConfirmationPopup.initializeBase(this, [element]);
}
Sb.ConfirmationPopup.prototype =
{
	onInit: function()
	{
		var settings = this.get_settings();
	
		var okButton = this.get_okButton();
		$addHandler(okButton, "click", Function.createDelegate(this, this.okClick));
		
		var cancelButton = this.get_cancelButton();
		$addHandler(cancelButton, "click", Function.createDelegate(this, this.cancelClick));
		
		var element = this.get_element();
		var closeButton = $get(settings.closeButton, element);
		$addHandler(closeButton, "click", Function.createDelegate(this, this.cancelClick));
	
	
		Sb.ConfirmationPopup.callBaseMethod(this, "onInit");
	},
	
	okClick: function()
	{
        try
		{
			var modalBehavior = this.get_modalBehavior();
			modalBehavior.hide();
            this.onOkHandler();
		}
		catch (exception)
		{
			window.errorManager.handleException(exception);
		}
	},
	
	cancelClick: function()
	{
	    try
		{
			var modalBehavior = this.get_modalBehavior();
			modalBehavior.hide();
		}
		catch (exception)
		{
			window.errorManager.handleException(exception);
		}
	},
		
	get_modalBehavior: function()
	{
		if (!this.modalBehavior)
		{
			this.modalBehavior = $find("confirmationModal");
		}
		
		return this.modalBehavior;
	},

	get_contentPanel: function()
	{
		 if (!this.contentPanel)
		 {
			var element = this.get_element();
			this.contentPanel = $get("confirmationMessageContent", element);
		 }
		 
		 return this.contentPanel;
	},
	
	get_okButton: function()
	{
		if (!this.okButton)
		{
			var element = this.get_element();
			this.okButton = $get("confirmationOk", element);
		}
		
		return this.okButton;
	},
	
	get_cancelButton: function()
	{
		if (!this.cancelButton)
		{
			var element = this.get_element();
			this.cancelButton = $get("confirmationCancel", element);
		}
		
		return this.cancelButton;
	},
	
	show: function(message, onOkDelegate)
	{
		if (message)
		{
			var contentPanel = this.get_contentPanel();
			contentPanel.innerHTML = message.toString();
			
			this.onOkHandler = onOkDelegate;
		}
	
		var modalBehavior = this.get_modalBehavior();
		modalBehavior.show();

		var okButton = this.get_okButton();
		okButton.focus();

	},
	
	showServer: function()
	{
		window.setTimeout(Function.createDelegate(this, function()
		{
			if (!window.cacheChecker.get_isLoadedFromCache())
			{
				this.show();
			}
			
		}), 0);
	}
	
}
Sb.ConfirmationPopup.registerClass("Sb.ConfirmationPopup", Sb.DataControl);



Sb.CacheChecker = function(hiddenId, newValue)
{
	Sb.CacheChecker.initializeBase(this);

	this.isLoadedFromCache = false;

	if (isNaN(newValue))
	{
		return;
	}

	var hidden = $get(hiddenId);
	if (!hidden)
	{
		return;
	}
	
	var oldValue = Number.parseInvariant(hidden.value);
	if (isNaN(oldValue))
	{
		return;
	}
	
	this.isLoadedFromCache = (oldValue >= newValue);
	
	if (!this.isLoadedFromCache)
	{
		hidden.value = newValue;
	}
	
}
Sb.CacheChecker.prototype =
{
	get_isLoadedFromCache: function()
	{
		return this.isLoadedFromCache;
	},
	
	forceRefresh: function()
	{
		if (this.get_isLoadedFromCache())
		{
			window.location.reload(true);
		}
	}
	
}
Sb.CacheChecker.registerClass("Sb.CacheChecker");



Sb.LogLevel = function() { }
Sb.LogLevel.prototype =
{
	info: 0,
	
	warn: 1,
	
	error: 2
}
Sb.LogLevel.registerEnum("Sb.LogLevel");



Sb.parseLogLevel = function(value)
{
	if (!value)
	{
		return Sb.LogLevel.info;
	}
	
	var valueAsNum = (isNaN(value)) ? Number.parseInvariant(value.toString()) : value;
	
	if (isNaN(valueAsNum))
	{
		return Sb.LogLevel.info;
	}
	
	if ((valueAsNum < Sb.LogLevel.info) || (valueAsNum > Sb.LogLevel.error))
	{
		return Sb.LogLevel.info;
	}
	
	return valueAsNum;
}



Sb.LogClient = function()
{
	Sb.LogClient.initializeBase(this);
}
Sb.LogClient.prototype =
{
	log: function(logData, logLevel)
	{
		if (!logData)
		{
			return;
		}
	
		var logLevelParsed = Sb.parseLogLevel(logLevel);
		var logDataSerialized = Sys.Serialization.JavaScriptSerializer.serialize(logData);
	
		var logService = new Sb.ClientLogging();
		logService.Log(logLevelParsed, logDataSerialized);
	}
}
Sb.LogClient.registerClass("Sb.LogClient");



Sb.ErrorManager = function()
{
	Sb.ErrorManager.initializeBase(this);
	
	var requestManager = Sys.WebForms.PageRequestManager.getInstance();
	requestManager.add_endRequest(Function.createDelegate(this, this.pageRequestEnd));
}
Sb.ErrorManager.defaultServerMessage = "Server side error.";
Sb.ErrorManager.handleExceptionLast = function(exception)
{
	window.setTimeout(function()
	{
		if (window.errorManager)
		{
			window.errorManager.handleException(exception);
		}
	
	}, 0);
}
Sb.ErrorManager.prototype =
{
	hasValue: function(value)
	{
		return ((value != null) && (typeof(value) != "undefined"))
	},

	ensureMessage: function(message, exception)
	{
		var displayMessage = message;
		
		if (!this.hasValue(displayMessage) && this.hasValue(exception))
		{
			displayMessage = (exception.message || exception.toString());
		}
		
		if (this.hasValue(displayMessage))
		{
			displayMessage = displayMessage.toString();
		}
		
		if ((!this.hasValue(displayMessage)) || (displayMessage.length == 0))
		{
			displayMessage = "Unknown error.";
		}
		
		return displayMessage;
	},
	
	pageRequestEnd: function(sender, e)
	{
		var exception = e.get_error();
		if (exception)
		{
			var message = exception.message;
			var separatorIndex = message.indexOf("###")
			if (separatorIndex >= 0)
			{
				message = message.substring(separatorIndex + 3);
			}
			
			this.displayMessage(message, Sb.ErrorManager.defaultServerMessage);
			e.set_errorHandled(true);
		}
	},
	
	displayMessage: function(message, exception)
	{
		var displayMessage = this.ensureMessage(message, exception);
		window.errorPopup.show(displayMessage);
	},
	
	logException: function(exception)
	{
		var logData = { exception: exception }
		window.logger.log(logData, Sb.LogLevel.error);
	},
	
	handleException: function(exception, userMessage)
	{
		window.setTimeout(Function.createDelegate(this, function()
		{
			this.logException(exception);
			this.displayMessage(userMessage, exception);
		}), 0);
	},
	
	handleWcfError: function(message, e)
	{
		var messageToShow = (message || Sb.ErrorManager.defaultServerMessage);
		
		if (e && e.get_timedOut())
		{
			messageToShow = "Server request timed out.";
		}
		
		this.displayMessage(messageToShow);
		
	}
	
}
Sb.ErrorManager.registerClass("Sb.ErrorManager");


Sb.ProgressBar = function(updateProgressDiv)
{
	Sb.ProgressBar.initializeBase(this);
	
	var prm = Sys.WebForms.PageRequestManager.getInstance();
    prm.add_initializeRequest(Function.createDelegate(this, this.resizeProgressBar));
	
	this._updateProgressDiv = updateProgressDiv;	
}

Sb.ProgressBar.prototype =
{
    resizeProgressBar : function()
    {
        var progressBarImage = this.get_progressBarImage();          
	    var windowSize = this.getWindowSize();			   	    
	    	    
        if (window.browserInfo.isIE6)
        {	                	    
            // In ie6 position:fixed don't works
              
            var progressBarDiv = this.get_progressBarDiv();  
            progressBarDiv.style.position = "absolute";
            progressBarDiv.style.height = window.document.documentElement.scrollHeight;
            progressBarDiv.style.width = windowSize.width;
            
            progressBarImage.style.position = "absolute";
            progressBarImage.style.top = (window.document.documentElement.scrollTop + ((windowSize.height - 30) / 2)) + "px";
	        progressBarImage.style.left = ((windowSize.width - 30) / 2) + "px";
	    } 
	    else
	    {
            progressBarImage.style.top = ((windowSize.height - 30) / 2) + "px";
	        progressBarImage.style.left = ((windowSize.width - 30) / 2) + "px";
	    }
    },

    show: function()
    {
        this.resizeProgressBar();
        this._updateProgressDiv.style.display = "";
    },
    
    hide: function()
    {
        this._updateProgressDiv.style.display = "none";
    },
    
    get_progressBarImage : function()
    {
        if (!this.progressBarImage)
        {        
			this.progressBarImage = $get("progressBarImage", this._updateProgressDiv);
        }
        
        return this.progressBarImage;
    },
    
    get_progressBarDiv : function()
    {
        if (!this.progressBarDiv)
        {
            this.progressBarDiv = $get("progressBarDiv", this._updateProgressDiv);
        }
    
        return this.progressBarDiv;
    },
    
    getWindowSize : function()
    {
	    if (window.innerWidth)
	    {
		    return {
			    width: window.innerWidth,
			    height: window.innerHeight
		    };
	    }
	    else if (window.document.documentElement && window.document.documentElement.clientWidth)
	    {
		    return {
			    width: window.document.documentElement.clientWidth,
			    height: window.document.documentElement.clientHeight
		    };
	    }
	    else if (window.document.body)
	    {
		    return {
			    width: window.document.body.clientWidth,
			    height: window.document.body.clientWidth
		    };
	    }
	    else
	    {
		    return null;
	    }
	}
}
Sb.ProgressBar.registerClass("Sb.ProgressBar");


Sb.DropDownItem = function(element)
{
	Sb.DropDownItem.initializeBase(this, [element]);
}
Sb.DropDownItem.prototype =
{
	onMouseOver: function()
	{
		var settings = this.get_settings();
		if (settings.classOver)
		{
			var element = this.get_element();
			this.classDefault = element.className;
			element.className = settings.classOver;
		}
	},
	
	onMouseOut: function()
	{
		var settings = this.get_settings();
		var element = this.get_element();
		var failSafeDefault = (this.classDefault || "");
		var className = (this.get_isSelected()) ?
			(settings.classSelected || failSafeDefault) : (settings.classNormal || failSafeDefault);
		element.className = className;
	},
	
	onClick: function()
	{
		var e = new Sys.EventArgs();
		this.raiseControlEvent("click", e);
	},

	onInitializing: function()
	{
		var element = this.get_element();
		$addHandler(element, "mouseover", Function.createDelegate(this, this.onMouseOver));
		$addHandler(element, "mouseout", Function.createDelegate(this, this.onMouseOut));
		$addHandler(element, "click", Function.createDelegate(this, this.onClick));
	},

	onDataSourceSet: function()
	{
		var dataSource = this.get_dataSource();
		
		if (!dataSource)
		{
			throw Error.argumentNull("dataSource", "DataSource cannot be null or undefined.");
		}
		
		if (!dataSource.value)
		{
			throw Error.argument("dataSource", "DataSource.value cannot be null or undefined.");
		}
	},

	onDataBinding: function()
	{
		var dataSource = this.get_dataSource();
		if (!dataSource)
		{
			return;
		}
		
		var settings = this.get_settings();
		
		var element = this.get_element();
		var label = element;
		if (settings.labelId && (settings.labelId != this.get_id()))
		{
			label = $get(settings.labelId, element);
		}
		
		label.innerHTML = (dataSource.label || dataSource.value);
		
	},
	
	get_value: function()
	{
		var dataSource = this.get_dataSource();
		return (dataSource && dataSource.value) ? dataSource.value : "";
	},
	
	get_label: function()
	{
		var dataSource = this.get_dataSource();
		return (dataSource && dataSource.label) ? dataSource.label : this.get_value();
	},
	
	get_isSelected: function()
	{
		return this.isSelected;
	},
	
	onSelectedSet: function()
	{
		var settings = this.get_settings();
		if (settings.classSelected)
		{
			var element = this.get_element();
			var className = (this.get_isSelected()) ?
				settings.classSelected : (settings.classNormal || "")
			element.className = className;
		}
	},
	
	set_isSelected: function(value)
	{
		this.isSelected = value;
		this.onSelectedSet();
	},
	
	add_click: function(handler)
	{
		var events = this.get_events();
		events.addHandler("click", handler);
	},
	
	remove_click: function(handler)
	{
		var events = this.get_events();
		events.removeHandler("click", handler);
	}
}
Sb.DropDownItem.registerClass("Sb.DropDownItem", Sb.DataControl);


Sb.DropDown = function(element)
{
	Sb.DropDown.initializeBase(this, [element]);
}
Sb.DropDown.prototype =
{
	onDataBinding: function()
	{
		var dataSource = this.get_dataSource();
		if ((!dataSource) || (!Array.isInstanceOfType(dataSource)))
		{
			return;
		}
		
		var settings = this.get_settings();
		if (!settings.panel)
		{
			return;
		}
		
		var id = this.get_id();
		var itemsHtml = "";
		Array.forEach(dataSource, function(item, index)
		{
			var itemElement = window.document.createElement("div");
			itemElement.setAttribute("id", id + "_item" + index);
			itemElement.setAttribute("class", settings.itemClassNormal);
			settings.panel.appendChild(itemElement);
			
			var itemControl = new Sb.DropDownItem(itemElement);
			itemControl.initialize({
				classNormal: settings.itemClassNormal,
				classOver: settings.itemClassOver,
				classSelected: settings.itemClassSelected
			});
			this.addControl(itemControl);
			itemControl.add_click(Function.createDelegate(this, this.itemClick));
			itemControl.set_dataSource({ value: item.value, label: item.label });
		
		}, this);
		
		this.onSelectedValueChanged();
		
		Sb.DropDown.callBaseMethod(this, "onDataBinding");
	},
	
	itemClick: function(sender, e)
	{
		var settings = this.get_settings();

		if (Sb.DropDownItem.isInstanceOfType(sender))
		{
			this.set_selectedValue(sender.get_value());
		}
		else
		{
			this.set_selectedValue("");
		}

		if (settings.postback && settings.postback.href)
		{
			var call = settings.postback.href.replace("javascript:", "");
			eval(call);
		}
		
	},
	
	get_labelText: function()
	{
		var settings = this.get_settings();
		return (settings.label) ? settings.label.innerHTML : "";
	},
	
	set_labelText: function(labelText)
	{
		var settings = this.get_settings();
		if (settings.label)
		{
			settings.label.innerHTML = labelText;
		}
	},
	
	get_selectedValue: function()
	{
		var settings = this.get_settings();
		return (settings.valueField) ? settings.valueField.value : "";
	},
	
	onSelectedValueChanged: function()
	{
		var settings = this.get_settings();
		if (settings.valueField)
		{
			var controls = this.get_controls();
			Array.forEach(controls, function(item)
			{
				if (Sb.DropDownItem.isInstanceOfType(item))
				{
					var isSelected = (settings.valueField.value == item.get_value());
					item.set_isSelected(isSelected);
					if (isSelected)
					{
						this.set_labelText(item.get_label());
					}
					
				}
			
			}, this);
			
		}
	},
	
	set_selectedValue: function(value)
	{
		var settings = this.get_settings();
		if (settings.valueField)
		{
			settings.valueField.value = value;
			this.onSelectedValueChanged();
		}
	}
	
}
Sb.DropDown.registerClass("Sb.DropDown", Sb.DataControl);


Sb.getWindowSize = function()
{
	if (window.innerWidth)
	{
		return {
			width: window.innerWidth,
			height: window.innerHeight
		};
	}
	else if (window.document.documentElement && window.document.documentElement.clientWidth)
	{
		return {
			width: window.document.documentElement.clientWidth,
			height: window.document.documentElement.clientHeight
		};
	}
	else if (window.document.body)
	{
		return {
			width: window.document.body.clientWidth,
			height: window.document.body.clientWidth
		};
	}
	else
	{
		return null;
	}
}



Sb.FloatingPanel = function(element)
{
	Sb.FloatingPanel.initializeBase(this, [element]);
	
}
Sb.FloatingPanel.clickName = "click";
Sb.FloatingPanel.okEventName = "ok";
Sb.FloatingPanel.cancelEventName = "cancel";
Sb.FloatingPanel.closeEventName = "close";
Sb.FloatingPanel.activePanels = [ ];
Sb.FloatingPanel.hideAll = function()
{
	Array.forEach(Sb.FloatingPanel.activePanels, function(item)
	{
		item.set_visible(false);
		
	}, null);
}
Sb.FloatingPanel.setActivePanel = function(panel)
{
	if (!Array.contains(Sb.FloatingPanel.activePanels, panel))
	{
		Array.add(Sb.FloatingPanel.activePanels, panel);
	}
	
	Array.forEach(Sb.FloatingPanel.activePanels, function(item)
	{
		item.set_visible(item == panel);

	}, null);

}
Sb.FloatingPanel.getLocation = function(domEvent, panelBounds)
{
	var location = { x: 0, y: 0 };
	
	var targetBounds = Sys.UI.DomElement.getLocation(domEvent.target);
	location.x = targetBounds.x + domEvent.offsetX;
	location.y = targetBounds.y + domEvent.offsetY;

	if (window.browserInfo.isIE && domEvent.target.offsetLeft && domEvent.target.offsetTop)
	{
		location.x -= domEvent.target.offsetLeft;
		location.y -= domEvent.target.offsetTop;
	}

	var windowSize = Sb.getWindowSize();
	if (windowSize)
	{
		if ((location.x + panelBounds.width) > windowSize.width)
		{
			location.x = location.x - panelBounds.width;
		}
	 
		if ((location.y + panelBounds.height) > windowSize.height)
		{
			location.y = location.y - panelBounds.height - 5;
		}
	}

	return location;
}
Sb.FloatingPanel.prototype =
{
	onInit: function()
	{
		this.set_visibilityMode(Sys.UI.VisibilityMode.hide);
		
		var initObject = this.get_settings();
	
		if (initObject.okButton)
		{
			var okButton = $get(initObject.okButton);
			if (okButton)
			{
				$addHandler(okButton, Sb.FloatingPanel.clickName, Function.createDelegate(this, this.okClick));
			}
		}
		
		if (initObject.cancelButton)
		{
			var cancelButton = $get(initObject.cancelButton);
			if (cancelButton)
			{
				$addHandler(cancelButton, Sb.FloatingPanel.clickName, Function.createDelegate(this, this.onCancelClick));
			}
		}
		
		if (initObject.closeButton)
		{
			var closeButton = $get(initObject.closeButton);
			if (closeButton)
			{	
				$addHandler(closeButton, Sb.FloatingPanel.clickName, Function.createDelegate(this, this.onCloseClick));
			}
		}
		
		Sb.FloatingPanel.callBaseMethod(this, "onInit");
		
	},
	
	onOkHide: function()
	{
		this.set_visible(false);
	},
	
	onOkClick: function () { },
	
	okClick: function()
	{
		try
		{
			this.onOkHide();
			this.onOkClick();

			var e = new Sys.EventArgs();
			this.raiseControlEvent(Sb.FloatingPanel.okEventName, e);
			
		}
		catch (exception)
		{
			window.errorManager.handleException(exception);
		}
		
	},
	
	add_ok: function(handler)
	{
		var events = this.get_events();
		events.addHandler(Sb.FloatingPanel.okEventName, handler);
	},
	
	remove_ok: function(handler)
	{
		var events = this.get_events();
		events.removeHandler(Sb.FloatingPanel.okEventName, handler);
	},
	
	onCancelClick: function()
	{
		try
		{
			this.set_visible(false);
			
			var e = new Sys.EventArgs();
			this.raiseControlEvent(Sb.FloatingPanel.cancelEventName, e);
			
		}
		catch (exception)
		{
			window.errorManager.handleException(exception);
		}
		
	},
	
	add_cancel: function(handler)
	{
		var events = this.get_events();
		events.addHandler(Sb.FloatingPanel.cancelEventName, handler);
	},
	
	remove_cancel: function(handler)
	{
		var events = this.get_events();
		events.removeHandler(Sb.FloatingPanel.cancelEventName, handler);
	},
	
	onCloseClick: function()
	{
		try
		{
			this.set_visible(false);
			
			var e = new Sys.EventArgs();
			this.raiseControlEvent(Sb.FloatingPanel.closeEventName, e);
			
		}
		catch (exception)
		{
			window.errorManager.handleException(exception);
		}

	},
	
	add_close: function(handler)
	{
		var events = this.get_events();
		events.addHandler(Sb.FloatingPanel.closeEventName, handler);
	},
	
	remove_close: function(handler)
	{
		var events = this.get_events();
		events.removeHandler(Sb.FloatingPanel.closeEventName, handler);
	},
	
	display: function(domEvent)
	{
		var location = Sb.FloatingPanel.getLocation(domEvent, Sys.UI.DomElement.getBounds(this.get_element()));
		var element = this.get_element();
		Sys.UI.DomElement.setLocation(element, location.x, location.y);
		Sb.FloatingPanel.setActivePanel(this);
	},
	
	get_visible: function()
	{
		var element = this.get_element();
		return ((!element.style.visibility) || (element.style.visibility != "hidden"));
	},
	
	set_visible: function(value)
	{
		var element = this.get_element();
		element.style.visibility = (value) ? "visible" : "hidden";
	},
	
	get_title: function()
	{
		if (!this.titleElementRead)
		{
			var settings = this.get_settings();
			this.titleElement = (settings.titleElement) ?
				$get(settings.titleElement) : null;
			
			this.titleElementRead = true;
		}
		
		return (this.titleElement) ? this.titleElement.innerHTML : null;
	},
	
	set_title: function(title)
	{
		if (!this.titleElementRead)
		{
			var settings = this.get_settings();
			this.titleElement = (settings.titleElement) ?
				$get(settings.titleElement) : null;
			
			this.titleElementRead = true;
		}
		
		if (this.titleElement)
		{
			this.titleElement.innerHTML = title;
		}
	}

}
Sb.FloatingPanel.registerClass("Sb.FloatingPanel", Sb.DataControl);



Sb.togglePanelCollapse = function(id)
{
	var panel = $get(id);
	if (panel && panel.style)
	{
		panel.style.display = (panel.style.display && (panel.style.display == "none")) ?
			"" : "none";
	}
}



Sb.DependencyCheckBox = function(element)
{
	Sb.DependencyCheckBox.initializeBase(this, [element]);
}
Sb.DependencyCheckBox.prototype =
{
	onInit: function()
	{
		var element = this.get_element();
		$addHandler(element, "click", Function.createDelegate(this, this.checkedChanged));
	},
	
	checkedChanged: function()
	{
		var element = this.get_element();
		var settings = this.get_settings();
		
		if (settings.checked && Array.isInstanceOfType(settings.checked))
		{
			Array.forEach(settings.checked, function(item)
			{
				var control = (Function.isInstanceOfType(item)) ? item() : item;
				control.checked = element.checked;
			});
		}
			
		if (settings.unchecked && Array.isInstanceOfType(settings.unchecked))
		{
			Array.forEach(settings.unchecked, function(item)
			{
				var control = (Function.isInstanceOfType(item)) ? item() : item;
				control.checked = (!element.checked);
			});
		}
		
		if (settings.enabled && Array.isInstanceOfType(settings.enabled))
		{	
			Array.forEach(settings.enabled, function(item)
			{
				var control = (Function.isInstanceOfType(item)) ? item() : item;
				if (control.set_isDisabled)
				{
					control.set_isDisabled(!element.checked);
				}
				else
				{
					control.disabled = (!element.checked);
				}
			});
		}
		
		if (settings.disabled && Array.isInstanceOfType(settings.disabled))
		{	
			Array.forEach(settings.disabled, function(item)
			{
				var control = (Function.isInstanceOfType(item)) ? item() : item;
				if (control.set_disabled)
				{
					control.set_disabled(element.checked);
				}
				else
				{
					control.disabled = element.checked;
				}
			});
		}
		
		if (settings.delegates && Array.isInstanceOfType(settings.delegates))
		{	
			Array.forEach(settings.delegates, function(item)
			{
				item();
			});
		}
	}
}
Sb.DependencyCheckBox.registerClass("Sb.DependencyCheckBox", Sb.DataControl);



Sb.TextBox = function(element)
{
	Sb.TextBox.initializeBase(this, [element]);
}
Sb.TextBox.prototype =
{
	get_isDisabled: function()
	{
		var settings = this.get_settings();
		return settings.isDisabled;
	},
	
	set_isDisabled: function(isDisabled)
	{
		var settings = this.get_settings();
		settings.isDisabled = isDisabled;
		
		Array.forEach(this.targetSettings, function(target)
		{
			target.targetElement.disabled = isDisabled;
		});
	},
	
	elementOver: function()
	{
		if (!this.get_isDisabled())
		{
			Sb.TextBox.callBaseMethod(this, "elementOver");
		}
	},
	
	elementOut: function()
	{
		if (!this.get_isDisabled())
		{
			Sb.TextBox.callBaseMethod(this, "elementOut");
		}
	},
	
	elementFocus: function()
	{
		if (!this.get_isDisabled())
		{
			Sb.TextBox.callBaseMethod(this, "elementFocus");
		}
	},
	
	elementBlur: function()
	{
		if (!this.get_isDisabled())
		{
			Sb.TextBox.callBaseMethod(this, "elementBlur");
		}
	}
}
Sb.TextBox.registerClass("Sb.TextBox", Sb.MultiTargetControl);



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