/*******************************************************************************
 * Copyright (c) 2008, 2021 SAP AG, IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *    SAP AG - initial API and implementation
 *    IBM Corporation - accessibility related fixes 
 *    Chris Grindstaff
 *******************************************************************************/
package org.eclipse.mat.ui.snapshot.views.inspector;

import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.layout.GridLayoutFactory;
import org.eclipse.jface.layout.TableColumnLayout;
import org.eclipse.jface.layout.TreeColumnLayout;
import org.eclipse.jface.resource.FontDescriptor;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.viewers.ColumnWeightData;
import org.eclipse.jface.viewers.IFontProvider;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.mat.SnapshotException;
import org.eclipse.mat.query.IContextObject;
import org.eclipse.mat.query.IContextObjectSet;
import org.eclipse.mat.snapshot.ISnapshot;
import org.eclipse.mat.snapshot.OQL;
import org.eclipse.mat.snapshot.model.GCRootInfo;
import org.eclipse.mat.snapshot.model.IClass;
import org.eclipse.mat.snapshot.model.IInstance;
import org.eclipse.mat.snapshot.model.IObject;
import org.eclipse.mat.snapshot.model.IObjectArray;
import org.eclipse.mat.snapshot.model.IPrimitiveArray;
import org.eclipse.mat.snapshot.model.ObjectReference;
import org.eclipse.mat.ui.MemoryAnalyserPlugin;
import org.eclipse.mat.ui.Messages;
import org.eclipse.mat.ui.accessibility.AccessibleCompositeAdapter;
import org.eclipse.mat.ui.accessibility.AccessibleToolbarAdapter;
import org.eclipse.mat.ui.snapshot.ImageHelper;
import org.eclipse.mat.ui.snapshot.editor.HeapEditor;
import org.eclipse.mat.ui.snapshot.editor.ISnapshotEditorInput;
import org.eclipse.mat.ui.util.Copy;
import org.eclipse.mat.ui.util.PopupMenu;
import org.eclipse.mat.ui.util.QueryContextMenu;
import org.eclipse.mat.util.MessageUtil;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CTabFolder;
import org.eclipse.swt.custom.CTabItem;
import org.eclipse.swt.custom.SashForm;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.events.MenuAdapter;
import org.eclipse.swt.events.MenuEvent;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.PaletteData;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.swt.widgets.ToolItem;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeColumn;
import org.eclipse.ui.IPartListener;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.actions.ActionFactory;
import org.eclipse.ui.part.ViewPart;

public class InspectorView extends ViewPart implements IPartListener, ISelectionChangedListener
{
    private HeapEditor editor;
    /* package */ISnapshot snapshot;

    private Composite top;
    private Composite visualViewer;
    private TableViewer topTableViewer;
    private CTabFolder tabFolder;
    private TableViewer attributesTable;
    private TableViewer staticsTable;
    private TreeViewer classHierarchyTree;
    private StyledText resolvedValue;
    private boolean pinSelection = false;
    private Font font;

    private List<Menu> contextMenus = new ArrayList<Menu>();

    boolean keepInSync = true;

    /* package */static class BaseNode
    {
        int objectId;
        long addr;

        public BaseNode(int objectId)
        {
            this(objectId, 0);
        }
        public BaseNode(int objectId, long addr)
        {
            this.objectId = objectId;
            this.addr = addr;
        }

        static int objectID(IObject object)
        {
            if (object == null)
                return -1;
            try
            {
                return object.getObjectId();
            }
            catch (RuntimeException e)
            {
                if (e.getCause() instanceof SnapshotException)
                    return -1;
                throw e;
            }
        }
    }

    private static class ObjectNode extends BaseNode
    {
        String label;
        int imageType;

        public ObjectNode(IObject object)
        {
            super(objectID(object), object.getObjectAddress());
            this.label = object.getTechnicalName();
            this.imageType = ImageHelper.getType(object);
        }

        public String getLabel()
        {
            return label;
        }

        public int getImageType()
        {
            return imageType;
        }
    }

    private static class TopTableLabelProvider extends LabelProvider
    {

        @Override
        public String getText(Object element)
        {
            if (element instanceof InfoItem)
                return ((InfoItem) element).getText();
            else if (element instanceof ObjectNode)
                return ((ObjectNode) element).getLabel();
            else if (element instanceof GCRootInfo[])
                return Messages.InspectorView_GCroot + GCRootInfo.getTypeSetAsString((GCRootInfo[]) element);
            else
                return "";//$NON-NLS-1$
        }

        @Override
        public Image getImage(Object element)
        {
            if (element instanceof InfoItem)
                return MemoryAnalyserPlugin.getDefault().getImage(((InfoItem) element).getDescriptor());
            else if (element instanceof ObjectNode)
                return ImageHelper.getImage(((ObjectNode) element).getImageType());
            else if (element instanceof GCRootInfo[])
                return MemoryAnalyserPlugin.getImage(ImageHelper.Decorations.GC_ROOT);
            else
                return null;
        }

    }

