Released GWT 2.0 with Speed Tracer

GWT 2.0 new features

• Fast edit/refresh with new development mode and draft compiles
• Declarative UI with UiBinder
• Pixel-perfect visuals with layout panels
• Compiler improvements
• Optimized resources with ClientBundle

Download GWT 2.0

Speed Tracer : http://code.google.com/webtoolkit/speedtracer/

Speed Tracer Examples : http://code.google.com/webtoolkit/speedtracer/speed-tracer-examples.html

Article : GWT Now With SpeedTracer

Video about GWT 2.0 Features :

GWT 2.0 New Features

Internationalization (I18n) – GWT

Introduction

Internationalization (i18n for short) is the process of adding a framework to support different national languages to your program. Localization (l10n) occurs when you use that framework to customize the program for each language. National language support is only going to get more important over time as internet usage grows in countries like China, India, and Brazil. Luckily GWT provides full and flexible support as of version 1.1.10 of the toolkit. Even if your application is not intended for a global audience, it pays to put all your human readable text in one place. You can more easily spell check your messages and ensure consistency between them if they’re all in the same file. It also lets non-programmers change the messages to correct grammatical errors or trademark usages without having to modify the code. The standard Java way to accomplish this is through resource bundles and property files. GWT lets you use these familiar concepts in your web applications as well.

Click here – complete article

GWT SmallTalk

Source: http://gwtsmalltalk.wordpress.com/

GWT Smalltalk (GST) is an implementation of the Smalltalk language which runs in web browsers.

It is built using the Google Web Toolkit (GWT) and is deployed on the Google Application Engine (GAE).

GST is designed to be used as development environment for the creation and maintenance of web-application clients. The GST server-side component supports GAE “Big Table” database access, instant messaging through XMPP, and the current release of the Google Wave API.

GST is implemented as a compiler – Smalltalk code is compiled to JavaScript source which is then evaluated to JavaScript functions. Speed on some arithmetic tests appears to be faster than Squeak Smalltalk.

Classes and method lookup are implemented similarly to Smalltalk-80 – class inheritance, instance variables, “self” and “super” are all explicitly supported.

GST is undergoing development and there are still many omissions and errors in the code.

You are welcome to take a look here.

GWT – 2D Graphics

2D graphics/multimedia library via HTML canvas

Demo

http://gwt-g2d.appspot.com/

Source

http://code.google.com/p/gwt-g2d/

gwt, canvas, game, media, 2d, g2d

GWT Library

Demo version can be seen here: http://www.future-earth.eu/gwt/calendar/MainDemoApp.html

Source : http://code.google.com/p/ftr-gwt-library/

GWT ENT – A Reflection, AOP, HTML template, UI Binding, Validate(JSR303) framework and JPA annotation Emulation for GWT

A Reflection, AOP, HTML template, UI Binding framework for GWT.

This project aims to make it easier to do what you want to do with GWT, now, the fllowing things have been contained in our project:

Reflection

Reflection for GWT, Support reflection of the following elements:

1. annotation
2. class
3. field
4. method
5. constructor(constructor.newInstance())
6. meta data of class(Going to be deleted, please using annotation instead)

Aspect-Oriented Programming for GWT

Support AOP in Client side, coded by JAVA(not based javascript library). Support both aspectj annotations and @pointcut/Google-guice matcher class, Please see here for all interceptors in sample project.

1. @Around
2. @Before
3. @After
4. @AfterReturning
5. @AfterThrowing

HTML Template

HTML template, Annotation based HTML template framework for GWT(HTML Template).

UIBinding

UI Binding, UIBinding framework from gwt-ent, Annotation or code based(UIBinding).

Validate

Support JSR-303, and the GWT way to support I18N

JPA Annotations Emulation

Give you ability to share domain classes between server side and client side.

GWT UI Generator

Please NOTE: It’s under fully refactor. gwt ui generator(WhyUIGenerator HowToUseUIGenerator)

Others

gwt acegi integration(IntegrationGWTWithAcegi)Please note that, all source code available at: http://code.google.com/p/gwt-ent/source

GWT Portlets

• This page has moved to
• http://vinaytechs.blogspot.com/2009/09/gwt-portlets.html
• Sorry for any inconvenience caused!

GWT Portlets is a free open source web framework for building GWT (Google Web Toolkit) applications. It defines a very simple & productive, yet powerful programming model to build good looking, modular GWT applications.

The programming model is somewhat similar to writing JSR168 portlets for a portal server (Liferay, JBoss Portal etc.). The “portal” is your application built using the GWT Portlets framework as a library. Application functionality is developed as loosely coupled Portlets each with an optional server side DataProvider.

Every Portlet knows how to externalize its state into a serializable PortletFactory subclass (momento / DTO / factory pattern) making important functionality possible:

• CRUD operations are handled by a single GWT RPC for all Portlets
• The layout of Portlets on a “page” can be represented as a tree of WidgetFactory’s (an interface implemented by PortletFactory)
• Trees of WidgetFactory’s can be serialized and marshalled to/from XML on the server, to store GUI layouts (or “pages”) in XML page files

