tutego

Von den Release Notes http://www.smartclient.com/smartgwt/release_notes.html#2_1:

• GWT 2.0.3 compatible

• New Graphite theme

• ListGrid enhancements

  • Record RollOver controls
  • RollUnder Canvas support
  • Background components
  • Support for arbitrary widgets in cells
  • Ability to display row numbers
  • setMaxExpandedRecords(..) to control max. number of simultaneous expanded records
  • ListGridField.setCanDragResize(), setCanReorder(), setAutoFreeze(), setShouldPrint() API's
  • Checkbox selection with grouping
  • MultiColumn sort enhancements

• TreeGrid enhancements

  • Support for Checkbox tree with Cascade selection
  • Support for tri-state checkboxes (selected, unselected, partial)
  • Performance enhancements

• ToolStrip enhancements

  • Significant improvement in appearance
  • Added ToolStripButton and ToolStripMenuButton classes
  • Vertical ToolStrips

• Print support enhancements

  • ability to control which components display in print view
  • print styling on a per-component basis
  • support print window customizations
  • API for the number of records displayed in print view (can be different from UI view)

• Browser Plugins as widgets

  • Flashlet widget
  • Applet widget
  • ActiveXControl widget
  • SVG widget

• Other Widget enhancements

  • Window : support for footer controls
  • Calendar : control dragability of events
  • New IMenuButton & IPickTreeItem classes with improved appearance
  • AdvancedCriteria enhancements and support for programmatic construction
  • SectionStack drag reordering support
  • FilterBuilder support for working with very large number of fields
  • Convenience FormItem.setRequiredMessage(..) API
  • TileGrids now automatically relayout if a tile resizes
  • Added support for grouping for formula and summary fields

• Performance enhancements

  • Snappier TreeGrid expand / collapse
  • Faster Canvas resize
  • Faster Tab close (deferred destroy)

• Logging of warnings and error to the GWT Developer Console in addition to the Smart GWT Dev. Console.

• Improved exception handling and reporting.

• i18n enhancements

• Showcase enhancements and several new samples under the "New Samples" side nav

• 27 additional enhancements and bug fixes that were logged in tracker

Labels: GWT, Open Source, Web Frameworks

Kurz nach 1.2.8 veröffentlich Google nun die Google App Engine 1.3. Von http://googleappengine.blogspot.com/2009/12/app-engine-sdk-130-released-including.html:

Store and Serve - Files can be uploaded and stored as blobs, to be served later in response to user requests. Developers can build their own organizational structures and access controls on top of blobs.
Pricing and Quotas - We include blob storage and transfer under the same datastore pricing and quotas you're already familiar with. For more information, see the App Engine quotas page.
The new Blobstore API is now available in both App Engine SDKs for local development. At this time it can only be used by applications that have enabled billing. There's a lot more information about the API and how it works in the Blobstore documentation (Python, Java) so please check that out and post any questions to the groups.
This release also includes some performance tweaks to the Java runtime. For example, we've sped up many reflective operations by up to 10x resulting in improvements on the order of 10% for applications based on dynamic languages. As always, there are a few other minor changes and bug fixes in this release, so make sure to read our release notes (Python, Java).

Labels: GWT, Open Source, Web Frameworks

Things that are changing with GWT 2.0 that might otherwise be confusing without explanation

* Terminology changes: We're going to start using the term
"development mode" rather than the old term "hosted mode." The term
"hosted mode" was sometimes confusing to people, so we'll be using the
more descriptive term from now on. For similar reasons, we'll be using
the term "production mode" rather than "web mode" when referring to
compiled script.

* Changes to the distribution: Note that there's only one download,
and it's no longer platform-specific. You download the same zip file
for every development platform. This is made possible by the new
plugin approach used to implement development mode (see below). The
distribution file does not include the browser plugins themselves;
those are downloaded separately the first time you use development
mode in a browser that doesn't have the plugin installed.

Functionality that will be coming in GWT 2.0
* In-Browser Development Mode: Prior to 2.0, GWT hosted mode provided
a special-purpose "hosted browser" to debug your GWT code. In 2.0, the
web page being debugged is viewed within a regular-old browser.
Development mode is supported through the use of a native-code plugin
for each browser. In other words, you can use development mode
directly from Safari, Firefox, IE, and Chrome.

* Code Splitting: Developer-guided code splitting allows you to chunk
your GWT code into multiple fragments for faster startup. Imagine
having to download a whole movie before being able to watch it. Well,
that's what you have to do with most Ajax apps these days -- download
the whole thing before using it. With code splitting, you can arrange
to load just the minimum script needed to get the application running
and the user interacting, while the rest of the app is downloaded as
needed.

* Declarative User Interface: GWT's UiBinder now allows you to create
user interfaces mostly declaratively. Previously, widgets had to be
created and assembled programmatically, requiring lots of code. Now,
you can use XML to declare your UI, making the code more readable,
easier to maintain, and faster to develop. The Mail sample has been
updated to use the new declarative UI.

* Bundling of resources (ClientBundle): GWT has shipped with
ImageBundles since GWT v1.4, giving developers automatic spriting of
images. ClientBundle generalizes this technique, bringing the power of
combining and optimizing resources into one download to things like
text files, CSS, and XML. This means fewer network round trips, which
in turn can decrease application latency -- especially on mobile
applications.

* Using HtmlUnit for running GWT tests: GWT 2.0 no longer uses SWT or
the old mozilla code (on linux) to run GWT tests. Instead, it uses
HtmlUnit as the built-in browser. HtmlUnit is 100% Java. This means
there is a single GWT distribution for linux, mac, and windows, and
debugging GWT Tests in development mode can be done entirely in a Java
debugger.

Known issues
* If you are planning to run the webAppCreator, i18nCreator, or the
junitCreator scripts on Mac or Linux, please set their executable bits
by doing a 'chmod +x *Creator'
* Our HtmlUnit integration is still not complete. Additionally,
HtmlUnit does not do layout. So tests can fail either because they
exercise layout or they hit bugs due to incomplete integration. If you
want such tests to be ignored on HtmlUnit, please annotate the test
methods with @DoNotRunWith({Platform.Htmlunit})
* The Google Eclipse Plugin will only allow you to add GWT release
directories that include a file with a name like gwt-dev-windows.jar.
You can fool it by sym linking or copying gwt-dev.jar to the
appropriate name.