    private static final class TableContentProvider implements IStructuredContentProvider
    {
        Object[] elements;

        public Object[] getElements(Object inputElement)
        {
            return elements;
        }

        public void dispose()
        {}

        public void inputChanged(Viewer viewer, Object oldInput, Object newInput)
        {
            if (newInput instanceof Collection<?>)
            {
                this.elements = ((Collection<?>) newInput).toArray();
            }
            else
            {
                this.elements = (Object[]) newInput;
            }
        }
    }

    public static class InfoItem extends BaseNode
    {
        private ImageDescriptor descriptor;
        private String text;

        public InfoItem(ImageDescriptor descriptor, String text)
        {
            this(null, descriptor, text);
        }

        public InfoItem(IObject object, ImageDescriptor descriptor, String text)
        {
            super(objectID(object), object != null ? object.getObjectAddress() : 0);
            this.descriptor = descriptor;
            this.text = text;
        }

        public ImageDescriptor getDescriptor()
        {
            return descriptor;
        }

        public String getText()
        {
            return text;
        }
    }

    private class MenuListener extends MenuAdapter
    {
        private Menu menu;
        private StructuredViewer viewer;

        public MenuListener(Menu menu, StructuredViewer viewer)
        {
            this.menu = menu;
            this.viewer = viewer;
        }

        @Override
        public void menuShown(MenuEvent e)
        {
            MenuItem[] items = menu.getItems();
            for (int ii = 0; ii < items.length; ii++)
                items[ii].dispose();

            PopupMenu popup = new PopupMenu();
            fillContextMenu(popup, viewer);
            popup.addToMenu(getViewSite().getActionBars().getStatusLineManager(), menu);
        }

    }

    private static class HierarchyTreeContentProvider implements ITreeContentProvider
    {
        LinkedList<IClass> supers;

        public Object[] getChildren(Object element)
        {
            int index = supers.indexOf(element);
            if (index >= 0 && index + 1 < supers.size())
                return new Object[] { supers.get(index + 1) };
            return ((IClass) element).getSubclasses().toArray();
        }

        public IClass getParent(Object element)
        {
            return ((IClass) element).getSuperClass();
        }

        public boolean hasChildren(Object element)
        {
            return !((IClass) element).getSubclasses().isEmpty();

        }

        public Object[] getElements(Object inputElement)
        {
            if (supers.isEmpty())
                return new Object[0];

            return new Object[] { supers.get(0) };
        }

        public void dispose()
        {}

        public void inputChanged(Viewer viewer, Object oldInput, Object newInput)
        {
            supers = new LinkedList<IClass>();
            if (newInput instanceof IClass[])
            {
                IClass[] input = (IClass[]) newInput;

                supers = new LinkedList<IClass>();
                supers.add(input[0]);

                while (input[0].hasSuperClass())
                {
                    input[0] = input[0].getSuperClass();
                    supers.addFirst(input[0]);
                }
            }
        }
    }

    private class HierarchyLabelProvider extends LabelProvider implements IFontProvider
    {
        private int classId;

        public HierarchyLabelProvider(int classId)
        {
            super();
            this.classId = classId;
        }

        @Override
        public Image getImage(Object element)
        {
            return (element instanceof IClass) ? ImageHelper.getImage(ImageHelper.Type.CLASS) : null;
        }

        @Override
        public String getText(Object element)
        {
            return (element instanceof IClass) ? ((IClass) element).getName() : "";//$NON-NLS-1$
        }

        public Font getFont(Object element)
        {
            if (element instanceof IClass && ((IClass) element).getObjectId() == classId)
                return font;
            return null;
        }

    }

    // //////////////////////////////////////////////////////////////
    // view construction
    // //////////////////////////////////////////////////////////////

    @Override
    public void createPartControl(final Composite parent)
    {
        SashForm form = new SashForm(parent, SWT.VERTICAL);
        GridLayoutFactory.fillDefaults().numColumns(1).margins(0, 0).spacing(1, 1).applyTo(form);

        top = new Composite(form, SWT.TOP);
        GridLayoutFactory.fillDefaults().numColumns(1).margins(0, 0).spacing(1, 1).applyTo(top);

        IToolBarManager mgr = getViewSite().getActionBars().getToolBarManager();
        mgr.add(createSyncAction());

        FontDescriptor fontDescriptor = FontDescriptor.createFrom(JFaceResources.getDefaultFont());
        fontDescriptor = fontDescriptor.setStyle(SWT.BOLD);
        this.font = fontDescriptor.createFont(top.getDisplay());

        createTopTable(top);
        createTabFolder(top);
        createVisualViewer(form);
        form.setWeights(new int[] { 95, 5 });

        // add page listener
        getSite().getPage().addPartListener(this);

        hookContextMenu();
        showBootstrapPart();
    }

