| /******************************************************************************* |
| * Copyright (c) 2000, 2017 IBM Corporation 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 |
| * |
| *******************************************************************************/ |
| package org.eclipse.dltk.internal.ui.editor; |
| |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.content.IContentType; |
| import org.eclipse.jface.text.IDocument; |
| import org.eclipse.jface.text.source.IAnnotationModel; |
| import org.eclipse.ui.editors.text.IStorageDocumentProvider; |
| import org.eclipse.ui.texteditor.IDocumentProvider; |
| import org.eclipse.ui.texteditor.IDocumentProviderExtension; |
| import org.eclipse.ui.texteditor.IDocumentProviderExtension2; |
| import org.eclipse.ui.texteditor.IDocumentProviderExtension3; |
| import org.eclipse.ui.texteditor.IDocumentProviderExtension4; |
| import org.eclipse.ui.texteditor.IDocumentProviderExtension5; |
| import org.eclipse.ui.texteditor.IElementStateListener; |
| |
| |
| /** |
| * A forwarding document provider is a document provider that forwards all requests |
| * to a known parent document provider. The only functional addition of the |
| * forwarding document provider is that it ensures that all documents provided |
| * to clients are appropriately set up. |
| * <p> |
| * This document provider should be used by editors that directly or indirectly |
| * work with a {@link org.eclipse.ui.editors.text.TextFileDocumentProvider} and do not |
| * accept that they may be provided with documents which do not contain the partitioning |
| * they work on. This can happen either because of a plug-in configuration error |
| * or when a user associates a file name or file extension with an existing text |
| * editor and the file buffer infrastructure does not recognize that file name |
| * or file extension to be of the same file type the editor works on. Thus, the |
| * document provided for the files with that name or extension may not be set up |
| * in the way the editor expects it. The <code>ForwardingDocumentProvider</code> |
| * compensates for that situation. |
| * </p> |
| * <p> |
| * Editors that directly work with a {@link org.eclipse.ui.editors.text.TextFileDocumentProvider} can |
| * now use a <code>ForwardingDocumentProvider</code> instead and configure a |
| * {@link org.eclipse.ui.editors.text.TextFileDocumentProvider} as its parent provider. Editors that |
| * indirectly work with a {@link org.eclipse.ui.editors.text.TextFileDocumentProvider}, e.g. never |
| * set a document provider explicitly, should explicitly set a |
| * <code>ForwardingDocumentProvider</code> as document provider. In this case |
| * the forwarding document provider may not be shared between editors. |
| * </p> |
| * |
| * |
| */ |
| public class SourceForwardingDocumentProvider implements IDocumentProvider, IDocumentProviderExtension, IDocumentProviderExtension2, IDocumentProviderExtension3, IDocumentProviderExtension4, IDocumentProviderExtension5, IStorageDocumentProvider { |
| |
| private IDocumentProvider fParentProvider; |
| private boolean fAllowSetParentProvider; |
| |
| |
| /** |
| * Creates a new forwarding document provider with a fixed parent document provider. Calling |
| * {@link #setParentProvider(IDocumentProvider)} does not have any effect on this object. |
| * |
| * @param partitioning the partitioning |
| * @param documentSetupParticipant the document setup participant |
| * @param parentProvider the parent document provider |
| */ |
| public SourceForwardingDocumentProvider(IDocumentProvider parentProvider) { |
| fParentProvider= parentProvider; |
| fAllowSetParentProvider= false; |
| } |
| |
| /** |
| * Sets the parent document provider. This method has only an effect if the |
| * forwarding document provider has accordingly be created. |
| * |
| * @param parentProvider the new parent document provider |
| */ |
| public void setParentProvider(IDocumentProvider parentProvider) { |
| if (fAllowSetParentProvider) |
| fParentProvider= parentProvider; |
| } |
| |
| @Override |
| public void connect(Object element) throws CoreException { |
| fParentProvider.connect(element); |
| } |
| |
| @Override |
| public void disconnect(Object element) { |
| fParentProvider.disconnect(element); |
| } |
| |
| @Override |
| public IDocument getDocument(Object element) { |
| return fParentProvider.getDocument(element); |
| } |
| |
| @Override |
| public void resetDocument(Object element) throws CoreException { |
| fParentProvider.resetDocument(element); |
| } |
| |
| @Override |
| public void saveDocument(IProgressMonitor monitor, Object element, IDocument document, boolean overwrite) throws CoreException { |
| fParentProvider.saveDocument(monitor, element, document, overwrite); |
| } |
| |
| @Override |
| public long getModificationStamp(Object element) { |
| return fParentProvider.getModificationStamp(element); |
| } |
| |
| @Override |
| public long getSynchronizationStamp(Object element) { |
| return fParentProvider.getSynchronizationStamp(element); |
| } |
| |
| @Override |
| public boolean isDeleted(Object element) { |
| return fParentProvider.isDeleted(element); |
| } |
| |
| @Override |
| public boolean mustSaveDocument(Object element) { |
| return fParentProvider.mustSaveDocument(element); |
| } |
| |
| @Override |
| public boolean canSaveDocument(Object element) { |
| return fParentProvider.canSaveDocument(element); |
| } |
| |
| @Override |
| public IAnnotationModel getAnnotationModel(Object element) { |
| return fParentProvider.getAnnotationModel(element); |
| } |
| |
| @Override |
| public void aboutToChange(Object element) { |
| fParentProvider.aboutToChange(element); |
| } |
| |
| @Override |
| public void changed(Object element) { |
| fParentProvider.changed(element); |
| } |
| |
| @Override |
| public void addElementStateListener(IElementStateListener listener) { |
| fParentProvider.addElementStateListener(listener); |
| } |
| |
| @Override |
| public void removeElementStateListener(IElementStateListener listener) { |
| fParentProvider.removeElementStateListener(listener); |
| } |
| |
| @Override |
| public boolean isReadOnly(Object element) { |
| if (fParentProvider instanceof IDocumentProviderExtension) { |
| IDocumentProviderExtension extension= (IDocumentProviderExtension)fParentProvider; |
| return extension.isReadOnly(element); |
| } |
| return false; |
| } |
| |
| @Override |
| public boolean isModifiable(Object element) { |
| if (fParentProvider instanceof IDocumentProviderExtension) { |
| IDocumentProviderExtension extension= (IDocumentProviderExtension)fParentProvider; |
| return extension.isModifiable(element); |
| } |
| return true; |
| } |
| |
| @Override |
| public void validateState(Object element, Object computationContext) throws CoreException { |
| if (fParentProvider instanceof IDocumentProviderExtension) { |
| IDocumentProviderExtension extension= (IDocumentProviderExtension)fParentProvider; |
| extension.validateState(element, computationContext); |
| } |
| } |
| |
| @Override |
| public boolean isStateValidated(Object element) { |
| if (fParentProvider instanceof IDocumentProviderExtension) { |
| IDocumentProviderExtension extension= (IDocumentProviderExtension)fParentProvider; |
| return extension.isStateValidated(element); |
| } |
| return true; |
| } |
| |
| @Override |
| public void updateStateCache(Object element) throws CoreException { |
| if (fParentProvider instanceof IDocumentProviderExtension) { |
| IDocumentProviderExtension extension= (IDocumentProviderExtension)fParentProvider; |
| extension.updateStateCache(element); |
| } |
| } |
| |
| @Override |
| public void setCanSaveDocument(Object element) { |
| if (fParentProvider instanceof IDocumentProviderExtension) { |
| IDocumentProviderExtension extension= (IDocumentProviderExtension)fParentProvider; |
| extension.setCanSaveDocument(element); |
| } |
| } |
| |
| @Override |
| public IStatus getStatus(Object element) { |
| if (fParentProvider instanceof IDocumentProviderExtension) { |
| IDocumentProviderExtension extension= (IDocumentProviderExtension)fParentProvider; |
| return extension.getStatus(element); |
| } |
| return null; |
| } |
| |
| @Override |
| public void synchronize(Object element) throws CoreException { |
| if (fParentProvider instanceof IDocumentProviderExtension) { |
| IDocumentProviderExtension extension= (IDocumentProviderExtension)fParentProvider; |
| extension.synchronize(element); |
| } |
| } |
| |
| @Override |
| public void setProgressMonitor(IProgressMonitor progressMonitor) { |
| if (fParentProvider instanceof IDocumentProviderExtension2) { |
| IDocumentProviderExtension2 extension= (IDocumentProviderExtension2)fParentProvider; |
| extension.setProgressMonitor(progressMonitor); |
| } |
| } |
| |
| @Override |
| public IProgressMonitor getProgressMonitor() { |
| if (fParentProvider instanceof IDocumentProviderExtension2) { |
| IDocumentProviderExtension2 extension= (IDocumentProviderExtension2)fParentProvider; |
| return extension.getProgressMonitor(); |
| } |
| return null; |
| } |
| |
| @Override |
| public boolean isSynchronized(Object element) { |
| if (fParentProvider instanceof IDocumentProviderExtension3) { |
| IDocumentProviderExtension3 extension= (IDocumentProviderExtension3)fParentProvider; |
| return extension.isSynchronized(element); |
| } |
| return true; |
| } |
| |
| @Override |
| public boolean isNotSynchronizedException(Object element, CoreException ex) { |
| if (fParentProvider instanceof IDocumentProviderExtension5) { |
| IDocumentProviderExtension5 extension= (IDocumentProviderExtension5)fParentProvider; |
| return extension.isNotSynchronizedException(element, ex); |
| } |
| return false; |
| } |
| |
| @Override |
| public IContentType getContentType(Object element) throws CoreException { |
| if (fParentProvider instanceof IDocumentProviderExtension4) { |
| IDocumentProviderExtension4 extension= (IDocumentProviderExtension4)fParentProvider; |
| return extension.getContentType(element); |
| } |
| return null; |
| } |
| |
| @Override |
| public String getDefaultEncoding() { |
| if (fParentProvider instanceof IStorageDocumentProvider) { |
| IStorageDocumentProvider provider= (IStorageDocumentProvider)fParentProvider; |
| return provider.getDefaultEncoding(); |
| } |
| return null; |
| } |
| |
| @Override |
| public String getEncoding(Object element) { |
| if (fParentProvider instanceof IStorageDocumentProvider) { |
| IStorageDocumentProvider provider= (IStorageDocumentProvider)fParentProvider; |
| return provider.getEncoding(element); |
| } |
| return null; |
| } |
| |
| @Override |
| public void setEncoding(Object element, String encoding) { |
| if (fParentProvider instanceof IStorageDocumentProvider) { |
| IStorageDocumentProvider provider= (IStorageDocumentProvider)fParentProvider; |
| provider.setEncoding(element, encoding); |
| } |
| } |
| } |