dev.enekoalonso.com » mootools

Mooml 1.2.3 – Bye, bye, with()

Eneko Alonso — Thu, 29 Apr 2010 04:26:54 +0000

Mooml 1.1 was the first version of Mooml that didn’t rely on eval(), a javascript function that causes lot’s of problems when not used properly, but that also prevent minimizers and compilers like Closure to generate valid code.

The new Mooml 1.2.3 release also gets rid of with(), which will no longer be used to render Mooml templates. Instead, templates are prepared when they get registered, so all template tag functions (div(), span(), p()) get replaced by calls to the Mooml engine. Although this means there will be a performance hit when registering templates, it also means templates will render faster. As a plus, template parameter names will no longer conflict with template tag function names. Thus, you can now have a template with a parameter named ‘div’ and the template wont fail rendering.

Download: http://mootools.net/forge/p/mooml
Source: http://github.com/eneko/mooml

March 15, 2010 -- More updates to Mooml coming soon (0)
March 24, 2010 -- Mooml 1.1 – No more eval(), say Hi to Mooml.Template and Mooml.Templates (0)
February 19, 2010 -- Having fun with Mooml & Twitter (0)
February 1, 2010 -- Mooml.globalize(): Mooml template functions going global (0)

Getting unique timestamps in Javascript

Eneko Alonso — Wed, 14 Apr 2010 18:16:18 +0000

Sometimes, when you want to generate unique id’s or similar, it is very common to use the current date as unix timestamp (new Date().getTime() or $time() in Mootools). The problem is that if we get the current timestamp multiple times too fast, it may happen that we get exactly the same value. Actually, this will happen very easily, as this tests shows:

var times = [];
while (times.length < 20) {
times.push(new Date().getTime());
}
console.log(times);
// All timestamps returned would be pretty much the same

To prevent this, we can use this little function which ensures we get a unique timestamp every time we call it:

// Mootools
function getUniqueTime() {
var time = $time();
while (time == $time());
return $time();
}
// Javascript generic
function getUniqueTime() {
var time = new Date().getTime();
while (time == new Date().getTime());
return new Date().getTime();
}

Test it in Firebug:

function getUniqueTime() {
var time = new Date().getTime();
while (time == new Date().getTime());
return new Date().getTime();
}
var times = [];
while (times.length < 20) {
times.push(getUniqueTime());
}
console.log(times);
// Now all timestamps are unique

Nice, uh?

April 28, 2010 -- Mooml 1.2.3 – Bye, bye, with() (0)
March 24, 2010 -- Mooml 1.1 – No more eval(), say Hi to Mooml.Template and Mooml.Templates (0)
February 19, 2010 -- Having fun with Mooml & Twitter (0)
February 1, 2010 -- Mooml.globalize(): Mooml template functions going global (0)

Mooml 1.1 – No more eval(), say Hi to Mooml.Template and Mooml.Templates

Eneko Alonso — Wed, 24 Mar 2010 20:54:01 +0000

Mooml 1.1 has been finally released today and made available to everybody via Github and Mootools Forge plugin repository.

What is new in Mooml 1.1

Mooml 1.1 has a lot of new features, but these are worth to mention:

No more eval()
Mooml.Template
Mooml.Templates
Pass functions as arguments to template functions
References to elements with an Id

No more eval()

Although the use of eval() was transparent to the final user, Mooml 1.0.X depended on it to properly generate the dom elements using the template functions like div(), span(), table(), etc. Mooml 1.1 does not use eval() anymore, which prevents issues when compressing the code with compilers like Google Closure Compiler and also increments the overall performance of template rendering.

Mooml.Template

Mooml.Template is the new constructor for Mooml templates. This constructor will allow to create standalone templates like this:

var tpl = new Mooml.Template('mytemplate', function(params) {
div({ id: params.divId }, params.divContent);
});
document.body.grab(tpl.render({
divId: 'mydiv',
divContent: 'Hi there!'
}));
// will create:
Hi there!

There is no need to create a Mooml.Template object when using Mooml.register(), which will work as in previous versions of Mooml.

Mooml.Templates

Mooml.Templates is a mixing that can be implemented into other Mootools classes. This will allow these classes to create their own templates internally and use them without the need of registering global templates with Mooml.register(). Here is an example of a Dog class:

var Dog = new Class({
Implements: [Options, Mooml.Templates],
options: {
bark: 'Bark! Bark!'
},
initialize: function(options) {
this.setOptions(options);
this.register('dog', function(bark) {
div({ 'class': 'dog'}, bark);
});
},
toElement: function() {
return this.render('dog', this.options.bark);
}
});
document.body.grab(new Dog()); //
Bark! Bark!
document.body.grab(new Dog({ bark: 'Woof! Woof!' })); //
Woof! Woof!
document.body.grab(new Dog({ bark: 'Arf!' })); //
Arf!

Pass functions as arguments to template functions

With Mooml 1.1, template functions accept functions as arguments. These function can be any function that returns an element, array of elements, string, number or any other argument type supported by Mooml template functions. For example:

