| /******************************************************************************* |
| * Copyright (c) 2004 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Common Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/cpl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.debug.internal.ui.views.memory; |
| |
| import java.util.ArrayList; |
| import java.util.Enumeration; |
| import java.util.Hashtable; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.debug.core.model.IDebugElement; |
| 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.core.memory.IExtendedMemoryBlock; |
| import org.eclipse.debug.internal.core.memory.IMemoryBlockListener; |
| import org.eclipse.debug.internal.core.memory.IMemoryRendering; |
| import org.eclipse.debug.internal.core.memory.MemoryBlockManager; |
| import org.eclipse.debug.internal.ui.DebugUIPlugin; |
| import org.eclipse.debug.ui.IDebugModelPresentation; |
| import org.eclipse.debug.ui.IDebugUIConstants; |
| import org.eclipse.debug.ui.IDebugView; |
| 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.IToolBarManager; |
| import org.eclipse.jface.action.MenuManager; |
| import org.eclipse.jface.action.Separator; |
| 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.StructuredSelection; |
| import org.eclipse.jface.viewers.Viewer; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.SWTException; |
| import org.eclipse.swt.custom.StackLayout; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.events.SelectionListener; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.TabFolder; |
| import org.eclipse.swt.widgets.TabItem; |
| import org.eclipse.ui.IActionBars; |
| import org.eclipse.ui.IPartListener2; |
| import org.eclipse.ui.ISelectionListener; |
| import org.eclipse.ui.IWorkbenchActionConstants; |
| import org.eclipse.ui.IWorkbenchPart; |
| import org.eclipse.ui.IWorkbenchPartReference; |
| import org.eclipse.ui.help.WorkbenchHelp; |
| import org.eclipse.ui.part.IPage; |
| import org.eclipse.ui.part.Page; |
| import org.eclipse.ui.part.PageBook; |
| import org.eclipse.ui.part.PageBookView; |
| import org.eclipse.ui.texteditor.IUpdate; |
| |
| /** |
| * |
| * @since 3.0 |
| */ |
| public class MemoryView extends PageBookView implements IDebugView, IMemoryBlockListener, ISelectionListener, IMemoryView { |
| |
| private Composite parent; |
| protected StackLayout stackLayout; |
| private TabFolder emptyTabFolder; |
| protected Hashtable tabFolderHashtable; |
| |
| private Action addMemoryBlockAction; |
| private Action removeMemoryBlockAction; |
| private Action resetMemoryBlockAction; |
| private Action copyViewToClipboardAction; |
| private Action printViewTabAction; |
| |
| protected IMemoryBlockRetrieval key; // store the key for current tab folder |
| |
| private MemoryViewPartListener fListener = null; |
| private boolean fVisible; |
| protected MemoryViewSelectionProvider fSelectionProvider; |
| protected ViewTabEnablementManager fViewTabEnablementManager; |
| |
| protected Hashtable fMenuMgr; |
| |
| /** |
| * A page in this view's page book that contains this view's viewer. |
| */ |
| class ViewerPage extends Page { |
| /** @see IPage#createControl(Composite) */ |
| public void createControl(Composite parent) { } |
| |
| /** @see IPage#getControl() */ |
| public Control getControl() { return null; } |
| |
| /** @see IPage#setFocus() */ |
| public void setFocus() { |
| Viewer viewer= getViewer(); |
| if (viewer != null) { |
| Control c = viewer.getControl(); |
| if (!c.isFocusControl()) { |
| c.setFocus(); |
| } |
| } |
| } |
| } |
| |
| class MemoryViewPartListener implements IPartListener2 |
| { |
| MemoryView fView = null; |
| |
| public MemoryViewPartListener(MemoryView view) |
| { |
| fView = view; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.IPartListener2#partActivated(org.eclipse.ui.IWorkbenchPartReference) |
| */ |
| public void partActivated(IWorkbenchPartReference ref) { |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.IPartListener2#partBroughtToTop(org.eclipse.ui.IWorkbenchPartReference) |
| */ |
| public void partBroughtToTop(IWorkbenchPartReference ref) { |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.IPartListener2#partClosed(org.eclipse.ui.IWorkbenchPartReference) |
| */ |
| public void partClosed(IWorkbenchPartReference ref) { |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.IPartListener2#partDeactivated(org.eclipse.ui.IWorkbenchPartReference) |
| */ |
| public void partDeactivated(IWorkbenchPartReference ref) { |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.IPartListener2#partHidden(org.eclipse.ui.IWorkbenchPartReference) |
| */ |
| public void partHidden(IWorkbenchPartReference ref) { |
| |
| IWorkbenchPart part = ref.getPart(false); |
| |
| if (part == fView) |
| { |
| fVisible = false; |
| // disable current storag block |
| |
| IMemoryViewTab top = getTopMemoryTab(); |
| |
| if (top != null) |
| { |
| top.setEnabled(false); |
| } |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.IPartListener2#partVisible(org.eclipse.ui.IWorkbenchPartReference) |
| */ |
| public void partVisible(IWorkbenchPartReference ref) { |
| IWorkbenchPart part = ref.getPart(false); |
| |
| if (part == fView) |
| { |
| fVisible = true; |
| |
| // get current selection from debug view |
| ISelection selection = DebugUIPlugin.getDefault().getWorkbench().getActiveWorkbenchWindow().getSelectionService().getSelection(IDebugUIConstants.ID_DEBUG_VIEW); |
| if (MemoryViewUtil.isValidSelection(selection)) |
| { |
| Object elem = ((IStructuredSelection)selection).getFirstElement(); |
| |
| IDebugTarget debugTarget = ((IDebugElement)elem).getDebugTarget(); |
| IMemoryBlockRetrieval memRetrieval =(IMemoryBlockRetrieval) ((IDebugElement)elem).getAdapter(IMemoryBlockRetrieval.class); |
| |
| if (memRetrieval == null) |
| { |
| // if debug element returns null from getAdapter, assume its debug target is going to retrieve memory blocks |
| memRetrieval = debugTarget; |
| } |
| |
| if (tabFolderHashtable.containsKey(memRetrieval)) |
| { |
| TabFolder toDisplay = (TabFolder)tabFolderHashtable.get(memRetrieval); |
| |
| if (toDisplay != null) |
| { |
| setTabFolder(toDisplay); |
| parent.layout(); |
| |
| // restore view tabs |
| IMemoryBlock[] memoryBlocks = MemoryBlockManager.getMemoryBlockManager().getMemoryBlocks(debugTarget); |
| |
| if (toDisplay.getItemCount() == 0) |
| { |
| restoreViewTabs(memoryBlocks); |
| } |
| } |
| } |
| |
| // disable current storag block |
| |
| IMemoryViewTab top = getTopMemoryTab(); |
| |
| if (top != null) |
| { |
| if (!top.isEnabled()) |
| { |
| top.setEnabled(true); |
| } |
| } |
| } |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.IPartListener2#partInputChanged(org.eclipse.ui.IWorkbenchPartReference) |
| */ |
| public void partInputChanged(IWorkbenchPartReference ref) { |
| } |
| |
| public void partOpened(IWorkbenchPartReference ref) |
| { |
| } |
| } |
| |
| // TODO: Handle selection change in table if possible |
| class MemoryViewSelectionProvider implements ISelectionProvider, SelectionListener |
| { |
| ArrayList fListeners = new ArrayList(); |
| ISelection selectedMemoryBlock; |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jface.viewers.ISelectionProvider#addSelectionChangedListener(org.eclipse.jface.viewers.ISelectionChangedListener) |
| */ |
| public void addSelectionChangedListener(ISelectionChangedListener listener) |
| { |
| if (!fListeners.contains(listener)) |
| fListeners.add(listener); |
| |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jface.viewers.ISelectionProvider#getSelection() |
| */ |
| public ISelection getSelection() |
| { |
| return selectedMemoryBlock; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jface.viewers.ISelectionProvider#removeSelectionChangedListener(org.eclipse.jface.viewers.ISelectionChangedListener) |
| */ |
| public void removeSelectionChangedListener(ISelectionChangedListener listener) |
| { |
| if (fListeners.contains(listener)) |
| fListeners.remove(listener); |
| |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jface.viewers.ISelectionProvider#setSelection(org.eclipse.jface.viewers.ISelection) |
| */ |
| public void setSelection(ISelection selection) |
| { |
| selectedMemoryBlock = selection; |
| |
| fireChanged(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt.events.SelectionEvent) |
| */ |
| public void widgetSelected(SelectionEvent e) |
| { |
| if (getTopMemoryTab() == null) |
| return; |
| |
| IMemoryBlock blk = getTopMemoryTab().getMemoryBlock(); |
| |
| if (blk != null) |
| { |
| setSelection(new StructuredSelection(blk)); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.swt.events.SelectionListener#widgetDefaultSelected(org.eclipse.swt.events.SelectionEvent) |
| */ |
| public void widgetDefaultSelected(SelectionEvent e) |
| { |
| |
| |
| } |
| |
| public void fireChanged() |
| { |
| SelectionChangedEvent evt = new SelectionChangedEvent(this, getSelection()); |
| for (int i=0; i<fListeners.size(); i++) |
| { |
| ((ISelectionChangedListener)fListeners.get(i)).selectionChanged(evt); |
| } |
| } |
| } |
| |
| /** |
| * The constructor. |
| */ |
| public MemoryView() { |
| |
| } |
| |
| /** |
| * This is a callback that will allow us |
| * to create the viewer and initialize it. |
| */ |
| public void createPartControl(Composite parent) { |
| |
| super.createPartControl(parent); |
| this.parent = parent; |
| stackLayout = new StackLayout(); |
| parent.setLayout(stackLayout); |
| |
| WorkbenchHelp.setHelp(parent, IDebugUIConstants.PLUGIN_ID + ".MemoryView_context"); //$NON-NLS-1$ |
| |
| fSelectionProvider = new MemoryViewSelectionProvider(); |
| fViewTabEnablementManager = new ViewTabEnablementManager(); |
| |
| // contribute actions |
| makeActions(); |
| contributeToActionBars(); |
| |
| getViewSite().getActionBars().updateActionBars(); |
| |
| emptyTabFolder = new TabFolder(parent, SWT.NULL); |
| setTabFolder(emptyTabFolder); |
| |
| tabFolderHashtable = new Hashtable(3); |
| fMenuMgr = new Hashtable(); |
| |
| addListeners(); |
| |
| // check current selection and create folder if something is already selected from debug view |
| ISelection selection = DebugUIPlugin.getDefault().getWorkbench().getActiveWorkbenchWindow().getSelectionService().getSelection(IDebugUIConstants.ID_DEBUG_VIEW); |
| |
| if (MemoryViewUtil.isValidSelection(selection)) |
| { |
| createFolder(selection); |
| } |
| |
| fVisible = true; |
| |
| getSite().setSelectionProvider(this.fSelectionProvider); |
| } |
| |
| protected void addListeners() |
| { |
| fListener = new MemoryViewPartListener(this); |
| getSite().getPage().addPartListener(fListener); |
| |
| MemoryBlockManager.getMemoryBlockManager().addListener(this); |
| DebugUIPlugin.getDefault().getWorkbench().getActiveWorkbenchWindow().getSelectionService().addSelectionListener(IDebugUIConstants.ID_DEBUG_VIEW, this); |
| // DebugUIPlugin.getDefault().getWorkbench().getActiveWorkbenchWindow().getSelectionService().addSelectionListener(IMemoryViewConstants.MEMORY_RENDERING_VIEW_ID, this); |
| DebugUIPlugin.getDefault().getWorkbench().getActiveWorkbenchWindow().getSelectionService().addSelectionListener(this); |
| } |
| |
| private MenuManager createContextMenuManager() { |
| MenuManager menuMgr = new MenuManager("#PopupMenu"); //$NON-NLS-1$ |
| menuMgr.setRemoveAllWhenShown(true); |
| menuMgr.addMenuListener(new IMenuListener() { |
| public void menuAboutToShow(IMenuManager manager) { |
| |
| IMemoryViewTab top = getTopMemoryTab(); |
| |
| if (top != null) |
| { |
| top.fillContextMenu(manager); |
| } |
| manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS)); |
| } |
| }); |
| |
| getSite().registerContextMenu(menuMgr, fSelectionProvider); |
| return menuMgr; |
| } |
| |
| private void contributeToActionBars() { |
| IActionBars bars = getViewSite().getActionBars(); |
| fillLocalToolBar(bars.getToolBarManager()); |
| |
| bars.getMenuManager().add(new SetDefaultColumnSizePrefAction()); |
| bars.updateActionBars(); |
| } |
| |
| |
| protected void fillContextMenu(IMenuManager manager) { |
| manager.add(addMemoryBlockAction); |
| manager.add(removeMemoryBlockAction); |
| manager.add(resetMemoryBlockAction); |
| // Other plug-ins can contribute there actions here |
| manager.add(new Separator("Additions")); //$NON-NLS-1$ |
| } |
| |
| protected void fillLocalToolBar(IToolBarManager manager) { |
| manager.add(addMemoryBlockAction); |
| manager.add(removeMemoryBlockAction); |
| |
| manager.add(new Separator()); |
| |
| manager.add(resetMemoryBlockAction); |
| manager.add(copyViewToClipboardAction); |
| manager.add(printViewTabAction); |
| } |
| |
| private void makeActions() { |
| addMemoryBlockAction = new AddMemoryBlockAction(); |
| |
| removeMemoryBlockAction = new RemoveMemoryBlockAction(); |
| removeMemoryBlockAction.setEnabled(false); |
| |
| resetMemoryBlockAction = new ResetMemoryBlockAction(); |
| resetMemoryBlockAction.setEnabled(false); |
| |
| copyViewToClipboardAction = new CopyViewTabToClipboardAction(); |
| copyViewToClipboardAction.setEnabled(false); |
| |
| printViewTabAction = new PrintViewTabAction(); |
| printViewTabAction.setEnabled(false); |
| |
| } |
| |
| /** |
| * Passing the focus request to the viewer's control. |
| */ |
| public void setFocus() { |
| stackLayout.topControl.setFocus(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.debug.ui.IMemoryBlockListener#MemoryBlockAdded(org.eclipse.debug.core.model.IMemoryBlock) |
| */ |
| public void MemoryBlockAdded(IMemoryBlock memoryblk) { |
| |
| final IMemoryBlock memory = memoryblk; |
| |
| // disable current view tab |
| if (getTopMemoryTab() != null) |
| getTopMemoryTab().setEnabled(false); |
| TabFolder tabFolder = (TabFolder) stackLayout.topControl; |
| TabItem tab = new TabItem(tabFolder, SWT.NULL); |
| // create memory tab with new memory |
| MemoryViewTab memoryTab; |
| |
| // create a new menu manager for each view tab |
| // menu manager will be cleaned up when the view tab is disposed |
| // or when the view is disposed |
| MenuManager menuMgr = createContextMenuManager(); |
| |
| HexRendering hexRendering = new HexRendering(memory, IMemoryViewConstants.RENDERING_RAW_MEMORY); |
| |
| memoryTab = new MemoryViewTab(memory, tab, menuMgr, hexRendering, new HexRenderer()); |
| |
| // put to hashtable to be cleaned up later |
| fMenuMgr.put(memoryTab, menuMgr); |
| |
| // bring new tab to the front |
| tabFolder.setSelection(tabFolder.indexOf(memoryTab.getTab())); |
| // bringing the tab to the front causes the view tab's cursor to lose focus |
| // this is a work-around to force focus to the cursor when the tab is created |
| // memoryTab.setCursorFocus(); |
| |
| updateToolBarActionsEnablement(); |
| |
| fSelectionProvider.setSelection(new StructuredSelection(memoryTab.getMemoryBlock())); |
| |
| // ask debug target about memeory retrieval |
| IDebugTarget debugTarget = memory.getDebugTarget(); |
| IMemoryBlockRetrieval standardMemRetrieval = (IMemoryBlockRetrieval)memory.getAdapter(IMemoryBlockRetrieval.class); |
| |
| if (standardMemRetrieval == null) |
| { |
| // if getAdapter returns null, assume we only have one language under the debug target |
| // make use of the debug target to get IMemoryBlock |
| standardMemRetrieval = debugTarget; |
| } |
| } |
| /* (non-Javadoc) |
| * @see org.eclipse.debug.ui.IMemoryBlockListener#MemoryBlockRemoved(org.eclipse.debug.core.model.IMemoryBlock) |
| */ |
| public void MemoryBlockRemoved(IMemoryBlock memoryblk) |
| { |
| final IMemoryBlock memory = memoryblk; |
| |
| // need to run the following code on the UI Thread to avoid invalid thread access exception |
| Display.getDefault().asyncExec(new Runnable() |
| { |
| public void run() |
| { |
| TabFolder tabFolder = (TabFolder) stackLayout.topControl; |
| |
| if (tabFolder.isDisposed()) |
| return; |
| |
| TabItem[] tabs = tabFolder.getItems(); |
| boolean foundTab = false; |
| for (int i = 0; i < tabs.length; i++) |
| { |
| IMemoryViewTab viewTab = (IMemoryViewTab) tabs[i].getData(); |
| if (viewTab.getMemoryBlock() == memory) |
| { |
| disposeViewTab(viewTab, tabs[i]); |
| foundTab = true; |
| break; |
| } |
| } |
| if (foundTab) |
| { |
| if (tabFolder.getItemCount() == 0) |
| { |
| removeMemoryBlockAction.setEnabled(false); |
| resetMemoryBlockAction.setEnabled(false); |
| copyViewToClipboardAction.setEnabled(false); |
| printViewTabAction.setEnabled(false); |
| |
| // if there is no more item in the top tab folder |
| // set selection as empty |
| fSelectionProvider.setSelection(new StructuredSelection(new Object[0])); |
| |
| // if there is no item left in the folder and if the debug target |
| // for the last memory block has been terminated |
| // Clean up the tab folder and use the EmptyTabFolder for display |
| IDebugTarget dt = memory.getDebugTarget(); |
| if (dt.isTerminated() || dt.isDisconnected()) |
| { |
| if (key != null) |
| { |
| tabFolderHashtable.remove(key); |
| } |
| if (!tabFolder.isDisposed()) |
| { |
| tabFolder.dispose(); |
| } |
| emptyFolder(); |
| } |
| } |
| } |
| // if a tab is not found in the current top control |
| // this deletion is a result of a debug target termination |
| // find memory from other folder and dispose the view tab |
| if (!foundTab) |
| { |
| Enumeration enumeration = tabFolderHashtable.elements(); |
| while (enumeration.hasMoreElements()) |
| { |
| tabFolder = (TabFolder) enumeration.nextElement(); |
| tabs = tabFolder.getItems(); |
| IMemoryViewTab viewTab = null; |
| for (int i = 0; i < tabs.length; i++) |
| { |
| viewTab = (IMemoryViewTab) tabs[i].getData(); |
| if (viewTab.getMemoryBlock() == memory) |
| { |
| disposeViewTab(viewTab, tabs[i]); |
| foundTab = true; |
| break; |
| } |
| } |
| if (foundTab) |
| { |
| if (tabFolder.getItemCount() == 0) |
| { |
| // if there is no item left in the folder and if the debug target |
| // for the last memory block has been terminated |
| // Clean up the tab folder and use the EmptyTabFolder for display |
| IDebugTarget dt = memory.getDebugTarget(); |
| if (dt.isTerminated() || dt.isDisconnected()) |
| { |
| Enumeration keyEnum = tabFolderHashtable.keys(); |
| Object tabKey = null; |
| while (keyEnum.hasMoreElements()) |
| { |
| tabKey = keyEnum.nextElement(); |
| if (tabFolderHashtable.get(tabKey) == tabFolder) |
| { |
| break; |
| } |
| } |
| // dispose of the folder if it no longer contains anything |
| if (!tabFolder.isDisposed()) |
| tabFolder.dispose(); |
| // remove the folder from the hashtable |
| if (tabKey != null) |
| tabFolderHashtable.remove(tabKey); |
| // use empty folder for display |
| emptyFolder(); |
| } |
| } |
| break; |
| } |
| } |
| } |
| } |
| }); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.IWorkbenchPart#dispose() |
| */ |
| public void dispose() { |
| |
| removeListeners(); |
| |
| // dispose empty folders |
| emptyTabFolder.dispose(); |
| |
| // dispose all other folders |
| try { |
| |
| if (tabFolderHashtable != null) { |
| Enumeration enumeration = tabFolderHashtable.elements(); |
| |
| while (enumeration.hasMoreElements()) |
| { |
| TabFolder tabFolder = (TabFolder)enumeration.nextElement(); |
| |
| if (tabFolder.isDisposed()) |
| continue; |
| |
| // if tab folder is not empty, dipose view tabs |
| TabItem[] tabs = tabFolder.getItems(); |
| |
| for (int i=0; i<tabs.length; i++) |
| { |
| IMemoryViewTab viewTab = (IMemoryViewTab)tabs[i].getData(); |
| |
| if (!tabs[i].isDisposed()) |
| disposeViewTab(viewTab, tabs[i]); |
| } |
| |
| tabFolder.dispose(); |
| } |
| |
| // set to null so that clean up is only done once |
| tabFolderHashtable = null; |
| } |
| } catch (Exception e) { |
| |
| Status status = new Status(IStatus.ERROR, |
| DebugUIPlugin.getUniqueIdentifier(), |
| 0, "Exception occurred when the Memory View is disposed", e); //$NON-NLS-1$ |
| DebugUIPlugin.log(status); |
| } |
| |
| super.dispose(); |
| } |
| |
| /** |
| * |
| */ |
| private void removeListeners() { |
| // remove listeners |
| MemoryBlockManager.getMemoryBlockManager().removeListener(this); |
| DebugUIPlugin.getDefault().getWorkbench().getActiveWorkbenchWindow().getSelectionService().removeSelectionListener(IDebugUIConstants.ID_DEBUG_VIEW,this); |
| // DebugUIPlugin.getDefault().getWorkbench().getActiveWorkbenchWindow().getSelectionService().removeSelectionListener(IMemoryViewConstants.MEMORY_RENDERING_VIEW_ID, this); |
| DebugUIPlugin.getDefault().getWorkbench().getActiveWorkbenchWindow().getSelectionService().removeSelectionListener(this); |
| |
| getSite().getPage().removePartListener(fListener); |
| fListener = null; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.part.PageBookView#createDefaultPage(org.eclipse.ui.part.PageBook) |
| */ |
| protected IPage createDefaultPage(PageBook book) { |
| MemoryView.ViewerPage page = new MemoryView.ViewerPage(); |
| page.createControl(book); |
| initPage(page); |
| return page; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.part.PageBookView#doCreatePage(org.eclipse.ui.IWorkbenchPart) |
| */ |
| protected PageRec doCreatePage(IWorkbenchPart part) { |
| |
| return null; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.part.PageBookView#doDestroyPage(org.eclipse.ui.IWorkbenchPart, org.eclipse.ui.part.PageBookView.PageRec) |
| */ |
| protected void doDestroyPage(IWorkbenchPart part, PageRec pageRecord) { |
| |
| |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.part.PageBookView#getBootstrapPart() |
| */ |
| protected IWorkbenchPart getBootstrapPart() { |
| |
| return null; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.part.PageBookView#isImportant(org.eclipse.ui.IWorkbenchPart) |
| */ |
| protected boolean isImportant(IWorkbenchPart part) { |
| |
| return false; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.debug.ui.IDebugView#getViewer() |
| */ |
| public Viewer getViewer() { |
| |
| return null; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.debug.ui.IDebugView#getPresentation(java.lang.String) |
| */ |
| public IDebugModelPresentation getPresentation(String id) { |
| |
| return null; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.debug.ui.IDebugView#setAction(java.lang.String, org.eclipse.jface.action.IAction) |
| */ |
| public void setAction(String actionID, IAction action) { |
| |
| |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.debug.ui.IDebugView#add(org.eclipse.ui.texteditor.IUpdate) |
| */ |
| public void add(IUpdate updatable) { |
| |
| |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.debug.ui.IDebugView#remove(org.eclipse.ui.texteditor.IUpdate) |
| */ |
| public void remove(IUpdate updatable) { |
| |
| |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.debug.ui.IDebugView#getAction(java.lang.String) |
| */ |
| public IAction getAction(String actionID) { |
| |
| return null; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.debug.ui.IDebugView#getContextMenuManager() |
| */ |
| public IMenuManager getContextMenuManager() { |
| return null; |
| } |
| |
| public IMemoryViewTab getTopMemoryTab() { |
| |
| if (stackLayout.topControl instanceof TabFolder) |
| { |
| TabFolder folder = (TabFolder)stackLayout.topControl; |
| int index = folder.getSelectionIndex(); |
| if (index >= 0) { |
| TabItem tab = folder.getItem(index); |
| return (IMemoryViewTab)tab.getData(); |
| } |
| } |
| return null; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.ISelectionListener#selectionChanged(org.eclipse.ui.IWorkbenchPart, org.eclipse.jface.viewers.ISelection) |
| */ |
| public void selectionChanged(IWorkbenchPart part, ISelection selection) { |
| |
| try { |
| |
| if (part == this) |
| return; |
| |
| if (!(selection instanceof IStructuredSelection)) |
| return; |
| |
| // back up current view tab |
| IMemoryViewTab lastViewTab = getTopMemoryTab(); |
| |
| //only single selection of IDebugElement is allowed for this action |
| if (selection == null || selection.isEmpty() || ((IStructuredSelection)selection).size() > 1) |
| { |
| // do not do anything if there is no selection or if there is more than one selection |
| // In the case when a debug adpater fires a debug event incorrectly, Launch View sets |
| // selection to nothing. If the view tab is disabled, it erases all the "delta" information |
| // in the content. This may not be desirable as it will cause memory to show up as |
| // unchanged when it's actually changed. Do not disable the view tab until there is a |
| // valid selection. |
| return; |
| } |
| |
| Object elem = ((IStructuredSelection)selection).getFirstElement(); |
| |
| if (elem instanceof IMemoryRendering){ |
| handleMemoryBlockSelection(lastViewTab, ((IMemoryRendering)elem).getBlock()); |
| } |
| else if (elem instanceof IMemoryBlock) |
| { |
| handleMemoryBlockSelection(lastViewTab, (IMemoryBlock)elem); |
| } |
| else if (elem instanceof IDebugElement) |
| { |
| handleDebugElementSelection(lastViewTab, (IDebugElement)elem); |
| } |
| else |
| { |
| if (part.getSite().getId().equals(IDebugUIConstants.ID_DEBUG_VIEW)) |
| { |
| if (lastViewTab != null) |
| lastViewTab.setEnabled(false); |
| emptyFolder(); |
| } |
| key = null; |
| return; |
| } |
| } |
| catch(SWTException se) |
| { |
| Status status = new Status(IStatus.ERROR, |
| DebugUIPlugin.getUniqueIdentifier(), |
| 0, "SWT Exception occurred in Memory View selection changed", se); //$NON-NLS-1$ |
| DebugUIPlugin.log(status); |
| } |
| } |
| |
| private void handleMemoryBlockSelection(final IMemoryViewTab lastViewTab, final IMemoryBlock memoryBlock) |
| { |
| // check top view tab, if already showing the memory block, do |
| // nothing |
| if (getTopMemoryTab() != null) { |
| if (getTopMemoryTab().getMemoryBlock() == memoryBlock) { |
| return; |
| } |
| // otherwise, find the memory block to display |
| TabFolder folder = (TabFolder) stackLayout.topControl; |
| TabItem[] items = folder.getItems(); |
| |
| for (int i = 0; i < items.length; i++) { |
| IMemoryViewTab viewTab = |
| (IMemoryViewTab) items[i].getData(); |
| if (viewTab.getMemoryBlock() == memoryBlock) { |
| boolean isEnabled = lastViewTab.isEnabled(); |
| |
| // switch to that memory block |
| lastViewTab.setEnabled(false); |
| folder.setSelection(i); |
| fSelectionProvider.setSelection( |
| new StructuredSelection(memoryBlock)); |
| getTopMemoryTab().setEnabled(isEnabled); |
| break; |
| } |
| } |
| } else { |
| // do nothing since there is nothing else to display |
| } |
| } |
| |
| private void handleDebugElementSelection(IMemoryViewTab lastViewTab, IDebugElement elem) |
| { |
| // find the folder associated with the given IMemoryBlockRetrieval |
| IMemoryBlockRetrieval retrieve = (IMemoryBlockRetrieval)elem.getAdapter(IMemoryBlockRetrieval.class); |
| IDebugTarget debugTarget = elem.getDebugTarget(); |
| |
| // if IMemoryBlockRetrieval is null, use debugtarget |
| if (retrieve == null) |
| retrieve = debugTarget; |
| |
| key = retrieve; |
| |
| if (debugTarget == null ||debugTarget.isTerminated() || debugTarget.isDisconnected()) { |
| emptyFolder(); |
| |
| if (tabFolderHashtable != null) |
| { |
| if (tabFolderHashtable.containsKey(key)) |
| { |
| TabFolder deleteFolder = (TabFolder)tabFolderHashtable.get(key); |
| |
| // dispose folder if not already disposed |
| if (!deleteFolder.isDisposed()) |
| deleteFolder.dispose(); |
| |
| tabFolderHashtable.remove(key); |
| } |
| } |
| |
| key = null; |
| return; |
| } |
| |
| // should never get here... added code for safety |
| if (tabFolderHashtable == null) |
| { |
| emptyFolder(); |
| key = null; |
| return; |
| } |
| |
| //if we've got a tabfolder to go with the IMemoryBlockRetrieval, display it |
| if (tabFolderHashtable.containsKey(retrieve)) { |
| if (stackLayout.topControl != (TabFolder)tabFolderHashtable.get(retrieve)) { |
| setTabFolder((TabFolder)tabFolderHashtable.get(retrieve)); |
| parent.layout(); |
| } |
| } else { //otherwise, add a new one |
| tabFolderHashtable.put(retrieve, new TabFolder(parent, SWT.NULL)); |
| setTabFolder((TabFolder)tabFolderHashtable.get(retrieve)); |
| parent.layout(); |
| } |
| |
| // restore view tabs based on memory block retrieval |
| IMemoryBlock[] memoryBlocks = MemoryBlockManager.getMemoryBlockManager().getMemoryBlocks(retrieve); |
| TabFolder toDisplay = (TabFolder)stackLayout.topControl; |
| |
| if (toDisplay.getItemCount() == 0) |
| { |
| restoreViewTabs(memoryBlocks); |
| } |
| |
| // disable last view tab as it becomes hidden |
| IMemoryViewTab newViewTab = getTopMemoryTab(); |
| |
| if (lastViewTab != null && lastViewTab != newViewTab) |
| { |
| lastViewTab.setEnabled(false); |
| } |
| |
| if (newViewTab != null) |
| { |
| // if new view tab is not already enabled, enable it |
| if (!newViewTab.isEnabled()) |
| { |
| // if the view tab is visible, enable it |
| if (fVisible) |
| { |
| newViewTab.setEnabled(true); |
| fSelectionProvider.setSelection(new StructuredSelection(newViewTab.getMemoryBlock())); |
| } |
| } |
| } |
| |
| //set toolbar actions enabled/disabled |
| updateToolBarActionsEnablement(); |
| } |
| |
| protected void emptyFolder() |
| { |
| setTabFolder(emptyTabFolder); |
| if (!parent.isDisposed()) { |
| parent.layout(); |
| } |
| |
| // this folder will always remain empty |
| // remove button should always be disabled |
| removeMemoryBlockAction.setEnabled(false); |
| resetMemoryBlockAction.setEnabled(false); |
| copyViewToClipboardAction.setEnabled(false); |
| printViewTabAction.setEnabled(false); |
| |
| fSelectionProvider.setSelection(new StructuredSelection(new Object[0])); |
| } |
| |
| private void createFolder(ISelection selection) |
| { |
| if (!(selection instanceof IStructuredSelection)) |
| return; |
| |
| //only single selection of PICLDebugElements is allowed for this action |
| if (selection == null || selection.isEmpty() || ((IStructuredSelection)selection).size() > 1) |
| { |
| return; |
| } |
| |
| Object elem = ((IStructuredSelection)selection).getFirstElement(); |
| |
| // if not debug element |
| if (!(elem instanceof IDebugElement)) |
| return; |
| |
| IDebugTarget debugTarget = ((IDebugElement)elem).getDebugTarget(); |
| IMemoryBlockRetrieval memRetrieval =(IMemoryBlockRetrieval) ((IDebugElement)elem).getAdapter(IMemoryBlockRetrieval.class); |
| |
| if (memRetrieval == null) |
| { |
| // if debug element returns null from getAdapter, assume its debug target is going to retrieve memory blocks |
| memRetrieval = debugTarget; |
| } |
| |
| //if we've got a tabfolder to go with the IMemoryBlockRetrieval, display it |
| if (tabFolderHashtable.containsKey(memRetrieval)) { |
| if (stackLayout.topControl != (TabFolder)tabFolderHashtable.get(memRetrieval)) { |
| setTabFolder((TabFolder)tabFolderHashtable.get(memRetrieval)); |
| parent.layout(); |
| } |
| } else { //otherwise, add a new one |
| tabFolderHashtable.put(memRetrieval, new TabFolder(parent, SWT.NULL)); |
| setTabFolder((TabFolder)tabFolderHashtable.get(memRetrieval)); |
| parent.layout(); |
| } |
| |
| //set toolbar actions enabled/disabled |
| updateToolBarActionsEnablement(); |
| } |
| |
| // enable/disable toolbar action |
| protected void updateToolBarActionsEnablement() |
| { |
| TabFolder folder = (TabFolder)stackLayout.topControl; |
| int index = folder.getSelectionIndex(); |
| if (index >= 0) { |
| removeMemoryBlockAction.setEnabled(true); |
| resetMemoryBlockAction.setEnabled(true); |
| copyViewToClipboardAction.setEnabled(true); |
| printViewTabAction.setEnabled(true); |
| |
| } else { |
| removeMemoryBlockAction.setEnabled(false); |
| resetMemoryBlockAction.setEnabled(false); |
| copyViewToClipboardAction.setEnabled(false); |
| printViewTabAction.setEnabled(false); |
| } |
| } |
| |
| private void restoreViewTabs(IMemoryBlock[] memoryBlocks) |
| { |
| for (int i=0; i<memoryBlocks.length; i++) |
| { |
| // enable to get latest data |
| if (memoryBlocks[i] instanceof IExtendedMemoryBlock) |
| { |
| ((IExtendedMemoryBlock)memoryBlocks[i]).enable(); |
| } |
| MemoryBlockAdded(memoryBlocks[i]); |
| |
| // disable after done |
| if (memoryBlocks[i] instanceof IExtendedMemoryBlock) |
| { |
| ((IExtendedMemoryBlock)memoryBlocks[i]).disable(); |
| } |
| } |
| |
| // enable memory block |
| IMemoryViewTab viewTab = getTopMemoryTab(); |
| if (viewTab != null) |
| { |
| if (viewTab.getMemoryBlock() instanceof IExtendedMemoryBlock) |
| { |
| ((IExtendedMemoryBlock)viewTab.getMemoryBlock()).enable(); |
| } |
| } |
| } |
| |
| private void setTabFolder(TabFolder folder) |
| { |
| if (stackLayout.topControl != null) |
| { |
| TabFolder old = (TabFolder)stackLayout.topControl; |
| |
| if (!old.isDisposed()) |
| { |
| old.removeSelectionListener(fSelectionProvider); |
| old.removeSelectionListener(fViewTabEnablementManager); |
| } |
| } |
| |
| stackLayout.topControl = folder; |
| |
| if (folder.getItemCount() > 0) |
| { |
| TabItem[] selectedItem = folder.getSelection(); |
| |
| if (selectedItem.length > 0) |
| { |
| IMemoryViewTab viewTab = (IMemoryViewTab)selectedItem[0].getData(); |
| fSelectionProvider.setSelection(new StructuredSelection(viewTab.getMemoryBlock())); |
| } |
| } |
| else |
| { |
| fSelectionProvider.setSelection(new StructuredSelection()); |
| } |
| |
| folder.addSelectionListener(fSelectionProvider); |
| folder.addSelectionListener(fViewTabEnablementManager); |
| } |
| |
| private void disposeViewTab(IMemoryViewTab viewTab, TabItem tabItem) |
| { |
| if (viewTab == null) |
| return; |
| |
| // get menu manager and clean up |
| IMenuManager menuMgr = (IMenuManager)fMenuMgr.get(viewTab); |
| |
| if (menuMgr != null) |
| { |
| menuMgr.dispose(); |
| } |
| |
| viewTab.dispose(); |
| |
| if (tabItem == null) |
| return; |
| |
| // dispose the tab item in case the view tab has not |
| // cleaned up the tab item |
| if (!tabItem.isDisposed()) |
| { |
| tabItem.dispose(); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.debug.ui.IMemoryView#getAllViewTabs() |
| */ |
| public IMemoryViewTab[] getAllViewTabs() { |
| |
| // otherwise, find the view tab to display |
| TabFolder folder = (TabFolder) stackLayout.topControl; |
| TabItem[] items = folder.getItems(); |
| |
| IMemoryViewTab[] viewTabs = new IMemoryViewTab[folder.getItemCount()]; |
| |
| for(int i=0; i<items.length; i++){ |
| viewTabs[i] = (IMemoryViewTab)items[i].getData(); |
| } |
| |
| return viewTabs; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.debug.ui.IMemoryView#moveToTop(org.eclipse.debug.ui.IMemoryViewTab) |
| */ |
| public void moveToTop(IMemoryViewTab viewTab) { |
| |
| IMemoryViewTab lastViewTab = getTopMemoryTab(); |
| |
| if (viewTab == lastViewTab) |
| return; |
| |
| // otherwise, find the view tab to display |
| TabFolder folder = (TabFolder) stackLayout.topControl; |
| TabItem[] items = folder.getItems(); |
| |
| for (int i = 0; i < items.length; i++) { |
| IMemoryViewTab tab = |
| (IMemoryViewTab) items[i].getData(); |
| if (viewTab == tab) { |
| |
| boolean isEnabled = lastViewTab.isEnabled(); |
| |
| // switch to that viewTab |
| lastViewTab.setEnabled(false); |
| folder.setSelection(i); |
| fSelectionProvider.setSelection( |
| new StructuredSelection(getTopMemoryTab().getMemoryBlock())); |
| getTopMemoryTab().setEnabled(isEnabled); |
| break; |
| } |
| } |
| } |
| |
| } |
