Aller au contenu | Aller au menu | Aller à la recherche

Technologies Mozilla

Ensemble des billets concernants les technologies Mozilla dont XUL

Fil des billets - Fil des commentaires

jeudi 26 mars 2009

Taskfox : Ubiquity pour tous

Ubiquity est un projet du Mozilla Labs, disponible sous forme d'une extension, qui a pour but de tester et valider la possibilité de contrôler son navigateur à l'aide de commande en langage naturel.

Taskfox est un projet d'intégration du meilleur d'Ubiquity pour tous, car les utilisateurs d'Ubiquity sont des personnes qui :

  • sont disposés à expérimenter des alternatives, à utiliser des lignes de commandes ;
  • sont des utilisateurs intensifs d'applications Web pour la plupart de leurs tâches quotidiennes (emails, agendas, gestion de documents, collaboration, etc) ;
  • comprennent que le Web est une source de données susceptibles d'être remixées, associées et éditées aussi bien par les utilisateurs au par les développeurs ;
  • ont l'habitude d'utiliser des extensions Firefox et sont prêt à installer Ubiquity sur leurs machines ;
  • ont des notions de basses en anglais.

L'objectif de Taskfox est de porter certains concept d'Ubiquity dans une prochaine version de Firefox, après Firefox 3.5 bien sûr. L'idée de base de Taskfox est simple : prendre les concepts d'Ubiquity qui offrent un gain de temps intéressant pour les intégrer à Firefox. Cela signifie permettre aux utilisateurs d'accéder rapidement à des informations et effectuer des tâches qui nécessiteraient normalement plusieurs étapes. Mais ça n'est pas simplement intégré Ubiquity à Firefox, c'est vraiment amélioré Firefox pour aider les utilisateurs, tous les utilisateurs, à utiliser le Web.

Blair présente le projet de façon détailler et si vous souhaitez voir à quoi cela pourrait ressembler des ébauches graphiques ont déjà été réalisé.

J'aime vraiment les idées liées à la barre d'adresse! Et vous qu'en pensez vous ? Mozilla attend vos impression.

Sinon pendant ce temps, le nouveau parser de commande d'Ubiquity est devenu un objectif de la version 0.2. Vous pouvez d'ailleurs déjà tester le parser français!

dimanche 22 mars 2009

ActiveRecord.js pour mozStorage

ActiveRecord.js est un projet d'ORM (Object Relational Mapping) pour JavaScript. Elle permet de manipuler des bases de données côté client (Google Gears, AIR, HTML5) mais aussi serveur (SQLite ou MySQL) avec Jaxer.

Je trouvais dommage qu'il n'y ai pas dans la version beta actuelle un connecteur pour manipuler des bases de données SQLite dans Mozilla, via l'API mozStorage. Sachant que par défaut, il y a un ActiveRecord.Adapter pour la manipulation de bases de données SQLite dans Adobe AIR.

J'ai donc créé un ActiveRecord.Adapter pour mozStrorage et ouvert un ticket. Je pense que je vais déjà m'en servir dans mes projets basés sur XulRunner, même si il manque peut être quelque point précis comme la gestion des Dates.

Si ça vous intéresse, testez le, c'est fait pour ça.

samedi 21 mars 2009

ActiveRecord.js un ORM JavaScript

Aptana a publié une première version Beta d'ActiveRecord.js, une solution Open-Source de Mapping d'Objet-Relationnel (en anglais object-relational mapping ou ORM) en JavaScript.

Aptana est la société éditrice d'un IDE pour le Web 2.0, Aptana Studio, mais aussi et surtout le premier serveur full AJAX, Jaxer.

