plugins/req/org.eclipse.papyrus.pdp4eng.req.ui/src/org/eclipse/papyrus/pdp4eng/req/ui/view/RequirementView.java

/**
 *  Copyright (c)2020 CEA LIST, Committer Name, and others.
 *
 *  All rights reserved. This program and the accompanying materials
 *  are made available under the terms of the Eclipse Public License 2.0
 *  which accompanies this distribution, and is available at
 *  https://www.eclipse.org/legal/epl-2.0/
 *
 *  SPDX-License-Identifier: EPL-2.0
 *
 *  Contributors:
 *  Patrick Tessier (CEA LIST) Patrick.tessier@cea.fr   - Initial API and implementation
 *
 */
package org.eclipse.papyrus.pdp4eng.req.ui.view;

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

import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.papyrus.infra.ui.editor.IMultiDiagramEditor;
import org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Accuracy;
import org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataMinimisation;
import org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Fairly;
import org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Lawful;
import org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByConsent;
import org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByContract;
import org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByLegalObligation;
import org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByPublicInterest;
import org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByVitalInterest;
import org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PurposeLimitation;
import org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.SecuritySafety;
import org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.StorageLimitation;
import org.eclipse.papyrus.sysml14.requirements.Requirement;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.FontData;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.ui.ISelectionListener;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.part.ViewPart;
import org.eclipse.ui.views.properties.IPropertySheetPage;
import org.eclipse.ui.views.properties.tabbed.ITabbedPropertySheetPageContributor;
import org.eclipse.ui.views.properties.tabbed.TabbedPropertySheetPage;

/**
 * This class is the requirements view that displays requirements that are associated to the selected element.
 *
 */
public class RequirementView extends ViewPart implements ITabbedPropertySheetPageContributor {

	private TreeViewer viewer;
	// list of stereotype to filter
	private ArrayList<Class<?>> steretotypeFilter = new ArrayList<>();
	private List<IPropertySheetPage> propertySheetPages = new ArrayList<>();
	private ISelectionListener mylistener;

	private static FontData[] getModifiedFontData(FontData[] originalData, int additionalStyle) {
		FontData[] styleData = new FontData[originalData.length];
		for (int i = 0; i < styleData.length; i++) {
			FontData base = originalData[i];
			styleData[i] = new FontData(base.getName(), base.getHeight(), base.getStyle() | additionalStyle);
		}
		return styleData;
	}

	public RequirementView() {
		steretotypeFilter.add(Requirement.class);
		steretotypeFilter.add(Lawful.class);
		steretotypeFilter.add(LawfulByConsent.class);
		steretotypeFilter.add(LawfulByContract.class);
		steretotypeFilter.add(LawfulByLegalObligation.class);
		steretotypeFilter.add(LawfulByPublicInterest.class);
		steretotypeFilter.add(LawfulByVitalInterest.class);
		steretotypeFilter.add(Fairly.class);
		steretotypeFilter.add(org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Transparency.class);
		steretotypeFilter.add(Accuracy.class);
		steretotypeFilter.add(DataMinimisation.class);
		steretotypeFilter.add(PurposeLimitation.class);
		steretotypeFilter.add(StorageLimitation.class);
		steretotypeFilter.add(SecuritySafety.class);


	}

	/**
	 * create action in the view in order to filter stereotypes
	 */
	public void createActions() {
		IMenuManager mainMenu = getViewSite().getActionBars().getMenuManager();
		MenuManager GDPRmenu = new MenuManager("GDPR requirement", "GDPR.requirement.menu"); //$NON-NLS-1$ //$NON-NLS-2$
		for (int i = 0; i < steretotypeFilter.size(); i++) {
			GDPRmenu.add(new RequirementAction(steretotypeFilter.get(i), steretotypeFilter));
			mainMenu.add(GDPRmenu);
		}
	}



