silverna-packs.js

《JavaScript王者归来》examples.rar

	}
	catch(e){
		return null;
	}
}
Object.prototype.__setByNS__ = function(s, val, cf)
{
	var n = s.split(".");
	var o = this;
	for(var i = 0; i < n.length - 1; i++)
	{
		var t = n[i];
		var nt = n[i+1];

		if(parseInt(t).toString() == t)
		{
			t-=0;
		}
		if(o[t] == null) 
		{
			if(parseInt(nt).toString() == nt || nt == "[]")
				o[t] = [];
			else
				o[t] = {};
		}
		if(nt == "[]")				//设置数组，例如 a.[].b
		{
			var p = n[i+2];
			n[i+1] = o[t].length;
			if(p)
				for(var j = 0; j < o[t].length; j++)
				{
					if(!o[t][j][p])
					{
						n[i+1] = j;
						break;
					}
				}
		}		
		o = o[t];
	}
	if(cf && o[n[i]])	//cf决定是否允许ns重名，若允许重名将重名的作为数组
	{
		if(o[n[i]] instanceof Array)
			o[n[i]].push(val);
		else
			o[n[i]] = [o[n[i]],val];
	}
	else
		o[n[i]] = val;
	return val;
}
Object.prototype.__defer__ = function(method, delay, args){
	var $pointer = this;
	if(!(args instanceof Array))
		args = [args];
	if(typeof(method) == "string")
		method = $pointer[method];
	args = args || [];
    window.setTimeout(function(){
		return method.apply($pointer, args);
	}, delay);
}
Object.prototype.__extend__ = function(_typecall, evtArgs)
{
	evtArgs = evtArgs || [];
	_typecall.apply(this, evtArgs);
}
//用一个函数侦听某个provider的输出，以一定的时间间隔delay（毫秒）
//当provider返回true的时候，侦听继续下去
//当provider返回false的时候，侦听结束
Function.prototype.listen = function(provider, delay, args)
{
	var $pointer = this;
	if(!(args instanceof Array))
		args = [args];
	setTimeout(function(){
		if(provider.apply($pointer, args))
		{
			$pointer.apply(null, args);
			$pointer.listen(provider, delay, args);
		}
	},delay);
};
(function(){
	Object.prototype.__getter__ = function(propName, closure){
		this["get"+propName.slice(0,1).toUpperCase() + propName.slice(1)] = closure;
	}
	Object.prototype.__setter__ = function(propName, closure){
		this["set"+propName.slice(0,1).toUpperCase() + propName.slice(1)] = closure;
	}	
})();
//$函数，有几个用途：
//直接调用返回一个空的function(){}
//传入字符串,转换以该字符串为ID的DOM对象，传入其它对象直接返回
//传入多个字符串或对象，字符串转换为已该字符串为ID的DOM对象，其他对象不变，返回列表
function $(){
	var _args = Array.apply([], arguments);
		
	if(_args.length == 0)
		return $void;

	if(_args.length == 1)
	{
		var obj = $id(_args[0]) || _args[0];
		return obj;
	}

	return _args.each(function(obj){
		return $id(obj) || obj;
	});
}
//将包含有length属性的对象转换为一个ArrayList
//把实现了Iterator原型的对象转换为一个ArrayList
function $arr(obj)
{
	if(!obj) return [];
	if(obj.toArray) return obj.toArray();
	var _set = [];
	for(var i = 0; i < obj.length; i++)
		_set.push(obj[i]);
	return _set;	
}
function $id(id){
	return document.getElementById(id);
}
window.setByNS = Object.prototype.__setByNS__;
window.getByNS = Object.prototype.__getByNS__;