ActiveRecord.js permet de manipuler une source de données sous-forme de base de données orientée objet en JavaScript pour de multiples environnements :

  • Google Gears (persistence côté client);
  • In Memory (si aucun système SQL n'est disponible du côté client);
  • Adobe AIR (persistence côté client);
  • SQLite and MySQL (via Aptana Jaxer, le serveur Open Source AJAX);
  • d'autres environnements (comme HTML5) grâce à la communauté.

ActiveRecord.js permet d'abstraire les commandes SQL sous-jacente ce qui permet aux développeurs d'avoir une API unifiée pour le stockage, la recherche, la sélection et la construction des objets et de leurs données en utilisant le pattern ActiveRecord popularisé par la communauté Ruby on Rails.

Mais à la différence d'autres projets qui ont essayé de directement implémenter la mise en oeuvre Rails d'ActiveRecord en JavaScript, ce projet a cherché à adapter les modèles affinées par la communauté Rails et quelques modèles Django en une API puissante et facile à utiliser.

ActiveRecor.js est la première pièce d'un framework MVC robuste, ActiveJS, créé spécialement pour le JavaScript et les applications AJAX. ActiveRecord.js est actuellement en Beta et Aptana qui a lancé le projet attend vos retours et observations avant de publier définitivement une version 1.0.

Si ça vous intéresse, vous pouvez lire :

Ou vous rendre :

jeudi 19 mars 2009

Fennec et Weave

Mozilla vient de publier une première beta de la version mobile de Firefox : Fennec.

Cette version n'est pour le moment disponible que pour Maemo, OS des Nokia Internet Tablets N810. Tristant Nitot a extrait des notes de version les évolutions principales :

  • Affichage plus rapide
  • TraceMonkey est activé par défaut
  • Support des plug-ins dont Flash

Ces évolutions devraient permettre aux utilisateurs d'avoir une sensation de navigation sur le Web avec un appareil mobile, très proche de ce qu'ils ont sur ordinateur. Et même si le Flash ne fait pas partie du Web, j'ai pu entendre des critiques à propos de l'iPhone car il n'y a pas de plugin Flash et que le "Web sans Flash ça n'est pas du Web".

Ces évolutions devraient aussi profiter à Firefox et à la plateforme Mozilla comme le compilateur JavaScript Just In Time (JIT), TraceMonkey, activé par défaut et l'affichage plus rapide. En ce qui concerne la rapidité, Taras a publié un article très intéressant sur comment Fennec était devenu plus rapide. Les contraintes avec les appareils mobiles sont qu'il n'y a pas d'accélération graphique matériel et peu de mémoire vive. Le résultat est qu'une mise à jour de l'affichage est au moins 10 fois plus lent que sur un ordinateur. La solution trouvée est de n'afficher que ce qui est nécessaire et de faire un minimum appel au DOM, ce qui pourrait être intéressant pour le SVG.

Autre annonce qui permettra aux utilisateurs de retrouver leur environnement de navigation sur mobile : l'extension Weave pour Fennec. Weave est un projet du Mozilla Labs qui permet entre autre de partager ces onglets et ces marques pages entre différents navigateurs.

Tout ça est encore en développement mais si vous souhaitez apporter votre pierre à l'édifice, tester les! Il existe des versions pour ordianteur Linux, Windows ou Mac.

Plus d'infos :

mardi 10 mars 2009

Paul continue ses démos sur l'élément video

Paul vient de publier un nouvelle article, et donc une nouvelle démo, sur l'élément <video/> de HTML5.

Cette fois ci Paul démontre l'intérêt d'avoir un élément <video/> plutôt qu'un plugin pour joué de la vidéo. Avec l'élément <video/> vous pouvez mettre des éléments html au dessus de la vidéo, ce qui est impossible avec un plugin. Dans cette nouvelle démo, Paul sous-titre une vidéo en français, anglais et espagnol, et comme c'est du html il y a des liens sur lesquels vous pouvez cliquer!

Paul dans toute sa splendeur ;-)

Bien sûr cette démo nécessite pour le moment une beta de Firefox 3.1/3.5.

vendredi 6 mars 2009

Firefox 3.1 alias Shiretoko devient Firefox 3.5

Alors que Mozilla-Europe est au Pays-Bas, les ingénieurs de Mozilla ont décidé de re-numéroter Shiretoko. La prochaine version de Firefox sera donc estampillé 3.5.

Après la sortie de Firefox 3, Mozilla souhaitait mettre en place 3 axes de développement :

  • les mises à jour majeur N.
  • les mises à jour mineur N.N
  • les mises à jour de sécurité N.N.N

L'objectif était de dynamiser le développement et de fournir plus régulièrement les nouveautés aux utilisateurs. Shiretoko devait être la première version de cette politique. Elle devait juste intégré ce qui n'avait pas pu l'être dans Firefox 3.0. Mais comme les développeurs de Mozilla Firefox sont d'incorruptible créateur de nouveauté, Shiretoko ne sera pas une mise à jour mineur mais une mise à jour semi-majeur!

