Part 1 Basics

1 GWT

1.1 Unplanned consequences (or the road to GWT)

1.2 Exploring the toolkit

1.3 Setting up your development environment

1.4 Summary

2 Building a GWT application: saying “Hello World!”

2.1 What’s a GWT application?

2.2 Examining the options for building an application

2.3 Creating the HelloWorld application with the GPE

2.4 Running HelloWorld in development mode

2.5 Finding out where it went wrong

2.6 Compiling HelloWorld for web mode

2.7 Understanding modules vs. packages

2.8 Digging deeper into the uncompiled application

2.9 Reviewing the deployable application part of a GWT application

2.10 Building on your understanding

2.11 Summary

3 Building a GWT application: enhancing HelloWorld

3.1 Reexamining the example application

3.2 Updating the HTML

3.3 Enhancing the code

3.4 Creating your user interface

3.5 Manipulating the page

3.6 Handling events

3.7 Managing history

3.8 Styling components

3.9 Securing your application

3.10 Building on your understanding

3.11 Summary

Part 2 Next steps

4 Creating your own widgets

4.1 What is a widget, again?

4.2 Creating a new widget from the DOM

4.3 Extending an existing widget

4.4 Extending a panel

4.5 Creating a composite

4.6 Using layout panels

4.7 Applying animation to widgets

4.8 Exploring the lifecycle of a widget

4.9 Getting Elemental, my dear Watson!

4.10 Summary

5 Using client bundles

5.1 Client bundle basics using DataResources

5.2 Text resource types

5.3 ImageResource

5.4 CssResource

5.5 Summary

6 Interface design with UiBinder

6.1 Binding the designer’s HTML to Java code

6.2 Handling events with UiBinder

6.3 Introducing the UiBinder expression language

6.4 Applying style with UiBinder

6.5 Using the Eclipse plug-in with UiBinder

6.6 Summary

7 Communicating with GWT-RPC

7.1 Surveying GWT-RPC

7.2 Learning GWT-RPC with Twitter

7.3 Fetching data from Twitter the non-GWT way

7.4 Defining a GWT-RPC-compatible model

7.5 Building and deploying the server side

7.6 Writing the client

7.7 Debugging GWT-RPC

7.8 Securing GWT-RPC against XSRF attacks

7.9 Summary

8 Using RequestFactory

8.1 Enabling annotation processing

8.2 Understanding RequestFactory architecture

8.3 Understanding the example project in this chapter

8.4 Making calls to the server

8.5 Using custom Locators and ServiceLocators (the “long way”)

8.6 Summary

9 The Editor framework

9.1 Framework and editor overview

9.2 Examining the chapter’s examples

9.3 Editor types

9.4 Constructing your first editor

9.5 Binding an editor with drivers

9.6 Editor subinterfaces

9.7 Accessing the RequestContext

9.8 Alternate way to construct an editor

9.9 Adapters

9.10 Summary

10 Data-presentation (cell) widgets

10.1 Understanding cells

10.2 Creating custom cells

10.3 Reviewing GWT’s cell widgets

10.4 Looking at a CellList

10.5 Walking through a CellTree

10.6 Browsing a CellBrowser

10.7 Constructing a CellTable

10.8 Building a DataGrid

10.9 Summary

11 Using JSNI—JavaScript Native Interface

11.1 What is JSNI?

11.2 Should you use JavaScript Native Interface?

11.3 Benefiting from the Google Plugin for Eclipse

11.4 Interacting with the browser

11.5 Handling objects from JavaScript

11.6 Wrapping a third-party library

11.7 Exposing an API to JavaScript

11.8 Summary

12 Classic Ajax and HTML forms

12.1 Understanding the underlying technology

12.2 Using RequestBuilder

12.3 Posting data with RequestBuilder

12.4 Using the JSON API and JsonpRequestBuilder

12.5 Using JSON with JS overlay

12.6 Using the XML API and RequestBuilder

12.7 Using FormPanel

12.8 Summary

13 Internationalization, localization, and accessibility

13.1 Making a user feel comfortable

13.2 Using static string internationalization

13.3 Using static-string i18n with UiBinder

13.4 Determining the locale for static-string internationalization

13.5 Internationalizing client bundles through static internationalization

13.6 Dynamic string internationalization

13.7 Localization of dates, times, and currencies

13.8 Displaying the right direction

13.9 Accessibility

13.10 Summary

Part 3 Advanced

14 Advanced event handling and event busses

14.1 Understanding events

14.2 How GWT manages events

14.3 Previewing and canceling events

14.4 Preventing default actions

14.5 Programmatically firing events

14.6 Creating your own events

14.7 Event busses

14.8 Summary

15 Building MVP-based applications

15.1 What is MVP?

15.2 Looking at the PhotoApp’s MVP foundations

15.3 Building MVP yourself

15.4 Altering an MVP application

15.5 Activity and Place (GWT’s reference MVP approach)

15.6 Fitting editors/data-presentation widgets into MVP

15.7 Summary

16 Dependency injection

16.1 Dependency injection—the fundamentals

16.2 Guice—a Java dependency injection framework

16.3 GIN—how DI differs in a GWT application

16.4 When to avoid DI

16.5 Summary

17 Deferred binding

17.1 What is deferred binding?

17.2 Pulling it all together

17.3 Using GWT properties to drive deferred binding

17.4 Managing explosive permutation numbers

17.5 Determining a property value

17.6 Coping when deferred binding isn’t enough

17.7 Summary

18 Generators

18.1 What does a generator do?

18.2 What can a generator do?

18.3 Indicating what generator to use and when

18.4 Configuration properties

18.5 Pulling it all together

18.6 Preparing to write a generator

18.7 Creating your own generator

18.8 Using your new generator

18.9 Summary

19 Metrics and code splitting

19.1 Using the lightweight metrics tool

19.2 Using the Compile Report

19.3 Making use of code splitting

19.4 Summary

index