Après avoir bien joué avec le Composer de NetBeans pour créer une interface JavaFX, je m’intéresse aujourd’hui un peu plus au code en lui-même.

On a accès au code auto généré par le Composer dans la source mais celui-ci n’est pas éditable. Toutefois en jouant sur les différents paramètres dans le Composer, on voit donc les changements et la façon dont l’éditeur gère le code.

Ensuite, la syntaxe n’est pas complexe mais peut paraitre un peu déroutante sur certains points. Retour sur le site de sun pour un peu d’aide : http://java.sun.com/javafx/1/tutorials/core/index.html

Plusieurs très bonnes leçons abordant facilement et progressivement les difficultés et différences propres à JavaFX dont voici le résumé :

• Déclarations:
  – constantes : def constante = 100;
  – variables : var maVariable; ou var maVariableTypée:Type;
  – fonctions : function maFonction(arg1:type1, arg2:type2) { .. } où les arguments sont bien sûrs optionnels
  ou bien function maFonction(arg1:type1, arg2:type2):typeDeRetour { .. return resultat; }
  – classe:
  public class Personne {
  public var nom: String;
  public var prenom: String;
  }

  On retrouve héritage et abstraction :
  abstract class maClasseAbstraite { …}
  class Voiture extends Véhicule { ..}

  – objet :
  var chanteur = Personne {
  nom: « Johnny » ;
  prenom: « Hallyday »;
  }
  – listes :
  def weekDays = [« Mon », »Tue », »Wed », »Thu », »Fri »]; // days[0] pour accéder au premier élément
  def nums = [1..100 step 3]; //liste des entiers de 3 en 3 jusque 100 : 1,4,7,…
  def numérosPlusGrandQueVingt = nums[n | n > 20];
  sizeof weekDays // renvoie 5
  insert « Sat » into weekDays ; // ajoute Sat en fin de liste
  insert « Sun » before weekDays[0]; // ajoute Sun en première place
  delete weekDays[0]; //supprime Sun

• Visibilité
  Les déclaration tiennent compte de l’endroit où elle sont effectuées comme en Java.
  On retrouve aussi les paramètres public, protected, package, ainsi que public-read(droits de lecture uniquement), public-init(droits de création de l’objet uniquement).
• Commentaires java classiques : // une ligne et /* lignes multiples */
• Fonction d’entrée dans la classe : function run(args : String[]) { … }
  A défaut de cette fonction, le compilateur considère que tout le code tapé est dans une fonction run « fictive ».
• Types de données:
  – String
  – Number and Integer (mais possibilité de récupérer aussi les types Java)
  – Boolean
  – Duration : durée (5ms = 5 millisecondes ; 30m = 30 minutes …)
  – Void
  – Null
  – Function Type
• Chaines de caractères
  def debut= « Une jolie « ;
  def fin= « phrase. »;
  def complet= « {debut}{fin} »;

  def test = true;
  var s = « Le test est {if (test) « positif » else « négatif »} »;

• Opérateurs classiques : =, +, -, *, /, mod, ++, --, not, ==, !=, <, >, <= >=, and, or
• Bind de variables : permet de lier une variable à une autre :
  var a = « Hello »;
  var b = bind a;

  b prendra toujours la valeur de a, on peut ainsi lier b non plus à a mais au résultat d’une fonction, une action utilisateur, …

Et voilà pour ce court extrait!

Bon code!

Premier truc cool, en voulant créer un nouveau projet, je remarque que NetBeans dispose d’exemples de programmes JavaFX. Donc, déjà on voit si ca compile! Les exemples sont plutôt basiques mais sympa. On y découvre de nombreux effets graphiques possibles dans le sous dossier « Building Blocks ». On remarque aussi la top nouveauté de NetBeans 6.9, le Composer. Deux types d’exemples sont présent, ceux avec un petit logo FX sur fond blanc, correspondant aux « anciens » exemples, et ceux avec un fond bleu correspondants aux nouveaux ».
L’ancien éditeur se contentait de code avec une fonction de prévisualisation du résultat. La nouvelle version permet de créer l’interface en déplaçant des objets, boutons, … une vraie création de gui facile en somme!
Après avoir bien joué avec les exemples, le Composer et jeté un oeil au code (peu commenté mais plutôt propre et facilement compréhensible), je crée donc un nouveau projet. On retrouve 3 types de projet : Script et Desktop, et Mobile (je ne vois pas de différence entre ces 2 derniers si ce n’est la taille prédéfinie de l’écran). Je choisis donc Desktop de façon à avoir accès au bel éditeur d’interface (du nom de Matisse).

En passant, les tutos sur le site NetBeans sont plutôt complets et bien organisés :

http://netbeans.org/kb/trails/matisse.html

