| /* |
| * Copyright (c) 2010, 2012, 2015 Eike Stepper (Berlin, Germany) and others. |
| * 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: |
| * Martin Fluegge - initial API and implementation |
| * |
| */ |
| package org.eclipse.emf.cdo.dawn.examples.acore.diagram.part; |
| |
| import org.eclipse.emf.common.notify.Adapter; |
| import org.eclipse.emf.common.notify.Notification; |
| import org.eclipse.emf.common.notify.Notifier; |
| 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.ResourceSet; |
| import org.eclipse.emf.ecore.util.EContentAdapter; |
| import org.eclipse.emf.ecore.util.EcoreUtil; |
| import org.eclipse.emf.transaction.NotificationFilter; |
| import org.eclipse.emf.transaction.TransactionalEditingDomain; |
| import org.eclipse.emf.workspace.util.WorkspaceSynchronizer; |
| |
| import org.eclipse.core.commands.ExecutionException; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IResourceStatus; |
| import org.eclipse.core.resources.IStorage; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IAdaptable; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.core.runtime.jobs.ISchedulingRule; |
| import org.eclipse.core.runtime.jobs.MultiRule; |
| import org.eclipse.gmf.runtime.common.core.command.CommandResult; |
| import org.eclipse.gmf.runtime.diagram.core.DiagramEditingDomainFactory; |
| import org.eclipse.gmf.runtime.diagram.ui.resources.editor.document.AbstractDocumentProvider; |
| import org.eclipse.gmf.runtime.diagram.ui.resources.editor.document.DiagramDocument; |
| import org.eclipse.gmf.runtime.diagram.ui.resources.editor.document.IDiagramDocument; |
| import org.eclipse.gmf.runtime.diagram.ui.resources.editor.document.IDiagramDocumentProvider; |
| import org.eclipse.gmf.runtime.diagram.ui.resources.editor.document.IDocument; |
| import org.eclipse.gmf.runtime.diagram.ui.resources.editor.internal.EditorStatusCodes; |
| import org.eclipse.gmf.runtime.diagram.ui.resources.editor.internal.util.DiagramIOUtil; |
| import org.eclipse.gmf.runtime.emf.commands.core.command.AbstractTransactionalCommand; |
| import org.eclipse.gmf.runtime.emf.core.resources.GMFResourceFactory; |
| import org.eclipse.gmf.runtime.notation.Diagram; |
| import org.eclipse.jface.operation.IRunnableContext; |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.part.FileEditorInput; |
| |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| |
| /** |
| * @generated |
| */ |
| public class AcoreDocumentProvider extends AbstractDocumentProvider implements IDiagramDocumentProvider |
| { |
| |
| /** |
| * @generated |
| */ |
| @Override |
| protected ElementInfo createElementInfo(Object element) throws CoreException |
| { |
| if (false == element instanceof FileEditorInput && false == element instanceof URIEditorInput) |
| { |
| throw new CoreException(new Status(IStatus.ERROR, AcoreDiagramEditorPlugin.ID, 0, |
| NLS.bind(Messages.AcoreDocumentProvider_IncorrectInputError, |
| new Object[] { element, "org.eclipse.ui.part.FileEditorInput", //$NON-NLS-1$ |
| "org.eclipse.emf.common.ui.URIEditorInput" }), //$NON-NLS-1$ |
| null)); |
| } |
| IEditorInput editorInput = (IEditorInput)element; |
| IDiagramDocument document = (IDiagramDocument)createDocument(editorInput); |
| |
| ResourceSetInfo info = new ResourceSetInfo(document, editorInput); |
| info.setModificationStamp(computeModificationStamp(info)); |
| info.fStatus = null; |
| return info; |
| } |
| |
| /** |
| * @generated |
| */ |
| @Override |
| protected IDocument createDocument(Object element) throws CoreException |
| { |
| if (false == element instanceof FileEditorInput && false == element instanceof URIEditorInput) |
| { |
| throw new CoreException(new Status(IStatus.ERROR, AcoreDiagramEditorPlugin.ID, 0, |
| NLS.bind(Messages.AcoreDocumentProvider_IncorrectInputError, |
| new Object[] { element, "org.eclipse.ui.part.FileEditorInput", //$NON-NLS-1$ |
| "org.eclipse.emf.common.ui.URIEditorInput" }), //$NON-NLS-1$ |
| null)); |
| } |
| IDocument document = createEmptyDocument(); |
| setDocumentContent(document, (IEditorInput)element); |
| setupDocument(element, document); |
| return document; |
| } |
| |
| /** |
| * Sets up the given document as it would be provided for the given element. The content of the document is not |
| * changed. This default implementation is empty. Subclasses may reimplement. |
| * |
| * @param element |
| * the blue-print element |
| * @param document |
| * the document to set up |
| * @generated |
| */ |
| protected void setupDocument(Object element, IDocument document) |
| { |
| // for subclasses |
| } |
| |
| /** |
| * @generated |
| */ |
| private long computeModificationStamp(ResourceSetInfo info) |
| { |
| int result = 0; |
| for (Iterator<Resource> it = info.getLoadedResourcesIterator(); it.hasNext();) |
| { |
| Resource nextResource = it.next(); |
| IFile file = WorkspaceSynchronizer.getFile(nextResource); |
| if (file != null) |
| { |
| if (file.getLocation() != null) |
| { |
| result += file.getLocation().toFile().lastModified(); |
| } |
| else |
| { |
| result += file.getModificationStamp(); |
| } |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * @generated |
| */ |
| @Override |
| protected IDocument createEmptyDocument() |
| { |
| DiagramDocument document = new DiagramDocument(); |
| document.setEditingDomain(createEditingDomain()); |
| return document; |
| } |
| |
| /** |
| * @generated |
| */ |
| private TransactionalEditingDomain createEditingDomain() |
| { |
| TransactionalEditingDomain editingDomain = DiagramEditingDomainFactory.getInstance().createEditingDomain(); |
| editingDomain.setID("org.eclipse.emf.cdo.dawn.examples.acore.diagram.EditingDomain"); //$NON-NLS-1$ |
| final NotificationFilter diagramResourceModifiedFilter = NotificationFilter |
| .createNotifierFilter(editingDomain.getResourceSet()) |
| .and(NotificationFilter.createEventTypeFilter(Notification.ADD)) |
| .and(NotificationFilter.createFeatureFilter(ResourceSet.class, ResourceSet.RESOURCE_SET__RESOURCES)); |
| editingDomain.getResourceSet().eAdapters().add(new Adapter() |
| { |
| |
| private Notifier myTarger; |
| |
| public Notifier getTarget() |
| { |
| return myTarger; |
| } |
| |
| public boolean isAdapterForType(Object type) |
| { |
| return false; |
| } |
| |
| public void notifyChanged(Notification notification) |
| { |
| if (diagramResourceModifiedFilter.matches(notification)) |
| { |
| Object value = notification.getNewValue(); |
| if (value instanceof Resource) |
| { |
| ((Resource)value).setTrackingModification(true); |
| } |
| } |
| } |
| |
| public void setTarget(Notifier newTarget) |
| { |
| myTarger = newTarget; |
| } |
| |
| }); |
| |
| return editingDomain; |
| } |
| |
| /** |
| * @generated |
| */ |
| protected void setDocumentContent(IDocument document, IEditorInput element) throws CoreException |
| { |
| IDiagramDocument diagramDocument = (IDiagramDocument)document; |
| TransactionalEditingDomain domain = diagramDocument.getEditingDomain(); |
| if (element instanceof FileEditorInput) |
| { |
| IStorage storage = ((FileEditorInput)element).getStorage(); |
| Diagram diagram = DiagramIOUtil.load(domain, storage, true, getProgressMonitor()); |
| document.setContent(diagram); |
| } |
| else if (element instanceof URIEditorInput) |
| { |
| URI uri = ((URIEditorInput)element).getURI(); |
| Resource resource = null; |
| try |
| { |
| resource = domain.getResourceSet().getResource(uri.trimFragment(), false); |
| if (resource == null) |
| { |
| resource = domain.getResourceSet().createResource(uri.trimFragment()); |
| } |
| if (!resource.isLoaded()) |
| { |
| try |
| { |
| Map options = new HashMap(GMFResourceFactory.getDefaultLoadOptions()); |
| // @see 171060 |
| // options.put(org.eclipse.emf.ecore.xmi.XMLResource.OPTION_RECORD_UNKNOWN_FEATURE, Boolean.TRUE); |
| resource.load(options); |
| } |
| catch (IOException e) |
| { |
| resource.unload(); |
| throw e; |
| } |
| } |
| if (uri.fragment() != null) |
| { |
| EObject rootElement = resource.getEObject(uri.fragment()); |
| if (rootElement instanceof Diagram) |
| { |
| document.setContent(rootElement); |
| return; |
| } |
| } |
| else |
| { |
| for (Iterator it = resource.getContents().iterator(); it.hasNext();) |
| { |
| Object rootElement = it.next(); |
| if (rootElement instanceof Diagram) |
| { |
| document.setContent(rootElement); |
| return; |
| } |
| } |
| } |
| throw new RuntimeException(Messages.AcoreDocumentProvider_NoDiagramInResourceError); |
| } |
| catch (Exception e) |
| { |
| CoreException thrownExcp = null; |
| if (e instanceof CoreException) |
| { |
| thrownExcp = (CoreException)e; |
| } |
| else |
| { |
| String msg = e.getLocalizedMessage(); |
| thrownExcp = new CoreException(new Status(IStatus.ERROR, AcoreDiagramEditorPlugin.ID, 0, |
| msg != null ? msg : Messages.AcoreDocumentProvider_DiagramLoadingError, e)); |
| } |
| throw thrownExcp; |
| } |
| } |
| else |
| { |
| throw new CoreException(new Status(IStatus.ERROR, AcoreDiagramEditorPlugin.ID, 0, |
| NLS.bind(Messages.AcoreDocumentProvider_IncorrectInputError, |
| new Object[] { element, "org.eclipse.ui.part.FileEditorInput", //$NON-NLS-1$ |
| "org.eclipse.emf.common.ui.URIEditorInput" }), //$NON-NLS-1$ |
| null)); |
| } |
| } |
| |
| /** |
| * @generated |
| */ |
| @Override |
| public long getModificationStamp(Object element) |
| { |
| ResourceSetInfo info = getResourceSetInfo(element); |
| if (info != null) |
| { |
| return computeModificationStamp(info); |
| } |
| return super.getModificationStamp(element); |
| } |
| |
| /** |
| * @generated |
| */ |
| @Override |
| public boolean isDeleted(Object element) |
| { |
| IDiagramDocument document = getDiagramDocument(element); |
| if (document != null) |
| { |
| Resource diagramResource = document.getDiagram().eResource(); |
| if (diagramResource != null) |
| { |
| IFile file = WorkspaceSynchronizer.getFile(diagramResource); |
| return file == null || file.getLocation() == null || !file.getLocation().toFile().exists(); |
| } |
| } |
| return super.isDeleted(element); |
| } |
| |
| /** |
| * @generated |
| */ |
| public ResourceSetInfo getResourceSetInfo(Object editorInput) |
| { |
| return (ResourceSetInfo)super.getElementInfo(editorInput); |
| } |
| |
| /** |
| * @generated |
| */ |
| @Override |
| protected void disposeElementInfo(Object element, ElementInfo info) |
| { |
| if (info instanceof ResourceSetInfo) |
| { |
| ResourceSetInfo resourceSetInfo = (ResourceSetInfo)info; |
| resourceSetInfo.dispose(); |
| } |
| super.disposeElementInfo(element, info); |
| } |
| |
| /** |
| * @generated |
| */ |
| @Override |
| protected void doValidateState(Object element, Object computationContext) throws CoreException |
| { |
| ResourceSetInfo info = getResourceSetInfo(element); |
| if (info != null) |
| { |
| LinkedList<IFile> files2Validate = new LinkedList<IFile>(); |
| for (Iterator<Resource> it = info.getLoadedResourcesIterator(); it.hasNext();) |
| { |
| Resource nextResource = it.next(); |
| IFile file = WorkspaceSynchronizer.getFile(nextResource); |
| if (file != null && file.isReadOnly()) |
| { |
| files2Validate.add(file); |
| } |
| } |
| ResourcesPlugin.getWorkspace().validateEdit(files2Validate.toArray(new IFile[files2Validate.size()]), |
| computationContext); |
| } |
| |
| super.doValidateState(element, computationContext); |
| } |
| |
| /** |
| * @generated |
| */ |
| @Override |
| public boolean isReadOnly(Object element) |
| { |
| ResourceSetInfo info = getResourceSetInfo(element); |
| if (info != null) |
| { |
| if (info.isUpdateCache()) |
| { |
| try |
| { |
| updateCache(element); |
| } |
| catch (CoreException ex) |
| { |
| AcoreDiagramEditorPlugin.getInstance().logError(Messages.AcoreDocumentProvider_isModifiable, ex); |
| // Error message to log was initially taken from |
| // org.eclipse.gmf.runtime.diagram.ui.resources.editor.ide.internal.l10n.EditorMessages.StorageDocumentProvider_isModifiable |
| } |
| } |
| return info.isReadOnly(); |
| } |
| return super.isReadOnly(element); |
| } |
| |
| /** |
| * @generated |
| */ |
| @Override |
| public boolean isModifiable(Object element) |
| { |
| if (!isStateValidated(element)) |
| { |
| if (element instanceof FileEditorInput || element instanceof URIEditorInput) |
| { |
| return true; |
| } |
| } |
| ResourceSetInfo info = getResourceSetInfo(element); |
| if (info != null) |
| { |
| if (info.isUpdateCache()) |
| { |
| try |
| { |
| updateCache(element); |
| } |
| catch (CoreException ex) |
| { |
| AcoreDiagramEditorPlugin.getInstance().logError(Messages.AcoreDocumentProvider_isModifiable, ex); |
| // Error message to log was initially taken from |
| // org.eclipse.gmf.runtime.diagram.ui.resources.editor.ide.internal.l10n.EditorMessages.StorageDocumentProvider_isModifiable |
| } |
| } |
| return info.isModifiable(); |
| } |
| return super.isModifiable(element); |
| } |
| |
| /** |
| * @generated |
| */ |
| protected void updateCache(Object element) throws CoreException |
| { |
| ResourceSetInfo info = getResourceSetInfo(element); |
| if (info != null) |
| { |
| for (Iterator<Resource> it = info.getLoadedResourcesIterator(); it.hasNext();) |
| { |
| Resource nextResource = it.next(); |
| IFile file = WorkspaceSynchronizer.getFile(nextResource); |
| if (file != null && file.isReadOnly()) |
| { |
| info.setReadOnly(true); |
| info.setModifiable(false); |
| return; |
| } |
| } |
| info.setReadOnly(false); |
| info.setModifiable(true); |
| return; |
| } |
| } |
| |
| /** |
| * @generated |
| */ |
| @Override |
| protected void doUpdateStateCache(Object element) throws CoreException |
| { |
| ResourceSetInfo info = getResourceSetInfo(element); |
| if (info != null) |
| { |
| info.setUpdateCache(true); |
| } |
| super.doUpdateStateCache(element); |
| } |
| |
| /** |
| * @generated |
| */ |
| @Override |
| public boolean isSynchronized(Object element) |
| { |
| ResourceSetInfo info = getResourceSetInfo(element); |
| if (info != null) |
| { |
| return info.isSynchronized(); |
| } |
| return super.isSynchronized(element); |
| } |
| |
| /** |
| * @generated |
| */ |
| @Override |
| protected ISchedulingRule getResetRule(Object element) |
| { |
| ResourceSetInfo info = getResourceSetInfo(element); |
| if (info != null) |
| { |
| LinkedList<ISchedulingRule> rules = new LinkedList<ISchedulingRule>(); |
| for (Iterator<Resource> it = info.getLoadedResourcesIterator(); it.hasNext();) |
| { |
| Resource nextResource = it.next(); |
| IFile file = WorkspaceSynchronizer.getFile(nextResource); |
| if (file != null) |
| { |
| rules.add(ResourcesPlugin.getWorkspace().getRuleFactory().modifyRule(file)); |
| } |
| } |
| return new MultiRule(rules.toArray(new ISchedulingRule[rules.size()])); |
| } |
| return null; |
| } |
| |
| /** |
| * @generated |
| */ |
| @Override |
| protected ISchedulingRule getSaveRule(Object element) |
| { |
| ResourceSetInfo info = getResourceSetInfo(element); |
| if (info != null) |
| { |
| LinkedList<ISchedulingRule> rules = new LinkedList<ISchedulingRule>(); |
| for (Iterator<Resource> it = info.getLoadedResourcesIterator(); it.hasNext();) |
| { |
| Resource nextResource = it.next(); |
| IFile file = WorkspaceSynchronizer.getFile(nextResource); |
| if (file != null) |
| { |
| rules.add(computeSchedulingRule(file)); |
| } |
| } |
| return new MultiRule(rules.toArray(new ISchedulingRule[rules.size()])); |
| } |
| return null; |
| } |
| |
| /** |
| * @generated |
| */ |
| @Override |
| protected ISchedulingRule getSynchronizeRule(Object element) |
| { |
| ResourceSetInfo info = getResourceSetInfo(element); |
| if (info != null) |
| { |
| LinkedList<ISchedulingRule> rules = new LinkedList<ISchedulingRule>(); |
| for (Iterator<Resource> it = info.getLoadedResourcesIterator(); it.hasNext();) |
| { |
| Resource nextResource = it.next(); |
| IFile file = WorkspaceSynchronizer.getFile(nextResource); |
| if (file != null) |
| { |
| rules.add(ResourcesPlugin.getWorkspace().getRuleFactory().refreshRule(file)); |
| } |
| } |
| return new MultiRule(rules.toArray(new ISchedulingRule[rules.size()])); |
| } |
| return null; |
| } |
| |
| /** |
| * @generated |
| */ |
| @Override |
| protected ISchedulingRule getValidateStateRule(Object element) |
| { |
| ResourceSetInfo info = getResourceSetInfo(element); |
| if (info != null) |
| { |
| LinkedList<ISchedulingRule> files = new LinkedList<ISchedulingRule>(); |
| for (Iterator<Resource> it = info.getLoadedResourcesIterator(); it.hasNext();) |
| { |
| Resource nextResource = it.next(); |
| IFile file = WorkspaceSynchronizer.getFile(nextResource); |
| if (file != null) |
| { |
| files.add(file); |
| } |
| } |
| return ResourcesPlugin.getWorkspace().getRuleFactory().validateEditRule(files.toArray(new IFile[files.size()])); |
| } |
| return null; |
| } |
| |
| /** |
| * @generated |
| */ |
| private ISchedulingRule computeSchedulingRule(IResource toCreateOrModify) |
| { |
| if (toCreateOrModify.exists()) |
| { |
| return ResourcesPlugin.getWorkspace().getRuleFactory().modifyRule(toCreateOrModify); |
| } |
| |
| IResource parent = toCreateOrModify; |
| do |
| { |
| /* |
| * XXX This is a workaround for https://bugs.eclipse.org/bugs/show_bug.cgi?id=67601 |
| * IResourceRuleFactory.createRule should iterate the hierarchy itself. |
| */ |
| toCreateOrModify = parent; |
| parent = toCreateOrModify.getParent(); |
| } while (parent != null && !parent.exists()); |
| |
| return ResourcesPlugin.getWorkspace().getRuleFactory().createRule(toCreateOrModify); |
| } |
| |
| /** |
| * @generated |
| */ |
| @Override |
| protected void doSynchronize(Object element, IProgressMonitor monitor) throws CoreException |
| { |
| ResourceSetInfo info = getResourceSetInfo(element); |
| if (info != null) |
| { |
| for (Iterator<Resource> it = info.getLoadedResourcesIterator(); it.hasNext();) |
| { |
| Resource nextResource = it.next(); |
| handleElementChanged(info, nextResource, monitor); |
| } |
| return; |
| } |
| super.doSynchronize(element, monitor); |
| } |
| |
| /** |
| * @generated |
| */ |
| @Override |
| protected void doSaveDocument(IProgressMonitor monitor, Object element, IDocument document, boolean overwrite) |
| throws CoreException |
| { |
| ResourceSetInfo info = getResourceSetInfo(element); |
| if (info != null) |
| { |
| if (!overwrite && !info.isSynchronized()) |
| { |
| throw new CoreException(new Status(IStatus.ERROR, AcoreDiagramEditorPlugin.ID, |
| IResourceStatus.OUT_OF_SYNC_LOCAL, Messages.AcoreDocumentProvider_UnsynchronizedFileSaveError, null)); |
| } |
| info.stopResourceListening(); |
| fireElementStateChanging(element); |
| try |
| { |
| monitor.beginTask(Messages.AcoreDocumentProvider_SaveDiagramTask, |
| info.getResourceSet().getResources().size() + 1); // "Saving diagram" |
| for (Iterator<Resource> it = info.getLoadedResourcesIterator(); it.hasNext();) |
| { |
| Resource nextResource = it.next(); |
| monitor.setTaskName(NLS.bind(Messages.AcoreDocumentProvider_SaveNextResourceTask, nextResource.getURI())); |
| if (nextResource.isLoaded() && !info.getEditingDomain().isReadOnly(nextResource)) |
| { |
| try |
| { |
| nextResource.save(AcoreDiagramEditorUtil.getSaveOptions()); |
| } |
| catch (IOException e) |
| { |
| fireElementStateChangeFailed(element); |
| throw new CoreException(new Status(IStatus.ERROR, AcoreDiagramEditorPlugin.ID, |
| EditorStatusCodes.RESOURCE_FAILURE, e.getLocalizedMessage(), null)); |
| } |
| } |
| monitor.worked(1); |
| } |
| monitor.done(); |
| info.setModificationStamp(computeModificationStamp(info)); |
| } |
| catch (RuntimeException x) |
| { |
| fireElementStateChangeFailed(element); |
| throw x; |
| } |
| finally |
| { |
| info.startResourceListening(); |
| } |
| } |
| else |
| { |
| URI newResoruceURI; |
| List<IFile> affectedFiles = null; |
| if (element instanceof FileEditorInput) |
| { |
| IFile newFile = ((FileEditorInput)element).getFile(); |
| affectedFiles = Collections.singletonList(newFile); |
| newResoruceURI = URI.createPlatformResourceURI(newFile.getFullPath().toString(), true); |
| } |
| else if (element instanceof URIEditorInput) |
| { |
| newResoruceURI = ((URIEditorInput)element).getURI(); |
| } |
| else |
| { |
| fireElementStateChangeFailed(element); |
| throw new CoreException(new Status(IStatus.ERROR, AcoreDiagramEditorPlugin.ID, 0, |
| NLS.bind(Messages.AcoreDocumentProvider_IncorrectInputError, |
| new Object[] { element, "org.eclipse.ui.part.FileEditorInput", //$NON-NLS-1$ |
| "org.eclipse.emf.common.ui.URIEditorInput" }), //$NON-NLS-1$ |
| null)); |
| } |
| if (false == document instanceof IDiagramDocument) |
| { |
| fireElementStateChangeFailed(element); |
| throw new CoreException( |
| new Status(IStatus.ERROR, AcoreDiagramEditorPlugin.ID, 0, |
| "Incorrect document used: " + document //$NON-NLS-1$ |
| + " instead of org.eclipse.gmf.runtime.diagram.ui.resources.editor.document.IDiagramDocument", //$NON-NLS-1$ |
| null)); |
| } |
| IDiagramDocument diagramDocument = (IDiagramDocument)document; |
| final Resource newResource = diagramDocument.getEditingDomain().getResourceSet().createResource(newResoruceURI); |
| final Diagram diagramCopy = EcoreUtil.copy(diagramDocument.getDiagram()); |
| try |
| { |
| new AbstractTransactionalCommand(diagramDocument.getEditingDomain(), |
| NLS.bind(Messages.AcoreDocumentProvider_SaveAsOperation, diagramCopy.getName()), affectedFiles) |
| { |
| @Override |
| protected CommandResult doExecuteWithResult(IProgressMonitor monitor, IAdaptable info) |
| throws ExecutionException |
| { |
| newResource.getContents().add(diagramCopy); |
| return CommandResult.newOKCommandResult(); |
| } |
| }.execute(monitor, null); |
| newResource.save(AcoreDiagramEditorUtil.getSaveOptions()); |
| } |
| catch (ExecutionException e) |
| { |
| fireElementStateChangeFailed(element); |
| throw new CoreException( |
| new Status(IStatus.ERROR, AcoreDiagramEditorPlugin.ID, 0, e.getLocalizedMessage(), null)); |
| } |
| catch (IOException e) |
| { |
| fireElementStateChangeFailed(element); |
| throw new CoreException( |
| new Status(IStatus.ERROR, AcoreDiagramEditorPlugin.ID, 0, e.getLocalizedMessage(), null)); |
| } |
| newResource.unload(); |
| } |
| } |
| |
| /** |
| * @generated |
| */ |
| protected void handleElementChanged(ResourceSetInfo info, Resource changedResource, IProgressMonitor monitor) |
| { |
| IFile file = WorkspaceSynchronizer.getFile(changedResource); |
| if (file != null) |
| { |
| try |
| { |
| file.refreshLocal(IResource.DEPTH_INFINITE, monitor); |
| } |
| catch (CoreException ex) |
| { |
| AcoreDiagramEditorPlugin.getInstance().logError(Messages.AcoreDocumentProvider_handleElementContentChanged, ex); |
| // Error message to log was initially taken from |
| // org.eclipse.gmf.runtime.diagram.ui.resources.editor.ide.internal.l10n.EditorMessages.FileDocumentProvider_handleElementContentChanged |
| } |
| } |
| changedResource.unload(); |
| |
| fireElementContentAboutToBeReplaced(info.getEditorInput()); |
| removeUnchangedElementListeners(info.getEditorInput(), info); |
| info.fStatus = null; |
| try |
| { |
| setDocumentContent(info.fDocument, info.getEditorInput()); |
| } |
| catch (CoreException e) |
| { |
| info.fStatus = e.getStatus(); |
| } |
| if (!info.fCanBeSaved) |
| { |
| info.setModificationStamp(computeModificationStamp(info)); |
| } |
| addUnchangedElementListeners(info.getEditorInput(), info); |
| fireElementContentReplaced(info.getEditorInput()); |
| } |
| |
| /** |
| * @generated |
| */ |
| protected void handleElementMoved(IEditorInput input, URI uri) |
| { |
| if (input instanceof FileEditorInput) |
| { |
| IFile newFile = ResourcesPlugin.getWorkspace().getRoot() |
| .getFile(new Path(URI.decode(uri.path())).removeFirstSegments(1)); |
| fireElementMoved(input, newFile == null ? null : new FileEditorInput(newFile)); |
| return; |
| } |
| // TODO: append suffix to the URI! (use diagram as a parameter) |
| fireElementMoved(input, new URIEditorInput(uri)); |
| } |
| |
| /** |
| * @generated |
| */ |
| public IEditorInput createInputWithEditingDomain(IEditorInput editorInput, TransactionalEditingDomain domain) |
| { |
| return editorInput; |
| } |
| |
| /** |
| * @generated |
| */ |
| public IDiagramDocument getDiagramDocument(Object element) |
| { |
| IDocument doc = getDocument(element); |
| if (doc instanceof IDiagramDocument) |
| { |
| return (IDiagramDocument)doc; |
| } |
| return null; |
| } |
| |
| /** |
| * @generated |
| */ |
| @Override |
| protected IRunnableContext getOperationRunner(IProgressMonitor monitor) |
| { |
| return null; |
| } |
| |
| /** |
| * @generated |
| */ |
| protected class ResourceSetInfo extends ElementInfo |
| { |
| |
| /** |
| * @generated |
| */ |
| private long myModificationStamp = IResource.NULL_STAMP; |
| |
| /** |
| * @generated |
| */ |
| private WorkspaceSynchronizer mySynchronizer; |
| |
| /** |
| * @generated |
| */ |
| private LinkedList<Resource> myUnSynchronizedResources = new LinkedList<Resource>(); |
| |
| /** |
| * @generated |
| */ |
| private IDiagramDocument myDocument; |
| |
| /** |
| * @generated |
| */ |
| private IEditorInput myEditorInput; |
| |
| /** |
| * @generated |
| */ |
| private boolean myUpdateCache = true; |
| |
| /** |
| * @generated |
| */ |
| private boolean myModifiable = false; |
| |
| /** |
| * @generated |
| */ |
| private boolean myReadOnly = true; |
| |
| /** |
| * @generated |
| */ |
| private ResourceSetModificationListener myResourceSetListener; |
| |
| /** |
| * @generated |
| */ |
| public ResourceSetInfo(IDiagramDocument document, IEditorInput editorInput) |
| { |
| super(document); |
| myDocument = document; |
| myEditorInput = editorInput; |
| startResourceListening(); |
| myResourceSetListener = new ResourceSetModificationListener(this); |
| getResourceSet().eAdapters().add(myResourceSetListener); |
| } |
| |
| /** |
| * @generated |
| */ |
| public long getModificationStamp() |
| { |
| return myModificationStamp; |
| } |
| |
| /** |
| * @generated |
| */ |
| public void setModificationStamp(long modificationStamp) |
| { |
| myModificationStamp = modificationStamp; |
| } |
| |
| /** |
| * @generated |
| */ |
| public TransactionalEditingDomain getEditingDomain() |
| { |
| return myDocument.getEditingDomain(); |
| } |
| |
| /** |
| * @generated |
| */ |
| public ResourceSet getResourceSet() |
| { |
| return getEditingDomain().getResourceSet(); |
| } |
| |
| /** |
| * @generated |
| */ |
| public Iterator<Resource> getLoadedResourcesIterator() |
| { |
| return new ArrayList<Resource>(getResourceSet().getResources()).iterator(); |
| } |
| |
| /** |
| * @generated |
| */ |
| public IEditorInput getEditorInput() |
| { |
| return myEditorInput; |
| } |
| |
| /** |
| * @generated |
| */ |
| public void dispose() |
| { |
| stopResourceListening(); |
| getResourceSet().eAdapters().remove(myResourceSetListener); |
| for (Iterator<Resource> it = getLoadedResourcesIterator(); it.hasNext();) |
| { |
| Resource resource = it.next(); |
| resource.unload(); |
| } |
| getEditingDomain().dispose(); |
| } |
| |
| /** |
| * @generated |
| */ |
| public boolean isSynchronized() |
| { |
| return myUnSynchronizedResources.size() == 0; |
| } |
| |
| /** |
| * @generated |
| */ |
| public void setUnSynchronized(Resource resource) |
| { |
| myUnSynchronizedResources.add(resource); |
| } |
| |
| /** |
| * @generated |
| */ |
| public void setSynchronized(Resource resource) |
| { |
| myUnSynchronizedResources.remove(resource); |
| } |
| |
| /** |
| * @generated |
| */ |
| public final void stopResourceListening() |
| { |
| mySynchronizer.dispose(); |
| mySynchronizer = null; |
| } |
| |
| /** |
| * @generated |
| */ |
| public final void startResourceListening() |
| { |
| mySynchronizer = new WorkspaceSynchronizer(getEditingDomain(), new SynchronizerDelegate()); |
| } |
| |
| /** |
| * @generated |
| */ |
| public boolean isUpdateCache() |
| { |
| return myUpdateCache; |
| } |
| |
| /** |
| * @generated |
| */ |
| public void setUpdateCache(boolean update) |
| { |
| myUpdateCache = update; |
| } |
| |
| /** |
| * @generated |
| */ |
| public boolean isModifiable() |
| { |
| return myModifiable; |
| } |
| |
| /** |
| * @generated |
| */ |
| public void setModifiable(boolean modifiable) |
| { |
| myModifiable = modifiable; |
| } |
| |
| /** |
| * @generated |
| */ |
| public boolean isReadOnly() |
| { |
| return myReadOnly; |
| } |
| |
| /** |
| * @generated |
| */ |
| public void setReadOnly(boolean readOnly) |
| { |
| myReadOnly = readOnly; |
| } |
| |
| /** |
| * @generated |
| */ |
| private class SynchronizerDelegate implements WorkspaceSynchronizer.Delegate |
| { |
| |
| /** |
| * @generated |
| */ |
| public void dispose() |
| { |
| } |
| |
| /** |
| * @generated |
| */ |
| public boolean handleResourceChanged(final Resource resource) |
| { |
| synchronized (ResourceSetInfo.this) |
| { |
| if (ResourceSetInfo.this.fCanBeSaved) |
| { |
| setUnSynchronized(resource); |
| return true; |
| } |
| } |
| Display.getDefault().asyncExec(new Runnable() |
| { |
| public void run() |
| { |
| handleElementChanged(ResourceSetInfo.this, resource, null); |
| } |
| }); |
| return true; |
| } |
| |
| /** |
| * @generated |
| */ |
| public boolean handleResourceDeleted(Resource resource) |
| { |
| synchronized (ResourceSetInfo.this) |
| { |
| if (ResourceSetInfo.this.fCanBeSaved) |
| { |
| setUnSynchronized(resource); |
| return true; |
| } |
| } |
| Display.getDefault().asyncExec(new Runnable() |
| { |
| public void run() |
| { |
| fireElementDeleted(getEditorInput()); |
| } |
| }); |
| return true; |
| } |
| |
| /** |
| * @generated |
| */ |
| public boolean handleResourceMoved(Resource resource, final URI newURI) |
| { |
| synchronized (ResourceSetInfo.this) |
| { |
| if (ResourceSetInfo.this.fCanBeSaved) |
| { |
| setUnSynchronized(resource); |
| return true; |
| } |
| } |
| if (myDocument.getDiagram().eResource() == resource) |
| { |
| Display.getDefault().asyncExec(new Runnable() |
| { |
| public void run() |
| { |
| handleElementMoved(getEditorInput(), newURI); |
| } |
| }); |
| } |
| else |
| { |
| handleResourceDeleted(resource); |
| } |
| return true; |
| } |
| |
| } |
| |
| } |
| |
| /** |
| * @generated |
| */ |
| private class ResourceSetModificationListener extends EContentAdapter |
| { |
| |
| /** |
| * @generated |
| */ |
| private NotificationFilter myModifiedFilter; |
| |
| /** |
| * @generated |
| */ |
| private ResourceSetInfo myInfo; |
| |
| /** |
| * @generated |
| */ |
| public ResourceSetModificationListener(ResourceSetInfo info) |
| { |
| myInfo = info; |
| myModifiedFilter = NotificationFilter.createEventTypeFilter(Notification.SET) |
| .or(NotificationFilter.createEventTypeFilter(Notification.UNSET)) |
| .and(NotificationFilter.createFeatureFilter(Resource.class, Resource.RESOURCE__IS_MODIFIED)); |
| } |
| |
| /** |
| * @generated |
| */ |
| @Override |
| public void notifyChanged(Notification notification) |
| { |
| if (notification.getNotifier() instanceof ResourceSet) |
| { |
| super.notifyChanged(notification); |
| } |
| if (!notification.isTouch() && myModifiedFilter.matches(notification)) |
| { |
| if (notification.getNotifier() instanceof Resource) |
| { |
| Resource resource = (Resource)notification.getNotifier(); |
| if (resource.isLoaded()) |
| { |
| boolean modified = false; |
| for (Iterator /* <org.eclipse.emf.ecore.resource.Resource> */it = myInfo.getLoadedResourcesIterator(); it |
| .hasNext() && !modified;) |
| { |
| Resource nextResource = (Resource)it.next(); |
| if (nextResource.isLoaded()) |
| { |
| modified = nextResource.isModified(); |
| } |
| } |
| boolean dirtyStateChanged = false; |
| synchronized (myInfo) |
| { |
| if (modified != myInfo.fCanBeSaved) |
| { |
| myInfo.fCanBeSaved = modified; |
| dirtyStateChanged = true; |
| } |
| if (!resource.isModified()) |
| { |
| myInfo.setSynchronized(resource); |
| } |
| } |
| if (dirtyStateChanged) |
| { |
| fireElementDirtyStateChanged(myInfo.getEditorInput(), modified); |
| |
| if (!modified) |
| { |
| myInfo.setModificationStamp(computeModificationStamp(myInfo)); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| } |
| |
| } |
