| /** |
| * Copyright (c) 2009-2010 Thales Corporate Services S.A.S. |
| * 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: |
| * Thales Corporate Services S.A.S - initial API and implementation |
| */ |
| package org.eclipse.egf.model.fcore.presentation; |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.lang.reflect.InvocationTargetException; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Iterator; |
| import java.util.LinkedHashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.eclipse.core.commands.operations.IOperationHistory; |
| import org.eclipse.core.commands.operations.IOperationHistoryListener; |
| import org.eclipse.core.commands.operations.IUndoContext; |
| import org.eclipse.core.commands.operations.IUndoableOperation; |
| import org.eclipse.core.commands.operations.ObjectUndoContext; |
| import org.eclipse.core.commands.operations.OperationHistoryEvent; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IMarker; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.Assert; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.egf.common.ui.helper.EditorHelper; |
| import org.eclipse.egf.common.ui.helper.ThrowableHandler; |
| import org.eclipse.egf.core.EGFCorePlugin; |
| import org.eclipse.egf.core.domain.PlatformResourceLoadedListener; |
| import org.eclipse.egf.core.domain.PlatformResourceLoadedListener.ResourceListener; |
| import org.eclipse.egf.core.domain.PlatformResourceLoadedListener.ResourceUser; |
| import org.eclipse.egf.core.helper.ResourceHelper; |
| import org.eclipse.egf.core.platform.EGFPlatformPlugin; |
| import org.eclipse.egf.core.ui.EGFCoreUIPlugin; |
| import org.eclipse.egf.core.ui.contributor.EditorListenerContributor; |
| import org.eclipse.egf.core.ui.l10n.CoreUIMessages; |
| import org.eclipse.egf.model.editor.EGFModelEditorPlugin; |
| import org.eclipse.egf.model.editor.adapter.ModelElementBundleAdapter; |
| import org.eclipse.egf.model.editor.provider.FcoreContentProvider; |
| import org.eclipse.egf.model.editor.provider.FcorePropertySheetPage; |
| import org.eclipse.egf.model.fcore.provider.FcoreCustomItemProviderAdapterFactory; |
| import org.eclipse.egf.model.fcore.provider.FcoreResourceItemProviderAdapterFactory; |
| import org.eclipse.egf.model.fprod.provider.FprodCustomItemProviderAdapterFactory; |
| import org.eclipse.egf.model.pattern.provider.PatternCustomItemProviderAdapterFactory; |
| import org.eclipse.emf.common.command.BasicCommandStack; |
| import org.eclipse.emf.common.command.Command; |
| import org.eclipse.emf.common.notify.AdapterFactory; |
| import org.eclipse.emf.common.notify.Notification; |
| import org.eclipse.emf.common.ui.MarkerHelper; |
| import org.eclipse.emf.common.ui.URIEditorInput; |
| import org.eclipse.emf.common.ui.ViewerPane; |
| import org.eclipse.emf.common.ui.editor.ProblemEditorPart; |
| import org.eclipse.emf.common.ui.viewer.IViewerProvider; |
| import org.eclipse.emf.common.util.BasicDiagnostic; |
| import org.eclipse.emf.common.util.Diagnostic; |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.common.util.UniqueEList; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EValidator; |
| import org.eclipse.emf.ecore.InternalEObject; |
| import org.eclipse.emf.ecore.impl.ENotificationImpl; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.util.EContentAdapter; |
| import org.eclipse.emf.ecore.util.EcoreUtil; |
| import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain; |
| import org.eclipse.emf.edit.domain.IEditingDomainProvider; |
| import org.eclipse.emf.edit.provider.AdapterFactoryItemDelegator; |
| import org.eclipse.emf.edit.provider.ComposedAdapterFactory; |
| import org.eclipse.emf.edit.provider.ReflectiveItemProviderAdapterFactory; |
| import org.eclipse.emf.edit.provider.ViewerNotification; |
| import org.eclipse.emf.edit.ui.action.EditingDomainActionBarContributor; |
| import org.eclipse.emf.edit.ui.celleditor.AdapterFactoryTreeEditor; |
| import org.eclipse.emf.edit.ui.dnd.EditingDomainViewerDropAdapter; |
| import org.eclipse.emf.edit.ui.dnd.LocalTransfer; |
| import org.eclipse.emf.edit.ui.dnd.ViewerDragAdapter; |
| import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider.ViewerRefresh; |
| import org.eclipse.emf.edit.ui.provider.UnwrappingSelectionProvider; |
| import org.eclipse.emf.edit.ui.util.EditUIMarkerHelper; |
| import org.eclipse.emf.transaction.TransactionalEditingDomain; |
| import org.eclipse.emf.transaction.ui.provider.TransactionalAdapterFactoryContentProvider; |
| import org.eclipse.emf.transaction.ui.provider.TransactionalAdapterFactoryLabelProvider; |
| import org.eclipse.emf.workspace.EMFCommandOperation; |
| import org.eclipse.emf.workspace.IWorkspaceCommandStack; |
| import org.eclipse.emf.workspace.ResourceUndoContext; |
| import org.eclipse.jface.action.IMenuListener; |
| import org.eclipse.jface.action.IMenuManager; |
| import org.eclipse.jface.action.IStatusLineManager; |
| import org.eclipse.jface.action.IToolBarManager; |
| import org.eclipse.jface.action.MenuManager; |
| import org.eclipse.jface.action.Separator; |
| import org.eclipse.jface.dialogs.MessageDialog; |
| import org.eclipse.jface.dialogs.ProgressMonitorDialog; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.ISelectionChangedListener; |
| import org.eclipse.jface.viewers.ISelectionProvider; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.SelectionChangedEvent; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.jface.viewers.StructuredViewer; |
| import org.eclipse.jface.viewers.TreeViewer; |
| import org.eclipse.jface.viewers.Viewer; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.custom.CTabFolder; |
| import org.eclipse.swt.dnd.DND; |
| import org.eclipse.swt.dnd.Transfer; |
| import org.eclipse.swt.events.ControlAdapter; |
| import org.eclipse.swt.events.ControlEvent; |
| import org.eclipse.swt.graphics.Point; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Menu; |
| import org.eclipse.swt.widgets.Tree; |
| import org.eclipse.ui.IActionBars; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IEditorSite; |
| import org.eclipse.ui.IPartListener; |
| import org.eclipse.ui.IWorkbenchPart; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.actions.WorkspaceModifyOperation; |
| import org.eclipse.ui.dialogs.SaveAsDialog; |
| import org.eclipse.ui.ide.IGotoMarker; |
| import org.eclipse.ui.part.FileEditorInput; |
| import org.eclipse.ui.part.MultiPageEditorPart; |
| import org.eclipse.ui.views.contentoutline.ContentOutline; |
| import org.eclipse.ui.views.contentoutline.ContentOutlinePage; |
| import org.eclipse.ui.views.contentoutline.IContentOutlinePage; |
| import org.eclipse.ui.views.properties.IPropertySheetPage; |
| import org.eclipse.ui.views.properties.PropertySheet; |
| import org.eclipse.ui.views.properties.PropertySheetPage; |
| |
| /** |
| * This is an example of a Fcore model editor. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public class FcoreEditor extends MultiPageEditorPart implements ResourceUser, ResourceListener, IEditingDomainProvider, ISelectionProvider, IMenuListener, IViewerProvider, IGotoMarker { |
| |
| public static String ID = "org.eclipse.egf.model.fcore.presentation.fcore.editor.id"; //$NON-NLS-1$ |
| |
| /** |
| * This keeps track of the editing domain that is used to track all changes |
| * to the model. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| protected AdapterFactoryEditingDomain editingDomain; |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| protected ObjectUndoContext undoContext; |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| protected Resource resource; |
| |
| /** |
| * This is the one adapter factory used for providing views of the model. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| protected ComposedAdapterFactory adapterFactory; |
| |
| /** |
| * This is the one adapter factory used for properties. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| protected ComposedAdapterFactory propertyAdapterFactory; |
| |
| /** |
| * This is the content outline page. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| protected IContentOutlinePage contentOutlinePage; |
| |
| /** |
| * This is a kludge... |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| protected IStatusLineManager contentOutlineStatusLineManager; |
| |
| /** |
| * This is the content outline page's viewer. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| protected TreeViewer contentOutlineViewer; |
| |
| /** |
| * This is the property sheet page. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| protected PropertySheetPage propertySheetPage; |
| |
| /** |
| * This is the viewer that shadows the selection in the content outline. |
| * The parent relation must be correctly defined for this to work. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| protected TreeViewer selectionViewer; |
| |
| /** |
| * This keeps track of the active viewer pane |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| protected ViewerPane currentViewerPane; |
| |
| /** |
| * This keeps track of the active content viewer, which may be either one of the viewers in the pages or the content outline viewer. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| protected Viewer currentViewer; |
| |
| /** |
| * This listens to which ever viewer is active. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| protected ISelectionChangedListener selectionChangedListener; |
| |
| /** |
| * This keeps track of all the {@link org.eclipse.jface.viewers.ISelectionChangedListener}s that |
| * are listening to this editor. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| protected Collection<ISelectionChangedListener> selectionChangedListeners = new ArrayList<ISelectionChangedListener>(); |
| |
| /** |
| * This keeps track of the selection of the editor as a whole. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| protected ISelection editorSelection = StructuredSelection.EMPTY; |
| |
| /** |
| * The MarkerHelper is responsible for creating workspace resource markers |
| * presented |
| * in Eclipse's Problems View. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| protected MarkerHelper markerHelper = new EditUIMarkerHelper(); |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| protected ViewerRefresh viewerRefresh; |
| |
| /** |
| * This listens for when the outline becomes active |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| protected IPartListener partListener = new IPartListener() { |
| |
| public void partActivated(IWorkbenchPart p) { |
| if (p instanceof ContentOutline) { |
| if (((ContentOutline) p).getCurrentPage() == contentOutlinePage) { |
| getActionBarContributor().setActiveEditor(FcoreEditor.this); |
| setCurrentViewer(contentOutlineViewer); |
| } |
| } else if (p instanceof PropertySheet) { |
| if (((PropertySheet) p).getCurrentPage() == propertySheetPage) { |
| getActionBarContributor().setActiveEditor(FcoreEditor.this); |
| handleActivate(); |
| } |
| } else if (p == FcoreEditor.this) { |
| handleActivate(); |
| } |
| } |
| |
| public void partBroughtToTop(IWorkbenchPart p) { |
| // Nothing to do |
| } |
| |
| public void partClosed(IWorkbenchPart p) { |
| // Nothing to do |
| } |
| |
| public void partDeactivated(IWorkbenchPart p) { |
| // Nothing to do |
| } |
| |
| public void partOpened(IWorkbenchPart p) { |
| // Nothing to do |
| } |
| |
| }; |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public ObjectUndoContext getUndoContext() { |
| return undoContext; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| private IOperationHistoryListener historyListener = new IOperationHistoryListener() { |
| |
| public void historyNotification(final OperationHistoryEvent event) { |
| Set<Resource> affectedResources = ResourceUndoContext.getAffectedResources(event.getOperation()); |
| switch (event.getEventType()) { |
| case OperationHistoryEvent.DONE: |
| if (affectedResources.contains(getResource())) { |
| final IUndoableOperation operation = event.getOperation(); |
| // remove the default undo context so that we can have |
| // independent undo/redo of independent resource changes |
| operation.removeContext(((IWorkspaceCommandStack) getEditingDomain().getCommandStack()).getDefaultUndoContext()); |
| // add our undo context to populate our undo menu |
| operation.addContext(getUndoContext()); |
| getSite().getShell().getDisplay().asyncExec(new Runnable() { |
| |
| public void run() { |
| firePropertyChange(IEditorPart.PROP_DIRTY); |
| // Try to select the affected objects. |
| if (operation instanceof EMFCommandOperation) { |
| Command command = ((EMFCommandOperation) operation).getCommand(); |
| if (command != null) { |
| setSelectionToViewer(command.getAffectedObjects()); |
| } |
| } |
| if (propertySheetPage != null) { |
| propertySheetPage.refresh(); |
| } |
| } |
| }); |
| } |
| break; |
| case OperationHistoryEvent.UNDONE: |
| case OperationHistoryEvent.REDONE: |
| if (affectedResources.contains(getResource())) { |
| final IUndoableOperation operation = event.getOperation(); |
| getSite().getShell().getDisplay().asyncExec(new Runnable() { |
| |
| public void run() { |
| firePropertyChange(IEditorPart.PROP_DIRTY); |
| // Try to select the affected objects. |
| if (operation instanceof EMFCommandOperation) { |
| Command command = ((EMFCommandOperation) operation).getCommand(); |
| if (command != null) { |
| setSelectionToViewer(command.getAffectedObjects()); |
| } |
| } |
| if (propertySheetPage != null) { |
| propertySheetPage.refresh(); |
| } |
| } |
| }); |
| } |
| break; |
| } |
| } |
| }; |
| |
| /** |
| * Whether or not this resource has been removed |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| protected boolean resourceHasBeenRemoved; |
| |
| /** |
| * Whether or not this resource has been externally changed |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| protected boolean resourceHasBeenExternallyChanged; |
| |
| /** |
| * Whether or not user saved this resource in this editor |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| protected boolean userHasSavedResource; |
| |
| /** |
| * Map to store the diagnostic associated with a resource. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| protected Map<URI, Diagnostic> resourceToDiagnosticMap = new LinkedHashMap<URI, Diagnostic>(); |
| |
| /** |
| * Controls whether the problem indication should be updated. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| protected boolean updateProblemIndication = true; |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| protected List<EContentAdapter> egfAdapters = new UniqueEList<EContentAdapter>(); |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| private boolean tabFolderGuard = false; |
| |
| /** |
| * Adapter used to update the problem indication when resources are demanded |
| * loaded. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| protected EContentAdapter editorResourceAdapter = new EContentAdapter() { |
| |
| @Override |
| public void notifyChanged(Notification notification) { |
| // Process Resource |
| if (notification.getNotifier() instanceof Resource) { |
| switch (notification.getFeatureID(Resource.class)) { |
| case Resource.RESOURCE__IS_LOADED: |
| case Resource.RESOURCE__ERRORS: |
| case Resource.RESOURCE__WARNINGS: { |
| // Problem |
| final Resource innerResource = (Resource) notification.getNotifier(); |
| if (innerResource == getResource() || ResourceHelper.hasURIProxyReferences(getResource(), innerResource.getURI())) { |
| Diagnostic diagnostic = ResourceHelper.analyzeResourceProblems(innerResource, null, ID); |
| if (diagnostic.getSeverity() != Diagnostic.OK) { |
| resourceToDiagnosticMap.put(innerResource.getURI(), diagnostic); |
| } else { |
| resourceToDiagnosticMap.remove(innerResource.getURI()); |
| } |
| // Try to refresh proxy owners |
| if (innerResource != getResource()) { |
| if (selectionViewer != null && selectionViewer.getControl() != null && selectionViewer.getControl().isDisposed() == false && selectionViewer.isBusy() == false) { |
| final List<EObject> owners = ResourceHelper.getURIProxyReferenceOwners(getResource(), innerResource.getURI()); |
| if (owners != null && owners.isEmpty() == false) { |
| if (viewerRefresh == null) { |
| viewerRefresh = new ViewerRefresh(selectionViewer); |
| } |
| for (EObject eObject : owners) { |
| Notification ownerNotification = new ENotificationImpl((InternalEObject) eObject, Notification.RESOLVE, null, eObject, eObject); |
| viewerRefresh.addNotification(new ViewerNotification(ownerNotification, ownerNotification.getNotifier(), true, true)); |
| } |
| selectionViewer.getControl().getDisplay().asyncExec(viewerRefresh); |
| } |
| } |
| } |
| // Display any trouble |
| if (updateProblemIndication) { |
| getSite().getShell().getDisplay().asyncExec(new Runnable() { |
| |
| public void run() { |
| updateProblemIndication(); |
| } |
| }); |
| } |
| } |
| break; |
| } |
| case Resource.RESOURCE__URI: { |
| getSite().getShell().getDisplay().asyncExec(new Runnable() { |
| |
| public void run() { |
| firePropertyChange(IEditorPart.PROP_DIRTY); |
| } |
| }); |
| break; |
| } |
| } |
| } else { |
| super.notifyChanged(notification); |
| } |
| } |
| |
| @Override |
| protected void setTarget(Resource innerTarget) { |
| basicSetTarget(innerTarget); |
| } |
| |
| @Override |
| protected void unsetTarget(Resource innerTarget) { |
| basicUnsetTarget(innerTarget); |
| } |
| |
| }; |
| |
| /** |
| * Handles activation of the editor or it's associated views. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| protected void handleActivate() { |
| setCurrentViewer(selectionViewer); |
| // Recompute the read only state. |
| if (editingDomain.getResourceToReadOnlyMap() != null) { |
| editingDomain.getResourceToReadOnlyMap().clear(); |
| // Refresh any actions that may become enabled or disabled. |
| setSelection(getSelection()); |
| } |
| if (resourceHasBeenRemoved) { |
| getSite().getShell().getDisplay().asyncExec(new Runnable() { |
| |
| public void run() { |
| if (isDirty() == false || handleDirtyConflict()) { |
| getSite().getPage().closeEditor(FcoreEditor.this, false); |
| } |
| } |
| |
| }); |
| } else if (resourceHasBeenExternallyChanged) { |
| handleChangedResource(); |
| } |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public void resourceMoved(final Resource movedResource, final URI oldURI) { |
| if (movedResource == getResource()) { |
| resourceHasBeenExternallyChanged = false; |
| resourceHasBeenRemoved = false; |
| userHasSavedResource = false; |
| if (currentViewerPane != null && currentViewerPane.getControl().isDisposed() == false) { |
| getSite().getShell().getDisplay().asyncExec(new Runnable() { |
| |
| public void run() { |
| if (AdapterFactoryEditingDomain.isStale(editorSelection)) { |
| setSelection(StructuredSelection.EMPTY); |
| } |
| selectionViewer.setSelection(new StructuredSelection(movedResource), true); |
| if (currentViewerPane != null && currentViewerPane.getControl().isDisposed() == false) { |
| currentViewerPane.setTitle(movedResource); |
| } |
| setPartName(movedResource.getURI().lastSegment()); |
| setInputWithNotify(EditorHelper.getEditorInput(editingDomain.getResourceSet().getURIConverter().normalize(movedResource.getURI()))); |
| firePropertyChange(PROP_TITLE); |
| } |
| |
| }); |
| } |
| } |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public void resourceDeleted(final Resource deletedResource) { |
| // Handle current resource |
| if (deletedResource == getResource()) { |
| if (isDirty() == false) { |
| // just close now without prompt |
| getSite().getShell().getDisplay().asyncExec(new Runnable() { |
| |
| public void run() { |
| getSite().getPage().closeEditor(FcoreEditor.this, false); |
| } |
| |
| }); |
| return; |
| } |
| // Dirty editor with a deleted resource |
| resourceHasBeenRemoved = true; |
| } |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public void resourceReloaded(final Resource reloadedResource) { |
| if (reloadedResource == getResource()) { |
| resourceHasBeenExternallyChanged = false; |
| resourceHasBeenRemoved = false; |
| userHasSavedResource = false; |
| getSite().getShell().getDisplay().asyncExec(new Runnable() { |
| |
| public void run() { |
| if (AdapterFactoryEditingDomain.isStale(editorSelection)) { |
| setSelection(StructuredSelection.EMPTY); |
| } |
| getOperationHistory().dispose(undoContext, true, true, true); |
| selectionViewer.setInput(reloadedResource); |
| selectionViewer.setSelection(new StructuredSelection(reloadedResource), true); |
| if (currentViewerPane != null) { |
| currentViewerPane.setTitle(reloadedResource); |
| } |
| updateProblemIndication = true; |
| setInputWithNotify(new URIEditorInput(reloadedResource.getURI())); |
| firePropertyChange(PROP_TITLE); |
| } |
| |
| }); |
| } |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public boolean userHasSavedResource() { |
| return userHasSavedResource; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public boolean resourceHasBeenExternallyChanged() { |
| return resourceHasBeenExternallyChanged; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public void externalUpdate(final Resource changedResource) { |
| if (changedResource == getResource()) { |
| resourceHasBeenExternallyChanged = true; |
| } |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public void internalUpdate(final Resource changedResource) { |
| if (changedResource == getResource()) { |
| resourceHasBeenExternallyChanged = false; |
| resourceHasBeenRemoved = false; |
| userHasSavedResource = false; |
| } |
| getSite().getShell().getDisplay().asyncExec(new Runnable() { |
| |
| public void run() { |
| firePropertyChange(IEditorPart.PROP_DIRTY); |
| } |
| |
| }); |
| } |
| |
| /** |
| * Handles what to do with changed resource on activation. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| protected void handleChangedResource() { |
| if (isDirty() == false || handleDirtyConflict()) { |
| PlatformResourceLoadedListener.getResourceManager().reloadResource(getResource()); |
| } |
| } |
| |
| /** |
| * Updates the problems indication with the information described in the |
| * specified diagnostic. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| protected void updateProblemIndication() { |
| if (updateProblemIndication) { |
| BasicDiagnostic diagnostic = new BasicDiagnostic(Diagnostic.OK, ID, 0, null, new Object[] { |
| getResource() |
| }); |
| for (URI uri : resourceToDiagnosticMap.keySet()) { |
| Diagnostic childDiagnostic = resourceToDiagnosticMap.get(uri); |
| if (childDiagnostic.getSeverity() != Diagnostic.OK) { |
| diagnostic.add(childDiagnostic); |
| } |
| } |
| int lastEditorPage = getPageCount() - 1; |
| if (lastEditorPage >= 0 && getEditor(lastEditorPage) instanceof ProblemEditorPart) { |
| ((ProblemEditorPart) getEditor(lastEditorPage)).setDiagnostic(diagnostic); |
| if (diagnostic.getSeverity() != Diagnostic.OK) { |
| setActivePage(lastEditorPage); |
| } else { |
| removePage(lastEditorPage); |
| setActivePage(0); |
| if (tabFolderGuard == false) { |
| tabFolderGuard = true; |
| hideTabs(); |
| tabFolderGuard = false; |
| } |
| } |
| } else if (diagnostic.getSeverity() != Diagnostic.OK) { |
| ProblemEditorPart problemEditorPart = new ProblemEditorPart(); |
| problemEditorPart.setDiagnostic(diagnostic); |
| problemEditorPart.setMarkerHelper(markerHelper); |
| try { |
| addPage(++lastEditorPage, problemEditorPart, getEditorInput()); |
| setPageText(lastEditorPage, problemEditorPart.getPartName()); |
| setActivePage(lastEditorPage); |
| showTabs(); |
| } catch (PartInitException exception) { |
| EGFModelEditorPlugin.INSTANCE.log(exception); |
| } |
| } |
| if (getResource() != null && getResource().getResourceSet() != null) { |
| if (markerHelper.hasMarkers(getResource())) { |
| markerHelper.deleteMarkers(getResource()); |
| if (diagnostic.getSeverity() != Diagnostic.OK) { |
| try { |
| markerHelper.createMarkers(diagnostic); |
| } catch (CoreException exception) { |
| EGFModelEditorPlugin.INSTANCE.log(exception); |
| } |
| } |
| } |
| } |
| |
| } |
| } |
| |
| /** |
| * Shows a dialog that asks if conflicting changes should be discarded. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| protected boolean handleDirtyConflict() { |
| return MessageDialog.openQuestion(getSite().getShell(), CoreUIMessages._UI_FileConflict_label, CoreUIMessages._WARN_FileConflict); |
| } |
| |
| /** |
| * This creates a model editor. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public FcoreEditor() { |
| super(); |
| initializeEditingDomain(); |
| } |
| |
| /** |
| * This sets up the editing domain for the model editor. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| protected void initializeEditingDomain() { |
| // Create an adapter factory that yields item providers. |
| adapterFactory = new ComposedAdapterFactory(ComposedAdapterFactory.Descriptor.Registry.INSTANCE); |
| adapterFactory.addAdapterFactory(new FcoreResourceItemProviderAdapterFactory()); |
| adapterFactory.addAdapterFactory(new ReflectiveItemProviderAdapterFactory()); |
| // Create an adapter factory that yields item providers for properties. |
| propertyAdapterFactory = new ComposedAdapterFactory(ComposedAdapterFactory.Descriptor.Registry.INSTANCE); |
| propertyAdapterFactory.addAdapterFactory(new FcoreResourceItemProviderAdapterFactory()); |
| propertyAdapterFactory.addAdapterFactory(new FprodCustomItemProviderAdapterFactory()); |
| propertyAdapterFactory.addAdapterFactory(new FcoreCustomItemProviderAdapterFactory()); |
| propertyAdapterFactory.addAdapterFactory(new PatternCustomItemProviderAdapterFactory()); |
| propertyAdapterFactory.addAdapterFactory(new ReflectiveItemProviderAdapterFactory()); |
| // Get the registered TransactionalEditingDomain |
| editingDomain = (AdapterFactoryEditingDomain) TransactionalEditingDomain.Registry.INSTANCE.getEditingDomain(EGFCorePlugin.EDITING_DOMAIN_ID); |
| // Create an UndoContext |
| undoContext = new ObjectUndoContext(this, EGFModelEditorPlugin.getPlugin().getString("_UI_FcoreEditor_label")); //$NON-NLS-1$ |
| // add an history listener |
| getOperationHistory().addOperationHistoryListener(historyListener); |
| } |
| |
| /** |
| * This is here for the listener to be able to call it. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| @Override |
| protected void firePropertyChange(int action) { |
| super.firePropertyChange(action); |
| } |
| |
| /** |
| * This sets the selection into whichever viewer is active. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public void setSelectionToViewer(Collection<?> collection) { |
| if (collection == null || collection.isEmpty()) { |
| return; |
| } |
| final Collection<EObject> selection = new UniqueEList<EObject>(collection.size()); |
| // Solve EObject against our resource set |
| for (Object object : collection) { |
| if (object instanceof EObject == false) { |
| continue; |
| } |
| URI uri = null; |
| try { |
| uri = EcoreUtil.getURI((EObject) object); |
| if (uri != null && uri.isEmpty() == false && "#//".equals(uri.toString().trim()) == false) { //$NON-NLS-1$ |
| EObject eObject = editingDomain.getResourceSet().getEObject(uri, true); |
| if (eObject != null) { |
| selection.add(eObject); |
| } |
| } |
| } catch (Throwable t) { |
| // Just ignore |
| } |
| } |
| if (selection.isEmpty() == false) { |
| Runnable runnable = new Runnable() { |
| |
| public void run() { |
| // Try to select the items in the current content viewer of the editor. |
| if (currentViewer != null) { |
| currentViewer.setSelection(new StructuredSelection(selection.toArray()), true); |
| } |
| } |
| |
| }; |
| getSite().getShell().getDisplay().asyncExec(runnable); |
| } |
| } |
| |
| /** |
| * This returns the editing domain as required by the {@link IEditingDomainProvider} interface. |
| * This is important for implementing the static methods of {@link AdapterFactoryEditingDomain} and for supporting {@link org.eclipse.emf.edit.ui.action.CommandAction}. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public TransactionalEditingDomain getEditingDomain() { |
| return (TransactionalEditingDomain) editingDomain; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public class ReverseAdapterFactoryContentProvider extends TransactionalAdapterFactoryContentProvider { |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public ReverseAdapterFactoryContentProvider(AdapterFactory adapterFactory) { |
| super(getEditingDomain(), adapterFactory); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| @Override |
| public Object[] getElements(Object object) { |
| Object parent = super.getParent(object); |
| return (parent == null ? Collections.EMPTY_SET : Collections.singleton(parent)).toArray(); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| @Override |
| public Object[] getChildren(Object object) { |
| Object parent = super.getParent(object); |
| return (parent == null ? Collections.EMPTY_SET : Collections.singleton(parent)).toArray(); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| @Override |
| public boolean hasChildren(Object object) { |
| Object parent = super.getParent(object); |
| return parent != null; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| @Override |
| public Object getParent(Object object) { |
| return null; |
| } |
| |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public void setCurrentViewerPane(ViewerPane viewerPane) { |
| if (currentViewerPane != viewerPane) { |
| if (currentViewerPane != null) { |
| currentViewerPane.showFocus(false); |
| } |
| currentViewerPane = viewerPane; |
| } |
| setCurrentViewer(currentViewerPane.getViewer()); |
| } |
| |
| /** |
| * This makes sure that one content viewer, either for the current page or |
| * the outline view, if it |
| * has focus, |
| * is the current one. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public void setCurrentViewer(Viewer viewer) { |
| // If it is changing... |
| // |
| if (currentViewer != viewer) { |
| if (selectionChangedListener == null) { |
| // Create the listener on demand. |
| // |
| selectionChangedListener = new ISelectionChangedListener() { |
| |
| // This just notifies those things that are affected by the |
| // section. |
| // |
| public void selectionChanged(SelectionChangedEvent selectionChangedEvent) { |
| setSelection(selectionChangedEvent.getSelection()); |
| } |
| |
| }; |
| } |
| |
| // Stop listening to the old one. |
| // |
| if (currentViewer != null) { |
| currentViewer.removeSelectionChangedListener(selectionChangedListener); |
| } |
| |
| // Start listening to the new one. |
| // |
| if (viewer != null) { |
| viewer.addSelectionChangedListener(selectionChangedListener); |
| } |
| |
| // Remember it. |
| // |
| currentViewer = viewer; |
| |
| // Set the editors selection based on the current viewer's |
| // selection. |
| // |
| setSelection(currentViewer == null ? StructuredSelection.EMPTY : currentViewer.getSelection()); |
| } |
| } |
| |
| /** |
| * This returns the viewer as required by the {@link IViewerProvider} interface. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public Viewer getViewer() { |
| return currentViewer; |
| } |
| |
| /** |
| * This creates a context menu for the viewer and adds a listener as well |
| * registering the menu for |
| * extension. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| protected void createContextMenuFor(StructuredViewer viewer) { |
| MenuManager contextMenu = new MenuManager("#PopUp"); //$NON-NLS-1$ |
| contextMenu.add(new Separator("additions")); //$NON-NLS-1$ |
| contextMenu.setRemoveAllWhenShown(true); |
| contextMenu.addMenuListener(this); |
| Menu menu = contextMenu.createContextMenu(viewer.getControl()); |
| viewer.getControl().setMenu(menu); |
| getSite().registerContextMenu(contextMenu, new UnwrappingSelectionProvider(viewer)); |
| |
| int dndOperations = DND.DROP_COPY | DND.DROP_MOVE; |
| Transfer[] transfers = new Transfer[] { |
| LocalTransfer.getInstance() |
| }; |
| viewer.addDragSupport(dndOperations, transfers, new ViewerDragAdapter(viewer)); |
| viewer.addDropSupport(dndOperations, transfers, new EditingDomainViewerDropAdapter(getEditingDomain(), viewer)); |
| } |
| |
| /** |
| * This is the method called to load a resource into the editing domain's |
| * resource set based on the editor's input. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public void createModel() { |
| URI uri = EditorHelper.getURI(getEditorInput()); |
| Exception exception = null; |
| resource = null; |
| try { |
| // Load the resource through the editing domain. |
| // |
| resource = editingDomain.getResourceSet().getResource(uri, true); |
| } catch (Exception e) { |
| exception = e; |
| resource = editingDomain.getResourceSet().getResource(uri, false); |
| } |
| resourceHasBeenExternallyChanged = PlatformResourceLoadedListener.getResourceManager().resourceHasBeenExternallyChanged(resource); |
| Diagnostic diagnostic = ResourceHelper.analyzeResourceProblems(resource, exception, ID); |
| if (diagnostic.getSeverity() != Diagnostic.OK) { |
| resourceToDiagnosticMap.put(resource.getURI(), diagnostic); |
| } |
| editingDomain.getResourceSet().eAdapters().add(editorResourceAdapter); |
| egfAdapters.add(new ModelElementBundleAdapter(resource, getSite())); |
| getEditingDomain().getResourceSet().eAdapters().addAll(egfAdapters); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public ResourceListener getListener() { |
| return this; |
| } |
| |
| /** |
| * Obtains the single resource that I edit. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public Resource getResource() { |
| return resource; |
| } |
| |
| /** |
| * This is the method used by the framework to install your own controls. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| @Override |
| public void createPages() { |
| |
| // Only creates the other pages if there is something that can be edited |
| if (getResource() != null) { |
| |
| ViewerPane viewerPane = new ViewerPane(getSite().getPage(), FcoreEditor.this) { |
| |
| @Override |
| public Viewer createViewer(Composite composite) { |
| Tree tree = new Tree(composite, SWT.MULTI); |
| TreeViewer newTreeViewer = new TreeViewer(tree); |
| return newTreeViewer; |
| } |
| |
| @Override |
| public void requestActivation() { |
| super.requestActivation(); |
| setCurrentViewerPane(this); |
| } |
| |
| }; |
| viewerPane.createControl(getContainer()); |
| |
| // Create a page for the selection tree view. |
| selectionViewer = (TreeViewer) viewerPane.getViewer(); |
| |
| selectionViewer.setContentProvider(new FcoreContentProvider(getEditingDomain(), adapterFactory)); |
| selectionViewer.setLabelProvider(new TransactionalAdapterFactoryLabelProvider(getEditingDomain(), adapterFactory)); |
| |
| selectionViewer.setInput(getResource()); |
| selectionViewer.setSelection(new StructuredSelection(getResource()), true); |
| viewerPane.setTitle(getResource()); |
| |
| new AdapterFactoryTreeEditor(selectionViewer.getTree(), adapterFactory); |
| |
| createContextMenuFor(selectionViewer); |
| for (EditorListenerContributor contributor : EGFCoreUIPlugin.getEditorListenerContributors()) { |
| contributor.addListener(getEditorSite().getPage(), selectionViewer); |
| } |
| int pageIndex = addPage(viewerPane.getControl()); |
| setPageText(pageIndex, getString("_UI_SelectionPage_label")); //$NON-NLS-1$ |
| |
| } |
| |
| // Ensures that this editor will only display the page's tab |
| // area if there are more than one page |
| getContainer().addControlListener(new ControlAdapter() { |
| |
| @Override |
| public void controlResized(ControlEvent event) { |
| if (tabFolderGuard == false) { |
| tabFolderGuard = true; |
| hideTabs(); |
| tabFolderGuard = false; |
| } |
| } |
| |
| }); |
| |
| getSite().getShell().getDisplay().asyncExec(new Runnable() { |
| |
| public void run() { |
| updateProblemIndication(); |
| } |
| |
| }); |
| |
| } |
| |
| /** |
| * If there is just one page in the multi-page editor part, |
| * this hides the single tab at the bottom. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| protected void hideTabs() { |
| if (getPageCount() <= 1) { |
| setPageText(0, ""); //$NON-NLS-1$ |
| if (getContainer() instanceof CTabFolder) { |
| ((CTabFolder) getContainer()).setTabHeight(1); |
| Point point = getContainer().getSize(); |
| getContainer().setSize(point.x, point.y + 6); |
| } |
| } |
| } |
| |
| /** |
| * If there is more than one page in the multi-page editor part, |
| * this shows the tabs at the bottom. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| protected void showTabs() { |
| if (getPageCount() > 1) { |
| setPageText(0, getString("_UI_SelectionPage_label")); //$NON-NLS-1$ |
| if (getContainer() instanceof CTabFolder) { |
| ((CTabFolder) getContainer()).setTabHeight(SWT.DEFAULT); |
| Point point = getContainer().getSize(); |
| getContainer().setSize(point.x, point.y - 6); |
| } |
| } |
| } |
| |
| /** |
| * This is used to track the active viewer. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| @Override |
| protected void pageChange(int pageIndex) { |
| super.pageChange(pageIndex); |
| if (contentOutlinePage != null) { |
| handleContentOutlineSelection(contentOutlinePage.getSelection()); |
| } |
| } |
| |
| /** |
| * This is how the framework determines which interfaces we implement. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| @SuppressWarnings("rawtypes") |
| @Override |
| public Object getAdapter(Class key) { |
| if (key.equals(IContentOutlinePage.class)) { |
| return showOutlineView() ? getContentOutlinePage() : null; |
| } else if (key.equals(IPropertySheetPage.class)) { |
| return getPropertySheetPage(); |
| } else if (key.equals(IGotoMarker.class)) { |
| return this; |
| } else if (key.equals(IUndoContext.class)) { |
| return undoContext; |
| } else { |
| return super.getAdapter(key); |
| } |
| } |
| |
| /** |
| * This accesses a cached version of the content outliner. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public IContentOutlinePage getContentOutlinePage() { |
| if (contentOutlinePage == null) { |
| // The content outline is just a tree. |
| class MyContentOutlinePage extends ContentOutlinePage { |
| |
| @Override |
| public void createControl(Composite parent) { |
| super.createControl(parent); |
| contentOutlineViewer = getTreeViewer(); |
| contentOutlineViewer.addSelectionChangedListener(this); |
| |
| // Set up the tree viewer. |
| contentOutlineViewer.setContentProvider(new FcoreContentProvider(getEditingDomain(), adapterFactory)); |
| contentOutlineViewer.setLabelProvider(new TransactionalAdapterFactoryLabelProvider(getEditingDomain(), adapterFactory)); |
| contentOutlineViewer.setInput(getResource()); |
| |
| // Make sure our popups work. |
| createContextMenuFor(contentOutlineViewer); |
| |
| if (editingDomain.getResourceSet().getResources().isEmpty() == false) { |
| // Select the root object in the view. |
| ArrayList<Object> selection = new ArrayList<Object>(); |
| selection.add(getResource()); |
| contentOutlineViewer.setSelection(new StructuredSelection(selection), true); |
| } |
| } |
| |
| @Override |
| public void makeContributions(IMenuManager menuManager, IToolBarManager toolBarManager, IStatusLineManager statusLineManager) { |
| super.makeContributions(menuManager, toolBarManager, statusLineManager); |
| contentOutlineStatusLineManager = statusLineManager; |
| } |
| |
| @Override |
| public void setActionBars(IActionBars actionBars) { |
| super.setActionBars(actionBars); |
| getActionBarContributor().shareGlobalActions(this, actionBars); |
| } |
| |
| } |
| |
| contentOutlinePage = new MyContentOutlinePage(); |
| |
| // Listen to selection so that we can handle it is a special way. |
| // |
| contentOutlinePage.addSelectionChangedListener(new ISelectionChangedListener() { |
| |
| // This ensures that we handle selections correctly. |
| // |
| public void selectionChanged(SelectionChangedEvent event) { |
| handleContentOutlineSelection(event.getSelection()); |
| } |
| |
| }); |
| } |
| |
| return contentOutlinePage; |
| } |
| |
| /** |
| * This accesses a cached version of the property sheet. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public IPropertySheetPage getPropertySheetPage() { |
| if (propertySheetPage == null) { |
| propertySheetPage = new FcorePropertySheetPage((AdapterFactoryEditingDomain) getEditingDomain()) { |
| |
| @Override |
| public void setSelectionToViewer(List<?> selection) { |
| FcoreEditor.this.setSelectionToViewer(selection); |
| FcoreEditor.this.setFocus(); |
| } |
| |
| @Override |
| public void setActionBars(IActionBars actionBars) { |
| super.setActionBars(actionBars); |
| getActionBarContributor().shareGlobalActions(this, actionBars); |
| } |
| |
| @Override |
| public void dispose() { |
| super.dispose(); |
| propertySheetPage = null; |
| } |
| |
| }; |
| propertySheetPage.setPropertySourceProvider(new FcoreContentProvider(getEditingDomain(), propertyAdapterFactory)); |
| } |
| |
| return propertySheetPage; |
| } |
| |
| /** |
| * This deals with how we want selection in the outliner to affect the other |
| * views. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public void handleContentOutlineSelection(ISelection selection) { |
| if (selectionViewer != null && !selection.isEmpty() && selection instanceof IStructuredSelection) { |
| Iterator<?> selectedElements = ((IStructuredSelection) selection).iterator(); |
| if (selectedElements.hasNext()) { |
| // Get the first selected element. |
| // |
| Object selectedElement = selectedElements.next(); |
| |
| ArrayList<Object> selectionList = new ArrayList<Object>(); |
| selectionList.add(selectedElement); |
| while (selectedElements.hasNext()) { |
| selectionList.add(selectedElements.next()); |
| } |
| |
| // Set the selection to the widget. |
| // |
| selectionViewer.setSelection(new StructuredSelection(selectionList)); |
| } |
| } |
| } |
| |
| /** |
| * Gets the title tool tip text of this part. |
| * |
| * @return the tool tip text |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated NOT |
| */ |
| @Override |
| public String getTitleToolTip() { |
| if (getEditorInput() == null) { |
| return super.getTitleToolTip(); |
| } |
| return EGFPlatformPlugin.getPlatformURIConverter().normalize(getResource().getURI()).toString(); |
| } |
| |
| /** |
| * This is for implementing {@link IEditorPart} and simply tests the command stack. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| @Override |
| public boolean isDirty() { |
| if (getResource() == null) { |
| return false; |
| } |
| return getResource().isModified(); |
| } |
| |
| /** |
| * This is for implementing {@link IEditorPart} and simply saves the model |
| * file. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| @Override |
| public void doSave(IProgressMonitor progressMonitor) { |
| |
| // Do the work within an operation because this is a long running |
| // activity that modifies the workbench. |
| WorkspaceModifyOperation operation = new WorkspaceModifyOperation() { |
| |
| // This is the method that gets invoked when the operation runs. |
| @Override |
| public void execute(final IProgressMonitor monitor) throws CoreException, InvocationTargetException, InterruptedException { |
| try { |
| // Save Resource |
| getEditingDomain().runExclusive(new Runnable() { |
| |
| public void run() { |
| Resource resourceToSave = getResource(); |
| try { |
| // Save the resource to the file system. |
| long timeStamp = resourceToSave.getTimeStamp(); |
| resourceToSave.save(Collections.EMPTY_MAP); |
| if (resourceToSave.getTimeStamp() != timeStamp) { |
| userHasSavedResource = true; |
| } |
| } catch (Exception exception) { |
| resourceToDiagnosticMap.put(resourceToSave.getURI(), ResourceHelper.analyzeResourceProblems(resourceToSave, exception, ID)); |
| } |
| } |
| |
| }); |
| } finally { |
| monitor.done(); |
| } |
| } |
| |
| }; |
| |
| updateProblemIndication = false; |
| try { |
| // This runs the options, and shows progress. |
| new ProgressMonitorDialog(getSite().getShell()).run(true, false, operation); |
| // Refresh the necessary state. |
| ((BasicCommandStack) editingDomain.getCommandStack()).saveIsDone(); |
| firePropertyChange(IEditorPart.PROP_DIRTY); |
| } catch (InvocationTargetException ite) { |
| ThrowableHandler.handleThrowable(EGFModelEditorPlugin.getPlugin().getSymbolicName(), ite); |
| } catch (InterruptedException e) { |
| Assert.isTrue(false, "This operation can not be canceled."); //$NON-NLS-1$ |
| } |
| updateProblemIndication = true; |
| updateProblemIndication(); |
| } |
| |
| /** |
| * This returns whether something has been persisted to the URI of the |
| * specified resource. |
| * The implementation uses the URI converter from the editor's resource set |
| * to try to open an |
| * input stream. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| protected boolean isPersisted(Resource innerResource) { |
| boolean result = false; |
| try { |
| InputStream stream = editingDomain.getResourceSet().getURIConverter().createInputStream(innerResource.getURI()); |
| if (stream != null) { |
| result = true; |
| stream.close(); |
| } |
| } catch (IOException e) { |
| // Ignore |
| } |
| return result; |
| } |
| |
| /** |
| * This always returns true because it is not currently supported. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| @Override |
| public boolean isSaveAsAllowed() { |
| return true; |
| } |
| |
| /** |
| * This also changes the editor's input. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| @Override |
| public void doSaveAs() { |
| SaveAsDialog saveAsDialog = new SaveAsDialog(getSite().getShell()); |
| saveAsDialog.open(); |
| IPath path = saveAsDialog.getResult(); |
| if (path != null) { |
| IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(path); |
| if (file != null) { |
| doSaveAs(URI.createPlatformResourceURI(file.getFullPath().toString(), true), new FileEditorInput(file)); |
| } |
| } |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| protected void doSaveAs(final URI uri, final IEditorInput editorInput) { |
| // changing the URI is, conceptually, a write operation. However, it does |
| // not affect the abstract state of the model, so we only need exclusive |
| // (read) access |
| try { |
| getEditingDomain().runExclusive(new Runnable() { |
| |
| public void run() { |
| getResource().setURI(uri); |
| setInputWithNotify(editorInput); |
| setPartName(editorInput.getName()); |
| } |
| |
| }); |
| } catch (InterruptedException ie) { |
| // just log it |
| EGFModelEditorPlugin.getPlugin().logError(ie); |
| // don't follow through with the save because we were interrupted while |
| // trying to start the transaction, so our URI is not actually changed |
| return; |
| } |
| |
| IProgressMonitor progressMonitor = getActionBars().getStatusLineManager() != null ? getActionBars().getStatusLineManager().getProgressMonitor() : new NullProgressMonitor(); |
| doSave(progressMonitor); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public void gotoMarker(IMarker marker) { |
| try { |
| if (marker.getType().equals(EValidator.MARKER)) { |
| final String uriAttribute = marker.getAttribute(EValidator.URI_ATTRIBUTE, null); |
| if (uriAttribute != null) { |
| try { |
| getEditingDomain().runExclusive(new Runnable() { |
| |
| public void run() { |
| URI uri = URI.createURI(uriAttribute); |
| EObject eObject = editingDomain.getResourceSet().getEObject(uri, true); |
| if (eObject != null) { |
| setSelectionToViewer(Collections.singleton(editingDomain.getWrapper(eObject))); |
| } |
| } |
| |
| }); |
| } catch (InterruptedException ie) { |
| // just log it |
| EGFModelEditorPlugin.getPlugin().logError(ie); |
| } |
| } |
| } |
| } catch (CoreException ce) { |
| EGFModelEditorPlugin.getPlugin().logError(ce); |
| } |
| } |
| |
| /** |
| * This is called during startup. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| @Override |
| public void init(IEditorSite site, IEditorInput editorInput) { |
| setSite(site); |
| setInputWithNotify(editorInput); |
| setPartName(editorInput.getName()); |
| site.setSelectionProvider(this); |
| site.getPage().addPartListener(partListener); |
| createModel(); |
| PlatformResourceLoadedListener.getResourceManager().addObserver(this); |
| // populate operation history if applicable |
| PlatformResourceLoadedListener.getResourceManager().populateUndoContext(getOperationHistory(), undoContext, getResource()); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| @Override |
| public void setFocus() { |
| selectionViewer.getControl().setFocus(); |
| } |
| |
| /** |
| * This implements {@link org.eclipse.jface.viewers.ISelectionProvider}. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public void addSelectionChangedListener(ISelectionChangedListener listener) { |
| selectionChangedListeners.add(listener); |
| } |
| |
| /** |
| * This implements {@link org.eclipse.jface.viewers.ISelectionProvider}. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public void removeSelectionChangedListener(ISelectionChangedListener listener) { |
| selectionChangedListeners.remove(listener); |
| } |
| |
| /** |
| * This implements {@link org.eclipse.jface.viewers.ISelectionProvider} to |
| * return this editor's |
| * overall selection. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public ISelection getSelection() { |
| return editorSelection; |
| } |
| |
| /** |
| * This implements {@link org.eclipse.jface.viewers.ISelectionProvider} to |
| * set this editor's |
| * overall selection. |
| * Calling this result will notify the listeners. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public void setSelection(ISelection selection) { |
| editorSelection = selection; |
| |
| for (ISelectionChangedListener listener : selectionChangedListeners) { |
| listener.selectionChanged(new SelectionChangedEvent(this, selection)); |
| } |
| setStatusLineManager(selection); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public void setStatusLineManager(ISelection selection) { |
| |
| IStatusLineManager statusLineManager = currentViewer != null && currentViewer == contentOutlineViewer ? contentOutlineStatusLineManager : getActionBars().getStatusLineManager(); |
| |
| if (statusLineManager != null) { |
| if (selection instanceof IStructuredSelection) { |
| Collection<?> collection = ((IStructuredSelection) selection).toList(); |
| switch (collection.size()) { |
| case 0: { |
| statusLineManager.setMessage(getString("_UI_NoObjectSelected")); //$NON-NLS-1$ |
| break; |
| } |
| case 1: { |
| String text = new AdapterFactoryItemDelegator(adapterFactory).getText(collection.iterator().next()); |
| statusLineManager.setMessage(getString("_UI_SingleObjectSelected", text)); //$NON-NLS-1$ |
| break; |
| } |
| default: { |
| statusLineManager.setMessage(getString("_UI_MultiObjectSelected", Integer.toString(collection.size()))); //$NON-NLS-1$ |
| break; |
| } |
| } |
| } else { |
| statusLineManager.setMessage(""); //$NON-NLS-1$ |
| } |
| } |
| |
| } |
| |
| /** |
| * This looks up a string in the plugin's plugin.properties file. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| private static String getString(String key) { |
| return EGFModelEditorPlugin.INSTANCE.getString(key); |
| } |
| |
| /** |
| * This looks up a string in plugin.properties, making a substitution. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| private static String getString(String key, Object s1) { |
| return EGFModelEditorPlugin.INSTANCE.getString(key, new Object[] { |
| s1 |
| }); |
| } |
| |
| /** |
| * This implements {@link org.eclipse.jface.action.IMenuListener} to help |
| * fill the context menus |
| * with contributions from the Edit menu. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public void menuAboutToShow(IMenuManager menuManager) { |
| ((IMenuListener) getEditorSite().getActionBarContributor()).menuAboutToShow(menuManager); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public EditingDomainActionBarContributor getActionBarContributor() { |
| return (EditingDomainActionBarContributor) getEditorSite().getActionBarContributor(); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public IActionBars getActionBars() { |
| return getActionBarContributor().getActionBars(); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public AdapterFactory getAdapterFactory() { |
| return adapterFactory; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public IOperationHistory getOperationHistory() { |
| return ((IWorkspaceCommandStack) editingDomain.getCommandStack()).getOperationHistory(); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| @Override |
| public void dispose() { |
| |
| // No more problem feedback |
| updateProblemIndication = false; |
| |
| // Remove contribution |
| for (EditorListenerContributor contributor : EGFCoreUIPlugin.getEditorListenerContributors()) { |
| contributor.removeListener(selectionViewer); |
| } |
| |
| // We have operation history stuff to clean up |
| getOperationHistory().removeOperationHistoryListener(historyListener); |
| getOperationHistory().dispose(getUndoContext(), true, true, true); |
| |
| // Remove observer |
| PlatformResourceLoadedListener.getResourceManager().removeObserver(this); |
| |
| // Remove our adapters |
| editingDomain.getResourceSet().eAdapters().remove(editorResourceAdapter); |
| for (EContentAdapter adapter : egfAdapters) { |
| editingDomain.getResourceSet().eAdapters().remove(adapter); |
| } |
| |
| // Remove our listeners |
| getSite().getPage().removePartListener(partListener); |
| |
| // Dispose |
| adapterFactory.dispose(); |
| if (getActionBarContributor().getActiveEditor() == this) { |
| getActionBarContributor().setActiveEditor(null); |
| } |
| if (propertySheetPage != null) { |
| propertySheetPage.dispose(); |
| } |
| if (contentOutlinePage != null) { |
| contentOutlinePage.dispose(); |
| } |
| |
| super.dispose(); |
| |
| } |
| |
| /** |
| * Returns whether the outline view should be presented to the user. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| protected boolean showOutlineView() { |
| return true; |
| } |
| |
| } |