Si vous souhaitez voir tout cela arrivé le plus vite possible, tester les beta et Shiretoko suivra!

jeudi 26 février 2009

Intrepid Ibex, Firefox et Prism

Je viens de changer de machine et j'ai pu expérimenter l'installation de la version Intrepid Ibex, 8.10, d'Ubuntu. C'est très franchement agréable de pouvoir préparer l'installation à partir d'XP en retaillant le disque dur et d'avoir l'ensemble du matériel supporter.

J'en ai profiter pour tester pour la première fois, le Firefox installé par défaut par Canonical. Il est relooké pour s'intégré parfaitement à Ubuntu. C'est la dernière version stable mise à disposition par Mozilla. Donc théoriquement pas besoin de le télécharger, mais j'ai eu une désagréable surprise avec Prism.

Prism est un projet du Mozilla Labs. Il est disponible sous forme d'une extension à Firefox 3 et il permet de transformer une application Web, en application indépendante du navigateur. C'est en fait une application qui utilise Firefox comme Runtime. J'ai donc ajouter Prism au Firefox d'Ubuntu. Je me suis rendu sur mon application Web favorite. A l'aide du menu Outils > Convert Web site to Application, j'ai transformé mon application Web en application indépendante et créé un raccourci sur le bureau. J'ai alors tester le raccourci qui me lançait un nouveau Firefox mais pas Prism!

Je n'ai pas cherché à savoir pourquoi il y avait une incompatibilité entre le Firefox fournit avec Ubuntu et Prism! J'ai préféré aller droit au but, car je n'avais pas le temps. J'ai donc téléchargé un Firefox fourni par Mozilla, réinstallé Prism, recréé mon application à partir de mon application Web, vérifié que ça fonctionnait, et je n'ai eu aucune mauvaise surprise.

Il est important que les utilisateurs d'Internet aient le choix dans le navigateur qu'ils utilisent lorsqu'ils acquièrent une nouvelle machine. Mais il est tout aussi important que l'on puisse retrouver ses chevaux, au plutôt son Prism. Cela peu paraître un peu extrémiste mais la fonctionnalité que propose Prism est par défaut dans Google Chrome et était considéré comme novatrice. Il me semble donc important que Prism soit compatible avec tous les Firefox!

mardi 24 février 2009

HTML5, CSS3, SVG... La magie du Web Ouvert!

En une semaine les démonstrations de la force du Web Ouvert se sont multiplié, ça commence par Bespin et ça fini par les démonstrations de Paul Rouget.

Bespin est un projet du Mozilla Labs. L'objectif est de démontrer la faisabilité d'un éditeur de code en ligne. L'objectif est de proposer quelque chose de nouveau pour la création de contenu Web, et avec la partie client c'est déjà réussi. Au lieu d'utiliser l'élément textarea ou quelque chose d'autre de compatible avec Internet Explorer, le Mozilla Labs a décidé de s'appuyer sur CANVAS, élément de la norme HTML5, implémenté par la majorité des navigateurs modernes. Daniel Glazman le dit très bien, c'est une innovation perturbatrice, a disruptive innovation!

Ce qui est intéressant avec cette proposition c'est le nombre de réaction, comme celle de Daniel mais aussi et surtout celle de Laurent Jouanneau. Tout comme Daniel, Laurent a été bluffé. Ce qui est intéressant dans cet article c'est la proposition d'un élément standard pour l'édition de code! Et c'est vrai que ça aurait de la gueule. Peut-être que le résultat de Bespin sera la création d'un tel élément.

Je voulais aussi revenir sur la possibilité d'utilisé du SVG pour stylisé des éléments HTML. J'en avais déjà parlé, mais ce qui est nouveau c'est que, dans la prochaine version de Firefox, il sera possible d'utiliser des éléments SVG externes. Ce qui veut dire qu'avec le trio HTML-CSS-SVG, on pourra faire des trucs super sympas, mais n'est ce pas trop ? Pour Daniel c'est même overkill!

Enfin les démos de Paul, où vous pouvez suivre les mouvements de Delphine ou voir Tristan Nitot sur un fond vert! Dans ces démos, Paul a utilisé les éléments CANVAS et VIDEO, DOM Workers et des nouveautés de JavaScript 1.8. Vous pouvez déjà en profiter si vous avez une version beta de Firefox 3.1, ou regarder les screencasts de Chris Blizzard, c'est bluffant!

