Weblabor

<script>

Function.prototype.bind=function (o)
{
	var m=this;
	return function ()
	{
		return m.apply(o,arguments);
	}
};

window.setListener=function ()
{
	alert(this==window)
}.bind(window);
window.setListener();

</script>

Package(function ()
{	
	var events=Class.Singleton(
	{
		static_classes: 
		[
			Class.Create(
			{
				set: function (eventListeners,element)
				{
					element.events=eventListeners;
				},
				get: function (element)
				{
					return element.events;
				}
			}),
			Hash,
			Array
		],
		getEventConfig: function (element,name)
		{
			return events.getProperty([element,name,"eventConfig"]);
		},
		setEventConfig: function (element,name,eventConfig)
		{
			events.setProperty(eventConfig,[element,name,"eventConfig"]);
		},
		buildEventConfig: function (element,name)
		{
			var eventConfig=this.getEventConfig(element,name);
			if (!eventConfig)
			{
				var configTemplate=this.getEventConfig(HTMLElement,name);
				if (!configTemplate)
				{
					throw new Exception("Event called: element.on'"+name+"' doesn't exists.");
				}
				var eventConfig=Object.extend({element: element},configTemplate);
				this.setProperty(eventConfig,[element,name,"eventConfig"]);
			}
			if (!eventConfig.virtual)
			{
				if (is.Function(eventConfig.prepare))
				{
					eventConfig.prepare();
				}
				if (!eventConfig.context)
				{
					eventConfig.context=element;
				}
				if (!eventConfig.type)
				{
					eventConfig.type=name;
				}
			}
			return eventConfig;
		},
		getListeners: function (element,name)
		{
			return events.get([element,name]);
		},
		addListener: function (element,name,method)
		{
			this.set(method,[element,name,-1]);
		},
		removeListener: function (element,name,method)
		{
			this.remove(this.find(function (listener)
			{
				return listener===method;
			},this,[element,name]));
		},
		createEvents: function (element,source)
		{
			Object.toHash(source).each(function (eventClass,name)
			{
				var eventConfig=
				{
					name: name,
					eventClass: eventClass,
					checkBefore: eventClass.checkBefore,
					checkAfter: eventClass.checkAfter,
					prepare: eventClass.prepare,
					virtual: eventClass.virtual
				};
				events.setEventConfig(element,name,eventConfig);
			});
		}
	},Tree);


	var HTMLEventInterface=
	{
		setListener: function (name,method)
		{
			var element=this;
			if (!is.Function(method))
			{
				return method;
			}
			var eventConfig=events.buildEventConfig(element,name);
			if (!eventConfig.controller)
			{
				var checkBefore=eventConfig.checkBefore,
					eventClass=eventConfig.eventClass,
					checkAfter=eventConfig.checkAfter,
					virtual=eventConfig.virtual,
					context=eventConfig.context,
					type=eventConfig.type;
				
				var controller=function (eventSource)
				{
					var listeners=events.getListeners(element,name);
					if (!listeners || !listeners.length)
					{
						return;
					}
					if (!BrowserFeatures.HTMLElement && !eventSource)
					{
						eventSource=window.event;
					}
					if (is.Function(checkBefore) && !checkBefore.call(element,eventSource))
					{
						return;
					}
					var eventObject=is.Instance(eventSource,CustomEvent)
						?eventSource //by triggerEvent
						:new eventClass(element,name,eventSource); //by normal event handling
					if (is.Function(checkAfter) && !checkAfter.call(element,eventObject))
					{
						return;
					}
					listeners.invoke(function ()
					{
						this.call(element,eventObject);
					});
				};
				eventConfig.controller=controller;
				if (!virtual)
				{
					if (BrowserFeatures.HTMLElement)
					{
						context.addEventListener(type,controller,false);
					}
					else
					{
						context.attachEvent("on"+eventConfig.type,controller);
					}
				}
			}
			events.addListener(element,name,method);
			return element;
		},
		removeListener: function (name,method)
		{
			var element=this;
			events.removeListener(element,name,method);
			return element;
		},
		createEvent: function (name,settings)
		{
			var element=this;
			if (!settings)
			{
				settings={};
			}
			var eventClass=is.Function(settings.initialize)
				?Class.Create(
				{
					initialize: settings.initialize	//function (element,name,eventSource), this=eventObject
				}).Extends(CustomEvent)
				:CustomEvent;
			var eventConfig=
			{
				name: name,
				eventClass: eventClass,
				checkBefore: settings.checkBefore, //function (), this=element -> true/false
				checkAfter: settings.checkAfter, //function (eventObject), this=element -> true/false
				prepare: settings.prepare, //function (), this=eventConfig; rewrites eventConfig.type &| eventConfig.context
				virtual: is.Null(settings.virtual)?true:settings.virtual //boolean, if true, then event can be triggered just manually
			};
			events.setEventConfig(element,name,eventConfig);
			return element;
		},
		triggerEvent: function (name,eventSource)
		{
			var element=this;
			var eventConfig=events.getEventConfig(element,name);
			if (eventConfig && is.Function(eventConfig.controller))
			{
				var eventObject=new CustomEvent(element,name,eventSource || {});
				eventConfig.controller(eventObject);
			}
			return element;
		}
	};
	
	var Event=Class.Create(
	{
		initialize: function (element,name,eventSource)
		{
			this.type=name;
			this.target=element;
			this.preventDefault=BrowserFeatures.HTMLElement
				?function ()
				{
					if (eventSource.preventDefault)
					{
						eventSource.preventDefault();
					}
				}
				:function ()
				{
					eventSource.returnValue=false;
				};
			this.stopPropagation=BrowserFeatures.HTMLElement
				?function ()
				{
					if (eventSource.stopPropagation)
					{
						eventSource.stopPropagation();
					}
				}
				:function ()
				{
					eventSource.cancelBubble=true;
				};
		},
		static_virtual: false
	});
	
	var CustomEvent=Class.Create(
	{
		initialize: function (element,name,eventSource)
		{
			this.type=name;
			this.target=element;
			Object.extend(this,eventSource);
		},
		static_virtual: true
	}).Extends(Event);
	
	
	var UIEvent=Class.Create().Extends(Event);
	
	var TextEvent=Class.Create(
	{
		static_prepare: function ()
		{
			if (!BrowserFeatures.HTMLElement)
			{
				this.type="propertychange";
			}
		},
		static_checkBefore: function (eventSource)
		{
			return (BrowserFeatures.HTMLElement?true:eventSource.propertyName==="value") || is.Instance(eventSource,CustomEvent);
		}
	}).Extends(Event);
	
	var KeyboardEvent=Class.Create(
	{
		initialize: function (element,name,eventSource)
		{
			this.parent.initialize.apply(this,arguments);
			this.which=eventSource.which || eventSource.charCode || eventSource.keyCode || 0;
		}
	}).Extends(Event);
	
	var MouseEvent=Class.Create(
	{
		initialize: function (element,name,eventSource)
		{
			this.parent.initialize.apply(this,arguments);
			if (this.type=="mouseover" || this.type=="mouseout")
			{
				this.relatedTarget=BrowserFeatures.HTMLElement
					?eventSource.relatedTarget
					:this.type=="mouseover"
						?eventSource.fromElement
						:eventSource.toElement;
			}
			if (BrowserFeatures.HTMLElement)
			{
				this.layerX=eventSource.layerX;
				this.layerY=eventSource.layerX;
				this.pageX=eventSource.pageX;
				this.pageY=eventSource.pageY;
			}
			else
			{
				this.layerX=eventSource.offsetX;
				this.layerY=eventSource.offsetY;
				this.pageX=eventSource.clientX+(document.documentElement && document.documentElement.scrollLeft || document.body && document.body.scrollLeft || 0)-(document.documentElement.clientLeft || 0);
				this.pageY=eventSource.clientY+(document.documentElement && document.documentElement.scrollTop || document.body && document.body.scrollTop || 0)-(document.documentElement.clientTop || 0);
			}
			switch (this.type)
			{
				case "click":
				case "dblclick":
				case "mousedown":
				case "mouseup":
					this.which=(BrowserFeatures.HTMLElement?eventSource.which:eventSource.button)==1
						?1
						:2;//too many browser differences in code by right,middle buttons
			}
		},
		static_checkAfter: function (eventObject)
		{
			//fixes mouseover-mouseout bubbling bug:
				//if you set a listener to an element's onmouseover, 
					//and you move the cursor on the child of the element, 
						//then it will cause a fast mouseout and re-mouseover event
			return !(this.relatedTarget && (this.relatedTarget.isAncestor(element) || this.target.isAncestor(element)));
		}
	}).Extends(Event);
	
	var MouseMultiWheelEvent=Class.Create().Extends(Event);
	
	var MouseWheelEvent=Class.Create(
	{
		static_prepare: function ()
		{
			if (BrowserFeatures.XUL)
			{
				this.type="DOMMouseScroll";
			}
		},
		initialize: function (element,name,eventSource)
		{
			this.parent.initialize.apply(this,arguments);
			this.delta=is.Number(eventSource.wheelDelta)
				?Math.sgn(eventSource.wheelDelta*-1)
				:Math.sgn(eventSource.detail);
		}
	}).Extends(Event);
	
	var MutationEvent=Class.Create().Extends(Event);
	
	var MutationNameEvent=Class.Create(
		//DOMNodeInserted: MutationEvent
		//DOMAttrModified: MutationEvent
		
		//DOMElementNameChanged: MutationNameEvent
		//DOMAttributeNameChanged: MutationNameEvent
	).Extends(Event);
	
	var HTMLEvents=
	{
		load: UIEvent,
		focus: UIEvent,
		blur: UIEvent,
		load: UIEvent,
		unload: UIEvent,
		beforeunload: UIEvent,
		abort: UIEvent,
		error: UIEvent,
		select: UIEvent,
		change: UIEvent,
		submit: UIEvent,
		reset: UIEvent,
		resize: UIEvent,
		scroll: UIEvent,
		//contextmenu: UIEvent,
		
		input: TextEvent,
		
		mouseover: MouseEvent,
		mouseout: MouseEvent,
		mousemove: MouseEvent,
		mousedown: MouseEvent,
		mouseup: MouseEvent,
		click: MouseEvent,
		dblclick: MouseEvent,
		
		
		keydown: KeyboardEvent,
		keyup: KeyboardEvent,
		keypress: KeyboardEvent,
		
		mousewheel: MouseWheelEvent,
		
		mousemultiwheel: MouseMultiWheelEvent
	};
		
	HTMLElement.Implements(HTMLEventInterface);
	//összes elementhez hozzáadja az interface-t
	HTMLElement.createEvent=HTMLEventInterface.createEvent;
	//lehetőség arra, hogy új, összes elementre vonatkozó eseményt hozzunk létre

	events.createEvents(HTMLElement,HTMLEvents);
	//alap események hozzáadása az összes elementhez
	
	Object.implement(window,HTMLEventInterface);
	
	events.createEvents(window,
	{
		load: Class.Create(
		{
			prepare: function ()
			{
				if (BrowserFeatures.HTMLElement)
				{
					if (BrowserFeatures.XUL)
					{
						//firefox
						this.type="DOMContentLoaded";
					}
					//safari,opera,chrome
				}
				else
				{
					//internet explorer
					this.type="readystatechange";
					this.context=document;
				}
			},
			checkBefore: function ()
			{
				return BrowserFeatures.HTMLElement?true:document.readyState=="complete";
			}
		}).Extends(UIEvent)
	});
	
	if (!BrowserFeatures.HTMLElement)
	{
		window.setListener("load",function ()
		{
			HTMLElement.__applyChanges();
		});
	}
	
	$.HTMLEventInterface=HTMLEventInterface;
});

Package(function (){...});
//ez gyakorlatilag az alábbinak felel meg
(function ()
{
...
})();

Class.Create({...}); //új osztály létrehozása, kibővíti az osztályt függvénnyekkel
$class.Extends(parentClass); //mint más nyelvekben az extends
$class.Implements({...}); //interface-t illeszt az osztályra
Class.Singleton({...},parentClass); //singleton class-t hoz létre, és egyből példányosítja

var a=Class.Create({
    static_property: 123,
    initialize: function (){alert("új példány")},
    property: 5
});
alert(a.property); //123
var b=new a(); //új példány
alert(b.property); //5

BrowserFeatures.HTMLElement -> van e HTMLElement alapból (ie-nél nincs)
BrowserFeatures.XUL -> XUL controllerek vannak e (ff-nél van csak)

element.setListener(name,method); //eseménykezelő hozzáadása
element.removeListener(name,method); //eseménykezelő elvétele
element.createEvent(settings); //saját eseménytípus hozzáadása
element.triggerEvent(name,eventObject); //esemény kiváltása