insideIT.fr : le blog des architectes IT de SFEIR

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

mercredi 11 février 2009

Editing Google Spreadsheets rows with Google Data API and GWT

In a previous article (here), we saw how to display Google Spreadsheets content with the Google Data API Java client and CellFeed objects.

This time, the proof of concept application shown below uses ListEntry objects to fetch our worksheets content, using header names (see (1) and (2) in the following screenshot) and unique identifiers (see (3)) instead of x and y positioning system.

You will find the source code at the bottom.

The following piece of code shows how to fetch every row entries in a worksheet into a HashMap which maps each row identifier to its ListEntry object:


  1         Map<String, ListEntry> listEntries =
2 new HashMap<String, ListEntry>();
3 List<WorksheetRow> rows = new ArrayList<WorksheetRow>();
4 try
5 {
6 ListFeed feed = sService.getFeed(new URL(sheetFeedURL),
7 ListFeed.class);
8 for (ListEntry entry : feed.getEntries())
9 {
10 WorksheetRow clonedRow = new WorksheetRow();
11 clonedRow.setTitle(entry.getTitle().getPlainText());
12 clonedRow.setId(entry.getId().substring(
13 entry.getId().lastIndexOf('/') + 1));
14 listEntries.put(clonedRow.getId(), entry);
15 CustomElementCollection elementColl =
16 entry.getCustomElements();
17 WorksheetRow.CustomElement rowElement =
18 new WorksheetRow.CustomElement();
19 for (String value : elementColl.getTags())
20 {
21 rowElement.put(value,
22 elementColl.getValue(value));
23 }
24 clonedRow.setElement(rowElement);
25 rows.add(clonedRow);
26 }
27 getSession().setAttribute("listEntries", listEntries);
28 } catch (MalformedURLException e) ...

Each ListEntry object has a list of «Tag» (column names) and a HashMap which maps each tag name to its value in the current entry. Note that each column name is automatically made unique.

To update a row with a modified WorkSheetRow object, we get its associated ListEntry object and set every value of the WorkSheetRow object with the «setValueLocal» method.


  1     public void updateWorkSheetRow(WorksheetRow row) throws AuthException