    private void createVisualViewer(Composite parent)
    {
        visualViewer = new Composite(parent, SWT.TOP);
        visualViewer.addPaintListener(new PaintListener()
        {
            public void paintControl(PaintEvent paintEvent)
            {
                Object toShow = visualViewer.getData("toShow");//$NON-NLS-1$
                if (toShow == null)
                    return;

                if (toShow instanceof Image)
                {
                    paintEvent.gc.drawImage((Image) toShow, 0, 0);
                }
                else if (toShow instanceof RGB)
                {
                    Color color = new Color(paintEvent.display, (RGB) toShow);
                    paintEvent.gc.setBackground(color);
                    paintEvent.gc.fillRectangle(0, 0, visualViewer.getSize().x, visualViewer.getSize().y);
                    color.dispose();
                }
            }
        });
        visualViewer.setVisible(false);
    }

    private Action createSyncAction()
    {
        Action syncAction = new Action(null, IAction.AS_CHECK_BOX)
        {

            @Override
            public void run()
            {
                if (!keepInSync)
                {
                    showBootstrapPart();
                    if (editor != null)
                        updateOnSelection(editor.getSelection());
                    keepInSync = true;
                }
                else
                {
                    keepInSync = false;
                }
                this.setChecked(!keepInSync);
            }

        };
        syncAction.setImageDescriptor(MemoryAnalyserPlugin
                        .getImageDescriptor(MemoryAnalyserPlugin.ISharedImages.SYNCED));
        syncAction.setToolTipText(Messages.InspectorView_LinkWithSnapshot);

        return syncAction;

    }

    private void createTopTable(Composite parent)
    {
        Composite composite = new Composite(parent, SWT.NONE);
        topTableViewer = new TableViewer(composite, SWT.FULL_SELECTION | SWT.MULTI);

        Table table = topTableViewer.getTable();
        AccessibleCompositeAdapter.access(table);
        TableColumnLayout columnLayout = new TableColumnLayout();
        composite.setLayout(columnLayout);

        TableColumn column = new TableColumn(table, SWT.LEFT);
        columnLayout.setColumnData(column, new ColumnWeightData(100, 10));

        // on win32, item height is reported too low the first time around
        int itemHeight = table.getItemHeight() + 1;
        if (itemHeight < 17)
            itemHeight = 17;

        int scrollbarHeight = 2;
        if (!Platform.OS_WIN32.equals(Platform.getOS()))//$NON-NLS-1$
            scrollbarHeight = table.getHorizontalBar().getSize().y;

        int detailsHeight = 9 * itemHeight + scrollbarHeight;

        table.setHeaderVisible(false);
        table.setLinesVisible(false);
        topTableViewer.setLabelProvider(new TopTableLabelProvider());
        topTableViewer.setContentProvider(new TableContentProvider());

        GridDataFactory.fillDefaults().hint(SWT.DEFAULT, detailsHeight)//
                        .grab(true, false).applyTo(composite);

    }

