The following example shows how to contribute features to the generic editor via extensions:

<extension point="org.eclipse.ui.genericeditor.contentAssistProcessors">
   <contentAssistProcessor
         class="org.eclipse.ui.genericeditor.examples.dotproject.NaturesAndProjectsContentAssistProcessor"
         contentType="org.eclipse.ui.genericeditor.examples.dotproject">
   </contentAssistProcessor>
</extension>
<extension point="org.eclipse.ui.genericeditor.hoverProviders">
   <hoverProvider
         class="org.eclipse.ui.genericeditor.examples.dotproject.NatureLabelHoverProvider"
         contentType="org.eclipse.ui.genericeditor.examples.dotproject"
         id="natureLabelHoverProvider">
   </hoverProvider>
</extension>
<extension point="org.eclipse.ui.genericeditor.presentationReconcilers">
   <presentationReconciler
         class="org.eclipse.ui.genericeditor.examples.dotproject.BlueTagsPresentationReconciler"
         contentType="org.eclipse.ui.genericeditor.examples.dotproject">
   </presentationReconciler>
</extension>

Those new extension points receive as arguments regular Platform classes (IPresentationReconcilier, ITextHover, ICompletionProposalComputer) to add behavior to the generic editor. No new Java API is necessary.

public class GradlePR extends PresentationReconciler {

	private IToken quoteToken = new Token(new TextAttribute(new Color(Display.getCurrent(), new RGB(139, 69, 19))));
	private IToken numberToken = new Token(new TextAttribute(new Color(Display.getCurrent(), new RGB(0, 0, 255))));
	private IToken commentToken = new Token(new TextAttribute(new Color(Display.getCurrent(), new RGB(0, 100, 0))));

	public GradlePR() {
		RuleBasedScanner scanner = new RuleBasedScanner();

		IRule[] rules = new IRule[5];
		rules[0] = new SingleLineRule("'", "'", quoteToken);
		rules[1] = new SingleLineRule("\"","\"", quoteToken);
		rules[2] = new PatternRule("//", null, commentToken, (char)0, true);
		rules[3] = new NumberRule(numberToken);
		
		rules[4] = new GradleWordRule();
		
		scanner.setRules(rules);

		DefaultDamagerRepairer dr = new DefaultDamagerRepairer(scanner);
		this.setDamager(dr, IDocument.DEFAULT_CONTENT_TYPE);
		this.setRepairer(dr, IDocument.DEFAULT_CONTENT_TYPE);
	}

}
        

Here is an example:

<extension point="org.eclipse.ui.editors">
  <editorContentTypeBinding
    contentTypeId="org.eclipse.ui.genericeditor.examples.dotproject"
    editorId="org.eclipse.ui.genericeditor.GenericEditor">
  </editorContentTypeBinding>
</extension>
       

Clients that use DecorationOverlayIcon will get HiDPI support for free. Subclasses of CompositeImageDescriptor will have to update their implementation of #drawCompositeImage(int, int) to use the new #drawImage(ImageDataProvider, int, int) method to draw the elements of the composite image.

protected void drawCompositeImage(int width, int height) {
	// draw overlay in top-right corner:
	ImageData imageData = myImageDescriptor.getImageData();
	drawImage(imageData, width - imageData.width, 0);
}
      

protected void drawCompositeImage(int width, int height) {
	// draw overlay in top-right corner:
	CachedImageDataProvider provider =
		createCachedImageDataProvider(myImageDescriptor);
	drawImage(provider, width - provider.getWidth(), 0);
}
      

Hint: Use CompositeImageDescriptor­#createCachedImageDataProvider(­Image­/ImageDescriptor) to create an ImageDataProvider. To calculate the width and height of the image that is about to be drawn, you can use CachedImageDataProvider­#getWidth()/­getHeight(). These methods already return values in SWT points, so that your code doesn't have to deal with device-dependent pixel coordinates.

Example of API usage:

ImageDescriptor descriptor = /*base image descriptor*/;
return new DecorationOverlayIcon(
	descriptor,
	PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_DEC_FIELD_ERROR),
	IDecoration.BOTTOM_LEFT);
      

This supports the same API and methods as the usual ContentAssist, so shifting from synchronous/blocking ContentAssistant to asynchronous one only requires instantiating the ContentAssistant as asynchronous. Note that as the computation now happens in background, the IContentAssistProcessor attached to an asynchronous ContentAssistant must not require the UI Thread; any IContentAssistProcessor computer requiring the UI Thread will need to be modified in order to be used with an asynchronous ContentAssistant.

Another new API is ContentAssistant#addContentAssistProcessor(IContentAssistProcessor, String), which provides a way to directly add multiple processors to one content assistant.

The generic and extensible editor has been switched to use this asynchronous ContentAssistant.

The goal of this change is to eliminate java.lang.IllegalArgumentException: Comparison method violates its general contract! that could occur when label decorations were updated in the background.

