technical
articles

technical information for developers

Eclipse Corner Articles

The following articles have been written by members of the development team and other members of the eclipse community. You too can contribute! Eclipse Corner depends on contributions from people like you.

(Besides these, a number of other web sites carry technical articles about Eclipse. You'll find pointers to these on the Eclipse Community page.)
Eclipse White Paper
Eclipse Platform Technical Overview July 2001 (updated for Eclipse 2.1 in Feb. 2003)
The Eclipse Platform is designed for building integrated development environments (IDEs) that can be used to create applications as diverse as web sites, embedded JavaTM programs, C++ programs, and Enterprise JavaBeansTM. This paper is a general technical introduction to the Eclipse Platform. Part I presents a technical overview of its architecture. Part II is a case study of how the Eclipse Platform was used to build a full-featured Java development environment.
New Articles
Rich Client Tutorial Part 2 Ed Burnette (SAS) August 9, 2004 (Updated November 21, 2005 for Eclipse 3.1)
The Rich Client Platform (RCP) allows you to build Java applications that can compete with native applications on any platform. Part 1 of the tutorial introduced you to the platform and the steps used to build the smallest possible RCP program. In part 2 we'll look at what we did in more detail and introduce some of the configuration classes that let you take control of much of the layout and functionality of an RCP application. This part has been updated for Eclipse 3.1.
Plugging into SourceForge.net David Biesack (SAS) October 15, 2005
Congratulations on taking the plunge and writing an open source plug-in for the Eclipse platform. SourceForge.net can provide a good home your plug-in, but information on how best to set up an Eclipse project there is sparse. This article is an introduction to SourceForge for the Eclipse developer. You will learn the features available to the SourceForge.net open source developer community and be guided through the process, from creating a SourceForge project to hosting your Eclipse Update site.
Persisting EMF models with WTP Daniel Rohe October 10, 2005
This article will guide you through an example where an EMF model is created without serialization and the serialization is done with the framework from the WTP plugin org.eclipse.wst.common.emf.
Rich Client Tutorial Part 1 Ed Burnette (SAS) July 28, 2004 (updated July 2005 for Eclipse 3.1)
The Rich Client Platform (RCP) is an exciting new way to build Java applications that can compete with native applications on any platform. This tutorial is designed to get you started building RCP applications quickly. It has been updated for Eclipse 3.1.
Extending The Visual Editor Dave Orme (db4objects), Gili Mendel (IBM), Joe Winchester (IBM) June 20, 2005
This tutorial shows how to extend the Visual Editor to support a custom widget. It covers topics such as adding to the Visual Editor's palette, building a BeanInfo class, and working with EMF .override files to introduce custom editor behavior.
Using GEF with EMF Chris Aniszczyk (IBM) June 8, 2005
The Graphical Editing Framework (GEF) provides a framework for creating visual editors while being model agnostic. In most cases, people bring their own model which tend to be based on Plain Old Java Objects (POJOs). An alternative using POJOs is the Eclipse Modeling Framework (EMF), which provides many features for manipulating models that aren't found in POJOs. The purpose of this article is to build upon the shapes example provided by GEF using the Eclipse Modeling Framework (EMF) and to provide an introduction using EMF based models in GEF based editors.
Build and Test Automation for Plug-ins and Features Markus Barchfeld (Zuehlke Engineering) May 29, 2005
Eclipse offers the possibility to build plug-ins automatically outside the Eclipse IDE, which is called "headless build". Eclipse itself is built headless and since Eclipse is an assembly of plug-ins, this feature is also available for any other plug-in. Although the set up of automatic building and testing requires only a couple of files, it can be tedious work to do nonetheless. This article shares the experiences and lessons learned while setting up automatic building and testing for an Open-Source Eclipse plug-in called RDT, Ruby Development Tools.
General
Plugging into SourceForge.net David Biesack (SAS) October 15, 2005
Congratulations on taking the plunge and writing an open source plug-in for the Eclipse platform. SourceForge.net can provide a good home your plug-in, but information on how best to set up an Eclipse project there is sparse. This article is an introduction to SourceForge for the Eclipse developer. You will learn the features available to the SourceForge.net open source developer community and be guided through the process, from creating a SourceForge project to hosting your Eclipse Update site.
Build and Test Automation for Plug-ins and Features Markus Barchfeld (Zuehlke Engineering) May 29, 2005
Eclipse offers the possibility to build plug-ins automatically outside the Eclipse IDE, which is called "headless build". Eclipse itself is built headless and since Eclipse is an assembly of plug-ins, this feature is also available for any other plug-in. Although the set up of automatic building and testing requires only a couple of files, it can be tedious work to do nonetheless. This article shares the experiences and lessons learned while setting up automatic building and testing for an Open-Source Eclipse plug-in called RDT, Ruby Development Tools.
Rich Client Tutorial Part 1 Ed Burnette (SAS) July 28, 2004 (updated July 2005 for Eclipse 3.1)
The Rich Client Platform (RCP) is an exciting new way to build Java applications that can compete with native applications on any platform. This tutorial is designed to get you started building RCP applications quickly. It has been updated for Eclipse 3.1.
Rich Client Tutorial Part 2 Ed Burnette (SAS) August 9, 2004 (Updated November 21, 2005 for Eclipse 3.1)
The Rich Client Platform (RCP) allows you to build Java applications that can compete with native applications on any platform. Part 1 of the tutorial introduced you to the platform and the steps used to build the smallest possible RCP program. In part 2 we'll look at what we did in more detail and introduce some of the configuration classes that let you take control of much of the layout and functionality of an RCP application. This part has been updated for Eclipse 3.1.
Rich Client Tutorial Part 3 Ed Burnette (SAS) July 28, 2004
The Rich Client Platform (RCP) lets you pick and choose functionality from Eclipse for use in your own applications. Parts 1 and 2 of this tutorial introduced you to the platform and some of the configuration classes it provides. Part 3 discusses how to add functionality such as menus, views, and help files.
PDE Does Plug-ins Wassim Melhem (IBM) and Dejan Glozic (IBM) September 8, 2003
The Plug-in Development Environment (PDE) provides a set of tools that assist the developer in every stage of plug-in development from genesis to deployment. This article chronicles the creation, development, testing, building, and deployment of a simple "Hello World" plug-in using a subset of these tools.
How to Internationalize your Eclipse Plug-In Dan Kehn (IBM), Scott Fairbrother (IBM), and Cam-Thu Le (IBM) August 23, 2002
This article is a roadmap for writing Eclipse plug-ins destined for the international market. We'll begin with a brief review of the motivations and technical challenges of internationalization, followed by step-by-step instructions of how to internationalize your Eclipse plug-in.
How to Test Your Internationalized Eclipse Plug-In Dan Kehn (IBM) August 23, 2002
This article shows you how to validate your internationalized product and prepares you for the types of common problems you can expect during translation testing. It includes an Eclipse plug-in that defines a Properties File Compare view that can help your translation testers find errors more quickly.
Branding Your Application Andrew Eidsness and Pascal Rapicault (IBM) September 16, 2004
In this article we look at how to create branding for your Eclipse-based application. Branding is how you change the high level visual elements of your product. This includes items such as the splash screen, the about dialog, and the program executable.
How to Use the Eclipse API Jim des Rivieres (OTI) April 24, 2001
The Eclipse Platform offers a comprehensive API (Application Programmer Interface) to developers writing plug-ins. This article discusses the general ground rules for using the Eclipse Platform API, including how to tell API from non-API, and how to stay in the API "sweet spot" to avoid the risk of being broken as the platform and its APIs evolve. These general ground rules are also recommended practice for plug-ins that must declare API elements of their own.
Levels of Integration Jim Amsden (OTI) March 25, 2001
The types of problems web application developers face today require the use of a diverse set of tools that operate in many domains. In order to provide flexible tool integration, a tool integration platform must allow tool developers to target different levels or integration based on the desired level of investment, time to market, and specific tool needs. Each integration level determines how a tool must behave, and what end users can expect as a result. This article defines the different levels of tool integration supported by Eclipse, and gives an overview of how they work.
Designing Accessible Plug-ins in Eclipse Tod Creasey (IBM) May 20, 2003
Accessibility for the disabled is now a priority in application development as advances in techniques and support within operating systems have now made this possible. This article covers the Eclipse accessibility support, general tips for creating accessible plug-ins, and the types of disabilities that the Eclipse accessibility support assists. This is all illustrated using an example of making a view accessible.
Building administrative applications in Eclipse Doina Klinger and Chris Markes (IBM) November 12, 2004
Eclipse is most commonly used as a platform for tools that allow the user to construct or assemble an end product out of development resources. It is less usual to use Eclipse as an administrative tool for monitoring existing runtime systems or applications. This article will describe some of the issues that arise in this case and illustrate possible solutions. It will show you can build an Eclipse perspective dedicated to the monitoring task. Running processes are shown in a dedicated view which always reflects their current state. You can start/stop the process, manage connections, invoke operations that the server exposes, examine server output and view events generated by the running applications.
Core
How You've Changed! Responding to resource changes in the Eclipse workspace (Revised for 3.0) John Arthorne (OTI) November 23, 2004
Many tools and user interface elements are interested in processing resource changes as they happen. For example, the task list wants to update new or changed markers, the navigator wants to reflect added and deleted resources, and the Java compiler wants to recompile modified Java files. Such notifications are potentially costly to compute, manage and broadcast. The Eclipse Platform resource model includes a series of mechanisms for efficiently notifying clients of resource changes. This article outlines these facilities and gives some examples of their use.
Project Natures and Builders (Revised for 3.0) John Arthorne (IBM) November 23, 2004
This article discusses two central mechanisms that are associated with projects in an Eclipse workspace. The first of these is incremental project builders, which create some built state based on the project contents, and then keep that built state synchronized as the project contents change. The second is project natures, which define and manage the association between a given project and a particular plug-in or feature. The purpose and uses of builders and natures will be described in detail, and working examples will be provided to highlight the finer details of implementing them for your own plug-in.
Notes on the Eclipse Plug-in Architecture Azad Bolour (Bolour Computing) July 3, 2003
Eclipse plug-ins embody an architectural pattern for building an application from constituent parts. This article presents an in-depth view of the participant roles and collaborations of this architectural pattern, as they exist in an instance of the Eclipse workbench. The goal is to provide an understanding of plug-ins, and of how plug-in extensions are defined and processed, independently of the mechanics of using the Eclipse workbench to produce plug-ins.
Debug
We Have Lift-off: The Launching Framework in Eclipse Joe Szurszewski (IBM) January 8, 2003
The ability to launch (run or debug) code under development is fundamental to an IDE. But because Eclipse is more of a tools platform than a tool itself, Eclipse's launching capabilities depend entirely on the current set of installed plug-ins. This article describes the API available to build launching plug-ins and works through developing an example launcher using this API.
Launching Java Applications Programmatically Darin Wright (IBM) August 26, 2003
Application developers require the ability to run and debug code in order to test it. Tool developers require the ability to launch Java applications that assist in application development - for example, starting and stopping a web server on which servlets, JSPs, and HTML pages can be tested; or launching a VM on which scrapbook evaluations can be performed. This article focuses on the high level API provided by the Java launching plug-in that tool developers can leverage for the programmatic launching of local Java applications.
How to write an Eclipse debugger Darin Wright (IBM) and Bjorn Freeman-Benson (Predictable Software) August 27, 2004
One of the major tasks of adding a new language to an Eclipse-based IDE is debugging support. A debugger needs to start and stop the program being debugged, suspend and resume, single-step, manage breakpoints and watch points, and so on. This article explains the Eclipse Platform debug framework and steps through a simple, yet illustrative, example of adding debug support for a new language.
Help
Help - Part 1: Contributing a Little Help (Revised for 2.0) Greg Adams (OTI) and Dorian Birsan (IBM) August 9, 2002
The Eclipse Platform’s help system defines two extension points ("toc" and "contexts") that allow individual plug-ins to contribute online help and context-sensitive help for their components. In this article we will investigate the "toc" extension point and how you can use it to contribute documentation for your plug-in.
SWT
Using OpenGL with SWT Bo Majewski (Cisco) April 15, 2005
OpenGL is a vendor-neutral, multi-platform standard for creating high-performance 2D and 3D graphics. Hardware and software implementations exist on various operating systems, including Windows, Linux and MacOS. OpenGL may be used to render simple 2D charts or complex 3D games. This article describes an experimental Eclipse plug-in that facilitates the use of OpenGL for drawing onto SWT widgets. A short history and overview of OpenGL is presented, followed by an example application.
Understanding Layouts in SWT (Revised for 2.0)  Carolyn MacLeod (OTI), Shantha Ramachandran (OTI) April 24, 2002
When writing applications in SWT, you may need to use layouts to give your windows a specific look. A layout controls the position and size of children in a Composite. Layout classes are subclasses of the abstract class Layout. This article shows you how to work with standard layouts, and write your own custom layout class.
SWT: The Standard Widget Toolkit - Part 2 Carolyn MacLeod (OTI) and Steve Northover (OTI) November 27, 2001
SWT uses operating system resources to deliver its native graphics and widget functionality. Allocating and freeing operating system resources is traditionally an area of programming that is error prone. Languages that include garbage collection, such as the Java™ language, relieve the programmer from the burden of managing memory, but not from the allocation and freeing of operating system resources. This article discusses the simple strategy used by SWT to help application designers manage operating system resources.
Getting Your Feet Wet with the SWT StyledText Widget (Revised for 3.0) Lynne Kues (OTI) and Knut Radloff (OTI) July 19, 2004
The StyledText widget is a customizable widget that can be used to display and edit text with different colors and font styles. This article presents an overview of the concepts, issues, and rules that you should be aware of when using the StyledText widget.

Into the Deep End of SWT StyledText Widget (Revised for 2.0) Lynne Kues (OTI) and Knut Radloff (OTI) September 18, 2002
This is the second of two articles on the SWT StyledText widget. This article dives into some of the more advanced concepts of StyledText and builds on the previous article "Getting Your Feet Wet With the SWT StyledText Widget".

SWT Color Model James Moody (OTI) and Carolyn MacLeod (OTI) April 24, 2001
The combination of platforms, display devices and color depth makes providing an easy to use yet powerful and portable color model an interesting challenge. In this article we will examine the color management models of Windows and X/Motif and then dig into the makings of the SWT color model and its implications for client code.
SWT: The Standard Widget Toolkit - Part 1 Steve Northover  (OTI) March 22, 2001
SWT is the software component that delivers native widget functionality for the Eclipse platform in an operating system independent manner. It is analogous to AWT/Swing in Java with a difference - SWT uses native widgets. This article is the first in series of articles that discuss the SWT widget toolkit. This article discusses the low level implementation techniques used to implement SWT on different platforms. Examples are drawn from the windows and Motif implementations.
ActiveX Support in SWT Veronika Irvine  (OTI) March 22, 2001
OLE Documents, such as Word, Excel or PowerPoint, and ActiveX Controls such as Internet Explorer are COM objects that can be embedded into other applications running on a Microsoft Windows platform. This article provides an overview of OLE and how to integrate OLE Documents and ActiveX Controls into an application using SWT.
Creating Your Own Widgets using SWT Steve Northover (OTI) & Carolyn MacLeod  (OTI) March 22, 2001
When writing applications, you typically use the standard widgets provided by SWT. On occasion, you will need to extend the set of base widgets by creating your own custom widgets. For example, you might want to add a new type of widget not provided by the standard widgets, or extend the functionality of an existing widget. This article explains the different SWT extension strategies and shows you how to use them.
Graphics Context - Quick on the draw Joe Winchester (IBM) July 3, 2003
The package org.eclipse.swt.graphics contains classes that allows management of graphics resources. Graphics can be drawn on anything that implements org.eclipse.swt.graphics.Drawable, which includes org.eclipse.swt.widgets.Control and org.eclipse.swt.graphics.Image. The class org.eclipse.swt.graphics.GC encapsulates all of the drawing API, including how to draw lines and shapes, draw text and images and fill shapes. This article shows how to use a GC to draw onto an Image, or onto a control through its paintEvent callback. The Canvas control, specifically designed for drawing operations, has a number of constructor style bits that allow you to determine when and how painting occurs, and the article shows how to use these.
Drag and Drop - Adding Drag and Drop to an SWT Application Veronika Irvine (IBM) August 25, 2003
Drag and drop provides a quick and easy mechanism for users to re-order and transfer data within an application and between applications. This article is an overview of how to implement Drag and Drop and Clipboard data transfers within an SWT application.
Taking a look at SWT Images Joe Winchester (IBM) September 10, 2003
SWT's Image class can be used to display images in a GUI. The most common source of images is to load from a standard file format such as GIF, JPEG, PNG, or BMP. Some controls, including Buttons and TreeItems, are able to display an Image directly through the setImage(Image) method, but any control's paint event allows images to be drawn through the callback's graphic context. SWT's ImageData class represents the raw data making up an SWT Image and determines the color for each pixel coordinate. This article shows the correct uses of ImageData and Image, shows how to load images from files, and how to achieve graphic effects such as transparency, alpha blending, animation, scaling, and custom cursors.
A small cup of SWT Christophe Cornu (IBM) September 19, 2003
Are you interested in developing applications for the Microsoft Pocket PC? Are you a desktop developer curious about embedded user interfaces? A well-built embedded application is both user and resource friendly. User expectations are high, but resources are very limited. This article contains a bag of hints, tricks, and recipes for developing SWT apps on the Pocket PC.
A Basic Image Viewer Chengdong Li (University of Kentucky) March 15, 2004
This article shows how to extend SWT Canvas to implement a mini image viewer plug-in using Java2D transforms. The extended image canvas can be used to scroll and zoom large images, and can also be extended to apply other transforms. The implementation is based on SWT and the non-UI portions of AWT. The plug-in has been tested on Windows, Linux GTK, and Mac OS X Carbon with Eclipse 2.1 or better.
Viewing HTML pages with SWT Browser widget Christophe Cornu (IBM) August 26, 2004
This article explains how to add HTML viewing capability to an SWT application. The Browser widget provides an easy way to integrate rich HTML content into your application.
Workbench & JFace
Folding in Eclipse Text Editors Prashant Deva March 11, 2005
Starting with release 3.0, Eclipse allows folding in its text editor. In this article, I explain the new projection infrastructure introduced in the JFace Text framework and show how to extend the XML Editor example provided with Eclipse to allow folding of text.
Eclipse User Interface Guidelines, Version 2.1 Nick Edgar, Kevin Haaland, Jin Li, and Kimberley Peter (IBM) February 2004
User Interface Guidelines "best practices" document intended for use by designers and implementors of an Eclipse user interface extension. (Earlier version of the guidelines.)
Simplifying Preference Pages with Field Editors Ryan Cooper (OTI) August 21, 2002
Even though preference pages can be simple to program, you can spend a lot of time getting them "just right." Field editors make this task faster and easier by providing the behavior for storing, loading, and validating preferences. Field editors also define some of the behavior for grouping and laying out widgets on a preference page.
How to use the JFace Tree Viewer  Chris Grindstaff (Applied Reasoning) May 2, 2002
The goal of this article is to teach you how to use TreeViewers in your Eclipse plug-ins or stand-alone JFace/SWT applications. We’ll start with a simple example and progressively add functionality.
Preferences in the Eclipse Workbench UI (Revised for 2.0) Tod Creasey (OTI) August 15, 2002
In the Eclipse Platform plug-in developers define preference pages for their plug-ins for use in the Workbench Preferences Dialog. This article explains when to use a preference and some of the features the Eclipse Platform provides to support preferences.
Creating an Eclipse View Dave Springgay (OTI) November 2, 2001
In the Eclipse Platform a view is typically used to navigate a hierarchy of information, open an editor, or display properties for the active editor.  In this article the design and implementation of a view will be examined in detail.  You'll learn how to create a simple view based on SWT, and a more advanced view using the JFace viewer hierarchy.  We'll also look at ways to achieve good integration with many of the existing features in the workbench, such as the window menu and toolbar, view linking, workbench persistence and action extension.
Creating JFace Wizards Doina Klinger (IBM) December 16, 2002
This article shows you how to implement a wizard using the JFace toolkit and how to contribute your wizard to the Eclipse workbench. A wizard whose page structure changes according to user input is implemented to demonstrate the flexibility of wizard support.
Contributing Actions to the Eclipse Workbench Simon Arsenault (OTI) October 18, 2001
The Eclipse Platform is an open and extensible platform. This article explains in detail how the Workbench can be extended to add new actions and provides guidance to the plug-in developers on how they can design for extensibility.
Using Perspectives in the Eclipse UI Dave Springgay (OTI)  August 27, 2001
In the Eclipse Platform a Perspective determines the visible actions and views within a window.  Perspectives also go well beyond this by providing mechanisms for task oriented interaction with resources in the Eclipse Platform, multi-tasking and information filtering.  In this article the concepts behind perspectives are examined.  The process for perspective definition, extension and instantiation will also be covered in detail with coding examples and sample scenarios.
Using Images in the Eclipse UI (Revised for 2.0) John Arthorne (OTI) September 12, 2002
Managing images in a large graphical application can be a daunting task. Since modern operating systems such as Windows only support a small number of images in memory at once, an application’s icons and background images must be carefully managed and sometimes shared between widgets. This article describes the image management facilities provided by the Eclipse Platform, along with some best practice guidelines to keep in mind when writing your own Eclipse UI plug-ins. We assume the reader already has a basic understanding of Eclipse, the UI extension points defined by the Eclipse Platform, and the Standard Widget Toolkit (SWT).
Mark My Words Dejan Glozic (IBM) and Jeff McAffer (OTI) April 1, 2001
Eclipse workbench has a central mechanism for managing resource annotations. They are called markers. In this article, you will learn how to use markers to mark-up resources as well as how to define your own marker types and enhance the Tasks view to handle them in a special way.
Understanding Decorators in Eclipse Balaji Krish-Sampath (IBM) January 16, 2003
Decorators, as the name suggests, are used for adorning/annotating resources with useful information. Decorators can be used by plug-ins to convey more information about a resource and other objects displayed in different workbench views.  This article, with the help of a simple plug-in example, will illustrate the steps involved in decorating resources, along with some best practice approaches for decorating resources. Finally, we will discuss performance issues that may arise when enabling decorators, and briefly go over the new Lightweight decorators found in Eclipse 2.1.
Take control of your properties Dicky Johan (Broadvision) May 20, 2003
The Eclipse workbench provides a properties view which is used to view (and/or edit) properties of a selected item. In this article, you will learn how to use the properties view to dynamically modify the properties of a GUI button.
Building and delivering a table editor with SWT/JFace Laurent Gauthier (Mirasol Op'nWorks) July 3, 2003
The JFace API provides several classes that can be used to build editable table views. In this article, we present a fairly extensive example that exercises the JFace and SWT classes needed to implement a table with cell editors for check-boxes, free text and combo-boxes. We also show how to package and deliver the classes into a stand-alone (non-Eclipse) Java application.
Drag and Drop in the Eclipse UI John Arthorne (IBM) August 25, 2003
In this article, we discuss the drag and drop facilities provided by JFace and the Eclipse platform UI. After reading this, you will know how to add drag and drop support to your own Eclipse views, and how that support will interact with the standard views in the Eclipse platform. Along the way, we'll also discuss that keyboard relative of drag and drop: cut and paste. You'll learn that putting your own custom objects on the clipboard is easy once you've figured out the basics of drag and drop. This article is intended to be read as a companion to the SWT drag and drop article.
Mutatis mutandis - Using Preference Pages as Property Pages Berthold Daum (bdaum industrial communications) October 24, 2003
A common problem in the implementation of applications is the implementation of project-specific properties that override workbench-wide preferences on project or file level. The naive approach is to implement these pages from scratch. However, writing the same code twice is a boring task and leads to increased maintenance efforts. In this article we show how existing preferences pages (with or without field editors) can be easily converted into pages that can act as both preference and property pages. We demonstrate this by implementing the abstract class FieldEditorOverlayPage providing the necessary functionality.
On the Job: The Eclipse Jobs API Michael Valenta (IBM) September 20, 2004
This article looks at the new Jobs API available as part of Eclipse 3.0. It describes the main portions of the Jobs API and the use of scheduling rules. It also describes some changes to Eclipse resource management including how the Resources plug-in integrates with the new API. Finally, it describes some new UI functionality that has been added to provide feedback to users about jobs that are run in the background.
Team
Branching with Eclipse and CVS Paul Glezen (IBM) July 3, 2003
This article presents a brief branch and merge scenario designed to quickly illustrate some branch and merge features of Eclipse's CVS integration. I assume the reader already appreciates the value of branching and merging in a source control environment. Little is said to justify it here. Rather, a step-by-step scenario illustrates the common branch and merge operations using Eclipse-based IDEs with CVS as the source control mechanism.
Update
How To Keep Up To Date Dejan Glozic (IBM) and Dorian Birsan (IBM) August 27, 2003
This article shows you how to create and publish bundles of plug-ins (called features) to an update site so that customers can download and install them directly into Eclipse using the Eclipse update manager. This has many advantages over the low tech way of delivering new or updated plug-ins in a zip file that someone manually unzips into the directory where Eclipse is installed.
Beyond the Eclipse Platform
Persisting EMF models with WTP Daniel Rohe October 10, 2005
This article will guide you through an example where an EMF model is created without serialization and the serialization is done with the framework from the WTP plugin org.eclipse.wst.common.emf.
Extending The Visual Editor Dave Orme (db4objects), Gili Mendel (IBM), Joe Winchester (IBM) June 20, 2005
This tutorial shows how to extend the Visual Editor to support a custom widget. It covers topics such as adding to the Visual Editor's palette, building a BeanInfo class, and working with EMF .override files to introduce custom editor behavior.
Using GEF with EMF Chris Aniszczyk (IBM) June 8, 2005
The Graphical Editing Framework (GEF) provides a framework for creating visual editors while being model agnostic. In most cases, people bring their own model which tend to be based on Plain Old Java Objects (POJOs). An alternative using POJOs is the Eclipse Modeling Framework (EMF), which provides many features for manipulating models that aren't found in POJOs. The purpose of this article is to build upon the shapes example provided by GEF using the Eclipse Modeling Framework (EMF) and to provide an introduction using EMF based models in GEF based editors.
Using EMF Catherine Griffin (IBM) December 9, 2002 (updated May 2003 for EMF 1.1)
This article introduces EMF, the Eclipse Modelling Framework, and will help you get started using EMF in your own Eclipse plug-ins.
JET Tutorial Part 1 (Introduction to JET) Remko Popma (Azzurri Ltd.) July 30, 2003 (updated May 2004 for EMF 2.0)
Generating source code can save you time in your projects and can reduce the amount of tedious redundant programming. Generating source code can be powerful, but the program that writes the code can quickly become very complex and hard to understand. One way to reduce complexity and increase readability is to use templates. The Eclipse Modeling Framework (EMF) project contains two very powerful tools for generating source code: JET (Java Emitter Templates) and JMerge (Java Merge). With JET you can use a JSP-like syntax (actually a subset of the JSP syntax) that makes it easy to write templates that express the code you want to generate. JET is a generic template engine that can be used to generate SQL, XML, Java source code and other output from templates.
In this article you will learn how to create JET templates, how to use the JET Nature and JET Builder to automatically translate templates into Java classes, and how to use these classes to generate source code. This article also provides a short reference to the JET syntax.
JET Tutorial Part 2 (Write Code that Writes Code) Remko Popma (Azzurri Ltd.) August 26, 2003 (updated May 2004 for EMF 2.0)
In Part 2 of this JET (Java Emitter Templates) tutorial, we will take a look at the JET engine API. You will learn how to write plug-ins that use the classes in the JET package to generate Java source code. As a real-world example, we will create a plug-in that takes user input and generates a Typesafe Enumeration class. The generated source code is based on a JET template that can be distributed with the plug-in, allowing users of the plug-in to customize the generated code by editing the template. This article also provides a short reference to the JET API.
Display a UML Diagram using Draw2D Daniel Lee (IBM) August 25, 2003
The Graphical Editing Framework (GEF) ships with a painting and layout plug-in called Draw2D. Draw2D provides figures and layout managers which form the graphical layer of a GEF application. This article focuses only on the use of Draw2D to render a simple UML class diagram. While Draw2D can be used for standalone purposes, it is not an editing framework. Most applications will use the GEF plug-in as the editing layer.
Using Native Drag and Drop with GEF Eric Bordeau (IBM) August 25, 2003
Native drag and drop provides the ability to drag data from one GUI object to another GUI object, which could potentially be in another application. GEF allows access to the operating system's underlying drag and drop infrastructure through SWT. This article will provide an in-depth look at GEF's drag and drop functionality and show some simple examples of how to take advantage of this API.
Building a Database Schema Diagram Editor with GEF Phil Zoio (Realsolve Solutions) September 27, 2004
GEF is a very powerful framework for visually creating and editing models. With a small initial investment, even the relative Eclipse novice can be quickly up and running, building applications with graphical editing capabilities. To illustrate, this article uses a relational database schema diagram editor with a deliberately simplified underlying model, but with enough bells and whistles to show some of the interesting features of GEF at work.
EMF goes RCP Marcelo Paternostro (IBM) October 12, 2004
This article explains how you can use EMF to generate RCP applications. It assumes that you have already used EMF, or have at least read the articles and references available on the documentation section of the EMF web site.
Modeling Rule-Based Systems with EMF Chaur G. Wu November 30, 2004
There are examples of meta-models defined in ECore for modeling objects and relational data. However, not much has been said about how to model rules. This article will define a meta-model in ECore for modeling rule-based systems. We will then use the meta-model to model the solution of a logical problem. Then we will compose some JET templates and generate code from the model, run the generated code through a rule engine and see that the logical problem is correctly solved.
A Shape Diagram Editor Bo Majewski (Cisco) December 8, 2004
Graphical Editing Framework (GEF) provides a powerful foundation for creating editors for visual editing of arbitrary models. Its effectiveness lies in a modular build, fitting use of design patterns, and decoupling of components that comprise a full, working editor. To a newcomer, the sheer number and variety of concepts and techniques present in GEF may feel intimidating. However, once learned and correctly used, they help to develop highly scalable and easy to maintain software. This article aims to provide a gentle yet comprehensive introduction to GEF. It describes a shape diagram editor - a small, fully functional test case of core concepts.