document.getNSById = function(id){
	return document.getNS(id);
}
document.getNS = function(o){
	var ret = {};
	for(var i = 0; i < arguments.length; i++)
	{
		var o = arguments[i];

		var value;
		if(typeof o == "string"){
			o = $id(o);
		}
		var ns = o.getAttribute("ns");
		if(ns == null) ns = o.id;
		value = $$(o).getValue();
		ret.__setByNS__(ns, value, true);
	}
	return ret;
}
document.getNSByName = function(name){
	var args = document.getElementsByName(name);
	return document.getNS.apply(this, $arr(args));
}
//declare Packs
//这里的声明非常重要，它为对象建立正确的名字空间，才能被with语句所支持
var core = {
	events : {
		EventManager:null
	},
	web : {
		widgets : 
			{
				adorners : {
					Adorner : null,
					ButtonAdorner : null,
					DragDropAdorner : null,
					DatePickerAdorner : null,
					MopCalendarAdorner : null,
					SliderAdorner : null,
					WindowAdorner : null,
					behaviors : {
						Behavior : null,
						ClickBehavior : null,
						DragBehavior : null,
						HoverBehavior : null,
						SelectBehavior : null
					}
				}, 
				Widget : null,
				ButtonWidget : null,
				DragDropWidget : null,
				DatePickerWidget : null,
				MopCalendarWidget : null,
				SliderWidget : null,
				WindowWidget : null
			},
		HTMLElement : null,
		CSSStyleSheet : null
	}
}

with(core.events)
{
	//原型：EventManager是一个重要的原型，它用来赋予对象自定义事件的能力
	//当对象类型的原型继承EventManager时，对象具有定义、分派和捕捉事件的能力
	//EventManager有四个重要的方法dispatchEvent、captureEvent、addEventListener和removeEventListener
	EventManager = function()
	{
		this.dispatchEvent = function(eventType, eventArgs)
		{
			eventArgs = eventArgs || {};
			var events = this["on"+eventType];
			var called = 0;

			if(events && typeof(events) == "function")
				events = [events];

			if(!eventArgs.type) eventArgs.type = eventType;
			//阻止默认动作的执行
			eventArgs.preventDefault = function()
			{
				eventArgs.defaultOp = null;
			}
			//阻止事件起泡
			eventArgs.stopPropagation = function()
			{
				eventArgs.cancelBubble = true;
			}
			var $pointer = this;
			if(events)
			{
				for(var i = 0; i < events.length; i++)
				{

					setTimeout(
						(function(i){
							var evt = events[i];
							var len = events.length;
							var capturer = events.capturer;
							var capturerName = events.capturerName;
							return	function(){
								called++;

								var ret = evt.call($pointer,eventArgs);
								//如果有捕获事件的方法，并且没有阻止事件气泡，在最后一个事件处理程序结束之后调用它
								if(!eventArgs.cancelBubble && called == len && capturer && capturerName && capturer[capturerName])
								{
									setTimeout(function(){
											capturer[capturerName](eventArgs)
										},1)
								}
								//如果定义了默认动作，在最后一个事件处理程序结束之后执行它
								if(called == len && eventArgs.defaultOp) 
								{
									eventArgs.defaultOp.call($pointer, eventArgs);
								}
								return ret;
							}
						})(i), 1
					);
				}
			}
			else if(eventArgs.defaultOp)
			{
				eventArgs.defaultOp.call($pointer, eventArgs);
			}
		}
		this.fireEvent = this.dispatchEvent;
		this.captureEvents = function(target, eventType, capturerName, closure)
		{
			if(capturerName instanceof Function)
			{
				closure = capturerName;
				capturerName = null;
			}
			capturerName = capturerName || "on" + eventType;
			target["on"+eventType] = target["on"+eventType] || [function(){}];
			var events = target["on"+eventType];
			if(typeof(events) == "function")
			{
				target["on"+eventType] = [events];
			}

			target["on"+eventType].capturer = this;
			target["on"+eventType].capturerName = capturerName;

			if(closure)
				this[capturerName] = closure;
		}

		this.addEventListener = function(eventType, closure)
		{
			if(this["on"+eventType] == null)
			{
				this["on"+eventType] = [];
			}
			var events = this["on"+eventType];
			if(events && typeof(events) == "function"){
				this["on"+eventType] = [events];		
				events = this["on"+eventType];
			}
			events.push(closure);
			return closure;
		}

		this.removeEventListener = function(eventType, closure)
		{
			var events = this["on"+eventType];
			if(events && typeof(events) == "function")
				events = [events];		
			
			for(var i = 0; i < events.length; i++)
			{
				if(events[i] == closure)
					events.splice(i, 1);
			}
			return closure;
		}
	}
}