    private void createTabFolder(Composite parent)
    {
        tabFolder = new CTabFolder(parent, SWT.TOP | SWT.FLAT);
        GridDataFactory.fillDefaults().grab(true, true).align(SWT.FILL, SWT.FILL).applyTo(tabFolder);

        ToolBar toolBar = new ToolBar(tabFolder, SWT.HORIZONTAL | SWT.FLAT);
        // Add custom AccessibleAdapter, passing in associated ToolBar.
        toolBar.getAccessible().addAccessibleListener(new AccessibleToolbarAdapter(toolBar) );
        tabFolder.setTopRight(toolBar);
        // set the height of the tab to display the tool bar correctly
        tabFolder.setTabHeight(Math.max(toolBar.computeSize(SWT.DEFAULT, SWT.DEFAULT).y, tabFolder.getTabHeight()));
        final ToolItem pinItem = new ToolItem(toolBar, SWT.CHECK);
        pinItem.setImage(MemoryAnalyserPlugin.getImage(MemoryAnalyserPlugin.ISharedImages.PINNED));
        pinItem.setToolTipText(Messages.InspectorView_PinTab);
        pinItem.addSelectionListener(new SelectionAdapter()
        {
            @Override
            public void widgetSelected(SelectionEvent e)
            {
                pinSelection = !pinSelection;
                pinItem.setSelection(pinSelection);
            }
        });

        toolBar.pack();

        final CTabItem staticsTab = new CTabItem(tabFolder, SWT.NULL);
        staticsTab.setText(Messages.InspectorView_Statics);
        staticsTable = createTable(tabFolder);
        staticsTab.setControl(staticsTable.getTable().getParent());

        CTabItem instancesTab = new CTabItem(tabFolder, SWT.NULL);
        instancesTab.setText(Messages.InspectorView_Attributes);
        attributesTable = createTable(tabFolder);
        instancesTab.setControl(attributesTable.getTable().getParent());

        CTabItem classHierarchyTab = new CTabItem(tabFolder, SWT.NULL);
        classHierarchyTab.setText(Messages.InspectorView_ClassHierarchy);
        classHierarchyTree = createHierarchyTree(tabFolder);
        classHierarchyTab.setControl(classHierarchyTree.getTree().getParent());

        CTabItem valueTab = new CTabItem(tabFolder, SWT.NULL);
        valueTab.setText(Messages.InspectorView_Value);
        resolvedValue = createValue(tabFolder);
        valueTab.setControl(resolvedValue);

        getViewSite().getActionBars().setGlobalActionHandler(ActionFactory.COPY.getId(), new Action()
        {
            @Override
            public void run()
            {
                if (topTableViewer.getControl().isFocusControl())
                {
                    Copy.copyToClipboard(topTableViewer.getControl());
                }
                else
                {
                    int s = tabFolder.getSelectionIndex();
                    switch (s)
                    {
                        case 0:
                            Copy.copyToClipboard(staticsTable.getControl());
                            break;
                        case 1:
                            Copy.copyToClipboard(attributesTable.getControl());
                            break;
                        case 2:
                            Copy.copyToClipboard(classHierarchyTree.getControl());
                            break;
                        case 3:
                            String buffer = resolvedValue.getSelectionText();
                            Copy.copyToClipboard(buffer, resolvedValue.getDisplay());
                            break;
                        default:
                            break;
                    }
                }
            }
        });

        tabFolder.setSelection(0);
    }

    private StyledText createValue(CTabFolder parent)
    {
        StyledText ret = new StyledText(parent, SWT.READ_ONLY | SWT.MULTI | SWT.WRAP);
        return ret;
    }

    private TreeViewer createHierarchyTree(CTabFolder parent)
    {
        Composite composite = new Composite(parent, SWT.NONE);
        TreeViewer classHierarchyTree = new TreeViewer(composite, SWT.FULL_SELECTION | SWT.MULTI);
        classHierarchyTree.setContentProvider(new HierarchyTreeContentProvider());
        classHierarchyTree.setLabelProvider(new HierarchyLabelProvider(-1));

        Tree tree = classHierarchyTree.getTree();
        AccessibleCompositeAdapter.access(tree);
        TreeColumnLayout columnLayout = new TreeColumnLayout();
        composite.setLayout(columnLayout);

        TreeColumn column = new TreeColumn(tree, SWT.LEFT);
        columnLayout.setColumnData(column, new ColumnWeightData(100, 10));

        return classHierarchyTree;
    }

    private TableViewer createTable(Composite parent)
    {
        Composite composite = new Composite(parent, SWT.NONE);
        TableColumnLayout columnLayout = new TableColumnLayout();
        composite.setLayout(columnLayout);
        GridDataFactory.fillDefaults().grab(true, true).align(SWT.FILL, SWT.FILL).applyTo(composite);

        final TableViewer viewer = new TableViewer(composite, SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.MULTI);
        Table table = viewer.getTable();
        AccessibleCompositeAdapter.access(table);
        viewer.setContentProvider(new FieldsContentProvider());
        viewer.setLabelProvider(new FieldsLabelProvider(this, table.getFont()));

        TableColumn tableColumn = new TableColumn(table, SWT.LEFT);
        tableColumn.setText(Messages.InspectorView_Type);
        tableColumn.setWidth(50);
        columnLayout.setColumnData(tableColumn, new ColumnWeightData(10, 50, false));

        tableColumn = new TableColumn(table, SWT.LEFT);
        tableColumn.setWidth(80);
        tableColumn.setText(Messages.InspectorView_Name);
        columnLayout.setColumnData(tableColumn, new ColumnWeightData(30, 80));

        tableColumn = new TableColumn(table, SWT.LEFT);
        tableColumn.setWidth(250);
        tableColumn.setText(Messages.InspectorView_Value);
        columnLayout.setColumnData(tableColumn, new ColumnWeightData(60, 250, true));

        table.setHeaderVisible(true);

        return viewer;
    }

    private void hookContextMenu()
    {
        createMenu(staticsTable);
        createMenu(attributesTable);
        createMenu(topTableViewer);
        createMenu(classHierarchyTree);
    }

    private void createMenu(StructuredViewer viewer)
    {
        Menu menu = new Menu(viewer.getControl());
        menu.addMenuListener(new MenuListener(menu, viewer));
        viewer.getControl().setMenu(menu);
        contextMenus.add(menu);
    }