var tpl = new Mooml.Template('mytemplate', function(content) {
div(content);
});
document.body.grab(tpl.render(function() {
return 'Html returned by a function()'
}));
// will create:
Html returned by a function()

References to elements with an Id

Finally, Mooml 1.1 templates can return references to all elements rendered that contain an Id, including elements rendered in nested templates:

var tpl = new Mooml.Template('mytemplate', function(content) {
div({id:'div1'}, content);
div({id:'div2'}, content);
div({id:'div3'}, content);
}, {
saveElementRefs: true
});
document.body.adopt(tpl.render('some text'));
tpl.elementRefs.div1; // reference to
some text
tpl.elementRefs.div2; // reference to
some text
tpl.elementRefs['div3']; // reference to
some text

Don’t miss the new demo: http://enekoalonso.com/projects/mooml/
Enjoy!

April 28, 2010 -- Mooml 1.2.3 – Bye, bye, with() (0)
March 15, 2010 -- More updates to Mooml coming soon (0)
February 19, 2010 -- Having fun with Mooml & Twitter (0)
February 1, 2010 -- Mooml.globalize(): Mooml template functions going global (0)

More updates to Mooml coming soon

Eneko Alonso — Tue, 16 Mar 2010 04:56:35 +0000

I’ve been very busy lately, both with spaniards.es and at work. Too much stuff to do. Nevertheless, I’ve been working lately on a version of Mooml that does not rely on with/eval. The problem of using eval (which has bad reputation but is used every time we parse JSON -unless you use this- or load Javascript via AJAX) in Mooml is that it references external variables, something that is not suported by javascript compilers like Google Closure.

So, I got it working, using RegEx, but seems like it is way slower than eval. I have to do some performance testing and do some research to see if there is any way I can improve the performance. Hope to have version 1.1 ready soon.

April 28, 2010 -- Mooml 1.2.3 – Bye, bye, with() (0)
March 24, 2010 -- Mooml 1.1 – No more eval(), say Hi to Mooml.Template and Mooml.Templates (0)
February 19, 2010 -- Having fun with Mooml & Twitter (0)
May 16, 2010 -- Performance matters (2)

Having fun with Mooml & Twitter

Eneko Alonso — Fri, 19 Feb 2010 20:43:54 +0000

Mooml is a templating engine for Mootools. With it, you can create HTML from Javascript using a very clean syntax. Plus, it is extremely useful when you have to generate repeating elements, since Mooml automatically renders arrays of data multiple times. Let’s see an example.

Searching Twitter

Nowadays there are a lot of APIs out there that support JSON or JSONP, which we can use directly from the front end using Javascript. Also, there are other APIs that return tons of JS data, like Google Maps. In this example we are going to be searching Twitter and displaying the search results in a container div, properly rendered as HTML.

The url for searching Twitter is http://search.twitter.com/search.json?q=mootools&show_user=true (searching for Mootools in this case). Check the output:

{
"results":[
{
"profile_image_url":"http://a3.twimg.com/profile_images/547672997/twitterProfilePhoto_normal.jpg",
"created_at":"Fri, 19 Feb 2010 17:08:55 +0000",
"from_user":"digitalr3bel",
"to_user_id":1212494,
"text":"@davidwalshblog Hi David – im a big fan of your site! Can you recommend a good MooTools tutorial for someone who can already program? thx",
"id":9343656026,
"from_user_id":23704390,
"to_user":"davidwalshblog",
"geo":null,
"iso_language_code":"en",
"source":"//apiwiki.twitter.com/" rel="nofollow">API"
}
// More results here…
],
"max_id":9343656026,
"since_id":0,
"refresh_url":"?since_id=9343656026&q=mootools",
"next_page":"?page=2&max_id=9343656026&q=mootools",
"results_per_page":15,
"page":1,
"completed_in":0.0352710000000001,
"query":"mootools"
}

We want to render each result inside out container div. On this example, we will just render the user name, user image and message text. Here is our Mooml template:

Mooml.register('twitter-search-result', function(entry) {
div({id: "tweet-" + entry.id},
img({src: entry.profile_image_url, alt: entry.from_user}),
span(entry.from_user),
p(entry.text)
);
});

Since all results are returned into an array, we can pass it directly to Mooml which will render all of the elements in it:

// Data is the JSON response from Twitter
Mooml.render('twitter-search-result', data.results);

So, let’s do a live test. Type something you want to search for and hit the search button to see Mooml in action :)

Search:

How cool is that?

The code

Ok, so here is the whole code I have used in this post for this mini-demo:

