Eclipse: Building Commercial-Quality Plug-ins (2nd Edition) and over one million other books are available for Amazon Kindle. Learn more

Vous voulez voir cette page en français ? Cliquez ici.

Sign in to turn on 1-Click ordering.
More Buying Choices
Have one to sell? Sell yours here
Start reading Eclipse: Building Commercial-Quality Plug-ins (2nd Edition) on your Kindle in under a minute.

Don't have a Kindle? Get your Kindle here, or download a FREE Kindle Reading App.

Eclipse: Building Commercial-Quality Plug-ins (2nd Edition) [Paperback]

Eric Clayberg , Dan Rubel

List Price: CDN$ 62.99
Price: CDN$ 50.39 & FREE Shipping. Details
You Save: CDN$ 12.60 (20%)
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
Usually ships within 1 to 2 months.
Ships from and sold by Gift-wrap available.


Amazon Price New from Used from
Kindle Edition CDN $29.96  
Paperback CDN $50.39  
Save Up to 90% on Textbooks
Hit the books in's Textbook Store and save up to 90% on used textbooks and 35% on new textbooks. Learn more.
There is a newer edition of this item:
Eclipse Plug-ins (4th Edition) Eclipse Plug-ins (4th Edition)
Currently unavailable
Join Amazon Student in Canada

Book Description

March 22 2006 032142672X 978-0321426727 2

A new edition of this title is available, ISBN-10: 0321553462 ISBN-13: 9780321553461



"I'm often asked, 'What are the best books about Eclipse?' Number one on my list, every time, is Eclipse: Building Commercial-Quality Plug-ins. I find it to be the clearest and most relevant book about Eclipse for the real-world software developer. Other Eclipse books focus on the internal Eclipse architecture or on repeating the Eclipse documentation, whereas this book is laser focused on the issues and concepts that matter when you're trying to build a product."
-- Bjorn Freeman-Benson
Director, Open Source Process, Eclipse Foundation

"As the title suggests, this massive tome is intended as a guide to best practices for writing Eclipse plug-ins. I think in that respect it succeeds handily. Before you even think about distributing a plug-in you've written, read this book."
-- Ernest Friedman-Hill

"Eclipse: Building Commercial-Quality Plug-ins was an invaluable training aid for all of our team members. In fact, training our team without the use of this book as a base would have been virtually impossible. It is now required reading for all our developers and helped us deliver a brand-new, very complex product on time and on budget thanks to the great job this book does of explaining the process of building plug-ins for Eclipse."
-- Bruce Gruenbaum

"This is easily one of the most useful books I own. If you are new to developing Eclipse plug-ins, it is a 'must-have' that will save you lots of time and effort. You will find lots of good advice in here, especially things that will help add a whole layer of professionalism and completeness to any plug-in. The book is very focused, well-structured, thorough, clearly written, and doesn't contain a single page of 'waffly page filler.' The diagrams explaining the relationships between the different components and manifest sections are excellent and aid in understanding how everything fits together. This book goes well beyond Actions, Views, and Editors, and I think everyone will benefit from the authors' experience. I certainly have."
-- Tony Saveski

"The authors of this seminal book have decades of proven experience with the most productive and robust software engineering technologies ever developed. Their experiences have now been well applied to the use of Eclipse for more effective Java development. A must-have for any serious software engineering professional!"
-- Ed Klimas

"Just wanted to also let you know this is an excellent book! Thanks for putting forth the effort to create a book that is easy to read and technical at the same time!"
-- Brooke Hedrick

"The key to developing great plug-ins for Eclipse is understanding where and how to extend the IDE, and that's what this book gives you. It is a must for serious plug-in developers, especially those building commercial applications. I wouldn't be without it."
-- Brian Wilkerson

"If you're looking for just one Eclipse plug-in development book that will be your guide, this is the one. While there are other books available on Eclipse, few dive as deep as Eclipse: Building Commercial-Quality Plug-ins."
-- Simon Archer

Eclipse has established itself as a dominant force in the application-development space. Key to the success of Eclipse is the ability of developers to extend its functionality using plug-ins.

This new edition of Eclipse: Building Commercial-Quality Plug-ins is the definitive, start-to-finish guide to building commercial-quality Eclipse plug-ins, with an emphasis on adding the sophistication and polish that paying customers demand. The book provides both a quick introduction to using Eclipse for new users and a reference for experienced Eclipse users wishing to expand their knowledge and improve the quality of their Eclipse-based products.