Pour en savoir plus :

mardi 20 janvier 2009

Ubiquibot : le robot d'Ubiquity

Ubiquity est un projet du Mozilla Labs. Il se présente sous forme d'une extension à Firefox permettant d'utiliser son navigateur préféré à l'aide de commande. J'en avais déjà parler.

Hormis les dernières évolutions (importante) d'Ubiquity, le Mozilla Labs a cherché à définir un nouveau logo, et c'est Ubiquibot qui a gagné!

Le choix final c'est fait sur les 3 logos suivants :

Avec comme critère :

  • la connection émotionnelle
  • le possibilité de reprendre le logo
  • la métaphore

pour en savoir plus vous pouvez lire le billet d'Aza : New Ubiquity Logo: Semi-Final Round

mardi 9 décembre 2008

Sortie de Firefox 3.1 beta 2

La Foundation Mozilla vient de publier la deuxième version beta de Firefox 3.1, aka Shiretoko. Attention, cette version est une verison de test, donc à ne pas installer sur tous les ordinateurs.

D'un point de vue évolution, cette nouvelle beta apporte :

  • TraceMonkey par défaut!!!! Il n'est plus nécessaire d'activer la compilation Just In Time du JavaScript, pour profiter des dernières accélérations du moteur JavaScript de Firefox!
  • Web Worker Threads. Cette fonctionnalité que s'appuie sur le travail de normalisation du W3C, permet de faire proprement du multithread en JavaScript que ce soit dans une page Web ou dans une application XUL.
  • Amélioration des éléments <audio> et <video>. En plus des OGG l'élément audio supporte les .wav. Pour plus d'info sur ces éléments : using audio and video
  • et d'autres encores..

Pour plus d'information :

lundi 8 décembre 2008

JavaFX pas assez concurentiel par rapport au Web Ouvert

Sun vient de publier la première version de sa technologie RIA, JavaFX, qui devait permettre aux développeurs Java de pouvoir faire des interfaces modernes. Et bien d'après ce que rapporte lemondeinformatique, c'est râté. Les spécialistes des technologies Java ont eu l'impression de pouvoir faire des interfaces jolies en Java et simplement grâce à un langage de script, JavaFX, mais apparement il manque encore trop de chose par rapport à GWT ou AJAX!

Ce qui est intéressant dans cet article ce sont ces réflexions :

  • L'autre concurrent très en avance est tout simplement Ajax, ce mélange de HTML et Javascript.
  • Tim Bray lui-même, directeur des technologies Web de Sun (et co-inventeur de XML), explique sur son blog que HTML et le navigateur ont gagné.

