Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2008 itemis AG (http://www.itemis.eu) 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.xtext.ui.editor.model;
 
 import java.util.Map;
 
 import  org.eclipse.core.resources.IEncodedStorage;
 import  org.eclipse.core.resources.IResourceStatus;
 import  org.eclipse.core.resources.IStorage;
 import  org.eclipse.core.runtime.CoreException;
 import  org.eclipse.core.runtime.IPath;
 import  org.eclipse.core.runtime.IProgressMonitor;
 import  org.eclipse.core.runtime.IStatus;
 import  org.eclipse.core.runtime.Status;
 import  org.eclipse.jface.text.DocumentEvent;
 import  org.eclipse.jface.text.IDocument;
 import  org.eclipse.jface.text.IDocumentExtension4;
 import  org.eclipse.jface.text.IDocumentListener;
 import  org.eclipse.jface.text.IDocumentPartitioner;
 import  org.eclipse.jface.text.source.AnnotationModel;
 import  org.eclipse.jface.text.source.IAnnotationModel;
 import  org.eclipse.ui.IEditorInput;
 import  org.eclipse.ui.IFileEditorInput;
 import  org.eclipse.ui.IStorageEditorInput;
 import  org.eclipse.ui.IURIEditorInput;
 import  org.eclipse.ui.PlatformUI;
 import  org.eclipse.ui.editors.text.FileDocumentProvider;
 

Author(s):
Peter Friese - Initial contribution and API
Sven Efftinge
Michael Clay
Heiko Behrens
Sebastian Zarnekow - Resetting unchanged flag on undo / redo, support for IURIEditorInput
Since:
2.4
 
 public class XtextDocumentProvider extends FileDocumentProvider {

Bundle of all required information to allow java.net.URI as underlying document content provider.

Since:
2.3
 
 	protected class URIInfo extends ElementInfo {

The flag representing the cached state whether the storage is modifiable.
 
 		public boolean isModifiablefalse;
The flag representing the cached state whether the storage is read-only.
 
 		public boolean isReadOnlytrue;
The flag representing the need to update the cached flag.
 
 		public boolean updateCachetrue;
 
 		public URIInfo(IDocument document, IAnnotationModel model) {
 			super(documentmodel);
 		}
 	}
 	
 
 	private Provider<IDocumentPartitioner> documentPartitioner;
 

Since:
2.4
	}
		XtextDocument xtextDocument = .get();
		return xtextDocument;
	}
	protected IDocument createDocument(Object elementthrows CoreException {
		IDocument document = null;
			documentcreateEmptyDocument();
			if (setDocumentContent(document, (IEditorInput) elementgetEncoding(element))) {
				setupDocument(elementdocument);
			}
else {
			document = super.createDocument(element);
		}
		if (document != null) {
			IDocumentPartitioner partitioner = .get();
			partitioner.connect(document);
			document.setDocumentPartitioner(partitioner);
		}
		return document;
	}
	public boolean isDeleted(Object element) {
			final IURIEditorInput input = (IURIEditorInput) element;
			boolean result = !input.exists();
			return result;
		}
		if (element instanceof IFileEditorInput) {
			final IFileEditorInput input = (IFileEditorInput) element;
			final IPath path = input.getFile().getLocation();
			if (path == null) {
				// return true;
				return !input.getFile().exists(); // fixed for EFS compatibility
			}
			return !path.toFile().exists();
		}
		return super.isDeleted(element);
	}
	protected boolean setDocumentContent(IDocument document, IEditorInput editorInputString encoding)
			throws CoreException {
		boolean result;
		if (isWorkspaceExternalEditorInput(editorInput)) {
			java.net.URI uri= ((IURIEditorInput) editorInput).getURI();
			try {
				InputStream contentStream = null;
				try {
					contentStream = uri.toURL().openStream();
					setDocumentContent(documentcontentStreamencoding);
finally {
					try {
						if (contentStream != null)
							contentStream.close();
catch (IOException e1) {
					}
				}
catch (IOException ex) {
				String message= (ex.getMessage() != null ? ex.getMessage() : ""); //$NON-NLS-1$
				IStatus snew Status(IStatus.ERROR, PlatformUI.PLUGIN_ID, IStatus.OK, messageex);
				throw new CoreException(s);
			result = true;
else {
			result = super.setDocumentContent(documenteditorInputencoding);
		}
		if (result
			setDocumentResource((XtextDocumentdocumenteditorInputencoding);
		return result;
	}

Since:
2.4
	protected void setDocumentResource(XtextDocument xtextDocument, IEditorInput editorInputString encodingthrows CoreException {
		try {
			// encoding can be null for FileRevisionEditorInput
			loadResource(xtextResourcextextDocument.get(), encoding == null ? getWorkspaceOrDefaultEncoding() : encoding);
			xtextResource.setModificationStamp(xtextDocument.getModificationStamp());
			xtextDocument.setInput(xtextResource);
catch(CoreException e) {
			throw e;
catch(RuntimeException e) {
			Throwable cause = e.getCause();
			if (cause instanceof CoreException) {
				throw (CoreException) cause;
			}
			throw new CoreException(new Status(IStatus.ERROR, .e.getMessage(), e));
		}
	}
	protected void disposeElementInfo(Object element, ElementInfo info) {
		if (info.fDocument instanceof XtextDocument) {
			XtextDocument document = (XtextDocumentinfo.fDocument;
			if (job != null) {
				job.cancel();
			}
			document.disposeInput();
		}
		super.disposeElementInfo(elementinfo);
	}
	protected void loadResource(XtextResource resourceString documentString encodingthrows CoreException {
		try {
			byte[] bytes = encoding != null ? document.getBytes(encoding) : document.getBytes();
			resource.load(new ByteArrayInputStream(bytes), Collections.singletonMap(.encoding));
catch (IOException ex) {
			String message = (ex.getMessage() != null ? ex.getMessage() : ex.toString());
			IStatus s = new Status(IStatus.ERROR, .messageex);
			throw new CoreException(s);
		}
	}
	protected ElementInfo createElementInfo(Object elementthrows CoreException {
		ElementInfo info;
			IDocument documentnull;
			IStatus statusnull;
			try {
				documentcreateDocument(element);
catch (CoreException x) {
				statusx.getStatus();
				documentcreateEmptyDocument();
			}
			infonew URIInfo(documentcreateAnnotationModel(element));
			info.fStatus= status;
else {
			info = super.createElementInfo(element);
		}
		return info;
	}

Since:
2.4
	protected void registerAnnotationInfoProcessor(ElementInfo info) {
		XtextDocument doc = (XtextDocumentinfo.fDocument;
		if(info.fModel != null) {
			AnnotationIssueProcessor annotationIssueProcessor = new AnnotationIssueProcessor(docinfo.fModel,
			ValidationJob job = new ValidationJob(docannotationIssueProcessor.);
		}
	}
	public class UnchangedElementListener implements IDocumentListener {
		private final ElementInfo element;
		private long modificationStamp;
		public UnchangedElementListener(ElementInfo element) {
			this. = element;
			if (element.fDocument instanceof IDocumentExtension4) {
				 = ((IDocumentExtension4) element.fDocument).getModificationStamp();
else {
				 = IDocumentExtension4.UNKNOWN_MODIFICATION_STAMP;
			}
		}
		public void documentAboutToBeChanged(DocumentEvent event) {
		}
		public void documentChanged(DocumentEvent event) {
			if (. &&  == event.getModificationStamp()) {
				fireElementDirtyStateChanged(..);
else if (!.) {
				fireElementDirtyStateChanged(..);
			}
		}
	}
	protected void addUnchangedElementListeners(Object element, ElementInfo info) {
		if (info.fDocument != null) {
			if ( != null)
				info.fDocument.removeDocumentListener();
			info.fDocument.addDocumentListener();
		}
	}
	protected void removeUnchangedElementListeners(Object element, ElementInfo info) {
		if ( != null) {
			info.fDocument.removeDocumentListener();
			 = null;
		}
	}
	protected IAnnotationModel createAnnotationModel(Object elementthrows CoreException {
		if (element instanceof IFileEditorInput) {
			IFileEditorInput input = (IFileEditorInput) element;
else if (element instanceof IURIEditorInput) {
			return new AnnotationModel();
		}
		return super.createAnnotationModel(element);
	}
	public void setResourceForEditorInputFactory(IResourceForEditorInputFactory resourceForEditorInputFactory) {
		this. = resourceForEditorInputFactory;
	}
	}
	public String getEncoding(Object element) {
		String encoding = super.getEncoding(element);
		if (encoding == null && element instanceof IStorageEditorInput) {
			try {
				IStorage storage = ((IStorageEditorInput) element).getStorage();
				URI uri = .getUri(storage);
				if (uri != null) {
					encoding = .getEncoding(uri);
else if (storage instanceof IEncodedStorage) {
					encoding = ((IEncodedStorage)storage).getCharset();
				}
catch (CoreException e) {
				throw new WrappedException(e);
			}
		}
		if (encoding == null) {
				encoding = getWorkspaceExternalEncoding((IURIEditorInput)element);
			else
		}
		return encoding;
	}

Since:
2.5
	protected String getWorkspaceExternalEncoding(IURIEditorInput element) {
		URI emfURI = toEmfUri(element.getURI());
	}

Since:
2.5
	}
	public boolean isSynchronized(Object element) {
		ElementInfo info = getElementInfo(element);
		if (info instanceof FileInfo) {
			FileInfo fileInfo = (FileInfo) getElementInfo(element);
			long modificationStamp = getModificationStamp(element);
			if (fileInfo.fModificationStamp != modificationStamp) {
				return false;
			}
		}
		return super.isSynchronized(element);
	}
	public boolean isModifiable(Object element) {
			URIInfo info= (URIInfogetElementInfo(element);
			if (info != null) {
				if (info.updateCache) {
					try {
						updateCache((IURIEditorInput) element);
catch (CoreException x) {
						handleCoreException(x"XtextDocumentProvider.isModifiable");
					}
				}
				return info.isModifiable;
			}
		}
		return super.isModifiable(element);
	}
	public boolean isReadOnly(Object element) {
			URIInfo info= (URIInfogetElementInfo(element);
			if (info != null) {
				if (info.updateCache) {
					try {
						updateCache((IURIEditorInput) element);
catch (CoreException x) {
						handleCoreException(x"XtextDocumentProvider.isReadOnly");
					}
				}
				return info.isReadOnly;
			}
		}
		return super.isReadOnly(element);
	}

Since:
2.3
	protected boolean isWorkspaceExternalEditorInput(Object element) {
		return element instanceof IURIEditorInput && !(element instanceof IFileEditorInput);
	}

Since:
2.3
	protected void updateCache(IURIEditorInput inputthrows CoreException {
		URIInfo info= (URIInfo) getElementInfo(input);
		if (info != null) {
			URI emfURI = toEmfUri(input.getURI());
			if (emfURI != null) {
				boolean readOnly = true;
				if (emfURI.isFile() && !emfURI.isArchive()) {
					// TODO: Should we use the ResourceSet somehow to obtain the URIConverter for the file protocol?
					// see also todo below, but don't run into a stackoverflow ;-)
					Map<String, ?> attributes = ..getAttributes(emfURInull);
				}
				info.isReadOnly=  readOnly;
				info.isModifiable= !readOnly;
			}
			info.updateCachefalse;
		}
	}
	private URI toEmfUri(java.net.URI uri) {
		if (uri == null)
			return null;
		String uriAsString = uri.toString();
		URI emfURI = URI.createURI(uriAsString);
		return emfURI;
	}
	private Charset getCharset(String name) {
		try {
			return Charset.forName(name);
			return Charset.defaultCharset();
		}
	}
	protected void doSaveDocument(IProgressMonitor monitorObject element, IDocument documentboolean overwrite)
			throws CoreException {
			IURIEditorInput casted = (IURIEditorInput) element;
			String encoding = getWorkspaceExternalEncoding(casted);
			CharsetEncoder encodergetCharset(encoding).newEncoder();
			OutputStream stream = null;
			try {
				try {
					monitor.beginTask("Saving", 2000);
					byte[] bytes;
					ByteBuffer byteBufferencoder.encode(CharBuffer.wrap(document.get()));
					if (byteBuffer.hasArray())
						bytesbyteBuffer.array();
					else {
						bytesnew byte[byteBuffer.limit()];
						byteBuffer.get(bytes);
					}
					// TODO: see todo above
					stream = ..createOutputStream(toEmfUri(casted.getURI()));
					stream.write(bytes, 0, byteBuffer.limit());
finally {
					monitor.done();
				}
catch (CharacterCodingException ex) {
				String message= MessageFormat.format("Some characters cannot be mapped using \"{0}\" character encoding.\n" +
						"Either change the encoding or remove the characters which are not supported by the \"{0}\" character encoding."new Object[]{ Charset.defaultCharset().name() });
				IStatus snew Status(IStatus.ERROR, ., 1 /* EditorsUI.CHARSET_MAPPING_FAILED */messagenull);
				throw new CoreException(s);
catch (IOException e) {
				String message"Could not save file.";
				IStatus snew Status(IStatus.ERROR, ., IResourceStatus.FAILED_WRITE_LOCAL, messagenull);
				throw new CoreException(s);
finally {
				try {
					Closeables.close(streamtrue);
catch (IOException e) {
					//never thrown, swallowed by Closeables.close
				}
			}
			return;
		}
		super.doSaveDocument(monitorelementdocumentoverwrite);
	}
	protected void doUpdateStateCache(Object elementthrows CoreException {
			URIInfo info= (URIInfogetElementInfo(element);
			if (info != null) {
				info.updateCachetrue;
				return;
			}
		}
		super.doUpdateStateCache(element);
	}
	protected void handleCoreException(CoreException exceptionString message) {
		if(exception.getStatus() == null || exception.getStatus().getCode() != IResourceStatus.RESOURCE_NOT_FOUND)
			super.handleCoreException(exceptionmessage);
	}
New to GrepCode? Check out our FAQ X