Breaking changes
* The way arguments are passed to the GWT testing infrastructure has
been revamped. There is now a consistent syntax to support arbitrary
"runstyles", including user-written with no changes to GWT. Though
this does not affect common launch configs, some of the less common
ones will need to be updated. For example, '-selenium FF3' has become
'-runStyle selenium:FF3'

As always, remember that GWT milestone builds like this are use-at-
your-own-risk and we don't recommend it for production use. Please
report any bugs you encounter to the GWT issue tracker (http://
code.google.com/p/google-web-toolkit/issues/list) after doing a quick
search to see if your issue has already been reported.

Labels: GWT, Web Frameworks

Das Update bringt interessante Neuerungen. Dazu zählen XMPP-Unterstützung. http://code.google.com/intl/de/appengine/docs/java/xmpp/:

An App Engine application can send and receive instant messages to and from any XMPP-compatible instant messaging service, such as Google Talk. An app can send and receive chat messages, send chat invites, and request status information. Incoming XMPP messages are handled by request handlers, similar to web requests.

Für Python gab es schon eine API für Aufgaben, die offline abgearbeitet werden konnten. Das gibt es es nun auch für Java, http://code.google.com/intl/de/appengine/docs/java/taskqueue/overview.html.

With the Task Queue API, applications can perform work outside of a user request but initiated by a user request. If an app needs to execute some background work, it may use the Task Queue API to organize that work into small, discrete units, called Tasks. The app then inserts these Tasks into one or more Queues. App Engine automatically detects new Tasks and executes them when system resources permit.

Labels: Open Source, Web Frameworks

SmartGWT 1.2 has been released. I have added several new samples to the Showcase including a real world mini-application. The other new samples can be found under the "New Samples" side nav item.

This is a feature-complete production ready release. There are only around 20 enhancement requests and 20 low / medium priority issues in the SmartGWT tracker which I think is pretty telling for such a comprehensive library. I hope to get to them over the weeks to come.

Here are some of the key features of this release :

• GWT 1.7 is fully supported and integration with GWT widgets has been improved significantly. Along with standard GWT widgets, you can now easily add Google Maps or even a Google Visualization Chart to your SmartGWT application

• Hosted mode performance improvements
• Fully implemented the highly requested ResultSet API.
• ListGrid performance improvements
• Full Support for Safari 4.x
• Support for Grid editing with all cell editors active
• Auto-loading of dependent XML schema for loadWSDL() and loadXMLSchema()
• Extended WebService APIs to allow simplified input data and allow setting SOAP headers
• Numerous enhancements. See the detailed API Changes document. Around 35 additional enhancements and bug fixes that were logged in tracker
• Official Maven Repository
• Enhancements to RPC Tab in Developer Console (shows component that initiated request, if applicable)

Looking ahead there are several exciting new features that are going to be in the next release. Deep level of customization of pretty much any widget is going to be supported. For example you'll be able to fully customize grid headers, provide your own widget implementation to use as a Tile in a TileGrid, or even customize pretty much any aspect of the Calendar component.

Labels: GWT, Web Frameworks

Im Google Code Blog werden einige Videos vorgestellt, die den aktuellen Zustand von GWT widerspiegeln. Etwa

GWT Can Do What?!?! A Preview of Google Web Toolkit 2.0 (PDF):

Und weitere:

Google Wave - Powered by GWT

Google Web Toolkit Architecture: Best Practices for Architecting your GWT App

Measure in Milliseconds: Performance Tips for Google Web Toolkit

Effective GWT: Developing a Complex, High- performance App with Google Web Toolkit

The Story of your Compile: Reading the Tea Leaves of the GWT Compiler for an Optimized Future

Progressively Enhance AJAX Applications with Google Web Toolkit and GQuery

Building Applications with Google APIs

Labels: GWT, Web Frameworks

Labels: Swing, Web Frameworks

GroupingStore<BaseModel> store = new GroupingStore<BaseModel>();

BaseModel c1 = new BaseModel();
c1.set( "title", "Java 1" );
c1.set( "category", "JAVA" );
c1.set( "price", 100 );
store.add( c1 );

BaseModel c2 = new BaseModel();
c2.set( "title", "Java 2" );
c2.set( "category", "JAVA" );
c2.set( "price", 200 );
store.add( c2 );

BaseModel c3 = new BaseModel();
c3.set( "title", "C#" );
c3.set( "category", ".NET" );
c3.set( "price", 100 );
store.add( c3 );

List<ColumnConfig> config = new ArrayList<ColumnConfig>();
config.add( new ColumnConfig( "category", "Kategorie", 200 ) );
config.add( new ColumnConfig( "title", "Titel", 100 ) );
config.add( new ColumnConfig( "price", "Preis", 100 ) );

store.groupBy( "category" );

final ColumnModel cm = new ColumnModel( config );

GroupingView view = new GroupingView();
view.setShowGroupedColumn( false );
view.setForceFit( true );
view.setGroupRenderer( new GridGroupRenderer()
{
  public String render( GroupColumnData data )
  {
    String header = cm.getColumnById( data.field ).getHeader();
    String items = data.models.size() == 1 ? "Eintrag" : "Einträge";
    return header + " " + data.group + " (" + data.models.size() + " " + items + ")";
  }
} );

EditorGrid<BaseModel> grid = new EditorGrid<BaseModel>( store, cm );
grid.setView( view );
grid.setBorders( true );
grid.setAutoHeight( true ); 

ContentPanel cp = new ContentPanel();
cp.add( grid );
cp.setHeight( 500 );
RootPanel.get().add( cp );

Labels: GWT, Web Frameworks

Nach dem ich nun eine Woche eine Anwendung mit Ext GWT (GXT) zusammengebaut habe, kommen mir Zweifel, ob Ext GWT überhaupt das richtige für meinen Anwendungsfall ist. Einige Fragen in dem Zusammenhang:

Ist Ext GWT 2.0 M2 gut gewählt?

