path: root/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/memory/MemoryBlocksTreeViewPane.java

/*******************************************************************************
 * Copyright (c) 2004, 2013 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     WindRiver - Bug 192028 [Memory View] Memory view does not
 *                 display memory blocks that do not reference IDebugTarget
 *
 *******************************************************************************/

package org.eclipse.debug.internal.ui.views.memory;

import java.util.ArrayList;

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.debug.core.DebugEvent;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.IDebugEventSetListener;
import org.eclipse.debug.core.IMemoryBlockListener;
import org.eclipse.debug.core.model.IDebugTarget;
import org.eclipse.debug.core.model.IMemoryBlock;
import org.eclipse.debug.core.model.IMemoryBlockRetrieval;
import org.eclipse.debug.internal.ui.DebugPluginImages;
import org.eclipse.debug.internal.ui.DebugUIMessages;
import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
import org.eclipse.debug.internal.ui.memory.provisional.MemoryViewPresentationContext;
import org.eclipse.debug.internal.ui.viewers.model.provisional.IPresentationContext;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.debug.ui.IDebugUIConstants;
import org.eclipse.debug.ui.contexts.DebugContextEvent;
import org.eclipse.debug.ui.contexts.IDebugContextListener;
import org.eclipse.debug.ui.memory.IMemoryRendering;
import org.eclipse.debug.ui.memory.IMemoryRenderingContainer;
import org.eclipse.debug.ui.memory.IMemoryRenderingSite;
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.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.ui.ISelectionListener;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IWorkbenchActionConstants;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.progress.UIJob;

/**
 * Tree viewer for memory blocks
 */
public class MemoryBlocksTreeViewPane implements ISelectionListener, ISelectionChangedListener, IMemoryViewPane, IMemoryRenderingContainer {

	public static final String PANE_ID = DebugUIPlugin.getUniqueIdentifier() + ".MemoryView.MemoryBlocksTreeViewPane"; //$NON-NLS-1$

	private IViewPart fParent;
	private IPresentationContext fPresentationContext;
	private MemoryViewTreeViewer fTreeViewer;
	protected IMemoryBlockRetrieval fRetrieval;
	private ViewPaneSelectionProvider fSelectionProvider;
	private AddMemoryBlockAction fAddMemoryBlockAction;
	private IAction fRemoveMemoryBlockAction;
	private IAction fRemoveAllMemoryBlocksAction;
	private String fPaneId;
	private boolean fVisible = true;
	private TreeViewPaneContextListener fDebugContextListener;
	private ViewPaneEventHandler fEvtHandler;
	private String fLabel;

	class TreeViewerRemoveMemoryBlocksAction extends Action {
		TreeViewerRemoveMemoryBlocksAction() {
			super();
			setText(DebugUIMessages.RemoveMemoryBlockAction_title);

			setToolTipText(DebugUIMessages.RemoveMemoryBlockAction_tooltip);
			setImageDescriptor(DebugPluginImages.getImageDescriptor(IInternalDebugUIConstants.IMG_ELCL_REMOVE_MEMORY));
			setHoverImageDescriptor(DebugPluginImages.getImageDescriptor(IInternalDebugUIConstants.IMG_LCL_REMOVE_MEMORY));
			setDisabledImageDescriptor(DebugPluginImages.getImageDescriptor(IInternalDebugUIConstants.IMG_DLCL_REMOVE_MEMORY));
			PlatformUI.getWorkbench().getHelpSystem().setHelp(this, IDebugUIConstants.PLUGIN_ID + ".RemoveMemoryBlockAction_context"); //$NON-NLS-1$
			setEnabled(true);
		}

		/*
		 * (non-Javadoc)
		 * @see org.eclipse.jface.action.IAction#run()
		 */
		@Override
		public void run() {
			ISelection selected = fTreeViewer.getSelection();

			if (selected != null && selected instanceof IStructuredSelection) {
				Object[] selectedMemBlks = ((IStructuredSelection) selected).toArray();
				ArrayList<Object> memoryBlocks = new ArrayList<Object>();
				for (int i = 0; i < selectedMemBlks.length; i++) {
					if (selectedMemBlks[i] instanceof IMemoryBlock) {
						memoryBlocks.add(selectedMemBlks[i]);
					}
				}

				DebugPlugin.getDefault().getMemoryBlockManager().removeMemoryBlocks(memoryBlocks.toArray(new IMemoryBlock[memoryBlocks.size()]));
			}
		}
	}

