Table of Contents
Foreword.
Preface.
1. The Big Picture.
Book Goals.Plug-In.Eclipse in a Nutshell.
I. CIRCLE ZERO: HELLO WORLD.
2. Setting Up Eclipse for Plug-In Development.
Setting Up a Workspace.Browsing and Searching Source.
3. Hello
World.
Declaration/Implementation Split.Hello Button.Saying “Hello”.
II. CIRCLE ONE: BASIC PLUG-IN.
4. Der Plan.
JUnit by Example.JUnit Integration.
5. Contributing a Menu Item
to Run Tests.
6. Implementing the Menu Item Behavior.
7. Displaying the Results.
8. Defining an Extension Point.
9. Notifying Extensions.
10. Publishing.
Package the Plug-In.Bundling the Plug-In into a
Feature.Contributing.
11. Closing Circle One.
Interlude.
12. Test-Driven Plug-In Development.
PDE JUnit.A Test Project Fixture.Testing the Contributed JUnit
Plug-In.And Now….
III. CIRCLE TWO: THE REST OF THE PLUG-IN.
13. Viewing Results.
Contributing a View.Listening to Testing Progress.Changing
Colors.
14. Menu Contributions
Creating Context Menus.Contributing Menu Items.
15. Failed Tests
Are Compile Errors.
16. Test Failures as Markers.
Test for a Marker.Passing the Project.Creating Markers.Deleting
Markers.Marker Images.Marker Resolution.
17. Finding
Tests.
18. Builders and Natures.
Resource Listeners Versus Builders.Using Natures to Configure
Builders.
19. Auto-Test Property.
20. Exception Handling.
IStatus, CoreException.Presenting Exceptions in an Error
Dialog.Logging Errors.
21. Tracing—Instrumenting a
Plug-In.
22. Marker Resolution--Invoking a Long-Running
Operation.
Testing Marker Resolution.Build and Rerun.Showing
Progress.Rerunning the Test.
23. Test Report View—Using
JFace.
TestResult.The Test.The
View.TestReportLabelProvider.TestReportContentProvider.Handling
Events.
24. A Simple Editor to Exclude Tests.
Contributing an Editor.Contributing a Contributor.
25. ResultView
Revisited—Observing Changes.
Testing Color.Observing Changes.Reacting to Changes.
26.
Perspectives.
Views in Perspective.Show View Menu.
27. Help.
Top-Level Help.Integrated Help.Context-Sensitive Help.
28.
Internationalization and Accessibility.
Externalizing Strings from the Manifest Files.Externalizing Strings
from Code.Accessibility.
29. Publishing a Plug-In for Other
Programmers.
Defining the API.Exporting Classes.Separating Published from
Internal Packages.Separating Core from UI.Publishing an Extension
Point—Extension Point Schemas.
30. Closing Circle Two.
Contributing.Redeploying the Plug-In.Where to Go Next?
IV. CIRCLE THREE: PATTERN STORIES.
31. Core Runtime—IAdaptable.
Extension Object/Extension Interface.Surfacing Interfaces Using
IAdaptable.AdapterFactories—Adding Interfaces to Existing
Types.
32. Core Workspace—Resources.
Accessing File-System Resources—Proxy and Bridge.The
Workspace—Composite.Traversing the Resource Tree—Visitor.Tracking
Resource Changes—Observer.Batching Changes—Execute Around
Method.
33. Java Core.
From Resources to Java Elements—Adapter.Java Elements—(Virtual)
Proxy.The Java Element Tree--Composite.Type
Hierarchies—Objectifying an Association.Traversing the Java
Model.Tracking Java Element Changes—Observer.Collecting
Results—Builder.Abstract Syntax Tree Analysis—Visitor.
34.
Standard Widget Toolkit—SWT.
Composing Widgets—Composite.Defining the Layout—Strategy.Responding
to Events—Observer.
35. JFace--User Interface Frameworks.
Viewers: Connecting a Widget to a Model—Pluggable Adapter.Viewers:
Customizing a Viewer without
Subclassing—Strategy.Actions—Command.
36. UI Workbench.
Implementing the Lazy Loading Rule—Virtual Proxies.Persisting UI
State—Memento.Workbench Services—IAdaptable .
37. Closing Circle
Three.
Final Forward Pointers.An Invitation to Contribute.
V. APPENDICES.
Appendix A. TestRunner Details.
TestRunner.SocketTestRunner.
Appendix B. The TestProject
Fixture.
Appendix C. AutoTestBuilder with Exclusion Support.
References.
Index. 0321205758T10202003Promotional Information
This book encourages tool building by laying bare the design of
an excellent tool platform, Eclipse, and encourages design by
building a typical tool extending Eclipse. This tutorial on
creating custom tools also provides an explanation of a highly
effective software design philosophy. The authors revive the lost
art of supporting existing work by building tools. This book
improves the software developers skill set by building little
tools, and gradually growing those tools into
better-than-professional quality products to help a whole community
of developers. This book revives that highly-effective practice of
tool writing and provides lessons along the way that tool building
and design are two of the most leveraged skills for software
developers.
About the Author
Kent Beck consistently challenges software engineering
dogma, promoting ideas like patterns, test-driven development, and
Extreme Programming. Currently affiliated with Three Rivers
Institute and Agitar Software, he is the author of many
Addison-Wesley titles.
Dr. Erich Gamma is technical director at the Software
Technology Center of Object Technology International in Zurich,
Switzerland.