• JSF 2.0: Mojarra in Version 2.0.0-b16
• Tomcat 6
• Maven
• Eclipse

Voraussetzung:

• JDK 6
• Tomcat 6
• Eclipse inklusive WTP, Maven (m2eclipse)
• Beim m2eclipse-Plugin “Maven integration for WTP” in Eclipse nachinstallieren, falls nicht vorhanden

Vorbereitung:

1. In Eclipse ein dynamische Webprojekt erstellen
2. Tomcat 6 als Server in Eclipse einrichten
3. Dem Projekt “Maven Nature” hinzufügen. Zur Zeit ist das Projekt ein reines Webprojekt ohne Maven Eigenschaften. Durch Rechte-Maustaste auf das Projekt und dann Maven > Enable Dependency Management wird Maven-Funktionalität für das Projekt hinzugefügt
4. Maven erwartet eine andere Ordner-Struktur als in dem WTP-Webprojekt. Als erstes muss der Source-Ordner angepasst werden. Hierfür müssen mind. folgender Ordner erstellt werden: src/main/java. Diesen muss man in Eclipse dann auch als Source-Ordner konfigurieren (Java Build Path)
5. Der WebContent-Ordner wird von Maven mit der WTP-Integration genutzt. Hier ist keine Veränderung/Anpassung notwendig
6. Die existierende pom.xml muss entsprechende Einträge erweitert werden. Für JSF 2 könnte das wie folgt aussehen:

   <project xmlns=&quot;http://maven.apache.org/POM/4.0.0&quot; xmlns:xsi=&quot;http://www.w3.org/2001/XMLSchema-instance&quot; xsi:schemaLocation=&quot;http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd&quot;>
     <modelVersion>4.0.0</modelVersion>
     <groupId>jsf2test</groupId>
     <artifactId>jsf2test</artifactId>
     <version>0.0.1-SNAPSHOT</version>
   
     <properties>
     	<version.jsf2>2.0.0-b16</version.jsf2>
     	<version.junit>4.4</version.junit>
     	<version.jstl>1.2</version.jstl>
     	<version.servlet>2.5</version.servlet>
     	<version.log4j>1.2.14</version.log4j>
     </properties>
   
     <repositories>
     	<repository>
   		<id>maven2-repository.dev.java.net</id>
   		<name>Java.net Repository for Maven</name>
   		<url>http://download.java.net/maven/2/</url>
   		<layout>default</layout>
   	</repository>
     </repositories>
   
     <build>
       <finalName>jsf2test</finalName>
       <plugins>
   	    <plugin>
   			<artifactId>maven-compiler-plugin</artifactId>
   			<configuration>
   			<source>1.5</source>
   			<target>1.5</target>
   			</configuration>
   		</plugin>
   
   	    <plugin>
   		  <groupId>org.mortbay.jetty</groupId>
   		  <!-- jetty 7
   		  <artifactId>jetty-maven-plugin</artifactId>
   		   -->
   		  <artifactId>maven-jetty-plugin</artifactId>
   		  <version>6.1.15</version>
   		  <!--
   		  <configuration>
   		    <scanIntervalSeconds>10</scanIntervalSeconds>
   		  </configuration>
   		   -->
   		</plugin>
       </plugins>
     </build>
   
      <dependencies>
      	<!-- JSF2 -->
   	<dependency>
   		<groupId>com.sun.faces</groupId>
   		<artifactId>jsf-api</artifactId>
   		<version>${version.jsf2}</version>
   	</dependency>
   
   	<dependency>
   		<groupId>com.sun.faces</groupId>
   		<artifactId>jsf-impl</artifactId>
   		<version>${version.jsf2}</version>
   	</dependency>
   
   	<dependency>
         <groupId>javax.servlet</groupId>
         <artifactId>jstl</artifactId>
         <version>${version.jstl}</version>
       </dependency>
   
       <dependency>
         <groupId>javax.servlet</groupId>
         <artifactId>servlet-api</artifactId>
         <version>${version.servlet}</version>
       </dependency>
   
   	<!-- Misc -->
       <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>${version.junit}</version>
         <scope>test</scope>
       </dependency>
   
       <dependency>
   	    <groupId>log4j</groupId>
   	    <artifactId>log4j</artifactId>
   	    <version>${version.log4j}</version>
   	</dependency>
   
     </dependencies>
   </project>
   

7. Die Bibliotheken, welche Maven bereitstellt, müssen beim Deploy in WEB/lib kopiert werden. Die Nutzung der Maven Dependencies geschieht durch folgende Einstellung: In den Eigenschaften des Projekts muss unter Java EE Module Dependencies die Maven Dependencies ausgewählt werden.
8. Web.xml für JSF anpassen. Z.B. wie folgt:

   <?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?>
   <web-app xmlns:xsi=&quot;http://www.w3.org/2001/XMLSchema-instance&quot; xmlns=&quot;http://java.sun.com/xml/ns/javaee&quot; xmlns:web=&quot;http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd&quot; xsi:schemaLocation=&quot;http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd&quot; id=&quot;WebApp_ID&quot; version=&quot;2.5&quot;>
     <display-name>dynWebTest</display-name>
   
     <servlet>
       <servlet-name>Faces Servlet</servlet-name>
       <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
       <load-on-startup>1</load-on-startup>
     </servlet>
   
     <servlet-mapping>
       <servlet-name>Faces Servlet</servlet-name>
       <url-pattern>*.xhtml</url-pattern>
     </servlet-mapping>
   
     <!-- This parameter is also possible to set over JNDI -->
     <context-param>
       <param-name>javax.faces.PROJECT_STAGE</param-name>
       <param-value>Development</param-value>
     </context-param>
   
     <welcome-file-list>
       <welcome-file>index.html</welcome-file>
       <welcome-file>index.xhtml</welcome-file>
     </welcome-file-list>
   </web-app>
   

Nun steht das Grundgerüst bereit, um endlich mit JSF 2.0 anzufangen.
Für diejenigen, die mit JSF 1.x schon gearbeitet haben, werden wohl die faces-config.xml vermissen. Korrekt. Ist gewollt. Ist nämlich die erste Verbesserung von JSF 2.0! Die faces-config.xml kann immer noch verwendet werden, aber vieles ist durch Annotations möglich und die Navigation ist einfacher/verständlicher geworden. Später mehr dazu.

Vielleicht noch ein paar Worte zur Beispielanwendung: Die Beispielanwendung beinhaltet eine Seite, mit einem Input-Feld und zwei Select-Boxen. Man stelle sich folgendes Szenario vor: Man möchte ein Registrierungs-Formular erstellen, in dem der Nutzer überprüfen kann, ob der Username noch vorhanden ist. Zusätzlich soll er das Land auswählen können, in dem er lebt.

Controller:
Der Controller ist das ManagedBean, welches in den XHTML-Seiten verwendet wird und alle Anfragen verarbeitet.

@ManagedBean(name = "fc")
@RequestScoped
public class FrontController {

	private Person person;

	private String country;

	private String continent;

	private Map<String, String[]> countries;

	@ManagedProperty(value = &quot;#{authService}&quot;)
	private AuthService authService;

	public void isUsernameValid() {

		if(authService.isUsernameValid(person.getUsername())) {

			output = &quot;Username ist nocht nicht vorhanden&quot;;
		} else {
			output = &quot;Username ist schon vorhanden. Bitte einen anderen auswählen&quot;;
		}
	}

        public String[] getCountries() {
		// deliver the countries to the actual continent
		return countries.get(continent);
	}
       /* further get/set-Methods */
}

Durch die Annotations wird JSF mitgeteilt, dass es sich bei der Klasse um ein managed bean mit dem Namen fc handelt (@ManagedBean) und die jeweils immer nur für ein Request gültig ist (@RequestScoped, weitere Scops sind vorhanden). Früher hat man diese Einstellungen in faces-config.xml durchgeführt.
Neu ist auch @ManagedProperty. Mittels dieser Annotation wird die Dependency Injection Funktionalität von JSF 2.0 verwendet. In FrontController#authService wird nun das passende Objekt mit dem managed bean namen “authService” injiziert.
Hier sei anzumerken, dass JSF kein field access durchführt, sondern die getter/setter-Methoden verwendet um Properties zu setzen.

Die Domain-Klasse Person ist ein einfaches Bean bzw. POJO, und repräsentiert die einzugebenden Daten in dem Formular.

Zu dem Controller und Model Teil gehört noch die Präsentation und diese wird mittels Facelets durchgeführt. In JSF 2.0 ist Facelets die primäre Technologie zur Beschreibung des Views. Man kann natürlich JSP nutzen, wenn man den Sprung nicht durchführen möchte. Aber die Vorteile liegen eher bei Facelets!

<!DOCTYPE html PUBLIC &quot;-//W3C//DTD XHTML 1.0 Transitional//EN&quot;
        &quot;http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd&quot;>

<html xmlns=&quot;http://www.w3.org/1999/xhtml&quot;
      xmlns:ui=&quot;http://java.sun.com/jsf/facelets&quot;
      xmlns:f=&quot;http://java.sun.com/jsf/core&quot;
      xmlns:h=&quot;http://java.sun.com/jsf/html&quot;>

<h:head>
  <title>JSF Demo</title>
</h:head>
<h:body>
  <h1>Register</h1>
  <h:form>