Revised to take advantage of pure Eclipse 3.1 and 3.2 APIs, this widely praised bestseller presents detailed, practical coverage of every aspect of plug-in development and specific solutions for the challenges developers are most likely to encounter. All code examples, relevant API listings, diagrams, and screen captures have been updated.

Some Eclipse concepts--such as actions, views, and editors--have not changed radically, but now have additional functionality and capabilities. Other areas, such as the Eclipse plug-in infrastructure, have changed drastically due to the Eclipse shift towards an OSGi-based infrastructure. This edition is fully updated to address these new advances for Eclipse developers.

  • Includes a quick introduction to Eclipse for experienced Java programmers
  • Serves as a systematic reference for experienced Eclipse users
  • Introduces all the tools you need to build Eclipse and Rational plug-ins
  • Explains the Eclipse architecture and the structure of plug-ins and extension points
  • Offers practical guidance on building Eclipse user interfaces with SWT and JFace
  • Shows how to use change tracking, perspectives, builders, markers, natures, and more
  • Covers internationalization, help systems, features, and branding

This book is designed for anyone who wants a deep understanding of Eclipse, and every experienced developer interested in extending Eclipse or the Rational Software Development Platform.

Special Offers and Product Promotions

  • Join Amazon Student in Canada

Customers Who Bought This Item Also Bought

Product Details

Product Description

About the Author

Eric Clayberg is Senior Vice President for Product Development for Instantiations, Inc. Eric is a easoned software technologist, product developer, entrepreneur, and manager. He has a B.S. from MIT, an MBA from Harvard, and has cofounded two successful software companies, ObjectShare and Instantiations.

Dan Rubel is Chief Technology Officer for Instantiations, Inc. He is an entrepreneur and an expert in the design and application of OO technologies. Dan is the primary architect and product manager for several successful commercial products. He has a B.S. from Bucknell and is a cofounder of Instantiations.

Excerpt. © Reprinted by permission. All rights reserved.

When we were first exposed to Eclipse back in late 1999, we were struck by the magnitude of the problem IBM was trying to solve. IBM wanted to unify all its development environments on a single code base. At the time, the company was using a mix of technology composed of a hodgepodge of C/C++, Java, and Smalltalk.

Many of IBM's most important tools, including the award-winning Visual-Age for Java IDE, were actually written in Smalltalk--a wonderful language for building sophisticated tools, but one that was rapidly losing market share to languages like Java. While IBM had one of the world's largest collections of Smalltalk developers, there wasn't a great deal of industry support for it outside of IBM, and there were very few independent software vendors (ISVs) qualified to create Smalltalk-based add-ons.

Meanwhile, Java was winning the hearts and minds of developers world-wide with its promise of easy portability across a wide range of platforms, while providing the rich application programming interface (API) needed to build the latest generation of Web-based business applications. More important, Java was an object-oriented (OO) language, which meant that IBM could leverage the large body of highly skilled object-oriented developers it had built up over the years of creating Smalltalk-based tools. In fact, IBM took its premiere Object Technology International (OTI) group, which had been responsible for creating IBM's VisualAge Smalltalk and VisualAge Java environments (VisualAge Smalltalk was the first of the VisualAge brand family and VisualAge Java was built using it), and tasked the group with creating a highly extensible integrated development environment (IDE) construction set based in Java. Eclipse was the happy result.

OTI was able to apply its highly evolved OO skills to produce an IDE unmatched in power, flexibility, and extensibility. The group was able to replicate most of the features that had made Smalltalk-based IDEs so popular the decade before, while simultaneously pushing the state of the art in IDE development ahead by an order of magnitude.

The Java world had never seen anything as powerful or as compelling as Eclipse, and it now stands, with Microsoft's .NET, as one of the world's premier development environments. That alone makes Eclipse a perfect platform for developers wishing to get their tools out to as wide an audience as possible. The fact that Eclipse is completely free and open source is icing on the cake. An open, extensible IDE base that is available for free to anyone with a computer is a powerful motivator to the prospective tool developer.

It certainly was to us. At Instantiations and earlier at ObjectShare, we had spent the better part of a decade as entrepreneurs focused on building add-on tools for various IDEs. We had started with building add-ons for Digitalk's Smalltalk/V, migrated to developing tools for IBM's VisualAge Smalltalk, and eventually ended up creating tools for IBM's VisualAge Java (including our award-winning VA Assist product and our jFactor product, one of the world's first Java refactoring tools). Every one of these environments provided a means to extend the IDE, but they were generally not well-documented and certainly not standardized in any way. Small market shares (relative to tools such as VisualBasic) and an eclectic user base also afflicted these environments and, by extension, us.

