articles.xml

<?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&trade;
		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&reg;
		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 &amp; 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&amp;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&trade;	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&reg; 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&reg;
		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 &Ouml;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&#153; 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&amp;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
		&reg; Windows &reg; 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&egrave;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>