Bien sûr Adobe et Microsoft, ne sont pas forcément du même avis sur le terrain de la guerre des RIA, mais serait-ce une première vrai victoire pour le Web Ouvert ? (Je rappelle qu'une technologie présentée par le labs de Microsoft utilise Canvas du HTML5 : Microsoft fait du Web Ouvert avec Seadragon-Ajax) Les forces commerciales pour promouvoir le Web Ouvert vont-elles s'accroitre avec le soutien de Sun ? La guerre continue...

lundi 1 décembre 2008

Microsoft fait du Web Ouvert avec Seadragon-Ajax

Le Microsoft Live Labs a publié il y a peu Seadragon-Ajax. Cette solution est le portage de la fonction DeepZoom de Silverlight sur le Web Ouvert. Il permet donc à tout ceux qui ne souhaite pas utiliser de technologie fermer dans leur page Web d'exploiter un système de zoom sur des images de hautes résolutions. Côté serveur ça reste du Microsoft, mais côté client c'est du Web ouvert. J'ai d'ailleurs été très surpris lorsque j'ai inspecter la page de présentation du projet avec FireBug:
Seadragon-Ajax s'appuie sur l'élément HTML5 canvas!

Je suis resté sur le cul. D'après tout ce que j'ai pus lire, Microsoft n'a pas prévu d'intégrer cet élément à son prochain navigateur IE8. Alors soit ils vont le faire, soit ils comptent sur d'autres comme Mozilla qui travail à un plugin permettant aux utilisateurs d'IE d'avoir la possibilité de profiter de cet élément. Par contre ce qui est sûr c'est que sur Firefox 3.1 ça doit être performant surtout avec JIT.

Je pense aussi qu'il y a un peu de marketing dans cette publication en montrant que Microsoft ne s'appuie pas que sur Silverlight et Internet Explorer pour conquérir le Web...

Autres articles :

lundi 17 novembre 2008

XULRunner, Flash et la mobilité (Platform ARM)

2 annonces concernant des cousins dans le domaine des interfaces riches ont été faites aujourd'hui ou dans les 24 heures précédent ce billet.

  • XULRunner 1.9.0.4 vient d'être publié en même temps que la nouvelle version de Firefox 3.0. Mark Finkle précise que des versions pour mobile sont disponibles.
  • Adobe vient de recentrer sont offre d'interfaçage riche autour de Flash et présente les dernières évolutions de son offre. Frédéric Cavazza, sur interfacesriches.org, précise qu'une version pour mobile est en préparation avec ARM.

Dans son compte rendu des évolutions de la platforme Flash, Frédéric Cavazza indique qu'il ne sait pas quels terminaux sont équipé d'une architecture ARM. Avant cela je savais que Maemo, utilisé par Nokia, était bati pour des architectures ARM. Mais je voulais en savoir plus, et j'ai donc découvert qu'un certains nombres d'objet mobile était basé sur une architecture ARM :

  • des console portables : Game Boy Advance, Nintendo DS, Nokia N-Gage
  • smartphone : blackberry, dell Axim, Palm TX
  • player mp3 : Zune, Ipod, Ipod Touch
  • téléphone portable : Nokia (E90, N93, N95, N82, N800, N810), SamSung HTC TyTN, IPhone

Donc si la concurence fait son travail, peut être qu'un jour nous pourrons faire tourner du Flash mais surtout des applications XULRunner sur IPhone! On peut rêver...

lundi 10 novembre 2008

Retourner un JSObject avec un XPCOM en C++

Je me suis lancé dans cette entreprise afin d'alléger l'utilisation de de XPConnect. L'objectif était de retourner un objet JavaScript au lieu d'un objet XPCOM. L'intérêt est de wrapper un objet C++ en JavaScript sans paser par de nombreux composants XPCOM. Le seul problème de cette technique est que l'on ne conserve pas de référence directe à l'Objet C++.

Récupérer le Context JavaScript

La première chose à faire est de récupérer le Context JavaScript, pour ce faire vous pouvez utiliser cette class créer par Paul :

class NativeJSContext {
  public:
    NativeJSContext() {
      if (!gXPConnect) {
        nsresult rv = CallGetService(nsIXPConnect::GetCID(), &gXPConnect);
        if (NS_FAILED(rv)) {
          NS_ERROR("Failed to get XPConnect!");
          return;
        }
      } else {
        NS_ADDREF(gXPConnect);
      }

      error = gXPConnect->GetCurrentNativeCallContext(&ncc);
      if (NS_FAILED(error))
        return;

      if (!ncc) {
        error = NS_ERROR_FAILURE;
        return;
      }

      ctx = nsnull;

      error = ncc->GetJSContext(&ctx);
      if (NS_FAILED(error))
        return;

      JS_BeginRequest(ctx);

      ncc->GetArgc(&argc);
      ncc->GetArgvPtr(&argv);
    }

    ~NativeJSContext() {
      JS_EndRequest(ctx);
    }

    nsAXPCNativeCallContext *ncc;
    nsresult error;
    JSContext *ctx;
    PRUint32 argc;
    jsval *argv;
};

Que vous exploiter ainsi :

 NativeJSContext js;
 if (NS_SUCCEEDED(js.error)) {
   /* Ici le code de création d'objet Javascript */
 }

Le Context JavaScript est nécessaire à la création de tout objet JavaScript et il est accessible ainsi :

 js.ctx /* tout simplement */

Créer un objet JavaScript

La première méthode consiste à créer un nouvel Objet JavaScript :

 JSObject *nJSObj = JS_NewObject(js.ctx, NULL, NULL, NULL);

Les méthode suivantes permettent de modifier l'objet en définissant ou ajoutant une propriété :

 jsval propval;
 JS_DefineProperty(js.ctx,nJSObj,"NewProp",propval,NULL,NULL,JSPROP_ENUMERATE);
 JS_SetProperty(js.ctx,nJSObj,"NewProp",&propval);

Créer un tableau JavaScript

La première méthode consiste à créer un nouveau tableau JavaScript :

 JSObject *nJSArray = JS_NewArrayObject(js.ctx, 0, NULL);

Les méthodes suivantes permettant d'ajouter un élément à notre tableau :

 jsuint len;
 JS_GetArrayLength(js.ctx, nJSArray, &len);
 jsval eleval;
 JS_SetElement(js.ctx,nJSArray,len,&eleval);

Créer des valeurs JavaScript

Comme vous avez pu le constater il faut créer des valeur JavaScript, jsval, pour pouvoir modifier vos objets JavaScript, objet et tableau.

La première méthode permet de transformer un objet ou un tableau en valeur JavaScript :

 jsval objval = OBJECT_TO_JSVAL(nJSObject);
 jsval arrayval = OBJECT_TO_JSVAL(nJSArray);

La seconde permet de transformer un entier en valeur JavaScript :

 jsval intval = INT_TO_JSVAL(100);

La troisième permet de transformer un nombre, double ou float, en valeur JavaScript :

 jsval numval;
 JS_NewNumberValue(js.ctx,10.50,&numval);

Enfin les méthodes suivantes permettent de transformer des chaines de caractères en valeur JavaScript :

 jsval strval;
 /* Pour un LITERAL ou une chaîne de caractères se finissant par null */
 strval = STRING_TO_JSVAL(JS_NewStringCopyZ(js.ctx,"une string"));
 /* Pour ne copier qu'un certains nombre de caractères */
 strval = STRING_TO_JSVAL(JS_NewStringCopyN(js.ctx,"une string",4));
 /* Pour créer une chaîne de caractères */
 strval = STRING_TO_JSVAL(JS_NewString(js.ctx,"une string",10));

Retourner l'Objet JavaScript créer

Voilà comment finir et faire en sorte que du côté JavaScript vous récupérier le réultat :

 jsval *retvalPtr = nsnull;
 js.ncc->GetRetValPtr(&retvalPtr);
 *retvalPtr = OBJECT_TO_JSVAL(featcol);
 js.ncc->SetReturnValueWasSet(PR_TRUE);

Conclusion

Maintenant vous avez tout ce qu'il faut pour créer vos premiers Objets JavaScript. Bien sûr Mozilla vous permet de faire plus comme créer des Class JavaScript ou des Fonctions JavaScript!

Voici le liste des références :

vendredi 31 octobre 2008

Aptana publie Jaxer 1.0 et sa version pro!

La société Aptana vient de publier la première version stable de son serveur AJAX, Jaxer! A téléchrager ici.

This 1.0 release of Jaxer is the culmination of three years of work to deliver this first-of-a-kind Ajax server that embeds the Mozilla Firefox browser engine within a server and full JavaScript application framework so that you can use your JavaScript and Ajax skills not just to create web pages but also to create full web applications on the server as well.

Cette version 1.0 de Jaxer est l'aboutissement de 3 ans de travail pour fournir le tout premier serveur AJAX qui intègre le navigateur Mozilla Firefox au sein d'un serveur et un framework d'application JavaScript complet ce qui signifie que vous pouvez utiliser vos compétences JavaScript et AJAX non pas seulement pour créer une page Web mais aussi une application Web complète sur serveur.

En plus de simplifier le développement d'application Web puisque vous n'utiliser qu'un seul langage et qu'il suffit de 'proxyfier' une méthode pour la rendre accéssible côté client alors qu'elle est exécuté côté serveur. Les dernières évolutions de Jaxer permettent de facilement mettre en oeuvre un service REST grâce au support d'une API RESTFull, ausupport natif du JSON mais aussi de E4X (XML for JavaScript). Vos réalisation avec Jaxer peuvent ainsi être exploiter par une large gamme d'applications que ce soit de l'AJAX, des Gadgets Web, Facebook ou une application Open Social, mais aussi basé sur Adobe Flash ou Microsoft Silverlight. Sans oubliés que de plus en plus d'outils mobiles comme l'IPhone d'Apple ou les téléphones d'autres constructeurs supportent de mieux en mieux JavaScript et AJAX.

As you can imagine we're excited to see JavaScript become more and more the lingua franca of Web applications. It's already ubiquitous on the client side and now you can use it confidently on the server side.

Comme vous pouvez l'imaginé, nous sommes heureux de voir le JavaScript devenir de plus en plus le lingua franca des applications Web. Il est déjà omniprésent côté client et vous pouvez l'utiliser en toute confiance côté serveur.

Il existe une introduction à Jaxer sous forme de screencast qui montre la base de jaxer et des exemples d'utilisations de

<script runat="server | both | server-proxy" >.

Jaxer 1.0 est disponible sous 2 licences. Il est disponible pour tous sous licence gratuite et Open Source ou en édition Pro sous une licence commerciale avec le support d'Aptana. Jaxer est aussi disponible en version Cloud sur l'Aptana Cloud.

Annonce officiel.

jeudi 30 octobre 2008

XULFR a 5 ans

Il y a 5 ans, Laurent Jouanneau lançait xulfr.org sans prétention. 5 ans plus tard xulfr est une association, l'un de ses membres, paul, est embauché par Mozilla et la communauté ne cesse de grandir. Mais celui qui parle le mieux de cette évènement n'est autre que la personne par qui tout est arrivé.

Je profite de cette anniversaire pour remercier Laurent, Paul et les autres car grâce à eux je travaille tous les jours avec des technologies graves mortelles!

Anniversaire xulfr

mardi 28 octobre 2008

Paul rejoint Mozilla

Paul a officiellement annoncé aujourd'hui qu'il avait rejoint Mozilla Europe en tant que Tech Evangéliste. En d'autres termes Paul est chargé de promouvoir les technologies Mozilla mais aussi les nouveautés du Web Ouvert (éléments video, audio, canvas, l'API drag&drop, de géolocalisation, etc). Il devrait aussi se charger d'organiser des évènements à travers l'Europe et d'apporter son savoir faire dans la création d'association de promotion des technologies Mozilla.

