| /** | |
| * Copyright (c) 2000, 2009 IBM Corporation and others. | |
| * This program and the accompanying materials | |
| * are made available under the terms of the Eclipse Public License v2.0 | |
| * which accompanies this distribution, and is available at | |
| * https://www.eclipse.org/legal/epl-v2.0 | |
| * | |
| * SPDX-License-Identifier: EPL-2.0 | |
| * | |
| * Contributors: | |
| * IBM Corporation - initial API and implementation | |
| * Thales Corporate Services S.A.S | |
| */ | |
| package org.eclipse.egf.common.ui.helper; | |
| import java.lang.reflect.Method; | |
| import java.util.Collections; | |
| import java.util.Iterator; | |
| 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.Path; | |
| import org.eclipse.core.runtime.Platform; | |
| import org.eclipse.egf.common.ui.EGFCommonUIPlugin; | |
| import org.eclipse.emf.common.EMFPlugin; | |
| import org.eclipse.emf.common.ui.URIEditorInput; | |
| import org.eclipse.emf.common.util.URI; | |
| import org.eclipse.emf.ecore.EObject; | |
| import org.eclipse.emf.ecore.resource.Resource; | |
| import org.eclipse.emf.ecore.resource.URIConverter; | |
| import org.eclipse.emf.edit.domain.EditingDomain; | |
| import org.eclipse.emf.edit.domain.IEditingDomainProvider; | |
| import org.eclipse.ui.IEditorDescriptor; | |
| import org.eclipse.ui.IEditorInput; | |
| import org.eclipse.ui.IEditorPart; | |
| import org.eclipse.ui.IEditorReference; | |
| import org.eclipse.ui.IEditorRegistry; | |
| import org.eclipse.ui.IURIEditorInput; | |
| import org.eclipse.ui.IWorkbench; | |
| import org.eclipse.ui.IWorkbenchPage; | |
| import org.eclipse.ui.IWorkbenchWindow; | |
| import org.eclipse.ui.PartInitException; | |
| import org.eclipse.ui.PlatformUI; | |
| import org.eclipse.ui.editors.text.EditorsUI; | |
| import org.eclipse.ui.part.FileEditorInput; | |
| import org.osgi.framework.Bundle; | |
| public class EditorHelper { | |
| public static void setSelectionToViewer(IEditorPart part, List<EObject> eObjects) { | |
| // Do we have something to process | |
| if (eObjects == null || eObjects.size() == 0) { | |
| return; | |
| } | |
| // Select | |
| try { | |
| Class<?>[] types = new Class[] { | |
| Class.forName("java.util.Collection")}; //$NON-NLS-1$ | |
| Method method = part.getClass().getMethod("setSelectionToViewer", types); //$NON-NLS-1$ | |
| if (method != null) { | |
| Object[] params = new Object[] { | |
| eObjects | |
| }; | |
| method.invoke(part, params); | |
| } | |
| } catch (Throwable t) { | |
| ThrowableHandler.handleThrowable(EGFCommonUIPlugin.getDefault().getPluginID(), t); | |
| } | |
| } | |
| public static void setSelectionToViewer(IEditorPart part, URI uri) { | |
| // Do we have something to process | |
| if (uri == null || uri.hasFragment() == false) { | |
| return; | |
| } | |
| // Whether or not could we have an EditingDomain | |
| if (part == null || part instanceof IEditingDomainProvider == false) { | |
| return; | |
| } | |
| EditingDomain editingDomain = ((IEditingDomainProvider) part).getEditingDomain(); | |
| // Process URI | |
| EObject eObject = editingDomain.getResourceSet().getEObject(uri, true); | |
| if (eObject == null) { | |
| return; | |
| } | |
| // Select | |
| try { | |
| Class<?>[] types = new Class[] { | |
| Class.forName("java.util.Collection")}; //$NON-NLS-1$ | |
| Method method = part.getClass().getMethod("setSelectionToViewer", types); //$NON-NLS-1$ | |
| if (method != null) { | |
| Object[] params = new Object[] { | |
| Collections.singletonList(eObject) | |
| }; | |
| method.invoke(part, params); | |
| } | |
| } catch (Throwable t) { | |
| // Nothing to do | |
| } | |
| } | |
| public static void openEditorsAndSelect(Map<Resource, List<EObject>> resources) { | |
| // is there something to select | |
| if (resources.isEmpty()) { | |
| return; | |
| } | |
| for (Iterator<Map.Entry<Resource, List<EObject>>> it = resources.entrySet().iterator(); it.hasNext();) { | |
| try { | |
| Map.Entry<Resource, List<EObject>> entry = it.next(); | |
| // Try to use a URIConverter to normalize such URI | |
| // if we have a platform:/plugin/ we need a platform:/resource/ if any | |
| // to have a chance to use a FileEditorInput rather than an URIEditorInput | |
| Resource resource = entry.getKey(); | |
| URI uri = resource.getURI(); | |
| if (uri != null && resource.getResourceSet() != null) { | |
| URIConverter converter = resource.getResourceSet().getURIConverter(); | |
| if (converter != null) { | |
| uri = converter.normalize(uri); | |
| } | |
| } | |
| IEditorPart editorPart = openEditor(uri); | |
| if (editorPart != null) { | |
| setSelectionToViewer(editorPart, entry.getValue()); | |
| } | |
| } catch (Throwable t) { | |
| ThrowableHandler.handleThrowable(EGFCommonUIPlugin.getDefault().getPluginID(), t); | |
| } | |
| } | |
| } | |
| public static String computeEditorId(String fileName) { | |
| IWorkbench workbench = PlatformUI.getWorkbench(); | |
| IEditorRegistry editorRegistry = workbench.getEditorRegistry(); | |
| IEditorDescriptor descriptor = editorRegistry.getDefaultEditor(fileName); | |
| if (descriptor != null) { | |
| return descriptor.getId(); | |
| } | |
| return EditorsUI.DEFAULT_TEXT_EDITOR_ID; | |
| } | |
| public static IEditorInput getEditorInput(URI uri) { | |
| if (uri == null || uri.isEmpty() || "//#".equals(uri)) { //$NON-NLS-1$ | |
| return null; | |
| } | |
| if (uri.isPlatformResource()) { | |
| String path = uri.toPlatformString(true); | |
| IResource resource = ResourcesPlugin.getWorkspace().getRoot().findMember(new Path(path)); | |
| if (resource instanceof IFile) { | |
| return EclipseUtil.createFileEditorInput((IFile) resource); | |
| } | |
| } | |
| return new URIEditorInput(uri.trimFragment()); | |
| } | |
| /** | |
| * Opens the default editor for the resource that contains the specified | |
| * EObject. | |
| */ | |
| public static IEditorPart openEditor(URI uri) throws PartInitException { | |
| if (uri == null) { | |
| return null; | |
| } | |
| IEditorPart part = restoreAlreadyOpenedEditor(uri, null, true); | |
| if (part != null) { | |
| return part; | |
| } | |
| IEditorInput editorInput = null; | |
| if (uri.isPlatformResource()) { | |
| String path = uri.toPlatformString(true); | |
| IResource resource = ResourcesPlugin.getWorkspace().getRoot().findMember(new Path(path)); | |
| if (resource instanceof IFile) { | |
| editorInput = EclipseUtil.createFileEditorInput((IFile) resource); | |
| return openEditor(editorInput, URI.createPlatformPluginURI(resource.getFullPath().toString(), false)); | |
| } | |
| } | |
| return openEditor(new URIEditorInput(uri.trimFragment()), uri); | |
| } | |
| /** | |
| * Opens the default editor for the resource that contains the specified | |
| * EObject. | |
| */ | |
| public static IEditorPart openEditor(URI uri, String editorId) throws PartInitException { | |
| if (uri == null) { | |
| return null; | |
| } | |
| IEditorPart part = restoreAlreadyOpenedEditor(uri, editorId, true); | |
| if (part != null) { | |
| return part; | |
| } | |
| IEditorInput editorInput = null; | |
| if (uri.isPlatformResource()) { | |
| String path = uri.toPlatformString(true); | |
| IResource resource = ResourcesPlugin.getWorkspace().getRoot().findMember(new Path(path)); | |
| if (resource instanceof IFile) { | |
| editorInput = EclipseUtil.createFileEditorInput((IFile) resource); | |
| return openEditor(editorInput, URI.createPlatformPluginURI(resource.getFullPath().toString(), false), editorId); | |
| } | |
| } | |
| return openEditor(new URIEditorInput(uri.trimFragment()), uri, editorId); | |
| } | |
| public static IEditorPart openEditor(IEditorInput input, URI uri) throws PartInitException { | |
| return openEditor(input, uri, null); | |
| } | |
| public static IEditorPart openEditor(IEditorInput input, URI uri, String editorId) throws PartInitException { | |
| if (input == null || uri == null) { | |
| return null; | |
| } | |
| IEditorPart part = restoreAlreadyOpenedEditor(uri, editorId, true); | |
| if (part != null) { | |
| return part; | |
| } | |
| IWorkbench workbench = PlatformUI.getWorkbench(); | |
| IWorkbenchPage page = workbench.getActiveWorkbenchWindow().getActivePage(); | |
| return page.openEditor(input, editorId != null ? editorId : computeEditorId(uri.trimFragment().lastSegment()), true, IWorkbenchPage.MATCH_NONE); | |
| } | |
| public static boolean isAlreadyOpenedEditor(URI uri) { | |
| if (uri == null) { | |
| return false; | |
| } | |
| return restoreAlreadyOpenedEditor(uri, null, false) != null ? true : false; | |
| } | |
| private static IEditorPart restoreAlreadyOpenedEditor(URI uri, String editorId, boolean activate) { | |
| if (uri == null) { | |
| return null; | |
| } | |
| URI uriToCheck = uri.trimFragment(); | |
| IWorkbench workbench = PlatformUI.getWorkbench(); | |
| if (workbench == null) { | |
| return null; | |
| } | |
| for (IWorkbenchWindow window : workbench.getWorkbenchWindows()) { | |
| for (IWorkbenchPage innerPage : window.getPages()) { | |
| for (IEditorReference reference : innerPage.getEditorReferences()) { | |
| try { | |
| IEditorInput editorInput = reference.getEditorInput(); | |
| if (editorInput != null) { | |
| URI editorInputURI = EditorHelper.getURI(editorInput); | |
| if (editorInputURI != null && editorInputURI.equals(uriToCheck)) { | |
| IEditorPart part = reference.getEditor(true); | |
| if (editorId != null && editorId.equals(part.getEditorSite().getId()) == false) { | |
| continue; | |
| } | |
| if (activate) { | |
| window.setActivePage(innerPage); | |
| innerPage.activate(part); | |
| part.setFocus(); | |
| } | |
| return part; | |
| } | |
| } | |
| } catch (PartInitException pie) { | |
| // Just Ignore | |
| } | |
| } | |
| } | |
| } | |
| return null; | |
| } | |
| public static URI getURI(IEditorInput editorInput) { | |
| URI result = null; | |
| if (EMFPlugin.IS_ECLIPSE_RUNNING) { | |
| result = EclipseUtil.getURI(editorInput); | |
| } | |
| if (result == null) { | |
| if (editorInput instanceof URIEditorInput) { | |
| result = ((URIEditorInput) editorInput).getURI().trimFragment(); | |
| } else { | |
| result = URI.createURI(editorInput.getName()); | |
| } | |
| } | |
| return result; | |
| } | |
| public static class EclipseUtil { | |
| static final Class<?> FILE_CLASS; | |
| static { | |
| Class<?> fileClass = null; | |
| try { | |
| fileClass = IFile.class; | |
| } catch (Throwable exception) { | |
| // Ignore any exceptions and assume the class isn't available. | |
| } | |
| FILE_CLASS = fileClass; | |
| } | |
| static final Class<?> FILE_REVISION_CLASS; | |
| static final Method FILE_REVISION_GET_URI_METHOD; | |
| static { | |
| Class<?> fileRevisionClass = null; | |
| Method fileRevisionGetURIMethod = null; | |
| Bundle bundle = Platform.getBundle("org.eclipse.team.core"); //$NON-NLS-1$ | |
| if (bundle != null && (bundle.getState() & (Bundle.ACTIVE | Bundle.STARTING | Bundle.RESOLVED)) != 0) { | |
| try { | |
| fileRevisionClass = bundle.loadClass("org.eclipse.team.core.history.IFileRevision"); //$NON-NLS-1$ | |
| fileRevisionGetURIMethod = fileRevisionClass.getMethod("getURI"); //$NON-NLS-1$ | |
| } catch (Throwable exeption) { | |
| // Ignore any exceptions and assume the class isn't available. | |
| } | |
| } | |
| FILE_REVISION_CLASS = fileRevisionClass; | |
| FILE_REVISION_GET_URI_METHOD = fileRevisionGetURIMethod; | |
| } | |
| static final Class<?> URI_EDITOR_INPUT_CLASS; | |
| static { | |
| Class<?> uriEditorInputClass = null; | |
| try { | |
| uriEditorInputClass = IURIEditorInput.class; | |
| } catch (Throwable exception) { | |
| // The class is not available. | |
| } | |
| URI_EDITOR_INPUT_CLASS = uriEditorInputClass; | |
| } | |
| public static URI getURI(IEditorInput editorInput) { | |
| if (FILE_CLASS != null) { | |
| IFile file = getIFile(editorInput); | |
| if (file != null) { | |
| return URI.createPlatformPluginURI(file.getFullPath().toString(), false); | |
| } | |
| } | |
| if (FILE_REVISION_CLASS != null) { | |
| Object fileRevision = editorInput.getAdapter(FILE_REVISION_CLASS); | |
| if (fileRevision != null) { | |
| try { | |
| return URI.createURI(((java.net.URI) FILE_REVISION_GET_URI_METHOD.invoke(fileRevision)).toString()); | |
| } catch (Throwable t) { | |
| EGFCommonUIPlugin.getDefault().logError(t); | |
| } | |
| } | |
| } | |
| if (URI_EDITOR_INPUT_CLASS != null) { | |
| if (editorInput instanceof IURIEditorInput) { | |
| return URI.createURI(((IURIEditorInput) editorInput).getURI().toString()).trimFragment(); | |
| } | |
| } | |
| return null; | |
| } | |
| public static IFile getIFile(IEditorInput editorInput) { | |
| if (FILE_CLASS != null) { | |
| return (IFile) editorInput.getAdapter(FILE_CLASS); | |
| } | |
| return null; | |
| } | |
| public static IURIEditorInput createFileEditorInput(IFile file) { | |
| return new FileEditorInput(file); | |
| } | |
| } | |
| } |