if(typeof(HTMLElement)!="undefined" && !window.opera)
{
  HTMLElement.prototype.__defineGetter__("outerHTML",function()
  {
    var a=this.attributes, str="<"+this.tagName, i=0;for(;i<a.length;i++)
    if(a[i].specified) str+=" "+a[i].name+'="'+a[i].value+'"';
    if(!this.canHaveChildren) return str+" />";
    return str+">"+this.innerHTML+"</"+this.tagName+">";
  });
  HTMLElement.prototype.__defineSetter__("outerHTML",function(s)
  {
    var r = this.ownerDocument.createRange();
    r.setStartBefore(this);
    var df = r.createContextualFragment(s);
    this.parentNode.replaceChild(df, this);
    return s;
  });
  HTMLElement.prototype.__defineGetter__("innerText",function()
  {
		return this.textContent;
  });
  HTMLElement.prototype.__defineSetter__("innerText",function(s)
  {
    this.textContent = s;
    return s;
  });
  HTMLElement.prototype.__defineGetter__("canHaveChildren",function()
  {
    return !/^(area|base|basefont|col|frame|hr|img|br|input|isindex|link|meta|param)$/.test(this.tagName.toLowerCase());
  });
}

with(core.web)
{
	//扩展DOM，具有兼容性的HTMLElement类型
	HTMLElement = function(domObj)
	{
		this.el = domObj;
	}

	HTMLElement._floatZIndex = 1000;
	
	HTMLElement.prototype.focus = function()
	{
		this.el.style.zIndex = HTMLElement._floatZIndex;
		HTMLElement._floatZIndex += 10;
	}
	HTMLElement.prototype.blur = function()
	{
		this.el.style.zIndex = 0;
	}
	HTMLElement.prototype.setAttribute = function(propName, value)
	{
		//this.el[propName] = value;
		return this.el.setAttribute(propName, value);
	}
	HTMLElement.prototype.getAttribute = function(propName)
	{
		return this.el.getAttribute(propName);
	}

	HTMLElement.prototype.setStyleRule = function(className,rules)
	{
		if(!rules)
			this.el.className = className;
		else
			this.el.style[className] = rules;
	}

	HTMLElement.prototype.setStyleRuleText = function(ruleText)
	{
		this.el.style.cssText = ruleText;
	}	

	HTMLElement.prototype.setText = function(text)
	{
		if(/^(input)|(select)|(textarea)$/i.test(this.el.tagName))
			this.el.value = text;
		else
			this.el.innerText = text;
	}

	HTMLElement.prototype.addEventListener = function(evtType, evtHandler, capturing, owner, userArgs)
	{
		var $pointer = owner || this;
		var $handler;
		capturing = capturing || false;

		if(this.el.attachEvent)
		{
			$handler = function()
			{	
				var evt = window.event;
				if(userArgs)
				{
					for(var each in userArgs)
					{
						evt[each] = userArgs[each];
					}
				}

				evt.target = evt.srcElement;
				evt.relatedTarget = evt.fromElement || evt.toElement;
				evt.leftButton = function(){return evt.button == 1};
				evt.rightButton = function(){return evt.button == 2};
				evt.layerX = evt.offsetX;
				evt.layerY = evt.offsetY;
				evt.pageX = evt.clientX - document.body.scrollLeft - document.body.clientLeft;
				evt.pageY = evt.clientY - document.body.scrollTop - document.body.clientTop;

				evt.attrName = evt.propertyName;

				return evtHandler.call($pointer,evt)
			};
			this.el.attachEvent("on"+evtType, $handler);
		}
		else if(this.el.addEventListener)
		{
			Event.prototype.leftButton = function(){return this.button == 0};
			Event.prototype.rightButton = function(){return this.button == 2};
			$handler = function(event){
				if(userArgs)
				{
					for(var each in userArgs)