/*******************************************************************************
 * Copyright (c) 2021 1C-Soft LLC.
 *
 * This program and the accompanying materials are made available under
 * the terms of the Eclipse Public License 2.0 which is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     Vladimir Piskarev (1C) - initial API and implementation
 *******************************************************************************/
package org.eclipse.handly.ui.typehierarchy;

import static org.eclipse.handly.context.Contexts.EMPTY_CONTEXT;

import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.handly.context.IContext;
import org.eclipse.handly.internal.ui.Activator;
import org.eclipse.handly.ui.DefaultEditorUtility;
import org.eclipse.handly.ui.EditorOpener;
import org.eclipse.handly.ui.EditorUtility;
import org.eclipse.handly.ui.PartListenerAdapter;
import org.eclipse.handly.ui.action.HistoryDropDownAction;
import org.eclipse.handly.ui.viewer.DelegatingSelectionProvider;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.SashForm;
import org.eclipse.swt.events.ControlAdapter;
import org.eclipse.swt.events.ControlEvent;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.IPartListener;
import org.eclipse.ui.IViewSite;
import org.eclipse.ui.IWorkbenchActionConstants;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.OpenAndLinkWithEditorHelper;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.actions.ActionFactory;
import org.eclipse.ui.actions.BaseSelectionListenerAction;
import org.eclipse.ui.part.PageBook;
import org.eclipse.ui.part.ViewPart;

/**
 * An abstract base implementation of a type hierarchy view.
 *
 * @since 1.6
 */