    <h:inputText id=&quot;name&quot; value=&quot;#{fc.person.username}&quot;>
    </h:inputText>
    <h:commandButton value=&quot;Check username&quot; action=&quot;#{fc.isUsernameValid}&quot;>
    	<f:ajax execute=&quot;name&quot; render=&quot;outIsUserValid&quot; />
    </h:commandButton>
    <h:outputText id=&quot;outIsUserValid&quot; value=&quot;#{fc.output}&quot; />
  </h:form>
  <br />

  <h:form>
                <!-- First select box to select the continent.... -->
  		<h:selectOneMenu value=&quot;#{fc.continent}&quot;>
  			<f:selectItems value=&quot;#{fc.continents}&quot; />
  			<f:ajax render=&quot;countrylist&quot; />
  		</h:selectOneMenu>

                <!-- ...and depending of the selected continent, contains this
                      second select box the countries
                -->
  		<h:selectOneMenu value=&quot;#{fc.country}&quot; id=&quot;countrylist&quot;>
  			<f:selectItems value=&quot;#{fc.countries}&quot; />
  		</h:selectOneMenu>
  </h:form>
</h:body>
</html>

Mittels Facelets ist die Beschreibung der Views reiner XML/XHTML.
In dem ersten Formular ist das Input-Feld, in dem der Nutzer überprüfen kann, ob sein Username schon vergeben ist. Die Überprüfung wird mittels Ajax durchgeführt. Hierfür ist der neue <f:ajax>-Tag zuständig. Beim betätigen des Buttons wird ein Ajax-Request verschickt, dieser beinhaltet die Werte aus den Felder in dem execute-Attribute. In unserem Fall aus dem Feld mit der ID name. Die Antwort wird, wie in dem render-Attribute definiert, in ID outIsUserValid eingefügt. Auf dem Server wird zur Verarbeitung die Methode FrontController.isUsernameValid() aufgerufen. Während des Aufrus ist FrontController#person mit den aktuellen Werten (hier: username) gesetzt.

In dem zweiten Formular gibt es zwei Select-Boxen. In dem einen kann ein Kontinent ausgewählt werden. Resultierend dazu, wird in der zweiten eine Liste von Ländern angezeigt. Diese Länder-Liste wird durch Ajax ermittelt.
In der ersten Liste ist wieder ein <f:ajax>-Tag zu finden. Bei dem 1. Beispiel wurde der Request verschickt, wenn der Nutzer den Button drückt. D.h. in der Javascript-Welt, beim Click-Event, wird der Request verschickt. Das <f:ajax>-Tag wählt immer das passende Event aus, abhängig von der Komponente, in dem es verwendet wird.
Bei Listen horcht es auf ein OnChange-Event. Natürlich kann man ein anderes Event festlegen, dafür gibt es das event-Attribut.
D.h. also, sobald in der ersten Liste die Auswahl verändert wird, wird die zweite Liste aktualisiert (durch render=”countrylist”). Auf dem Server wird FrontController.getCountries() aufgerufen. In dem Kontext ist FrontController#continent belegt, da der Nutzer eine Auswahl in der 1.Liste durchgeführt hat. FrontController.getCountries() liefert nun nur ein Array von Ländern zurück. Die korrekte Verschachtelung in HTML-Elemente (option-Tag) übernimmt JSF!

Fazit:

• Mittels JSF 2.0 hat man weniger Konfigurationsaufwand
• Durch den Einsatz von Facelets macht das Erstellen der HTML-Seiten wieder Spass. Hier kann man die vorhandenen HTML-Templates fast unverändert übernehmen…
• Unproblematischer Javascript/Ajax-Einsatz, ohne es wirklich zu merken!
• DI ohne Spring!

Also der erste Eindruck hat überzeugt. Wenn man JSF-Fan war, wird man JSF-Fan weiter bleiben. Wenn nicht, könnte man es jetzt bestimmt werden

• Andy Schwartz Blogeintrag Andy hat selbst eine Auflistung inklusive weitere Erklärung aufgeführt
• Mojarra: Get started
• Mojarra 2.0.0 Release Notes: Mit den Verweisen zu den aktuellen APIs, TLDs etc

Zu dieser Auflistung, die aktualisiert wird, folgen in dem Blog ein paar Beispiele zu speziellen Themen.

P.S.: In dem Block “Spec 2.0″ folgen demnächst Beiträge zu Spezifikationen, Frameworks die nun in Version 2.0 erschienen sind.

Es bietet eine gute Möglichkeit die Entkopplung der einzelnen Schichten einzuhalten und mit der Kombination von Facelets, kann sogar ein Grafiker einfacher damit arbeiten.

Bei JSF sind bestimmte “Aktionen” einer Methode zugeordnet. (Methode aus dem ManagedBean, normale Klasse welche in faces-config.xml festgeleg wird, bzw. bei Spring-Einsatz kann man das auch weglassen). D.h. eine Aktion “Kunde anlegen”, welches als Button dargestellt wird, wird mit der Methode CustomerController.add() gebunden.

Oft funktioniert das auch ohne Probleme. Man füllt das Formular aus und drückt den Button. JSF konstruiert den ComponentTree, stellt die Daten wieder in die Objekte und sollte irgendwann auch unsere Methode CustomerController.add() aufrufen. Jaein.

<h:form enctype=”multipart/form-data”>

Man beachte <code>enctype=”multipart/form-data” </code>. Das ist das Problem. Ein einfaches

<h:form>

funktioniert. Dann wird die Methode wieder auch aufgerufen!

Das Beispiel basiert auf das Tutorial von SUN [1] und wurde um die Eigenschaft erweitert, dass das Applet auch auf dem Desktop verwendet werden kann.

Das Beispiel erstellt eine analoge Uhr, welche man sich auf den Desktop ziehen kann. Der Fokus liegt auf die Implementierung und nicht auf jegliche graphische Feinheiten.

Ein JavaFX Script wie im unteren Listing zu sehen beinhaltet immer eine Stage Klasse. Dies ist der globale Container, der alle weiteren Elemente beinhaltet.

import javafx.scene.Scene;
import javafx.stage.Stage;

var stage = Stage {
      title: "JavaFX Test Clock"
      width: 300
      height: 300
      scene: Scene {
          content: []
     }
}

Da JavaFX eine deklarative Sprache ist, beschreibt man, was man haben will. Dafür gibt es verschiedene Propterties (wie in dem Fall: width, height, scene, content), die man belegen kann.

Ein Stage Container besitzt ein Scene, in dem verschiedene Nodes enthalten sind. Node kann hier als ein graphisches Element (Rectangle, Text, ImageView) angesehen werden. In dem oberen Listing gibt es noch keine Nodes – content ist ein leeres Array.

Eine Uhr besteht aus verschiedenen Kreisen und Linien für die Zeiger. Nun könnte man in dem stage.scene.content diese graphischen Elemente schreiben, da man jedoch etwas strukturierter arbeiten will, kapseln wir die Funktionalität in eine eigene Klasse. Im folgenden Listing ist ein Teil von Clock.fx zu sehen:

public class Clock extends CustomNode {

public var radius: Number = 77;
public var centerX: Number = 144;
public var centerY: Number = 144;

public var hours: Number;
public var minutes: Number;
public var seconds: Number;

public override function create(): Node {
  return Group {
    content: [
     Group {
      transforms: Translate {
        x: centerX
        y: centerY
      }
      content: [
        // displays the number of every third hour
        for (i in [3, 6, 9, 12])
          Text {
             transforms: Translate {
                x: -5,
                y: 5
             }
             fill: Color.GREEN
             font: Font {
               size: 16
             }
             x: radius * (( i + 0 ) mod 2 * ( 2 - i / 3))
             y: radius * (( i + 1 ) mod 2 * ( 3 - i / 3))
             content: "{i}"
          },  //Text

          // display a yellow point for the rest of the
          // hours on the clock
          for (i in [1..12] )
            if (i mod 3 != 0 ) then Circle {
               transforms: Rotate {
                  angle: 30 * i
               }
               centerX: radius
               radius: 3
               fill: Color.YELLOW
            } // if
            else [ ],

            // clock's first center circle
            Circle {
              radius: 5
              fill: Color.DARKRED
            }, //Circle
            // the smaller center circle
            Circle {
              radius: 3
              fill: Color.RED
            }, //Circle
            // the seconds hand
            Line {
              transforms: Rotate {
                angle: bind seconds * 6
              }
              endY: -radius - 3
              strokeWidth: 2
              stroke: Color.VIOLET
            },  //Line
            // the hour hand
            Path {
              transforms: Rotate {
                 angle: bind (hours + minutes / 60) * 30 - 90
              }
              fill: Color.YELLOW
              elements: [
                 MoveTo {
                    x: 4,
                    y: 4
                 },
                 ArcTo {
                    x: 4
                    y: -4
                    radiusX: 1
                    radiusY: 1
                 },
                 LineTo {
                    x: radius - 15
                    y: 0
                 },
              ] //elements
            },  // Path
            // the minutes hand
            Path {
              transforms: Rotate {
                 angle: bind minutes * 6 - 90
              }
              fill: Color.GREEN
              elements: [
                 MoveTo {
                    x: 4,
                    y: 4
                 },
                 ArcTo {
                    x: 4
                    y: -4
                    radiusX: 1
                    radiusY: 1
                 },
                 LineTo {
                    x: radius
                    y: 0
                 },
              ] // elements
            } // Path
       ] // 2. Group content
     } // Group
   ] // Group content
  };  // Group
 } // create()

} // class

Um nun das Drag-and-Drop des Applets zu ermöglichen, erweitert man den Stage um einen sogenannten AppletStageExtension.

stage = Stage {
    title: "JavaFX Test Clock"
    width: 300
    height: 300
    style: StageStyle.TRANSPARENT
    onClose: function() {
        //System.exit(0);
    }
    visible: true
    scene: Scene {
        fill: bind if (inBrowser) Color.WHITE else Color.TRANSPARENT
        content: [
            Clock {},
            // drag controls
            dragArea,
            dragClosers,
            statusText
        ]
    }
    extensions: [
        AppletStageExtension {
            shouldDragStart: function(e): Boolean {
                return inBrowser and e.primaryButtonDown and dragArea.hover;
            }
            onDragStarted: function(): Void {
                inBrowser = false;
            }
            onAppletRestored: function(): Void {
                inBrowser = true;
            }
            useDefaultClose: false
        }
    ]
}

Die Funktion shoudDragStart() gibt an, ob die Drag-Drop-Funktionalität angeboten werden soll, oder nicht.
Anzumerken ist, dass das Property AppletStageExtension.useDefaultClose = false ist, da ein eigenes Close-Symbol erstellt wurde. Beim Betätigen dieses Buttons schließt sich das Applet und kehrt zum Browser zurück – falls dieser noch vorhanden ist.

In dem oberen Listing beinhaltet stage.scene.content noch den Node “dragArea”:

var dragArea:Rectangle = Rectangle {
    x: 155
    y: 30
    width: 420
    height: 25
    fill: Color.RED
    onMouseDragged:function(e:MouseEvent):Void {
        stage.x += e.dragX;
        stage.y += e.dragY;
    }
};

Das ist der Bereich, in dem der Nutzer das Applet herum ziehen kann. In der onMouseDragged() Funktion wird immer die aktuelle Position der Stage gesetzt.

Was passiert, wenn ein Applet auf den Desktop verschoben wird und das Browser-Fenster geschlossen wird? Dann bietet Java die Möglichkeit eine Verknüpfung zu erstellen.
Dabei speichert es ein paar XML-Daten im User-Verzeichnis und setzt eine Verlinkung, um die Daten per Java Webstart zu starten.

Der Inhalt der JNLP-XML-Datei sieht z.B. so aus:

<?xml version="1.0" encoding="UTF-8"?>
<jnlp spec="1.0+" codebase="http://example.net/JavaFXClock" href="JavaFXClock_browser.jnlp">
    <information>
        <title>JavaFXClock</title>
        <vendor>Hafid Haddouti</vendor>
        <homepage href="http://example.net/JavaFXClock"/>
        <description>JavaFXClock</description>
        <offline-allowed/>
        <shortcut>
            <desktop/>
        </shortcut>
    </information>
    <resources>
        <j2se version="1.5+"/>
        <extension name="JavaFX Runtime" href="http://dl.javafx.com/javafx-rt.jnlp"/>
        <jar href="JavaFXClockt.jar" main="true"/>
    </resources>
    <applet-desc name="JavaFXClock" main-class="com.sun.javafx.runtime.adapter.Applet" width="350" height="350">
        <param name="MainJavaFXScript" value="javafxtest.Main">
    </applet-desc>
</jnlp>

Ein Beispiel ist hier zu finde.

Links:
[1] JavaFX Tutorial: http://java.sun.com/javafx/1/tutorials/build-javafx-nb-app/

Überblick

Um JavaFX-Anwendung zu nutzen, braucht man standardmäßig nur die aktuelle Java Version. Hier ist Java 1.6.0_11 [3] passend, da diese Version die Fähigkeit anbietet, Applets auf den Desktop zu ziehen. Beim ersten Aufruf einer JavaFX-Anwendung werden die Runtime-Bibliotheken beim ersten Mal runtergeladen, wenn sie nicht vorhanden sind. Bei entsprechender Implimentierung der JavaFX-Anwendung (was ja ein Applet ist), kann man sich das Applet auf den Desktop ziehen. Schließt man dann den Browser, bekommt man die Möglichkeit ein Verweis auf den Desktop zu erstellen, um später das Applet – und nur das Applet, nicht auch den Browser – wieder zu nutzen.

JavaFX kommt auch mit einer neuen Script-Sprache, dem JavaFX Script. JavaFX Script ist eine deklarative kompilierbare Scriptsprache, was auch type inference – und somit implizit auch statische Typen – anbietet.

Entwicklung

Zur Entwicklung. Sun setzt ja bekanntlich auf Netbeans. Das bedeutet in dem Fall, es gibt ein Netbeans-Version [4] mit integriertem JavaFX. Diese Version beinhaltet das JavaFX Software Development Kit, Beispiele und bei Windows noch den JavaFX Mobile Emulator.

Zusätzlich gibt es Plugins für Photoshop und Adobe Illustrator. Mit JavaFX sollen ja auch schöne GUIs erstellt werden und hierfür bietet man Grafikern eine einfache Möglichkeit dies in ihren bekannten Umgebungen zu erstellen. Wie gut diese Plugins funktionieren, kann ich leider nicht sagen.

Für Eclipse-Nutzer gibt es ein veraltetes Plugin [5], hier ist zu hoffen, dass demnächst eine aktuellere Version veröffentlich wird.

Mit Netbeans kann man jedenfalls recht einfach erste JavaFX Anwendungen realisieren. Für die grafische Darstellung kann man eine Palette von vorhandenen Mustern, Transformationen etc nutzen. Jedoch gibt es hier keinen visuellen Designer. Die Palette beinhaltet nur Code-Fragmente, die in den existierenden Code eingefügt werden können. Ob es hier einen Designer geben wird, ist fraglich, da entsprechen Photoshop/Illustrator Plugins existieren.

Features

Die Features dürfen nun auch nicht vergessen werden:

• RIA Plattform für verschiedene Endgeräte
• Einfache Integration für Grafiker
• Gute Unterstützung von Grafiken, 2D, 3D, Video, Audio
• Zugang zu Java-Bibliotheken

Für weitere Details sei auf die Überblicks-Seite in [1] verwiesen.

Links:
[1] JavaFX Überblick: http://javafx.com/about/overview/
[2] JavaFX Getting Started with the Technology: http://javafx.com/docs/gettingstarted/javafx/
[3] Java SE 6 Update Release Notes: http://java.sun.com/javase/6/webnotes/6u11.html
[4] JavaFX Download (for Windows): http://javafx.com/downloads/windows.jsp
[5] OpenJFX Eclipse Plugin v0.0.2: http://download.java.net/general/openjfx/plugins/eclipse/
[6] JavaFX API: http://java.sun.com/javafx/1/docs/api/index.html
[7] JavaFX Script Language: http://java.sun.com/javafx/1/tutorials/core/
[8] JavaFX Language Reference: http://openjfx.java.sun.com/current-build/doc/reference/JavaFXReference.html
[9] JavaFX Blog: http://blogs.sun.com/javafx/

Die erstellten Designs können dann als PNG exportiert werden.

Die zwei Abbildungen zeigen die Arbeitsfläche und die Shapes:

Ein paar Verbesserungen wären:

• Die Festlegung der konkreten Größe der Elemente (Width und Height)
• Bessere Tabellenunterstützung (z.B. Definition der Spaltenränder)

Links:

[1] Pencil

[2] Firefox Add-on Pencil