    private void fillContextMenu(PopupMenu manager, StructuredViewer viewer)
    {
        IStructuredSelection selection = (IStructuredSelection) viewer.getSelection();

        if (editor != null)
        {
            InspectorContextProvider contextProvider = new InspectorContextProvider(snapshot);
            final IContextObject firstElement = contextProvider.getContext(selection.getFirstElement());

            IStructuredSelection editorSelection = (IStructuredSelection) editor.getSelection();
            final Object editorElement = editorSelection.getFirstElement();

            boolean isObject = firstElement != null
                            && editorElement instanceof IContextObject
                            && firstElement.getObjectId() != ((IContextObject) editorElement)
                                            .getObjectId();

            if (isObject)
            {
                manager.add(new Action(Messages.InspectorView_GoInto)
                {
                    @Override
                    public void run()
                    {
                        updateOnSelection(new StructuredSelection(firstElement));
                    }
                });
                manager.addSeparator();
            }

            QueryContextMenu contextMenu = new QueryContextMenu(editor, contextProvider);
            contextMenu.addContextActions(manager, selection, viewer.getControl());
        }
    }

    private void showBootstrapPart()
    {
        IWorkbenchPage page = getSite().getPage();
        if (page != null)
            partActivated(page.getActiveEditor());
    }

    protected boolean isImportant(IWorkbenchPart part)
    {
        return part instanceof HeapEditor;
    }

    @Override
    public void dispose()
    {
        if (this.editor != null)
        {
            this.editor.removeSelectionChangedListener(this);
            this.editor = null;
        }

        for (Menu menu : contextMenus)
        {
            if (menu != null && !menu.isDisposed())
            {
                menu.dispose();
                menu = null;
            }
        }

        if (font != null)
            font.dispose();

        getSite().getPage().removePartListener(this);
        super.dispose();
    }

    // //////////////////////////////////////////////////////////////
    // view life-cycle
    // //////////////////////////////////////////////////////////////

    @Override
    public void setFocus()
    {
        tabFolder.getSelection().getControl().setFocus();
    }

    public void partActivated(IWorkbenchPart part)
    {
        if (!isImportant(part)) { return; }

        if (!keepInSync)
            return;

        HeapEditor heapEditor = (HeapEditor) part;

        if (this.editor != heapEditor)
        {
            if (this.editor != null)
            {
                this.editor.removeSelectionChangedListener(this);
            }

            this.editor = heapEditor;

            final ISnapshotEditorInput input = heapEditor.getSnapshotInput();
            if (input.hasSnapshot())
            {
                this.snapshot = input.getSnapshot();
            }
            else
            {
                this.snapshot = null;

                // snapshot is not yet available -> register to be informed once
                // the snapshot has been fully loaded
                input.addChangeListener(new ISnapshotEditorInput.IChangeListener()
                {

                    public void onBaselineLoaded(ISnapshot snapshot)
                    {}

                    public void onSnapshotLoaded(ISnapshot snapshot)
                    {
                        if (InspectorView.this.snapshot == null)
                            InspectorView.this.snapshot = snapshot;

                        input.removeChangeListener(this);
                    }

                });
            }

            this.editor.addSelectionChangedListener(this);

            updateOnSelection(this.editor.getSelection());
        }
    }

    public void partBroughtToTop(IWorkbenchPart part)
    {
        partActivated(part);
    }

    public void partClosed(IWorkbenchPart part)
    {
        if (!isImportant(part)) { return; }

        HeapEditor heapEditor = (HeapEditor) part;

        if (this.editor == heapEditor)
        {
            this.editor.removeSelectionChangedListener(this);

            clearInput();

            this.snapshot = null;
            this.editor = null;

            if (!keepInSync)
            {
                keepInSync = true;
                showBootstrapPart();
            }
        }
    }

    public void partDeactivated(IWorkbenchPart part)
    {}

    public void partOpened(IWorkbenchPart part)
    {}

    public void selectionChanged(SelectionChangedEvent event)
    {
        if (keepInSync)
        {
            ISelection selection = event.getSelection();
            updateOnSelection(selection);
        }
    }