<script type="text/javascript" src="http://enekoalonso.com/lib/mootools-1.2.4-core-nc.js">script>
<script type="text/javascript" src="http://enekoalonso.com/lib/mooml.js">script>
<script type="text/javascript">
Mooml.register('twitter-search-result', function(entry) {
div({id: "tweet-" + entry.id},
img({src: entry.profile_image_url, alt: entry.from_user}),
span(entry.from_user),
p(entry.text)
);
});
function searchTwitter() {
new Element('script', {
type:'text/javascript',
src:'http://search.twitter.com/search.json?q={text}&show_user=true&callback=renderData'.substitute({
text:$('twitter-mooml-search').get('value')
})
}).inject(document.head);
}
function renderData(data) {
$('mooml-twitter-demo').empty().adopt(Mooml.render('twitter-search-result', data.results));
}
$('twitter-mooml-search-btn').addEvent('click', searchTwitter);
searchTwitter();

As you can see, the code is very basic and so is the Mooml template. The coolest thing here is that you don’t need to iterate over the results to render each element.

Have fun!

April 28, 2010 -- Mooml 1.2.3 – Bye, bye, with() (0)
March 24, 2010 -- Mooml 1.1 – No more eval(), say Hi to Mooml.Template and Mooml.Templates (0)
March 15, 2010 -- More updates to Mooml coming soon (0)
February 1, 2010 -- Mooml.globalize(): Mooml template functions going global (0)

Mooml.globalize(): Mooml template functions going global

Eneko Alonso — Mon, 01 Feb 2010 15:49:35 +0000

Since version 1.0.9, Mooml includes a new feature: globalize. It maybe handy for some websites to globalize all the Mooml template functions (div, a, p, span…) to the window object scope, so they can be used anywhere in the code without the need of defining or evaluating a template.

For example, in normal Mootools code we would create a div like this:

// options can have attributes, css, events and more
var mydiv = new Element('div', options);

With Mooml.globalize() we can do this:

Mooml.globalize(); // Only need to call this once
var mydiv = div(options); // Same options as Mootools new Element()

Mooml globalized functions can also have nested elements, which makes very easy to create dom elements:

var mydiv = div(options,
p('First paragraph'),
p('Second paragraph'),
div('Nested div:',
span('div content')
),
Mooml.render('nested_template'),
'Some inline html too'
);

Will generate the dom elements for this html:

First paragraph
Second paragraph
Nested div:
div content

Some inline html too

Elements created by Mooml template functions are not automatically injected in the DOM. They are just created like when you use new Element().

Please be aware that using Mooml.globalize() feature will pollute the window object scope, overriding any methods with the same name and/or possibly conflicting with other Javascript libraries. As a tip, Mooml.tags can be edited before calling Mooml.globalize(), so only functions for those tags we are interested on will be created.

April 28, 2010 -- Mooml 1.2.3 – Bye, bye, with() (0)
March 24, 2010 -- Mooml 1.1 – No more eval(), say Hi to Mooml.Template and Mooml.Templates (0)
February 19, 2010 -- Having fun with Mooml & Twitter (0)
March 15, 2010 -- More updates to Mooml coming soon (0)

Detecting when CSS gets loaded by the browser with Mootools and Asset.css

Eneko Alonso — Wed, 27 Jan 2010 19:20:22 +0000

Asset.css claims to have an onload event in Mootools documentation, but sadly, not all browsers support this feature. Even worse, browsers like Chrome seem to support the event, but never fire it.

After some research and testing at work, we have come up with a solution that overrides Asset.css to detect when CSS gets loaded by the browser using the onload event in those browsers that support it (Internet Explorer and Opera) and doing polling in those that do not (Chrome, Safari and Firefox). Here is the code:

// Add callback support to Asset.css for all browsers
Asset.css = function(source, onLoad) {
var link = new Element('link', {
rel: 'stylesheet',
media: 'screen',
type: 'text/css',
href: source
});
if (("onload" in link) && !Browser.Engines.webkit()) {
if (onLoad) link.onload = onLoad;
} else {
(function() {
try {
link.sheet.cssRules;
} catch (e) {
setTimeout(arguments.callee, 100);
return;
};
if (onLoad) onLoad();
})();
}
link.inject(document.head);
return link;
}
// Load some CSS and show an alert when done
var mycss = new Asset.css('http://example.com/style.css', function() {
alert('CSS loaded!');
});
// Unload the css
mycss.destroy();

Enjoy!

June 30, 2009 -- iPhone 3.0 geolocation with Javascript (1)
March 1, 2009 -- Safari 4 rocks (1)
June 8, 2010 -- Change in WebSockets handshake protocol (0)
April 28, 2010 -- Mooml 1.2.3 – Bye, bye, with() (0)

Finally: Singletons, the Mootools way

Eneko Alonso — Mon, 18 Jan 2010 17:26:38 +0000

I have been using for a while the “new new Class” syntax to create singletons on the projects I am working on. This is for many reasons, but specially because I didn’t like other solutions like Class.Mutators, Class.Oclude or extending a plain object with $extend().

Now, after discussing a little bit on the Mootools email list about what was the best way to create singletons, I have created Class.Singleton so we can create singletons the Mootools way. Here is how it works:

var MySingleton = new Class.Singleton({
initialize: function(){
// code here
},
method1: function(){
// code here
},
method2: function(){
// code here
}
});

Using inheritance, mixins, etc