Ext GWT 2 gibt es noch gar nicht lange (http://extjs.com/blog/2009/05/20/ext-gwt-20-milestone-2-released/), neues M2 Release also vor 2 Wochen, und die Komponenten sind grundsätzlich toll. Auf der Demo Seite http://extjs.com/examples-dev/explorer.html#overview kann man sich das anschauen.

Probleme: Ext GWT 2.0 hat in meinen Augen sehr vielen Änderungen in der API. Quellcode für Ext GWT 1.0 findet man im Netz, doch viele Beispiele lassen sich nicht ohne weiteres auf die 2er Version übertragen. Wer migrieren will/muss wird noch seinen Spaß bekommen. Einige Beispiele laufen in der Demo nicht (http://extjs.com/examples-dev/explorer.html#grouping), bei anderen fehlt der Quellcode im Demo. Da muss man dann die Quellen laden.

Laut Ankündigung müsste GXT schon längst fertig sein.

Was passt mir an Ext GWT nicht?

• Die Dokumentation. Einfache Beispiele zu finden kostet viel Zeit. Es fehlt so etwas wie ein Java-Almanac für Ext GWT. Aus komplexen Szenarien kann man sich einfache Beispiele ableiten, von dort diese auf seinen Anwendungsfall übertragen. Selbst die Beispiele aus dem ShowCase könnten einfacher sein, denn der ShowCase nutzt interne “Demo-Datengeber-Klassen”. Hier wären in meinen Augen einfachere Beispiele gut gewesen, die wirklich eigenständig sind um schnell die wichtigsten Schnittstellen ablesen zu können.
• Compiliere ich meine Programme, so lassen sich im Browser plötzlich keine Textfelder mehr selektieren und den Cursor sieht man nicht.
• Das Layout-Handing. Da die Ext GWT Anwendungen auf eine “Bildschirmseite” kommen, und weniger auf einem beliebig langen HTML-Dokument, gibt es Probleme mit den Höhen. Manches mal sind die Elemente in einem Scroll-Container zu klein, dann zu groß. Ich habe viel Zeit damit verbracht, große Tabellen in den richtigen Größen auf den Container zu setzen.
• Während das Orginal-GWT viele eher den typischen Web-Charakter hat, basiert Ext GWT auf dem Applikationsgedanken: (Popup-)Menüs in Web-Applikationen? Hm …
• Anpassungen des Aussehens sind eine Qual. Die CSS-Datei gxt-all.css ist 6478 Zeilen lang, gxt-gray.css noch mal 443! Wer viel Zeit hat, kann einmal versuchen, den Font 2 Pixel größer zu setzen. Dazu müssen natürlich auch die Icons passen. Strg++ geht nicht einfach so.
• Es “erfindet” GXT eigentlich alles neu: Widgets, Container, Layout-Manager, Grafik-Einbindung, …. Besonders blöd ist das bei den Grafiken, wo Google mit Proxies einen schönen Ansatz fährt.
• Es gibt keinen Gui-Builder, für GWT aber schon.

War Ext GWT eine gute Wahl, oder hätte es doch SmartGWT sein sollen?

Das weiß ich nicht, denn mit SmartGWT habe ich nur einfache Beispiele programmiert. Ext GWT hat aber den gleichen RIA-Ansatz wie SmartGWT, und unterscheidet sich nicht großartig im Ansatz. Die GXT-Komponenten sehen auf jeden Fall super aus. Daher hat mich GXT ja auch so angezogen. Wer hübscher ist gewinnt :) Die Komponenten sind fancy und meine Lieblinge sind http://extjs.com/examples-dev/explorer.html#advancedcharts (cool), http://extjs.com/examples-dev/explorer.html#gridplugins, http://extjs.com/examples-dev/explorer.html#grouping, http://extjs.com/examples-dev/explorer.html#filtertree, http://extjs.com/examples-dev/explorer.html#gridtogrid.

Ist ein RIA-Framework wie GXT immer gut?

Das ist eigentlich die zentrale Frage.

• Die Standard-Komponenten von GWT sind etwas “einfach”. Natürlich nutzt GXT das GWT als Infrastruktur, aber hat sich in meinen Augen weit davon entfernt.
• GXT versucht, alle Desktop-Komponenten in den Browser zu bekommen. Und so bekommen wir immer mehr und mehr tolle Komponenten. Das hat aber seinen Preis! Der generierte JavaScript-Code wird schnell astronomisch. Und die Anwendungen sehen eben nicht mehr so aus wie Webseiten. Das ist mal gewollt, mal nicht gewollt. Ein richtig und falsch gibt es nicht! Wer aber vollständige Applikationen im Web-Schreiben möchte, der bekommt mit GXT ein gutes Framework. Alles ist vorbereitet und das Look-and-Feel konsistent.
• Änderungen des Aussehens sind aufwändig. Wenn man also HTML/CSS sehen und damit designen möchte, ist mit GXT nicht optimal bedient. (Als nächstes teste ich http://code.google.com/p/google-web-toolkit-incubator/wiki/UiBinder --- wenn der denn mal im Trunk ist…) Soll ein (echte) Webdesigner eine GXT-Anwendung skinnen, wird der sicherlich nicht glücklich werden. Es ist eben nicht Design first.

Labels: GWT, Web Frameworks

<link rel="stylesheet" href="/squared/styles/squared.css">
<script language="javascript" src="/squared/js/templates.js"></script>
<script language="javascript" src="/squared/api/com.google.quality.views.squared.client.Squared.nocache.js"></script>

Verfolgt man den Link ist das typische obfuscated JavaScript zu sehen. Wer viiiiel Zeit hat, kann das ja mal debuggen und hier berichten. Ein kleiner Test mit FireBug zeigt, dass Squared sich über Service per RPC die Objekte geben lässt

["com.google.quality.views.squared.shared.model.Workspace/4054808271","US presidents",
 "com.google.quality.views.squared.shared.model.Suggestions/3280816700",
 "java.util.ArrayList/3821976829",
 "com.google.quality.views.squared.shared.model.Entry/3459296909" ...

Labels: GWT, Web Frameworks

Die Daten einer Tabelle liegen zeilenweise in einem ListStore. Die ListStore wird mit dem generischen Typ parametrisiert, den das Modell speichern soll. Es können entweder eigene Beans sein, oder wir nutzen BaseModel, ein generischer Speicher von Ext GWT, der wie eine Map (oder Dyna-Bean) arbeitet.

ListStore<BaseModel> store = new ListStore<BaseModel>();

Geben wir der Tabelle zwei Zeilen, also zwei BaseModel-Objekte.

BaseModel c = new BaseModel();
c.set( "url", "http://www.tutego.com/index.html ");
c.set( "days", "34");
c.set( "price", "233");
store.add( c );

c = new BaseModel();
c.set( "url", "http://www.heise.de/newsticker/ ");
c.set( "days", "3");
c.set( "price", "2553");
store.add( c );

Die BaseModel-Objekte beschreiben also drei Spalten.

Nun sind die Daten im Speicher und die Informationen für die Spalten müssen aufgebaut werden. Jede Spalte wird durch ein ColumnConfig-Objekt beschrieben. Die ColumnConfig-Objekte werden dann in einer Liste gespeichert und zur Initialisierung eines ColumnModels genutzt. Ein ColumnConfig-Objekt bekommt Informationen wie die Breite, aber auch Editoren zugewiesen.

List<ColumnConfig> configs = new ArrayList<ColumnConfig>();

TextField<String> column1TextEditor = new TextField<String>();
column1TextEditor.setAllowBlank( false );
ColumnConfig column1 = new ColumnConfig( "url", "URL", 400 );
column1.setEditor( new CellEditor( column1TextEditor ) );
configs.add( column1 ); 

ColumnConfig column2 = new ColumnConfig( "days", "Tag(e)", 80 );
column2.setEditor( new CellEditor( new TextField<String>() ) );
configs.add( column2 );

ColumnConfig column3 = new ColumnConfig( "price", "Gesamtpreis", 80 );
column3.setEditor( new CellEditor( new TextField<String>() ) );
configs.add( column3 );

ColumnModel cm = new ColumnModel( configs );

Der parametrisierte Konstruktor von ColumnConfig erwartet einen Schlüsselnamen, den Titel für den Spaltenkopf und die Breite.

Jetzt kommt es zur Hautkomponente, dem EditorGrid. Er benötigt drei Informationen: Die Tabellendaten (der ListStore store), die Spaltendaten (ColumnModel cm) und als generische Angabe der Datentyp der Modellelemente.

EditorGrid<BaseModel> grid = new EditorGrid<BaseModel>( store, cm );

Die Komponenten wird nun wie jede andere auf den Container gesetzt.

panel.add( grid );

Zugriff auf die Daten liefert store.getModels(). Möchte man durch alle Zeilen laufen, erledigt dies einfach das erweiterte for:

for ( BaseModel model :store.getModels() )
  …

Labels: GWT, Web Frameworks

Ext GWT bietet eine einfache Möglichkeit, JavaBeans an Formulare zu binden. Im ersten Schritt muss die Bean dazu vorbereitet werden.

1. Die JavaBean implementiert das Marker-Interface com.extjs.gxt.ui.client.data.BeanModelTag.
2. Will man’s nicht-invasiv, so deklariert man ein Zusatz-Interface, was BeanModelMarker erweitert und hängt dort eine spezielle Zusatz-Annotation an, mit dem Verweise auf die JavaBean.

Gebunden werden soll der Titel eines Seminars an das Textfeld titleTextField auf dem FormPanel:

FormPanel courseDescriptionPanel = new FormPanel();

TextField<String> titleTextField = new TextField<String>();
titleTextField.setFieldLabel( "Kurstitel" );
titleTextField.setName( "title" );
titleTextField.setAllowBlank( false ); 
courseDescriptionPanel.add( titleTextField );

Im nächsten Schritt kann man die Bean aufbauen und etwa mit Werten aus einem Service füllen:

Course c = new Course();
c.setTitle( "ejb super kurs" );

Dann wird um diese Standard-JavaBean eine Ext GWT-Klasse gelegt, quasi ein Wrapper:

BeanModel userModel = BeanModelLookup.get().getFactory(Course.class).createModel( c );

Dieses BeanModel wird als nächstes mit dem FormPanel verbunden, auf dem das Texteingabefeld liegt.

FormBinding formBindingCourse = new FormBinding( courseDescriptionPanel );

Und das muss mit dem BeanModel (dem Wrapper um das Exemplar unserer JavaBean) verbunden werden:

formBindingCourse.bind( userModel );

Nun kennt der formBindingCourse die Bean, aber noch nicht, welches Gui-Element eigentlich mit welcher Property verbunden ist. Das kann man mit autoBind() automatisieren, oder aber mit addFieldBinding() manuell für jedes Element setzen. Bei unserem Textfeld heißt das:

formBindingCourse.addFieldBinding( new FieldBinding( titleTextField, "title" ) );

Jede Änderung an der Gui wird nun an die Bean weitergeben.

Weiteres Infos unter http://extjs.com/blog/2008/07/14/preview-java-bean-support-with-ext-gwt/ oder in Foren-Beispielen.

Labels: GWT, Web Frameworks

Dass Captchas wie

für uns Menschen nicht leicht zu lesen ist eine Sache, eine andere ist, dass viele schon gehackt wurden und Spammer so die Form-Formulare vollmüllen.

Ein anderes Verfahren zeigt Bilder, aus denen man ein bestimmtes auswählen muss. Diese Idee verfolgt zum Beispiel http://www.thepcspy.com/kittenauth. Hier muss man aus einer Reihe von Tieren auswählen, um das Formular abzuschicken.

Mein einziges Problem: Bei einigen Fragen fällt die Auswahl nicht leicht. Etwa bei der Frage, was alles Fohlen (engl. foals) sind. Einige Bilder sind so undeutlich, dass ich drei Versuche brauche um ein Formular zu bestätigen. Das ergibt wenig Sinn.

Siehe dazu auch http://research.microsoft.com/en-us/um/redmond/projects/asirra/.

Labels: Web Frameworks

GWT-SL bietet schon seit längerem die Möglichkeit, die RPC-Services durch Spring-Beans zu definieren. Ist Spring auf der Serverseite, so möchte man gerne Spring-POJOs als GWT-RPC-Service freigeben. GWT-SL ist aber relativ groß und mit http://code.google.com/p/gwtrpc-spring/ gibt es eine sehr schlanke Alternative, die nur aus zwei Klassen besteht. Das die Klassen, die beide im Quellcode unter 3 KB liegen, liegt daran, dass GWT in den neuen Versionen eine Integration RPC-Implementierungen vereinfacht. Die Hauptseite zeigt die 4 Schritten zur Integration anschaulich.

Labels: GWT, Open Source, Web Frameworks

gwt-connectors ist eine GWT-Bibliothek, um Formen miteinander zu verbinden.

Die Präsentation zeigt, wie das geht.

Wer’s selber ausprobieren möchte, schaut unter demo (IE, Firefox, Opera, Chrome). (Aber wie kann man nun die Verbindung wieder lösen …)

Der nötige Programmcode ist kurz:

// Create boundary panel
AbsolutePanel boundaryPanel = new AbsolutePanel();
boundaryPanel.setSize("600px", "400px");
RootPanel.get().add(boundaryPanel, 10, 10);
Diagram diagram = new Diagram(boundaryPanel);
boundaryPanel.add(new Label("Connectors example"), 10, 2);

// Add connectors
Connector connector1 = new Connector(50, 80, 100, 100);
connector1.showOnDiagram(diagram);

Connector connector2 = new Connector(350, 200, 270, 80);
connector2.showOnDiagram(diagram); 

Connector connector3 = new Connector(450, 120, 500, 80);
connector3.showOnDiagram(diagram); 

// Add some elements that can be connected
Label label = new Label("LABEL");
Image image = new Image("http://code.google.com/images/code_sm.png");
HTML html = new HTML("<b>HTML<br>ELEMENT</b>"); 

boundaryPanel.add(label, 50, 270);
boundaryPanel.add(image, 180, 250);
boundaryPanel.add(html, 450, 250); 

Shape shapeForLabel = new Shape(label);
shapeForLabel.showOnDiagram(diagram); 

Shape shapeForImage = new Shape(image);
shapeForImage.showOnDiagram(diagram); 

Shape shapeForHtml = new Shape(html);
shapeForHtml.showOnDiagram(diagram);

Ich bin gespannt, wann es das erste UML-Tool mit GWT gibt. gwt-connectores basiert im Übrigen auf Fred Sauer's gwt-dnd. (Dazu auch das Demo http://allen-sauer.com/com.allen_sauer.gwt.dnd.demo.DragDropDemo/DragDropDemo.html.)

Dazu passt auch die Ankündigung von http://googledocs.blogspot.com/2009/03/drawing-on-your-creativity-in-docs.html, ein Zeichenwerkzeug in Google Docs einzubetten:

http://www.googlewatchblog.de/2009/03/26/google-docs-drawing-veroeffentlicht/ hat dazu ebenfalls ein Bild parat:

Labels: GWT, Open Source, Web Frameworks

Alles fängt mit http://jquery.com/ an. Darauf baut auf http://code.google.com/p/flot/, eine JavaScript-Bib. für Chars:

• Basic example
• Different graph types and setting various options
• Turning series on/off
• Selection support and zooming and zooming with overview
• Plotting time series and visitors per day with zooming and weekends
• Dual axis support
• Interacting with the data

http://code.google.com/p/gflot/ ist nun der GWT-Aufsatz auf flot.

final String[] MONTH_NAMES = { "jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec" };

PlotModel model = new PlotModel();
PlotOptions plotOptions = new PlotOptions();

BarSeriesOptions barSeriesOptions = new BarSeriesOptions();
barSeriesOptions.setShow(true);
barSeriesOptions.setLineWidth(1);
barSeriesOptions.setBarWidth(1);
barSeriesOptions.setAlignment(BarAlignment.CENTER);

plotOptions.setDefaultBarsSeriesOptions(barSeriesOptions);
plotOptions.setLegendOptions(new LegendOptions().setShow(false));



// add tick formatter to the options

plotOptions.setXAxisOptions(new AxisOptions().setTicks(12).setTickFormatter(new TickFormatter() {

 public String formatTickValue(double tickValue, Axis axis) {

   if (tickValue > 0 && tickValue <= 12) {

     return MONTH_NAMES[(int) (tickValue - 1)];

    }

    return "";

  }

}));


// create a series

SeriesHandler handler = model.addSeries("Ottawa's Month Temperatures (Daily Average in &deg;C)", "blue");


// add data

handler.add(new DataPoint(1, -10.5));

handler.add(new DataPoint(2, -8.6));
handler.add(new DataPoint(3, -2.4));
handler.add(new DataPoint(4, 6));
handler.add(new DataPoint(5, 13.6));
handler.add(new DataPoint(6, 18.4));
handler.add(new DataPoint(7, 21));
handler.add(new DataPoint(8, 19.7));
handler.add(new DataPoint(9, 14.7));
handler.add(new DataPoint(10, 8.2));
handler.add(new DataPoint(11, 1.5));
handler.add(new DataPoint(12, -6.6));

// create the plot
SimplePlot plot = new SimplePlot(model, plotOptions);

// put it on a panel
FlowPanel panel = new FlowPanel();
panel.add(plot);

return panel;

Eine Alternative dazu ist http://code.google.com/p/charts4j/  bzw. http://code.google.com/p/charts4j/wiki/GWT_Port.

Labels: GWT, Open Source, Web Frameworks

Nach Python unterstützt die GAP nun auch Java 6. Allerdings gibt es auch einige Besonderheiten:

• Kein Dateisystem (somit keine sinnvollen java.io.File-Operationen), da Zugriff über den App Engine Datastore
  
• Keine eigenen Threads
• Kein AWT- und Swing-Funktionalität/Pakete. Dass man kein Fenster aufmachen kann ist klar, aber es können auch keine Bilder skaliert werden und einige Web-Frameworks nutzen Swing-Modelle wie TableModel. (Für die Bild-Operationen bietet Google eine eigene API: http://code.google.com/intl/de/appengine/docs/java/images/overview.html)
  
• Eingeschränktes Reflection
• Besonderer Klassenlader
• (Natürlich) kein JNI
• Nicht unterstützte Dinge werfen eine SecurityException
  

Nichts desto trotz laufen auch dyn. Sprachen wie Groovy und JRuby. Und es gibt ein Eclipse-Plugin für das Deployment (Google Plugin for Eclipse). Datenzugriff der AppEngine gibt es mit der API von JPA/JDO über http://www.datanucleus.org/products/accessplatform/ (früher JPOX), IMHO eine recht unbekannte Implementierung der Standards.

Zum Weiterlesen:

• http://code.google.com/intl/de/appengine/docs/java/overview.html
• http://googleappengine.blogspot.com/2009/04/seriously-this-time-new-language-on-app.html
• http://www.infoq.com/news/2009/04/gae
• http://code.google.com/intl/de-DE/appengine/docs/java/jrewhitelist.html
• http://paulhammant.com/blog/google-app-engine-for-java-with-rich-ruby-clients.html
• http://www.vineetmanohar.com/2009/04/11/writing-java-hello-world-for-google-app-engine/
• http://broadcast.oreilly.com/2009/04/java-for-google-appengine-fina.html
• http://www.theserverside.com/news/thread.tss?thread_id=54256
• 
  

Labels: Open Source, Web Frameworks

• Die Container und Layout-API sehen ein wenig anders aus. Bei SmartGWT gibt es eine Klasse Layout (und Unterklassen wie VLayout), die eigentlich Container mit einem speziellen assoziierten Layoutmechanismus sind. So heißt es dann auch layout.addMember(...) und das ist gewöhnungsbedürftig. Da gefällt mir Ext-GWT besser, wo wie bei AWT/Swing den Layout-Manager auf einem Container setzt. Hier wird also bei Ext-GWT das übliche Strategie-Muster eingesetzt.
• Die Optik von Ext-GWT (etwa bei Menüs) ist in meinen Augen deutlich besser. Es gibt viele kleine Fehler in der Darstellung, etwa Ein-Pixel freie Linien.
  
• Ext-GWT bietet bessere Unterstützung für Formulare, was etwa das automatische Ein-/Ausfalten von Details angeht.
• SmartGWT bietet vertikale Tabs und eine Integration vom Google Kalander.
• Das Binding funktioniert bei beiden völlig anders. SmartGWT erwartet spezielle Binding-Komponenten, also etwa DataSourceTextField statt TextItem (ja, warum das nun nicht DataSourceTextItem heißt, ....). Wenn später Quellcode umbaut wird, muss man die Komponenten ändern und wenn eine angepasste Unterklasse etwa von TextItem erbt, muss das auch anpasst werde. Das Design ist in meinen Augen nicht optimal. Besser macht es Ext-GW; hier bleibt man bei den Standardkomponenten und setzt diese später zu einer Gruppe (FormBinding) zusammen.
• Ext-GWT bietet eine prima XTemplate-Klasse, in der dann Platzhalter definiert werden können, etwa {[new Number(values.change).toFixed(2)]}, die später über das Binding ersetzt werden.
• Bei SmartGWT lässt sich nicht jede Komponente in einen DynamicForm setzen. Bei der RTF-Komponente RichTextEditor (ein VLayout) geht das zum Beispiel nicht. Dafür gibt es noch mal den Wrapper RichTextItem (ein FormItem). Das ist verwirrend.
  
• Ohne Anpassungen beim SmartGWT ist der Font rechts einer Checkbox ein andere als Links von einem Textfeld.Und Warum muss bei TextItem immer standardmäßig ein Doppelpunkt gesetzt werden, was dann auch noch mit einem Leerzeichen vom Text abgesetzt wird?
• SmartGWT hat merkwürdige Klassennamen wie com.smartgwt.client.core.BaseClass oder IButton (und eine Button-Klasse gibt es auch noch).
• SmartGWT-Methoden mit den Namen addItem(), addMember(), addChild() und addPeer() tragen nicht zur Übersichtlichkeit beim Hinzufügen von Komponenten be

• void setAttribute(java.lang.String attribute, boolean value)
• void setAttribute(java.lang.String attribute, java.lang.Boolean value)
• void setAttribute(java.lang.String attribute, DataClass value)
• void setAttribute(java.lang.String attribute, DataClass[] value)
• void setAttribute(java.lang.String attribute, java.util.Date value)
• void setAttribute(java.lang.String attribute, double value)
• void setAttribute(java.lang.String attribute, int value)
• void setAttribute(java.lang.String attribute, int[] value)
• void setAttribute(java.lang.String attribute, com.google.gwt.core.client.JavaScriptObject value)
• void setAttribute(java.lang.String attribute, java.util.Map value)
• void setAttribute(java.lang.String attribute, java.lang.String value)
• void setAttribute(java.lang.String attribute, java.lang.String[] value)
• void setAttribute(java.lang.String attribute, ValueEnum[] value)

Labels: GWT, Web Frameworks

1. Unter http://code.google.com/p/smartgwt/downloads/list lade smartgwt-1.0b2.zip und packe es aus.
2. Setzte smartgwt.jar (und smartgwt-skins.jar falls Skinning gewünscht ist) in das lib-Verzeichnis der Web-Applikation (oder überall anderes hin, die Jar-Datei spielt ja später keine Rolle mehr) und melde die Java-Archive im Klassenpfad an.
3. In der Modul-XML-Datei füge ein:
   <inherits name="com.smartgwt.SmartGwt"/>
   Eintragungen für CSS in der HTML-Datei sind nicht nötig.
4. In der onModuleLoad() kann man man etwa schreiben:
   RootPanel.get().add( new IButton("Klick mich härter") );
   Imports wieder generieren lassen, mit dem Präfix I gibt es keine Verwechslungen.
5. Ideen und API aus dem http://www.smartclient.com/smartgwt/showcase/ und http://www.smartclient.com/smartgwt/javadoc/

Labels: GWT, Web Frameworks

Voraussetzung: http://www.tutego.com/blog/javainsel/2008/05/gwt-beispiel-in-eclipse.html

1. Lade unter http://extjs.com/products/gxt/download.php das Ext GWT 1.2.3 SDK http://extjs.com/products/gxt/download.php?dl=gxt123 und entpacke es.
2. Setzte gxt.jar in das WebContent/WEB-INF/lib Verzeichnis (oder überall anderes hin, die Jar-Datei spielt später keine Rolle mehr). Füge das Java-Archiv zum Klassenpfad hinzu (Java Build Path > Add)
3. Die Host-Page im public-Ordner bekommt einen Verweis auf das Sytesheet. Setzte unter <head>:
   <link rel="stylesheet" type="text/css" href="css/ext-all.css" />
4. Im public-Verzeichnis gibt es ebenfalls die Modul-XML Datei. Füge hinzu:
   <inherits name='com.extjs.gxt.ui.GXT'/>
5. In onModuleLoad() kann man nun ein Demoprogramm schreiben, was eine Ext GWT Komponente nutzt:
   RootPanel.get().add( new DatePicker() );
   Imports wieder automatisch generieren lassen. Aufpassen, dass man bei Mehrdeutigkeiten die korrekten import-Anweisungen generiert werden. So gibt es Window zum Beispiel zweimal.
6. Die API-Doku http://extjs.com/deploy/gxtdocs/ und die Beispiele vom ShowCase http://extjs.com/explorer/#overview zeigen den Gebrauch der API.

Labels: GWT, Web Frameworks

1. Lade das WAR-Archiv http://quercus.caucho.com/download/quercus-3.2.1.war von http://quercus.caucho.com/.
2. Packe der WAR-Archiv aus.
3. Lege in Eclipse ein Dynamic Web Project (etwa unter dem Namen php) an.
4. Verbinde es mit Tomcat. (Tomcat kann über Eclipse neuerdings auch automatisch heruntergeladen werden.)
5. Kopiere aus dem ausgepackten Quercus-WAR das WEB-INF in das WEB-INF vom Eclipse-Web-Projekt (3 Jars in lib und web.xml)
6. Kopiere images und index.php aus dem ausgepackten Quercus-WAR in WebContent
7. Starte Tomcat in der Eclipse-View
8. Gehe im Browser auf http://localhost:8080/php/

Labels: Open Source, Web Frameworks

Aus der http://groups.google.com/group/Google-Web-Toolkit-Contributors/browse_thread/thread/09ce2144aa8491e6?pli=1:

The GWT team is happy to announce the availability of Google Web Toolkit 1.6 Milestone 2! Binary distributions are available for download directly from the GWT Google Code project. http://code.google.com/p/google-web-toolkit/downloads/list?can=1&q=1.... If you have already tried GWT 1.6 Milestone 1, you may not notice much difference in Milestone 2. Changes have mostly been general polish and various small bug fixes. For the nitty-gritty details of the changes since the previous milestone, see the attached source control commit logs. You can also watch the GWT bug tracker for the most up-to-date list of resolved issues ( http://code.google.com/p/google-web-toolkit/issues/list?can=1&q=statu...). As for doc, the javadoc that comes bundled with the distribution should be up-to-date, but the online Developer Guide ( http://code.google.com/docreader/#p=google-web-toolkit-doc-1-6) is still being tweaked. We anticipate that GWT 1.6 M2 will be the last milestone build for this version. After a few more bugs fixes and a bit more doc, we expect it to be followed soon by a release candidate build. In the meanwhile, please report bugs to the GWT issue tracker (http://code.google.com/p/google-web-toolkit/issues/list) after doing a quick search to see if your issue has already been reported. If you encounter a bug in 1.6 M2 that you think qualifies as a showstopper, we would greatly appreciate it if you'd also reply on this thread to alert the engineering team.

Über weitere GWT-Updates und Produkte hält http://www.ongwt.com/ auf dem Laufenden.

Labels: GWT, Web Frameworks

Aufruf von http://suchen.mobile.de/fahrzeuge/anbieter-521268-seite81-112.html

macro city [on line 30, column 9 in search/vlisting/listSearchResults.ftl] in user-directive city [on line 76, column 229 in search/vlisting/listSearchResults.ftl] in user-directive rd.html [on line 62, column 9 in search/vlisting/listSearchResults.ftl] ---------- Java backtrace for programmers: ---------- freemarker.template.TemplateException: Error executing macro: city required parameter: resultView is not specified. at freemarker.core.Macro$Context.sanityCheck(Macro.java:181) at freemarker.core.Macro$Context.runMacro(Macro.java:161) at freemarker.core.Environment.visit(Environment.java:537) at freemarker.core.UnifiedCall.accept(UnifiedCall.java:128) at freemarker.core.Environment.visit(Environment.java:196) at freemarker.core.MixedContent.accept(MixedContent.java:92) at freemarker.core.Environment.visit(Environment.java:196) at freemarker.core.Case.accept(Case.java:80) at freemarker.core.Environment.visit

:

:

org.apache.catalina.valves.AccessLogValve.invoke(AccessLogValve.java:542) at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:151) at org.apache.jk.server.JkCoyoteHandler.invoke(JkCoyoteHandler.java:200) at org.apache.jk.common.HandlerRequest.invoke(HandlerRequest.java:283) at org.apache.jk.common.ChannelSocket.invoke(ChannelSocket.java:773) at org.apache.jk.common.ChannelSocket.processConnection(ChannelSocket.java:703) at org.apache.jk.common.ChannelSocket$SocketConnection.runIt(ChannelSocket.java:895) at org.apache.tomcat.util.threads.ThreadPool$ControlRunnable.run(ThreadPool.java:685) at java.lang.Thread.run(Thread.java:619)

Wenn man in Google nach "org.springframework.web.servlet.view" sucht,  bekommt man auch noch mehr indexierte Webseiten, die diese Fehler aufweisen.

Labels: Web Frameworks

Apache Click http://incubator.apache.org/click/ heißt es und läuft ab Java 1.4. Super. Kommt damit 5 Jahre zu spät. Also nix mit Annotationen. Schön XML und so. (Click 0.3 gab es auch schon im März 2005, also ist das Projekt nicht wirklich jung.) Das Wort Ajax taucht auf den ganzen Webseiten nicht auf. Immerhin gibt es eine http://incubator.apache.org/click/docs/click-ide.html auf Eclipse 3.4 Basis. Toll die Antwort auf die Frage "Why develop a new Web Application Framework?" Antwort: "Because the existing frameworks did not meet my needs. Struts doesn't really do much, while Tapestry is too complicated. For a more comprehensive answer please see Why Click." Klar, als ob es nur Struts und Tapestry gibt. Vor 10 Jahren vielleicht. Bei Struts 1.x ist die Zeit schon lange abgelaufen und bei Tapestry 5 hält man sich noch ein wenig mit DI/IoC über Wasser.

Labels: Open Source, Web Frameworks

Die Nachricht vom Dezember 2008 ist schon etwas älter, ist aber dennoch eine Meldung wert.

The Woodstock release 4.2 is the last official version of Woodstock that Sun will release. Sun will continue to support its customers that have built on top of Woodstock 4.2. The Project Woodstock code is still available, and community members can still create new features or enhancements.

Damit geht Suns Versuch, eine "Standard"-JSF-Komponenten-Sammlung aufzubauen, auch zu Ende. Nun hat sich Sun von JSF-Komponenten nicht ganz abgekehrt, und unterstützt ICEfaces. ICEFaces steht unter der Mozilla Public License (MPL) und ist mit RichFaces die populärste JSF-Komponentensammlung. Die Demo-Seite zeigt warum. Zudem gab es letzte Jahr eine Auszeichnung.

We are very pleased to announce that ICEfaces has been voted the Best Overall Enterprise RIA Product by the AJAXWorld RIA Conference & Expo 2008 West delegates.

Sun geht es mit dem Schritt zu ICEFaces insbesondere darum, die JSF-Bibliothek in NetBeans gut zu unterstützen. ICEfaces 1.7 wurde schon früh in der Version NetBeans 6.0.1 integriert.

• ICEfaces Evolves Integration with NetBeans IDE and GlassFish
• Woodstock to ICEfaces Migration, Woodstock Migration Path to ICEfaces
• http://www.netbeans.org/kb/articles/icefaces-netbeans-crud-apps.html

Das ICEfaces Project integration for Eclipse 3.4 unterstützt als Eclipse-Plugin Eclipse 3.4 und ICEFaces 1.7.2SP1.

Es ist auch auch ICEfaces 1.8.0-RC1 now available. Siehe dazu auch http://www.icefaces.org/releasenotes/icefaces-1.8.0-RC1-RN.html.

Labels: Open Source, Web Frameworks

Eine tolle GWT-Anwendung/Bibliothek ist http://code.google.com/p/emite/:

Der Chat-Client läuft im Browser als GWT-Anwendung. Über einen Proxy kann dann der Client (Browser) direkt mit dem Xmpp Server sprechen. (Noch ist ein Proxy nötig, siehe http://ejohn.org/blog/cross-site-xmlhttprequest/). Das heißt, emite implementiert das Extensible Messaging and Presence Protocol (XMPP), um über Bidirectional-streams Over Synchronous HTTP (BOSH) die Daten zum Chat-Server zu senden. Da emite auf der einen Seite eine Bibliothek ist und auf der anderen Seiten ein Chat-Client mit der hübschen Gui, lässt sich die Bib. natürlich auch getrennt nutzen; eine Nachricht wird etwas so versandt:

Session session = Suco.get(Session.class);
session.login(XmppURI.uri("me@domain", "myPassword");
Message message = new Message("send this");
session.send(message);

Intern setzt emite auf http://code.google.com/p/suco/ auf. Suco ist ein einfaches DI-Framework für GWT-Applikationen zusammen mit einem Eventing-Framework. (Suco ist nicht Annotationsgetrieben, da kein echtes Reflection mit GWT möglich ist. Mit einem speziellen Builder könnte man da aber was machen. Hm...)

Labels: Open Source, Web Frameworks

SmartClient Ajax (http://www.smartclient.com/) ist eine (weitere) Ajax-Bibliothek für RIA-Anwendungen. Die Demos unter http://www.smartclient.com/index.jsp#_Welcome zeigen auch, was man heute von RIA-Frameworks erwartet: Nette Komponenten, Layout-Manager und Data-Binding über diverse Datenquellen. Es geht nicht nur um hübsche Widgets allein und die Optik ist auch nur OK. (Obwohl http://extjs.com/ in meinen Augen immer noch aus optischen Gründen vorne liegt, hat doch SmartClient Ajax einen sehr großen Vorteil: SmartClient Ajax platform now open source under LGPL. Ext JS ist, wenn man es denn kommerziell einsetzten möchte, nicht ganz billig.)

Für die JS-Library gibt es mit http://code.google.com/p/smartgwt/ auch eine GWT-Wrapper SmartGWT. Der Showcase liegt unter http://www.smartclient.com/smartgwt/showcase/, die JavaDoc unter http://www.smartclient.com/smartgwt/javadoc/. SmartGWT liegt wie auch SmartClient Ajax unter der LGPL. Der Port ist mehr oder weniger die (Fleiß)Arbeit einer Person Sanjiv Jivan. Die folgenden Screenshots stammen aus seinem Blog http://www.jroller.com/sjivan/entry/smartgwt_1_0_released:

Labels: GWT, Open Source, Web Frameworks

Sind

• http://noon.gilead.free.fr/gilead/
• http://gwt-widget.sourceforge.net/

Gilead (früher Hibernate4GWT), abgeleitet von "Generic Light Entity Adapter" ist ein interessantes Projekt mit folgendem Konzept:

transform persistent entities back to simple Plain Old Java Object, by removing code instrumentation and replacing persistent collections with their regular counterpart.

Kommt zum Beispiel eine JPA-Bean mit Assoziationen mit Eager-fetching rein, kommt ein vollständig geladener Objektgraph raus. Das ist praktisch genau dann, wenn man einen Daten-Service hat, den man von der GWT-Oberfläche zum Holen der Daten nutzt, aber die JPA-Implementierung baut diverse Proxies ein.

Das SF-Projekt "GWT-Widgets" besteht aus zwei Teilen: Der GWT Server Library (GWT-SL) und der GWT Widget Library. Die GWT-SL ist eine GWT-Spring-Integration. Mit dem GWTRPCServiceExporter können etwa die Spring-POJOs als GWT-Services veröffentlicht werden. Die Doku stellt die Arbeitsweise kurz vor.

Labels: GWT, Open Source, Web Frameworks

Labels: GWT, Open Source, Web Frameworks

YUI4JSF (http://yui4jsf.sourceforge.net/) bietet auf der Basis der The Yahoo! User Interface Library (YUI) neue JSF-Komponenten:

• Accordion Menu
• CommandButton
• Ajax CommandButton
• CommandLink
• Menu Button
• Auto Complete
• Slider
• Calendar
• Datatable
• Column
• Editor
• Menu
• MenuBar
• SubMenu
• Menuitem
• Menu Button Item
• TreeView
• TabView
• Tab
• SortList
• SlideShow
• Panel
• Dialog
• Simple Dialog
• Choose Color
• Input Color
• Tooltip
• Logger

Die Webseite schreibt über das YUI4JSF-Projekt:

Components that wrap around builtin YUI Widgets. YUI has many widgets like calendar, slider, autocomplete, treeview, inputColor and etc. YUI4JSF takes these widgets and provides pure JSF Components which take care of the javascript and server side interaction.

Components powered by YUI Utilities. YUI Utilities like DragDrop Utils are used to create custom components like SortList or Accordion Panel.

AJAX Forms (Beta). YUI4JSF Ajax components like ajaxCommandButton ajaxifies your existing forms in few seconds.

Layout Engine (Experimental). YUI4JSF provides a templating engine that helps creating a flexible layout mechanism in your JSF pages.

Das Demo (http://www.nightdev.devisland.net/yui4jsf-examples) zeigt die Komponenten live. Wenn ich allerdings das Look-and-Feel der YUI-Beispiele mit denen von YUI4JSF vergleiche, kommt YUI4JSF irgendwie schlechter weg.

License: Apache License V2.0

Labels: Open Source, Web Frameworks