// Compatibility shim for legacy framework


var BindingsVersion = RuntimeVersion = $Version;

new function()
{
	var O = Object;
	var B = $Binding;
	var R = $Request;
	var N = $Network;

	if (typeof(Web)!="undefined" && Web.Runtime && Web.Runtime.BaseUrl)
	{
		$Config.baseUrl = Web.Runtime.BaseUrl;
	}

	
	Web = 
	{
		Debug : $Debug,
		Memory : $Memory,
		Browser: $Browser,
		Dom : 
		{
			getElementsByCssSelector : $Dom.Css.getElementsByCssSelector,
			getAnyElementByTagName : $Dom.getAnyElementByTagName
		},
		Enum : 
		{
			create : function()
			{
				return $Enum.apply(new $Enum(),arguments);
			},
			extend : function(p_srcEnum,p_addEnum)
			{
				if (!p_srcEnum) p_srcEnum = new $Enum();
				return p_srcEnum.extend(p_addEnum);
			},
			getValue : function(p_enumType, p_str)
			{
				return p_enumType.parse(p_str);
			}
		},
		Flags : 
		{
			create : function()
			{
				return $Flags.apply(new $Flags(),arguments);
			}
		},
		StringBuilder : $StringBuilder,
		Event : $Event,
		Conversion : 
		{
			coerceInt : Number.coerceInt,
			coerceFloat :Number.coerceFloat
		},
		Type :
		{
			resolve: O.resolve,
			compare: O.compare,
			isString: O.isString,
			isArray: O.isArray,
			isFunction : O.isFunction,
			isObject : O.isObject,
			isBoolean : O.isBoolean,
			isNumber : O.isNumber
		},
		Runtime :
		{
			culture : $Config.culture,
			oninit : null, // to do
			onunload : $Runtime.onunload,
			init : function()
			{
    			Web.Runtime._readyState = Web.Runtime.readyStateType.Init;
				if (Web && Web.Runtime.BaseUrl)
				{
					$Config.baseUrl = Web.Runtime.BaseUrl;
				}		
				$Binding.parse();
    			Web.Runtime._readyState = Web.Runtime.readyStateType.InitComplete;
			},
			MaxThreadLock : $Task.Scheduler.lock,
			readyStateType : new $Enum("Uninitialized","Init", "InitComplete")
		},
		Utility : 
		{
			extractHost :  R.extractHost,
			resolveUrl : R.resolveUrl,
			Prioritizer : Array.$Prioritizer,
			loadSources : function(p_astrSources, p_astrStyles, p_astrXml, p_astrImages, p_ePriority, p_fncAsyncCallback, p_objContext)
			{
                new N(p_ePriority,p_objContext).add(N.Type.Script,p_astrSources).add(N.Type.CSS,p_astrStyles).add(N.Type.Image,p_astrImages).add(N.Type.XML,p_astrXml).load(p_fncAsyncCallback);
			}
		},
		Network:
		{
			_streamUpdate : N._streamUpdate,
			registerProxy : N.Proxy._registerProxy,
			abortGroup : N.abortGroup,
			createRequest : function(p_enumNetworkType, p_strUrl, p_objContext, p_fnCallback, p_enumPriority, p_strPostArgs, p_objHeaders,p_enumFlags,p_intTimeout,p_strTag,p_blnProxy,p_objAuth)
			{		
				var flags = p_enumFlags;
				if (p_blnProxy)
					flags = flags | N.Flags.CLIENTPROXY;	
								
				var obj = {};
				var n;
				
				function cb(o,c)
				{
					if (p_fnCallback)
					{
						p_fnCallback(o[0].resource,p_objContext);
					}
				}
				obj.abort = function()
				{
					if (n)
						n.abort();
				}
				
				obj.isExecuting = function()
				{
					return (n && n.isExecuting);
				}
				
				obj.execute = function()
				{
					n = new N(p_enumPriority,p_objContext,[new R(p_strUrl,p_enumNetworkType,flags,p_objContext).setHeaders(p_objHeaders).setPostString(p_strPostArgs).setGroup(p_strTag).setTimeout(p_intTimeout).setObject(p_objContext && p_objContext.pool)])
					n.load(cb);
				}
				return obj;
			},
			createBatch : function(p_enumPriority,p_objContext)
			{
				var n = new N(p_enumPriority,p_objContext);
				
				var obj = {};
				obj.abort = function()
				{
					n.abort();
				}
				
				obj.execute = function(p_fnCallback)
				{
					n.load(p_fnCallback);
				}
				
				obj.add = function(p_enumNetworkType,p_strUrl,	p_objContext, p_strPostArgs,p_objHeaders,p_enumFlags, p_blnProxy, p_intTimeout)
				{
					var flags = p_enumFlags;
					if (p_blnProxy)
						flags = flags | N.Flags.CLIENTPROXY;
						
					n.add(p_enumNetworkType, new R(p_strUrl,p_enumNetworkType,flags,p_objContext).setHeaders(p_objHeaders).setPostString(p_strPostArgs).setTimeout(p_intTimeout).setObject(p_objContext && p_objContext.pool))
				}
				
				return obj;
			},
			Type : N.Type,
			registerScript : N.registerScript,
			RegisterBaseDomain : N.registerBaseDomain,
			onprofile : N.Events.onprofile,
			onrequest : N.Events.onrequest
		},
		Bindings :
		{
			Base : B,
			extendBinding : B.extend,
			revalidateBinding : B.validate,
			removeBindings : B.remove,
			attachElementBindingSync :  function(p_elItem, p_vBindingType, p_objScope, p_htParams, p_strNamespace)
			{
			    var fncType = O.resolve(p_vBindingType), objBinding = new fncType(p_elItem,p_htParams,p_strNamespace);
				objBinding.initialize(p_objScope);
				return objBinding;
		    },
			attachElementBinding : function(p_elItem, p_vBindingType, p_objScope, p_htParams, p_strNamespace, p_fncCallback, p_astrBindingSource, p_astrStyleSource, p_ePriority, p_astrXmlSource,p_astrImageSource)
			{
				function fLoad()
				{
					B.define(p_vBindingType,null,p_objScope).setDefaults(p_htParams).setNS(p_strNamespace).bindTo(p_elItem).attach(function(o) {p_fncCallback(o && o[0])});
				}
				if (!p_astrBindingSource && !p_astrStyleSource && !p_astrImageSource && !p_astrXmlSource)
				{
                    return Web.Bindings.attachElementBindingSync(p_elItem, p_vBindingType, p_objScope, p_htParams, p_strNamespace);
                }
                else
                {		
				    new N(p_ePriority).add(N.Type.Script,p_astrBindingSource).add(N.Type.CSS,p_astrStyleSource).add(N.Type.Image,p_astrImageSource).add(N.Type.XML,p_astrXmlSource).load(fLoad);
				}
		    },
			attachSelectorBindingSync : function(p_vSelector, p_vBindingType, p_objScope, p_htParams, p_strNamespace, p_elScope, p_fncCallback)
			{
				return B.define(p_vBindingType,p_elScope,p_objScope).setDefaults(p_htParams).setNS(p_strNamespace).bindCss(p_vSelector).attach(p_fncCallback);
			},
			attachSelectorBinding : function(p_vSelector, p_vBindingType, p_objScope, p_htParams, p_strNamespace, p_elScope, p_fncCallback, p_astrBindingSource, p_astrStyleSource, p_ePriority, p_astrXmlSource, p_astrImageSource)
			{
				var me =this;
				function fLoad()
				{	
					me.attachSelectorBindingSync(p_vSelector, p_vBindingType, p_objScope, p_htParams, p_strNamespace, p_elScope, p_fncCallback);
				}
				
				if (!p_astrBindingSource && !p_astrStyleSource && !p_astrImageSource && !p_astrXmlSource)
                    return Web.Bindings.attachSelectorBindingSync(p_vSelector, p_vBindingType, p_objScope, p_htParams, p_strNamespace, p_elScope, p_fncCallback);
                else				
				    new N(p_ePriority).add(N.Type.Script,p_astrBindingSource).add(N.Type.CSS,p_astrStyleSource).add(N.Type.Image,p_astrImageSource).add(N.Type.XML,p_astrXmlSource).load(fLoad)
			}

		},
		Accessibility : 
		{
			notify : $Accessibility.notify
		},
		Error : $Tracing.Error
	}
	Web.Event.create = function(b)
	{
		return(new $Event(b));
	}	
	
	Type = 
	{
	    createEnum : function()
	    {
	        var iLength = arguments.length, args = [];
	        for (var i=1;i<iLength;i++)
	            args.push(arguments[i]);
	        return $Flags.apply(new $Flags(),args);
	    },
	    createFlags : Web.Flags.create
	}
	
	$Event.prototype.clear = $Event.prototype.dispose;
	$Event.prototype.reset = function()
	{
	    this.isInvoked = false;
	};
	
	$Event.DOM.prototype.clear = $Event.DOM.prototype.dispose;

	
	Web.Utility.Prioritizer.Priorities =  Array.$Prioritizer.Priorities
	if (typeof(Live)=="undefined")
	{
		Live = {};
	}
		
	if(typeof($Config)!="undefined")
	{
	    var ct = $Config.Themes;
	    if(ct)
	    {
	        Live.Themes = 
	        {
	            CurrentTheme : ct.current,
				CurrentThemeVersion : ct.version,
				ThemeUrl : ct.url,
				BaseUrl : ct.baseUrl
	        }
	    }
	}
}