As an Advanced IBM Business Partner, we were fortunate to have built a long and trusted relationship with the folks at IBM responsible for the creation of Eclipse. That relationship meant that we were in a unique position to be briefed on the technology and to start using it on a daily basis nearly a year and half before the rest of the world even heard about it. When IBM finally announced Eclipse to the world in mid-2001, our team at Instantiations had built some of the first demo applications IBM had to show. Later that year when IBM released its first Eclipse-based commercial tool, WebSphere Studio Application Developer v4.0 (v4.0 so that it synchronized with its then current VisualAge for Java v4.0), our CodePro product became the very first commercial add-on available for it (and for Eclipse in general) on the same day.

Currently, the CodePro product adds hundreds of enhancements to Eclipse and any Eclipse-based IDE. Developing CodePro over the last several years has provided us with an opportunity to learn the details of Eclipse development at a level matched by very few others (with the obvious exception of the IBM and OTI developers, who eat, sleep, and breathe this stuff on a daily basis). CodePro has also served as a testbed for many of the ideas and techniques presented in this book, providing us with a unique perspective from which to write.

Goals of the Book

This book provides an in-depth description of the process involved in building commercial-quality extensions for the Eclipse and the IBM Software Development Platform (SDP)--IBM's commercial version of Eclipse--development environments. To us, "commercial-quality" is synonymous with "commercial-grade" or "high-quality." Producing a commercial-quality plug-in means going above and beyond the minimal requirements needed to integrate with Eclipse. It means attending to all those details that contribute to the "fit and polish" of a commercial offering.

In the world of Eclipse plug-ins, very few people take the time to really go the extra mile, and most plug-ins fall into the open source, amateur category. For folks interested in producing high-quality plug-ins (which would certainly be the case for any software company wanting to develop Eclipse-based products), there are many details to consider. Our book is meant to encompass the entire process of plug-in development, including all the extra things that need to be done to achieve high-quality results. This book has several complementary goals:

  • Provide a quick introduction to using Eclipse for new users
  • Provide a reference for experienced Eclipse users wishing to expand their knowledge and improve the quality of their Eclipse-based products
  • Provide a detailed tutorial on creating sophisticated Eclipse plug-ins suitable for new and experienced users

The first three chapters introduce the Eclipse development environment and outline the process of building a simple plug-in. The intention of these chapters is to help developers new to Eclipse quickly pull together a plug-in they can use to experiment with.

The first chapter, in particular, introduces the reader to the minimum set of Eclipse tools that he or she will need to build plug-ins. It is a fairly quick overview of the Eclipse IDE and relevant tools (one could write an entire book on that topic alone), and we would expect expert Eclipse users to skip that chapter entirely.

The second chapter introduces the example that we will use throughout most of the book and provides a very quick introduction to building a working plug-in from start to finish. The third chapter presents a high-level overview of the Eclipse architecture and the structure of plug-ins and extension points.The fourth and fifth chapters cover the Standard Widget Toolkit (SWT) and JFace, which are the building blocks for all Eclipse user interfaces (UIs). These chapters can act as a stand-alone reference; they are intended to provide just enough detail to get you going. Both of these topics are rich enough to warrant entire books and several are currently available.

The subsequent chapters, comprising the bulk of this book, focus on describing each of the various aspects of plug-in development and providing the reader with in-depth knowledge of how to solve the various challenges involved. Each chapter focuses on a different aspect of the problem, and includes an overview, a detailed description, a discussion of challenges and solutions, diagrams, screenshots, cookbook-style code examples, relevant API listings, and a summary.

We have structured the book so that the most important material required for every plug-in project appears in the first half of it. Some of the packaging- and building-oriented material is placed at the end (for example, features and product builds). This organizational scheme left several topics that, while not critical to every plug-in, were important to the creation of commercial-quality plug-ins. These topics have been placed in the second half of the book in an order based on the importance of each and how it related to earlier material. Internationalization, for example, is one of those topics. It isn't critical, and it isn't even all that complicated when you get right down to it. It is, however, important to the book's premise, so we felt it was a topic we needed to include. Since we aren't assuming that the reader is an Eclipse expert (or even a plug-in developer), we have tried to take the reader through each of the important steps in as much detail as possible. While it is true that this is somewhat introductory, it is also an area that most plug-in developers totally ignore and have little or no experience with.

