android-10.0.0_r47/s

/*
 * Copyright (C) 2012 The Android Open Source Project
 *
 * Licensed under the Eclipse Public License, Version 1.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.eclipse.org/org/documents/epl-v10.php
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.ide.eclipse.adt.internal.editors.common;

import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.ide.eclipse.adt.internal.editors.AndroidXmlEditor;
import com.android.ide.eclipse.adt.internal.editors.uimodel.UiElementNode;
import com.android.resources.ResourceFolderType;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.text.contentassist.IContentAssistProcessor;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IURIEditorInput;
import org.eclipse.ui.forms.editor.IFormPage;
import org.eclipse.ui.part.EditorActionBarContributor;
import org.eclipse.ui.part.FileEditorInput;
import org.eclipse.ui.part.MultiPageEditorPart;
import org.w3c.dom.Document;

/**
 * Implementation of form editor for /res XML files.
 * <p/>
 * All delegates must have one {@link IDelegateCreator} instance
 * registered in the {@code DELEGATES[]} array of {@link CommonXmlEditor}.
 */
public abstract class CommonXmlDelegate {

    /** The editor that created the delegate. Never null. */
    private final CommonXmlEditor mEditor;

    /** Root node of the UI element hierarchy. Can be null. */
    private UiElementNode mUiRootNode;

    private IContentAssistProcessor mContentAssist;

    /**
     * Static creator for {@link CommonXmlDelegate}s. Delegates implement a method
     * that will decide whether this delegate can be created for the given file input.
     */
    public interface IDelegateCreator {
        /**
         * Determines whether this delegate can handle the given file, typically
         * based on its resource path (e.g. ResourceManager#getResourceFolder).
         *
         * @param delegator The non-null instance of {@link CommonXmlEditor}.
         * @param type The {@link ResourceFolderType} of the folder containing the file,
         *   if it can be determined. Null otherwise.
         * @return A new delegate that can handle that file or null.
         */
        public @Nullable <T extends CommonXmlDelegate> T createForFile(
                            @NonNull CommonXmlEditor delegator,
                            @Nullable ResourceFolderType type);
    }

    /** Implemented by delegates that need to support {@link EditorActionBarContributor} */
    public interface IActionContributorDelegate {
        /** Called from {@link EditorActionBarContributor#setActiveEditor(IEditorPart)}. */
        public void setActiveEditor(IEditorPart part, IActionBars bars);
    }

    protected CommonXmlDelegate(
            CommonXmlEditor editor,
            IContentAssistProcessor contentAssist) {
        mEditor = editor;
        mContentAssist = contentAssist;
    }

    public void dispose() {
    }

    /**
     * Returns the editor that created this delegate.
     *
     * @return the editor that created this delegate. Never null.
     */
    public @NonNull CommonXmlEditor getEditor() {
        return mEditor;
    }

    /**
     * @return The root node of the UI element hierarchy
     */
    public UiElementNode getUiRootNode() {
        return mUiRootNode;
    }

    protected void setUiRootNode(UiElementNode uiRootNode) {
        mUiRootNode = uiRootNode;
    }

    /** Called to compute the initial {@code UiRootNode}. */
    public abstract void delegateInitUiRootNode(boolean force);

    /**
     * Returns true, indicating the "save as" operation is supported by this editor.
     */
    public boolean isSaveAsAllowed() {
        return true;
    }

    /**
     * Create the various form pages.
     */
    public abstract void delegateCreateFormPages();

    public void delegatePostCreatePages() {
        // pass
    }

    /**
     * Changes the tab/title name to include the project name.
     */
    public void delegateSetInput(IEditorInput input) {
        if (input instanceof FileEditorInput) {
            FileEditorInput fileInput = (FileEditorInput) input;
            IFile file = fileInput.getFile();
            getEditor().setPartName(file.getName());
        } else if (input instanceof IURIEditorInput) {
            IURIEditorInput uriInput = (IURIEditorInput) input;
            String name = uriInput.getName();
            getEditor().setPartName(name);
        }
    }

    /**
     * Processes the new XML Model, which XML root node is given.
     *
     * @param xml_doc The XML document, if available, or null if none exists.
     */
    public abstract void delegateXmlModelChanged(Document xml_doc);

    public void delegatePageChange(int newPageIndex) {
        // pass
    }

    public void delegatePostPageChange(int newPageIndex) {
        // pass
    }
    /**
     * Save the XML.
     * <p/>
     * The actual save operation is done in the super class by committing
     * all data to the XML model and then having the Structured XML Editor
     * save the XML.
     * <p/>
     * Here we just need to tell the graphical editor that the model has
     * been saved.
     */
    public void delegateDoSave(IProgressMonitor monitor) {
        // pass
    }

    /**
     * Tells the editor to start a Lint check.
     * It's up to the caller to check whether this should be done depending on preferences.
     */
    public Job delegateRunLint() {
        return getEditor().startLintJob();
    }


    /**
     * Returns the custom IContentOutlinePage or IPropertySheetPage when asked for it.
     */
    public Object delegateGetAdapter(Class<?> adapter) {
        return null;
    }

    /**
     * Returns the {@link IContentAssistProcessor} associated with this editor.
     * Most implementations should lazily allocate one processor and always return the
     * same instance.
     * Must return null if there's no specific content assist processor for this editor.
     */
    public IContentAssistProcessor getAndroidContentAssistProcessor() {
        return mContentAssist;
    }

    /**
     * Does this editor participate in the "format GUI editor changes" option?
     *
     * @return false since editors do not support automatically formatting XML
     *         affected by GUI changes unless they explicitly opt in to it.
     */
    public boolean delegateSupportsFormatOnGuiEdit() {
        return false;
    }

    /**
     * Called after the editor's active page has been set.
     *
     * @param superReturned the return value from
     *            {@link MultiPageEditorPart#setActivePage(int)}
     * @param pageIndex the index of the page to be activated; the index must be
     *            valid
     * @return the page, or null
     * @see MultiPageEditorPart#setActivePage(int)
     */
    public IFormPage delegatePostSetActivePage(IFormPage superReturned, String pageIndex) {
        return superReturned;
    }

    /** Called after an editor has been activated */
    public void delegateActivated() {
    }

    /** Called after an editor has been deactivated */
    public void delegateDeactivated() {
    }

    /**
     * Returns the name of the editor to be shown in the editor tab etc. Return
     * null to keep the default.
     *
     * @return the part name, or null to use the default
     */
    public String delegateGetPartName() {
        return null;
    }

    /**
     * Returns the persistence category, as described in
     * {@link AndroidXmlEditor#getPersistenceCategory}.
     *
     * @return the persistence category to use for this editor
     */
    public int delegateGetPersistenceCategory() {
        return AndroidXmlEditor.CATEGORY_OTHER;
    }
}