Je commence donc par suivre l’exemple suivant http://netbeans.org/project_downloads/javafx/jdbc/JDBC.html
Ce tutoriel permet un test rapide pour la connexion à une base JavaDB. En 5min c’est testé/validé. Plutôt content de la facilité avec laquelle ca marche.
Je refais à peu de chose près la même chose avec ma base à moi maintenant : j’ai finalement opté pour une base H2 qui est donc stockée dans un simple fichier et qui à terme sera donc utilisée en embarquée dans mon application.
On rajoute le jar au classpath, sélectionne le driver modifie l’exemple et zoupla c’est reglé.

Le second screencast présenté montre avec quelle facilité et rapidité on peut faire joujou avec le logo Netbeans (rotation, zoom,…), rien d’exceptionnel mais ca me fait penser que ca va être plutôt cool pour un prototypage d’écran rapide à montrer au client. Vu la facilité de l’outil, des modifs en temps réel avec l’utilisateur sur l’interface sont tout à fait envisageables (dur à imaginer pour du J2EE par exemple!!).

Coup de tel, problème en prod sur mes autres activités (de la BI pour les intéréssés). Ma découverte s’arrête là pour l’instant.

Ma hiérarchie proposait un outil Access: Access pour la db, interface et gestion via vba.

Ayant déjà donné dans du dev vba, je préfèrerai voir autre chose. J’ai fait dans le temps des applets Java, je me dis que ca pourrait être pas mal. Je vais donc regarder du côté de JavaSE et Swing dans NetBeans. Rapidement je me dis que ce serait une bonne occasion de faire ça en JavaFX (que j’avais découvert en 1.0, qui m’avait fortement déçu et était concrètement inutilisable…).

Première étape : Recherche documentaire
D’abord vérifier que ca a bien évolué depuis la 1.0. A ce niveau le site officiel javafx.com est plutôt bien foutu, pas mal d’exemple et une doc assez claire pour la prise en main initiale.
Quelques recherches google (crud javaFX, javaFX charts) me fournissent divers liens qui me seront bien utiles pour la suite.

premières conclusions: javaFX dans sa version 1.3 (sortie il y a peu) n’est toujours pas vraiment complet et contient encore quelques bugs mais est globalement utilisable et permet pas mal de choses cool (suffit de voir la galerie d’exemples sur le site officiel).

Je sais qu’en m’engageant dans cette voie, je risque de galérer de longues heures sur des broutilles, mais logiquement rien d’insurmontable. De plus, il y a apparemment peu de changements entre la 1.2 et la 1.3, ce qui montre une certaine stabilité.

A ce sujet, on prendra garde dans les exemples du web à ne considérer que ce qui est postérieur à juin 2009 (sortie de la 1.2). Beaucoup trop d’incompatibilités avec les précédentes versions.

2 blogs de référence pour le suivi du langage : Jim Weaver et Rakesh Menom

Seconde étape: Base de données

J’ai pour contrainte d’avoir une base de donnée sans serveur et partageable entre plusieurs utilisateurs. De plus, il est nécessaire de pouvoir la « bidouiller » avec un éditeur sql classique.
Après recherches, je vais partir sur du SQLite, la base est stockée dans un simple fichier, pas besoin de serveur. Celle-ci est partageable (compte tenu de la volumétrie et charge sur l’application, les accès concurrents ne devraient poser aucun pb).
Et il y a l’outil sqliteman pour manipuler la db avec un éditeur « classique ».

Troisième étape: Installation

La recherche documentaire avait lieu sur ma machine perso, toujours updatée. Désormais, il faut installer le nécessaire sur la machine de boulot : WinXP Pro SP2, proxy.

Je récupère le dernier jdk dispo chez sun, enfin oracle. On y trouve un bundle spécial JavaFX avec NetBeans 6.8 : http://java.sun.com/javase/downloads/index.jsp#jdkJavaFX

Droits admin indispensable pour l’installation du jdk (pas nécessaire pour netbean cependant): c’est parti pour une négociation avec l’admin! (bcp plus facile que je l’aurai imaginé en fait d’ailleurs!!)

J’avais aussi récupéré NetBeans 6.9 et JavaFX 1.3, mais le mot « beta » n’a pas trop plu.. Pas grave on verra ce que ca donne par la suite. J’installe le lendemain moi-même NB 6.9 et le sdk 1.3 (mais le path système JAVA ne peut être mis à jour). NetBeans 6.9 se lance sans soucis.

Retour sur le site javafx.com pour voir les exemples : rien ne marche, erreur « host not found » lorsque le jnlp essaie de lancer les appli. Je me dis, ça c’est le proxy! Je vais dans panneau de configuration/Java et je tente de régler le proxy. Celui ci, dans mon entreprise est défini par un script .pac qui gère les accès à l’intranet par rapport à l’extérieur. Ce qui ne pose aucun problème dans IE ou Firefox. Je coche « Utiliser les paramètres du navigateur ». Même erreur. Je recopie l’adresse du script de configuration dans la case adéquate : même erreur. Motivé, j’analyse le script et récupère l’adresse et le port du proxy pour l’extérieur. Je les rentre aux cases adéquates et oh joie ça marche!