* Copyright (c) 2001, 2011 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

*

* Contributors:

*     IBM Corporation - initial API and implementation

*     Jens Lukowski/Innoopract - initial renaming/restructuring

*    

*******************************************************************************/

* Configuration for the source viewer used by StructuredTextEditor.<br />

* Note: While ISourceViewer is passed in for each get configuration, clients

* should create a new viewer configuration instance for each instance of

* source viewer as some methods return the same instance of an object,

* regardless of the sourceviewer.

* <p>

* Clients should subclass and override just those methods which must be

* specific to their needs.

* </p>

*

* @see org.eclipse.wst.sse.ui.StructuredTextEditor

* @see org.eclipse.wst.sse.ui.internal.StructuredTextViewer

* @since 1.0

*/

  /**

   * One instance per configuration because creating a second assistant that

   * is added to a viewer can cause odd key-eating by the wrong one.

   */

  private StructuredContentAssistant fContentAssistant = null;

 

  /*

   * One instance per configuration because it's just like content assistant

   */

  private IQuickAssistAssistant fQuickAssistant = null;

  /*

   * One instance per configuration

   */

  private IReconciler fReconciler;

  /**

   * Extended configuration provisionalConfiguration type to contribute

   * additional auto edit strategies

   */

  private final String AUTOEDITSTRATEGY = "autoeditstrategy"; //$NON-NLS-1$

 

  private final String CONTENT_ASSIST_SIZE = "contentassistsize";

 

  private ReconcilerHighlighter fHighlighter = null;

 

  /**

   * Creates a structured text viewer configuration.

   */

  public StructuredTextViewerConfiguration() {

    super();

    // initialize fPreferenceStore with same preference store used in

    // StructuredTextEditor

    fPreferenceStore = createCombinedPreferenceStore();

  }

  /**

   * Create a preference store that combines the source editor preferences

   * with the base editor's preferences.

   *

   * @return IPreferenceStore

   */

  private IPreferenceStore createCombinedPreferenceStore() {

    IPreferenceStore sseEditorPrefs = SSEUIPlugin.getDefault().getPreferenceStore();

    IPreferenceStore baseEditorPrefs = EditorsUI.getPreferenceStore();

    return new ChainedPreferenceStore(new IPreferenceStore[]{sseEditorPrefs, baseEditorPrefs});

  }

  /**

   * Note: Clients cannot override this method because this method returns a

   * specially configured Annotation Hover for the StructuredTextViewer

   *

   * (non-Javadoc)

   * @see org.eclipse.ui.editors.text.TextSourceViewerConfiguration#getAnnotationHover(org.eclipse.jface.text.source.ISourceViewer)

   */

  final public IAnnotationHover getAnnotationHover(ISourceViewer sourceViewer) {

    return new StructuredTextAnnotationHover() {

      protected boolean isIncluded(Annotation annotation) {

        return isShowInVerticalRuler(annotation);

      }

    };

  }

  /**

   * Get color for the preference key. Assumes fPreferenceStore is not null.

   *

   * @param key

   * @return Color for preference key or null if none found

   */

  private Color getColor(String key) {

    RGB rgb = PreferenceConverter.getColor(fPreferenceStore, key);

    return EditorUtility.getColor(rgb);

  }

  /* (non-Javadoc)

   * @see org.eclipse.jface.text.source.SourceViewerConfiguration#getAutoEditStrategies(org.eclipse.jface.text.source.ISourceViewer, java.lang.String)

   */

  public IAutoEditStrategy[] getAutoEditStrategies(ISourceViewer sourceViewer, String contentType) {

    List allStrategies = new ArrayList(0);

    IAutoEditStrategy[] superStrategies = super.getAutoEditStrategies(sourceViewer, contentType);

    for (int i = 0; i < superStrategies.length; i++) {

      allStrategies.add(superStrategies[i]);

    }

    // add auto edit strategies contributed by clients

    List extendedAutoEdits = ExtendedConfigurationBuilder.getInstance().getConfigurations(AUTOEDITSTRATEGY, contentType);

    if (!extendedAutoEdits.isEmpty()) {

      allStrategies.addAll(extendedAutoEdits);

    }

    return (IAutoEditStrategy[]) allStrategies.toArray(new IAutoEditStrategy[allStrategies.size()]);

  }

  /**

   * Returns the configured partitioning for the given source viewer. The

   * partitioning is used when the querying content types from the source

   * viewer's input document.<br />

   * Note: Clients cannot override this method at this time.

   *

   * @param sourceViewer

   *            the source viewer to be configured by this configuration

   * @return the configured partitioning

   * @see #getConfiguredContentTypes(ISourceViewer)

   */

  final public String getConfiguredDocumentPartitioning(ISourceViewer sourceViewer) {

    /*

     * This implementation returns default structured text partitioning

     */

    return IStructuredPartitioning.DEFAULT_STRUCTURED_PARTITIONING;

  }

  public int[] getConfiguredTextHoverStateMasks(ISourceViewer sourceViewer, String contentType) {

    /*

     * This implementation returns configured text hover state masks for

     * StructuredTextViewers

     */

    TextHoverManager.TextHoverDescriptor[] hoverDescs = SSEUIPlugin.getDefault().getTextHoverManager().getTextHovers();

    int stateMasks[] = new int[hoverDescs.length];

    int stateMasksLength = 0;

    for (int i = 0; i < hoverDescs.length; i++) {

      if (hoverDescs[i].isEnabled()) {

        int j = 0;

        int stateMask = computeStateMask(hoverDescs[i].getModifierString());

        while (j < stateMasksLength) {

          if (stateMasks[j] == stateMask)

            break;

          j++;

        }

        if (j == stateMasksLength)

          stateMasks[stateMasksLength++] = stateMask;

      }

    }

    if (stateMasksLength == hoverDescs.length)

      return stateMasks;

    int[] shortenedStateMasks = new int[stateMasksLength];

    System.arraycopy(stateMasks, 0, shortenedStateMasks, 0, stateMasksLength);

    return shortenedStateMasks;

  }

  /**

   * Returns the content assistant ready to be used with the given source

   * viewer.<br />

   * Note: The same instance of IContentAssistant is returned regardless of

   * the source viewer passed in.

   * <p>

   * Clients should generally not override this method. Instead, clients

   * wanting to add their own processors should override

   * <code>getContentAssistProcessors(ISourceViewer, String)</code>

   * </p>

   *

   * @param sourceViewer

   *            the source viewer to be configured by this configuration

   * @return a content assistant

   * @see #getContentAssistProcessors(ISourceViewer, String)

   */

  public IContentAssistant getContentAssistant(ISourceViewer sourceViewer) {

    /*

     * Note: This method was made final so that StructuredContentAssist is

     * always used and content assist extension point always works.

     */

    if (fContentAssistant == null) {

      fContentAssistant = new StructuredContentAssistant();

      // content assistant configurations

      fContentAssistant.setDocumentPartitioning(getConfiguredDocumentPartitioning(sourceViewer));

      fContentAssistant.enableAutoActivation(true);

      fContentAssistant.setProposalPopupOrientation(IContentAssistant.PROPOSAL_OVERLAY);

      fContentAssistant.setContextInformationPopupOrientation(IContentAssistant.CONTEXT_INFO_ABOVE);

      fContentAssistant.setInformationControlCreator(getInformationControlCreator(sourceViewer));

      fContentAssistant.enableColoredLabels(PlatformUI.getPreferenceStore().getBoolean(IWorkbenchPreferenceConstants.USE_COLORED_LABELS));

      // set content assist preferences

      if (fPreferenceStore != null) {

        int delay = fPreferenceStore.getInt(EditorPreferenceNames.CODEASSIST_AUTOACTIVATION_DELAY);

        fContentAssistant.setAutoActivationDelay(delay);

        Color color = getColor(EditorPreferenceNames.CODEASSIST_PROPOSALS_BACKGROUND);

        fContentAssistant.setProposalSelectorBackground(color);

        color = getColor(EditorPreferenceNames.CODEASSIST_PROPOSALS_FOREGROUND);

        fContentAssistant.setProposalSelectorForeground(color);

        color = getColor(EditorPreferenceNames.CODEASSIST_PARAMETERS_BACKGROUND);

        fContentAssistant.setContextInformationPopupBackground(color);

        fContentAssistant.setContextSelectorBackground(color);

        color = getColor(EditorPreferenceNames.CODEASSIST_PARAMETERS_FOREGROUND);

        fContentAssistant.setContextInformationPopupForeground(color);

        fContentAssistant.setContextSelectorForeground(color);

      }

     

      // add content assist processors for each partition type

      String[] types = getConfiguredContentTypes(sourceViewer);

      for (int i = 0; i < types.length; i++) {

        String type = types[i];

        // add all content assist processors for current partiton type

        IContentAssistProcessor[] processors = getContentAssistProcessors(sourceViewer, type);

        if (processors != null) {

          for (int j = 0; j < processors.length; j++) {

            fContentAssistant.setContentAssistProcessor(processors[j], type);

          }

        }

      }

      IDialogSettings dialogSettings = SSEUIPlugin.getInstance().getDialogSettings();

      if(dialogSettings != null) {

        IDialogSettings section = dialogSettings.getSection(CONTENT_ASSIST_SIZE);

        if(section == null) {

          section = dialogSettings.addNewSection(CONTENT_ASSIST_SIZE);

        }

        fContentAssistant.setRestoreCompletionProposalSize(section);

      }

    }

    return fContentAssistant;

  }

  /**

   * <p>Returns a {@link StructuredContentAssistProcessor} which can be contributed to through

   * the <tt>org.eclipse.wst.sse.ui.completionProposal</tt> extension point.</p>

   *

   * <p>If an extender of this class overrides this method and does not include an

   * implementation of a {@link StructuredContentAssistProcessor} in their returned

   * processors then all of the contributions by the aforementioned extension point

   * will be left out.</p>

   *

   * @param sourceViewer

   *            the source viewer to be configured by this configuration

   * @param partitionType

   *            the partition type for which the content assist processors

   *            are applicable

   * @return IContentAssistProcessors or null if should not be supported

   */

  protected IContentAssistProcessor[] getContentAssistProcessors(ISourceViewer sourceViewer, String partitionType) {

    IContentAssistProcessor processor = new StructuredContentAssistProcessor(

        fContentAssistant, partitionType, sourceViewer, null);

    return new IContentAssistProcessor[]{processor};

  }

  /**

   * Returns the content formatter ready to be used with the given source

   * viewer.

   * <p>

   * It is not recommended that clients override this method as it may

   * become <code>final</code> in the future and replaced by an extensible

   * framework.

   * </p>

   *

   * @param sourceViewer

   *            the source viewer to be configured by this configuration

   * @return a content formatter or <code>null</code> if formatting should

   *         not be supported

   */

  public IContentFormatter getContentFormatter(ISourceViewer sourceViewer) {

    // try to use the StructuredTextMultiPassContentFormatter so that it

    // picks up any additional formatting strategies contributed via the

    // editorConfiguration extension point

    IContentFormatter formatter = null;

    if (sourceViewer != null) {

      IDocument document = sourceViewer.getDocument();

      if (document instanceof IDocumentExtension3) {

        String partitioning = getConfiguredDocumentPartitioning(sourceViewer);

        IDocumentPartitioner partitioner = ((IDocumentExtension3) document).getDocumentPartitioner(partitioning);

        if (partitioner instanceof StructuredTextPartitioner) {

          String defaultPartitionType = ((StructuredTextPartitioner) partitioner).getDefaultPartitionType();

          formatter = new StructuredTextMultiPassContentFormatter(partitioning, defaultPartitionType);

        }

      }

    }

    return formatter;

  }

  /**

   * Returns the double-click strategy ready to be used in this viewer when

   * double clicking onto text of the given content type. Note that if

   * clients want to contribute their own doubleclick strategy, they should

   * use <code>org.eclipse.wst.sse.ui.editorConfiguration</code> extension

   * point's <code>doubleClickStrategy</code> element instead of

   * overriding this method. If clients do override this method, please

   * remember to call <code>super.getDoubleClickStrategy()</code>.

   *

   * @param sourceViewer

   *            the source viewer to be configured by this configuration

   * @param contentType

   *            the content type for which the strategy is applicable

   * @return a double-click strategy or <code>null</code> if double

   *         clicking should not be supported

   */

  public ITextDoubleClickStrategy getDoubleClickStrategy(ISourceViewer sourceViewer, String contentType) {

    ITextDoubleClickStrategy strategy = null;

    Object extendedStrategy = ExtendedConfigurationBuilder.getInstance().getConfiguration(ExtendedConfigurationBuilder.DOUBLECLICKSTRATEGY, contentType);

    if (extendedStrategy instanceof ITextDoubleClickStrategy) {

      strategy = (ITextDoubleClickStrategy) extendedStrategy;

    }

    else {

      strategy = super.getDoubleClickStrategy(sourceViewer, contentType);

    }

    return strategy;

  }

  /**

   * Returns the hyperlink presenter for the given source viewer.<br />

   * Note: Clients cannot override this method, and although it's no longer

   * necessary, it must remain for binary compatibility.

   *

   * @param sourceViewer

   *            the source viewer to be configured by this configuration

   * @return a hyperlink presenter specially configured for

   *         StructuredTextViewer

   */

  final public IHyperlinkPresenter getHyperlinkPresenter(ISourceViewer sourceViewer) {

    if (fPreferenceStore == null) {

      return super.getHyperlinkPresenter(sourceViewer);

    }

    return new MultipleHyperlinkPresenter(fPreferenceStore);

  }

 

  /**

   * Returns the information control creator. The creator is a factory

   * creating information controls for the given source viewer.<br />

   * Note: Clients cannot override this method at this time.

   *

   * @param sourceViewer

   *            the source viewer to be configured by this configuration

   * @return the information control creator

   */

  final public IInformationControlCreator getInformationControlCreator(ISourceViewer sourceViewer) {

    // used by hover help

    return new IInformationControlCreator() {

      public IInformationControl createInformationControl(Shell parent) {

        return new DefaultInformationControl(parent, new HTMLTextPresenter(true));

      }

    };

  }

  /**

   * Returns the information presenter ready to be used with the given

   * source viewer.

   * <p>

   * Clients cannot override this method. Instead, clients wanting to add

   * their own information providers should override

   * <code>getInformationProvider(ISourceViewer, String)</code>

   * </p>

   *

   * @param sourceViewer

   *            the source viewer to be configured by this configuration

   * @return a content assistant

   * @see #getInformationProvider(ISourceViewer, String)

   */

  final public IInformationPresenter getInformationPresenter(ISourceViewer sourceViewer) {

    InformationPresenter presenter = new InformationPresenter(getInformationPresenterControlCreator(sourceViewer));

    // information presenter configurations

    presenter.setSizeConstraints(60, 10, true, true);

    presenter.setDocumentPartitioning(getConfiguredDocumentPartitioning(sourceViewer));

    // add information providers for each partition type

    String[] types = getConfiguredContentTypes(sourceViewer);

    for (int i = 0; i < types.length; i++) {

      String type = types[i];

      IInformationProvider provider = getInformationProvider(sourceViewer, type);

      if (provider != null) {

        presenter.setInformationProvider(provider, type);

      }

    }

    return presenter;

  }

  /**

   * Returns the information provider that will be used for information

   * presentation in the given source viewer and for the given partition

   * type.

   *

   * @param sourceViewer

   *            the source viewer to be configured by this configuration

   * @param partitionType

   *            the partition type for which the information provider is

   *            applicable

   * @return IInformationProvider or null if should not be supported

   * @deprecated instead of overriding this method to provide documentation

   *             information, adopters should use the

   *             <code>documentationTextHover</code> element in the

   *             <code>org.eclipse.wst.sse.ui.editorConfiguration</code>

   *             extension point

   */

  protected IInformationProvider getInformationProvider(ISourceViewer sourceViewer, String partitionType) {

    ITextHover bestMatchHover = new BestMatchHover(partitionType);

    return new TextHoverInformationProvider(bestMatchHover);

  }

  /**

   * Returns the information presenter control creator. The creator is a

   * factory creating the presenter controls for the given source viewer.

   *

   * @param sourceViewer

   *            the source viewer to be configured by this configuration

   * @return an information control creator

   */

  private IInformationControlCreator getInformationPresenterControlCreator(ISourceViewer sourceViewer) {

    return new IInformationControlCreator() {

      public IInformationControl createInformationControl(Shell parent) {

        int shellStyle = SWT.RESIZE | SWT.TOOL;

        int style = SWT.V_SCROLL | SWT.H_SCROLL;

        return new DefaultInformationControl(parent, shellStyle, style, new HTMLTextPresenter(false));

      }

    };

  }

  /**

   * Returns the line style providers that will be used for syntax

   * highlighting in the given source viewer.

   * <p>

   * Not fully API since return type LineStyleProvider is not API.

   * </p>

   *

   * @param sourceViewer

   *            the source viewer to be configured by this configuration

   * @param partitionType

   *            the partition type for which the lineStyleProviders are

   *            applicable

   * @return LineStyleProvders or null if should not be supported

   */

  public LineStyleProvider[] getLineStyleProviders(ISourceViewer sourceViewer, String partitionType) {

    return null;

  }

  /**

   * See <code>getLineStyleProviders(ISourceViewer, String)</code> for

   * alternative way to provide highlighting information.

   *

   * @param sourceViewer

   *            the source viewer to be configured by this configuration

   * @return always returns null

   * @see #getLineStyleProviders(ISourceViewer, String)

   */

  public IPresentationReconciler getPresentationReconciler(ISourceViewer sourceViewer) {

    StructuredPresentationReconciler reconciler = new StructuredPresentationReconciler();

    reconciler.setDocumentPartitioning(getConfiguredDocumentPartitioning(sourceViewer));

   

    String[] contentTypes = getConfiguredContentTypes(sourceViewer);

   

    if(contentTypes != null) {

      StructuredDocumentDamagerRepairer dr = null;

     

      for (int i = 0; i < contentTypes.length; i++) {

        if (fHighlighter != null) {

          LineStyleProvider provider = fHighlighter.getProvider(contentTypes[i]);

          if (provider == null)

            continue;

         

          dr = new StructuredDocumentDamagerRepairer(provider);

          dr.setDocument(sourceViewer.getDocument());

          reconciler.setDamager(dr, contentTypes[i]);

          reconciler.setRepairer(dr, contentTypes[i]);

        }

      }

    }

   

    return reconciler;

  }

 

  /* (non-Javadoc)

   * @see org.eclipse.ui.editors.text.TextSourceViewerConfiguration#getOverviewRulerAnnotationHover(org.eclipse.jface.text.source.ISourceViewer)

   */

  public IAnnotationHover getOverviewRulerAnnotationHover(ISourceViewer sourceViewer) {

    return new StructuredTextAnnotationHover(true) {

      protected boolean isIncluded(Annotation annotation) {

        return isShowInOverviewRuler(annotation);

      }

    };

  }

  /*

   * @see org.eclipse.jface.text.source.SourceViewerConfiguration#getQuickAssistAssistant(org.eclipse.jface.text.source.ISourceViewer)

   */

  public IQuickAssistAssistant getQuickAssistAssistant(ISourceViewer sourceViewer) {

    if (fQuickAssistant == null) {

      IQuickAssistAssistant assistant = new QuickAssistAssistant();

      assistant.setQuickAssistProcessor(new CompoundQuickAssistProcessor());

      assistant.setInformationControlCreator(getQuickAssistAssistantInformationControlCreator());

      // Waiting for color preferences, see:

      // https://bugs.eclipse.org/bugs/show_bug.cgi?id=133731

      // set content assist preferences

      if (fPreferenceStore != null) {

        Color color = getColor(EditorPreferenceNames.CODEASSIST_PROPOSALS_BACKGROUND);

        assistant.setProposalSelectorBackground(color);

        color = getColor(EditorPreferenceNames.CODEASSIST_PROPOSALS_FOREGROUND);

        assistant.setProposalSelectorForeground(color);

      }

      fQuickAssistant = assistant;

    }

    return fQuickAssistant;

  }

  /**

   * Returns the information control creator for the quick assist assistant.

   *

   * @return the information control creator

   */

  private IInformationControlCreator getQuickAssistAssistantInformationControlCreator() {

    return new IInformationControlCreator() {

      public IInformationControl createInformationControl(Shell parent) {

        return new DefaultInformationControl(parent, new HTMLTextPresenter(true));

      }

    };

  }

  /**

   * Returns the reconciler ready to be used with the given source viewer.<br />

   * Note: The same instance of IReconciler is returned regardless of the

   * source viewer passed in.

   * <p>

   * Clients cannot override this method. Instead, clients wanting to add

   * their own reconciling strategy should use the

   * <code>org.eclipse.wst.sse.ui.extensions.sourcevalidation</code>

   * extension point.

   * </p>

   *

   * @param sourceViewer

   *            the source viewer to be configured by this configuration

   * @return a reconciler

   */

  final public IReconciler getReconciler(ISourceViewer sourceViewer) {

    IReconciler reconciler = null;

   

    if (sourceViewer != null) {

      //Only create reconciler if sourceViewer is present

      if (fReconciler == null && sourceViewer != null) {

        StructuredRegionProcessor newReconciler = new StructuredRegionProcessor();

 

        // reconciler configurations

        newReconciler.setDocumentPartitioning(getConfiguredDocumentPartitioning(sourceViewer));

 

        fReconciler = newReconciler;

      }

      reconciler = fReconciler;

    }

   

    return reconciler;

  }

  /**

   * @since 2.0

   * @param treeViewer

   * @return a label provider providing the status line contents

   */

  public ILabelProvider getStatusLineLabelProvider(ISourceViewer sourceViewer) {

    return null;

  }

  /**

   * Create documentation hovers based on hovers contributed via

   * <code>org.eclipse.wst.sse.ui.editorConfiguration</code> extension

   * point

   *

   * @param partitionType

   * @return

   */

  private ITextHover[] createDocumentationHovers(String partitionType) {

    List extendedTextHover = ExtendedConfigurationBuilder.getInstance().getConfigurations(ExtendedConfigurationBuilder.DOCUMENTATIONTEXTHOVER, partitionType);

    ITextHover[] hovers = (ITextHover[]) extendedTextHover.toArray(new ITextHover[extendedTextHover.size()]);

    return hovers;

  }

  public ITextHover getTextHover(ISourceViewer sourceViewer, String contentType, int stateMask) {

    ITextHover textHover = null;

    /*

     * Returns a default problem, annotation, and best match hover

     * depending on stateMask

     */

    TextHoverManager.TextHoverDescriptor[] hoverDescs = SSEUIPlugin.getDefault().getTextHoverManager().getTextHovers();

    int i = 0;

    while (i < hoverDescs.length && textHover == null) {

      if (hoverDescs[i].isEnabled() && computeStateMask(hoverDescs[i].getModifierString()) == stateMask) {

        String hoverType = hoverDescs[i].getId();

        if (TextHoverManager.PROBLEM_HOVER.equalsIgnoreCase(hoverType))

          textHover = new ProblemAnnotationHoverProcessor();

        else if (TextHoverManager.ANNOTATION_HOVER.equalsIgnoreCase(hoverType))

          textHover = new AnnotationHoverProcessor();

        else if (TextHoverManager.COMBINATION_HOVER.equalsIgnoreCase(hoverType))

          textHover = new BestMatchHover(contentType);

        else if (TextHoverManager.DOCUMENTATION_HOVER.equalsIgnoreCase(hoverType)) {

          ITextHover[] hovers = createDocumentationHovers(contentType);

          if (hovers.length > 0) {

            textHover = hovers[0];

          }

        }

      }

      i++;

    }

    return textHover;

  }

  /**

   * Returns the undo manager for the given source viewer.<br />

   * Note: Clients cannot override this method because this method returns a

   * specially configured undo manager for the StructuredTextViewer.

   *

   * @param sourceViewer

   *            the source viewer to be configured by this configuration

   * @return an undo manager specially configured for StructuredTextViewer

   */

  final public IUndoManager getUndoManager(ISourceViewer sourceViewer) {

    /*

     * This implementation returns an UndoManager that is used exclusively

     * in StructuredTextViewer

     */

    return new StructuredTextViewerUndoManager();

  }

 

  public void setHighlighter(ReconcilerHighlighter highlighter) {

    fHighlighter = highlighter;

  }

 

  /**

   * @return the associated content assistnat

   */

  protected StructuredContentAssistant getContentAssistant() {

    return this.fContentAssistant;

  }

}