| /******************************************************************************* |
| * Copyright (c) 2017, 2020 Obeo. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Obeo - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.emf.ecoretools.design.service; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.lang.reflect.Field; |
| import java.net.MalformedURLException; |
| import java.nio.file.Files; |
| import java.nio.file.StandardCopyOption; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.emf.codegen.ecore.genmodel.GenClass; |
| import org.eclipse.emf.codegen.ecore.genmodel.GenClassifier; |
| import org.eclipse.emf.codegen.ecore.genmodel.GenEnum; |
| import org.eclipse.emf.codegen.ecore.genmodel.GenEnumLiteral; |
| import org.eclipse.emf.codegen.ecore.genmodel.GenFeature; |
| import org.eclipse.emf.codegen.ecore.genmodel.GenModelPackage; |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.ecore.EAnnotation; |
| import org.eclipse.emf.ecore.EClass; |
| import org.eclipse.emf.ecore.EGenericType; |
| import org.eclipse.emf.ecore.EModelElement; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EParameter; |
| import org.eclipse.emf.ecore.EReference; |
| import org.eclipse.emf.ecore.EStructuralFeature; |
| import org.eclipse.emf.ecore.ETypedElement; |
| import org.eclipse.emf.ecore.EcoreFactory; |
| import org.eclipse.emf.ecore.EcorePackage; |
| import org.eclipse.emf.ecore.impl.EStringToStringMapEntryImpl; |
| import org.eclipse.emf.edit.ui.provider.ExtendedImageRegistry; |
| import org.eclipse.jface.resource.ImageDescriptor; |
| import org.eclipse.sirius.diagram.DEdge; |
| import org.eclipse.sirius.diagram.description.EdgeMapping; |
| import org.eclipse.sirius.viewpoint.DSemanticDecorator; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.widgets.FileDialog; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.ui.PlatformUI; |
| |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.collect.Iterables; |
| import com.google.common.collect.Lists; |
| import com.google.common.collect.Ordering; |
| |
| /** |
| * The services class used by the Properties View support. |
| */ |
| public class PropertiesServices { |
| |
| protected static final String GEN_MODEL_PACKAGE_NS_URI = "http://www.eclipse.org/emf/2002/GenModel"; |
| |
| public List<EStructuralFeature> removeFeaturesToHide(EObject ctx, Collection<EStructuralFeature> unfiltered) { |
| List<EStructuralFeature> toBeFilterd = Lists.newArrayList(unfiltered); |
| toBeFilterd.remove(GenModelPackage.Literals.GEN_CLASS__ECORE_CLASS); |
| toBeFilterd.remove(GenModelPackage.Literals.GEN_PACKAGE__ECORE_PACKAGE); |
| toBeFilterd.remove(GenModelPackage.Literals.GEN_CLASS__ECORE_CLASS); |
| toBeFilterd.remove(GenModelPackage.Literals.GEN_FEATURE__ECORE_FEATURE); |
| if (ctx instanceof EReference) { |
| toBeFilterd.remove(EcorePackage.Literals.ESTRUCTURAL_FEATURE__DEFAULT_VALUE_LITERAL); |
| } |
| toBeFilterd.remove(GenModelPackage.Literals.GEN_ENUM__ECORE_ENUM); |
| toBeFilterd.remove(GenModelPackage.Literals.GEN_TYPE_PARAMETER__ECORE_TYPE_PARAMETER); |
| |
| PriorityComparator<EStructuralFeature> comparator = new PriorityComparator<EStructuralFeature>(ImmutableList.of( |
| EcorePackage.Literals.ENAMED_ELEMENT__NAME, EcorePackage.Literals.ETYPED_ELEMENT__ETYPE, |
| EcorePackage.Literals.ETYPED_ELEMENT__LOWER_BOUND, EcorePackage.Literals.ETYPED_ELEMENT__UPPER_BOUND, |
| EcorePackage.Literals.ECLASSIFIER__INSTANCE_CLASS_NAME, |
| EcorePackage.Literals.ECLASSIFIER__INSTANCE_TYPE_NAME, |
| EcorePackage.Literals.ESTRUCTURAL_FEATURE__DEFAULT_VALUE_LITERAL, |
| EcorePackage.Literals.EREFERENCE__EOPPOSITE, EcorePackage.Literals.EREFERENCE__CONTAINMENT, |
| EcorePackage.Literals.ESTRUCTURAL_FEATURE__TRANSIENT, |
| EcorePackage.Literals.ESTRUCTURAL_FEATURE__DERIVED)); |
| /* |
| * reorder features |
| */ |
| |
| return Ordering.from(comparator).sortedCopy(toBeFilterd); |
| } |
| |
| class PriorityComparator<T> implements Comparator<T> { |
| private final List<T> values; |
| |
| public PriorityComparator(List<T> values) { |
| this.values = values; |
| } |
| |
| @Override |
| public int compare(T o1, T o2) { |
| int idx1 = values.indexOf(o1); |
| int idx2 = values.indexOf(o2); |
| if (idx1 > -1) { |
| return idx2 > -1 ? idx1 - idx2 : -1; |
| } |
| return idx2 > -1 ? 1 : 0; |
| } |
| } |
| |
| public List<EObject> removeSemanticElementsToHide(EObject ctx, Collection<EObject> unfiltered, |
| DSemanticDecorator selection) { |
| List<EObject> filtered = Lists.newArrayList(); |
| for (EObject eObject : unfiltered) { |
| if (!(eObject instanceof EParameter)) { |
| filtered.add(eObject); |
| } |
| } |
| if (selection instanceof DEdge && ctx instanceof EClass |
| && ((DEdge) selection).getActualMapping() instanceof EdgeMapping |
| && "EC ESupertypes".equals(((EdgeMapping) ((DEdge) selection).getActualMapping()).getName())) { |
| filtered.addAll(((EClass) ctx).getEGenericSuperTypes()); |
| for (EGenericType genType : ((EClass) ctx).getEGenericSuperTypes()) { |
| filtered.addAll(genType.getETypeArguments()); |
| } |
| } |
| |
| return filtered; |
| } |
| |
| public EStringToStringMapEntryImpl getVisibleDocAnnotations(EObject self) { |
| if (self instanceof EModelElement) { |
| EAnnotation eAnnot = ((EModelElement) self).getEAnnotation(GEN_MODEL_PACKAGE_NS_URI); |
| if (eAnnot != null) { |
| for (EStringToStringMapEntryImpl mapEntry : Iterables.filter(eAnnot.getDetails(), |
| EStringToStringMapEntryImpl.class)) { |
| if ("documentation".equals(mapEntry.getKey())) { |
| return mapEntry; |
| } |
| } |
| } |
| |
| } else if (self instanceof EAnnotation) { |
| for (EStringToStringMapEntryImpl mapEntry : Iterables.filter(((EAnnotation) self).getDetails(), |
| EStringToStringMapEntryImpl.class)) { |
| if ("documentation".equals(mapEntry.getKey())) { |
| return mapEntry; |
| } |
| } |
| } else if (self instanceof EStringToStringMapEntryImpl) { |
| if ("documentation".equals(((EStringToStringMapEntryImpl) self).getKey())) { |
| return (EStringToStringMapEntryImpl) self; |
| } |
| } |
| return null; |
| } |
| |
| public EObject setDocAnnotation(EObject self, String value) { |
| if (self instanceof EModelElement) { |
| EAnnotation eAnnot = ((EModelElement) self).getEAnnotation(GEN_MODEL_PACKAGE_NS_URI); |
| if (eAnnot != null) { |
| for (EStringToStringMapEntryImpl mapEntry : Iterables.filter(eAnnot.getDetails(), |
| EStringToStringMapEntryImpl.class)) { |
| if ("documentation".equals(mapEntry.getKey())) { |
| mapEntry.setValue(value); |
| } |
| } |
| } else { |
| EAnnotation newAnnot = EcoreFactory.eINSTANCE.createEAnnotation(); |
| newAnnot.setSource(GEN_MODEL_PACKAGE_NS_URI); |
| newAnnot.getDetails().put("documentation", value); |
| ((EModelElement) self).getEAnnotations().add(newAnnot); |
| } |
| |
| } else if (self instanceof EAnnotation) { |
| for (EStringToStringMapEntryImpl mapEntry : Iterables.filter(((EAnnotation) self).getDetails(), |
| EStringToStringMapEntryImpl.class)) { |
| if ("documentation".equals(mapEntry.getKey())) { |
| mapEntry.setValue(value); |
| } |
| } |
| |
| } else if (self instanceof EStringToStringMapEntryImpl) { |
| if ("documentation".equals(((EStringToStringMapEntryImpl) self).getKey())) { |
| ((EStringToStringMapEntryImpl) self).setValue(value); |
| } |
| } |
| return self; |
| } |
| |
| public boolean isJavaFileGenerated(EObject cur) { |
| URI javaImplementationURI = getJavaImplementationURI(cur); |
| if (javaImplementationURI != null && cur.eResource() != null && cur.eResource().getResourceSet() != null |
| && cur.eResource().getResourceSet().getURIConverter() != null) { |
| return cur.eResource().getResourceSet().getURIConverter().exists(javaImplementationURI, |
| Collections.EMPTY_MAP); |
| } |
| return false; |
| } |
| |
| public String getJavaImplementationPath(EObject cur) { |
| URI targetFile = getJavaImplementationURI(cur); |
| if (targetFile != null) { |
| return targetFile.toString(); |
| } |
| return null; |
| } |
| |
| private URI getJavaImplementationURI(EObject cur) { |
| GenClassifier gClass = null; |
| if (cur instanceof GenFeature) { |
| gClass = ((GenFeature) cur).getGenClass(); |
| } |
| if (cur instanceof GenEnumLiteral) { |
| gClass = ((GenEnumLiteral) cur).getGenEnum(); |
| } |
| if (cur instanceof GenClassifier) { |
| gClass = (GenClassifier) cur; |
| } |
| if (cur instanceof GenEnum) { |
| gClass = (GenClassifier) cur; |
| } |
| String className = ""; |
| if (gClass instanceof GenClass) { |
| className = ((GenClass) gClass).getClassName(); |
| } else if (gClass instanceof GenEnum) { |
| className = ((GenEnum) gClass).getClassifierInstanceName(); |
| } |
| |
| if (gClass != null && gClass.getGenPackage() != null) { |
| String packageName = gClass.getGenPackage().getClassPackageName(); |
| URI targetDirectory = URI.createURI(gClass.getGenPackage().getGenModel().getModelDirectory()) |
| .appendSegments(packageName.split("\\.")); |
| URI targetFile = targetDirectory.appendSegment(className + ".java"); |
| return targetFile; |
| } |
| return null; |
| } |
| |
| public String upperBoundDisplay(ETypedElement host) { |
| if (host.getUpperBound() == -1) { |
| return "*"; |
| } |
| return Integer.valueOf(host.getUpperBound()).toString(); |
| } |
| |
| public ETypedElement setUpperBound(ETypedElement host, String newValue) { |
| if ("*".equals(newValue)) { |
| host.setUpperBound(-1); |
| } else { |
| host.setUpperBound(Integer.valueOf(newValue)); |
| } |
| return host; |
| } |
| |
| public EObject eGetMonoRef(EObject cur, EStructuralFeature ref) { |
| return (EObject) cur.eGet(ref); |
| } |
| |
| public EObject moveUpInContainer(EObject cur) { |
| EObject container = cur.eContainer(); |
| if (container != null) { |
| EList<EObject> siblings = (EList<EObject>) container.eGet(cur.eContainingFeature()); |
| int oldPosition = siblings.indexOf(cur); |
| int newPosition = oldPosition - 1; |
| if (newPosition < 0) { |
| newPosition = 0; |
| } |
| siblings.move(newPosition, cur); |
| } |
| return cur; |
| } |
| |
| public EObject moveDownInContainer(EObject cur) { |
| EObject container = cur.eContainer(); |
| if (container != null) { |
| EList<EObject> siblings = (EList<EObject>) container.eGet(cur.eContainingFeature()); |
| int oldPosition = siblings.indexOf(cur); |
| int newPosition = oldPosition + 1; |
| if (newPosition > siblings.size() - 1) { |
| newPosition = siblings.size() - 1; |
| } |
| siblings.move(newPosition, cur); |
| } |
| return cur; |
| } |
| |
| public boolean isAccessible(String path) { |
| final boolean res; |
| |
| if (path != null) { |
| final IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(path)); |
| res = file.exists() && file.isAccessible(); |
| } else { |
| res = false; |
| } |
| |
| return res; |
| } |
| |
| public String selectIcon(String targetPath) { |
| final IFile targetFile = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(targetPath)); |
| final Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(); |
| |
| final FileDialog fileDialog = new FileDialog(shell, SWT.OPEN); |
| fileDialog.setText("Select icon"); |
| fileDialog.setFileName(targetFile.getLocation().toOSString()); |
| final String[] filterExt = { "*.gif", "*.png", "*.jpg", "*.jpeg" }; |
| fileDialog.setFilterExtensions(filterExt); |
| final String source = fileDialog.open(); |
| if (source != null) { |
| try { |
| Files.copy(new File(source).toPath(), targetFile.getLocation().toFile().toPath(), |
| StandardCopyOption.REPLACE_EXISTING); |
| targetFile.refreshLocal(IResource.DEPTH_INFINITE, null); |
| } catch (IOException | CoreException e) { |
| final String message = String.format("An error occurred while copying %s to %s", source, |
| targetFile.getLocation().toFile().toPath().toString()); |
| EcoreToolsDesignPlugin.getPlugin() |
| .log(new Status(IStatus.ERROR, EcoreToolsDesignPlugin.PLUGIN_ID, message, e)); |
| } |
| } |
| |
| removeImageFromCache(ExtendedImageRegistry.INSTANCE, targetFile.getLocation()); |
| |
| return targetPath; |
| } |
| |
| /** |
| * Removes the {@link Image} from the cache used by EEF2 to ensure loading of |
| * the new content. |
| * |
| * @param registry the {@link ExtendedImageRegistry} |
| * @param targetPath the image {@link IPath} |
| */ |
| private void removeImageFromCache(ExtendedImageRegistry registry, IPath targetPath) { |
| try { |
| final ImageDescriptor descriptor = ImageDescriptor |
| .createFromURL(targetPath.toFile().toURI().toURL()); |
| |
| for (Field field : registry.getClass().getDeclaredFields()) { |
| if ("table".equals(field.getName())) { |
| field.setAccessible(true); |
| @SuppressWarnings("unchecked") |
| final Map<Object, Image> table = (Map<Object, Image>) field.get(registry); |
| final Image image = table.remove(descriptor); |
| if (image != null) { |
| image.dispose(); |
| } |
| field.setAccessible(false); |
| break; |
| } |
| } |
| |
| } catch (MalformedURLException | IllegalArgumentException | IllegalAccessException e) { |
| EcoreToolsDesignPlugin.getPlugin() |
| .log(new Status(IStatus.ERROR, EcoreToolsDesignPlugin.PLUGIN_ID, "Couldn't reload icon.", e)); |
| } |
| } |
| |
| } |