public abstract class TypeHierarchyViewPart
    extends ViewPart
{
    /**
     * Pop-up menu: name of group for focus actions (value
     * <code>"group.focus"</code>).
     */
    protected static final String GROUP_FOCUS = "group.focus"; //$NON-NLS-1$

    private static final Object[] NO_ELEMENTS = new Object[0];

    private static final String KEY_HIERARCHY_KIND =
        "org.eclipse.handly.typehierarchy.view.hierarchyKind"; //$NON-NLS-1$
    private static final String KEY_LAYOUT_MODE =
        "org.eclipse.handly.typehierarchy.view.layoutMode"; //$NON-NLS-1$
    private static final String KEY_HORIZONTAL_WEIGHTS =
        "org.eclipse.handly.typehierarchy.view.horizontalWeights"; //$NON-NLS-1$
    private static final String KEY_VERTICAL_WEIGHTS =
        "org.eclipse.handly.typehierarchy.view.verticalWeights"; //$NON-NLS-1$

    private static final int LAYOUT_AUTOMATIC = SWT.HORIZONTAL | SWT.VERTICAL;

    private final Set<TypeHierarchyKind> supportedHierarchyKinds;
    private Set<TypeHierarchyKind> enabledHierarchyKinds;
    private TypeHierarchyKind hierarchyKind;
    private int layoutMode = getDefaultLayoutMode();
    private boolean layoutAdjusted;
    private int[] horizontalWeights, verticalWeights;
    private Object[] inputElements = NO_ELEMENTS;
    private final List<HistoryEntry> history = new ArrayList<>();
    private PageBook pageBook, hierarchyPageBook;
    private Control noHierarchyPage;
    private SashForm sashForm;
    private final Map<TypeHierarchyKind, TreeViewer> hierarchyViewers =
        new HashMap<>();
    private EditorOpener editorOpener;
    private SetHierarchyKindAction[] setHierarchyKindActions =
        new SetHierarchyKindAction[0];
    private SetLayoutModeAction[] setLayoutModeActions =
        new SetLayoutModeAction[0];
    private final FocusOnSelectionAction focusOnSelectionAction =
        new FocusOnSelectionAction();
    private HistoryDropDownAction<HistoryEntry> historyDropDownAction;
    private final RefreshAction refreshAction = new RefreshAction();

    private final IPartListener partListener = new PartListenerAdapter()
    {
        @Override
        public void partOpened(IWorkbenchPart part)
        {
            if (part != TypeHierarchyViewPart.this)
                return;

            refresh();
        };
    };

    /**
     * Constructs a type hierarchy view that supports all of the
     * type hierarchy kinds.
     *
     * @see TypeHierarchyKind
     * @see #TypeHierarchyViewPart(Set)
     */
    public TypeHierarchyViewPart()
    {
        this(EnumSet.allOf(TypeHierarchyKind.class));
    }

    /**
     * Constructs a type hierarchy view that supports the given
     * type hierarchy kinds. Clients <b>must not</b> modify the given set
     * afterwards.
     *
     * @param supportedHierarchyKinds not <code>null</code> and not empty
     */
    public TypeHierarchyViewPart(Set<TypeHierarchyKind> supportedHierarchyKinds)
    {
        if (supportedHierarchyKinds.isEmpty())
            throw new IllegalArgumentException();

        this.supportedHierarchyKinds = supportedHierarchyKinds;
        this.enabledHierarchyKinds = supportedHierarchyKinds;
        this.hierarchyKind = supportedHierarchyKinds.iterator().next();

        makeSetHierarchyKindActions();
        makeSetLayoutModeActions();
        refreshAction.setEnabled(false);
    }

    /**
     * Returns whether the given elements are possible input elements for this view.
     * <p>
     * Default implementation invokes {@link #isPossibleInputElement(Object)} for
     * each of the given elements until <code>false</code> is returned for an element
     * (in which case this method will return <code>false</code>) or all elements
     * have been checked (in which case it will return <code>true</code>).
     * </p>
     *
     * @param elements may be <code>null</code> or may contain null elements,
     *  in which case <code>false</code> will be returned; may be empty,
     *  in which case <code>true</code> will be returned
     * @return <code>true</code> if the given elements are possible input elements
     *  for this view, and <code>false</code> otherwise
     */
    public boolean arePossibleInputElements(Object[] elements)
    {
        if (elements == null)
            return false;
        for (Object element : elements)
        {
            if (!isPossibleInputElement(element))
                return false;
        }
        return true;
    }

    /**
     * Sets the current input elements for this view. Clients <b>must not</b>
     * modify the given array afterwards.
     *
     * @param elements not <code>null</code>, must not contain null elements;
     *  may be empty
     * @throws IllegalArgumentException if {@link #arePossibleInputElements(Object[])}
     *  returns <code>false</code> for the given elements
     */
    public void setInputElements(Object[] elements)
    {
        if (!arePossibleInputElements(elements))
            throw new IllegalArgumentException(Arrays.toString(elements));

        Object[] oldInputElements = inputElements;

        inputElements = elements;

        refreshAction.setEnabled(elements.length > 0);

        if (elements.length > 0)
            addHistoryEntry(createHistoryEntry(elements));

        onInputElementsChanged(oldInputElements, elements);
    }

    /**
     * Returns the current input elements for this view.
     *
     * @return the current input elements (never <code>null</code>,
     *  may be empty). Clients <b>must not</b> modify the returned array.
     */
    public final Object[] getInputElements()
    {
        return inputElements;
    }

    /**
     * Returns whether the given hierarchy kind is currently enabled for this view.
     *
     * @param kind may be <code>null</code>, in which case <code>false</code>
     *  will be returned
     * @return <code>true</code> if the given kind is currently enabled,
     *  and <code>false</code> otherwise
     */
    public final boolean isEnabledHierarchyKind(TypeHierarchyKind kind)
    {
        return enabledHierarchyKinds.contains(kind);
    }

    /**
     * Sets the current hierarchy kind for this view.
     *
     * @param kind not <code>null</code>
     * @throws IllegalArgumentException if the given kind is not currently {@link
     *  #isEnabledHierarchyKind(TypeHierarchyKind) enabled} for this view
     */
    public void setHierarchyKind(TypeHierarchyKind kind)
    {
        if (!isEnabledHierarchyKind(kind))
            throw new IllegalArgumentException();

        if (kind == hierarchyKind)
            return;

        TypeHierarchyKind oldKind = hierarchyKind;

        hierarchyKind = kind;

        for (SetHierarchyKindAction action : setHierarchyKindActions)
            action.setChecked(action.kind == kind);

        onHierarchyKindChanged(oldKind, kind);
    }

    /**
     * Returns the current hierarchy kind for this view.
     *
     * @return the current hierarchy kind (never <code>null</code>)
     * @see #setHierarchyKind(TypeHierarchyKind)
     */
    public final TypeHierarchyKind getHierarchyKind()
    {
        return hierarchyKind;
    }

    /**
     * Sets layout mode for this view, which may be one of the constants
     * {@link SWT#HORIZONTAL} or {@link SWT#VERTICAL}; this method may also
     * be called with <code>SWT.HORIZONTAL|SWT.VERTICAL</code> for automatic
     * layout or {@link SWT#NONE} for hierarchy-only layout.
     * <p>
     * Note that only a subset of the allowed values for layout mode may be
     * {@link #supportsLayoutMode(int) supported} by the view.
     * </p>
     *
     * @param layoutMode the given layout mode
     * @throws IllegalArgumentException if the given layout mode is not
     *  {@link #supportsLayoutMode(int) supported} by the view
     */
    public void setLayoutMode(int layoutMode)
    {
        if (!supportsLayoutMode(layoutMode))
            throw new IllegalArgumentException();

        if (layoutMode == this.layoutMode)
            return;

        int oldLayoutMode = this.layoutMode;

        this.layoutMode = layoutMode;

        for (SetLayoutModeAction action : setLayoutModeActions)
            action.setChecked(action.layoutMode == layoutMode);

        onLayoutModeChanged(oldLayoutMode, layoutMode);
    }

    /**
     * Returns the current layout mode for this view.
     *
     * @return the current layout mode
     * @see #setLayoutMode(int)
     */
    public final int getLayoutMode()
    {
        return layoutMode;
    }

    /**
     * Returns <code>true</code> if the given value represents a supported
     * layout mode for this view, and <code>false</code> otherwise.
     * The set of the supported layout mode values does not change over
     * the lifetime of the view and is never empty.
     * <p>
     * Default implementation only supports {@link SWT#NONE}, which represents
     * hierarchy-only layout.
     * </p>
     *
     * @param layoutMode the layout mode to check
     * @return <code>true</code> if the given value represents a supported
     *  layout mode for this view, and <code>false</code> otherwise
     */
    public boolean supportsLayoutMode(int layoutMode)
    {
        return layoutMode == SWT.NONE;
    }

    /**
     * Performs a full refresh of the content of this view.
     */
    public final void refresh()
    {
        refresh(EMPTY_CONTEXT);
    }

    @Override
    public void init(IViewSite site, IMemento memento) throws PartInitException
    {
        super.init(site, memento);
        if (memento != null)
        {
            if (supportedHierarchyKinds.size() > 1)
            {
                String value = memento.getString(KEY_HIERARCHY_KIND);
                if (value != null)
                {
                    TypeHierarchyKind kind = null;
                    try
                    {
                        kind = TypeHierarchyKind.valueOf(value);
                    }
                    catch (IllegalArgumentException e)
                    {
                    }
                    if (supportedHierarchyKinds.contains(kind))
                        setHierarchyKind(kind);
                }
            }

            Integer layoutMode = memento.getInteger(KEY_LAYOUT_MODE);
            if (layoutMode != null)
            {
                int value = layoutMode.intValue();
                if (supportsLayoutMode(value))
                    setLayoutMode(value);
            }

            try
            {
                horizontalWeights = toIntArray(memento.getString(
                    KEY_HORIZONTAL_WEIGHTS));
            }
            catch (NumberFormatException e)
            {
            }

            try
            {
                verticalWeights = toIntArray(memento.getString(
                    KEY_VERTICAL_WEIGHTS));
            }
            catch (NumberFormatException e)
            {
            }
        }
    }

    @Override
    public void saveState(IMemento memento)
    {
        super.saveState(memento);
        if (supportedHierarchyKinds.size() > 1)
            memento.putString(KEY_HIERARCHY_KIND, hierarchyKind.name());
        memento.putInteger(KEY_LAYOUT_MODE, layoutMode);
        saveSashFormWeights();
        memento.putString(KEY_HORIZONTAL_WEIGHTS, toString(horizontalWeights));
        memento.putString(KEY_VERTICAL_WEIGHTS, toString(verticalWeights));
    }

    @Override
    public void createPartControl(Composite parent)
    {
        getSite().getPage().addPartListener(partListener);

        parent.addControlListener(new ControlAdapter()
        {
            @Override
            public void controlResized(ControlEvent e)
            {
                if (!layoutAdjusted || layoutMode == LAYOUT_AUTOMATIC)
                    adjustLayout(layoutMode);
            }
        });

        DelegatingSelectionProvider selectionProvider =
            new DelegatingSelectionProvider();

        getSite().setSelectionProvider(selectionProvider);

        selectionProvider.addSelectionChangedListener(e ->
        {
            ISelection selection = e.getSelection();
            if (selection instanceof IStructuredSelection)
                updateStatusLine(
                    getViewSite().getActionBars().getStatusLineManager(),
                    (IStructuredSelection)selection);
        });

        pageBook = new PageBook(parent, SWT.NONE);

        noHierarchyPage = createNoHierarchyPage(pageBook);

        sashForm = new SashForm(pageBook, SWT.NONE);

        hierarchyPageBook = new PageBook(sashForm, SWT.NONE);

        if (layoutMode == SWT.NONE)
            sashForm.setMaximizedControl(hierarchyPageBook);

        for (TypeHierarchyKind kind : supportedHierarchyKinds)
        {
            TreeViewer hierarchyViewer = createHierarchyViewer(
                hierarchyPageBook, kind);

            configureHierarchyViewer(hierarchyViewer, kind);

            initContextMenu(hierarchyViewer.getControl(), (
                IMenuManager manager) ->
            {
                createHierarchyViewerMenuGroups(manager, kind);
                fillHierarchyViewerMenu(manager, kind);
            }, getSite().getId(), selectionProvider);

            new OpenEditorHelper(hierarchyViewer);

            hierarchyViewer.getControl().addFocusListener(new FocusListener()
            {
                @Override
                public void focusGained(FocusEvent e)
                {
                    selectionProvider.setDelegate(hierarchyViewer);
                    onHierarchySelectionChanged(hierarchyViewer.getSelection(),
                        kind);
                }

                @Override
                public void focusLost(FocusEvent e)
                {
                    selectionProvider.setDelegate(null);
                }
            });

            hierarchyViewer.addSelectionChangedListener(
                e -> onHierarchySelectionChanged(e.getSelection(), kind));

            hierarchyViewers.put(kind, hierarchyViewer);
        }

        editorOpener = createEditorOpener();

        selectionProvider.addSelectionChangedListener(focusOnSelectionAction);

        addRefreshAction(refreshAction);

        getViewSite().getActionBars().setGlobalActionHandler(
            ActionFactory.REFRESH.getId(), refreshAction);

        for (SetHierarchyKindAction action : setHierarchyKindActions)
            addSetHierarchyKindAction(action, action.kind);

        for (SetLayoutModeAction action : setLayoutModeActions)
            addSetLayoutModeAction(action, action.layoutMode);

        historyDropDownAction = createHistoryDropDownAction(
            new HistoryDropDownAction.History<HistoryEntry>()
            {
                @Override
                public List<HistoryEntry> getHistoryEntries()
                {
                    return getHistory();
                }

                @Override
                public void setHistoryEntries(List<HistoryEntry> entries)
                {
                    List<HistoryEntry> history = getHistory();
                    history.clear();
                    history.addAll(entries);
                    onHistoryChanged();
                }

                @Override
                public HistoryEntry getActiveEntry()
                {
                    Object[] inputElements = getInputElements();
                    if (inputElements.length == 0)
                        return null;
                    return createHistoryEntry(inputElements);
                }

                @Override
                public void setActiveEntry(HistoryEntry entry)
                {
                    setInputElements(entry.getInputElements());
                }

                @Override
                public String getLabel(HistoryEntry entry)
                {
                    return entry.getLabel();
                }

                @Override
                public ImageDescriptor getImageDescriptor(HistoryEntry entry)
                {
                    return entry.getImageDescriptor();
                }
            });
        historyDropDownAction.setEnabled(!getHistory().isEmpty());
        addHistoryDropDownAction(historyDropDownAction);
    }

    @Override
    public void dispose()
    {
        getSite().getPage().removePartListener(partListener);

        super.dispose();
    }

    @Override
    public void setFocus()
    {
        pageBook.setFocus();
    }

    /**
     * Returns whether the given element is a possible input element for this view.
     *
     * @param element may be <code>null</code>, in which case <code>false</code>
     *  will be returned
     * @return <code>true</code> if the given element is a possible input element
     *  for this view, and <code>false</code> otherwise
     * @see #arePossibleInputElements(Object[])
     */
    protected abstract boolean isPossibleInputElement(Object element);

    /**
     * Creates and returns a history entry for the given input elements.
     *
     * @param inputElements never <code>null</code>; never empty
     * @return the created history entry (not <code>null</code>)
     */
    protected abstract HistoryEntry createHistoryEntry(Object[] inputElements);

    /**
     * Computes the content description for this view.
     *
     * @return the computed content description (not <code>null</code>)
     * @see #getContentDescription()
     */
    protected abstract String computeContentDescription();

    /**
     * Returns whether the view has already been opened and has not yet been
     * closed.
     *
     * @return <code>true</code> if the view is currently open,
     *  and <code>false</code> otherwise
     */
    protected final boolean isOpen()
    {
        return pageBook != null && !pageBook.isDisposed();
    }

    /**
     * Performs a refresh of the content of this view according to options
     * specified in the given context.
     *
     * @param context the operation context (never <code>null</code>)
     */
    protected void refresh(IContext context)
    {
        if (!isOpen())
            return;

        setContentDescription(computeContentDescription());

        for (Map.Entry<TypeHierarchyKind, TreeViewer> entry : hierarchyViewers.entrySet())
            setHierarchyViewerInput(entry.getValue(), entry.getKey());

        updateHierarchyPage();
    }

    /**
     * Ensures that the appropriate hierarchy page is shown by this view.
     * <p>
     * This method may only be called after the SWT controls for this view
     * have been created and before they have been disposed.
     * </p>
     */
    protected void updateHierarchyPage()
    {
        if (inputElements.length > 0)
        {
            TreeViewer hierarchyViewer = hierarchyViewers.get(hierarchyKind);
            Control hierarchyPage = hierarchyViewer.getControl();
            pageBook.showPage(sashForm);
            hierarchyPageBook.showPage(hierarchyPage);
            hierarchyPage.setFocus();
        }
        else
        {
            pageBook.showPage(noHierarchyPage);
            pageBook.setFocus();
        }
    }

    /**
     * A callback that is invoked when the view input elements change.
     *
     * @param oldInputElements never <code>null</code>
     * @param newInputElements never <code>null</code>
     */
    protected void onInputElementsChanged(Object[] oldInputElements,
        Object[] newInputElements)
    {
        refresh();
    }

    /**
     * A callback that is invoked when the current hierarchy kind changes.
     *
     * @param oldKind never <code>null</code>
     * @param newKind never <code>null</code>
     */
    protected void onHierarchyKindChanged(TypeHierarchyKind oldKind,
        TypeHierarchyKind newKind)
    {
        if (!isOpen())
            return;

        updateHierarchyPage();
    }

    /**
     * Returns a set of the supported hierarchy kinds for this view.
     *
     * @return the supported hierarchy kinds (never <code>null</code>,
     *  never empty)
     */
    protected final Set<TypeHierarchyKind> getSupportedHierarchyKinds()
    {
        return supportedHierarchyKinds;
    }

    /**
     * Sets the enabled hierarchy kinds for this view. Note that at least one
     * hierarchy kind must be enabled. Clients <b>must not</b> modify the given
     * set afterwards.
     *
     * @param kinds not <code>null</code> and not empty
     */
    protected void setEnabledHierarchyKinds(Set<TypeHierarchyKind> kinds)
    {
        if (kinds.isEmpty())
            throw new IllegalArgumentException();

        if (!supportedHierarchyKinds.containsAll(kinds))
            throw new IllegalArgumentException();

        if (enabledHierarchyKinds.equals(kinds))
            return;

        Set<TypeHierarchyKind> oldKinds = enabledHierarchyKinds;

        enabledHierarchyKinds = kinds;

        for (SetHierarchyKindAction action : setHierarchyKindActions)
            action.setEnabled(kinds.contains(action.kind));

        if (!kinds.contains(hierarchyKind))
            setHierarchyKind(kinds.iterator().next());

        onEnabledHierarchyKindsChanged(oldKinds, kinds);
    }

    /**
     * A callback that is invoked when the set of enabled hierarchy kinds changes.
     *
     * @param oldKinds never <code>null</code>
     * @param newKinds never <code>null</code>
     */
    protected void onEnabledHierarchyKindsChanged(
        Set<TypeHierarchyKind> oldKinds, Set<TypeHierarchyKind> newKinds)
    {
        if (!isOpen())
            return;

        for (TypeHierarchyKind kind : symmetricDifference(oldKinds, newKinds))
            setHierarchyViewerInput(hierarchyViewers.get(kind), kind);
    }

    /**
     * A callback that is invoked when the view layout mode changes.
     *
     * @param oldLayoutMode the old layout mode
     * @param newLayoutMode the new layout mode
     */
    protected void onLayoutModeChanged(int oldLayoutMode, int newLayoutMode)
    {
        if (!isOpen())
            return;

        sashForm.setMaximizedControl(newLayoutMode == SWT.NONE
            ? hierarchyPageBook : null);
        adjustLayout(newLayoutMode);
    }

    /**
     * Updates the status line based on the given selection in this view.
     * <p>
     * Default implementation clears the status line message if the selection
     * is empty or if exactly one element is selected; sets a generic message
     * of the form "(x) items selected" otherwise. It always clears the error
     * message.
     * </p>
     *
     * @param manager the status line manager (never <code>null</code>)
     * @param selection the current selection (never <code>null</code>)
     */
    protected void updateStatusLine(IStatusLineManager manager,
        IStructuredSelection selection)
    {
        String message = null;
        int size = selection.size();
        if (size > 1)
        {
            message = MessageFormat.format(
                Messages.TypeHierarchyViewPart_0__items_selected, size);
        }
        manager.setMessage(message);
        manager.setErrorMessage(null);
    }

    /**
     * Creates and returns a control for the 'no hierarchy' page.
     * This method is called once, when the part's control is created.
     * <p>
     * Default implementation returns a <code>Label</code> telling,
     * in general terms, that there is no type hierarchy to display.
     * Subclasses may override this method (e.g., to give details
     * on what the user needs to do to display a type hierarchy).
     * </p>
     *
     * @param parent the parent composite (never <code>null</code>)
     * @return the created control (not <code>null</code>)
     */
    protected Control createNoHierarchyPage(Composite parent)
    {
        Label label = new Label(parent, SWT.LEAD + SWT.WRAP);
        label.setText(Messages.TypeHierarchyViewPart_No_hierarchy_to_display);
        return label;
    }

    /**
     * Returns the {@link SashForm} created for this view.
     *
     * @return the <code>SashForm</code>,
     *  or <code>null</code> if it has yet to be created
     */
    protected final SashForm getSashForm()
    {
        return sashForm;
    }

    /**
     * Returns the hierarchy tree viewer for the given hierarchy kind.
     *
     * @param kind the type hierarchy kind (never <code>null</code>)
     * @return the hierarchy tree viewer,
     *  or <code>null</code> if it has yet to be created
     * @see #createHierarchyViewer(Composite, TypeHierarchyKind)
     */
    protected final TreeViewer getHierarchyViewer(TypeHierarchyKind kind)
    {
        return hierarchyViewers.get(kind);
    }

    /**
     * Creates and returns a tree viewer that will be used for displaying
     * the type hierarchy of the given kind. This method only creates the viewer;
     * it does not configure it. This method is called once, when the part's
     * control is created.
     *
     * @param parent the parent composite (never <code>null</code>)
     * @param kind the type hierarchy kind (never <code>null</code>)
     * @return the created viewer (not <code>null</code>)
     * @see #configureHierarchyViewer(TreeViewer, TypeHierarchyKind)
     */
    protected TreeViewer createHierarchyViewer(Composite parent,
        TypeHierarchyKind kind)
    {
        return new TreeViewer(parent, SWT.SINGLE);
    }

    /**
     * Configures the newly created hierarchy viewer for the given hierarchy kind.
     * This method has to set as least a content provider and a label provider.
     * This method is called once, just after the viewer is created.
     *
     * @param viewer the viewer to configure (never <code>null</code>)
     * @param kind the type hierarchy kind (never <code>null</code>)
     */
    protected abstract void configureHierarchyViewer(TreeViewer viewer,
        TypeHierarchyKind kind);

    /**
     * Sets the input for the hierarchy viewer for the given hierarchy kind.
     *
     * @param viewer the viewer to set the input for (never <code>null</code>)
     * @param kind the type hierarchy kind (never <code>null</code>)
     */
    protected void setHierarchyViewerInput(TreeViewer viewer,
        TypeHierarchyKind kind)
    {
        viewer.setInput(inputElements.length > 0 && isEnabledHierarchyKind(kind)
            ? inputElements : null);
    }

    /**
     * Creates the menu groups for the pop-up menu of the hierarchy viewer of
     * the given hierarchy kind. This method is called each time the pop-up menu
     * is about to show, just before {@link #fillHierarchyViewerMenu} is called.
     * <p>
     * Default implementation adds groups named {@link #GROUP_FOCUS} and
     * {@link IWorkbenchActionConstants#MB_ADDITIONS}. Subclasses may extend
     * or override this method, but should usually keep the default groups.
     * <p>
     *
     * @param manager the menu manager (never <code>null</code>)
     * @param kind the type hierarchy kind (never <code>null</code>)
     */
    protected void createHierarchyViewerMenuGroups(IMenuManager manager,
        TypeHierarchyKind kind)
    {
        manager.add(new Separator(GROUP_FOCUS));
        manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
    }

    /**
     * Fills the pop-menu for the hierarchy viewer for the given hierarchy kind
     * using the menu groups created by {@link #createHierarchyViewerMenuGroups}.
     * This method is called each time the pop-up menu is about to show.
     * <p>
     * Default implementation adds generic actions such as 'focus on selection'.
     * Subclasses may extend or override this method.
     * </p>
     *
     * @param manager the menu manager (never <code>null</code>)
     * @param kind the type hierarchy kind (never <code>null</code>)
     */
    protected void fillHierarchyViewerMenu(IMenuManager manager,
        TypeHierarchyKind kind)
    {
        if (focusOnSelectionAction.isEnabled())
            manager.appendToGroup(GROUP_FOCUS, focusOnSelectionAction);
    }

    /**
     * A callback that is invoked when selection changes in the hierarchy viewer
     * for the given hierarchy kind.
     * <p>
     * Default implementation tries to reveal the selected hierarchy node in an
     * open editor with {@link #revealInEditor(Object, boolean, boolean)
     * revealInEditor}.
     * </p>
     *
     * @param selection the new selection (never <code>null</code>)
     * @param kind the type hierarchy kind (never <code>null</code>)
     */
    protected void onHierarchySelectionChanged(ISelection selection,
        TypeHierarchyKind kind)
    {
        Object element = getSelectedElement(selection);
        if (element != null)
        {
            if (hierarchyViewers.get(kind).getControl().isFocusControl())
            {
                try
                {
                    revealInEditor(element, false, false);
                }
                catch (PartInitException e)
                {
                    // cannot happen: may not open a new editor
                }
            }
        }
    }

    /**
     * Reveals the given element in an appropriate editor on a best effort basis.
     * <p>
     * Default implementation uses the {@link #getEditorOpener() editor opener}.
     * </p>
     *
     * @param element not <code>null</code>
     * @param activate whether to activate the editor
     * @param mayOpenNewEditor whether a new editor may be opened
     *  when the element cannot be revealed in an existing editor
     * @throws PartInitException if a new editor could not be created
     *  or initialized
     */
    protected void revealInEditor(Object element, boolean activate,
        boolean mayOpenNewEditor) throws PartInitException
    {
        EditorUtility editorUtility = editorOpener.getEditorUtility();
        if (editorUtility.getEditorInput(element) == null)
            return;

        if (mayOpenNewEditor)
            editorOpener.open(element, activate, true);
        else
        {
            IWorkbenchPage page = editorOpener.getWorkbenchPage();
            IEditorReference editorRef = editorUtility.findEditor(page,
                element);
            if (editorRef != null)
            {
                IEditorPart editor = editorRef.getEditor(true);
                if (editor != null)
                {
                    if (activate)
                        page.activate(editor);
                    else
                        page.bringToTop(editor);
                    editorUtility.revealElement(editor, element);
                }
            }
        }
    }

    /**
     * Returns the editor opener used by this view.
     *
     * @return the editor opener,
     *  or <code>null</code> if it has yet to be created
     * @see #createEditorOpener()
     */
    protected final EditorOpener getEditorOpener()
    {
        return editorOpener;
    }

    /**
     * Creates and returns an editor opener for this view.
     * This method is called once, when the part's control is created.
     * <p>
     * Subclasses may override this method if they require a specific
     * editor opener.
     * </p>
     *
     * @return the created editor opener (not <code>null</code>)
     */
    protected EditorOpener createEditorOpener()
    {
        return new EditorOpener(getSite().getPage(),
            DefaultEditorUtility.INSTANCE);
    }

    /**
     * Returns the 'focus on selection' action used by this view.
     *
     * @return the 'focus on selection' action
     */
    protected final IAction getFocusOnSelectionAction()
    {
        return focusOnSelectionAction;
    }

    /**
     * Contributes the 'refresh' action to this view.
     * This method is called once, when the part's control is created.
     * <p>
     * Default implementation adds the given action to the view tool bar.
     * Subclasses may extend or override this method.
     * </p>
     *
     * @param action the 'refresh' action (never <code>null</code>)
     */
    protected void addRefreshAction(IAction action)
    {
        getViewSite().getActionBars().getToolBarManager().add(action);
    }

    /**
     * Contributes a 'set hierarchy kind' action to this view. This method
     * is called once for each of the 'set hierarchy kind' actions, when the
     * part's control is created. If this view supports only one hierarchy kind,
     * no 'set hierarchy kind' action is created and this method is not called.
     * <p>
     * Default implementation adds the given action to the view tool bar
     * as well as to the view menu. Subclasses may extend or override
     * this method.
     * </p>
     *
     * @param action a 'set hierarchy kind' action
     *  (never <code>null</code>)
     * @param kind the hierarchy kind set by the given action
     *  (never <code>null</code>)
     * @see #setHierarchyKind(TypeHierarchyKind)
     */
    protected void addSetHierarchyKindAction(IAction action,
        TypeHierarchyKind kind)
    {
        IActionBars actionBars = getViewSite().getActionBars();
        actionBars.getToolBarManager().add(action);
        actionBars.getMenuManager().add(action);
    }

    /**
     * Contributes a 'set layout mode' action to this view. This method
     * is called once for each of the 'set layout mode' actions, when the
     * part's control is created. If this view supports only one layout mode,
     * no 'set layout mode' action is created and this method is not called.
     * <p>
     * Default implementation adds the given action to the 'Layout' sub-menu
     * of the view menu. The sub-menu is created if necessary. Subclasses may
     * extend or override this method.
     * </p>
     *
     * @param action a 'set layout mode' action
     *  (never <code>null</code>)
     * @param layoutMode the layout mode set by the given action
     * @see #setLayoutMode(int)
     */
    protected void addSetLayoutModeAction(IAction action, int layoutMode)
    {
        IActionBars actionBars = getViewSite().getActionBars();
        IMenuManager viewMenu = actionBars.getMenuManager();
        String id = "layout"; //$NON-NLS-1$
        IMenuManager layoutSubMenu = viewMenu.findMenuUsingPath(id);
        if (layoutSubMenu == null)
        {
            viewMenu.add(new Separator());
            layoutSubMenu = new MenuManager(
                Messages.TypeHierarchyViewPart_Layout_menu, id);
            viewMenu.add(layoutSubMenu);
        }
        layoutSubMenu.add(action);
    }

    /**
     * Creates and returns a 'show history list' action for this view.
     * This method is called once, when the part's control is created.
     * <p>
     * Subclasses need to override this method if they extend
     * {@link HistoryDropDownAction}.
     * </p>
     *
     * @param history never <code>null</code>
     * @return the created action (not <code>null</code>)
     */
    protected HistoryDropDownAction<HistoryEntry> createHistoryDropDownAction(
        HistoryDropDownAction.History<HistoryEntry> history)
    {
        return new HistoryDropDownAction<>(history);
    }

    /**
     * Contributes the 'show history list' action to this view.
     * This method is called once, when the part's control is created.
     * <p>
     * Default implementation adds the given action to the view tool bar.
     * Subclasses may extend or override this method.
     * </p>
     *
     * @param action the 'show history list' action (never <code>null</code>)
     */
    protected void addHistoryDropDownAction(IAction action)
    {
        getViewSite().getActionBars().getToolBarManager().add(action);
    }

    /**
     * Returns the history used by this view; the history is represented by
     * a "live" list of history entries.
     *
     * @return the view history (never <code>null</code>)
     */
    protected List<HistoryEntry> getHistory()
    {
        return history;
    }

    /**
     * A callback that is invoked when the history has been updated.
     * <p>
     * Default implementation sets the enabled state of the 'show history list'
     * action according to whether the history is empty and, if the history
     * is empty, clears the view input.
     * </p>
     *
     * @see #getHistory()
     */
    protected void onHistoryChanged()
    {
        boolean empty = getHistory().isEmpty();
        historyDropDownAction.setEnabled(!empty);
        if (empty)
            setInputElements(NO_ELEMENTS);
    }

    private void addHistoryEntry(HistoryEntry entry)
    {
        List<HistoryEntry> history = getHistory();
        history.remove(entry);
        history.add(0, entry);
        onHistoryChanged();
    }

    private void makeSetHierarchyKindActions()
    {
        int size = supportedHierarchyKinds.size();
        if (size > 1)
        {
            setHierarchyKindActions = new SetHierarchyKindAction[size];
            int i = 0;
            for (TypeHierarchyKind kind : supportedHierarchyKinds)
                setHierarchyKindActions[i++] = new SetHierarchyKindAction(kind);
        }
    }

    private void makeSetLayoutModeActions()
    {
        List<SetLayoutModeAction> actions = new ArrayList<>();
        if (supportsLayoutMode(SWT.VERTICAL))
            actions.add(new SetLayoutModeAction(SWT.VERTICAL));
        if (supportsLayoutMode(SWT.HORIZONTAL))
            actions.add(new SetLayoutModeAction(SWT.HORIZONTAL));
        if (supportsLayoutMode(LAYOUT_AUTOMATIC))
            actions.add(new SetLayoutModeAction(LAYOUT_AUTOMATIC));
        if (supportsLayoutMode(SWT.NONE))
            actions.add(new SetLayoutModeAction(SWT.NONE));
        int size = actions.size();
        if (size > 1)
            setLayoutModeActions = actions.toArray(
                new SetLayoutModeAction[size]);
    }

    private int getDefaultLayoutMode()
    {
        if (supportsLayoutMode(LAYOUT_AUTOMATIC))
            return LAYOUT_AUTOMATIC;
        if (supportsLayoutMode(SWT.VERTICAL))
            return SWT.VERTICAL;
        if (supportsLayoutMode(SWT.HORIZONTAL))
            return SWT.HORIZONTAL;
        if (supportsLayoutMode(SWT.NONE))
            return SWT.NONE;
        throw new AssertionError();
    }

    private void adjustLayout(int layoutMode)
    {
        if (layoutMode == SWT.NONE)
            return;

        Point size = sashForm.getParent().getParent().getSize();
        if (size.x == 0 || size.y == 0)
            return;

        int orientation = (layoutMode == LAYOUT_AUTOMATIC) ? (size.x > size.y
            ? SWT.HORIZONTAL : SWT.VERTICAL) : layoutMode;

        if (sashForm.getOrientation() == orientation && layoutAdjusted)
            return;

        if (sashForm.getOrientation() != orientation)
        {
            saveSashFormWeights();
            sashForm.setOrientation(orientation);
        }

        restoreSashFormWeights();
        layoutAdjusted = true;
    }

    private void saveSashFormWeights()
    {
        if (!layoutAdjusted)
            return;

        int[] weights = sashForm.getWeights();
        if (weights.length < 2)
            return;

        if (sashForm.getOrientation() == SWT.HORIZONTAL)
            horizontalWeights = weights;
        else
            verticalWeights = weights;
    }

    private void restoreSashFormWeights()
    {
        int[] weights = (sashForm.getOrientation() == SWT.HORIZONTAL)
            ? horizontalWeights : verticalWeights;
        if (weights != null)
            sashForm.setWeights(weights);
    }

    private void initContextMenu(Control parent, IMenuListener listener,
        String menuId, ISelectionProvider selectionProvider)
    {
        MenuManager manager = new MenuManager();
        manager.setRemoveAllWhenShown(true);
        manager.addMenuListener(listener);
        Menu menu = manager.createContextMenu(parent);
        parent.setMenu(menu);
        getSite().registerContextMenu(menuId, manager, selectionProvider);
    }

    private static Object getSelectedElement(ISelection selection)
    {
        if (selection instanceof IStructuredSelection)
        {
            IStructuredSelection ss = (IStructuredSelection)selection;
            if (ss.size() == 1)
                return ss.getFirstElement();
        }
        return null;
    }

    private static Set<TypeHierarchyKind> symmetricDifference(
        Set<TypeHierarchyKind> kindsA, Set<TypeHierarchyKind> kindsB)
    {
        Set<TypeHierarchyKind> result = EnumSet.copyOf(kindsA);
        for (TypeHierarchyKind kind : kindsB)
        {
            if (!result.add(kind))
                result.remove(kind);
        }
        return result;
    }

    private static String toString(int[] values)
    {
        if (values == null)
            return null;
        StringBuilder sb = new StringBuilder();
        int length = values.length;
        for (int i = 0; i < length; i++)
        {
            sb.append(values[i]);
            if (i < length - 1)
                sb.append(',');
        }
        return sb.toString();
    }

    private static int[] toIntArray(String s) throws NumberFormatException
    {
        if (s == null)
            return null;
        String[] values = s.split(","); //$NON-NLS-1$
        int length = values.length;
        int[] result = new int[length];
        for (int i = 0; i < length; i++)
        {
            result[i] = Integer.parseInt(values[i]);
        }
        return result;
    }

    /**
     * Represents an entry of the type hierarchy view history list.
     */
    protected abstract static class HistoryEntry
    {
        private final Object[] inputElements;

        /**
         * Constructs a history entry for the given input elements.
         * Clients <b>must not</b> modify the given array afterwards.
         *
         * @param inputElements never <code>null</code>; never empty
         */
        protected HistoryEntry(Object[] inputElements)
        {
            if (inputElements.length == 0)
                throw new AssertionError();
            this.inputElements = inputElements;
        }

        /**
         * Returns the input elements for this history entry.
         *
         * @return the input elements (never <code>null</code>; never empty).
         *  Clients <b>must not</b> modify the returned array.
         */
        public final Object[] getInputElements()
        {
            return inputElements;
        }

        @Override
        public boolean equals(Object obj)
        {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            HistoryEntry other = (HistoryEntry)obj;
            if (!Arrays.equals(inputElements, other.inputElements))
                return false;
            return true;
        }

        @Override
        public int hashCode()
        {
            return Arrays.hashCode(inputElements);
        }

        /**
         * Returns a user-readable text label for this history entry.
         * <p>
         * Default implementation composes a label based on labels for
         * input elements. It invokes {@link #getElementLabel(Object)}
         * to obtain a label for an input element.
         * </p>
         *
         * @return the text label of the history entry (never <code>null</code>)
         */
        public String getLabel()
        {
            switch (inputElements.length)
            {
            case 1:
                return MessageFormat.format(
                    Messages.TypeHierarchyViewPart_History_entry_label__0,
                    getElementLabel(inputElements[0]));
            case 2:
                return MessageFormat.format(
                    Messages.TypeHierarchyViewPart_History_entry_label__0__1,
                    getElementLabel(inputElements[0]), getElementLabel(
                        inputElements[1]));
            default:
                return MessageFormat.format(
                    Messages.TypeHierarchyViewPart_History_entry_label__0__1_more,
                    getElementLabel(inputElements[0]), getElementLabel(
                        inputElements[1]));
            }
        }

        /**
         * Returns a user-readable text label for the given element.
         *
         * @param element the given element
         * @return the text label of the element (never <code>null</code>)
         */
        protected abstract String getElementLabel(Object element);

        /**
         * Returns an image descriptor for this history entry.
         * <p>
         * Default implementation always returns <code>null</code>.
         * </p>
         *
         * @return the image descriptor of the history entry
         *  (may be <code>null</code>)
         */
        public ImageDescriptor getImageDescriptor()
        {
            return null;
        }
    }

    /**
     * Helper for opening editors on the viewer's selection.
     */
    protected class OpenEditorHelper
        extends OpenAndLinkWithEditorHelper
    {
        /**
         * Creates a new helper for the given viewer.
         *
         * @param viewer the viewer
         */
        public OpenEditorHelper(StructuredViewer viewer)
        {
            super(viewer);
        }

        @Override
        protected void activate(ISelection selection)
        {
            Object element = getSelectedElement(selection);
            if (element != null)
            {
                try
                {
                    revealInEditor(element, true, false);
                }
                catch (PartInitException e)
                {
                    // cannot happen: may not open a new editor
                }
            }
        }

        @Override
        protected void open(ISelection selection, boolean activate)
        {
            Object element = getSelectedElement(selection);
            if (element != null)
            {
                try
                {
                    revealInEditor(element, activate, true);
                }
                catch (PartInitException e)
                {
                    ErrorDialog.openError(getSite().getShell(),
                        Messages.TypeHierarchyViewPart_Open_selected_element,
                        Messages.TypeHierarchyViewPart_Error_opening_editor,
                        e.getStatus());
                }
            }
        }
    }

    private class FocusOnSelectionAction
        extends BaseSelectionListenerAction
    {
        FocusOnSelectionAction()
        {
            super(
                Messages.TypeHierarchyViewPart_Focus_on_selection_action_text);
            setToolTipText(
                Messages.TypeHierarchyViewPart_Focus_on_selection_action_tooltip);
        }

        @Override
        public void run()
        {
            setInputElements(getStructuredSelection().toArray());
        }

        @Override
        protected boolean updateSelection(IStructuredSelection selection)
        {
            return !selection.isEmpty() && arePossibleInputElements(
                selection.toArray());
        }
    }

    private class RefreshAction
        extends Action
    {
        RefreshAction()
        {
            setText(Messages.TypeHierarchyViewPart_Refresh_action_text);
            setToolTipText(
                Messages.TypeHierarchyViewPart_Refresh_action_tooltip);
            setImageDescriptor(Activator.getImageDescriptor(
                Activator.IMG_ELCL_REFRESH));
            setDisabledImageDescriptor(Activator.getImageDescriptor(
                Activator.IMG_DLCL_REFRESH));
        }

        @Override
        public void run()
        {
            refresh();
        }
    }

    private class SetHierarchyKindAction
        extends Action
    {
        final TypeHierarchyKind kind;

        SetHierarchyKindAction(TypeHierarchyKind kind)
        {
            super(null, AS_RADIO_BUTTON);
            this.kind = kind;
            switch (kind)
            {
            case TYPES:
                setText(
                    Messages.TypeHierarchyViewPart_Show_type_hierarchy_action_text);
                setToolTipText(
                    Messages.TypeHierarchyViewPart_Show_type_hierarchy_action_tooltip);
                setImageDescriptor(Activator.getImageDescriptor(
                    Activator.IMG_ELCL_TH_TYPES));
                break;
            case SUPERTYPES:
                setText(
                    Messages.TypeHierarchyViewPart_Show_supertype_hierarchy_action_text);
                setToolTipText(
                    Messages.TypeHierarchyViewPart_Show_supertype_hierarchy_action_tooltip);
                setImageDescriptor(Activator.getImageDescriptor(
                    Activator.IMG_ELCL_TH_SUPERTYPES));
                break;
            case SUBTYPES:
                setText(
                    Messages.TypeHierarchyViewPart_Show_subtype_hierarchy_action_text);
                setToolTipText(
                    Messages.TypeHierarchyViewPart_Show_subtype_hierarchy_action_tooltip);
                setImageDescriptor(Activator.getImageDescriptor(
                    Activator.IMG_ELCL_TH_SUBTYPES));
                break;
            }
            if (kind == getHierarchyKind())
                setChecked(true);
        }

        @Override
        public void run()
        {
            setHierarchyKind(kind);
        }
    }

    private class SetLayoutModeAction
        extends Action
    {
        final int layoutMode;

        SetLayoutModeAction(int layoutMode)
        {
            super(null, AS_RADIO_BUTTON);
            this.layoutMode = layoutMode;
            switch (layoutMode)
            {
            case SWT.VERTICAL:
                setText(
                    Messages.TypeHierarchyViewPart_Layout_vertical_action_text);
                setToolTipText(
                    Messages.TypeHierarchyViewPart_Layout_vertical_action_tooltip);
                setImageDescriptor(Activator.getImageDescriptor(
                    Activator.IMG_ELCL_LAYOUT_VERTICAL));
                break;
            case SWT.HORIZONTAL:
                setText(
                    Messages.TypeHierarchyViewPart_Layout_horizontal_action_text);
                setToolTipText(
                    Messages.TypeHierarchyViewPart_Layout_horizontal_action_tooltip);
                setImageDescriptor(Activator.getImageDescriptor(
                    Activator.IMG_ELCL_LAYOUT_HORIZONTAL));
                break;
            case LAYOUT_AUTOMATIC:
                setText(
                    Messages.TypeHierarchyViewPart_Layout_automatic_action_text);
                setToolTipText(
                    Messages.TypeHierarchyViewPart_Layout_automatic_action_tooltip);
                setImageDescriptor(Activator.getImageDescriptor(
                    Activator.IMG_ELCL_LAYOUT_AUTOMATIC));
                break;
            case SWT.NONE:
                setText(
                    Messages.TypeHierarchyViewPart_Layout_single_action_text);
                setToolTipText(
                    Messages.TypeHierarchyViewPart_Layout_single_action_tooltip);
                setImageDescriptor(Activator.getImageDescriptor(
                    Activator.IMG_ELCL_LAYOUT_SINGLE));
                break;
            default:
                throw new IllegalArgumentException();
            }
            if (layoutMode == getLayoutMode())
                setChecked(true);
        }

        @Override
        public void run()
        {
            setLayoutMode(layoutMode);
        }
    }
}