Skip to content

About

Eclipse Platform UI - a comprehensive set of frameworks and common services that collectively provide a powerful software development infrastructure.

Resources

Contributing

Stars

0 stars

Watchers

0 watching

Forks

 
 

Repository files navigation

Eclipse Platform UI: viewers, workbench and rich-client applications

Platform UI connects application models to SWT controls and supplies the Eclipse workbench: views, editors, commands, perspectives, dialogs, data binding and E4 application services. Use JFace for reusable presentation components, and the workbench/RCP layers when building an Eclipse application. Native SWT widgets are maintained in a separate repository.

Layer map · Concepts · Quickstart · Example · Architecture reference

UI layer map

Layer Start here Typical question
JFace org.eclipse.jface How does model input become viewer content, labels or selection?
Data binding Core binding and SWT/JFace binding Which observable, realm and owner controls an update?
Workbench / IDE Workbench and IDE Who owns an editor, view, site or selection service?
E4 model Workbench model How is application structure represented?
Commands Core commands Which command and handler define an action?
Tests / examples tests/ and examples/ Where is the smallest matching reproduction?

UI key concepts

  • Viewer: exposes model input/selection through a control.
  • Content / label provider: supplies model elements versus their presentation. Providers have replacement and disposal lifecycles.
  • Workbench part: an editor or view managed by workbench services; its controls, listeners and resources still need a clear lifetime.
  • Realm: the execution context for observable access and notifications; it is not permission to access arbitrary SWT widgets from a worker thread.
  • Resource manager / registry: shared-resource ownership. Do not call SWT disposal directly on a resource borrowed from a JFace manager or registry.
  • RCP: the Eclipse rich-client application platform; some bundles are reusable there while other bundles specifically serve the IDE.

Fork compatibility contract

This fork is an optimized, backward-compatible superset of Eclipse Platform UI. Existing applications written against the upstream subset must retain their public APIs and behavior when they use this fork. Fork-specific APIs, features, optimizations and contracts are part of the superset and must be preserved when changes are integrated.

Compatibility is directional: the fork supports existing subset clients; upstream is not required to implement the fork's extensions. Release qualification covers the inherited contracts and the additional fork behavior.

UI fork status

This fork derives from Eclipse Platform UI. The established JFace/workbench implementations and M3 sidecar coexist with a source-backed architecture and coverage guide. Its module/package inventory and selected lifecycle contracts are documented; complete per-package semantics and runtime qualification remain separate work. The M3 direction below is not a claim of measured responsiveness, memory savings or complete runtime integration in this checkout.

UI quickstart

The inspected Jenkinsfile selects JDK 25. Prepare Maven 3.9.x, network access to Eclipse parent/p2 dependencies and a working SWT/native display. The Oomph setup below creates an upstream workspace; verify fork remotes before editing. Maven defaults configure individual-bundle/target resolution; a plain Java classpath is not the PDE target platform.

git clone https://github.com/hsoliwal/eclipse.platform.ui.git
cd eclipse.platform.ui
git rev-parse HEAD
java -version
mvn -version
# Focused JFace source-plus-test lane; not the whole repository.
mvn clean verify -pl :org.eclipse.jface,:org.eclipse.jface.tests

Use mvn clean verify for the ordinary full reactor. Tycho's integration-test lifecycle requires verify; a test invocation alone is not equivalent. These commands were checked against source/configuration, not executed here.

UI command and ownership cheat sheet

git grep -n -e 'setContentProvider' -e 'setInput' -- bundles/org.eclipse.jface/src
git grep -n 'handleDispose' -- bundles/org.eclipse.jface/src/org/eclipse/jface/viewers
find . -path '*/target/surefire-reports/TEST-*.xml' -print
  • Include the modified production bundle alongside its tests so the selected run does not silently exercise only a target-platform copy.
  • For a stale label, distinguish model mutation, provider notification and viewer refresh before modifying SWT painting.
  • For shutdown failures, trace provider listeners, control disposal and delayed callbacks. A repaint cannot repair invalid ownership.

UI worked example

Replace a viewer's input without retaining the previous model. Read ContentViewer.java with the lifecycle guide.

  1. Create the viewer/control, install its content and label providers, then set input.
  2. In setInput, the provider receives old/new input before the viewer stores the new input. Detach old-model listeners and attach new-model listeners there.
  3. Keep that provider callback safe for teardown as well: input removal is also part of disposal. Do not assume it is always a normal presentation update.
  4. Provider replacement may dispose the old provider; sharing it across viewers requires an explicit shared-lifetime design.
  5. Test input A → input B → control disposal, checking that A no longer notifies this viewer and cleanup releases listeners. The homepage describes the case; it does not claim those tests were run.

Continue with JFace, data binding, RCP and the architecture coverage boundaries. The original project, contribution and licensing sections remain below.

Source tour checked at 119b433438c6. Commands describe that revision; recheck build configuration when changing revisions. Build/UI/performance verification was not run for this README update.


M³ × Eclipse Platform UI

Test runtime ideas against the real IDE workbench—not only isolated microbenchmarks.

M3 research target Evidence first

M3 runtime programme · Technical paper · Source invitation

Note

This is an experimental downstream fork of the upstream Eclipse Platform UI project. M3 String, regex, precompute and collection integration are engineering directions, not verified deployment, performance, compatibility or upstream-endorsement claims. Preserve original licensing, copyright, API behavior and native/UI contracts.

Engineering questions for this fork

