To create a Bikeshed project in Eclipse:

* Set your source code control system (e.g., svn or git) to ignore
the following files and directories. Eclipse needs to edit them,
but they should not be submitted.

*.jar
.settings
.classpath
.project
bin/
build/
classes/
# Matches gwtc output in the war directory, e.g. war/com.google.gwt.bikeshed.tree.Tree/
com.google.gwt.*
bikeshed/war/expenses/
bikeshed/war/expensesScaffold/
bikeshed/war/stocks/
bikeshed/war/tree/
bikeshed/war/validation/

* Install the Google Plugin for Eclipse
* Create a new Java project with trunk/bikeshed/ as its existing source
* Bring up the project properties
  * Google > Web Toolkit > Use Google Web Toolkit
  * Google > App Engine > Use Google App Engine
  * Google > App Engine > ORM
    * Remove src and test
    * Add server and shared from src/com/google/gwt/sample/bikeshed/stocks
  * Java Build Path > Libraries > Add Variable > GWT_TOOLS, Extend > redist/json/r2_20080312/json.jar
* Copy tools/redist/json/r2_20080312/json.jar to bikeshed/war/WEB_INF/lib
* Right click on the bikeshed project and choose Run as > Web Application. Choose from the various .html files
