org.osgi.framework.BundleException:
   Could not resolve module: com.vogella.tasks.services [9]
      Unresolved requirement:
         Require-Bundle: com.vogella.tasks.events;
            bundle-version="1.0.0"

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<?pde version="3.8"?>
<target name="target-platform">
    <locations>
        <location includeAllPlatforms="false" includeConfigurePhase="true" includeMode="planner" includeSource="true" type="InstallableUnit">
            <repository location="https://download.eclipse.org/releases/2026-09"/>
            <unit id="org.eclipse.equinox.sdk.feature.group"/>
            <unit id="org.eclipse.platform.feature.group"/>
            <unit id="org.eclipse.jdt.feature.group"/> (1)
        </location>
    </locations>
</target>

Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: Partdescriptor
Bundle-SymbolicName: com.vogella.plugin.partdescriptor
Bundle-Version: 1.0.0.qualifier
Bundle-Vendor: VOGELLA
Require-Bundle: org.eclipse.core.runtime,
 org.eclipse.jface,
 org.eclipse.e4.ui.model.workbench,
 org.eclipse.e4.ui.di
Model-Fragment: fragment.e4xmi
Bundle-RequiredExecutionEnvironment: JavaSE-21
Automatic-Module-Name: com.vogella.plugin.partdescriptor
Bundle-ActivationPolicy: lazy
Import-Package: jakarta.annotation

package com.vogella.ide.ui;

import jakarta.annotation.PostConstruct;

import org.eclipse.e4.ui.di.Focus;
import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;

public class PartEclipse4x  {
    private TableViewer viewer;

    @PostConstruct
    public void createPartControl(Composite parent) {
        viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL
                | SWT.V_SCROLL);
        viewer.setContentProvider(ArrayContentProvider.getInstance());
        viewer.setLabelProvider(new LabelProvider());
        viewer.setInput(new String[] {"One", "Two", "Three"});
    }

    @Focus
    public void setFocus() {
        viewer.getControl().setFocus();
    }
}

<?xml version="1.0" encoding="utf-8"?>
<plugin>
   <extension
         id="id1"
         point="org.eclipse.e4.workbench.model">
      <fragment
            apply="notexists"
            uri="fragment.e4xmi">
      </fragment>
   </extension>

</plugin>

package com.vogella.ide.e4view.views;

import jakarta.annotation.PostConstruct;
import jakarta.inject.Inject;

import org.eclipse.e4.ui.di.Focus;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchActionConstants;

public class SampleView {

    /**
     * The ID of the view as specified by the extension.
     */
    public static final String ID = "com.vogella.ide.e4view.views.SampleView";

    @Inject
    IWorkbench workbench;

    private TableViewer viewer;
    private Action action1;
    private Action action2;
    private Action doubleClickAction;

    class ViewLabelProvider extends LabelProvider implements ITableLabelProvider {
        @Override
        public String getColumnText(Object obj, int index) {
            return getText(obj);
        }

        @Override
        public Image getColumnImage(Object obj, int index) {
            return getImage(obj);
        }

        @Override
        public Image getImage(Object obj) {
            return workbench.getSharedImages().getImage(ISharedImages.IMG_OBJ_ELEMENT);
        }
    }

