Contributing to Eclipse - Principles, Patterns, and Plug-Ins

The comprehensive guide to builing Eclipse Plug-Ins that explains a highly effective software design philosophy.

Written by two worldclass programmers and software designers -- Kent Beck and Eric Gamma!
Explains how to extend Eclipse for software projects and how to use Eclipse to create software tools that improve development time
Shows how to create our software productivity Tools using insightful examples 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.

List 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. 0321205758T10202003

About the author

Kent Beck is the founder and director of Three Rivers Institute (TRI). He has pioneered patterns for software development, the XUnit family of test frameworks, the HotDraw drawing editor framework, CRC cards, refactoring, and most recently eXtreme Programming (XP). He lives on 20 acres in rural southern Oregon.

Dr. Erich Gamma ist der Leiter des IBM OTI Lab in Zürich. Er ist ein Eclipse Committer und verantwortlich für die Java-Entwicklungsumgebung Eclipse . Außerdem ist er Mitglied des Eclipse Project Management Committee (PMC). Neben seiner Tätigkeit im Eclipse-Projekt kennt man Erich Gamma als Entwickler von JUnit. Erich Gamma hat an der Universität Zürich promoviert. Zusammen mit Richard Helm, Ralph Johnnson und John Vlissides ist Erich Gamma weltweit als Gang of Four (GoF) bekannt.

Summary

The Eclipse Series.
Erich Gamma and Kent Beck introduce students quickly, yet thoroughly, to Eclipse, the emerging environment for software development. Contributing to Eclipse is a comprehensive, step-by-by tutorial guiding students with its many sidebars, essays, and forward pointers. The books also serves as an introduction to test-driven plug-in development giving students the confidence to create higher quality plug-ins.

Product details

• Authors: Kent Beck, Erich Gamma
• Publisher: Addison-Wesley Longman, Amsterdam
• Languages: English
• Product format: Paperback / Softback
• Released: 01.01.2003
• EAN: 9780321205759
• ISBN: 978-0-321-20575-9
• No. of pages: 416
• Dimensions: 234 mm x 181 mm x 26 mm
• Weight: 785 g
• Illustrations: w. figs.
• Series: the eclipse series; the eclipse series
• Subject: Natural sciences, medicine, IT, technology > IT, data processing > IT