Bonne continuation dans ton nouveau travail Paul!

Autres liens :

jeudi 18 septembre 2008

Créer son nsIProtocolHandler pour afficher un buffer (char *)

Dans le cadre de la réalisation de mon premier composants XPCOM en C++, j'ai dû résoudre le problème suivant : Comment récupérer un buffer pour le manipuler en JavaScript et l'afficher via la définition d'un nouveau protocol ?

Voici mes découvertes :

nsIBinaryOutputStream

L'objet JavaScript suivant permet d'écriture dans un output stream :

Components.classes"@mozilla.org/binaryoutputstream;1"
  .createInstance(Components.interfaces.nsIBinaryOutputStream);

Un tel objet permet de récupérer le buffer générer au sein de mon composant C++ via la méthode writeByteArray qui prend en paramètre le buffer (char *) et la taille de celui-ci. J'ai donc créer une méthode saveToStream qui prend en paramètre un objet implémentant l'interface nsIBinaryOutputStream.
Par exemple pour écrire dans un fichier :

// création d'un fichier local
var aFile = Components.classes"@mozilla.org/file/local;1".createInstance(Components.interfaces.nsILocalFile);
aFile.initWithPath( "/tmp/buffer");
// création du OutputStream associé au fichier
var stream = Components.classes"@mozilla.org/network/file-output-stream;1".createInstance(Components.interfaces.nsIFileOutputStream);
stream.init(aFile, 0x04 | 0x08 | 0x20, 0600, 0);
// création du binary output stream
var bos = Components.classes"@mozilla.org/binaryoutputstream;1".createInstance(Components.interfaces.nsIBinaryOutputStream);
// cette étape va permettre d'écrire dans l'output stream du fichier
bos.setOutputStream(stream);
// écriture du buffer dans l'output stream du fichier
myComponent.saveToStream(bos);
// il n'y a plus qu'à fermer les flux pour finaliser l'écriture du buffer dans le fichier
bos.close();
stream.close();