    @PostConstruct
    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(), "com.vogella.ide.e4view.viewer");
        makeActions();
        hookContextMenu();
        hookDoubleClickAction();
    }

    private void hookContextMenu() {
        MenuManager menuMgr = new MenuManager("#PopupMenu");
        menuMgr.setRemoveAllWhenShown(true);
        menuMgr.addMenuListener(this::fillContextMenu);
        Menu menu = menuMgr.createContextMenu(viewer.getControl());
        viewer.getControl().setMenu(menu);
    }

    private void fillContextMenu(IMenuManager manager) {
        manager.add(action1);
        manager.add(action2);
        // Other plug-ins can contribute their actions here
        manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
    }

    private void makeActions() {
        action1 = new Action() {
            @Override
            public void run() {
                showMessage("Action 1 executed");
            }
        };
        action1.setText("Action 1");
        action1.setToolTipText("Action 1 tooltip");
        action1.setImageDescriptor(workbench.getSharedImages().getImageDescriptor(ISharedImages.IMG_OBJS_INFO_TSK));

        action2 = new Action() {
            @Override
            public void run() {
                showMessage("Action 2 executed");
            }
        };
        action2.setText("Action 2");
        action2.setToolTipText("Action 2 tooltip");
        action2.setImageDescriptor(workbench.getSharedImages().getImageDescriptor(ISharedImages.IMG_OBJS_INFO_TSK));

        doubleClickAction = new Action() {
            @Override
            public void run() {
                IStructuredSelection selection = viewer.getStructuredSelection();
                showMessage("Double-click detected on " + selection.getFirstElement());
            }
        };
    }

    private void hookDoubleClickAction() {
        viewer.addDoubleClickListener(event -> doubleClickAction.run());
    }

    private void showMessage(String message) {
        MessageDialog.openInformation(viewer.getControl().getShell(), "e4view View", message);
    }

    @Focus
    public void setFocus() {
        viewer.getControl().setFocus();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<?eclipse version="3.4"?>
<plugin>

   <extension
         point="org.eclipse.ui.views">
      <category
            name="Sample Category"
            id="com.vogella.ide.e4view">
      </category>
      <e4view
            id="com.vogella.ide.e4view.views.SampleView"
            name="Sample View"
            icon="icons/default_folder.png"
            class="com.vogella.ide.e4view.views.SampleView"
            category="com.vogella.ide.e4view">
      </e4view>
   </extension>
  <!-- MORE ENTRIES, LEFT OUT FOR BREVITY -->

</plugin>

package com.vogella.tasks.ui.handlers;

import org.eclipse.e4.core.di.annotations.Execute;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.swt.widgets.Shell;

public class TestHandler {

    @Execute
    public void execute(Shell shell) {
        MessageDialog.openInformation(shell, "First", "Hello, e4 API world");
    }
}

package de.vogella.plugin.adapter.model;

public class Task {

    private String summary;
    private String description;
    private boolean done;

    public String getSummary() {
        return summary;
    }

    public void setSummary(String summary) {
        this.summary = summary;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public boolean isDone() {
        return done;
    }

    public void setDone(boolean done) {
        this.done = done;
    }

}

<extension
      point="org.eclipse.ui.views">
   <category
         id="de.vogella.plugin.adapter.category"
         name="Sample Category">
   </category>
   <view
         id="de.vogella.plugin.adapter.views.sampleview"
         name="Sample View"
         category="de.vogella.plugin.adapter.category"
         class="de.vogella.plugin.adapter.views.SampleView">
   </view>
</extension>

package de.vogella.plugin.adapter.views;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.ColumnLabelProvider;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.part.ViewPart;

import de.vogella.plugin.adapter.model.Task;

public class SampleView extends ViewPart {

    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.setLabelProvider(new ColumnLabelProvider() {
            @Override
            public String getText(Object element) {
                if (element instanceof Task task) {
                    return task.getSummary();
                }
                return super.getText(element);
            }
        });
        viewer.setInput(getElements());

        // publish the viewer selection to the workbench selection service,
        // this allows the Properties view to see the selected objects
        getSite().setSelectionProvider(viewer);
    }

    @Override
    public void setFocus() {
        viewer.getControl().setFocus();
    }

    // build up a simple data model
    private List<Task> getElements() {
        List<Task> tasks = new ArrayList<>();
        Task task = new Task();
        task.setSummary("First Task");
        task.setDescription("A very good description");
        task.setDone(true);
        tasks.add(task);
        task = new Task();
        task.setSummary("Second Task");
        task.setDescription("Second super description");
        tasks.add(task);

        return tasks;
    }
}

<extension
         point="org.eclipse.core.runtime.adapters">
      <factory
            adaptableType="de.vogella.plugin.adapter.model.Task"
            class="de.vogella.plugin.adapter.TaskAdapterFactory">
         <adapter
               type="org.eclipse.ui.views.properties.IPropertySource">
         </adapter>
      </factory>
</extension>

package de.vogella.plugin.adapter;

import org.eclipse.ui.views.properties.IPropertyDescriptor;
import org.eclipse.ui.views.properties.IPropertySource;
import org.eclipse.ui.views.properties.TextPropertyDescriptor;

import de.vogella.plugin.adapter.model.Task;

public class TaskPropertySource implements IPropertySource {

    private final Task task;

    public TaskPropertySource(Task task) {
        this.task = task;
    }

    @Override
    public boolean isPropertySet(Object id) {
        return false;
    }

    @Override
    public Object getEditableValue() {
        return this;
    }

    @Override
    public IPropertyDescriptor[] getPropertyDescriptors() {
        return new IPropertyDescriptor[] {
                new TextPropertyDescriptor("summary", "Summary"),
                new TextPropertyDescriptor("description", "Description") };
    }

    @Override
    public Object getPropertyValue(Object id) {
        if (id.equals("summary")) {
            return task.getSummary();
        }
        if (id.equals("description")) {
            return task.getDescription();
        }
        return null;
    }

    @Override
    public void resetPropertyValue(Object id) {
    }

    @Override
    public void setPropertyValue(Object id, Object value) {
        String s = (String) value;
        if (id.equals("summary")) {
            task.setSummary(s);
        }
        if (id.equals("description")) {
            task.setDescription(s);
        }
    }

}

package de.vogella.plugin.adapter;

import org.eclipse.core.runtime.IAdapterFactory;
import org.eclipse.ui.views.properties.IPropertySource;

import de.vogella.plugin.adapter.model.Task;

public class TaskAdapterFactory implements IAdapterFactory {

    // use a static final field so that the adapterList is only instantiated once
    private static final Class<?>[] adapterList = new Class<?>[] { IPropertySource.class };

    @Override
    public <T> T getAdapter(Object adaptableObject, Class<T> adapterType) {
        if (adapterType == IPropertySource.class && adaptableObject instanceof Task task) {
            return adapterType.cast(new TaskPropertySource(task));
        }
        return null;
    }

    @Override
    public Class<?>[] getAdapterList() {
        return adapterList;
    }

}

package de.vogella.plugin.adapter.views;

import java.util.ArrayList;
import java.util.List;

import jakarta.annotation.PostConstruct;

import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.DelegatingStyledCellLabelProvider;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.model.WorkbenchLabelProvider;

import de.vogella.plugin.adapter.model.Task;

public class SampleWorkbenchAdapterView {

    private TableViewer viewer;

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

        // use the WorkbenchLabelProvider as IStyledLabelProvider implementation
        viewer.setLabelProvider(new DelegatingStyledCellLabelProvider(new WorkbenchLabelProvider()));

        viewer.setInput(getElements());
    }

    // build up a simple data model
    private List<Task> getElements() {
        List<Task> tasks = new ArrayList<>();
        Task task = new Task();
        task.setSummary("First Task");
        task.setDescription("A very good description");
        task.setDone(true);
        tasks.add(task);
        task = new Task();
        task.setSummary("Second Task");
        task.setDescription("Second super description");
        tasks.add(task);

        return tasks;
    }
}

