Chapter 1. Welcome to the Griffon revolution
1.2. Building the GroovyEdit text editor in minutes
1.2.1. Giving GroovyEdit a view
1.2.2. Making the menu items behave: the controller
1.2.3. How about a tab per file?
1.3. Java desktop development: welcome to the jungle
1.3.1. Lots of boilerplate code (ceremony vs. essence)
1.3.2. UI definition complexity
1.4.1. At the core: the MVC pattern
Chapter 2. A closer look at Griffon
2.1. A tour of the common application structure
2.2. The ABCs of configuration
2.3. Using Griffon’s command line
2.4. Application life cycle overview
3.1. A quick look at models and bindings
3.2. Models as communication hubs
3.3.1. JavaBeans bound properties: the Java way
3.4. Have your people call my people: binding
3.5. The secret life of BindingUpdatable
3.5.1. Keeping track of bindings with the BindingUpdatable object
3.5.2. Managing the bindstorm: bind(), unbind(), and rebind()
3.5.3. Manually triggering a binding: update() and reverseUpdate()
4.1. Java Swing for the impatient
4.1.1. “Hello World” the Swing way
4.2. Groovy SwingBuilder: streamlined Swing
4.3. Anatomy of a Griffon view
4.5.1. Rounding up reusable code
4.6. Using screen designers and visual editors
4.6.1. Integrating with the NetBeans GUI builder (formerly Matisse)
Chapter 5. Understanding controllers and services
5.1.1. Quick tour of injected properties and methods
Chapter 6. Understanding MVC groups
6.2.2. Marshaling the MVC type instances
6.3. Using and managing MVC groups
6.4. Creating custom artifact templates
Chapter 7. Multithreaded applications
7.1. The bane of Swing development
7.2. SwingBuilder alternatives
7.2.1. Groovy Swing without threading
7.2.2. Groovy Swing with threading
7.2.3. Synchronous calls with edt
7.3. Multithreaded applications with Griffon
7.3.1. Threading and the application life cycle
7.3.2. Threading support the Griffon way
7.3.3. Controller actions and multithreading: a quick guide
7.4. SwingXBuilder and threading support
7.5.1. Defining the application’s outline
7.5.2. Setting up the UI elements
7.5.3. Defining a tab per loading technique
7.6. Additional threading options
7.6.1. Synchronous calls in the UI thread
7.6.2. Asynchronous calls in the UI thread
Chapter 8. Listening to notifications
8.1. Working with build events
8.1.1. Creating a simple script
8.2. Working with application events
8.3. Your class as an event publisher
Chapter 9. Testing your application
9.2. Not for the faint of heart: UI testing
9.3. Testing with Spock and easyb
9.3.1. Spock reaches a new level
9.4. Metrics and code inspection
9.4.1. Java-centric tools: JDepend and FindBugs
9.4.2. Reporting Groovy code violations with CodeNarc
10.1. Understanding the common packaging options
10.2. Using Griffon’s standard packaging targets
10.2.3. The applet and webstart targets
10.3. Using the Installer plugin
Chapter 11. Working with plugins
11.1.1. Getting a list of available plugins
11.2. Understanding plugin types
11.3. Creating the Tracer plugin and addon
11.3.1. Bootstrapping the plugin/addon
11.3.2. Intercepting property updates
12.1.1. Registering node factories
12.2. Builder delegates under the hood
12.2.1. Acting before the node is created
12.2.2. Tweaking the node before properties are set
12.3. Quick tour of builder extensions in Griffon
Chapter 13. Griffon in front, Grails in the back
13.1. Getting started with Grails
13.2. Building the Grails server application
13.2.1. Creating domain classes
13.4. Building the Griffon frontend
13.5. Querying the Grails backend
Chapter 14. Productivity tools
14.1. Getting set up in popular IDEs
Appendix Porting a legacy application