Sometimes a developer needs a quick solution, while at other times that same developer needs to gain in-depth knowledge about a particular aspect of development. The intent is to provide several different ways for the reader to absorb and use the information so that both needs can be addressed. Relevant APIs are included in several of the chapters so that the book can be used as a stand-alone reference during development without requiring the reader to look up those APIs in the IDE. Most API descriptions are copied or paraphrased from the Eclipse platform Javadoc.

As the originators of Eclipse and a major consumer of Eclipse-based technology, IBM is justifiably concerned that new plug-ins meet the same high-quality standards that IBM adheres to. To that end, IBM has established a rigorous Ready for Rational Software (RFRS) certification program meant to ensure the availability of high-quality add-ons to Eclipse and the IBM Software Development Platform. RFRS certification should be one of the ultimate goals for anyone wishing to build and market Eclipse plug-ins. Every chapter covers any relevant RFRS certification criteria and strategies.

The examples provided as part of the chapters describe building various aspects of a concrete Eclipse plug-in that you will see evolve over the course of the book. When used as a reference rather than read cover-to-cover, you will typically start to look in one chapter for issues that are covered in another. To facilitate this type of searching, every chapter contains numerous forward and backward references to related material that appears in other chapters.

Intended Audience

The audience for this book includes Java tool developers wishing to build products that integrate with Eclipse and other Eclipse-based products, relatively advanced Eclipse users wishing to customize their environments, or anyone who is curious about what makes Eclipse tick. You do not need to be an expert Eclipse user to make use of this book because we introduce most of what you need to know to use Eclipse in Chapter 1, Using Eclipse Tools. While we don't assume any preexisting Eclipse knowledge, we do anticipate that the reader is a fairly seasoned developer with a good grasp of Java and at least a cursory knowledge of extensible markup language (XML).

Conventions Used in This Book

The following formatting conventions are used throughout the book.

Bold -- the names of UI elements such as menus, buttons, field labels, tabs, and window titles
Italic -- emphasize new terms and Web site addresses
Courier -- code examples, references to class and method names, and filenames
Courier Bold -- emphasize code fragments
"Quoted text" -- quotation marks surrounding text indicates words to be entered by the user

What's New in the Second Edition

In this edition, we use the same Favorites view example as in the first edition, but have recreated the code from scratch to take advantage of pure Eclipse 3.1 and 3.2 APIs. All the screenshots are new and much of the text has been reworked. Some Eclipse concepts, such as actions, views, and editors are similar but with additional functionality and capabilities; other areas, such as the Eclipse plug-in infrastructure, have changed drastically due to the Eclipse shift toward an OSGi-based infrastructure. While all the chapters have been updated, the following is a sample of some of the sections that are new or have changed significantly in this second edition:

  • Section 2.3, Reviewing the Generated Code, on page 71
  • Section 2.4, Building a Product, on page 81
  • Section 3.1, Structural Overview, on page 101
  • Section 3.2, Plug-in Directory or JAR file, on page 104
  • Section 3.3, Plug-in Manifest, on page 107
  • Section 3.4, Plug-in Class, on page 114
  • Section 3.5, Plug-in Model, on page 119
  • Section 6.3, Object Actions, on page 224
  • Section 6.6, Key Bindings, on page 251
  • Section 7.3, View Actions, on page 283
  • Section 7.4, Linking the View, on page 305
  • Section 8.1, Editor Declaration, on page 326
  • Section 8.5, Editor Actions, on page 354
  • Section 9.4, Progress Monitor, on page 383
  • Section 11.1, Dialogs, on page 405
  • Section 11.2, Wizards, on page 430
  • Section 12.3, Preference APIs, on page 467
  • Section 13.3, Displaying Properties in the Properties View, on page 489
  • Section 14.1, Builders, on page 499
  • Section 15.5, Cheat Sheets, on page 563
  • Section 16.2, Externalizing Plug-in Strings, on page 578
  • Section 18.2, Branding, on page 631
  • Section 18.3, Update Sites, on page 637
  • Section 19.2, Building the Favorites Product, on page 671
  • Section 20.2, Accessing Internal Code, on page 711
  • Section 20.4, Opening a Browser or Creating an Email, on page 718
  • Section 20.7, Label Decorators, on page 732

Customer Reviews

