javascript

Chapter 18: Advanced Techniques
Custom events using the EventTarget type can then be used as follows:
function handleMessage(event){
alert(“Message received: “ + event.message);
}
//create a new object
var target = new EventTarget();
//add an event handler
target.addHandler(“message”, handleMessage);
//fire the event
target.fire({ type: “message”, message: “Hello world!”});
//remove the handler
target.removeHandler(“message”, handleMessage);
//try again - there should be no handler
target.fire({ type: “message”, message: “Hello world!”});
In this code, the handleMessage() function is defined to handle a message event. It accepts the event
object and outputs the message property. The target object ’ s addHandler() method is called, passing
in ” message ” and the handleMessage() function. On the next line, fire() is called with an object
literal containing two properties: type and message . This calls the event handlers for the message event
so an alert will be displayed (from handleMessage() ). The event handler is then removed so that when
the event is fired again, no alert will be displayed.
Because this functionality is encapsulated in a custom type, other objects can inherit this behavior by
inheriting from EventTarget , as in this example:
function Person(name, age){
EventTarget.call(this);
this.name = name;
this.age = age;
}
inheritPrototype(Person,EventTarget);
Person.prototype.say = function(message){
this.fire({type: “message”, message: message});
};
The Person type uses parasitic combination inheritance (see Chapter 6 ) to inherit from EventTarget .
Whenever the say() method is called, an event is fired with the details of a message. It ’ s common for
the fire() method to be called during other methods of a type, and quite uncommon for it to be called
publicly. This code can then be used as follows:
function handleMessage(event){
alert(event.target.name + “ says: “ + event.message);
}
//create new person
608