Class.Singleton works like defining any other Mootools class using Class(), so we can have inheritance, mixins, etc.

var BaseClass = new Class({
initialize: function() {
// Initialization code here
console.log('BaseClass initialized.');
},
method1: function() {
// some code
}
});
var MySingleton = new Class.Singleton({
Extends: BaseClass,
initialize: function() {
this.parent();
console.log('MySingleton singleton initialized.');
},
method1: function() {
this.parent();
// more code
}
});

Hope you like it!

Repository url: http://github.com/eneko/Class.Singleton

April 23, 2009 -- Sending messages between Javascript objects (2)
April 7, 2009 -- Setting up timers and intervals inside JS objects (2)
July 20, 2009 -- Setters & Getters on Mootools classes (0)
December 14, 2008 -- Threads in Javascript (0)

Mooml: Mootools markup language (intro)

Eneko Alonso — Mon, 18 Jan 2010 05:38:56 +0000

It was a month ago when I found about Jaml, an excellent small Javascript library created by Ed Spencer which allows generating HTML code using very nice and clean templates. At work we use Mootools in most of our projects, so I thought it would be nice to improve Jaml by taking advantage of the power of Mootools. And this is the result.

Mooml: Mootools markup language

What is Mooml? Mooml is a templating system that allows generating HTML snippets very easily, without all the ugly nested “new Element” calls or string concatenation. With Mooml you can save templates for later use or evaluate snippets on the fly.

Download: http://mootools.net/forge/p/mooml
Source: http://github.com/eneko/mooml

Let’s see an example

Required HTML:

Node Title
Node body here.

Node title and body are variables, so let’s save them on a Json format for now.

var data = {
title: 'Node Title',
body: 'Node body here'
}

Using Mootools “new Element” we would have to code something like this:

var el = new Element('div', {'class': 'node'}).adopt([
new Element('h2', {text: data.title}),
new Element('p', {text: data.body})
]);

That code is much better than plain Javascript, but still messy. We could use the new Elements.from included in Mootools More 1.2.4, but that would require us writing the html as a string, which rapidly gets messy concatenating variables, etc.

var el = Elements.from('
' + data.title + '
' + data.body + '
');

With Mooml…

With Mooml, we can create a template for that piece of code, and reuse it later as many times as we need:

Mooml.register('node', function(data) {
div({'class': 'node'},
h2(data.title),
p(data.body)
)
});
document.body.grab(Mooml.render('node', data));

We can also execute the template directly as a function:

document.body.grab(Mooml.templates.node(data));

Finally, with Mooml we can evaluate templates on the fly, without having to store them for later:

document.body.grab(Mooml.evaluate(function(data) {
div({'class': 'node'},
h2(data.title),
p(data.body)
)
}, data));

More examples soon :)

April 28, 2010 -- Mooml 1.2.3 – Bye, bye, with() (0)
March 24, 2010 -- Mooml 1.1 – No more eval(), say Hi to Mooml.Template and Mooml.Templates (0)
March 15, 2010 -- More updates to Mooml coming soon (0)
February 19, 2010 -- Having fun with Mooml & Twitter (0)

I never use $$ on my projects (and barely use $)

Eneko Alonso — Sat, 16 Jan 2010 04:53:28 +0000

On all the projects I’ve worked on, I always try to follow the MVC arquitectural pattern, separating the model from the view *and* creating a controller. It may be a simple controller in charge of a tab-set, or an accordion. Or it may be a full size controller in charge of the whole page structure, on sites that make an extensive use of javascript.

Either way, I always have a controller for a dynamic section of the page and the controller always works with the container of that section. If I need to reference any element inside the container I will use this.container.getElementById() or this.container.getElements(), which will do a search only on the child elements of the container and not on the whole dom tree of the page.

Yes, it is very usual to see nowadays code that alters the links of a page we are searching the whole page. And coding like that is just a waste of resources.

December 18, 2008 -- Gravity in the DOM (0)
May 14, 2010 -- Interesting JSON vulnerability (old stuff) (0)
April 28, 2010 -- Mooml 1.2.3 – Bye, bye, with() (0)
April 14, 2010 -- Getting unique timestamps in Javascript (0)

Creating HTML blocks with Mootools

Eneko Alonso — Wed, 02 Sep 2009 20:50:16 +0000

Sometimes we need to create HTML from JS. There are multiple ways to do this, from using innerHTML to creating element by element appending child to parents, setting attributes, etc. And there are as many different opinions about what is the right way to do it.

Meanwhile, once thing I missed from jQuery, not available on Mootools, was the ability to do something like this:

var element = jQuery('
bar
');

In Mootools, the equivalent should be:

var element = new Element('
bar
');

But that does not work.

On the Mootools mailing list, someone was asking about how to implement this and we just found a different approach, which instead of using the Element class, extends the String class like this:

String.implement({
toElement: function() {
return new Element('div', {html:this}).getFirst();
}
});

Now you can do this:

var element = '
bar
'.toElement();

To try it, paste this snippet on Firebug’s console:

String.implement({
toElement: function() {
return new Element('div', {html:this}).getFirst();
}
});
console.log('
bar
'.toElement().get('id'));

Nice, uh? Of course, the HTML can be as complex as you need and where do you get the content of the string is up to you :)

March 24, 2010 -- Mooml 1.1 – No more eval(), say Hi to Mooml.Template and Mooml.Templates (0)
July 20, 2010 -- Little tricks: string padding in Javascript (2)
July 1, 2010 -- Little tricks: editing strings by index in Javascript and Python (1)
April 28, 2010 -- Mooml 1.2.3 – Bye, bye, with() (0)

Fixing issues with ‘change’ event on text fields ala Mootools

Eneko Alonso — Fri, 14 Aug 2009 23:54:20 +0000

Very nice snippet to solve a few annoying issues with the change event:
http://www.meiocodigo.com/2009/08/13/new-changed-event/

June 8, 2010 -- Change in WebSockets handshake protocol (0)
April 28, 2010 -- Mooml 1.2.3 – Bye, bye, with() (0)
April 14, 2010 -- Getting unique timestamps in Javascript (0)
March 24, 2010 -- Mooml 1.1 – No more eval(), say Hi to Mooml.Template and Mooml.Templates (0)

Setters & Getters on Mootools classes

Eneko Alonso — Mon, 20 Jul 2009 23:45:15 +0000

Although I haven’t need them for my classes, I thought it would be very cool to have the possibility to use them. Setters and Getters are very popular in modern programming languages, since they let you do some actions when a member/property of an object is being accessed or modified. Setters and Getters are native on Javascript objects.

// Setter on plain JS
var b = {
saveCount: 0,
set count (c) {
console.log('Setting count (B):' + c);
this.saveCount = c;
},
get count () {
console.log('count is being accessed (B)');
return this.saveCount;
}
}
b.count = 5;
console.log("Count (B): " + b.count);

Well, Mootools objects created using Class do not support that syntax. Fortunately, we can use the __defineSetter__ and __defineGetter__ functions:

// Setter in Mootools
var A = new Class({
saveCount: 0,
initialize: function() {
this.__defineSetter__("count", this.setCount);
this.__defineGetter__("count", this.getCount);
},
setCount: function(c) {
console.log('Setting count(A):' + c);
this.saveCount = c;
},
getCount: function() {
console.log('count is being accessed (A)');
return this.saveCount;
}
});
var a = new A();
a.count = 5;
console.log("Count(A): " + a.count);

Nice, uh?

April 23, 2009 -- Sending messages between Javascript objects (2)
April 7, 2009 -- Setting up timers and intervals inside JS objects (2)
January 2, 2009 -- Solving the 8 Queen Puzzle in Javascript (1)
April 28, 2010 -- Mooml 1.2.3 – Bye, bye, with() (0)

Mootools stuff to review

Eneko Alonso — Wed, 15 Jul 2009 16:32:09 +0000

Two interesting things I have to review;
MooTools: Bubbling Controllers
MooTools: Ignoring the next click

April 28, 2010 -- Mooml 1.2.3 – Bye, bye, with() (0)
April 14, 2010 -- Getting unique timestamps in Javascript (0)
March 24, 2010 -- Mooml 1.1 – No more eval(), say Hi to Mooml.Template and Mooml.Templates (0)
March 15, 2010 -- More updates to Mooml coming soon (0)

iPhone 3.0 geolocation with Javascript

Eneko Alonso — Tue, 30 Jun 2009 16:13:43 +0000

I was watching one of the video tutorials from Apple last night about some custom JS available on Safari, only on the iPhone 3.0, that let’s you interact with the phone and obtain data like the current location, etc.

So I built a little page to see how it works. I included Mootools 1.2.3 from Google servers and the Google Maps API. And voilá, with a few lines of code we have a totally functional web based GSP navigation system. A little bit ugly, but functional. Currenlty it only centers the map on the coordinates given by the phone, and also does a reverse geolocation to obtain the address (actually city, state and country). But it could be easily extended to add markers to the map, or even paths to track the movement.

If you have an iPhone (or an iPhone simulator) go to:
http://enekoalonso.com/research/iphone/geolocation.html

The source code:

var Navigator = new Class({
initialize: function() {
// Listen for position changes
this.watchId = navigator.geolocation.watchPosition(
function(position){ this.position(position) }.bind(this),
function() {},
{ enableHighAccuracy: true, timeout: 1000, maximumAge: 10000 }
);
this.infoPanel = $('info');
// Create the Geocoder and the Map
this.geocoder = new google.maps.Geocoder();
this.map = new google.maps.Map($('map'), {
zoom: 12,
mapTypeId: google.maps.MapTypeId.ROADMAP
});
},
position: function(position) {
// Update labels
this.infoPanel.getElement('p.date').set('text', position.timestamp);
this.infoPanel.getElement('p.coords').set('text', position.coords.latitude + ', ' + position.coords.longitude);
this.infoPanel.getElement('p.altitude').set('text', position.coords.altitude);
this.infoPanel.getElement('p.heading').set('text', position.coords.heading);
this.infoPanel.getElement('p.speed').set('text', position.coords.speed);
// Center map
var latLng = new google.maps.LatLng(position.coords.latitude, position.coords.longitude);
this.map.set_center(latLng);
// Reverse geolocation (get current address)
this.geocoder.geocode({'latLng': latLng},
function(results, status) {
if (google.maps.GeocoderStatus.OK) this.showAddress(results)
}.bind(this)
);
},
showAddress: function(results) {
// console.dir(response);
if (results[1]) {
this.infoPanel.getElement('p.location').set('text', results[1].formatted_address);
}
}
});
window.addEvent('load', function() {
new Navigator();
});

Enjoy.

February 19, 2010 -- Having fun with Mooml & Twitter (0)
January 28, 2010 -- Things to do (0)
February 28, 2009 -- Kyte’s REST API (0)
July 30, 2010 -- Creating QR Codes with Google Charts API (0)

Sending messages between Javascript objects

Eneko Alonso — Fri, 24 Apr 2009 04:44:34 +0000

When applications (or websites) get pretty big, it usually happens that a lot of different objects or classes interact with each other or, even worst, depend on each other to achieve the site functionality.

A simple example could be a Tabs manager class, which controls a set of tabs in the page. Sometimes, the content in this tabs is sensitive to when the tabs are shown or hidden. At this point you have three options: either the Tabs class needs to know about the content or you create a set of callback functions or you use custom events. Still, for every one of these options you are going to need variables referencing the instances of your classes (this is: var myTabs = new Tabs())

Personally, I don’t like having global variables for the objects I create. I think the code gets very messy and complicated.

So, after dealing with all these issues at work day after day I thought it would be very cool to have a messaging system between my classes, the same way other languages like Cocoa do (in a more simpler way, at least for now).

Sending messages between classes

Wouldn’t it be nice if the Tabs class would send a message every time a new tab is selected? Wouldn’t it be nice if the objects that are going to reside inside those tabs could listen to that message and update accordingly?

To do this, I created a Base class and a Register, where my objects will register automatically upon instantiation (thanks to the Base class).

var InstanceRegister = new Class({
instances: [],
addInstance: function(object) {
this.instances.push(object);
},
broadcastMessage: function(msg) {
$A(this.instances).each(function(item, index) {
item.processMessage(msg);
});
}
});
var Register = new InstanceRegister();
var Base = new Class({
ClassName: 'Base',
Implements: Options,
initialize: function(options) {
this.setOptions(options);
Register.addInstance(this);
},
processMessage: function(msg) {
console.log(this.ClassName, ' msg received: ');
console.dir(msg);
},
sendMessage: function(msg) {
Register.broadcastMessage(msg);
}
});

As you can see, the register is just an array of Instances. Yes, Register is a global object, but it will be the only one we will need. Meanwhile, the Base class adds the new instance to the Register automatically. For convenience, the Base class has a sendMessage method. Also, for convenience, I like to add a ClassName property to all my classes in case I need it later for logging, instance class type identification, etc.

Now, thanks to MooTools, we can create our classes and make them inherit from Base. We can override the processMessages method and act accordingly:

var Tabs = new Class({
ClassName: 'Tabs',
Extends: Base,
…
activateTab: function(tab) {
…
this.sendMessage({msg:'tabActivated', data:tab});
}
});
var VideoPlayer = new Class({
ClassName: 'VideoPlayer',
Extends: Base,
…
processMessage: function(msg) {
if (msg.msg == 'tabActivated' && msg.data = 'video-tab') {
// Play video
}
}
});

The beautifulness of this code resides, as I mentioned before, in the absence of any object references. Tabs doesn’t know anything about the VideoPlayer class nor any other object listening to the messages. And the VideoPlayer doesn’t know anything about the Tabs class either. It only knows about the message it has to listen to. No object references, no methods, no callbacks.

Pay attention now. This is the best part! Whenever we instance our classes, no matter how many times we do, we don’t need variable references anymore:

new Tabs();
new VideoPlayer();

Nice, uh?

Since I implemented this class I use it a lot on every project at work. It makes my life easier, keeping my classes simple and independent from each other. It’s even better. We have got to a point where we have integrated this feature with our Flash components, so these send messages to the Register when needed and any JS object listening reacts to them as needed.

By doing this, even being unidirectional (Flash to JS only), we have achieved something great: from now on, our Flash objects don’t need to know anything about our JS objects at all. Just send a message to the register and done.

At any point, even from Firebug, you can send a message to the Register. This is very nice, even for debugging:

A listener class

I found it is very nice, while in development, to have a Listener class debugging any message received. This way I don’t need to add a console.log call on all my classes to output received messages. The Listener will do it for me:

var Listener = new Class({
Extends: Base,
initialize: function() {
this.parent();
this.ignoreMessages = false;
},
processMessage: function(msg) {
if (msg.msg == 'stopListener') this.ignoreMessages = true;
if (msg.msg == 'startListener') this.ignoreMessages = false;
if (this.ignoreMessages) return;
console.log('Listener: msg received:');
console.dir(msg);
}
});
new Listener();

Even you can control the Listener by sending custom messages to it! Awesome!

Could this be achieved with custom events?

With Mootools, creating custom events is piece of cake. But from what I understand, custom events work only inside the object that is firing them. This is, if object A fires an event ‘customEvent’, you can only listen to it if you add a callback function when you instantiate that class:

var A = new Class({
Implements: Events,
initialize: function() {
document.body.addEvent('click', function() {
console.log('A: body clicked');
this.fireEvent('bodyClicked', [this]);
}.bind(this));
}
});
var B = new Class({
doSomething: function() {
console.log('B: doing something…');
}
});
new A({
onBodyClicked: function() {
// Tell B to do something (you need a reference to B!)
}
});
new B(); // Will never do something

Ideally, B should be able to listen to the bodyClicked event without passing any info when A is instantiated. But if I’m not mistaken, this is not possible.

Revised version

I decided that it would be cool to have the Messenger as something my classes could implement, instead of inherit from (Base). Also, it would be good if one object could register for a specific message only, which would improve performance too.

var NotificationServiceCenter = new Class({
instances: {},
addObserver: function(msg, instance) {
if (!this.instances[msg]) {
this.instances[msg] = [];
}
this.instances[msg].push(instance);
},
broadcastMessage: function(msg, data) {
if (this.instances[msg]) {
$A(this.instances[msg]).each(function(item, index) {
item.processMessage(msg, data);
});
}
}
});
var NotificationService = new NotificationServiceCenter();
var Messenger = new Class({
addMsgEvent: function(msg) {
NotificationService.addObserver(msg, this);
},
sendMessage: function(msg, data) {
NotificationService.broadcastMessage(msg, data);
},
processMessage: function(msg, data) {
// For implementation on the final Class
}
});
var A = new Class({
Implements: Messenger,
initialize: function() {
document.body.addEvent('click', function(){
console.log('A: document body clicked');
this.sendMessage('documentbodyclicked', 'Hello world!');
}.bind(this));
}
});
var B = new Class({
Implements: Messenger,
initialize: function() {
this.addMsgEvent('documentbodyclicked');
},
processMessage: function(msg, data) {
console.log('B: msg received: ', data);
}
});
new A();
new B();

Here you go!

July 20, 2009 -- Setters & Getters on Mootools classes (0)
April 7, 2009 -- Setting up timers and intervals inside JS objects (2)
January 2, 2009 -- Solving the 8 Queen Puzzle in Javascript (1)
January 18, 2010 -- Finally: Singletons, the Mootools way (0)

MooTools 1.2.2 is here and it’s very cool

Eneko Alonso — Fri, 24 Apr 2009 03:43:29 +0000

What a great surprise it’s been to see the major updates in Mootools Core are around the Class object. Object Oriented javascript is the future and MooTools is the freeway to get there. Now, better than ever.

MooTools 1.2.2 is a mainly a bug fix release but it also includes an almost entirely new Class.js. The reasoning behind this is that the old Class.js didn’t play nicely with some advanced usages of this.parent() present in the new MooTools-More.
[...]
Other than providing the parent fixes, the new Class also features a much more robust inheritance model, especially when dealing with objects. For example, the objects you implement now in a class are merged if an object with the same name is found in the class prototype…
[...]
Another object-oriented feature we introduced is that now sub-objects are actually inherited Parent-to-Child. If you implement a new option in Animal, then Cat, which is a subclass of Animal, will get the new option as well, and so will every instance already existing.

Those are very cool features! Good job guys!
http://mootools.net/blog/2009/04/23/mootools-122-and-the-new-mootools-more/

Want more? Take a look at the new plugins available on Mootools More:
http://mootools.net/more

April 28, 2010 -- Mooml 1.2.3 – Bye, bye, with() (0)
April 14, 2010 -- Getting unique timestamps in Javascript (0)
March 24, 2010 -- Mooml 1.1 – No more eval(), say Hi to Mooml.Template and Mooml.Templates (0)
March 15, 2010 -- More updates to Mooml coming soon (0)

Synchronizing sounds (or trying to…)

Eneko Alonso — Fri, 10 Apr 2009 15:22:10 +0000

The purpose of this demo is to test and see how possible is to synchronize sounds with DOM effects while being played in different threads or timers. It looks like, while synchronizing sounds with DOM effects is quite simple and works fine, sounds played by different threads or timers get out of sync after a while.

See the demo in action.

Next step: build a sound controller class that can play sounds at some intervals, delays, etc

December 26, 2008 -- Forest demo (was Grass) (0)
December 23, 2008 -- Grass demo: background sounds (0)
December 20, 2008 -- Particle Balls demo, now with sound! (3)
April 28, 2010 -- Mooml 1.2.3 – Bye, bye, with() (0)

Setting up timers and intervals inside JS objects

Eneko Alonso — Wed, 08 Apr 2009 05:00:58 +0000

It may seem trivial but it has its tricky point. Usually, in procedural Javascript (this is, non object oriented programming), timers are set up passing the callback function on a string:

function hello() {
alert("hello");
}
// Will execute hello() after 10 seconds
setTimeout('hello()', 10000);

For this code to work, hello() has to be a global function (actually a function of the window object). Otherwise, when the timer times out, it won’t find it.

When writing object oriented code, one would like to call a function inside the object itself, not a global function. We can achieve this passing an anonymous function to the setTimeout function that calls our function:

var MyClass = new Class({
initialize: function() {
setTimeout(function() { this.hello(); }, 10000); // This wont work
},
hello: function() {
alert("hello");
}
});

The previous code wont work, since this inside the anonymous function points to the window object and not to our instance of MyClass. We solve this using the bind function provided by Mootools:

var MyClass = new Class({
initialize: function() {
setTimeout(function() { this.hello(); }.bind(this), 10000);
},
hello: function() {
alert("hello");
}
});

This code will work fine, but it still has a big problem. If we wanted to access any member or function of our instance inside the hello() function, it wouldn’t work. This is because when the timer times out, the context of our instance is lost. Inside the hello() function, this will point to the window object.

var MyClass = new Class({
initialize: function() {
this.text = 'hello';
setTimeout(function() { this.hello(); }.bind(this), 10000);
},
hello: function() {
alert(this.text); // This wont work
}
});

There are multiple ways to solve this issue but my favorite is to use the function call() of the function object. This function let’s you pass an object while calling your function that will become this inside it.

var MyClass = new Class({
initialize: function() {
this.text = 'hello';
setTimeout(function() { this.hello.call(this); }.bind(this), 10000);
},
hello: function() {
alert(this.text);
}
});

Now we can use this inside the hello() function and everything will work fine, no matter how many instances of MyClass we create.

var MyClass = new Class({
initialize: function(text) {
this.text = text;
setTimeout(function() { this.hello.call(this); }.bind(this), 10000);
},
hello: function() {
alert(this.text);
}
});
new MyClass('hello');
new MyClass('hi there!');
new MyClass('wassup?');

Enjoy :)

April 23, 2009 -- Sending messages between Javascript objects (2)
February 1, 2010 -- Mooml.globalize(): Mooml template functions going global (0)
January 18, 2010 -- Finally: Singletons, the Mootools way (0)
July 20, 2009 -- Setters & Getters on Mootools classes (0)

Kyte’s REST API

Eneko Alonso — Sat, 28 Feb 2009 17:39:47 +0000

During the last weeks at work I’ve been working on a very cool Mootools based Javascript API to interact with Kyte’s REST API. So far it’s been working very good and I’m very impressed about how fast Kyte’s API is.

Unfortunately, until the project I’m working on is launched I won’t be able to show any code. The launch date is April 27th :)