There are no customer reviews yet on
5 star
4 star
3 star
2 star
1 star
Most Helpful Customer Reviews on (beta) 4.2 out of 5 stars  12 reviews
15 of 16 people found the following review helpful
3.0 out of 5 stars Too many trees, too little forest June 16 2008
By Thomas Maurer - Published on
I am writing Eclipse plug-ins for almost two years now and owned this book almost from the beginning. Looking back I must say that the book helped me get started and let me believe "it's possible". As probably many others I was a little intimidated at first by the vast possibilities of the framework.
Now that I am much more experienced I must say that whenever I look into the book it leaves me a little bit disappointed. It only adds little value to the "Platform Plug-in Developer Guide" which is part of the online documentation and already covers a lot.
The book goes into details and code very quickly without explaining the concepts very well. I still use the book every now and then for finding some nuggets not covered elsewhere and sometimes I get lucky but not too often.
Shall you buy this book? If you are a beginner and if you like to learn by programming a sample plug-in then yes. The more proficient you get the more the book will lose its value and you will use other sources of information.
5 of 5 people found the following review helpful
5.0 out of 5 stars Fantastic book(and a few suggestions) April 22 2008
By AA - Published on
If you're planning to write an eclipse plugin, this is THE book to read. The authors have done a fantastic job. Kudos.
Now a few suggestions.
The examples in the book can now be imported in the form of an eclipse plugin. This is great but the examples take a huge leap. For example, chapter 6 introduces you to the concept of views and shows you how to build a simple view with a table and a hard coded set of values. The example in chapter 7 is a huge leap in complexity. It would have been nice to have an example that shows you how to wire events to mouse clicks in the basic "One, Two, Three" view. Instead, the example in chapter 7 tries to do too much. As such, I can only give a limited time to reading the book and going through the examples. The jump in the complexity of the examples from chapter 6 to chapter 7 is like going from "hello world" to socket programming.

Again, my review is based on the perspective of someone who is writing eclipse plugins as productivity tools for my project, not as commercial products that I plan to sell. I may not be the right audience for your fantastic book but I suspect there are a lot of people like me who want to write plugins as productivity tools. Since your book is THE best book on eclipse plugins, I'm sure they'll be referring to it too.

Another thing: Part of the examples from chapter 7 don't seem to work. Specifically, the "add to favorites" button on the toolbar doesn't work because the selection object is of the type TextSelection and not IStructuredSelection. Maybe I'm doing something wrong.

Update: After having actually written a decent eclipse plugin, I have a list of suggestions for people who're just getting started.
1. Eclipse Corner is a very good resource for tips on writing eclipse plugins.
2. If you can't figure out how something is done, try looking for code on google codesearch. For example, lang:java eclipse ASTRewrite
3. If you're using Ganymede, you can see how things are done in the eclipse source code. For example, if you want to see the code that implements the outline view, select the outline view and hit Alt-Shift-F1. This will bring up the plugin spy. It will have a link to the source code that implements the outline view. Of course, the real code for the outline view is buried in a deep hierarchy but you get the general idea.
3 of 3 people found the following review helpful
4.0 out of 5 stars Some technical aspects are missing Oct. 15 2006
By Andrejus Chaliapinas - Published on
While whole book has enough details on plugins UI part, there is no information on third-party integration and plugin class loading issue is not covered enough (authors offer you to write your own jar class loader). Also missed a sample on PreferenceManager usage.
3 of 4 people found the following review helpful
5.0 out of 5 stars Highly Recommended April 10 2006
By Maupinman - Published on
This book covers most of what you would want to know about developing high quality Eclipse plug-ins. By working through this book as a tutorial I have learned more about Java and Eclipse than I ever imagined I would. This is easily one of the most useful books I own and I highly recommend it.
5.0 out of 5 stars Any programmer seeking an advanced Eclipse 'bible' of detail must have this Nov. 15 2008
By Midwest Book Review - Published on
Eclipse has become a dominant force in applications and its success rests largely on its generous plug-in applications which extend its abilities to developers. That's why the second updated edition Eclipse: Building Commercial-Quality Plug-Ins is key to any advanced programming collection specializing in Java or Eclipse: it's been revised to incorporate Eclipse 3.1 and 3.2 APIs, and offers both a quick introduction and a step-by-step reference for experienced Eclipse users to take the next advanced steps. Any programmer seeking an advanced Eclipse 'bible' of detail must have this.

Look for similar items by category