Other important features of the framework are listed below:

• Pages can be edited in the browser at runtime (by developers and/or users) using the framework layout editor
• Portlets are positioned absolutely so can use scrolling regions
• Portlets are configurable, indicate when they are busy loading for automatic “loading spinner” display and can be maximized
• Themed widgets including a styled dialog box, a CSS styled button replacement, small toolbuttons and a HTML template driven menu

GWT Portlets is implemented in Java code and does not wrap any external Javascript libraries. It does not impose any server side framework (e.g. Spring or J2EE) but is designed to work well in conjunction with such frameworks.

source: http://code.google.com/p/gwtportlets/

Ajax File Uploader for javascript users

GWTUpload is a library for uploading files to web servers, showing a progress bar with real information about the process (file size, bytes transferred, etc). It uses ajax requests to ask the web server for the upload progress. It has two components written in java, the server side with servlet and utility classes, and the client side that is compiled into javascript using gwt.

JSUpload is the same client library but compiled and exported into javascript, so users that don’t develop in java can use it directly in web pages. It provides a server program written in perl that can be installed in any web server as a cgi-bin script.

Goals

All the components are documented.

The user can configure customized functions for onChange, onStart and onFinish events

The user can customize the provided progress bars, or implement his own.

Both the client and server sides, are easy to use just writing a few lines of code.

The server side could be implemented in any language.

The client side can be used from gwt applications, or from javascript without knowing gwt.

There are available widgets for multiple and single uploads

It works in any browser with js enabled, and it doesn’t need any plugin installed like flash or gears.

The provided widgets are ready to use, in the sense that they come with a set of configured styles.

Source : http://code.google.com/p/gwtupload/

Screenshots:

GWT-cs: GWT application construction with Spring

GWT-cs is a GWT module that allows developers to construct their GWT client side code using Spring IoC. It combines the powerful features of deferred binding and generator from GWT and inverse of control from Springframework, so that developers can define their application structures not only of their server code, but also of their client side GWT class beans.

One can enjoy the full support of the existing Srpingframework tool sets, such as Spring IDE Eclipse plugin in authoring the Spring bean configurtion files. GWT compiler will invoke the GWT-cs bean factory generator to generate the factory class(s) at compile time from the (Spring) configuration file(s), which will then be compiled by GWT compiler into javascript for runtime execution.

GWT-cs features a tiny archive file with only two classes and one interface. The current release (v0.11) supports a subset of the Spring IoC functions that are enough to let developers to build their GWT application structures. GWT-cs does not dictate how it is done, but leaves the door fully open for anybody to do it in his own way. Typically, a bean defined in Spring xml configuration file would be a GWT Composite class and one can define one or more beans to collaborately build a page.

Source : http://code.google.com/p/gwt-cs/

Screenshot:

Debug Panel for GWT Developers

Check out an online example of the Debug Panel, check out the example’s source to see how easy it is to use or check out the Google Code project for more information.

Flex VS Ajax Vs Silverlight

• This page has moved to
• http://vinaytechs.blogspot.com/2009/09/flex-vs-ajax-vs-silverlight.html
• Sorry for any inconvenience caused!

adnotatio – GWT-based HTML annotation tool

Source :http://code.google.com/p/adnotatio/

This project contains the following parts:

• adnotatio.client.annotator - The annotator framework.
• adnotatio.renderer - A very extensible XML template system used to define declarativly GWT interfaces.
• adnotatio.common - A set of utilities used by the annotator and by the template system. This code has no external dependencies (besides standard java/GWT libraries) and it contains:
  • Asynchronious resource loaders and “barriers”
  • Generic event system
  • Cache system
  • XML utilities

gwt-canvas : Canvas support for the Google Web Toolkit (GWT)

Source : http://code.google.com/p/gwt-canvas/

gwt-canvas Demo

To see gwt-canvas in action check out this interactive demo and/or this MasterMind game.

If you haven’t heard about the canvas yet, learn more at Mozilla’s tutorial (covers only native Canvas usage).

 

gwt-rolodex : A gwt widget for the animated display of image sets

• This page has moved to
• http://vinaytechs.blogspot.com/2009/09/gwt-rolodex-gwt-widget-for-animated.html
• Sorry for any inconvenience caused!

This widget displays a stack of images that you can flick through like a rolodex or a card deck. It uses gwt’s deferred binding for the image generation and lightweight animation to create a fast and smooth experience in all supported browsers. Check out the HelpMovieDemo and FlipBookDemo demos.

 

GFlot – GWT charting library

“Flot is a pure Javascript plotting library”. GFlot is a GWT adaptation of Flot which combines the high quality charting capabilities of Flot with the power of GWT. In addition, GFlots provides an MVC abstraction layer that ease the development of complex charts and integrates nicely with the GWT RPC infrastructure.

Demo

Check out the showcase demo here. The source code for the examples is here.