Grâce au Binary Output Stream je suis capable d'écrire le buffer générer dans mon composant XPCOM dans un fichier.

nsIChannel et nsIPipe

Dans Mozilla, il est possible de définir son propre protocol. La principale étape est de définir la méthode newChannel qui prend en paramètre un objet implémentant l'interface nsIURI et doit retourner un objet implémentant l'interface nsIChannel. Dans mon cas c'est dans cette méthode que j'utilise mon composant et donc que je récupère un objet implémentant l'interface nsIOutputStream. Or un nsIChannel est basé sur un objet implémentant une interface nsIInputStream. Il fallait trouver le moyen d'obtenir le input stream associé à l'output stream.

L'objet JavaScript suivant permet de lié input stream et output stream :

Components.classes"@mozilla.org/pipe;1".createInstance(Components.interfaces.nsIPipe);

Enfin il fallait faire de l'input stream obtenu un objet implémentant l'interface nsIChannel, c'est ce que permet l'objet suivant :

Components.classes"@mozilla.org/network/input-stream-channel;1".createInstance(Components.interfaces.nsIInputStreamChannel);

La méthode newChannel s'implémente ainsi :

myProtocolHandler.prototype.newChannel = function(aURI) {
     // création du pipe
     var pipe = Components.classes"@mozilla.org/pipe;1".createInstance(Components.interfaces.nsIPipe);
     pipe.init(true,true, 0, 0, null);
     // création du binary output stream
     var bos = Components.classes"@mozilla.org/binaryoutputstream;1".createInstance(Components.interfaces.nsIBinaryOutputStream);
     // cette étape va permettre d'écrire dans l'output stream du pipe
     bos.setOutputSTream(pipe.outputStream);
     // écriture du buffer dans l'output stream du pipe
     myComponent.saveToStream(bos);
     // fermeture des output stream
     bos.close();
     pipe.outputStream.close();
     // il reste plus qu'à créer le channel
     var channel = Components.classes"@mozilla.org/network/input-stream-channel;1".createInstance(Components.interfaces.nsIInputStreamChannel);
     channel.setURI(aURI);
     channel.contentStream = pipe.inputStream;
     channel.QueryInterface(Components.interfaces.nsIChannel);
     return channel;
}