package de.vogella.plugin.adapter;

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.StyledString;
import org.eclipse.jface.viewers.StyledString.Styler;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.TextStyle;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.model.WorkbenchAdapter;

import de.vogella.plugin.adapter.model.Task;

public class TaskWorkbenchAdapter extends WorkbenchAdapter {

    @Override
    public ImageDescriptor getImageDescriptor(Object object) {
        return PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_OBJ_ELEMENT);
    }

    @Override
    public StyledString getStyledText(Object object) {
        if (object instanceof Task task) {
            StyledString styledString = new StyledString(task.getSummary());
            if (task.isDone()) {
                Styler styler = new Styler() {

                    @Override
                    public void applyStyles(TextStyle textStyle) {
                        // tasks which are done should have a green background
                        textStyle.background = Display.getCurrent().getSystemColor(SWT.COLOR_GREEN);
                    }
                };
                styledString.setStyle(0, task.getSummary().length(), styler);
            }
            return styledString;
        }
        return super.getStyledText(object);
    }

}

package de.vogella.plugin.adapter;

import org.eclipse.core.runtime.IAdapterFactory;
import org.eclipse.ui.model.IWorkbenchAdapter;
import org.eclipse.ui.model.IWorkbenchAdapter2;
import org.eclipse.ui.model.IWorkbenchAdapter3;
import org.eclipse.ui.views.properties.IPropertySource;

import de.vogella.plugin.adapter.model.Task;

public class TaskAdapterFactory implements IAdapterFactory {

    // use a static final field so that the adapterList is only instantiated once
    private static final Class<?>[] adapterList = new Class<?>[] { IPropertySource.class, IWorkbenchAdapter.class,
            IWorkbenchAdapter2.class, IWorkbenchAdapter3.class };

    @Override
    public <T> T getAdapter(Object adaptableObject, Class<T> adapterType) {
        if (!(adaptableObject instanceof Task)) {
            return null;
        }
        if (adapterType == IPropertySource.class) {
            return adapterType.cast(new TaskPropertySource((Task) adaptableObject));
        }
        if (adapterType == IWorkbenchAdapter.class || adapterType == IWorkbenchAdapter2.class
                || adapterType == IWorkbenchAdapter3.class) {
            return adapterType.cast(new TaskWorkbenchAdapter());
        }
        return null;
    }

    @Override
    public Class<?>[] getAdapterList() {
        return adapterList;
    }

}