Web.Runtime._readyState = Web.Runtime.readyStateType.Uninitialized;

registerNamespace("Web.UI.Utilities");

Web.UI.Utilities.CleanupHelper = function()
{
    this.mgr = new $Memory.Groups();
}

Web.UI.Utilities.CleanupHelper.prototype = 
{
    initialize : function() {},
    dispose : function() {this.mgr.dispose()},
    disposeGroup : function(n) {this.mgr.create(n).dispose()},
    attachEvent : function(group,obj,evt,cb)
    {
        var o = {};
        o[evt] = cb;
        this.mgr.create(group).Events.register(obj,o);
    },
    detachEvent : function(obj,evt,cb) {obj.detachEvent(evt,cb)},
    initializeProperty : function(obj,group)
    {
        this.mgr.create(group).Properties.register(obj);
    },
    registerNode : function(node,group) {this.mgr.create(group).Nodes.register(node)},
    createNode : function(tag,properties,styles,parent,group)
    {
        return this.mgr.create(group).Nodes.create(tag,properties,styles,parent);
    },
    removeNodeGroup : function(group)
    {
        this.mgr.create(group).Nodes.dispose();
    }, 
    detachEventGroup : function(group)
    {
        this.mgr.create(group).Events.dispose();    
    },
    disposePropertyGroup : function(group)
    {
        this.mgr.create(group).Properties.dispose();    
    }    
}