2 {
3 Map<String, ListEntry> listEntries = (Map<String, ListEntry>) getSession().getAttribute("listEntries");
6 ListEntry entry = listEntries.get(row.getId());
7 for (String tag : row.getElement().keySet())
8 {
9 entry.getCustomElements().setValueLocal(tag, row.getElement().get(tag));
10 try
11 {
12 entry.update();
13 } catch (IOException e)...

Then we simply have to call the modified entry update method.

Going further

Row editing in Spreadsheets API is not limited to the ListEntry class: Indeed, there is also a ListQuery class which enables advanced selection for your Worksheets.

Listing in reverse order:

In order to list the rows in reverse order, you just have to set the «reverse» property of a ListQuery object to «true» and pass this object to the SpreadsheetService object


  1     ListQuery query = new ListQuery(listFeedUrl);
2 query.setReverse(true);
3 ListFeed feed = service.query(query, ListFeed.class);
4 for (ListEntry entry : feed.getEntries())
5 { ...

Full-text search:

For full-text search, use the «setFullTextQuery» method. Note that you can pass several strings.


  1     ListQuery query = new ListQuery(listFeedUrl);
2 query.setFullTextQuery("Florent Tue");
3 ListFeed feed = service.query(query, ListFeed.class);
4 for (ListEntry entry : feed.getEntries())
5 { ...

Structured query:

Structured queries can filter the list by a particular value to a column name. You can also set the ordering of the listing with a column name.


  1     ListQuery query = new ListQuery(listFeedUrl);
2 query.setSpreadsheetQuery("name = 'Florent'");
3 query.setOrderBy("column:name");
4 ListFeed feed = service.query(query, ListFeed.class);
5 for (ListEntry entry : feed.getEntries())
6 { ...

Useful Links:

Article related downloads:

lundi 9 février 2009

Leveraging Google Data APIs Java client library with GWT

While the Java client library for Google DATA API can’t be compiled by the GWT compiler, you can still use it in RPC Servlets with the advantage of hiding the protocol or substituting the default authentication backend with yours.

The screenshot below shows an example of a simple GWT application made up of a tree widget displaying my spreadsheets and their worksheets, and a grid widget on which appears the selected worksheet.

The source code of this demo is at the bottom.

Google Data APIs are based on Atom and RSS formats and the Atom Publishing Protocol. Since they are REST-styled, you may use them with any browser:

First we need to authenticate to the service we want to use (Google Spreadsheets in our case) with our Google account. The easiest way is to use the ClientLogin interface:

$ export TOKEN=`curl https://www.google.com/accounts/ClientLogin \
-d Email=cappelle.florent@gmail.com -d Passwd=$GDATA_PASSWORD \
-d accountType=HOSTED_OR_GOOGLE \
-d source=SFEIR-GWTSheets-1 \
-d service=wise | grep 'Auth=' | cut -d'=' -f2`

The service parameter is the Google service we want to use; in this case the «wise» value stands for the spreadsheets service. If the login is successful, the response will include a token which we will use in the next requests. Note that in some cases the service may require a CAPTCHA challenge to be done.

Then we request the list of the spreadsheets we include our token in the Authorization header:

$ curl -H "Authorization: GoogleLogin auth=$TOKEN" \
"http://spreadsheets.google.com/feeds/spreadsheets/private/full" > SpreadsheetList.xml

Querying and editing our spreadsheets this way (you would have to build PUT requests with XML) would be quite inefficient. Instead of parsing XML and building HTTP requests, you may use the Java client library which already does this for you with the SpreadsheetService class:


  1         SpreadsheetService sService;
  2         sService = new SpreadsheetService("SFEIR-GWTSheets-1");
  3         try
  4         {
  5             sService.setUserCredentials(email, password);
  6             logger.info(email + " authentication successful");
  7             getSession().setAttribute("sService", sService);
  8         } catch (AuthenticationException e)
  9         {
 10             logger.log(Level.WARNING, e.getMessage());
 11             thrownew AuthException(e.getMessage());
 12         }

The preceding piece of code is extracted from a GWT-RPC Service method:

  • The «setUserCredentials» method requests a token and stores it in the sService object, which we store in the session for the next requests.
  • If the login fails or a CAPTCHA challenge is needed, an AuthException is thrown back to the client.

Once the user is logged in, we build a feed URL with the FeedURLFactory class (see the following piece of code). Its «getSpreadsheetsFeedUrl» returns the URL for the spreadsheet list feed, which then is fetched by the SpreadsheetService object (sService).


  1         List<SpreadsheetEntry> spreadsheetEntries = null;
  2         FeedURLFactory factory = FeedURLFactory.getDefault();
  3         SpreadsheetFeed feed;
  4
  5         try
  6         {
  7             feed = service.getFeed(factory.getSpreadsheetsFeedUrl(),
  8                     SpreadsheetFeed.class);
  9             spreadsheetEntries = feed.getEntries();
 10             getSession().setAttribute("spreadsheetEntries",
 11                     spreadsheetEntries);
 12         } catch (IOException e) ...

The «getEntries» method returns a list of SpreadsheetEntry: Each of these entries contains standard Atom information (author, title, etc) and a worksheet list feed URL. However we don’t even need to build a feed URL since the «getWorksheets» method directly returns a list of WorksheetEntry.

The SpreadSheetModel is a list of Worksheet which is returned to the GWT client: the title and the dimensions of each worksheet are used by the tree and the grid widgets. The cell feed URL is also needed to fetch the content of each cell.


  1         SpreadSheetModel model = new SpreadSheetModel();
  2         try
  3         {
  4             List<WorksheetEntry> worksheetEntries =
  5                     entry.getWorksheets();
  6             for (WorksheetEntry sheet : worksheetEntries)
  7             {
  8                 model.add(new SpreadSheetModel.WorkSheet(
  9                         sheet.getTitle().getPlainText(),
 10                         sheet.getCellFeedUrl().toExternalForm(),
 11                         sheet.getRowCount(), sheet.getColCount()));
 12             }
 13         } catch (IOException e) ...

At the client side, the code that fills the tree widget is pretty simple:


 1             public void onSuccess(SpreadSheetModel model)
 2             {
 3                 TreeItem item = getItem(position);
 4                 for (SpreadSheetModel.WorkSheet sheet : model)
 5                 {
 6                     TreeItem newItem = item.addItem(sheet.getTitle());
 7                     newItem.setUserObject(sheet);
 8                 }
 9                 // remove the empty child (see populate method)
10                 item.getChild(0).remove();
11                 item.setState(true, false);
12             }

Once the user clicks on a worksheet title in the tree, the worksheet feed URL is given to a RPC method «fetchworksheetcells», which returns a list of cells: the Cell class of the Google API can’t be used as it is in the client side, so we have to copy its properties to a DTO class (WorksheetCell). «copyProperties» of the Apache Commons Beanutils library does this in a single line.


  1         List<WorksheetCell> cells = new ArrayList<WorksheetCell>();
  2         try
  3         {
  4             CellFeed feed = sService.getFeed(new URL(sheetFeedURL),
  5                     CellFeed.class);
  6             List<CellEntry> cellEntries = feed.getEntries();
  7             for (CellEntry entry : cellEntries)
  8             {
  9                 Cell cell = entry.getCell();
 10                 WorksheetCell clonedCell = new WorksheetCell();
 11                 BeanUtils.copyProperties(clonedCell, cell);
 12                 cells.add(clonedCell);
 13             }
 14         } catch (MalformedURLException e) ...

Note that worksheet feeds also have a list feed, which enables relational alike manipulation of worksheet data. Insertion, modification and deletion are very easy with the Java client, for example the modification of a cell entry needs two lines of code:


  1     cellEntry.changeInputValueLocal(newValue);
  2     cellEntry.update();

Useful Links:

Article related downloads:

vendredi 6 février 2009

GWT Time Picker widget

A l'instar du composant "Time Picker" réalisé autour de jQuery http://haineault.com/media/jquery/ui-timepickr/page/, j'ai voulu réaliser un composant aux fonctionnalités proches mais en pur GWT. Voici donc ce composant, ou plutôt l'embryon de ce composant car le développement n'est pas encore achevé et des fonctionnalités restent en suspens.

Il s'agit pour moi plus d'un POC que d'un composant encore exploitable. S'il suscite l'intérêt, je travaillerai à l'améliorer.

La démo est accessible à cette adresse :
TimePickerEntryPoint

La page du projet et le code source sont disponibles ici :
code.google.com/p/gwt-incubator-lib

Screenshot :
GWTTimePicker

jeudi 11 décembre 2008

Roadmap GWT (1.6 et après)

Encore un post intéressant sur le blog de l'équipe GWT !
Cette fois, le sujet est le futur... Au programme de GWT 1.6 (prévu pour le premier trimestre 2009) :

* New compiled file deployment structure
* Migration from Tomcat to Jetty hosted mode server
* Uniform event handlers
* DatePicker, LazyPanel migrated in from incubator
* String performance improvements
* Compiler performance improvements

Et pour l'après 1.6 :

* Developer Guided Code splitting
* Analysis of compiled code, aka Story of your compile (SOYC)
* In-browser hosted mode, aka Out-of-process Hosted Mode (OOPHM)
* UI Binder
* Client Bundle
* RPC performance improvements

What's ahead for Google Web Toolkit

mercredi 10 décembre 2008

Google Visualization API pour GWT

La famille des APIs Google pour GWT s'agrandit avec la librairie Google Visualization pour GWT. L'annonce est encore chaude sur le blog de l'équipe GWT.

Le but de l'API Google Visualization est de permettre d'accéder à de multiples sources de données structurées pour les afficher, en choisissant parmi une large sélection de visualisations.

mercredi 3 décembre 2008

Release de SmartGWT

Sanjiv, le créateur de GWT-Ext vient de sortir la première release de SmartGWT. Sanjiv a réussi à sortir un wrapping de la librairie JavaScript SmartClient en à peine 4 mois !

SmartGWT reprend les principales fonctionnalités de GWT-Ext auxquelles s'ajoutent un databinding puissant, d'avantages de widgets (notamment le composant Calendar, un Google Agenda simplifié) et de meilleures performances d'affichage. Sanjiv a su prendre du recul par rapport à sa précédente expérience, et présente une librairie mieux adaptée au développement d'applications de gestion. Allez voir les sources, vous verrez que l'utilisation des composants graphiques et des datasources se fait de façon beaucoup plus simple qu'auparavant.

Utilisation d'une grille éditable à la volée

A cela s'ajoute une très grande réactivité de l'équipe : critiqués sur leurs styles un peu old school, ils sont déjà en train d'y remédier.

Quelques indicateurs :

  • GWT-Ext incite à passer sur SmartGWT : lien
  • Evolution du nombre de posts du google group GWT-Ext : lien

vendredi 14 novembre 2008

Joda-Time pour GWT : Goda-Time

Pour les utilisateurs de GWT appréciant l'API Joda-Time, bonne nouvelle !

Goda-Time, a GWT port of Joda-Time, has just been forked from gwittir. Goda-Time is looking for volunteers.

Description du projet :

GWT port of Joda-Time

Originally found in the gwittir project. As of Nov 12th 2008 kebernet, the owner of gwittir, has been silent for 5 months. Goda-Time needed its own project anyway. I ripped Goda-Time out of the gwittir source tree and made it compile on its own.

Goda-Time still needs help with cleanup and unit tests. Goda-Time needs volunteers. Send a message to the group to indicate your interest.

En français :
Après une longue inactivité du projet Gwittir qui comprend une ébauche du port de l'API Joda-Time pour GWT, voici le projet Goda-Time qui reprend cette ébauche avec pour but de la compléter.
Ce projet est ouvert, toute participation est la bienvenue.

Goda-Time

mercredi 15 octobre 2008

Jetty or Tomcat for GWT 1.6 ?

Bruce Johnson (tech lead of the Google Web Toolkit ) :

The GWT team has started putting together a 1.6 roadmap, which we'll publish as soon as we have it nailed down. Two of the areas we want to work on for 1.6 are some improvements to hosted mode startup time and a friendlier output directory structure (something that looks more .war-like).

As part of this effort, we've all but decided to switch the hosted mode embedded HTTP server from Tomcat to Jetty. Would this break you? (And if so, how mad would you be if we did it anyway?)

Less than two months after the release of GWT 1.5, the GWT team is already asking the community for its opinion for GWT improvement for 1.6 roadmap. In this post, Bruce Johnson is asking the community if it would rather have Jetty or Tomcat as the hosted mode embedded HTTP. Unfortunately, I do not know Jetty enough to have an opinion. But if you know both Jetty and Tomcat, you should not hesitate to participate in this debate.

GWT et accessibilité

Google Web Toolkit Blog :

As described in our earlier article outlining ARIA support in GWT1.5, widgets now include basic support for W3C ARIA, an emerging set of Web standards that enable AJAX applications to work smoothly with screenreaders. But there is more to using an application than interacting with individual user interface widgets — overall usability is determined by the complete user experience.

We have improved the usability of Google Health for screenreader users by enhancing the built-in support available in GWT 1.5 via JavaScript. The resulting user experience enables users of screenreaders and self-voicing browsers to easily navigate the interface to obtain relevant auditory feedback.

Pour les personnes intéressées par la problématique d'accessibilité dans une application GWT, Google vient d’annoncer l’ajout de cette fonctionnalité dans Google Health. Pour rappel, Google Health est une application de gestion de dossiers médicaux états-uniens développée avec GWT.

mercredi 24 septembre 2008

Extension de la boîte à outil GWT

Google Web Toolkit Blog :

Following up on our earlier post, a release candidate of the Google Maps API Library for GWT is now available for download. This library provides a way to access the Google Maps API from a GWT project without having to write additional JavaScript code. The library gives you full control using the standard Maps components such as InfoWindows, Markers, MapTypes, and Geocoding. You can even use advanced features such as adding GWT widgets to the Map, creating custom overlays, custom map types, and other components.

In addition to maps, the Google API Libraries for GWT also provide libraries for Gears, Gadgets and the Google AJAX Search API. Please try out these release candidates and give us feedback, either through the issue tracker on code.google.com, or through the Google-Web-Toolkit or Google-Web-Toolkit-Contributors group.

C'est chaud bouillant !

Google vient d'annoncer la sortie de la release candidate de son API Google Maps pour GWT. Tout un programme qui ne se limite pas à l'accès des maps depuis GWT mais également à l'intégration de composants GWT dans les maps. Pour couronner le tout, cette librairie ne se limite pas seulement à Google Maps, mais vient également grignoter sur les plate-bandes de Gears, Gadgets et Google AJAX Search API.

Je me joins à l'équipe GWT pour vous inviter à tester cette librairie au plus vite !

mercredi 10 septembre 2008

GWT-Incubator et GWT 1.5

gwt_canvasL'équipe GWT vient d'annoncer la sortie d'une version de GWT-Incubator compatible avec GWT 1.5.

GWT-Incubator est l'incubateur de l'équipe GWT pour développer de nouveaux Widgets (DatePicker, ProgressBar, Tables, ...) et librairies (GWT logging suite, CSS resource).

A noter, l'apparition du Widget GWTCanvas :)

mardi 2 septembre 2008

Telecharger Google Chrome en francais

Google Chrome le navigateur 'made by Google' est disponible en téléchargement et en version française.

Vous pouvez le télécharger à l'adresse suivante http://www.google.com/chrome?hl=fr

A tester donc :

  • sa rapidité d'exécution Javascript, puisque Chrome intègre un JIT Javascipt nommé V8
  • sa stabilité, en effet chaque onglet présent sur le navigateur possède son propre espace d'exécution, du coup lorsqu'un onglet ne répond plus, il ne bloque pas la totalité du navigateur. A la fermeture d' un onglet son processus est totalement libéré
  • sa sécurité, puisque chaque processus possède sa propre 'sandbox', de plus Chrome fait appel à des listes noires de sites suspects afin d'avertir l'utilisateur et éviter le phishing ou le malware.
  • sa rapidité de rendu, car Chrome utilise le rendu du moteur web open source Webkit, les équipes du projet d'OS mobile Android utilisant déjà ce rendu
  • le mode offline via l'utilisation de Google Gears
  • mode incognito, pour surfer en anonyme sur le net

L'avenir nous dira si Google Chrome aura réussi à 'éclipser' les navigateurs tels que IE ou Firefox de nos machines.


Mesdames, Messieurs, à vos téléchargements.

GWT in the AIR Milestone 1

Logo Adobe AIR Avec la sortie de Google Chrome, Didier Girard annonce sur onGWT : "le navigateur est la plateforme".

Pourtant la plateforme n'est pas encore morte. Par exemple, le projet GWT in the AIR vient d'annoncer la sortie de sa version Milestone 1. Pour rappel, l'objectif de ce projet est de permettre le développement d'application AIR, c'est à dire d'application desktop s'exécutant dans la runtime AIR d'Adobe, à partir de code GWT.

GWT in the Air rend l'API AIR d'Adobe disponible en GWT via JSNI. Ce projet fournit également des outils facilitant le développement d'application AIR en GWT dont des outils de test. Le point faible du projet est le manque de documentation bien que le chantier soit en cours. Pour le moment, il faut se référer au showcase et à la documentation AIR d'Adobe.




English version:

With Google Chrome release, Didier Girard announces on onGWT : "the browser is the platform".

But the platform is not dead yet. For instance, GWT in the AIR just released its Milestone 1 version. A quick reminder: the aim of this project is to allow the development of AIR applications, i.e. desktop applications running on top of the Adobe AIR runtime, from GWT code.

GWT in the AIR makes the Adobe AIR API available for GWT using JSNI. This project also provides tools to ease "GWT in Adobe AIR" development includint test tools. The weakness of this project is its lack of documentation but it seems to be progressing. For the moment, the showcase and Adobe AIR documentation should be your starting points.

lundi 1 septembre 2008

Revue de presse GWT / Gears

Sortie de la version finale de GWT 1.5

Depuis la sortie de la version RC, on l'attendait avec impatience, c'est maintenant chose faite : la version finale de GWT 1.5 est sortie.
Au programme des nouveautés, on notera tout particulièrement :
  • support de Java 5
  • amélioration des performances
  • amélioration de l'intéropérabilité avec javascript
  • amélioration des widgets
  • intégration d'un premier niveau d'accessibilité
  • une meilleure documentation avec notamment un showcase
GWT 1.5 Now Available
Sortie de GWT 1.5
ShowCase GWT


Et si vous rendiez vos applications Web Offline avec Gears et GWT 1.5 ?

Octo publie une série de 3 billets sur le thème "Et si vous rendiez vos applications Web Offline ?".
La première partie présente les enjeux des applications web déconnectées, tandis que les deux autres parties expliquent, exemple de code à l'appui, comment implémenter de telles applications, et ce, en proposant deux approches possibles (passage du mode connecté au mode déconnecté explicite ou implicite).
Outre les exemple de code illustrant le propos, on appréciera la mise en exergue des problèmatiques soulevées par ce nouveau type d'application, et ce, sans fausse complaisance.
Et si vous rendiez vos applications Web Offline [Part #1]
Et si vous rendiez vos applications Web Offline [Part #2]
Et si vous rendiez vos applications Web Offline [Part #3]


Sortie de Google Gears pour Safari

Google vient de sortir Gears pour Safari. Pour l'instant, il ne s'agit que d'une version beta.
Au delà de la nouvelle, Google Gears commence à avoir un support multi-plateformes relativement intéressant, avec le support de Windows, Windows Mobile, Mac, et Linux côté OS ; et le support de Internet Explorer, Firefox et Safari côté navigateur.
Si l'on ajoute à cela le fait que Google met en avant Gears, en rendant possible l'utilisation offline de ses services phares (Docs, Reader, Mail, ...) avec Gears, il ne serait pas surprenant que d'ici peu, les décideurs des entreprises s'intéressent de près à cette technologie et à la possiblilité de rendre offline leurs applications web.
A suivre...
Google posts Gears for Safari beta


mercredi 30 juillet 2008

NouvelleCuisine : a portal for the masses

NouvelleCuisine is a product that will allow you to enhance creativity, information sharing, and collaboration.

NouvelleCuisine has two key features :

  • Setup is based on one of the most common computer skills : spreadsheets.

  • The requirements to deploy it are extremely simple: a simple web server (Apache, IIS, lighttpd, etc) is all that you need

Here is an example of what can be accomplished with our product :

NouvelleCuisine Example

Global architecture of NouvelleCuisine



The contents of the portal are described in a Google Spreadsheet. When NouvelleCuisine starts, it reads the Spreadsheet and adds widgets (or gadgets) to the page depending on what it finds in the configuration spreadsheet. It is possible to have widgets for Youtube, Slideshare presentations, RSS Feeds, Google Documents, Google Maps... And if the widget for your content is not available, it is possible to add a new type of widget.

Global architecture

Collaboration


The main goal of NouvelleCuisine is to improve collaboration between people. With this solution, there are no technical brakes, everybody can administrate his own content and publish it to the portal.

Example of collaboration allowed by NouvelleCuisine

Serverless


Technically speaking, the application has been developed with nothing but GWT 1.5, and a GWT-based library called GWT-DND for Drag&Drop functionality. There is no server side code, everything is client side: putting the portal on a simple web server is sufficient to allow access to your portal to people around the world.

We called our project NouvelleCuisine, in reference to the French word characterising the new French cooking trend. For us, this portal is a way to get a mashup solution with no infrastructure costs.

The possibilities offered are very large because anybody can use this portal to present his vision of a specific theme.


Demonstrations


You will find portals using NouvelleCuisine here
Currently, there are three samples :


vendredi 27 juin 2008

GWT, Data binding et IHM auto générée

Lorsqu'il s'agit de construire des IHM, la problématique de binding (uni ou bi directionnel) avec les objets à présenter, voire la génération automatique de leur représentation, est rapidement au centre du débat.

Selon la techno utilisée pour construire l'IHM des solutions existent souvent et remplissent tout ou partiellement cette tâche. Cependant s'il existe un domaine dans lequel GWT n'excelle pas (encore), c'est bien celui-là. La faute à plusieurs facteurs : - Google ne fournit pas (encore?) de moyens simples dans l'API pour y arriver - L'API Reflection fait cruellement défaut pour remplir cette tâche de façon aisée - C'est une problématique assez complexe qui nécessite de trouver un savant équilibre entre personalisation possible (par exemple laisser un controle possible sur la façon de transtyper des données via des "type converters" ) et simplicité de mise en oeuvre (car à la base c'est le but de simplifier les choses).

Cependant le gain apporté par ces solutions est tellement évident qu'inévitablement des personnes se sont penchées sur ce manque pour le combler.

Parmi les solutions commençant à apparaitre pour GWT, je voulais en mettre une en avant aujourd'hui. Il s'agit de Metawidget (http://www.metawidget.org). Elle a été présentée recemment sur TSS et méritait un écho ici.

Metawidget

Metawidget se définit comme un outil de mapping objets <-> IHM. L'atout majeur d'un tel outil est sa capacité à introspecter des objets et en construire une représentation graphique. Sa particularité est de pouvoir générer des IHM selon différentes technologies comme : Swing, JSF, Struts, Android et tout recemment GWT. Cela en fait un outil interessant car polyvalent.

Metawidget utilise une approche assez intelligente, et surtout très pragmatique, pour introspecter les objets pour GWT. Ce dernier ne rend pas possible la reflection coté client ? Qu'à cela ne tienne : le serveur va s'en charger ! L'idée sous-jacente est de proposer - de façon transparente - un service dédié à l'introspection en "remote" des objets du modele ; objets dont la particularité avec GWT est d'exister tant coté client (en équivalent Javascript) que coté serveur... (en Java donc). C'était une idée toute simple et efficace, conforme au principe bien connu et éprouvé : "keep it simple, stupid" ! ;-)

Pour détailler un peu le fonctionnement de Metawidget, voici quelques éléments important caractérisant cet outil : - Metawidget s'articule autour de 2 concepts majeurs : les Metawidgets et les Inspectors. Les premiers auront la responsabilité de générer la représentation dans la techno retenue (des MetaWidgets existent pour chacune), tandis que les Inspectors sont chargés d'extraire les informations des objets du modele à présenter (et ce selon différentes stratégies représentées par différentes implémentations comme les *AnnotationInspectors, le PropertyTypeInspector, l'HibernateValidatorInspector, l'XMLInspector...). - les Inspectors peuvent se completer les uns avec les autres pour obtenir une description la plus détaillée possible de l'objet. Ils peuvent aussi etre totalement personnalisés : il est possible d'écrire sa propre implémentation. - la personalisation du rendu par surcharge ou ecriture de MetaWidgets est aussi rendue possible. Vive le design par interface ! ;-) - le support des "datatypes converters" est présent et il est très simple d'ecrire ses propres convertisseurs.

A plus d'un titre cet outil mérite d'être considéré, même si encore jeune (les premières versions remontent à début 2008) et pas encore assez connu.

Si vous souhaitez aller plus loin, voici le lien : (http://www.metawidget.org)

vendredi 6 juin 2008

Happy Hour GWT du mercredi 4 juin

la_cantine Tout d'abord un grand merci à tous ceux qui sont venus, pour s'être déplacé et pour leur questions et leur attention. Et encore toutes nos excuses à ceux qui n'ont pu être reçus faute de place. La volonté était de limiter le nombre de participants pour rendre les speakers plus accessibles au dialogue.
Et le dialogue n'a pas manqué de s'installer dans les sessions (témoin le débordement général sur le planning de départ), ce qui montre la justesse de la formule et nous motive pour renouveler l'expérience.

L'événement s'est déroulé à La Cantine (par Silicon Sentier), au 151 rue de Montmartre, dans le passage des Panoramas à Paris (Métro 9, Grands Boulevards).
L'endroit est formidable, très convivial et chaleureux, organisé autour d'une grande salle en L (coupée en trois) au rez-de-chaussé donnant sur un bar et d'une belle salle en étage. On s'y sent vite à l'aise et comme chez soi. Les poufs verts ou oranges très design donnaient déjà un air de déco à la Google. L'ère des portables et du wifi a apporté ceci qu'un endroit comme celui-ci peut-être résolument orienté technologie sans ressembler à une usine ou à ces anciennes salles d'ordinateurs parsemées de fils en tout genre, très bruyantes et assez désagrables. Ici les ordinateurs se posent sur un coin de table ou sur les genoux, l'ambiance est tamisée, la lumière du jour traverse un puit de lumière très "maison d'architecte". Un vrai paradis pour Geek en somme (bah quoi, on s'assume).

le_bar

[On voit en haut à gauche le très sympathique patron du lieu.]

Les sessions ont pu se tenir dans des endroits très variés allant de la table ronde au canapés autour d'une table basse.
Quatres salles ont permis de tenir douze sessions après la double introduction par Didier Girard en live et Bruce Johnson dans une vidéo spécialement enregistrée pour l'occasion (encore merci à lui).

Les sessions :

Salle 1 Salle 2 Salle 3 Salle 4
Comment organiser une application GWT GWT de Hello World à RPC Réalisation d'une application avec GWT.EXT GWT vs Flex vs Silverlight
Intégrer GWT avec Spring, Maven et Hibernate Retour d'expérience sur la mise en oeuvre de GWT GWT 1.5 GWT vs Struts 2
Créer un composant GWT Install party GWT et Google App Engine Install party 2


le_buffetcadeaux Un buffet était organisé entre les sessions pour poursuivre la discussion autour d'un verre ou parler de tout autre chose.
Ce petit événement s'est terminé bien tard par un tirage au sort pour distribuer les goodies gracieusement offerts par Google pour l'occasion : des hélicoptères radio-commandés. 

 

 

Retrouvez toutes les photos sur : Picasa

mercredi 28 mai 2008

GWT 1.5, c'est officiel ...

Quelques bruits ça et présageaient de la mise à disposition de la nouvelle version de GWT sous peu. C'est désormais chose faite.

Pour ceux qui ne connaissent pas cette technologie, il s’agit d’un Framework Web développé par Google. Il permet à des développeurs de réaliser des applications Web dynamiques basées sur Ajax sans écrire la moindre ligne de JavaScript. Les développements s’effectuent en effet en Java, ce qui permet de gagner un temps considérable dans la réalisation d’applications.

La version 1.5 RC 1 de GWT est officiellement disponible depuis ce matin au téléchargement. A noter toutefois qu'il s'agit d'une release candidate et non d'une version définitive.

Celle-ci était très attendue des développeurs, en effet, elle supporte désormais le JDK 5, les generics, l’autoboxing, les annotations, ...

En fait, on peut dire qu’aucune partie de GWT n’a réellement été épargnée, que ce soit en termes d’interface graphique, de compilation, d’appel RPC, tout a été amélioré.

On s’apercevra notamment que désormais, au niveau des composants graphiques, des animations sont disponibles ou encore des thèmes visuels. A noter également un effort au niveau de l’accessibilité avec le support de ARIA pour les composants standards (uniquement sous Firefox pour le moment).

Au delà des nouvelles fonctionnalités qui sont loin d’être négligeables, c'est un lot d'optimisations qui accompagne cette nouvelle version. Dans le processus de développement notamment, avec la réduction du temps de lancement en hosted mode et la diminution du temps de compilation. En termes de temps d’exécution de l’application également, avec un temps d’exécution plus court que si l’application avait été développée directement à la main en JavaScript.

Pour plus d’informations sur les nouveautés de cette version, c’est par ici .

Cette version de GWT était dans les cartons depuis quelques temps et on comprend pourquoi lorsque l’on regarde le travail qui a été accompli. Une bonne nouvelle donc pour beaucoup de développeurs, d’autant plus que Google a bien l’intention d’améliorer encore le processus de compilation.

Faciliter le développement d’applications GWT est un autre des objectifs de Google pour l’avenir avec notamment la mise à disposition d’un plugin Eclipse.

Sources :

http://code.google.com

http://www.regdeveloper.co.uk

http://www.eweek.com

mercredi 14 mai 2008

Imaginer le browser en Virtual Machine et le Javascript son bytecode.

javascript_logoLes applications estampillées RIA reposent pour partie sur les fonctionalités natives offertes par les browsers : leur moteur Javascript d'une part et celui de rendu d'autre part (HTML & co). Le Javascript est ainsi (re)devenu la star incontournable des applis web actuelles (s'il est fait exception des applis s'appuyant sur des plugins comme Flash). La différence fondamentale actuelle est l'usage qu'il est fait du javascript maintenant : son rôle évolue d'un langage pour "bricoleur - talentueux pour certains - du web" à ce qui pourrait être assimilé à du "bytecode" puisque généré par des compilateurs de toutes sortes.

GWT a ouvert le bal en proposant la conversion de code Java en code Javascript (avec certaines limitations) interpretable par la "Browser Virtual Machine" qu'est le navigateur. D'autres initiatives, sans doute marginales - mais qui sait... la communauté peut s'y attacher - , vont dans le même sens et renforcent ce mouvement :

- HotRuby : une VM pour ... Ruby (HotRuby a javascript flash virtual machine that runs ruby)

- Orto : compile un programme Java en Javascript (Running java in javascript)

Force est de constater que les efforts actuels des différents protagonistes du marché du navigateur que sont Firefox, Safari, Opera et ... IE (même si ce dernier fait clairement figure d'outsider pour le moment) vont aussi dans le sens d'une amélioration très notable des performances offertes par leur moteur Javascript : Comparaison de performances sur dromaeo.com.

La vocation du browser va t'elle s'enrichir d'un rôle de machine virtuelle pour toutes sortes de langages et offrir un nouveau champ de bataille à ceux-ci ?

vendredi 11 avril 2008

GWT in the AIR

Logo Adobe AIRJe viens de découvrir l'existence d'un projet GWT qui s'annonce intéressant : GWT in the AIR ou le mariage de GWT avec AIR.
Pour rappel, GWT est un framework open source qui permet le développement d'applications AJAX avec le langage de programmation Java. Adobe AIR est un environnement d'exécution sous licence Creative Commons qui permet de déployer localement des applications internet riches.
La combinaison de ces deux ingrédients semble détonnante, non ?

Une autre démo de la combinaison GWT + AIR : From GWT to Air in 1'

page 2 de 2 -