Surface What to investigate Non-negotiable contract
Workbench state Measure lifecycle, selection, editor and view-state access RCP/IDE extension points and public behavior
SWT handoff Characterize event-loop responsiveness, model-to-widget transitions and native resources Thread affinity, disposal and UI responsiveness
Long sessions Reproduce open/edit/search/close cycles No retained-state leaks or correctness regressions

Approach: inventory first; copy/derive only with license and provenance; qualify reusable recipes in Synexia; port into the appropriate runtime/product owner; then test with representative desktop projects and publish CPU, allocation, retained-memory, startup and responsiveness numbers, including regressions. No Synexia runtime dependency.

Come inspect the code

Java, JNI, SWT, workbenches, widgets, real code: open the repositories. Bring a failing case, a performance counterexample, a profiler trace or a better algorithm. Challenge the design on the merits of source, tests and evidence—not slogans or a résumé.

Explore the family: M3JDK21 · SWT · Eclipse Platform · Platform UI · Nebula · GEF Classic.

Contribute here: issues · pull requests · M3 compatibility and benchmark contract.

The remainder of this README retains the existing M3 fork notes and the original upstream Eclipse Platform UI documentation. Nothing in this introduction rebrands upstream work as M3-authored code.


M3 direction in this fork

M3 is based on the idea that shared immutable structure and indexed metadata can provide a basis for reusable computation. The programme starts with M3 String, regex, and precompute in M3JDK21, then collections and SWT/Eclipse integration.

This Eclipse Platform UI fork is a target for evaluating qualified runtime and collection improvements in RCP and IDE workloads, including responsiveness and resource use.

Explore the idea: M3 technical design paper · Programme goals and roadmap. The paper explains the proposed architecture, cost tradeoffs, and evaluation plan. Readers are invited to examine the work and contribute representative workloads.

This section describes the direction of the hsoliwal fork. Upstream documentation follows below; upstream authorship, licenses, and project identity remain intact.


Eclipse Platform UI Project

Thanks for your interest in this project.

Project Description

Platform UI provides the basic building blocks for user interfaces built with Eclipse.

Some of these form the Eclipse Rich Client Platform (RCP) and can be used for arbitrary rich client applications, while others are specific to the Eclipse IDE. The Platform UI codebase is built on top of the Eclipse Standard Widget Toolkit (SWT), which is developed as an independent project.

For more information, refer to the Eclipse Platform project page and the Platform UI wiki page.

Source and documentation map

SWT's native widget implementations are maintained in the separate SWT repository. A workbench or JFace regression should first be reproduced in its UI test bundle; a native-widget issue may need a smaller SWT reproduction.

The Oomph configuration below provisions the upstream Platform UI development workspace. Verify the Git remote and branch before editing this fork. Fork-specific changes belong in hsoliwal/eclipse.platform.ui pull requests; upstream changes follow CONTRIBUTING.md.

Package and lifecycle documentation

The architecture and coverage guide connects source-backed lifecycle contracts, project/module ownership, Java package and source-set coverage, and export boundaries. It pins the inspected source revision and keeps unreviewed semantics, generated or native boundaries, and unrun verification visible. Inventory coverage is reported separately from complete package/API documentation.

How to Contribute

Contributions are most welcome. There are many ways to contribute, from entering high quality bug reports, to contributing code or documentation changes.

For a complete guide, see the CONTRIBUTING page.

Create Eclipse Development Environment for Eclipse Platform UI

Test Dependencies

Several test plug-ins have a dependency to the Mockito and Hamcrest libraries. Please install them by installing "Eclipse Test Framework" from the current release stream p2 repo.

How to Build on the Command Line

Use Maven 3.9.x and the JDK selected by the checked-in Jenkinsfile, currently JDK 25, to reproduce this revision's CI. From the repository root:

mvn clean verify

Focused UI tests

Tycho tests need the verify lifecycle; mvn test alone is not an equivalent test run. For example, to build JFace and its test bundle together:

mvn clean verify -pl :org.eclipse.jface,:org.eclipse.jface.tests

The source and tests are in bundles/org.eclipse.jface/ and tests/org.eclipse.jface.tests/. Include the changed production bundle when selecting tests so the run exercises your source changes, rather than only a bundle resolved from the target platform. A focused run does not cover other workbench, text or data-binding test bundles.

The root POM enables the UI harness and UI thread by default. Provide a working native SWT/display environment; Jenkins uses Xvnc on Linux. .mvn/maven.config enables the individual-bundle profile, eager target resolution and tycho.localArtifacts=ignore. The parent and target dependencies must be reachable in the configured Eclipse repositories; a plain Java classpath is not a substitute for the PDE target platform.

Test reports are written under **/target/surefire-reports/TEST-*.xml. When reproducing the Jenkins lane, also inspect its API analysis and compiler reports: that lane uses maven.test.failure.ignore=true, so a successful Maven process alone does not prove passing tests. Report the exact command, JDK, OS/display backend and any skipped or unavailable UI coverage.

Issue Tracking

This project uses GitHub to track ongoing development and issues. In case you have an issue, please read the information about Eclipse being a community project and bear in mind that this project is almost entirely developed by volunteers. So the contributors may not be able to look into every reported issue. You will also find the information about how to find and report issues in repositories of the eclipse-platform organization there. Be sure to search for existing issues before you create another one.

In case you want to report an issue that is specific to this eclipse.platform.ui repository, you can find existing issues or create new issues within this repository.

Contact

Contact the project developers via the project's "dev" list.

License

Eclipse Public License (EPL) 2.0

About

Eclipse Platform UI - a comprehensive set of frameworks and common services that collectively provide a powerful software development infrastructure.

Resources

Contributing

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages