org.eclipse.jface.text.reconciler.IReconcilingStrategy Java Examples

/**
 * @see org.eclipse.jface.text.source.SourceViewerConfiguration#getReconciler(org.eclipse.jface.text.source.ISourceViewer)
 */
@Override
public IReconciler getReconciler(ISourceViewer sourceViewer) {
    if (fPreferenceStore == null || !fPreferenceStore.getBoolean(SpellingService.PREFERENCE_SPELLING_ENABLED))
        return null;
    if (!TexlipsePlugin.getDefault().getPreferenceStore().getBoolean(TexlipseProperties.ECLIPSE_BUILDIN_SPELLCHECKER))
        return null;
    //Set TeXlipse spelling Engine as default
    PreferenceStore store = new PreferenceStore();
    store.setValue(SpellingService.PREFERENCE_SPELLING_ENGINE, 
            "org.eclipse.texlipse.LaTeXSpellEngine");
    store.setValue(SpellingService.PREFERENCE_SPELLING_ENABLED, 
    true);
    SpellingService spellingService = new SpellingService(store);
    if (spellingService.getActiveSpellingEngineDescriptor(store) == null)
        return null;
    IReconcilingStrategy strategy= new TeXSpellingReconcileStrategy(sourceViewer, spellingService);
    
    MonoReconciler reconciler= new MonoReconciler(strategy, true);
    reconciler.setDelay(500);
    reconciler.setProgressMonitor(new NullProgressMonitor());
    return reconciler;
}
 

@Override
public IReconciler getReconciler(ISourceViewer sourceViewer) {
	if (!EditorsUI.getPreferenceStore().getBoolean(SpellingService.PREFERENCE_SPELLING_ENABLED))
		return null;

	IReconcilingStrategy strategy= new SpellingReconcileStrategy(sourceViewer, EditorsUI.getSpellingService()) {
		@Override
		protected IContentType getContentType() {
			return PROPERTIES_CONTENT_TYPE;
		}
	};

	MonoReconciler reconciler= new MonoReconciler(strategy, false);
	reconciler.setDelay(500);
	return reconciler;
}
 

@Override
public IReconciler getReconciler(ISourceViewer sourceViewer) {
	if (!EditorsUI.getPreferenceStore().getBoolean(SpellingService.PREFERENCE_SPELLING_ENABLED))
		return null;

	IReconcilingStrategy strategy = new SpellingReconcileStrategy(sourceViewer, EditorsUI.getSpellingService()) {
		@Override
		protected IContentType getContentType() {
			return EditorConfigTextTools.EDITORCONFIG_CONTENT_TYPE;
		}
	};

	MonoReconciler reconciler = new MonoReconciler(strategy, false);
	reconciler.setDelay(500);
	return reconciler;
}
 

@Override
public IReconciler getReconciler(ISourceViewer sourceViewer) {
    if (fPreferenceStore == null || !fPreferenceStore.getBoolean(SpellingService.PREFERENCE_SPELLING_ENABLED)) {
        return null;
    }

    SpellingService spellingService = EditorsUI.getSpellingService();
    if (spellingService.getActiveSpellingEngineDescriptor(fPreferenceStore) == null) {
        return null;
    }

    //Overridden (just) to return a PyReconciler!
    IReconcilingStrategy strategy = new PyReconciler(sourceViewer, spellingService);

    MonoReconciler reconciler = new MonoReconciler(strategy, false);
    reconciler.setIsIncrementalReconciler(false);
    reconciler.setProgressMonitor(new NullProgressMonitor());
    reconciler.setDelay(500);
    return reconciler;
}
 

public void fullReconcile()
{
	for (IReconcilingStrategy strategy : fStrategies)
	{
		if (strategy instanceof IBatchReconcilingStrategy)
		{
			IBatchReconcilingStrategy extension = (IBatchReconcilingStrategy) strategy;
			extension.fullReconcile();
		}
	}
}
 

public void initialReconcile()
{
	for (IReconcilingStrategy strategy : fStrategies)
	{
		if (strategy instanceof IReconcilingStrategyExtension)
		{
			IReconcilingStrategyExtension extension = (IReconcilingStrategyExtension) strategy;
			extension.initialReconcile();
		}
	}
}
 

public void setProgressMonitor(IProgressMonitor monitor)
{
	for (IReconcilingStrategy strategy : fStrategies)
	{
		if (strategy instanceof IReconcilingStrategyExtension)
		{
			IReconcilingStrategyExtension extension = (IReconcilingStrategyExtension) strategy;
			extension.setProgressMonitor(monitor);
		}
	}
}
 

public void reconcile(IRegion partition)
{
	for (IReconcilingStrategy strategy : fStrategies)
	{
		strategy.reconcile(partition);
	}
}
 

public void reconcile(DirtyRegion dirtyRegion, IRegion subRegion)
{
	for (IReconcilingStrategy strategy : fStrategies)
	{
		strategy.reconcile(dirtyRegion, subRegion);
	}
}
 

public void setDocument(IDocument document)
{
	for (IReconcilingStrategy strategy : fStrategies)
	{
		strategy.setDocument(document);
	}
}
 

/**
 * Creates a new Java reconciling strategy.
 *
 * @param viewer the source viewer
 * @param editor the editor of the strategy's reconciler
 * @param documentPartitioning the document partitioning this strategy uses for configuration
 */
public JavaCompositeReconcilingStrategy(ISourceViewer viewer, ITextEditor editor, String documentPartitioning) {
	fEditor= editor;
	fJavaStrategy= new JavaReconcilingStrategy(editor);
	setReconcilingStrategies(new IReconcilingStrategy[] {
		fJavaStrategy,
		new JavaSpellingReconcileStrategy(viewer, editor)
	});
}
 

/**
 * 
 */
public CommonReconciler(IReconcilingStrategy defaultStrategy)
{
	super();
	this.defaultStrategy = defaultStrategy;
	setReconcilingStrategy(defaultStrategy, String.valueOf(System.currentTimeMillis()));
}
 

@Override
public IReconcilingStrategy getReconcilingStrategy(String contentType)
{
	IReconcilingStrategy strategy = super.getReconcilingStrategy(contentType);
	if (strategy != null)
	{
		return strategy;
	}
	return defaultStrategy;
}
 

public void dispose()
{
	for (IReconcilingStrategy strategy : fStrategies)
	{
		if (strategy instanceof IDisposableReconcilingStrategy)
		{
			((IDisposableReconcilingStrategy) strategy).dispose();
		}
	}
}
 

@Override
protected void initialProcess()
{
	for (IReconcilingStrategy s : reconcilingStrategies)
	{
		if (s instanceof IReconcilingStrategyExtension)
		{
			((IReconcilingStrategyExtension) s).initialReconcile();
		}
	}
	fInitialProcessDone = true;
}
 

@Override
public IReconciler getReconciler(ISourceViewer sourceViewer) {
  JavaReconciler reconciler = (JavaReconciler) super.getReconciler(sourceViewer);
  if (reconciler != null) {
    try {
      JavaCompositeReconcilingStrategy strategy = (JavaCompositeReconcilingStrategy) reconciler.getReconcilingStrategy(IDocument.DEFAULT_CONTENT_TYPE);
      IReconcilingStrategy[] strategies = strategy.getReconcilingStrategies();
      IReconcilingStrategy[] newStrategies = new IReconcilingStrategy[strategies.length];
      for (int i = 0; i < strategies.length; i++) {
        if (strategies[i] instanceof JavaSpellingReconcileStrategy) {
          // Replace the default Java reconcile strategy with our own, which
          // will suppress spell checking within JSNI blocks
          newStrategies[i] = new GWTJavaSpellingReconcileStrategy(
              sourceViewer, getEditor());
        } else {
          newStrategies[i] = strategies[i];
        }
      }
      strategy.setReconcilingStrategies(newStrategies);
    } catch (Exception e) {
      // We're being defensive to ensure that we always return a reconciler
      GWTPluginLog.logError(e);
    }
    return reconciler;
  }

  return null;
}
 

@Override
protected IReconcilingStrategy getSpellcheckStrategy() {
  if (spellcheckStrategy == null) {
    String contentTypeId = getContentType(getDocument());
    if (contentTypeId != null) {
      if (getTextViewer() instanceof ISourceViewer) {
        ISourceViewer viewer = (ISourceViewer) getTextViewer();
        spellcheckStrategy = new UiBinderSpellcheckStrategy(viewer,
            contentTypeId);
        spellcheckStrategy.setDocument(getDocument());
      }
    }
  }
  return spellcheckStrategy;
}
 

protected IReconcilingStrategy getCodeLensStrategy() {
	if (!TypeScriptUIPlugin.getDefault().getPreferenceStore()
			.getBoolean(TypeScriptUIPreferenceConstants.EDITOR_ACTIVATE_CODELENS)) {
		return null;
	}
	if (codeLensStrategy == null && getDocument() != null) {
		if (getTextViewer() instanceof ISourceViewer) {
			ISourceViewer viewer = (ISourceViewer) getTextViewer();
			codeLensStrategy = new TypeScriptCodeLensStrategy(viewer);
			codeLensStrategy.setDocument(getDocument());
			codeLensStrategy.setProgressMonitor(new NullProgressMonitor());
		}
	}
	return codeLensStrategy;
}
 

protected IReconcilingStrategy getTypeScriptFoldingStrategy() {
	if ("org.eclipse.wst.jsdt.core.jsSource".equals(contentType)) {
		return super.getFoldingStrategy();
	}
	if (foldingStrategy == null) {
		ITextViewer viewer = getTextViewer();
		if (viewer instanceof ProjectionViewer) {
			foldingStrategy = new TypeScriptFoldingStrategy();
			foldingStrategy.setViewer((ProjectionViewer) viewer);
			foldingStrategy.setDocument(getDocument());
		}
	}
	return foldingStrategy;
}
 

/**
 * @param strategy
 * @param contentTypes
 */
public void setReconcilingStrategy(IReconcilingStrategy strategy, Collection<String> contentTypes)
{
	for (String contentType : contentTypes)
	{
		setReconcilingStrategy(strategy, contentType);
	}
}
 

@Override
public IReconciler getReconciler(ISourceViewer sourceViewer)
{
	if (fTextEditor != null && fTextEditor.isEditable())
	{
		IReconcilingStrategy reconcilingStrategy = new CommonReconcilingStrategy(fTextEditor);
		if (EditorsUI.getPreferenceStore().getBoolean(SpellingService.PREFERENCE_SPELLING_ENABLED))
		{
			SpellingService spellingService = EditorsUI.getSpellingService();
			Collection<String> spellingContentTypes = getSpellingContentTypes(sourceViewer);
			if (spellingService.getActiveSpellingEngineDescriptor(fPreferenceStore) != null
					&& !spellingContentTypes.isEmpty())
			{
				reconcilingStrategy = new CompositeReconcilingStrategy(reconcilingStrategy,
						new MultiRegionSpellingReconcileStrategy(sourceViewer, spellingService,
								getConfiguredDocumentPartitioning(sourceViewer), spellingContentTypes));
			}
		}
		CommonReconciler reconciler = new CommonReconciler(reconcilingStrategy);
		reconciler.setDocumentPartitioning(getConfiguredDocumentPartitioning(sourceViewer));
		reconciler.setIsIncrementalReconciler(false);
		reconciler.setIsAllowedToModifyDocument(false);
		reconciler.setProgressMonitor(new NullProgressMonitor());
		reconciler.setDelay(500);
		return fReconciler = reconciler;
	}
	return null;
}
 

/**
 * {@inheritDoc}
 */
@Override
public void initialReconcile() {
    if (strategies == null)
        return;

    for (IReconcilingStrategy strategy : strategies) {
        if (strategy instanceof IReconcilingStrategyExtension) {
            IReconcilingStrategyExtension extension = (IReconcilingStrategyExtension)strategy;
            extension.initialReconcile();
        }
    }
}
 

/**
 * {@inheritDoc}
 */
@Override
public void setProgressMonitor(IProgressMonitor monitor) {
    if (strategies == null)
        return;

    for (IReconcilingStrategy strategy : strategies) {
        if (strategy instanceof IReconcilingStrategyExtension) {
            IReconcilingStrategyExtension extension = (IReconcilingStrategyExtension)strategy;
            extension.setProgressMonitor(monitor);
        }
    }
}
 

/**
 * {@inheritDoc}
 */
@Override
public void reconcile(IRegion partition) {
    if (strategies == null)
        return;

    for (IReconcilingStrategy strategy : strategies) {
        strategy.reconcile(partition);
    }
}
 

/**
 * {@inheritDoc}
 */
@Override
public void reconcile(DirtyRegion dirtyRegion, IRegion subRegion) {
    if (strategies == null)
        return;

    for (IReconcilingStrategy strategy : strategies) {
        strategy.reconcile(dirtyRegion, subRegion);
    }
}
 

/**
 * {@inheritDoc}
 */
@Override
public void setDocument(IDocument document) {
    if (strategies == null)
        return;

    for (IReconcilingStrategy strategy : strategies) {
        strategy.setDocument(document);
    }
}
 

@Override
public IReconcilingStrategy create(ISourceViewer viewer) {
	if (viewer instanceof ISourceViewerExtension5) {
		return new XtextCodeMiningReconcileStrategy((ISourceViewerExtension5) viewer);
	}
	return null;
}
 

default IReconcilingStrategy createOrNull(ISourceViewer viewer) {
	try {
		return create(viewer);
	} catch(Throwable t) {
		return null;
	}
}
 

/**
 * @since 2.3
 */
@Override
public void initialReconcile() {
	for (IReconcilingStrategy strategy: strategies) {
		if (strategy instanceof IReconcilingStrategyExtension) {
			((IReconcilingStrategyExtension) strategy).initialReconcile();
		}
	}
}
 

/**
 * @since 2.3
 */
@Override
public void setProgressMonitor(IProgressMonitor monitor) {
	this.monitor = monitor;
	for (IReconcilingStrategy strategy: strategies) {
		if (strategy instanceof IReconcilingStrategyExtension) {
			((IReconcilingStrategyExtension) strategy).setProgressMonitor(monitor);
		}
	}
}