Chapter 1 introduces GWT and examines where it sits in relation to complementary
and competing technologies. It also shows how easy it is to get a first GWT
application up and
Chapter 2 provides a detailed understanding of the steps required to build the
default GWT application using the GWT command-line tools, indicating what each
tool is, why it’s used, and when you should use it. This chapter also discusses alternative
approaches to creating your application, including by hand and by using
an IDE wizard.
xxvi ABOUT THIS BOOK
Chapter 3 is the first step you’ll take away from the default GWT application and
toward the initial version of the Dashboard. We’ll explain what default files you
need to change/replace and why.
Chapter 4 starts our discussion of standard GWT components. It looks at widgets,
but not in a textbook style. Using component applications from the running
Dashboard application, you’ll get insight into the use of key widgets from GWT.
The second part of the chapter looks at building your own widgets, including the
GWT Widget Libraries PNGImage widget and two widgets that extend the standard
Chapter 5 covers panels, looking at how they’re used in the Dashboard and how to
extend and create your own panels—including the DashboardPanel used for the
Dashboard application components.
Chapter 6 introduces event handling as performed by GWT and explains how to
harness it for your own components. You’ll see how to handle new events for widgets
as well as plumb together the event handling for double-clicks and so on.
Chapter 7 finishes the four key aspects of GWT application components by thoroughly
discussing the development of composite widgets. We lean on the EditableLabel,
which has been around for nearly a year and is included in the GWT
Widget Library. You’ll also build some slider composite widgets, culminating in a
sliding color-picker widget.
and want to interact with. The GWT Widget Library includes a GWT widget that
wraps the Google Ajax Search functionality; you’ll learn how we built that component
as well as how to wrap the Google Video Search component.
Chapter 9 wraps up the direct user interface components included in the book.
You’ll learn the details of using the GWT module’s XML configuration file to,
among other things, inject resources, alter the project layout, invoke class replacement
and generation, and include server components. You’ll also see how to
include third-party GWT libraries, as well as how to create you own libraries of
Chapter 10 takes you into the world of GWT-RPC, where you’ll learn how to pass
Java objects between the web browser and your Java servlets.
ABOUT THIS BOOK xxvii
Chapter 11 expands on the previous chapter by showing you common usage patterns
and custom serialization for GWT-RPC. This include polling techniques,
including how to emulate server-push.
Chapter 12 looks at GWT’s support for classic Ajax and HTML forms. These tools
offer flexibility, allowing your GWT application to connect to any server-side application.
This chapter provides real-world examples for loading external configuration
data and using GWT to upload files to the server.
Chapter 13 finishes our discussion of client-server communication with GWT’s support
JSON is and provide an example of using it to communicate with the Yahoo
Chapter 14 looks at GWT’s powerful generators. You’ll learn how to build generators
that introspect code at compile time to generate new subclasses with additional
functionality. You’ll also see how these generators can promote comments
written in code to be displayed in dialogs to the user at runtime.
Chapter 15 rounds off the advanced techniques by thoroughly covering properties,
including internationalization both in the normal sense of changing text for
labels and menus, and so on, and also in terms of changing whole components of
your application based on the defined locale. You’ll also use properties to drive
the selection of the view that is presented to the user.
Chapter 16 shows you how to test your GWT code with JUnit and how to deploy
your finished application to the server. You’ll learn how to organize your deployed
code to reduce clutter on the server.
Chapter 17 completes the book by investigating the underlying mechanisms of
GWT, for those interested in delving a little deeper. You’ll see how bootstrapping
works (including the changes introduced by GWT 1.4), what your compiled code
should look like, and what the various output files produced by the compiler are