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.
A snapshot of all the source code developed throughout this book is available for download here.
Once you have downloaded and unpacked the zip file, please refer to the file cte-source/readme.txt for how to import the code into your Eclipse workspace for browsing.
Download the archive (ZIP, 170K)
Download the Sample Chapter related to this title.
1. The Big Picture.
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.
II. CIRCLE ONE: BASIC PLUG-IN.4. Der Plan.
JUnit by Example.
JUnit Integration.5. Contributing a Menu Item to Run Tests.
Package the Plug-In.
Bundling the Plug-In into a Feature.
Contributing.11. Closing Circle One.
Interlude.12. Test-Driven Plug-In Development.
A Test Project Fixture.
Testing the Contributed JUnit Plug-In.
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.
Test for a Marker.
Passing the Project.
Marker Resolution.17. Finding Tests.
Resource Listeners Versus Builders.
Using Natures to Configure Builders.19. Auto-Test Property.
Presenting Exceptions in an Error Dialog.
Logging Errors.21. Tracing—Instrumenting a Plug-In.
Testing Marker Resolution.
Build and Rerun.
Rerunning the Test.23. Test Report View—Using JFace.
Handling Events.24. A Simple Editor to Exclude Tests.
Contributing an Editor.
Contributing a Contributor.25. ResultView Revisited—Observing Changes.
Reacting to Changes.26. Perspectives.
Views in Perspective.
Show View Menu.27. 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.
Separating Published from Internal Packages.
Separating Core from UI.
Publishing an Extension Point—Extension Point Schemas.30. Closing Circle Two.
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.
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.
Abstract Syntax Tree Analysis—Visitor.34. Standard Widget Toolkit—SWT.
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.
SocketTestRunner.Appendix B. The TestProject Fixture.
Eclipse is a many-splendored thing. Eclipse is a technology, an extensible platform for tool integration, and a wide range of tools built on that platform. Eclipse is an open source project that delivers this technology. And Eclipse is a community that contributes to the open source project and also produces commercial Eclipse-based tools. The community itself is diverse, ranging from users of Eclipse-based products, to tool writers building extensions, to researchers exploring new ways of using Eclipse.
Eclipse is an ambitious undertaking. It provides a platform that allows diverse tools to interoperate, often in ways that the tool writers did not initially imagine. To make this aim a reality, we use an open, merit-based, collaborative development process--high-quality contributions are accepted from anyone. As the Contribution Rule reminds us, "Everything is a contribution." And with many contributions, the possibilities are endless.
The Eclipse Platform is composed of numerous plug-ins, and if you cast your net more widely, you will discover a plethora of additional plug-ins. Contributing to Eclipse enables you to jump into this expanding ecosystem and become a tool writer yourself. It is a guide through the initial barrier to entry, giving you the tools to explore the Eclipse landscape and venture out on your own. A fully worked example takes you step by step through the evolution of a plug-in--from initial implementation to product-ready software. In addition, this book defines Rules for extending Eclipse, so your plug-ins are "done right." Eclipse-literate readers will appreciate this book too: Its instruction confirms your accumulated understanding and it provides new insights into areas where you are less experienced. Chapters end with forwarding pointers to additional material so you can dive deeper.
These authors know what they are talking about. Erich is the authoritative source on the Java development tooling. In addition to leading this effort, he has been influential in the evolution and maturation of the Eclipse Platform. Kent has a deep understanding of software development processes and he is a master at providing clarity, simplicity, and understanding. Together, they share their experiences with Eclipse and teach us how our own experiences can be successful. I trust you will enjoy this refreshingly practical book while you absorb its instruction on how to immerse yourself into Eclipse.
On a personal note, Erich and I have been collaborating on IDE technology for several years. The previous efforts were educational stepping stones--sometimes not even completed before we moved on to the next iteration. But we kept learning. With Eclipse, we have a technology that will continue to grow and evolve. Eclipse is worth investing in. Put Eclipse to work for you. I have confidence you will find new ways to contribute to Eclipse!
Eclipse Platform Lead
Download the Index
file related to this title.