| <?xml version="1.0" encoding="UTF-8"?><!--This document is automatically generated. Do not manually edit.--> |
| <articles> |
| <article link="index.html"> |
| <title>Abstract Syntax Tree</title> |
| <date>November 20, 2006</date> |
| <category>AST</category> |
| <category>Java</category> |
| <category>Plug-ins</category> |
| <author> |
| <name>Thomas Kuhn</name> |
| <company>Eye Media GmbH</company> |
| </author> |
| <author> |
| <name>Olivier Thomann</name> |
| <company>IBM Ottawa Lab</company> |
| </author> |
| <description> |
| The Abstract Syntax Tree is the base framework for many powerful |
| tools of the Eclipse IDE, including refactoring, Quick Fix and |
| Quick Assist. The Abstract Syntax Tree maps plain Java source |
| code in a tree form. This tree is more convenient and reliable |
| to analyse and modify programmatically than text-based source. |
| This article shows how you can use the Abstract Syntax Tree for |
| your own applications. |
| </description> |
| <base>/articles/Article-JavaCodeManipulation_AST</base> |
| </article> |
| |
| <article link="ViewArticle2.html"> |
| <title>Creating an Eclipse View</title> |
| <date>November 2, 2001</date> |
| <category>Platform</category> |
| <category>JFace</category> |
| <category>RCP</category> |
| <category>User interface</category> |
| <author> |
| <name>Dave Springgay</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/viewArticle</base></article><article link="PerspectiveArticle.html"> |
| <title>Using Perspectives in the Eclipse UI</title> |
| <date>August 27, 2001</date> |
| <category>Platform</category> |
| <category>RCP</category> |
| |
| <author> |
| <name>Dave Springgay</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/using-perspectives</base></article><article link="swt-design-2.html"> |
| <title> |
| SWT: The Standard Widget Toolkit PART 2: Managing Operating |
| System Resources |
| </title> |
| <date>November 27, 2001</date> |
| <category>User interface</category> |
| <category>SWT</category> |
| <author> |
| <name>Carolyn MacLeod</name> |
| <company>IBM</company> |
| </author> |
| <author> |
| <name>Steve Northover</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| <![CDATA[ |
| This is the second in a series of articles about the design ideas behind |
| SWT. 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. |
| ]]> |
| </description> |
| <base>/articles/swt-design-2</base></article><article link="eclipse-platform-whitepaper.html"> |
| <title>Eclipse Platform Technical Overview</title> |
| <date>July 1, 2001</date> |
| <update> |
| <date>February 1, 2003</date> |
| </update> |
| <update> |
| <date>April 19, 2006</date> |
| <reason>for Eclipse 3.1</reason> |
| </update> |
| <category>Whitepaper</category> |
| <category>Platform</category> |
| <description> |
| The Eclipse Platform is designed for building applications, |
| integrated development environments (IDEs)and arbitrary tools. |
| 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. |
| </description> |
| <translation language="pdf"> |
| <link>eclipse-platform-whitepaper.pdf</link> |
| <date>April 19, 2006</date> |
| </translation> |
| <base>/articles/Whitepaper-Platform-3.1</base></article><article link="../../whitepapers/eclipse-overview.pdf" show="false"> |
| <title>Eclipse Platform Technical Overview</title> |
| <date>July 1, 2001</date> |
| <update> |
| <date>February 1, 2003</date> |
| </update> |
| <category>Whitepaper</category> |
| <description> |
| The Eclipse Platform is designed for building integrated |
| development environments (IDEs) that can be used to create |
| applications as diverse as web sites, embedded Java<sup>TM</sup> |
| programs, C++ programs, and Enterprise JavaBeans |
| <sup>TM</sup>. 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. |
| </description> |
| <base>/articles/Whitepaper</base></article><article link="article2.html"> |
| <title>Into the Deep End of the SWT StyledText Widget</title> |
| <date>October 17, 2001</date> |
| <category>SWT</category> |
| <category>User interface</category> |
| <author> |
| <name>Lynne Kues</name> |
| <company>IBM</company> |
| </author> |
| <author> |
| <name>Knut Radloff</name> |
| <company>IBM</company> |
| </author> |
| <update> |
| <date>September 18, 2002</date> |
| <reason>for Eclipse 2.0</reason> |
| </update> |
| <description> |
| The StyledText widget is a customizable widget that can be used |
| to display and edit text with different colors and font styles. |
| In this article we discuss why you might want to customize the |
| StyledText widget and how you would do that. |
| </description> |
| <base>/articles/StyledText 2</base></article><article link="article1.html"> |
| <title>Getting Your Feet Wet with the SWT StyledText Widget</title> |
| <date>May 7, 2001</date> |
| <category>SWT</category> |
| <category>User interface</category> |
| <author> |
| <name>Lynne Kues</name> |
| <company>IBM</company> |
| </author> |
| <author> |
| <name>Knut Radloff</name> |
| <company>IBM</company> |
| </author> |
| <update> |
| <date>July 19, 2004</date> |
| <reason>for Eclipse 3.0</reason> |
| </update> |
| <description> |
| 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. |
| </description> |
| <base>/articles/StyledText 1</base></article><article link="pocket-PC.html"> |
| <title> |
| A small cup of SWT: A bag of hints, tricks and recipes for |
| developing SWT apps on the Pocket PC |
| </title> |
| <date>September 19, 2003</date> |
| <category>Embedded</category> |
| <category>eRCP</category> |
| <category>RCP</category> |
| <category>eSWT</category> |
| <category>SWT</category> |
| <category>User interface</category> |
| <author> |
| <name>Christophe Cornu</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| <![CDATA[ |
| 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. Resources are |
| very limited... |
| ]]> |
| </description> |
| <base>/articles/Article-small-cup-of-swt</base></article><article link="index.html"> |
| <title>Contributing Actions to the Eclipse Workbench</title> |
| <date>October 18, 2001</date> |
| |
| <category>Plug-ins</category> |
| <category>Actions</category> |
| <category>Workbench</category> |
| |
| <author> |
| <name>Simon Arsenault</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-action-contribution</base></article><article link="YourFirstPlugin.html" show="false"> |
| <title> |
| Your First Plug-in: Developing the Eclipse "Hello |
| World" plug-in |
| </title> |
| |
| <category>Plug-ins</category> |
| <category>Platform</category> |
| <category>Debugging</category> |
| <category>Java</category> |
| |
| <date>March 22, 2001</date> |
| |
| <category>Platform</category> |
| <author> |
| <name>Jim Amsden</name> |
| <company>IBM</company> |
| </author> |
| <update> |
| <date>September 6, 2002</date> |
| <reason>for Eclipse release 2.0</reason> |
| <author> |
| <name>Andrew Irvine</name> |
| <company>IBM</company> |
| </author> |
| </update> |
| <update> |
| <date>January 28, 2003</date> |
| </update> |
| <description> |
| The traditional Hello World program doesn't do that much, but it |
| can be invaluable when exploring a new development environment. |
| In this article we'll develop the Eclipse Hello World plug-in |
| and show you how to integrate it with the Eclipse Workbench. |
| After you read this article you should know how to use the |
| Eclipse Java Development Tooling to create, run, and debug a |
| simple plug-in that extends the Eclipse Platform. You'll see how |
| to setup a project for your plug-in, edit the Java code, |
| compile, and run or debug your plug-in in another launched copy |
| of Eclipse. We'll be looking at plug-in manifest files, |
| extensions, and extension points to see how plug-ins are |
| described to Eclipse and how they are integrated with the |
| Platform. |
| </description> |
| <base>/articles/Article-Your First Plug-in</base></article><article link="Writing%20Your%20Own%20Widget.htm"> |
| <title>Creating Your Own Widgets using SWT</title> |
| <date>March 22, 2001</date> |
| <category>SWT</category> |
| <category>User interface</category> |
| <author> |
| <name>Steve Northover</name> |
| <company>IBM</company> |
| </author> |
| <author> |
| <name>Carolyn MacLeod</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| When writing applications, you typically use the standard |
| widgets provided by SWT. On occasion, you will need to create |
| 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. |
| </description> |
| <base>/articles/Article-Writing Your Own Widget</base></article><article link="article.html"> |
| <title>Eclipse Workbench: Using the Selection Service</title> |
| <date>April 14, 2006</date> |
| |
| <category>JFace</category> |
| <category>RCP</category> |
| <category>Workbench</category> |
| <category>User interface</category> |
| <category>Selections</category> |
| <category>Plug-ins</category> |
| |
| <author> |
| <name>Marc R. Hoffmann</name> |
| <company>Mountainminds GmbH & Co. KG</company> |
| <email>hoffmann@mountainminds.com</email> |
| </author> |
| <description> |
| The selection service provided by the Eclipse workbench allows |
| efficient linking of different parts within the workbench |
| window. Knowing and using the existing selection mechanisms |
| gives your plug-ins a clean design, smoothly integrates them |
| into the workbench and opens them for future extensions. |
| </description> |
| <base>/articles/Article-WorkbenchSelections</base></article><article link="drag_drop.html"> |
| <title>Drag and Drop in the Eclipse UI</title> |
| <date>August 25, 2003</date> |
| <category>JFace</category> |
| <category>RCP</category> |
| <category>Drag and drop</category> |
| <category>User interface</category> |
| <author> |
| <name>John Arthorne</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-Workbench-DND</base></article><article link="persisting.html"> |
| <title>Persisting EMF models with WTP</title> |
| <date>October 10, 2005</date> |
| |
| <category>Modeling</category> |
| <category>Web tools</category> |
| <category>EMF</category> |
| <category>Plug-ins</category> |
| |
| <author> |
| <name>Daniel Rohe</name> |
| </author> |
| <description> |
| This article guides you through an example where an EMF |
| model is created without serialization and the serialization is |
| done with the framework from the web tools plug-in |
| org.eclipse.wst.common.emf. |
| </description> |
| <base>/articles/Article-WTP-Persisting-EMF</base></article><article link="customwidget.html"> |
| <title> |
| Extending The Visual Editor: Enabling support for a custom |
| widget |
| </title> |
| <date>June 20, 2005</date> |
| <category>User interface</category> |
| <category>Visual editor</category> |
| <category>EMF</category> |
| <author> |
| <name>Dave Orme</name> |
| <company>db4objects</company> |
| </author> |
| <author> |
| <name>Gili Mendel</name> |
| <company>IBM</company> |
| </author> |
| <author> |
| <name>Joe Winchester</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-VE-Custom-Widget</base></article><article link="Using Images In Eclipse.html"> |
| <title>Using Images in the Eclipse UI</title> |
| <date>April 20, 2001</date> |
| <update> |
| <date>September 12, 2002</date> |
| <reason>for Eclipse 2.0</reason> |
| </update> |
| |
| <category>SWT</category> |
| <category>RCP</category> |
| <category>User interface</category> |
| <category>Plug-ins</category> |
| |
| <author> |
| <name>John Arthorne</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| Managing images in a large graphical application can be a |
| daunting task. Since modern operating systems such as Windows&reg; |
| 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). |
| |
| </description> |
| <base>/articles/Article-Using Images In Eclipse</base></article><article link="using-emf.html"> |
| <title>Using EMF</title> |
| <date>December 9, 2002</date> |
| <update> |
| <date>May 1, 2003</date> |
| <reason>for EMF 1.1.0</reason> |
| </update> |
| |
| <category>Modeling</category> |
| <category>EMF</category> |
| <category>Plug-ins</category> |
| |
| <author> |
| <name>Catherine Griffin</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| This article introduces EMF, the Eclipse Modeling Framework, |
| and will help you get started using EMF in your own Eclipse |
| plug-ins. |
| </description> |
| <base>/articles/Article-Using EMF</base></article><article link="keeping-up-to-date.html"> |
| <title>How To Keep Up To Date</title> |
| <date>August 27, 2003</date> |
| <update> |
| <date>January 13, 2004</date> |
| <reason>to add appendix</reason> |
| </update> |
| <category>Platform</category> |
| |
| <category>Update</category> |
| <category>RCP</category> |
| <category>Plug-ins</category> |
| <category>Features</category> |
| |
| <author> |
| <name>Dejan Glozic</name> |
| <company>IBM</company> |
| </author> |
| <author> |
| <name>Dorian Birsan</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-Update</base></article><article link="Understanding-Layouts.htm"> |
| <title>Understanding Layouts in SWT</title> |
| <date>March 22, 2001</date> |
| <category>Platform</category> |
| <category>SWT</category> |
| <category>RCP</category> |
| <category>User interface</category> |
| <author> |
| <name>Carolyn MacLeod</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-Understanding-Layouts</base></article><article link="workbench.html"> |
| <title> |
| Inside the Workbench: A guide to the workbench internals |
| </title> |
| <date>October 20, 2005</date> |
| <category>Workbench</category> |
| <category>Platform</category> |
| |
| <author> |
| <name>Stefan Xenos</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| This article describes how the Eclipse 3.1 workbench works, in |
| particular the infrastructure for views and editors. The goal is |
| to teach you about important classes in the workbench, and how |
| they interact. A familiarity with the basic workbench APIs for |
| views, editors, action sets, and so forth is assumed. |
| </description> |
| <base>/articles/Article-UI-Workbench</base></article><article link="Index.html"> |
| <title>Eclipse User Interface Guidelines: Version 2.1</title> |
| <translation language="cn"> |
| <link>index_cn.html</link> |
| <date>January 18, 2005</date> |
| <author> |
| <name>Bobbie Wang</name> |
| <company>IBM</company> |
| </author> |
| <author> |
| <name>Cliff Liang</name> |
| <company>IBM</company> |
| </author> |
| </translation> |
| <update> |
| <date>February 1, 2004</date> |
| </update> |
| <category>Workbench</category> |
| <category>Platform</category> |
| |
| <author> |
| <name>Nick Edgar</name> |
| <company>IBM</company> |
| </author> |
| <author> |
| <name>Kevin Haaland</name> |
| <company>IBM</company> |
| </author> |
| <author> |
| <name>Jin Li</name> |
| <company>IBM</company> |
| </author> |
| <author> |
| <name>Kimberley Peter</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| The Eclipse platform is very flexible and extensible, but this |
| flexibility has a serious drawback. In particular, there is no |
| way within the program to ensure user interface consistency |
| between the registered components within the platform. |
| </description> |
| <base>/articles/Article-UI-Guidelines</base></article><article link="TreeViewerArticle.htm"> |
| <title>How to use the JFace Tree Viewer</title> |
| <date>May 5, 2002</date> |
| |
| <category>JFace</category> |
| <category>User interface</category> |
| <category>Plug-ins</category> |
| |
| <author> |
| <name>Chris Grindstaff</name> |
| <email>chrisg@appliedReasoning.com</email> |
| <company>Applied Reasoning</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-TreeViewer</base></article><article link="table_viewer.html"> |
| <title>Building and delivering a table editor with SWT/JFace</title> |
| <date>July 3, 2003</date> |
| <category>RCP</category> |
| <category>JFace</category> |
| <category>User interface</category> |
| <author> |
| <name>Laurent Gauthier</name> |
| <email>lgauthier@opnworks.com</email> |
| <company>Mirasol Op'nWorks</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-Table-viewer</base></article><article link="tabbed_properties_view.html"> |
| <title>The Eclipse Tabbed Properties View</title> |
| <date>February 19, 2006</date> |
| <category>Workbench</category> |
| |
| <author> |
| <name>Anthony Hunter</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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 tabbed properties view to |
| create an enhanced user interface for the properties view. |
| </description> |
| <base>/articles/Article-Tabbed-Properties</base></article><article link="how2TestI18n.html"> |
| <title>How to Test Your Internationalized Eclipse Plug-In</title> |
| <date>August 23, 2002</date> |
| |
| <category>RCP</category> |
| <category>Platform</category> |
| <category>Plug-ins</category> |
| <category>Internationalization</category> |
| |
| <author> |
| <name>Dan Kehn</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-TVT</base></article><article link="tptpProfilingArticle.html"> |
| <title>Java Application Profiling using TPTP</title> |
| <date>February 21, 2006</date> |
| <category>Test and performance</category> |
| <category>Profiling</category> |
| |
| <author> |
| <name>Valentina Popescu</name> |
| <company>IBM</company> |
| </author> |
| <update> |
| <date>July 11, 2006</date> |
| </update> |
| <description> |
| This article demonstrates how to use the TPTP Profiling tool to |
| profile a Java application for identifying execution related hot |
| spots. It shows how to start the profiling session, use the |
| various TPTP views to analyze the data, identify methods with |
| high execution time then jump to the source code to fix the |
| performance problem. |
| </description> |
| <base>/articles/Article-TPTP-Profiling-Tool</base></article><article link="article.html"> |
| <title>Teach Your Eclipse to Speak the Local Lingo</title> |
| <date>March 9, 2006</date> |
| <category>Platform</category> |
| |
| <category>User interface</category> |
| <author> |
| <name>Kit Lo</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| Translations for the Eclipse Project and several top-level |
| projects are contributed to the Eclipse Foundation in every |
| major release of Eclipse. This article provides step-by-step |
| instructions describing what is available, where to download |
| them, how to install them, and how to launch Eclipse in |
| different languages. |
| </description> |
| <base>/articles/Article-Speak-The-Local-Language</base></article><article link="graphics-resources.html"> |
| <title>Taking a look at SWT Images</title> |
| <date>September 10th, 2003</date> |
| <category>RCP</category> |
| <category>SWT</category> |
| <category>User interface</category> |
| <author> |
| <name>Joe Winchester</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-SWT-images</base></article><article link="SWT_graphics.html"> |
| <title>Graphics Context - Quick on the draw</title> |
| <date>July 3, 2003</date> |
| <category>RCP</category> |
| <category>SWT</category> |
| <category>User interface</category> |
| <author> |
| <name>Joe Winchester</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| <![CDATA[ |
| The package <code>org.eclipse.swt.graphics</code> contains |
| classes that allow management of graphics resources. Graphics |
| can be drawn on anything that implements |
| <code>org.eclipse.swt.graphics.Drawable</code>, which includes |
| <code>org.eclipse.swt.widgets.Control</code> and |
| <code>org.eclipse.swt.graphics.Image</code>. The class |
| <code>org.eclipse.swt.graphics.GC</code> 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. |
| ]]> |
| </description> |
| <base>/articles/Article-SWT-graphics</base></article><article link="browser.html"> |
| <title>Viewing HTML pages with SWT Browser widget</title> |
| <date>August 26, 2004</date> |
| <category>RCP</category> |
| <category>SWT</category> |
| <category>User interface</category> |
| <author> |
| <name>Christophe Cornu</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-SWT-browser-widget</base></article><article link="Virtual-in-SWT.html"> |
| <title>Virtual Tables and Trees</title> |
| <date>June 5, 2006</date> |
| <category>SWT</category> |
| <category>User interface</category> |
| <author> |
| <name>Beatriz Iaderoza</name> |
| <company>IBM Ottawa Lab</company> |
| </author> |
| <author> |
| <name>Grant Gayed</name> |
| <company>IBM Ottawa Lab</company> |
| </author> |
| <description> |
| Virtual Tables and Trees allow developers to quickly create Tables and Trees with large |
| amounts of data and populate them efficiently. This article is an overview of how to use |
| virtual Tables and Trees within SWT applications. |
| </description> |
| <base>/articles/Article-SWT-Virtual</base></article><article link="opengl.html"> |
| <title>Using OpenGL with SWT</title> |
| <date>April 15, 2005</date> |
| <category>SWT</category> |
| <category>User interface</category> |
| <author> |
| <name>Bo Majewski</name> |
| <company>Cisco Systems, Inc.</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-SWT-OpenGL</base></article><article link="SWT-Design-1.html"> |
| <title> |
| <![CDATA[ |
| SWT: The Standard Widget Toolkit PART 1: Implementation Strategy |
| for Java™ Natives |
| ]]> |
| </title> |
| <date>March 22, 2001</date> |
| <category>SWT</category> |
| <category>User interface</category> |
| <author> |
| <name>Steve Northover</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| <![CDATA[ |
| The first in a series of articles about the design ideas behind |
| SWT. 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 a rich set of native widgets. Even in an |
| ideal situation, industrial strength cross platform widget |
| libraries are very difficult to write and maintain. This is due |
| to the inherent complexity of widget systems and the many subtle |
| differences between platforms. There are several basic |
| approaches that have helped significantly to reduce the |
| complexity of the problem and deliver high quality libraries. |
| This article discusses one of them, the low level implementation |
| techniques used to implement SWT on different platforms. |
| Examples are drawn from the Windows® and Motif implementations. |
| ]]> |
| </description> |
| <base>/articles/Article-SWT-Design-1</base></article><article link="DND-in-SWT.html"> |
| <title>Adding Drag and Drop to an SWT Application</title> |
| <date>August 25, 2003</date> |
| <update> |
| <date>November 2, 2005</date> |
| </update> |
| <category>RCP</category> |
| <category>SWT</category> |
| <category>User interface</category> |
| <category>Drag and drop</category> |
| <author> |
| <name>Veronika Irvine</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-SWT-DND</base></article><article link="swt-color-model.htm"> |
| <title>SWT Color Model</title> |
| <date>April 24, 2001</date> |
| <category>SWT</category> |
| <category>User interface</category> |
| <author> |
| <name>James Moody</name> |
| <company>IBM</company> |
| </author> |
| <author> |
| <name>Carolyn MacLeod</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| <![CDATA[ |
| 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. |
| ]]> |
| </description> |
| <base>/articles/Article-SWT-Color-Model</base></article><article link="article.html"> |
| <title>Modeling Rule-Based Systems with EMF</title> |
| <date>November 30, 2004</date> |
| <category>Modeling</category> |
| <category>EMF</category> |
| <category>JET</category> |
| <author> |
| <name>Chaur G. Wu</name> |
| <email>cha_urwu@hotmail.com</email> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-Rule Modeling With EMF</base></article><article link="resource-deltas.html"> |
| <title> |
| How You've Changed!: Responding to resource changes in the |
| Eclipse workspace |
| </title> |
| <date>August 23, 2002</date> |
| <update> |
| <date>November 23, 2004</date> |
| <reason>for Eclipse 3.0</reason> |
| </update> |
| |
| <category>Platform</category> |
| <category>Resources</category> |
| <category>Jobs</category> |
| <category>Plug-ins</category> |
| |
| <author> |
| <name>John Arthorne</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-Resource-deltas</base></article><article link="tutorial3.html"> |
| <title>Rich Client Tutorial Part 3</title> |
| <date>July 28, 2004</date> |
| <update> |
| <date>February 6, 2006</date> |
| <reason>for Eclipse 3.1.2</reason> |
| </update> |
| <category>RCP</category> |
| <category>Tutorial</category> |
| <author> |
| <name>Ed Burnette</name> |
| <company>SAS</company> |
| </author> |
| <description> |
| The Rich Client Platform (RCP) lets you reuse common |
| functionality from the Eclipse IDE for use in your own |
| applications. Parts 1 and 2 of this tutorial introduced you to |
| the platform with a very simple example that did nothing but |
| open a blank window. Part 3 discusses a more complicated example |
| with menus, views, and other features. This part has been |
| updated for Eclipse 3.1.2. |
| </description> |
| <base>/articles/Article-RCP-3</base></article><article link="tutorial2.html"> |
| <title>Rich Client Tutorial Part 2</title> |
| <date>August 9, 2004</date> |
| <update> |
| <date>February 6, 2006</date> |
| <reason>for Eclipse 3.1.2</reason> |
| </update> |
| <category>RCP</category> |
| <category>Tutorial</category> |
| <category>Jobs</category> |
| |
| <author> |
| <name>Ed Burnette</name> |
| <company>SAS</company> |
| </author> |
| <description> |
| 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.2. |
| </description> |
| <base>/articles/Article-RCP-2</base></article><article link="tutorial1.html"> |
| <title>Rich Client Tutorial Part 1</title> |
| <date>July 28, 2004</date> |
| <update> |
| <date>February 6, 2006</date> |
| <reason>for Eclipse 3.1.2</reason> |
| </update> |
| <category>RCP</category> |
| <category>Tutorial</category> |
| <author> |
| <name>Ed Burnette</name> |
| <company>SAS</company> |
| </author> |
| <description> |
| 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.2. |
| </description> |
| <base>/articles/Article-RCP-1</base></article><article link="properties-view.html"> |
| <title>Take control of your properties</title> |
| <date>May 20, 2003</date> |
| <category>Platform</category> |
| <author> |
| <name>Dicky Johan</name> |
| <email>dicky.johan@broadvision.com</email> |
| <company>Broadvision</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-Properties-View</base></article><article link="article.html"> |
| <title>How to Correctly and Uniformly Use Progress Monitors</title> |
| <date>January 18, 2006</date> |
| <category>Platform</category> |
| |
| <author> |
| <name> |
| <![CDATA[Kenneth Ölwing]]> |
| </name> |
| <company>BEA JRPG</company> |
| </author> |
| <description> |
| Handling a progress monitor instance is deceptively simple. It |
| seems to be straightforward but it is easy to make a mistake |
| when using them. And, depending on numerous factors such as the |
| underlying implementation, how it is displayed, the result can |
| range from completely ok, mildly confusing or outright |
| silliness. In this article we lay down a few ground rules that |
| will help anyone use progress monitors in a way that will work |
| with the explicit and implicit contract of IProgressMonitor. |
| Also, understanding the usage side makes it easier to understand |
| how to implement a monitor. |
| </description> |
| <base>/articles/Article-Progress-Monitors</base></article><article link="preferences.htm"> |
| <title>Preferences in the Eclipse Workbench UI</title> |
| <date>August 15, 2002</date> |
| <category>Platform</category> |
| <category>Plug-ins</category> |
| <category>Preferences</category> |
| |
| <author> |
| <name>Tod Creasey</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-Preferences</base></article><article link="sourceforge.html"> |
| <title>Plugging into SourceForge.net</title> |
| <date>October 15, 2005</date> |
| |
| <category>Plug-ins</category> |
| <author> |
| <name>David Biesack</name> |
| <company>SAS</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-Plugging-into-SourceForge</base></article><article link="plugin_architecture.html"> |
| <title>Notes on the Eclipse Plug-in Architecture</title> |
| <date>July 3, 2003</date> |
| |
| <category>Platform</category> |
| <category>Plug-ins</category> |
| |
| <author> |
| <name>Azad Bolour</name> |
| <company>Bolour Computing</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-Plug-in-architecture</base></article><article link="PDE-intro.html"> |
| <title>PDE Does Plug-ins</title> |
| <date>September 8, 2003</date> |
| |
| <category>PDE</category> |
| <category>Plug-ins</category> |
| |
| <author> |
| <name>Wassim Melhem</name> |
| <company>IBM</company> |
| </author> |
| <author> |
| <name>Dejan Glozic</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-PDE-does-plugins</base></article><article link="automation.html"> |
| <title>Build and Test Automation for plug-ins and features</title> |
| <date>May 29, 2005</date> |
| |
| <category>Build</category> |
| <category>PDE</category> |
| <category>Plug-ins</category> |
| <category>Building</category> |
| <category>Test and performance</category> |
| |
| <author> |
| <name>Markus Barchfeld</name> |
| <company>Zuehlke Engineering</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-PDE-Automation</base></article><article link="help1.htm"> |
| <title>Help Part 1: Contributing a Little Help</title> |
| <date>August 9, 2002</date> |
| |
| <category>Platform</category> |
| <category>Help</category> |
| <category>Plug-ins</category> |
| |
| <author> |
| <name>Greg Adams</name> |
| <company>IBM</company> |
| </author> |
| <author> |
| <name>Dorian Birsan</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-Online Help for 2_0</base></article><article link="help1.htm" show="false"> |
| <!-- This article is for Eclipse version 1.0 and |
| has been replaced with a new version for Eclipse 2.1 --> |
| <title>Help Part 1: Contributing a Little Help</title> |
| <date>May 28, 2001</date> |
| |
| <category>Platform</category> |
| <category>Help</category> |
| <category>Plug-ins</category> |
| |
| <author> |
| <name>Greg Adams</name> |
| <company>IBM</company> |
| </author> |
| <author> |
| <name>Dorian Birsan</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-Online Help for 1_0</base></article><article link="overlay-pages.html"> |
| <title> |
| Mutatis mutandis - Using Preference Pages as Property Pages |
| </title> |
| <date>October 24, 2003</date> |
| |
| <category>Platform</category> |
| <author> |
| <name>Berthold Daum</name> |
| <company>bdaum industrial communications</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-Mutatis-mutandis</base></article><article link="monitorArticle.html"> |
| <title>Building Administrative Applications in Eclipse</title> |
| <date>November 12, 2004</date> |
| |
| <category>Platform</category> |
| <author> |
| <name>Doina Klinger</name> |
| <email>dklinger@uk.ibm.com</email> |
| <company>IBM</company> |
| </author> |
| <author> |
| <name>Chris Markes</name> |
| <email>cmarkes@uk.ibm.com</email> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-Monitor</base></article><article link="mark-my-words.html"> |
| <title> |
| Mark My Words: Using markers to tell users about problems and |
| tasks |
| </title> |
| <date>April 1, 2001</date> |
| |
| <category>Platform</category> |
| <author> |
| <name>Dejan Glozic</name> |
| <company>IBM</company> |
| </author> |
| <author> |
| <name>Jeff McAffer</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-Mark My Words</base></article><article link="levels-of-integration.html"> |
| <title> |
| Levels Of Integration: Five ways you can integrate with the |
| Eclipse Platform |
| </title> |
| <date>March 25, 2001</date> |
| |
| <category>Platform</category> |
| <author> |
| <name>Jim Amsden</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-Levels-Of-Integration</base></article><article link="launch.html"> |
| <title>We Have Lift-off: The Launching Framework in Eclipse</title> |
| <date>January 8, 2003</date> |
| |
| <category>Platform</category> |
| <category>Debugging</category> |
| <category>Plug-ins</category> |
| |
| <author> |
| <name>Joe Szurszewski</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-Launch-Framework</base></article><article link="ltk.html"> |
| <title> |
| The Language Toolkit: An API for Automated Refactorings in |
| Eclipse-based IDEs |
| </title> |
| <date>April 12, 2006</date> |
| <category>ltk</category> |
| |
| <category>Platform</category> |
| <author> |
| <name>Leif Frenzel</name> |
| <company>Innoopract</company> |
| </author> |
| <description> |
| Anyone who supports a programming language in an Eclipse-based |
| IDE will be asked sooner or later to offer automated |
| refactorings - similar to what is provided by the Java |
| Development Tools (JDT). Since the release of Eclipse 3.1, at |
| least part of this task--which is by no means simple--is supported |
| by a language neutral API: the Language Toolkit (LTK). But how |
| is this API used? |
| </description> |
| <base>/articles/Article-LTK</base></article><article link="launching-java.html"> |
| <title>Launching Java Applications Programmatically</title> |
| <date>August 26, 2003</date> |
| |
| <category>Java</category> |
| <category>Plug-ins</category> |
| |
| <author> |
| <name>Darin Wright</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-Java-launch</base></article><article link="wizardArticle.html"> |
| <title>Creating JFace Wizards</title> |
| <date>December 16, 2002</date> |
| <update> |
| <date>January 18, 2006</date> |
| </update> |
| <category>User interface</category> |
| <category>JFace</category> |
| <category>Platform</category> |
| <author> |
| <name>Doina Klinger</name> |
| <email>dklinger@uk.ibm.com</email> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-JFace Wizards</base></article><article link="jet_tutorial2.html"> |
| <title>JET Tutorial Part 2 (Write Code that Writes Code)</title> |
| <date>August 26, 2003</date> |
| <update> |
| <date>May 31, 2004</date> |
| <reason>for EMF 2.0 (Eclipse 3.0)</reason> |
| </update> |
| <category>Modeling</category> |
| <category>Tutorial</category> |
| <category>JET</category> |
| <category>EMF</category> |
| <category>Plug-ins</category> |
| <author> |
| <name>Remko Popma</name> |
| <email>remko.popma@azzurri.jp</email> |
| <company>Azzurri Ltd.</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-JET2</base></article><article link="jet_tutorial1.html"> |
| <title>JET Tutorial Part 1 (Introduction to JET)</title> |
| <date>July 30, 2003</date> |
| <update> |
| <date>May 31, 2004</date> |
| <reason>for EMF 2.0 (Eclipse 3.0)</reason> |
| </update> |
| <category>Modeling</category> |
| <category>Tutorial</category> |
| <category>JET</category> |
| <category>EMF</category> |
| <author> |
| <name>Remko Popma</name> |
| <email>remko.popma@azzurri.jp</email> |
| <company>Azzurri Ltd.</company> |
| </author> |
| <description> |
| 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. 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. |
| </description> |
| <base>/articles/Article-JET</base></article><article link="article.html"> |
| <title>Introducing the GMF Runtime</title> |
| <date>January 16, 2006</date> |
| <category>GMF</category> |
| <category>Modeling</category> |
| <category>Plug-ins</category> |
| <author> |
| <name>Frederic Plante</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| Graphical Modeling Framework (GMF) is a new Eclipse project with |
| the potential to become a keystone framework for the rapid |
| development of standardized Eclipse graphical modeling editors. |
| GMF is divided in two main components: the runtime, and the |
| tooling used to generate editors capable of leveraging the |
| runtime. Architects and developers involved in the development |
| of graphical editors or of plug-ins integrating both EMF and GEF |
| technologies should consider building their editors against the |
| GMF Runtime component. This article is designed to help |
| understand the benefits of the GMF Runtime by presenting its |
| various value-added features. |
| </description> |
| <base>/articles/Article-Introducing-GMF</base></article><article link="article.html"> |
| <title>Introducing AJDT: The AspectJ Development Tools</title> |
| <date>October 16, 2006</date> |
| <category>AspectJ</category> |
| <category>AJDT</category> |
| <author> |
| <name>Matt Chapman</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| The AspectJ Development Tools (AJDT) project is an Eclipse Tools |
| project which enables the development of AspectJ applications in |
| Eclipse. This article gives an overview of the capabilities of |
| AJDT 1.4 for Eclipse 3.2 by describing several scenarios, |
| including adding aspects to existing Java&trade; projects, |
| working with aspects across multiple projects, and using the |
| load-time weaving capabilities of AspectJ 5. |
| </description> |
| <base>/articles/Article-Introducing-AJDT</base></article><article link="how2I18n.html"> |
| <title>How to Internationalize your Eclipse Plug-In</title> |
| <date>August 23, 2002</date> |
| <category>Platform</category> |
| <category>RCP</category> |
| <category>Plug-ins</category> |
| <category>Internationalization</category> |
| |
| <author> |
| <name>Dan Kehn</name> |
| <company>IBM</company> |
| </author> |
| <author> |
| <name>Scott Fairbrother</name> |
| <company>IBM</company> |
| </author> |
| <author> |
| <name>Cam-Thu Le</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-Internationalization</base></article><article link="Image_viewer.html"> |
| <title>A Basic Image Viewer</title> |
| <date>March 15, 2004</date> |
| <category>SWT</category> |
| <category>User interface</category> |
| <category>Plug-ins</category> |
| |
| <author> |
| <name>Chengdong Li</name> |
| <email>cdli@ccs.uky.edu</email> |
| <company> |
| Research in Computing for Humanities, University of Kentucky |
| </company> |
| </author> |
| <description> |
| This article shows how to extend the 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. |
| </description> |
| <base>/articles/Article-Image-Viewer</base></article><article link="gef-schema-editor.html"> |
| <title> |
| Building a Database Schema Diagram Editor with GEF |
| </title> |
| <date>September 27, 2004</date> |
| <category>Modeling</category> |
| <category>GEF</category> |
| <author> |
| <name>Phil Zoio</name> |
| <company>Realsolve Solutions Ltd.</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-GEF-editor</base></article><article link="GEF-dnd.html"> |
| <title>Using Native Drag and Drop with GEF</title> |
| <date>August 25, 2003</date> |
| <category>Modeling</category> |
| <category>User interface</category> |
| <category>GEF</category> |
| <author> |
| <name>Eric Bordeau</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-GEF-dnd</base></article><article link="shape.html"> |
| <title>A Shape Diagram Editor</title> |
| <translation language="cn"> |
| <link>shape_cn.html</link> |
| <date>May 31, 2006</date> |
| <author> |
| <name>Cliff Liang</name> |
| <company>BeniSoft</company> |
| <link>http://benisoft.com/</link> |
| <email>cliff.liang@benisoft.com</email> |
| </author> |
| </translation> |
| <date>December 8, 2004</date> |
| <category>Modeling</category> |
| <category>GEF</category> |
| <author> |
| <name>Bo Majewski</name> |
| <company>Cisco Systems, Inc.</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-GEF-diagram-editor</base></article><article link="gef-emf.html"> |
| <title>Using GEF with EMF</title> |
| <date>June 8, 2005</date> |
| <category>Modeling</category> |
| <category>GEF</category> |
| <category>EMF</category> |
| <author> |
| <name>Chris Aniszczyk</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-GEF-EMF</base></article><article link="GEF-Draw2d.html"> |
| <title>Display a UML Diagram using Draw2D</title> |
| <date>August 25, 2003</date> |
| |
| <category>Modeling</category> |
| <category>GEF</category> |
| <category>Draw 2D</category> |
| <category>Plug-ins</category> |
| |
| <author> |
| <name>Daniel Lee</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-GEF-Draw2d</base></article><article link="article.html"> |
| <title>From Front End To Code - MDSD in Practice</title> |
| <date>June 15, 2006</date> |
| <category>Modeling</category> |
| <category>MDD</category> |
| <category>EMF</category> |
| <category>GMF</category> |
| <author> |
| <name>Markus Voelter</name> |
| </author> |
| <author> |
| <name>Bernd Kolb</name> |
| </author> |
| <author> |
| <name>Sven Efftinge</name> |
| </author> |
| <author> |
| <name>Arno Haase</name> |
| </author> |
| <description> |
| Model-driven software development (MDSD) is not just about generating code. Several |
| additional challenges have to be mastered. These include: how to get usable graphical and |
| textual editors for your domain specific language (DSL), how to validate your models against |
| your metamodels, how to define model modifications and transformations and finally, how to |
| write scalable, maintainable and extensible code generators. In this article we show how to |
| tackle all these challenges, based on a collection of open source tools: Eclipse, Eclipse |
| Modeling Framework (EMF), Graphical Modeling Framework (GMF) as well as |
| openArchitectureWare. We believe that this tool chain provides a proven and stable stack for |
| making MDSD a practical reality. |
| </description> |
| <base>/articles/Article-FromFrontendToCode-MDSDInPractice</base></article><article link="article.html"> |
| <title>Eclipse Forms: Rich UI for the Rich Client</title> |
| <date>January 16, 2006</date> |
| |
| <category>User interface</category> |
| <category>RCP</category> |
| <author> |
| <name>Dejan Glozic</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| Spice up your rich client with rich user experience using |
| Eclipse Forms. Written as a thin layer on top of SWT, Eclipse |
| Forms allow you to achieve the Web look in your desktop |
| applications without using the embedded browser. This allows you |
| to retain full control of the widgets in the UI and to maintain |
| portability across all operating systems Eclipse already runs |
| on. This article will take you from baby steps to advanced |
| topics of the rich user interface experience of Eclipse Forms. |
| </description> |
| <base>/articles/Article-Forms</base></article><article link="folding.html"> |
| <title>Folding in Eclipse Text Editors</title> |
| <date>March 11, 2005</date> |
| <category>Platform</category> |
| <category>User interface</category> |
| <author> |
| <name>Prashant Deva</name> |
| <email>prashant.deva@gmail.com</email> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-Folding-in-Eclipse-Text-Editors</base></article><article link="field_editors.html"> |
| <title>Simplifying Preference Pages with Field Editors</title> |
| <date>August 21, 2002</date> |
| |
| <category>Platform</category> |
| <author> |
| <name>Ryan Coopero</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-Field-Editors</base></article><article link="EditorContributor.html" show="false"> |
| <title>Editor Contributors - A Distinct Species</title> |
| <date>January 16, 2003</date> |
| |
| <category>Platform</category> |
| <category>Plug-ins</category> |
| <category>Editors</category> |
| |
| <author> |
| <name>Dejan Glozic</name> |
| <email>dejan@ca.ibm.com</email> |
| <company>IBM</company> |
| </author> |
| <description> |
| Why are Eclipse desktop editors using a distinct contribution |
| mechanism instead of simply doing it directly from editors? |
| Eclipse platform desktop offers various ways a plug-in can |
| contribute to menus and tool bars. The most natural way for |
| views is to contribute directly (if you own the view, that is). |
| However, editors are somewhat special - their contributors are |
| registered alongside editors and contribution from editor |
| instances is not allowed. This article explains why the |
| difference and how editor contributors prevent renegade runtime |
| footprint and improve user experience. We will also take a look |
| at handling editor contributors in multi-page editors. |
| </description> |
| <base>/articles/Article-EditorContributor</base></article><article link="article.html"> |
| <title>Creating Database Web Applications with Eclipse</title> |
| <date>April 10, 2006</date> |
| <category>Web tools</category> |
| <category>Derby</category> |
| <category>Tutorial</category> |
| <author> |
| <name>Stephen Schaub</name> |
| <company> |
| Department of Computer Science, Bob Jones University |
| </company> |
| </author> |
| <description> |
| The Eclipse Web Tools Project delivers a feature-rich |
| environment for developing J2EE database-driven web |
| applications. This tutorial walks you through the process of |
| creating a simple database web application using Eclipse WTP, |
| Tomcat, and the Derby database engine. |
| </description> |
| <base>/articles/Article-EclipseDbWebapps</base></article><article link="rcp.html"> |
| <title>EMF goes RCP</title> |
| <date>October 12, 2004</date> |
| <category>Modeling</category> |
| <category>RCP</category> |
| <category>EMF</category> |
| <author> |
| <name>Marcelo Paternostro</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-EMF-goes-RCP</base></article><article link="article.html" show="true"> |
| <title>Implementing Model Integrity in EMF with EMFT OCL</title> |
| <date>August 1, 2006</date> |
| |
| <category>MDD</category> |
| <category>EMF</category> |
| <category>Modeling</category> |
| <category>JET</category> |
| |
| <author> |
| <name>Christian W. Damus</name> |
| <company>IBM Rational (Canada)</company> |
| </author> |
| <description> |
| This article illustrates how the EMFT OCL parser/interpreter |
| technology adds to the value of EMF/JET code generation as a |
| foundation for model-driven development (MDD). We will see, with |
| fully functional examples, how a metamodel can be generated from |
| an Ecore model without requiring any post-generation custom |
| code, including complete implementations of invariant |
| constraints, derived attributes and references, and operations |
| </description> |
| <base>/articles/Article-EMF-Codegen-with-OCL</base></article><article link="decorators.html"> |
| <title>Understanding Decorators in Eclipse</title> |
| <date>January 16, 2003</date> |
| |
| <category>Platform</category> |
| <category>Decorators</category> |
| <category>Resources</category> |
| <category>Plug-ins</category> |
| |
| <author> |
| <name>Balaji Krish-Sampath</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-Decorators</base></article><article link="how-to.html"> |
| <title>How to Write an Eclipse Debugger</title> |
| <date>August 27, 2004</date> |
| |
| <category>CVS</category> |
| <category>Debugging</category> |
| <author> |
| <name>Darin Wright</name> |
| <company>IBM</company> |
| </author> |
| <author> |
| <name>Bjorn Freeman-Benson</name> |
| <company>Eclipse Foundation</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-Debugger</base></article><article link="customDraw.htm"> |
| <title>Custom Drawing Table and Tree Items</title> |
| <date>September 15th, 2006</date> |
| |
| <category>SWT</category> |
| <category>User interface</category> |
| |
| <author> |
| <name>Grant Gayed</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| Populating a table or tree widget involves creating items and |
| setting their attributes (eg.- texts, images, etc.), after which |
| the table or tree takes responsibility for displaying the items. |
| This approach makes item creation straightforward and visually |
| consistent. As of Eclipse 3.2, clients of Table and Tree can now |
| custom draw their items, enabling a wide range of potential |
| visual appearances. This article explores the custom draw |
| mechanism for Table and Tree. |
| </description> |
| <base>/articles/Article-CustomDrawingTableAndTreeItems</base></article><article link="jobs-api.html"> |
| <title>On the Job: The Eclipse Jobs API</title> |
| <date>September 20, 2004</date> |
| |
| <category>Platform</category> |
| <category>Jobs</category> |
| <category>Resources</category> |
| |
| <author> |
| <name>Michael Valenta</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-Concurrency</base></article><article link="eclipse_branch.html"> |
| <title>Branching with Eclipse and CVS</title> |
| <date>July 3, 2003</date> |
| |
| <category>CVS</category> |
| <author> |
| <name>Paul Glezen</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-CVS-branching</base></article><article link="tutorial.html"> |
| <title>Extending WTP Using Project Facets</title> |
| <date>November 6, 2006</date> |
| |
| <category>Web Tools</category> |
| <category>Tutorial</category> |
| <category>Facets</category> |
| <category>Plug-ins</category> |
| |
| <author> |
| <name>Konstantin Komissarchik</name> |
| <company>BEA Systems, Inc.</company> |
| </author> |
| |
| <description> |
| The Faceted Project Framework allows the plug-in developer to |
| think of Web Tools Platform (WTP) projects as composed of units |
| of functionality, otherwise known as facets, that can be added |
| and removed by the user. This tutorial walks you through an |
| example of creating a couple of basic facets and in the process |
| covers the majority of the framework's extension points. This |
| tutorial has been written for version 1.5 of the Web Tools |
| Platform. |
| </description> |
| <base>/articles/Article-BuildingProjectFacets</base></article><article link="builders.html"> |
| <title>Project Builders and Natures</title> |
| <date>January 27, 2003</date> |
| |
| <category>Workbench</category> |
| <category>Builders</category> |
| <category>Natures</category> |
| <category>Plug-ins</category> |
| |
| <author> |
| <name>John Arthorne</name> |
| <company>IBM</company> |
| </author> |
| <update> |
| <date>November 23, 2004</date> |
| <author> |
| <name>John Arthorne</name> |
| <company>IBM</company> |
| </author> |
| <reason>for Eclipse 3.0</reason> |
| </update> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-Builders</base></article><article link="branding-your-application.html"> |
| <title>Branding Your Application</title> |
| <date>September 16, 2004</date> |
| <category>RCP</category> |
| <author> |
| <name>Andrew Eidsness</name> |
| <company>IBM</company> |
| </author> |
| <author> |
| <name>Pascal Rapicault</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-Branding</base></article><article link="AuthoringWithEclipse.html"> |
| <title>Authoring with Eclipse</title> |
| <date>December 14, 2005</date> |
| |
| <author> |
| <name>Chris Aniszczyk</name> |
| <company>IBM</company> |
| </author> |
| <author> |
| <name>Lawrence Mandel</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| The topic of technical publishing is relatively new to the world |
| of Eclipse. One can make the argument that technical publishing |
| is just another collaborative development process involving |
| several people with different backgrounds and skills. This |
| article will show that the Eclipse platform is a viable platform |
| for technical publishing by discussing how to write documents |
| such as an article or a book within Eclipse. In fact, this |
| article was written using Eclipse. |
| </description> |
| <base>/articles/Article-Authoring-With-Eclipse</base></article><article link="index.html"> |
| <title>ActiveX Support In SWT</title> |
| <date>March 22, 2001</date> |
| <category>SWT</category> |
| <category>User interface</category> |
| <category>integration</category> |
| <author> |
| <name>Veronika Irvine</name> |
| <company>IBM</company> |
| </author> |
| <description> |
| <![CDATA[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 integrating OLE Documents and ActiveX Controls into an |
| application using SWT.]]> |
| </description> |
| <base>/articles/Article-ActivexSupportInSwt</base></article><article link="index.html"> |
| <title>Designing Accessible Plug-ins in Eclipse</title> |
| <date>May 20, 2003</date> |
| |
| <category>Plug-ins</category> |
| <category>Accessibility</category> |
| |
| <author> |
| <name>Tod Creasey</name> |
| <company>IBM</company> |
| </author> |
| <update> |
| <date>July 25, 2006</date> |
| <reason>for Eclipse 3.2</reason> |
| </update> |
| <description> |
| Accessibility for disabled users 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. |
| </description> |
| <base>/articles/Article-Accessibility</base></article><article link="eclipse-api-usage-rules.html"> |
| <title>How to Use the Eclipse API</title> |
| |
| <category>Plug-ins</category> |
| |
| <update> |
| <date>May 18, 2001</date> |
| </update> |
| |
| <author> |
| <name><![CDATA[Jim des Rivières]]></name> |
| <company>IBM</company> |
| </author> |
| <description> |
| 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. |
| </description> |
| <base>/articles/Article-API use</base></article></articles> |