	@Override
	public void createPartControl(Composite parent) {
		viewer = new TreeViewer(parent, SWT.MULTI | SWT.FULL_SELECTION);
		viewer.setContentProvider(new ReviewsTreeContentProvider(steretotypeFilter));

		// useful for the label provider
		FontData[] boldFontData = getModifiedFontData(viewer.getTree().getFont().getFontData(), SWT.BOLD);
		FontData[] italicFontData = getModifiedFontData(viewer.getTree().getFont().getFontData(), SWT.ITALIC);
		Font boldFont = new Font(Display.getCurrent(), boldFontData);
		Font italicFont = new Font(Display.getCurrent(), italicFontData);
		// set label provider
		viewer.setLabelProvider(new ReviewsTreeLabelProvider(boldFont, italicFont));
		createActions();

		Listener paintListener = makeTreeItemMultiline();
		viewer.getTree().addListener(SWT.MeasureItem, paintListener);
		viewer.getTree().addListener(SWT.EraseItem, paintListener);

		// used to synchronize the selection on this view
		getSite().setSelectionProvider(viewer);
		mylistener = new ISelectionListener() {
			@Override
			public void selectionChanged(IWorkbenchPart sourcepart, ISelection selection) {
				if (sourcepart != RequirementView.this && selection instanceof IStructuredSelection) {
					viewer.setInput(((IStructuredSelection) selection).getFirstElement());
				}
			}
		};
		getSite().getWorkbenchWindow().getSelectionService().addSelectionListener(mylistener);

	}

	
	@Override
	public void dispose() {
		getSite().getWorkbenchWindow().getSelectionService().removeSelectionListener(mylistener);
		super.dispose();
	}
	private Listener makeTreeItemMultiline() {
		// this code comes from eclipse in oder to display multi line in a tree
		Listener paintListener = new Listener() {
			@Override
			public void handleEvent(Event event) {
				switch (event.type) {
				case SWT.MeasureItem: {
					TreeItem item = (TreeItem) event.item;
					String text = item.getText();
					Point size = event.gc.textExtent(text);
					event.width = size.x + 20;
					event.height = Math.max(event.height, size.y);
					break;
				}
				case SWT.PaintItem: {
					TreeItem item = (TreeItem) event.item;
					String text = item.getText();
					Point size = event.gc.textExtent(text);
					int offset2 = event.index == 0 ? Math.max(0, (event.height - size.y) / 2) : 0;
					event.gc.drawText(text, event.x, event.y + offset2, true);
					break;
				}
				case SWT.EraseItem: {
					event.detail &= ~SWT.FOREGROUND;
					break;
				}
				}
			}
		};
		return paintListener;
	}

	@Override
	public String getContributorId() {
		return "org.eclipse.papyrus.pdp4eng.req.ui.RequirementView"; //$NON-NLS-1$
	}

	@Override
	public void setFocus() {
	}

	@Override
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public Object getAdapter(Class adapter) {
		if ((IPropertySheetPage.class.equals(adapter))) {
			return getPropertySheetPage();
		}

		else {
			return super.getAdapter(adapter);
		}
	}

	/**
	 * Retrieves the {@link IPropertySheetPage} that his Model Explorer uses.
	 *
	 * @return
	 */
	private IPropertySheetPage getPropertySheetPage() {
		IWorkbenchPart part = null;
		try {
			IWorkbenchWindow activeWorkbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
			if (activeWorkbenchWindow != null) {
				IWorkbenchPage activePage = activeWorkbenchWindow.getActivePage();
				if (activePage != null) {
					part = activePage.getActiveEditor();
				}
			}
		} catch (NullPointerException e) {
			// An element is not active yet
			return null;
		}


		if (part instanceof IMultiDiagramEditor) {
			if (part instanceof ITabbedPropertySheetPageContributor) {
				ITabbedPropertySheetPageContributor contributor = (ITabbedPropertySheetPageContributor) part;
				IPropertySheetPage propertySheetPage = new TabbedPropertySheetPage(contributor);
				this.propertySheetPages.add(propertySheetPage);
				return propertySheetPage;
			}
		}
		return null;
	}
}