	class TreeViewerRemoveAllMemoryBlocksAction extends Action {
		TreeViewerRemoveAllMemoryBlocksAction() {
			super();
			setText(DebugUIMessages.MemoryBlocksTreeViewPane_2);

			setToolTipText(DebugUIMessages.MemoryBlocksTreeViewPane_2);
			setImageDescriptor(DebugPluginImages.getImageDescriptor(IInternalDebugUIConstants.IMG_ELCL_REMOVE_ALL));
			setHoverImageDescriptor(DebugPluginImages.getImageDescriptor(IInternalDebugUIConstants.IMG_ELCL_REMOVE_ALL));
			setDisabledImageDescriptor(DebugPluginImages.getImageDescriptor(IInternalDebugUIConstants.IMG_DLCL_REMOVE_ALL));
			PlatformUI.getWorkbench().getHelpSystem().setHelp(this, IDebugUIConstants.PLUGIN_ID + ".RemoveAllMemoryBlocksAction_context"); //$NON-NLS-1$
		}

		/*
		 * (non-Javadoc)
		 * @see org.eclipse.jface.action.IAction#run()
		 */
		@Override
		public void run() {

			IWorkbenchWindow window = DebugUIPlugin.getActiveWorkbenchWindow();
			if (window == null) {
				return;
			}
			boolean proceed = MessageDialog.openQuestion(window.getShell(), DebugUIMessages.MemoryBlocksTreeViewPane_0, DebugUIMessages.MemoryBlocksTreeViewPane_1); //
			if (proceed) {
				IMemoryBlock[] memoryBlocks = DebugPlugin.getDefault().getMemoryBlockManager().getMemoryBlocks(fRetrieval);
				DebugPlugin.getDefault().getMemoryBlockManager().removeMemoryBlocks(memoryBlocks);
			}
		}
	}

	class ViewPaneEventHandler implements IMemoryBlockListener, IDebugEventSetListener {
		private boolean fDisposed = false;

		public ViewPaneEventHandler() {
			DebugPlugin.getDefault().getMemoryBlockManager().addListener(this);
			DebugPlugin.getDefault().addDebugEventListener(this);
		}

		/*
		 * (non-Javadoc)
		 * @see org.eclipse.jface.viewers.IContentProvider#dispose()
		 */
		public void dispose() {
			fDisposed = true;
			DebugPlugin.getDefault().getMemoryBlockManager().removeListener(this);
			DebugPlugin.getDefault().removeDebugEventListener(this);
		}

		/*
		 * (non-Javadoc)
		 * @see org.eclipse.debug.internal.core.memory.IMemoryBlockListener#
		 * MemoryBlockAdded(org.eclipse.debug.core.model.IMemoryBlock)
		 */
		@Override
		public void memoryBlocksAdded(final IMemoryBlock[] memory) {
			// if the content provider is disposed, do not handle event
			if (fDisposed) {
				return;
			}
			updateActionsEnablement();
		}

		/*
		 * (non-Javadoc)
		 * @see org.eclipse.debug.internal.core.memory.IMemoryBlockListener#
		 * MemoryBlockRemoved(org.eclipse.debug.core.model.IMemoryBlock)
		 */
		@Override
		public void memoryBlocksRemoved(final IMemoryBlock[] memory) {
			if (fDisposed) {
				return;
			}
			updateActionsEnablement();
		}