    private void updateOnSelection(ISelection selection)
    {
        IContextObject objectSet = null;

        if (selection instanceof IStructuredSelection)
        {
            Object object = ((IStructuredSelection) selection).getFirstElement();
            if (object instanceof IContextObject)
                objectSet = (IContextObject) object;
        }

        long addr = 0;
        if (objectSet instanceof IContextObjectSet)
        {
            String oql = ((IContextObjectSet)objectSet).getOQL();
            if (oql != null && ((IContextObjectSet)objectSet).getObjectIds().length == 0)
            {
                String addr0 = OQL.forAddress(0);
                addr0 = addr0.substring(0, addr0.length() - 1);
                if (oql.startsWith(addr0.substring(0, addr0.length())) && oql.substring(addr0.length() - 2).matches("0[xX][0-9a-fA-F]+")) //$NON-NLS-1$
                {
                    addr = Long.parseUnsignedLong(oql.substring(addr0.length()), 16);
                }
            }
        }
        if (objectSet == null || (objectSet.getObjectId() < 0 && addr == 0))
        {
            clearInput();
        }
        else
        {
            final int objectId = objectSet.getObjectId();

            // do not update if the selection has not changed (double click)
            Object data = topTableViewer.getData("input"); //$NON-NLS-1$
            if (data != null)
            {
                int current = ((Integer) data).intValue();
                if (current == objectId)
                {
                    Object addr0 = topTableViewer.getData("address"); //$NON-NLS-1$
                    if (addr0 != null)
                    {
                        long currentAddr = ((Long) addr0).longValue();
                        if (currentAddr == addr)
                            return;
                    }
                }
            }
            final long objectAddress = addr;

            final ISnapshot savedSnapshot = snapshot;

            Job job = new Job(Messages.InspectorView_UpdateObjectDetails)
            {

                @Override
                protected IStatus run(IProgressMonitor monitor)
                {
                    try
                    {
                        if (snapshot == null || savedSnapshot != snapshot)
                            return Status.OK_STATUS;

                        final IObject object;
                        if (objectId >= 0)
                            object = savedSnapshot.getObject(objectId);
                        else
                            object = (new ObjectReference(savedSnapshot, objectAddress)).getObject();

                        // prepare object info
                        final List<Object> classInfos = prepareClassInfo(object);

                        // prepare static fields info
                        final LazyFields<?> staticFields = prepareStaticFields(object);

                        // prepare attributes
                        final LazyFields<?> attributeFields = prepareAttributes(object);

                        // update visual viewer
                        final Object toShow = prepareVisualInfo(object);

                        topTableViewer.getControl().getDisplay().asyncExec(new Runnable()
                        {
                            public void run()
                            {
                                topTableViewer.setInput(classInfos);
                                topTableViewer.setData("input", objectId);//$NON-NLS-1$
                                topTableViewer.setData("address", object.getObjectAddress());//$NON-NLS-1$
                                staticsTable.setInput(staticFields);
                                attributesTable.setInput(attributeFields);
                                updateVisualViewer(toShow);

                                IClass input = object instanceof IClass ? (IClass) object : object.getClazz();

                                try
                                {
                                    classHierarchyTree.getTree().setRedraw(false);
                                    classHierarchyTree.setInput(null);
                                    classHierarchyTree
                                                    .setLabelProvider(new HierarchyLabelProvider(input.getObjectId()));
                                    classHierarchyTree.setInput(new IClass[] { input });
                                    classHierarchyTree.expandAll();
                                }
                                finally
                                {
                                    classHierarchyTree.getTree().setRedraw(true);
                                }

                                String txt = object.getClassSpecificName();
                                resolvedValue.setText(txt != null ? txt : "");//$NON-NLS-1$

                                if (!pinSelection)// no tab pinned
                                {
                                    int selectionIndex = tabFolder.getSelectionIndex();
                                    if (selectionIndex <= 1)
                                    {
                                        int newSelectionIndex = (object instanceof IClass) ? 0 : 1;
                                        if (selectionIndex != newSelectionIndex)
                                            tabFolder.setSelection(newSelectionIndex);
                                    }
                                }

                            }

                            private void updateVisualViewer(Object toShow)
                            {
                                Object previous = visualViewer.getData("toShow");//$NON-NLS-1$
                                if (previous instanceof Image)
                                    ((Image) previous).dispose();

                                if (toShow != null)
                                {
                                    if (toShow instanceof ImageData)
                                    {
                                        Image image = new Image(visualViewer.getDisplay(), (ImageData) toShow);
                                        visualViewer.setData("toShow", image);//$NON-NLS-1$
                                    }
                                    else if (toShow instanceof RGB)
                                    {
                                        visualViewer.setData("toShow", toShow);//$NON-NLS-1$
                                    }
                                    visualViewer.redraw();
                                }
                                visualViewer.setVisible(toShow != null);
                                visualViewer.getParent().layout();
                            }
                        });

                        return Status.OK_STATUS;
                    }
                    catch (SnapshotException e)
                    {
                        return new Status(IStatus.ERROR, MemoryAnalyserPlugin.PLUGIN_ID,
                                        Messages.InspectorView_ErrorUpdatingInspector, e);
                    }
                }

                private Object prepareVisualInfo(IObject object) throws SnapshotException
                {
                    String kind = object.getClazz().getName();

                    if ("org.eclipse.swt.graphics.RGB".equals(kind))//$NON-NLS-1$
                    {
                        Integer red = (Integer) object.resolveValue("red");//$NON-NLS-1$
                        Integer green = (Integer) object.resolveValue("green");//$NON-NLS-1$
                        Integer blue = (Integer) object.resolveValue("blue");//$NON-NLS-1$

                        if (red == null || green == null || blue == null)
                            return null;

                        return new RGB(red, green, blue);
                    }
                    else if ("org.eclipse.swt.graphics.ImageData".equals(kind))//$NON-NLS-1$
                    {
                        IPrimitiveArray data = (IPrimitiveArray) object.resolveValue("data");//$NON-NLS-1$
                        Integer width = (Integer) object.resolveValue("width");//$NON-NLS-1$
                        Integer height = (Integer) object.resolveValue("height");//$NON-NLS-1$
                        Integer depth = (Integer) object.resolveValue("depth");//$NON-NLS-1$
                        Integer scanlinePad = (Integer) object.resolveValue("scanlinePad");//$NON-NLS-1$
                        Integer transparentPixel = (Integer) object.resolveValue("transparentPixel");//$NON-NLS-1$

                        if (data == null || width == null || height == null || depth == null || scanlinePad == null
                                        || transparentPixel == null)
                            return null;

                        PaletteData paletteData = makePaletteData((IInstance) object.resolveValue("palette"));//$NON-NLS-1$
                        if (paletteData == null)
                            return null;

                        byte[] dataArray = (byte[]) data.getValueArray();
                        byte[] dataCopy = new byte[dataArray.length];
                        System.arraycopy(dataArray, 0, dataCopy, 0, dataArray.length);

                        ImageData imageData = new ImageData(width, height, depth, paletteData, scanlinePad, dataCopy);
                        imageData.transparentPixel = transparentPixel;

                        IPrimitiveArray alphaBytes = (IPrimitiveArray) object.resolveValue("alphaData");//$NON-NLS-1$
                        if (alphaBytes != null)
                        {
                            byte[] alphaDataArray = (byte[]) alphaBytes.getValueArray();
                            byte[] alphaDataCopy = new byte[alphaDataArray.length];
                            System.arraycopy(alphaDataArray, 0, alphaDataCopy, 0, alphaDataArray.length);
                            imageData.alphaData = alphaDataCopy;
                        }

                        return imageData;
                    }

                    return null;
                }

                private LazyFields<?> prepareAttributes(final IObject object)
                {
                    LazyFields<?> fields = null;
                    if (object instanceof IInstance)
                        fields = new LazyFields.Instance((IInstance) object);
                    else if (object instanceof IPrimitiveArray)
                        fields = new LazyFields.PrimitiveArray((IPrimitiveArray) object);
                    else if (object instanceof IObjectArray)
                        fields = new LazyFields.ObjectArray((IObjectArray) object);
                    else if (object instanceof IClass)
                        fields = new LazyFields.Class((IClass) object, true, false);
                    else
                        fields = LazyFields.EMPTY;

                    return fields;
                }

                private LazyFields<?> prepareStaticFields(final IObject object)
                {
                    LazyFields<?> fields = null;
                    if (object instanceof IClass)
                        fields = new LazyFields.Class((IClass) object, false, false);
                    else if (object instanceof IInstance)
                        fields = new LazyFields.Class(object.getClazz(), false, true);
                    else
                        fields = LazyFields.EMPTY;

                    return fields;
                }

                private List<Object> prepareClassInfo(final IObject object) throws SnapshotException
                {
                    List<Object> details = new ArrayList<Object>();

                    details.add(new InfoItem(object, MemoryAnalyserPlugin
                                    .getImageDescriptor(MemoryAnalyserPlugin.ISharedImages.ID), "0x"//$NON-NLS-1$
                                    + Long.toHexString(object.getObjectAddress())));

                    String className = object instanceof IClass ? ((IClass) object).getName() : object.getClazz()
                                    .getName();

                    int p = className.lastIndexOf('.');
                    if (p < 0) // primitive
                    {
                        InfoItem item = new InfoItem(object, ImageHelper.getImageDescriptor(ImageHelper
                                        .getType(object)), className);
                        details.add(item);
                        details.add(new InfoItem(MemoryAnalyserPlugin
                                        .getImageDescriptor(MemoryAnalyserPlugin.ISharedImages.PACKAGE), ""));//$NON-NLS-1$
                    }
                    else
                    {
                        details.add(new InfoItem(object, ImageHelper.getImageDescriptor(ImageHelper
                                        .getType(object)), className.substring(p + 1)));
                        details.add(new InfoItem(MemoryAnalyserPlugin
                                        .getImageDescriptor(MemoryAnalyserPlugin.ISharedImages.PACKAGE), className
                                        .substring(0, p)));
                    }

                    details.add(new ObjectNode(object.getClazz()));

                    IClass superClass = object instanceof IClass ? ((IClass) object).getSuperClass() : object
                                    .getClazz().getSuperClass();

                    if (superClass != null)
                    {
                        details.add(new InfoItem(superClass, MemoryAnalyserPlugin
                                        .getImageDescriptor(MemoryAnalyserPlugin.ISharedImages.SUPERCLASS), superClass
                                        .getName()));
                    }

                    ISnapshot snapshot = object.getSnapshot();
                    if (object instanceof IClass)
                        details.add(new ObjectNode(snapshot.getObject(((IClass) object).getClassLoaderId())));
                    else
                        details.add(new ObjectNode(snapshot.getObject(object.getClazz().getClassLoaderId())));

                    details.add(new InfoItem(MemoryAnalyserPlugin
                                    .getImageDescriptor(MemoryAnalyserPlugin.ISharedImages.SIZE), MessageUtil.format(
                                    Messages.InspectorView_shallowSize, object.getUsedHeapSize())));
                    details.add(new InfoItem(MemoryAnalyserPlugin
                                    .getImageDescriptor(MemoryAnalyserPlugin.ISharedImages.SIZE), MessageUtil.format(
                                    Messages.InspectorView_retainedSize, object.getRetainedHeapSize())));

                    GCRootInfo[] gc;
                    try
                    {
                        gc = object.getGCRootInfo();
                    }
                    catch (SnapshotException e)
                    {
                        gc = null;
                    }
                    details.add(gc != null ? (Object) gc : new InfoItem(MemoryAnalyserPlugin
                                    .getImageDescriptor(ImageHelper.Decorations.GC_ROOT),
                                    Messages.InspectorView_noGCRoot));
                    return details;
                }

                private PaletteData makePaletteData(IInstance palette) throws SnapshotException
                {
                    Boolean isDirect = (Boolean) palette.resolveValue("isDirect");//$NON-NLS-1$
                    if (isDirect == null)
                        return null;

                    if (isDirect)
                    {
                        Integer redMask = (Integer) palette.resolveValue("redMask");//$NON-NLS-1$
                        Integer greenMask = (Integer) palette.resolveValue("greenMask");//$NON-NLS-1$
                        Integer blueMask = (Integer) palette.resolveValue("blueMask");//$NON-NLS-1$

                        if (redMask == null || greenMask == null || blueMask == null)
                            return null;

                        return new PaletteData(redMask, greenMask, blueMask);
                    }
                    else
                    {
                        IObjectArray array = (IObjectArray) palette.resolveValue("colors");//$NON-NLS-1$
                        if (array == null)
                            return null;

                        RGB[] rgbs = new RGB[array.getLength()];
                        long[] refs = array.getReferenceArray();
                        ISnapshot snapshot = palette.getSnapshot();
                        for (int ii = 0; ii < refs.length; ii++)
                        {
                            int id = snapshot.mapAddressToId(refs[ii]);
                            IObject obj = snapshot.getObject(id);
                            if (obj == null)
                                return null;

                            Integer red = (Integer) obj.resolveValue("red");//$NON-NLS-1$
                            Integer green = (Integer) obj.resolveValue("green");//$NON-NLS-1$
                            Integer blue = (Integer) obj.resolveValue("blue");//$NON-NLS-1$

                            if (red == null || green == null || blue == null)
                                return null;

                            rgbs[ii] = new RGB(red, green, blue);
                        }

                        return new PaletteData(rgbs);
                    }
                }
            };
            job.schedule();
        }
    }