C'est bien mais c'est synchone...

nsIPipe et nsIThreadManager

La dernière étape consiste à faire en sorte que la création du buffer et l'écriture soit asynchrone. Ce qu'il faut savoir c'est que le pipe permet d'écrire dans un thread et de lire le résultat dans un autre, de plus tant que rien n'est écrit dans l'output stream du pipe rein n'est lu, enfin lorsque l'output stream est clos le channel et donc la requête qui a été créer à partir de l'input stream du pipe est considéré comme fini.

Il faut d'abord définir un thread d'exécution :

var workingThread = function(pipe, myComponent) {
   this.pipe = pipe;
   this.component = myComponent;
};
workingThread.prototype = {
  run: function() {
    try {
      var bos = Cc"@mozilla.org/binaryoutputstream;1".createInstance(Ci.nsIBinaryOutputStream);
      bos.setOutputStream(this.pipe.outputStream);
      this.component.saveToStream(bos);
      bos.close();
      this.pipe.outputStream.close();
    } catch(err) {
      Components.utils.reportError(err);
    }
  },
  
  QueryInterface: function(iid) {
    if (iid.equals(Ci.nsIRunnable) ||
        iid.equals(Ci.nsISupports)) {
            return this;
    }
    throw Components.results.NS_ERROR_NO_INTERFACE;
  }
};

Ensuite il suffit de déclarer un objet global permettant l'exécution en fond de tâche :

background = Components.classes"@mozilla.org/thread-manager;1".getService().newThread(0);

Il ne reste plus qu'à réécrire la méthode newChannel du protocol handler :

myProtocolHandler.prototype.newChannel = function(aURI) {
     // création du pipe
     var pipe = Components.classes"@mozilla.org/pipe;1".createInstance(Components.interfaces.nsIPipe);
     pipe.init(true,true, 0, 0, null);
     // appel en fond de tâche de la création du buffer et de l'écriture
     background.dispatch(new workingThread(pipe, myComponent), background.DISPATCH_NORMAL);
     // il reste plus qu'à créer le channel
     var channel = Components.classes"@mozilla.org/network/input-stream-channel;1".createInstance(Components.interfaces.nsIInputStreamChannel);
     channel.setURI(aURI);
     channel.contentStream = pipe.inputStream;
     channel.QueryInterface(Components.interfaces.nsIChannel);
     return channel;
}

En espérant que ça puisses vous servir ;-)

mardi 16 septembre 2008

Effets SVG sur du HTML

Après l'intégration des tranformations CSS3, Robert O'Callahan annonce la possibilité d'utiliser les effets SVG sur du contenu HTML. Le Web Ouvert va vraiment devenir sympa ;-)

mardi 17 juin 2008

Firefox 3 Download Day

Firefox 3 Download Day

C'est pour aujourd'hui, à partir de 19H dixit Tristan Nitot

- page 2 de 4 -