		/*
		 * (non-Javadoc)
		 * @see
		 * org.eclipse.debug.internal.ui.views.memory.BasicDebugViewContentProvider
		 * #doHandleDebugEvent(org.eclipse.debug.core.DebugEvent)
		 */
		protected void doHandleDebugEvent(DebugEvent event) {

			// if the view is disposed, do not handle event
			if (fDisposed) {
				return;
			}

			if (event.getKind() == DebugEvent.TERMINATE) {
				// should only handle the terminate event if the target is
				// terminated
				if (event.getSource() instanceof IDebugTarget) {
					IMemoryBlockRetrieval srcRetrieval = MemoryViewUtil.getMemoryBlockRetrieval(event.getSource());
					if (srcRetrieval == fRetrieval) {
						// #setInput must be done on the UI thread
						UIJob job = new UIJob("setInput") { //$NON-NLS-1$
							@Override
							public IStatus runInUIThread(IProgressMonitor monitor) {

								// if viewpane is disposed, do not handle event
								if (fTreeViewer.getContentProvider() == null) {
									return Status.OK_STATUS;
								}

								fTreeViewer.setInput(null);
								return Status.OK_STATUS;
							}
						};

						job.setSystem(true);
						job.schedule();
					}
				}
			}
		}

		@Override
		public void handleDebugEvents(DebugEvent[] events) {
			for (int i = 0; i < events.length; i++) {
				doHandleDebugEvent(events[i]);
			}
		}
	}

	class TreeViewPaneContextListener implements IDebugContextListener {
		public void contextActivated(ISelection selection) {

			if (selection.isEmpty() && fRetrieval != null) {
				fRetrieval = null;
				if (fTreeViewer != null && fTreeViewer.getContentProvider() != null) {
					fTreeViewer.setInput(fRetrieval);
				}
				updateActionsEnablement();
				return;
			}

			if (selection instanceof IStructuredSelection) {
				Object obj = ((IStructuredSelection) selection).getFirstElement();
				if (obj instanceof IAdaptable) {
					IAdaptable context = (IAdaptable) obj;
					IMemoryBlockRetrieval retrieval = MemoryViewUtil.getMemoryBlockRetrieval(context);
					if (retrieval != null && retrieval != fRetrieval && fTreeViewer != null && fTreeViewer.getContentProvider() != null) {
						// set new setting
						fRetrieval = retrieval;
						fTreeViewer.setInput(fRetrieval);
					}
					updateActionsEnablement();
				}
			}
		}

		/*
		 * (non-Javadoc)
		 * @see
		 * org.eclipse.debug.internal.ui.contexts.provisional.IDebugContextListener
		 * #contextEvent(org.eclipse.debug.internal.ui.contexts.provisional.
		 * DebugContextEvent)
		 */
		@Override
		public void debugContextChanged(DebugContextEvent event) {
			if ((event.getFlags() & DebugContextEvent.ACTIVATED) > 0) {
				contextActivated(event.getContext());
			}
		}
	}

	public MemoryBlocksTreeViewPane(IViewPart parent) {
		fParent = parent;
		fSelectionProvider = new ViewPaneSelectionProvider();
	}

	@Override
	public Control createViewPane(Composite parent, String paneId, String label) {
		fPaneId = paneId;
		int style = SWT.MULTI | SWT.V_SCROLL | SWT.H_SCROLL | SWT.VIRTUAL;

		fLabel = label;

		IMemoryRenderingSite site = getMemoryRenderingSite();
		fPresentationContext = new MemoryViewPresentationContext(site, this, null);
		fTreeViewer = new MemoryViewTreeViewer(parent, style, fPresentationContext);

		IAdaptable context = DebugUITools.getPartDebugContext(fParent.getSite());
		IMemoryBlockRetrieval retrieval = MemoryViewUtil.getMemoryBlockRetrieval(context);
		if (retrieval != null) {
			fTreeViewer.setInput(retrieval);
		}

		fRetrieval = retrieval;

		fParent.getViewSite().getSelectionProvider().addSelectionChangedListener(this);
		fParent.getViewSite().getPage().addSelectionListener(this);

		fDebugContextListener = new TreeViewPaneContextListener();
		DebugUITools.addPartDebugContextListener(fParent.getSite(), fDebugContextListener);

		fTreeViewer.addSelectionChangedListener(new ISelectionChangedListener() {

			@Override
			public void selectionChanged(SelectionChangedEvent event) {
				ISelection treeSelected = event.getSelection();
				fSelectionProvider.setSelection(treeSelected);
			}
		});

		updateRetrieval();
		fEvtHandler = new ViewPaneEventHandler();

		// create context menu
		MenuManager mgr = createContextMenuManager();
		Menu menu = mgr.createContextMenu(fTreeViewer.getControl());
		fTreeViewer.getControl().setMenu(menu);

		GridData data = new GridData();
		data.grabExcessHorizontalSpace = true;
		data.grabExcessVerticalSpace = true;
		data.horizontalAlignment = SWT.FILL;
		data.verticalAlignment = SWT.FILL;
		fTreeViewer.getControl().setLayoutData(data);

		updateActionsEnablement();

		return fTreeViewer.getControl();
	}

	/**
	 *
	 */
	private void updateRetrieval() {

		Object context = DebugUITools.getPartDebugContext(fParent.getSite());
		fRetrieval = MemoryViewUtil.getMemoryBlockRetrieval(context);
	}

	protected MenuManager createContextMenuManager() {
		MenuManager menuMgr = new MenuManager("#PopupMenu"); //$NON-NLS-1$
		menuMgr.setRemoveAllWhenShown(true);
		menuMgr.addMenuListener(new IMenuListener() {
			@Override
			public void menuAboutToShow(IMenuManager manager) {
				manager.add(fAddMemoryBlockAction);
				manager.add(fRemoveMemoryBlockAction);
				manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
			}
		});

		// register a context menu manager, use its pane id as the menu id
		fParent.getSite().registerContextMenu(getId(), menuMgr, fSelectionProvider);
		return menuMgr;
	}

	@Override
	public void dispose() {
		fParent.getViewSite().getSelectionProvider().removeSelectionChangedListener(this);
		fParent.getViewSite().getPage().removeSelectionListener(this);
		fAddMemoryBlockAction.dispose();
		DebugUITools.removePartDebugContextListener(fParent.getSite(), fDebugContextListener);
		fEvtHandler.dispose();
		fPresentationContext.dispose();
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.ISelectionListener#selectionChanged(org.eclipse.ui.
	 * IWorkbenchPart, org.eclipse.jface.viewers.ISelection)
	 */
	@Override
	public void selectionChanged(IWorkbenchPart part, ISelection selection) {

		if (selection instanceof IStructuredSelection) {
			Object obj = ((IStructuredSelection) selection).getFirstElement();

			if (obj instanceof IMemoryBlock) {
				// if the selection event comes from this view
				if (part == fParent) {
					// do not change selection if the selection is already
					// correct
					ISelection treeSel = fTreeViewer.getSelection();
					if (treeSel instanceof IStructuredSelection) {
						if (((IStructuredSelection) treeSel).getFirstElement() == obj) {
							return;
						}
					}
					// remove itself as selection listener when handling
					// selection changed event
					removeSelctionListener(this);
					fTreeViewer.setSelection(selection);
					// remove itself as selection listener when handling
					// selection changed event
					addSelectionListener(this);
				}
			}
		}

	}

	@Override
	public String getId() {
		return fPaneId;
	}

	/*
	 * (non-Javadoc)
	 * @see
	 * org.eclipse.debug.internal.ui.views.memory.IMemoryViewPane#getActions()
	 */
	@Override
	public IAction[] getActions() {

		if (fAddMemoryBlockAction == null) {
			fAddMemoryBlockAction = new RetargetAddMemoryBlockAction((IMemoryRenderingSite) fParent);
		}

		if (fRemoveMemoryBlockAction == null) {
			fRemoveMemoryBlockAction = new TreeViewerRemoveMemoryBlocksAction();
		}

		if (fRemoveAllMemoryBlocksAction == null) {
			fRemoveAllMemoryBlocksAction = new TreeViewerRemoveAllMemoryBlocksAction();
		}

		updateActionsEnablement();

		return new IAction[] {
				fAddMemoryBlockAction, fRemoveMemoryBlockAction,
				fRemoveAllMemoryBlocksAction };
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.debug.internal.ui.views.memory.IMemoryViewPane#
	 * addSelectionListener(org.eclipse.jface.viewers.ISelectionChangedListener)
	 */
	@Override
	public void addSelectionListener(ISelectionChangedListener listener) {
		if (fSelectionProvider == null) {
			fSelectionProvider = new ViewPaneSelectionProvider();
		}

		fSelectionProvider.addSelectionChangedListener(listener);
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.debug.internal.ui.views.memory.IMemoryViewPane#
	 * removeSelctionListener
	 * (org.eclipse.jface.viewers.ISelectionChangedListener)
	 */
	@Override
	public void removeSelctionListener(ISelectionChangedListener listener) {
		if (fSelectionProvider == null) {
			return;
		}

		fSelectionProvider.removeSelectionChangedListener(listener);
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.debug.internal.ui.views.memory.IMemoryViewPane#
	 * getSelectionProvider()
	 */
	@Override
	public ISelectionProvider getSelectionProvider() {
		return fSelectionProvider;
	}

	/*
	 * (non-Javadoc)
	 * @see
	 * org.eclipse.debug.internal.ui.views.memory.IMemoryViewPane#restoreViewPane
	 * ()
	 */
	@Override
	public void restoreViewPane() {
		updateRetrieval();
		updateActionsEnablement();
	}

	/*
	 * (non-Javadoc)
	 * @see
	 * org.eclipse.debug.internal.ui.views.memory.IMemoryViewPane#getControl()
	 */
	@Override
	public Control getControl() {
		return fTreeViewer.getControl();
	}

	/*
	 * (non-Javadoc)
	 * @see
	 * org.eclipse.debug.internal.ui.views.memory.IMemoryViewPane#setVisible
	 * (boolean)
	 */
	@Override
	public void setVisible(boolean visible) {
		if (fVisible != visible) {
			fVisible = visible;

			if (fVisible) {
				fTreeViewer.refresh();
				fTreeViewer.getControl().setFocus();
			}
		}
	}

	/*
	 * (non-Javadoc)
	 * @see
	 * org.eclipse.debug.internal.ui.views.memory.IMemoryViewPane#isVisible()
	 */
	@Override
	public boolean isVisible() {
		return fVisible;
	}

	private void updateActionsEnablement() {
		if (fRemoveMemoryBlockAction == null) {
			return;
		}

		if (fRemoveAllMemoryBlocksAction == null) {
			return;
		}

		if (fRetrieval != null) {
			IMemoryBlock[] memBlocks = DebugPlugin.getDefault().getMemoryBlockManager().getMemoryBlocks(fRetrieval);
			if (memBlocks.length > 0) {
				fRemoveMemoryBlockAction.setEnabled(true);
				fRemoveAllMemoryBlocksAction.setEnabled(true);
			} else {
				fRemoveMemoryBlockAction.setEnabled(false);
				fRemoveAllMemoryBlocksAction.setEnabled(false);
			}
		} else {
			fRemoveMemoryBlockAction.setEnabled(false);
			fRemoveAllMemoryBlocksAction.setEnabled(false);
		}
	}

	@Override
	public void selectionChanged(SelectionChangedEvent event) {
		// only handle selection changed from parent's selection provider
		if (event.getSource() == fParent.getSite().getSelectionProvider()) {
			MemoryBlocksTreeViewPane.this.selectionChanged(fParent, event.getSelection());
		}
	}

	public StructuredViewer getViewer() {
		return fTreeViewer;
	}

	@Override
	public IMemoryRenderingSite getMemoryRenderingSite() {
		if (fParent instanceof IMemoryRenderingSite) {
			return (IMemoryRenderingSite) fParent;
		}
		return null;
	}

	@Override
	public void addMemoryRendering(IMemoryRendering rendering) {
		// do nothing
	}

	@Override
	public void removeMemoryRendering(IMemoryRendering rendering) {
		// do nothing
	}

	@Override
	public IMemoryRendering[] getRenderings() {
		return new IMemoryRendering[0];
	}

	@Override
	public IMemoryRendering getActiveRendering() {
		return null;
	}

	@Override
	public String getLabel() {
		return fLabel;
	}
}