    private void clearInput()
    {
        topTableViewer.getControl().getDisplay().asyncExec(new Runnable()
        {
            public void run()
            {
                // fix: add one (dummy) row to each table so that the
                // ColumnViewer does not cache the last (real) row subject
                // which in turn often has a reference to the snapshot

                if (topTableViewer.getContentProvider() != null)
                {
                    topTableViewer.setInput(new Object[] { new Object() });
                    topTableViewer.setData("input", null); //$NON-NLS-1$
                }

                if (staticsTable.getContentProvider() != null)
                {
                    staticsTable.setInput(LazyFields.EMPTY);
                }

                if (attributesTable.getContentProvider() != null)
                {
                    attributesTable.setInput(LazyFields.EMPTY);
                }

                if (classHierarchyTree.getContentProvider() != null)
                {
                    classHierarchyTree.setInput(new Object[] { new Object() });
                }

                if (!resolvedValue.isDisposed())
                {
                    resolvedValue.setText(""); //$NON-NLS-1$
                }

                for (Menu menu : contextMenus)
                {
                    if (!menu.isDisposed())
                        disposeItems(menu);
                }
            }
        });
    }

    private void disposeItems(Menu menu)
    {
        MenuItem[] items = menu.getItems();
        for (MenuItem menuItem : items)
        {
            if (!menuItem.isDisposed())
                menuItem.dispose();
        }
    }

}