Java 类org.eclipse.ui.texteditor.ITextEditorExtension 实例源码

private boolean canModifyEditor(ITextEditor editor)
{
    if (editor instanceof ITextEditorExtension2)
    {
        return ((ITextEditorExtension2) editor).isEditorInputModifiable();
    }
    else if (editor instanceof ITextEditorExtension)
    {
        return !((ITextEditorExtension) editor).isEditorInputReadOnly();
    }
    else if (editor != null)
    {
        return editor.isEditable();
    }
    return false;
}

@Override
public void setActiveEditor(IEditorPart part) {
    super.setActiveEditor(part);
    if (part instanceof ITextEditor) {
        ITextEditor textEditor = (ITextEditor) part;
        if (commandsMenuContributionItem != null) {
            commandsMenuContributionItem.setTextEditor(textEditor);
        }

        if (inputPositionStatsContributionItem != null) {
            inputPositionStatsContributionItem.setActionHandler(getAction(textEditor, ITextEditorActionConstants.GOTO_LINE));
            ITextEditorExtension extension = (ITextEditorExtension) textEditor;
            extension.setStatusField(inputPositionStatsContributionItem, ITextEditorActionConstants.STATUS_CATEGORY_INPUT_POSITION);
        }

        if (part instanceof AbstractThemeableEditor) {
            FoldingActionsGroup foldingActions = ((AbstractThemeableEditor) part).getFoldingActionsGroup();
            if (foldingActions != null) {
                foldingActions.updateActionBars();
            }
        }
        markOccurrencesAction.setEditor(textEditor);
    }
}

/**
 * @return true if the contents of the editor may be changed. Clients MUST call this before actually
 * modifying the editor.
 */
public static boolean canModifyEditor(ITextEditor editor) {

    if (editor instanceof ITextEditorExtension2) {
        return ((ITextEditorExtension2) editor).isEditorInputModifiable();

    } else if (editor instanceof ITextEditorExtension) {
        return !((ITextEditorExtension) editor).isEditorInputReadOnly();

    } else if (editor != null) {
        return editor.isEditable();

    }

    //If we don't have the editor, let's just say it's ok (working on document).
    return true;
}

/**
 * Eclipse forces us to check this ourselves
 * 
 * @return true if the editor is modifiable
 */
private boolean getEditable() {
    boolean result = false;
    ITextEditor editor= getThisEditor();
    if (editor != null) {
        if (editor instanceof ITextEditorExtension2)
            result = ((ITextEditorExtension2) editor).isEditorInputModifiable();
        else if (editor instanceof ITextEditorExtension)
            result = !((ITextEditorExtension) editor).isEditorInputReadOnly();
        else 
            result = editor.isEditable();
    } 
    return result;
}

private void findJavaAnnotation() {
    fPosition= null;
    fAnnotation= null;
    fHasCorrection= false;

    AbstractMarkerAnnotationModel model= getAnnotationModel();
    IAnnotationAccessExtension annotationAccess= getAnnotationAccessExtension();

    IDocument document= getDocument();
    if (model == null)
        return ;

    boolean hasAssistLightbulb= fStore.getBoolean(PreferenceConstants.EDITOR_QUICKASSIST_LIGHTBULB);

    Iterator<Annotation> iter= model.getAnnotationIterator();
    int layer= Integer.MIN_VALUE;

    while (iter.hasNext()) {
        Annotation annotation= iter.next();
        if (annotation.isMarkedDeleted())
            continue;

        int annotationLayer= layer;
        if (annotationAccess != null) {
            annotationLayer= annotationAccess.getLayer(annotation);
            if (annotationLayer < layer)
                continue;
        }

        Position position= model.getPosition(annotation);
        if (!includesRulerLine(position, document))
            continue;

        AnnotationPreference preference= fAnnotationPreferenceLookup.getAnnotationPreference(annotation);
        if (preference == null)
            continue;

        String key= preference.getVerticalRulerPreferenceKey();
        if (key == null)
            continue;

        if (!fStore.getBoolean(key))
            continue;

        boolean isReadOnly= fTextEditor instanceof ITextEditorExtension && ((ITextEditorExtension)fTextEditor).isEditorInputReadOnly();
        if (!isReadOnly
                && (
                    ((hasAssistLightbulb && annotation instanceof AssistAnnotation)
                    || JavaCorrectionProcessor.hasCorrections(annotation)))) {
            fPosition= position;
            fAnnotation= annotation;
            fHasCorrection= true;
            layer= annotationLayer;
            continue;
        } else if (!fHasCorrection) {
                fPosition= position;
                fAnnotation= annotation;
                layer= annotationLayer;
        }
    }
}