For now, you can disable this fix by setting the system property eclipse.disable.fix.for.bug364735 to true. This temporary system property is planned to be removed unless issues with the new sorting are discovered.

Currently, the default Eclipse renderers do not use these new elements.

For plug-in based products this means that the new org.eclipse.e4.core.di.extensions.supplier bundle needs to be added the list of included plug-ins. Feature based products should not notice the split.

Note: As part of the re-organization, org.eclipse.e4.core.di.extensions.EventUtils (only intended to be used for internal testing), was moved to org.eclipse.e4.core.di.internal.extensions.util.EventUtils in the new bundle.

public class MyPart {
		   
    // highest ranked service
	
    @Inject
    @Service
    MyOsgiService service;
			
}

public class MyPart {

    // all services sorted by ranking

    @Inject
    @Service
    List<MyOsgiService> service; 
		
}

public class MyPart {
		    
    // get the highest ranked service that has
    // the component property connection=online set		
	
    @Inject
    @Service(filterExpression="(connection=online)") 
    MyOsgiService service;
			
}

Example usage:

public class SampleView extends ViewPart {

	@Inject IWorkbench workbench;

	private TableViewer viewer;

	@Override
	public void createPartControl(Composite parent) {
		viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);

		viewer.setContentProvider(ArrayContentProvider.getInstance());
		viewer.setInput(new String[] { "One", "Two", "Three" });
		viewer.setLabelProvider(new ViewLabelProvider());

		// Create the help context id for the viewer's control
		workbench.getHelpSystem().setHelp(viewer.getControl(), "test7.viewer");
	}
	// more stuff
}
      

public class TestExpression {
   @Evaluate
   public boolean isVisible(EPartService partService,
          @Optional @Named("myValueToBeChecked") String myValueToBeChecked) {

      return "expectedValue".equals(myValueToBeChecked) &&
         !partService.getDirtyParts().isEmpty();
   }
}

org.eclipse.test.Screenshots#takeScreenshot(Class<?> testClass, String name)

If your tests are organized in a JUnit-4-style test suite using the

@RunWith(Suite.class)

annotation, you can just replace that line by

@RunWith(TracingSuite.class)

This will log the start of each atomic test contained in the suite to System.out, and it will try to collect more information after a timeout (stack traces, screenshot). And it will even try to throw an exception in the main thread, so that other tests can proceed. See the Javadoc for configuration options.

The OSGi R6 API for declarative services requires some additional packages (org.osgi.util.function and org.osgi.util.promise). These packages are now exported by the org.eclipse.osgi.util bundle. In order to resolve and run the new Declarative Services implementation the following bundles are required in your target:

• org.apache.felix.scr
• org.eclipse.equinox.ds
• org.eclipse.osgi.services
• org.eclipse.osgi.util

The Equinox bundle org.eclipse.equinox.util is no longer needed for the Felix Declarative Services implementation.

Note that org.eclipse.equinox.ds automatically sets ds.delayed.keepInstances=true, which avoids failures in existing clients of Equinox DS that assume that component instances are not deactivated when their use count goes to zero.

The typical compile error indicating that you should change your BREE is:

The type java.util.stream.Stream cannot be resolved. It is indirectly referenced from required .class files.

Note that this change is only required when using org.eclipse.core.runtime.ListenerList. However, now that some Java 8 types are being exposed in the public API, similar changes may be done in other API types.

Example for adding a selection listener to a button:

import static org.eclipse.swt.events.SelectionListener.widgetSelectedAdapter;
// ...

Button button = new Button(parent, SWT.PUSH);
button.addSelectionListener(widgetSelectedAdapter(e -> {System.out.print("Hello");}));
	  

• Image#getImageData(int zoom): Returns an ImageData for the given zoom level.

Note: this API is mainly intended to be used by custom implementations of ImageDataProvider that draw a composite image at the requested zoom level based on other images. For custom zoom levels, the ImageData may be an auto-scaled version of the native image and may look more blurred or mangled than expected.

APIs for Table header foreground color:
Table#getHeaderForeground()
Table#setHeaderForeground(Color)

APIs for Table header background color:
Table#getHeaderBackground()
Table#setHeaderBackground(Color)

APIs for Tree header foreground color:
Tree#getHeaderForeground()
Tree#setHeaderForeground(Color)

APIs for Tree header background color:
Tree#getHeaderBackground()
Tree#setHeaderBackground(Color)

Table, Tree {
    swt-header-color: #CCC;
    swt-header-background-color: #383D3F;
}
      

Example:

button.setData("org.eclipse.swt.internal.gtk.css", "button:hover {background: blue; border-radius: 20px;}")
      

-Dorg.eclipse.swt.internal.gtk.cssFile=/path/to/my.css

button:hover {
  box-shadow: inset 0 0 0 5px #3071A9;
}
      

Image#getImageData(int zoom) is the replacement API for Image#getImageDataAtCurrentZoom().