dev.enekoalonso.com » mootools

Javascript console in the terminal (command line)

Eneko Alonso — Wed, 06 Oct 2010 04:15:19 +0000

I’ve been looking for a command line Javascript console for a while. I have even thought of creating my own one, some hybrid between my fake Linux terminal and JSFiddle.net. Lately, I’ve been working with node.js lately on a little project just for fun. Never before I had done server side Javascript and it looks like it has serious potential. But still, I had no console other than Firebug or, my favorite, the one included in Webkit.

So I am very happy after coming across this article which shows how to use the JavaScriptCore.Framework included in Mac OS X on the command line. Doing some Google searches, looks like people have been talking about this for a long time. Even more! Here is how to compile javascript to .exe in Windows. Didn’t even thought that could be possible, being Javascript such a dynamic language.

One interesting thing about the jsc Javascript console is that you can load() javascript files from disk. Thus, one can get the Mootools core (Core + Function + Array + Number + String + Hash + Class + Class.Extras + JSON) and load it to start creating awesome classes, etc.

This is going to be a lot of fun :)

October 12, 2011 -- Command line scripting with Node.js (0)
July 13, 2011 -- Clone your OSX terminal window (1)
September 17, 2010 -- MooTools Core for Server and Mobile Development (1)
July 30, 2010 -- Titanium Developer: love and hate (3)

MooTools Core for Server and Mobile Development

Eneko Alonso — Fri, 17 Sep 2010 17:50:30 +0000

One of the best things of MooTools is that it is very modular, from the core itself. This means you don’t need to include all core elements in your projects if you don’t want or don’t need some modules. For example, you may not want to include Array or Function, if you don’t need any enhancements of such objects.

In the case of server side or mobile applications (Titanium Developer and other Javascript based mobile frameworks), there is no browser involved which means there is no DOM. Thus, we can removed any kind of module that depend or are designed to work with this elements: Browser, Element, Selectors, Cookie… all those modules have no value for server side or mobile applications.

I found this page which summarizes the modules you should need for server or mobile development:

MooTools Core
Core: core
Native: Array, Function, Number, String, Hash
Class: Class, Class.Extras

MooTools More
Core: More
Class: Class.Refactor, Class.Binds, Class.Occludes

http://onecrayon.com/spice/docs/mootools-server/

Personally, I don’t find the MooTools More modules very useful, so I’m not including them in my projects. Maybe Binds would be a good addition, but it is not critical.

Having MooTools in a Javascript application makes it easier to develop and brings you all the power of Object Oriented programming with classes, inheritance and more.

July 30, 2010 -- Titanium Developer: love and hate (3)
June 14, 2011 -- Titanium Studio and Titanium Mobile 1.7 (0)
August 18, 2010 -- Titanium Developer: love and hate (Part II) (0)
September 21, 2010 -- Date from ISO 8601 string (1)

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?

May 6, 2011 -- Finding duplicate ID’s on an HTML page (0)
October 5, 2010 -- Javascript console in the terminal (command line) (1)
September 21, 2010 -- Date from ISO 8601 string (1)
September 17, 2010 -- MooTools Core for Server and Mobile Development (1)

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() (3)
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() (3)
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() (3)
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() (3)
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 (2)
May 18, 2011 -- location.hash is dead (on html5 browsers) (0)
October 5, 2010 -- Javascript console in the terminal (command line) (1)

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 (2)
December 14, 2008 -- Threads in Javascript (1)

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() (3)
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 6, 2011 -- Finding duplicate ID’s on an HTML page (0)
October 5, 2010 -- Javascript console in the terminal (command line) (1)
September 17, 2010 -- MooTools Core for Server and Mobile Development (1)

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)
May 12, 2011 -- Angry Birds as a Web App (0)
May 6, 2011 -- Finding duplicate ID’s on an HTML page (0)
October 5, 2010 -- Javascript console in the terminal (command line) (1)

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/

October 5, 2010 -- Javascript console in the terminal (command line) (1)
September 17, 2010 -- MooTools Core for Server and Mobile Development (1)
June 8, 2010 -- Change in WebSockets handshake protocol (0)
April 28, 2010 -- Mooml 1.2.3 – Bye, bye, with() (3)

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)
October 5, 2010 -- Javascript console in the terminal (command line) (1)

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

October 5, 2010 -- Javascript console in the terminal (command line) (1)
September 17, 2010 -- MooTools Core for Server and Mobile Development (1)
April 28, 2010 -- Mooml 1.2.3 – Bye, bye, with() (3)
April 14, 2010 -- Getting unique timestamps in Javascript (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.

September 17, 2010 -- MooTools Core for Server and Mobile Development (1)
February 19, 2010 -- Having fun with Mooml & Twitter (0)
January 28, 2010 -- Things to do (0)
February 28, 2009 -- Kyte’s REST 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 (2)
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

October 5, 2010 -- Javascript console in the terminal (command line) (1)
September 17, 2010 -- MooTools Core for Server and Mobile Development (1)
April 28, 2010 -- Mooml 1.2.3 – Bye, bye, with() (3)
April 14, 2010 -- Getting unique timestamps in Javascript (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)
October 5, 2010 -- Javascript console in the terminal (command line) (1)

dev.enekoalonso.com » mootools

Javascript console in the terminal (command line)

Related Posts:

MooTools Core for Server and Mobile Development

Related Posts:

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: