Eclipse data tools platform api

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. 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. Written in a concise and friendly style, packed with tips and a practical project, this book will instruct you on using PHPEclipse to make your PHP application development more efficient, and cut development time.

This article describes how the Eclipse 3. 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. Congratulations on taking the plunge and writing an open source plug-in for the Eclipse platform.

This article is an introduction to SourceForge for the Eclipse developer. You will learn the features available to the SourceForge. Eclipse is more than a state-of-the-art IDE: its Rich Client Platform RCP plug-ins form an outstanding foundation for any desktop application, from chat applications to enterprise software front-ends. 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.

This practical pocket guide gets you up to speed quickly with Eclipse. It covers basic concepts, including Views and editors, as well as features that are not commonly understood, such as Perspectives and Launch Configurations. You'll learn how to write and debug your Java code--and how to integrate that code with tools such as Ant and JUnit.

You'll also get a toolbox full of tips and tricks to handle common--and sometimes unexpected--tasks that you'll run across in your Java development cycle. This tutorial shows how to extend the Visual Editor to support a custom widget. 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.

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.

A short history and overview of OpenGL is presented, followed by an example application. Starting with release 3. 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. 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.

In his friendly, easy-to-understand style, the bestselling author of Java 2 For Dummies shows developers how to get up to speed fast on this popular Eclipse Java IDE. Eclipse has been one of the best IDEs for unit testing ever since its early days.

From Version 3. Das Buch ist auf dem aktuellen Stand von Eclipse 3. This step-by-step guide introduces novices to using all major features of Eclipse 3. It is packed with code-rich, real-world examples that show programmers how to speed up the development of applications by reusing and extending existing Eclipse components.

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. 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. 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. In typical Developer's Notebook style, you'll learn how to take SWT out for a spin, make it work for you,and turn it upside down, all without wasted words or space.

Each lab in this notebook details a specific task; you can read from the first page to the last, look up just what you need to know, and even squeeze this book into your laptop bag as a quick reference when you forget how to create a multi-tabbed view. Eclipse is a world-class Java integrated development environment IDE and an open source project and community.

As in the best-selling first edition, the authors draw on their considerable experience teaching Eclipse and mentoring developers to provide guidance on how to customize Eclipse for increased productivity and efficiency. 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. 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. 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.

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. 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. Eclipse is a powerful open source platform that gives Java developers a new way to approach development projects.

In the Eclipse Cookbook, Java expert Steve Holzner demystifies Eclipse with practical recipes for more than situations you may encounter--from deploying a web application automatically to reverse engineering compiled code, from re-naming all references to a class across multiple packages to initializing the SWT JNI libraries.

O'Reilly's new guide to the technology, Eclipse, provides exactly what you're looking for: a fast-track approach to mastery of Eclipse. This insightful, hands-on book delivers clear and concise coverage, with no fluff, that gets down to business immediately. The book is tightly focused, covering all aspects of Eclipse: the menus, preferences, views, perspectives, editors, team and debugging techniques, and how they're used every day by thousands of developers.

Development of practical skills is emphasized with dozens of examples presented throughout the book. The extended image canvas can be used to scroll and zoom large images, and can also be extended to apply other transforms. They enable you to build nimble and powerful Java GUIs--but this is only the beginning.

With Draw2D and the Graphical Editing Framework, you can go beyond static applications and create full-featured editors. And with the Rich Client Platform, you can build customized workbenches whose capabilities far exceed those of traditional interfaces. It guides you through the process of developing Eclipse-based GUIs and shows how to build applications with features your users will love. The authors share their intimate knowledge of the subject with you in a friendly, readable style.

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. 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 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. 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.

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.

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. 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. Application developers require the ability to run and debug code in order to test it. 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.

Drag and drop provides a quick and easy mechanism for users to re-order and transfer data within an application and between applications. Draw2D provides figures and layout managers which form the graphical layer of a GEF application. 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. 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. 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. 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. 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. This article also provides a short reference to the JET syntax.

There are many programming languages that allow access and discrete control of system memory. If you are a debug provider for one of these languages, then you probably have a requirement to provide support for debug-time memory inspection and manipulation. The Eclipse debug framework provides a Memory View, along with an extensible framework to simplify and standardize this task.

This article introduces the Memory View and describes how to add your own customized memory support. 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.

The package org. Graphics can be drawn on anything that implements org. Drawable , which includes org. Control and org. The class org. GC encapsulates all of the drawing API, including how to draw lines and shapes, draw text and images and fill shapes. This article shows how to use a GC to draw onto an Image, or onto a control through its paintEvent callback. The Canvas control, specifically designed for drawing operations, has a number of constructor style bits that allow you to determine when and how painting occurs, and the article shows how to use these.

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.

Eclipse is in your future! Whether you're an OO Guru, a Java neophyte, or a professional business programmer, there's a good chance that you will be using Eclipse some day soon. IBM spent millions of dollars on Eclipse before releasing it into the Open Source community, and you can take advantage of all of that development.

But how do you get started? 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. In this article, you will learn how to use the properties view to dynamically modify the properties of a GUI button.

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. 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. 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.

This book provides a thorough guide to using Eclipse features and plug-ins effectively in the context of real-world Java development.

Realistic examples demonstrate how to use Eclipse effectively to build, test and debug applications using the tools provided by Eclipse and other third-party open source plugins. The reader will learn how to use plugin tools for using Eclipse in a team environment, including using Ant for more sophisticated build processes and CVS for source control. 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.

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.

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.

Even though preference pages can be simple to program, you can spend a lot of time getting them "just right. Field editors also define some of the behavior for grouping and laying out widgets on a preference page. 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. We'll start with a simple example and progressively add functionality.

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. 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. These general ground rules are also recommended practice for plug-ins that must declare API elements of their own. 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. The combination of platforms, display devices and color depth makes providing an easy to use yet powerful and portable color model an interesting challenge. Managing images in a large graphical application can be a daunting task.

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. 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.

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. 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. The two part series of articles describes 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. 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. Obfuscating RCP applications can be a challenge for a number of reasons. First, RCP applications are composed of many plugins that must be obfuscated at the same time. And second, classes often need to be excluded from obfuscation because they're referenced by plugin extensions or extension points. In this article the author takes you on a tour of the process they use to build and obfuscate a large-scale RCP application.

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. Eclipse is not just for Java-centric development. The CDT project has been a part of Eclipse for over four years now and has acquired a large and faithful following. There are a large number of embedded tool vendors, for example, that are including the CDT as a standard part of their development tool suite.

In fact, RAP can be thought of as RCP for the Web, and that means, among other things, that a large part of the existing code from desktop RCP applications can be used to run them in a browser. This webinar will teach you about the three RAP building blocks - a widget toolkit, the Eclipse plug-in mechanism, and a workbench - and how they compare with RCP.

The widget toolkit is a Java component library similar to SWT. It shields you from differences in the underlying technologies. The plug-in mechanism for Web applications employs the OSGi functionality. The workbench is tightly integrated with the widget toolkit and is similar to the Eclipse platform workbench. Using industry best practices such as model-driven development with UML, and taking advantage of the Eclipse Modeling Framework EMF , initially included are models for:.

The Connectivity project includes components for defining, connecting to, and working with data sources. The frameworks include:. Mission The Data Tools Platform DTP project will include extensible frameworks and exemplary tools, enabling a diverse set of plug-in offerings specific to particular data-centric technologies and supported by the DTP ecosystem.

In the spirit of Eclipse, the project will be guided by the following values: Vendor neutrality: We intend to provide data management frameworks and tools not biased toward any vendor. Our intention is that DTP be leveraged to provide the Eclipse community with the widest range of choices possible. To this end, we seek community involvement in formulating key framework interfaces, so that the largest possible constituency is represented.

Extensibility: We recognize both the common need for data tooling infrastructure and the desire to extend the offerings in new and innovative ways. To support these efforts, our components will be designed for, and make good use of, extensibility mechanisms supported by Eclipse. We strongly believe that DTP will achieve its full potential only as the result of deep and broad cooperation with the Eclipse membership-at-large.

Thus, we will make every effort to accommodate collaboration, reach acceptable compromises, and provide a project management infrastructure that includes all contributors, regardless of their affiliation, location, interests, or level of involvement. Regular meetings covering all aspects of DTP, open communication channels, and equal access to process will be key areas in driving successful community involvement. Transparency: As with all projects under the eclipse.

Agile development: We will strive to incorporate into our planning process innovations that arise once a project is underway, and the feedback from our user community on our achievements to date.

We think an agile planning and development process, in which progress is incremental, near-term deliverables are focused, and long-term planning is flexible, will be the best way to achieve this. Scope Data-centric applications are those having an association with a data source, and a mapping from a data source to an in-memory model. These include: In-memory representation: Models providing a domain-based interaction with data, such as database definitions, query models, result sets, and objects.

These models provide the basis upon which all other DTP components are constructed. Connectivity: Specification and configuration of data source drivers.

Management: Administration of data sources including both generic and vendor-specific configuration options. Examples include adding and removing tables from a database, setting type information for contained data, and setting performance parameters. Data-centric model transformation: Changing data from one format to another is a common task in data-centric application development.

For example, there are several popular dialects of the SQL standard. Hence, there is a need to translate between the two dialects. Extract-Transform-Load: Obtaining data from and supplying data to data sources, typically using large-scale batch movements and involving data checking and validation. Often includes some operations on data obtained before loading into target data source. Data Mapping: Mapping between data source and in-memory representation, used for bridging between domains such as object, relational, hierarchical, and multi-dimensional data structures.

The components folder contains a folder for each component that will be built. These folders may be used directly with PDE builder as the buildLocation for the build. A component is synonymous with a feature. The feature specified by the component is used to drive the build. See the PDE builder documentation for more information. This system deviates from the general PDE build integration by the following:.

The cruise folder contains scripts for driving the main build from CruiseControl. The build.