February 19, 2010 -- Having fun with Mooml & Twitter (0)
June 30, 2009 -- iPhone 3.0 geolocation with Javascript (1)
May 6, 2010 -- Tech talks at LEVEL Studios (0)
April 28, 2010 -- Mooml 1.2.3 – Bye, bye, with() (0)

dev.enekoalonso.com » mootools

Mooml 1.2.3 – Bye, bye, with()

Related Posts:

Getting unique timestamps in Javascript

Related Posts:

Mooml 1.1 – No more eval(), say Hi to Mooml.Template and Mooml.Templates

What is new in Mooml 1.1

No more eval()

Mooml.Template

Mooml.Templates

Pass functions as arguments to template functions

References to elements with an Id

Related Posts:

More updates to Mooml coming soon

Related Posts:

Having fun with Mooml & Twitter

Searching Twitter

The code

Related Posts:

Mooml.globalize(): Mooml template functions going global

Related Posts:

Detecting when CSS gets loaded by the browser with Mootools and Asset.css

Related Posts:

Finally: Singletons, the Mootools way

Using inheritance, mixins, etc

Related Posts:

Mooml: Mootools markup language (intro)

Mooml: Mootools markup language

Let’s see an example

Node Title

' + data.title + '

With Mooml…

Related Posts:

I never use $$ on my projects (and barely use $)

Related Posts:

Creating HTML blocks with Mootools

Related Posts:

Fixing issues with ‘change’ event on text fields ala Mootools

Related Posts:

Setters & Getters on Mootools classes

Related Posts:

Mootools stuff to review

Related Posts:

iPhone 3.0 geolocation with Javascript

Related Posts:

Sending messages between Javascript objects

Sending messages between classes

A listener class

Could this be achieved with custom events?

Revised version

Related Posts:

MooTools 1.2.2 is here and it’s very cool

Related Posts:

Synchronizing sounds (or trying to…)

Related Posts:

Setting up timers and intervals inside JS objects

Related Posts:

Kyte’s REST API

Related Posts: