Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2010 Christoph Kulla 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: Christoph Kulla - Initial API and implementation /
 
 package org.eclipse.xtext.ui.editor.hover;
 
 import java.util.List;
 
 import  org.eclipse.core.runtime.Assert;
 import  org.eclipse.jface.action.ToolBarManager;
 import  org.eclipse.jface.resource.JFaceResources;
 import  org.eclipse.jface.text.AbstractInformationControl;
 import  org.eclipse.jface.text.AbstractReusableInformationControlCreator;
 import  org.eclipse.jface.text.IDocument;
 import  org.eclipse.jface.text.IInformationControl;
 import  org.eclipse.jface.text.IInformationControlCreator;
 import  org.eclipse.jface.text.IInformationControlExtension2;
 import  org.eclipse.jface.text.IInformationControlExtension4;
 import  org.eclipse.jface.text.IRewriteTarget;
 import  org.eclipse.jface.text.ITextViewer;
 import  org.eclipse.jface.text.ITextViewerExtension;
 import  org.eclipse.jface.text.Position;
 import  org.eclipse.jface.text.Region;
 import  org.eclipse.jface.text.contentassist.ICompletionProposal;
 import  org.eclipse.jface.text.contentassist.ICompletionProposalExtension;
 import  org.eclipse.jface.text.contentassist.ICompletionProposalExtension2;
 import  org.eclipse.jface.text.quickassist.IQuickAssistInvocationContext;
 import  org.eclipse.jface.text.source.Annotation;
 import  org.eclipse.swt.SWT;
 import  org.eclipse.swt.custom.ScrolledComposite;
 import  org.eclipse.swt.custom.StyledText;
 import  org.eclipse.swt.events.FocusEvent;
 import  org.eclipse.swt.events.FocusListener;
 import  org.eclipse.swt.events.KeyEvent;
 import  org.eclipse.swt.events.KeyListener;
 import  org.eclipse.swt.events.MouseEvent;
 import  org.eclipse.swt.events.MouseListener;
 import  org.eclipse.swt.events.PaintEvent;
 import  org.eclipse.swt.events.PaintListener;
 import  org.eclipse.swt.events.SelectionAdapter;
 import  org.eclipse.swt.events.SelectionEvent;
 import  org.eclipse.swt.graphics.Color;
 import  org.eclipse.swt.graphics.Font;
 import  org.eclipse.swt.graphics.Image;
 import  org.eclipse.swt.graphics.Point;
 import  org.eclipse.swt.graphics.Rectangle;
 import  org.eclipse.swt.layout.GridData;
 import  org.eclipse.swt.layout.GridLayout;
 import  org.eclipse.swt.widgets.Canvas;
 import  org.eclipse.swt.widgets.Composite;
 import  org.eclipse.swt.widgets.Control;
 import  org.eclipse.swt.widgets.Display;
 import  org.eclipse.swt.widgets.Label;
 import  org.eclipse.swt.widgets.Link;
 import  org.eclipse.swt.widgets.ScrollBar;
 import  org.eclipse.swt.widgets.Shell;
 import  org.eclipse.ui.editors.text.EditorsUI;
 import  org.eclipse.ui.texteditor.DefaultMarkerAnnotationAccess;
 
Hover which shows annotation and quick fixes. Clone from JDTs org.eclipse.jdt.internal.ui.text.java.hover.AbstractAnnotationHover.

Author(s):
Christoph Kulla
 
 
 // Following differences exist between AbstractAnnotationHover and AnnotationWithQuickFixesHover:
 //
 // 1) AnnotationInfo provides proposals directly, no need of subclassing
 // 2) Configuration of the hover content via preferences in the ui is not supported yet
 // 3) List of Quickfixes is retrieved from an XtextQuickAssistProcessor
 // 4) Removed access to JavaHoverMessages and replaced with XtextUIMessages
 // 5) Dropped support of FixCorrectionProposal and ICleanUp (JDT concept)
 // 6) Removed field fAnnotationAccess, DefaultMarkerAnnotationAccesss is not supported as we have no preferences
 // 7) Removed field fAllAnnotations, no filtering of only Java Annotations required
 // 8) instead of being an abstract class this a non abstract class
 
 // All comments starting with DIFF describes differences between the two versions
 
 // If no comments appear the code does not differ from AbstractAnnotationHover.
 
 // DIFF: AnnotationWithQuickFixesHover is is not abstract (8)
 
 	
	// DIFF: not part of AbstractAnnotationHover (3)
	// public to give access in tests
	public static class AnnotationInfo {
		public final Annotation annotation;
		public final Position position;
		public final ITextViewer viewer;
		// DIFF: not part of AbstractAnnotationHover (1)
		public final ICompletionProposal[] proposals;
		public AnnotationInfo(Annotation annotation, Position position, ITextViewer textViewer, ICompletionProposal[] proposals) {
			this.annotation;
			this.position;
			this.textViewer;
			// DIFF: not part of AbstractAnnotationHover(1)
			this. = proposals;
		}

Create completion proposals which can resolve the given annotation at the given position. Returns an empty array if no such proposals exist.

Returns:
the proposals or an empty array
		public ICompletionProposal[] getCompletionProposals() {
			// DIFF: return proposals directly, no subclassing (1)
			return ;
		}

Adds actions to the given toolbar.

Parameters:
manager the toolbar manager to add actions to
infoControl the information control
		public void fillToolBar(ToolBarManager manager, IInformationControl infoControl) {
			// DIFF: disabled as configuration is not supported yet (2)
//			ConfigureAnnotationsAction configureAnnotationsAction= new ConfigureAnnotationsAction(annotation, infoControl);
//			manager.add(configureAnnotationsAction);
		}
	}
	private static class AnnotationInformationControl extends AbstractInformationControl implements IInformationControlExtension2 {
		private final DefaultMarkerAnnotationAccess fMarkerAnnotationAccess;
		private Control fFocusControl;
		private Composite fParent;
		public AnnotationInformationControl(Shell parentShellString statusFieldText) {
			super(parentShellstatusFieldText);
			new DefaultMarkerAnnotationAccess();
		}
		public AnnotationInformationControl(Shell parentShell, ToolBarManager toolBarManager) {
			super(parentShelltoolBarManager);
			new DefaultMarkerAnnotationAccess();
		}
		public AnnotationInformationControl(Shell parentShellboolean resizeable) {
			super(parentShellresizeable);
			new DefaultMarkerAnnotationAccess();
		}		
		/*
		 * @see org.eclipse.jface.text.IInformationControl#setInformation(java.lang.String)
		 */
		public void setInformation(String information) {
			//replaced by IInformationControlExtension2#setInput
		}
		public void setInput(Object input) {
			Assert.isLegal(input instanceof AnnotationInfo);
		}
		public boolean hasContents() {
			return  != null;
		}
			return ;
		}
		public void setFocus() {
			super.setFocus();
			if ( != null)
				.setFocus();
		}
		public final void setVisible(boolean visible) {
			if (!visible)
			super.setVisible(visible);
		}
		protected void disposeDeferredCreatedContent() {
			Control[] children.getChildren();
			for (int i= 0; i < children.length; i++) {
				children[i].dispose();
			}
			ToolBarManager toolBarManagergetToolBarManager();
			if (toolBarManager != null)
				toolBarManager.removeAll();
		}
		/*
		 * @see org.eclipse.jface.text.AbstractInformationControl#createContent(org.eclipse.swt.widgets.Composite)
		 */
		protected void createContent(Composite parent) {
			parent;
			GridLayout layoutnew GridLayout(1, false);
			layout.verticalSpacing= 0;
			layout.marginWidth= 0;
			layout.marginHeight= 0;
			.setLayout(layout);
		}
		public Point computeSizeHint() {
			Point preferedSizegetShell().computeSize(SWT.DEFAULT, SWT.DEFAULT, true);
			Point constrainsgetSizeConstraints();
			if (constrains == null)
				return preferedSize;
			Point constrainedSizegetShell().computeSize(constrains.x, SWT.DEFAULT, true);
			int width= Math.min(preferedSize.x, constrainedSize.x);
			int height= Math.max(preferedSize.y, constrainedSize.y);
			return new Point(widthheight);
		}

Fills the toolbar actions, if a toolbar is available. This is called after the input has been set.
		protected void fillToolbar() {
			ToolBarManager toolBarManagergetToolBarManager();
			if (toolBarManager == null)
				return;
			.fillToolBar(toolBarManagerthis);
			toolBarManager.update(true);
		}

Create content of the hover. This is called after the input has been set.
		protected void deferredCreateContent() {
			setColorAndFont(.getForeground(), .getBackground(), JFaceResources.getDialogFont());
			ICompletionProposal[] proposalsgetAnnotationInfo().getCompletionProposals();
			if (proposals.length > 0)
			.layout(true);
		}
		private void setColorAndFont(Control control, Color foreground, Color background, Font font) {
			control.setForeground(foreground);
			control.setBackground(background);
			control.setFont(font);
			if (control instanceof Composite) {
				Control[] children= ((Composite) control).getChildren();
				for (int i= 0; i < children.length; i++) {
					setColorAndFont(children[i], foregroundbackgroundfont);
				}
			}
		}
		private void createAnnotationInformation(Composite parentfinal Annotation annotation) {
			Composite compositenew Composite(parent, SWT.NONE);
			composite.setLayoutData(new GridData(SWT.FILL, SWT.TOP, truefalse));
			GridLayout layoutnew GridLayout(2, false);
			layout.marginHeight= 2;
			layout.marginWidth= 2;
			layout.horizontalSpacing= 0;
			composite.setLayout(layout);
			final Canvas canvasnew Canvas(composite, SWT.NO_FOCUS);
			GridData gridDatanew GridData(SWT.BEGINNING, SWT.BEGINNING, falsefalse);
			gridData.widthHint= 17;
			gridData.heightHint= 16;
			canvas.setLayoutData(gridData);
			canvas.addPaintListener(new PaintListener() {
				public void paintControl(PaintEvent e) {
					e.gc.setFont(null);
					.paint(annotatione.gc, canvasnew Rectangle(0, 0, 16, 16));
				}
			});
			StyledText textnew StyledText(composite, SWT.MULTI | SWT.WRAP | SWT.READ_ONLY);
			GridData datanew GridData(SWT.FILL, SWT.FILL, truetrue);
			text.setLayoutData(data);
			String annotationTextannotation.getText();
			if (annotationText != null)
				text.setText(annotationText);
		}
		private void createCompletionProposalsControl(Composite parent, ICompletionProposal[] proposals) {
			Composite compositenew Composite(parent, SWT.NONE);
			composite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, truetrue));
			GridLayout layout2new GridLayout(1, false);
			layout2.marginHeight= 0;
			layout2.marginWidth= 0;
			layout2.verticalSpacing= 2;
			composite.setLayout(layout2);
			Label separatornew Label(composite, SWT.SEPARATOR | SWT.HORIZONTAL);
			GridData gridDatanew GridData(SWT.FILL, SWT.CENTER, truefalse);
			separator.setLayoutData(gridData);
			Label quickFixLabelnew Label(composite, SWT.NONE);
			GridData layoutDatanew GridData(SWT.BEGINNING, SWT.CENTER, falsefalse);
			layoutData.horizontalIndent= 4;
			quickFixLabel.setLayoutData(layoutData);
			String text;
			if (proposals.length == 1) {
				// DIFF: replaced JavaHoverMessages with XtextUIMessages (4)
else {
				// DIFF: replaced JavaHoverMessages with XtextUIMessages (4)
				text= MessageFormat.format(.new Object[] { String.valueOf(proposals.length) });
			}
			quickFixLabel.setText(text);
			setColorAndFont(compositeparent.getForeground(), parent.getBackground(), JFaceResources.getDialogFont());
			createCompletionProposalsList(compositeproposals);
		}
		private void createCompletionProposalsList(Composite parent, ICompletionProposal[] proposals) {
			final ScrolledComposite scrolledCompositenew ScrolledComposite(parent, SWT.V_SCROLL | SWT.H_SCROLL);
			GridData gridDatanew GridData(SWT.FILL, SWT.FILL, truetrue);
			scrolledComposite.setLayoutData(gridData);
			scrolledComposite.setExpandVertical(false);
			scrolledComposite.setExpandHorizontal(false);
			Composite compositenew Composite(scrolledComposite, SWT.NONE);
			composite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, truetrue));
			GridLayout layoutnew GridLayout(2, false);
			layout.marginLeft= 5;
			layout.verticalSpacing= 2;
			composite.setLayout(layout);
			List<Link> listnew ArrayList<Link>();
			for (int i= 0; i < proposals.length; i++) {
				list.add(createCompletionProposalLink(compositeproposals[i], 1));// Original link for single fix, hence pass 1 for count
				// DIFF: outcommented, no support of FixCorrectionProposal and ICleanUp (5)
//				if (proposals[i] instanceof FixCorrectionProposal) {
//					FixCorrectionProposal proposal= (FixCorrectionProposal)proposals[i];
//					int count= proposal.computeNumberOfFixesForCleanUp(proposal.getCleanUp());
//					if (count > 1) {
//						list.add(createCompletionProposalLink(composite, proposals[i], count));
//					}
//				}
			}
			final Link[] linkslist.toArray(new Link[list.size()]);
			scrolledComposite.setContent(composite);
			setColorAndFont(scrolledCompositeparent.getForeground(), parent.getBackground(), JFaceResources.getDialogFont());
			Point contentSizecomposite.computeSize(SWT.DEFAULT, SWT.DEFAULT);
			composite.setSize(contentSize);
			Point constraintsgetSizeConstraints();
			if (constraints != null && contentSize.x < constraints.x) {
				ScrollBar horizontalBarscrolledComposite.getHorizontalBar();
				int scrollBarHeight;
				if (horizontalBar == null) {
					Point scrollSizescrolledComposite.computeSize(SWT.DEFAULT, SWT.DEFAULT);
					scrollBarHeightscrollSize.y - contentSize.y;
else {
					scrollBarHeighthorizontalBar.getSize().y;
				}
				gridData.heightHint= contentSize.y - scrollBarHeight;
			}
			links[0];
			for (int i= 0; i < links.length; i++) {
				final int indexi;
				final Link linklinks[index];
				link.addKeyListener(new KeyListener() {
					public void keyPressed(KeyEvent e) {
						switch (e.keyCode) {
							case SWT.ARROW_DOWN:
								if (index + 1 < links.length) {
									links[index + 1].setFocus();
								}
								break;
							case SWT.ARROW_UP:
								if (index > 0) {
									links[index - 1].setFocus();
								}
								break;
							default:
								break;
						}
					}
					public void keyReleased(KeyEvent e) {
					}
				});
				link.addFocusListener(new FocusListener() {
					public void focusGained(FocusEvent e) {
						int currentPositionscrolledComposite.getOrigin().y;
						int hightscrolledComposite.getSize().y;
						int linkPositionlink.getLocation().y;
						if (linkPosition < currentPosition) {
							if (linkPosition < 10)
								linkPosition= 0;
							scrolledComposite.setOrigin(0, linkPosition);
else if (linkPosition + 20 > currentPosition + hight) {
							scrolledComposite.setOrigin(0, linkPosition - hight + link.getSize().y);
						}
					}
					public void focusLost(FocusEvent e) {
					}
				});
			}
		}
		private Link createCompletionProposalLink(Composite parentfinal ICompletionProposal proposalint count) {
			final boolean isMultiFixcount > 1;
			if (isMultiFix) {
				new Label(parent, SWT.NONE); // spacer to fill image cell
				parentnew Composite(parent, SWT.NONE); // indented composite for multi-fix
				GridLayout layoutnew GridLayout(2, false);
				layout.marginWidth= 0;
				layout.marginHeight= 0;
				parent.setLayout(layout);
			}
			Label proposalImagenew Label(parent, SWT.NONE);
			proposalImage.setLayoutData(new GridData(SWT.BEGINNING, SWT.CENTER, falsefalse));
			Image image/*isMultiFix ? JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_MULTI_FIX) : */proposal.getImage();
			if (image != null) {
				proposalImage.setImage(image);
				proposalImage.addMouseListener(new MouseListener() {
					public void mouseDoubleClick(MouseEvent e) {
					}
					public void mouseDown(MouseEvent e) {
					}
					public void mouseUp(MouseEvent e) {
						if (e.button == 1) {
							apply(proposal...isMultiFix);
						}
					}
				});
			}
			Link proposalLinknew Link(parent, SWT.WRAP);
			GridData layoutDatanew GridData(SWT.BEGINNING, SWT.CENTER, falsefalse);
			String linkText;
			if (isMultiFix) {
				// DIFF: XtextUIMessages (4)
				linkText= MessageFormat.format(.new Object[] { String.valueOf(count) });
else {
				linkTextproposal.getDisplayString();
			}
			proposalLink.setText("<a>" + linkText + "</a>"); //$NON-NLS-1$ //$NON-NLS-2$
			proposalLink.setLayoutData(layoutData);
			proposalLink.addSelectionListener(new SelectionAdapter() {
				public void widgetSelected(SelectionEvent e) {
					apply(proposal...isMultiFix);
				}
			});
			return proposalLink;
		}
		private void apply(ICompletionProposal p, ITextViewer viewerint offsetboolean isMultiFix) {
			//Focus needs to be in the text viewer, otherwise linked mode does not work
			IRewriteTarget targetnull;
			try {
				IDocument documentviewer.getDocument();
				if (viewer instanceof ITextViewerExtension) {
					ITextViewerExtension extension= (ITextViewerExtension) viewer;
					targetextension.getRewriteTarget();
				}
				if (target != null)
					target.beginCompoundChange();
				if (p instanceof ICompletionProposalExtension2) {
					ICompletionProposalExtension2 e= (ICompletionProposalExtension2) p;
					e.apply(viewer, (char) 0, isMultiFix ? SWT.CONTROL : SWT.NONE, offset);
else if (p instanceof ICompletionProposalExtension) {
					ICompletionProposalExtension e= (ICompletionProposalExtension) p;
					e.apply(document, (char) 0, offset);
else {
					p.apply(document);
				}
				Point selectionp.getSelection(document);
				if (selection != null) {
					viewer.setSelectedRange(selection.x, selection.y);
					viewer.revealRange(selection.x, selection.y);
				}
finally {
				if (target != null)
					target.endCompoundChange();
			}
		}
	}
	private static final class PresenterControlCreator extends AbstractReusableInformationControlCreator {
		public IInformationControl doCreateInformationControl(Shell parent) {
			// DIFF: do not show toolbar in hover, no configuration supported (2)
			// return new AnnotationInformationControl(parent, new ToolBarManager(SWT.FLAT));
			return new AnnotationInformationControl(parenttrue);
		}
	}
	private static final class HoverControlCreator extends AbstractReusableInformationControlCreator {
		private final IInformationControlCreator fPresenterControlCreator;
		public HoverControlCreator(IInformationControlCreator presenterControlCreator) {
			presenterControlCreator;
		}
		public IInformationControl doCreateInformationControl(Shell parent) {
			return new AnnotationInformationControl(parent, EditorsUI.getTooltipAffordanceString()) {
				public IInformationControlCreator getInformationPresenterControlCreator() {
				}
			};
		}
		public boolean canReuse(IInformationControl control) {
			if (!super.canReuse(control))
				return false;
			if (control instanceof IInformationControlExtension4)
				((IInformationControlExtension4) control).setStatusText(EditorsUI.getTooltipAffordanceString());
			return true;
		}
	}
	// DIFF: added this Runnable to execute quickAssistProposals to retrieve proposal list (3)
	private final class CompletionProposalRunnable implements Runnable {
		public ICompletionProposal[] proposals = null;
		IQuickAssistInvocationContext invocationContext;
		public CompletionProposalRunnable(IQuickAssistInvocationContext invocationContext) {
			this. = invocationContext;
		}
		public void run() {
		}
	}
	// DIFF: outcommented, no configuration supported (3)
//	/**
//	 * Action to configure the annotation preferences.
//	 *
//	 * @since 3.4
//	 */
//	private static final class ConfigureAnnotationsAction extends Action {
//
//		private final Annotation fAnnotation;
//		private final IInformationControl fInfoControl;
//
//		public ConfigureAnnotationsAction(Annotation annotation, IInformationControl infoControl) {
//			super();
//			fAnnotation= annotation;
//			fInfoControl= infoControl;
//			setImageDescriptor(JavaPluginImages.DESC_ELCL_CONFIGURE_ANNOTATIONS);
//			setDisabledImageDescriptor(JavaPluginImages.DESC_DLCL_CONFIGURE_ANNOTATIONS);
//			setToolTipText(JavaHoverMessages.AbstractAnnotationHover_action_configureAnnotationPreferences);
//		}
//
//		/*
//		 * @see org.eclipse.jface.action.Action#run()
//		 */
//		@Override
//		public void run() {
//			Shell shell= PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
//
//			Object data= null;
//			AnnotationPreference preference= getAnnotationPreference(fAnnotation);
//			if (preference != null)
//				data= preference.getPreferenceLabel();
//
//			fInfoControl.dispose(); //FIXME: should have protocol to hide, rather than dispose
//			PreferencesUtil.createPreferenceDialogOn(shell, "org.eclipse.ui.editors.preferencePages.Annotations", null, data).open(); //$NON-NLS-1$
//		}
//	}
//	private final IPreferenceStore fStore= JavaPlugin.getDefault().getCombinedPreferenceStore();
	// DIFF: (6)
//	private final DefaultMarkerAnnotationAccess fAnnotationAccess= new DefaultMarkerAnnotationAccess();
	// DIFF: (7)
//	private final boolean fAllAnnotations;
The hover control creator.

Since:
3.4
	private IInformationControlCreator fHoverControlCreator;
The presentation control creator.

Since:
3.4
	private IInformationControlCreator fPresenterControlCreator;
	// DIFF: this code is entirely different, as the hover subclasses from AbstractProblemHover and 
	// hooks different methods
	protected Region getHoverRegionInternal(final int lineNumberfinal int offset) {
		List<Annotation> annotations = getAnnotations(lineNumberoffset);
		if (annotations != null) {
			for (Annotation annotation : annotations) {
				Position position = .getAnnotationModel().getPosition(annotation);
				if (position != null) {
					final int start = position.getOffset();
					return new Region (startposition.getLength());	
				}
			}
		}
		return null;
	}
	// DIFF: this code is entirely different, as the hover subclasses from AbstractProblemHover and 
	// hooks different methods
	protected Object getHoverInfoInternal(ITextViewer textViewerfinal int lineNumberfinal int offset) {
		if (result != null)
			return result;
		List<Annotation> annotations = getAnnotations(lineNumberoffset);
		if (annotations != null) {
			for (Annotation annotation : annotations) {
				if (annotation.getText() != null) {
					Position position = getAnnotationModel().getPosition(annotation);
					final QuickAssistInvocationContext invocationContext = new QuickAssistInvocationContext(position.getOffset(), position.getLength(), true);
					CompletionProposalRunnable runnable = new CompletionProposalRunnable(invocationContext);	
					// Note: the resolutions have to be retrieved from the UI thread, otherwise
					// workbench.getActiveWorkbenchWindow() will return null in LanguageSpecificURIEditorOpener and
					// cause an exception
					Display.getDefault().syncExec(runnable);
					if (invocationContext.isMarkedCancelled()) {
						return null;
					}
					result = new AnnotationInfo (annotationpositionrunnable.proposals);
					return result;
				}
			}
		}
		return null;
	}
	public IInformationControlCreator getHoverControlCreator() {
		if ( == null)
	}
	public IInformationControlCreator getInformationPresenterControlCreator() {
	}
	// DIFF: not required, get AnnotationModel via getAnnotationModel and not from the 
	// file buffer manager
//	private IPath getEditorInputPath() {
//		if (getEditor() == null)
//			return null;
//
//		IEditorInput input= getEditor().getEditorInput();
//		if (input instanceof IStorageEditorInput) {
//			try {
//				return ((IStorageEditorInput)input).getStorage().getFullPath();
//			} catch (CoreException ex) {
//				JavaPlugin.log(ex.getStatus());
//			}
//		}
//		return null;
//	}
//	private IAnnotationModel getAnnotationModel(IPath path) {
//		if (path == null)
//			return null;
//
//		ITextFileBufferManager manager= FileBuffers.getTextFileBufferManager();
//		try {
//			manager.connect(path, LocationKind.NORMALIZE, null);
//		} catch (CoreException ex) {
//			JavaPlugin.log(ex.getStatus());
//			return null;
//		}
//
//		IAnnotationModel model= null;
//		try {
//			model= manager.getTextFileBuffer(path, LocationKind.NORMALIZE).getAnnotationModel();
//			return model;
//		} finally {
//			if (model == null) {
//				try {
//					manager.disconnect(path, LocationKind.NORMALIZE, null);
//				} catch (CoreException ex) {
//					JavaPlugin.log(ex.getStatus());
//				}
//			}
//		}
//	}
	// DIFF: not required, as preferences are not supported (2)
//	/**
//	 * Returns the annotation preference for the given annotation.
//	 *
//	 * @param annotation the annotation
//	 * @return the annotation preference or <code>null</code> if none
//	 */
//	private static AnnotationPreference getAnnotationPreference(Annotation annotation) {
//
//		if (annotation.isMarkedDeleted())
//			return null;
//		return EditorsUI.getAnnotationPreferenceLookup().getAnnotationPreference(annotation);
//	}
New to GrepCode? Check out our FAQ X