private void findJavaAnnotation() {
    fPosition= null;
    fAnnotation= null;
    fHasCorrection= false;

    AbstractMarkerAnnotationModel model= getAnnotationModel();
    IAnnotationAccessExtension annotationAccess= getAnnotationAccessExtension();

    IDocument document= getDocument();
    if (model == null)
        return ;

    boolean hasAssistLightbulb= fStore.getBoolean(PreferenceConstants.EDITOR_QUICKASSIST_LIGHTBULB);

    Iterator<Annotation> iter= model.getAnnotationIterator();
    int layer= Integer.MIN_VALUE;

    while (iter.hasNext()) {
        Annotation annotation= iter.next();
        if (annotation.isMarkedDeleted())
            continue;

        int annotationLayer= layer;
        if (annotationAccess != null) {
            annotationLayer= annotationAccess.getLayer(annotation);
            if (annotationLayer < layer)
                continue;
        }

        Position position= model.getPosition(annotation);
        if (!includesRulerLine(position, document))
            continue;

        boolean isReadOnly= fTextEditor instanceof ITextEditorExtension && ((ITextEditorExtension)fTextEditor).isEditorInputReadOnly();
        if (!isReadOnly
                && (
                    ((hasAssistLightbulb && annotation instanceof AssistAnnotation)
                    || JavaCorrectionProcessor.hasCorrections(annotation)))) {
            fPosition= position;
            fAnnotation= annotation;
            fHasCorrection= true;
            layer= annotationLayer;
            continue;
        } else if (!fHasCorrection) {
            AnnotationPreference preference= fAnnotationPreferenceLookup.getAnnotationPreference(annotation);
            if (preference == null)
                continue;

            String key= preference.getVerticalRulerPreferenceKey();
            if (key == null)
                continue;

            if (fStore.getBoolean(key)) {
                fPosition= position;
                fAnnotation= annotation;
                layer= annotationLayer;
            }
        }
    }
}

/**
 * Checks the editor's modifiable state. Returns <code>true</code> if the editor can be modified,
 * taking in account the possible editor extensions.
 *
 * <p>If the editor implements <code>ITextEditorExtension2</code>,
 * this method returns {@link ITextEditorExtension2#isEditorInputModifiable()};<br> else if the editor
 * implements <code>ITextEditorExtension</code>, it returns {@link ITextEditorExtension#isEditorInputReadOnly()};<br>
 * else, {@link ITextEditor#isEditable()} is returned, or <code>false</code> if the editor is <code>null</code>.</p>
 *
 * <p>There is only a difference to {@link #validateEditorInputState()} if the editor implements
 * <code>ITextEditorExtension2</code>.</p>
 *
 * @return <code>true</code> if a modifying action should be enabled, <code>false</code> otherwise
 * @since 3.0
 */
protected boolean canModifyEditor() {
    ITextEditor editor= getTextEditor();
    if (editor instanceof ITextEditorExtension2)
        return ((ITextEditorExtension2) editor).isEditorInputModifiable();
    else if (editor instanceof ITextEditorExtension)
        return !((ITextEditorExtension) editor).isEditorInputReadOnly();
    else if (editor != null)
        return editor.isEditable();
    else
        return false;
}

/**
 * Checks and validates the editor's modifiable state. Returns <code>true</code> if an action
 * can proceed modifying the editor's input, <code>false</code> if it should not.
 *
 * <p>If the editor implements <code>ITextEditorExtension2</code>,
 * this method returns {@link ITextEditorExtension2#validateEditorInputState()};<br> else if the editor
 * implements <code>ITextEditorExtension</code>, it returns {@link ITextEditorExtension#isEditorInputReadOnly()};<br>
 * else, {@link ITextEditor#isEditable()} is returned, or <code>false</code> if the editor is <code>null</code>.</p>
 *
 * <p>There is only a difference to {@link #canModifyEditor()} if the editor implements
 * <code>ITextEditorExtension2</code>.</p>
 *
 * @return <code>true</code> if a modifying action can proceed to modify the underlying document, <code>false</code> otherwise
 * @since 3.0
 */
protected boolean validateEditorInputState() {
    ITextEditor editor= getTextEditor();
    if (editor instanceof ITextEditorExtension2)
        return ((ITextEditorExtension2) editor).validateEditorInputState();
    else if (editor instanceof ITextEditorExtension)
        return !((ITextEditorExtension) editor).isEditorInputReadOnly();
    else if (editor != null)
        return editor.isEditable();
    else
        return false;
}