| /******************************************************************************* |
| * Copyright (c) 2006, 2016 Wind River Systems Inc. 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: |
| * Ted R Williams (Wind River Systems, Inc.) - initial implementation |
| * Randy Rohrbach (Wind River Systems, Inc.) - Copied and modified to create the floating point plugin |
| *******************************************************************************/ |
| |
| package org.eclipse.cdt.debug.ui.memory.floatingpoint; |
| |
| import java.lang.reflect.Method; |
| import java.math.BigInteger; |
| |
| import org.eclipse.cdt.debug.core.model.provisional.IMemoryRenderingViewportProvider; |
| import org.eclipse.cdt.debug.ui.memory.floatingpoint.FPutilities.Endian; |
| import org.eclipse.cdt.debug.ui.memory.floatingpoint.FPutilities.FPDataType; |
| import org.eclipse.core.commands.AbstractHandler; |
| import org.eclipse.core.commands.Command; |
| import org.eclipse.core.commands.ExecutionEvent; |
| import org.eclipse.core.commands.ExecutionException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.debug.core.DebugException; |
| import org.eclipse.debug.core.DebugPlugin; |
| import org.eclipse.debug.core.model.IMemoryBlock; |
| import org.eclipse.debug.core.model.IMemoryBlockExtension; |
| import org.eclipse.debug.core.model.MemoryByte; |
| 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.IMemoryBlockConnection; |
| import org.eclipse.debug.internal.ui.memory.provisional.MemoryViewPresentationContext; |
| import org.eclipse.debug.internal.ui.viewers.model.provisional.IModelChangedListener; |
| import org.eclipse.debug.internal.ui.viewers.model.provisional.IModelDelta; |
| import org.eclipse.debug.internal.ui.viewers.model.provisional.IModelProxy; |
| import org.eclipse.debug.internal.ui.viewers.model.provisional.IModelProxyFactory; |
| import org.eclipse.debug.ui.IDebugUIConstants; |
| import org.eclipse.debug.ui.memory.AbstractMemoryRendering; |
| import org.eclipse.debug.ui.memory.AbstractTableRendering; |
| import org.eclipse.debug.ui.memory.IMemoryRendering; |
| import org.eclipse.debug.ui.memory.IMemoryRenderingContainer; |
| import org.eclipse.debug.ui.memory.IMemoryRenderingSite; |
| import org.eclipse.debug.ui.memory.IRepositionableMemoryRendering; |
| import org.eclipse.debug.ui.memory.IResettableMemoryRendering; |
| 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.IInputValidator; |
| import org.eclipse.jface.dialogs.InputDialog; |
| import org.eclipse.jface.preference.IPreferenceStore; |
| import org.eclipse.jface.preference.PreferenceConverter; |
| import org.eclipse.jface.resource.ImageDescriptor; |
| import org.eclipse.jface.resource.JFaceResources; |
| import org.eclipse.jface.util.IPropertyChangeListener; |
| import org.eclipse.jface.util.PropertyChangeEvent; |
| import org.eclipse.jface.viewers.IBasicPropertyConstants; |
| import org.eclipse.jface.window.Window; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.dnd.Clipboard; |
| import org.eclipse.swt.dnd.DND; |
| import org.eclipse.swt.dnd.TextTransfer; |
| import org.eclipse.swt.dnd.Transfer; |
| import org.eclipse.swt.graphics.Color; |
| import org.eclipse.swt.graphics.RGB; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.ui.IWorkbench; |
| import org.eclipse.ui.IWorkbenchActionConstants; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.commands.ICommandService; |
| import org.eclipse.ui.model.IWorkbenchAdapter; |
| import org.eclipse.ui.progress.UIJob; |
| |
| |
| /** |
| * A memory rendering displaying memory in a floating point memory view look and |
| * feel, optimized for minimal IO traffic. |
| * <p> |
| * requirements of the debug model implementation: - An IMemoryBlockExtension is |
| * required. |
| * |
| * Since it is not possible to size the memory block to match the size of the |
| * viewport, memory block change notification is not useful. Such events are |
| * ignored by this rendering. |
| */ |
| |
| @SuppressWarnings({ "restriction" }) |
| public class FPRendering extends AbstractMemoryRendering |
| implements IRepositionableMemoryRendering, IResettableMemoryRendering, IMemoryRenderingViewportProvider, IModelChangedListener |
| { |
| protected Rendering fRendering; |
| protected Action actionDisplayBigEndian; |
| protected Action actionDisplayLittleEndian; |
| protected Action actionDisplayFloatingPoint; |
| |
| private IWorkbenchAdapter fWorkbenchAdapter; |
| private IMemoryBlockConnection fConnection; |
| |
| private final static int MAX_MENU_COLUMN_COUNT = 8; |
| |
| Action actionFloatingPoint32 = null; |
| Action actionFloatingPoint64 = null; |
| |
| Action actionDisplay4Digits = null; |
| Action actionDisplay8Digits = null; |
| Action actionDisplay16Digits = null; |
| |
| // Constructor |
| |
| public FPRendering(String id) |
| { |
| super(id); |
| |
| JFaceResources.getFontRegistry().addListener(new IPropertyChangeListener() |
| { |
| @Override |
| public void propertyChange(PropertyChangeEvent event) |
| { |
| if (event.getProperty().equals(IInternalDebugUIConstants.FONT_NAME)) |
| { |
| FPRendering.this.fRendering.handleFontPreferenceChange(JFaceResources.getFont(IInternalDebugUIConstants.FONT_NAME)); |
| } |
| } |
| }); |
| |
| this.addPropertyChangeListener(new IPropertyChangeListener() |
| { |
| @Override |
| public void propertyChange(PropertyChangeEvent event) |
| { |
| IMemoryRendering sourceRendering = (IMemoryRendering) event.getSource(); |
| if (!sourceRendering.getMemoryBlock().equals(getMemoryBlock())) |
| return; |
| |
| Object address = event.getNewValue(); |
| |
| if (event.getProperty().equals(AbstractTableRendering.PROPERTY_SELECTED_ADDRESS) && address instanceof BigInteger) |
| { |
| FPRendering.this.fRendering.ensureVisible((BigInteger) address); |
| } |
| } |
| }); |
| |
| FPRenderingPlugin.getDefault().getPreferenceStore().addPropertyChangeListener(new IPropertyChangeListener() |
| { |
| @Override |
| public void propertyChange(PropertyChangeEvent event) |
| { |
| disposeColors(); |
| allocateColors(); |
| applyPreferences(); |
| } |
| }); |
| |
| DebugUIPlugin.getDefault().getPreferenceStore().addPropertyChangeListener(new IPropertyChangeListener() |
| { |
| @Override |
| public void propertyChange(PropertyChangeEvent event) |
| { |
| if (event.getProperty().equals(IDebugUIConstants.PREF_PADDED_STR)) |
| { |
| if (FPRendering.this.fRendering != null) |
| { |
| setRenderingPadding((String) event.getNewValue()); |
| FPRendering.this.fRendering.redrawPanes(); |
| } |
| } |
| } |
| }); |
| } |
| |
| static int paddingCounter = 0; |
| |
| void setRenderingPadding(String padding) |
| { |
| if (padding == null || padding.length() == 0) padding = " "; //$NON-NLS-1$ |
| FPRendering.this.fRendering.setPaddingString(padding); |
| } |
| |
| protected void logError(String message, Exception e) |
| { |
| Status status = new Status(IStatus.ERROR, getRenderingId(), DebugException.INTERNAL_ERROR, message, e); |
| FPRenderingPlugin.getDefault().getLog().log(status); |
| } |
| |
| BigInteger fBigBaseAddress; // Memory base address |
| private BigInteger fStartAddress; // Starting address |
| private BigInteger fEndAddress; // Ending address |
| private int fAddressableSize; // Memory block size |
| private int fAddressSize; // Size of address |
| |
| /* |
| * @see org.eclipse.debug.internal.ui.viewers.model.provisional.IModelChangedListener#modelChanged(org.eclipse.debug.internal.ui.viewers.model.provisional.IModelDelta, org.eclipse.debug.internal.ui.viewers.model.provisional.IModelProxy) |
| */ |
| @Override |
| public void modelChanged(IModelDelta delta, IModelProxy proxy) |
| { |
| /* |
| * The event model in the traditional renderer is written to expect a suspend first |
| * which will cause it to save its current data set away in an archive. Then when |
| * the state change comes through it will compare and refresh showing a difference. |
| */ |
| int flags = delta.getFlags(); |
| if ( ( flags & IModelDelta.STATE ) != 0 ) { |
| fRendering.handleSuspend(false); |
| } |
| |
| fRendering.handleChange(); |
| } |
| |
| /* |
| * We use the model proxy which is supplied by the TCF implementation to provide the knowledge of memory |
| * change notifications. The older backends ( the reference model, Wind River Systems Inc. ) are written |
| * to generate the Debug Model events. TCF follows the "ModelDelta/IModelProxy" implementation that the |
| * platform renderers use. So this implementation acts as a shim. If the older Debug Events come in then |
| * fine. If the newer model deltas come in fine also. |
| */ |
| IModelProxy fModel; |
| |
| @Override |
| public void dispose() |
| { |
| /* |
| * We use the UI dispatch thread to protect the proxy information. Even though I believe the |
| * dispose routine is always called in the UI dispatch thread. I am going to make sure. |
| */ |
| Display.getDefault().asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| if ( fModel != null ) { |
| fModel.removeModelChangedListener(FPRendering.this); |
| fModel.dispose(); |
| } |
| }}); |
| |
| if(this.fRendering != null) |
| this.fRendering.dispose(); |
| disposeColors(); |
| super.dispose(); |
| } |
| |
| @Override |
| public void init(final IMemoryRenderingContainer container, final IMemoryBlock block) |
| { |
| super.init(container, block); |
| |
| /* |
| * Working with the model proxy must be done on the UI dispatch thread. |
| */ |
| final IModelProxyFactory factory = (IModelProxyFactory) DebugPlugin.getAdapter(block, IModelProxyFactory.class ); |
| if ( factory != null ) { |
| Display.getDefault().asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| |
| /* |
| * The asynchronous model assumes we have an asynchronous viewer that has an IPresentationContext |
| * to represent it. The Platform memory subsystem provides a way to create one without a viewewr. |
| */ |
| IMemoryRenderingSite site = container.getMemoryRenderingSite(); |
| MemoryViewPresentationContext context = new MemoryViewPresentationContext(site, container, FPRendering.this); |
| |
| /* |
| * Get a new proxy and perform the initialization sequence so we are known the |
| * the model provider. |
| */ |
| fModel = factory.createModelProxy(block, context); |
| if (fModel != null) { |
| fModel.installed(null); |
| fModel.addModelChangedListener(FPRendering.this); |
| } |
| |
| }}); |
| } |
| |
| try |
| { |
| fBigBaseAddress = ((IMemoryBlockExtension) block).getBigBaseAddress(); |
| } |
| catch (DebugException de) |
| { |
| logError(FPRenderingMessages.getString("FPRendering.FAILURE_RETRIEVE_BASE_ADDRESS"), de); //$NON-NLS-1$ |
| } |
| |
| try |
| { |
| fAddressableSize = ((IMemoryBlockExtension) block).getAddressableSize(); |
| } |
| catch (DebugException de) |
| { |
| fAddressableSize = 1; |
| } |
| |
| try |
| { |
| fStartAddress = ((IMemoryBlockExtension) block).getMemoryBlockStartAddress(); |
| } |
| catch (DebugException de) |
| { |
| fStartAddress = null; |
| logError(FPRenderingMessages.getString("FPRendering.FAILURE_RETRIEVE_START_ADDRESS"), de); //$NON-NLS-1$ |
| } |
| |
| try |
| { |
| fAddressSize = ((IMemoryBlockExtension) block).getAddressSize(); |
| } |
| catch (DebugException e) |
| { |
| fAddressSize = 0; |
| } |
| |
| BigInteger endAddress; |
| try |
| { |
| endAddress = ((IMemoryBlockExtension) block).getMemoryBlockEndAddress(); |
| if (endAddress != null) |
| fEndAddress = endAddress; |
| } |
| catch (DebugException e) |
| { |
| fEndAddress = null; |
| } |
| |
| if (fEndAddress == null) |
| { |
| int addressSize; |
| try |
| { |
| addressSize = ((IMemoryBlockExtension) block).getAddressSize(); |
| } |
| catch (DebugException e) |
| { |
| addressSize = 4; |
| } |
| |
| endAddress = BigInteger.valueOf(2); |
| endAddress = endAddress.pow(addressSize * 8); |
| endAddress = endAddress.subtract(BigInteger.ONE); |
| fEndAddress = endAddress; |
| } |
| |
| // default to MAX_VALUE if we have trouble getting the end address |
| if (fEndAddress == null) |
| fEndAddress = BigInteger.valueOf(Integer.MAX_VALUE); |
| } |
| |
| public BigInteger getBigBaseAddress() |
| { |
| return fBigBaseAddress; |
| } |
| |
| public BigInteger getMemoryBlockStartAddress() |
| { |
| return fStartAddress; |
| } |
| |
| public BigInteger getMemoryBlockEndAddress() |
| { |
| return fEndAddress; |
| } |
| |
| public int getAddressableSize() |
| { |
| return fAddressableSize; |
| } |
| |
| public int getAddressSize() |
| { |
| return fAddressSize; |
| } |
| |
| @Override |
| public Control createControl(Composite parent) |
| { |
| allocateColors(); |
| |
| this.fRendering = new Rendering(parent, this); |
| |
| applyPreferences(); |
| |
| createMenus(); |
| |
| if (actionFloatingPoint32.isChecked()) |
| actionDisplay16Digits.setEnabled(false); |
| else |
| actionDisplay16Digits.setEnabled(true); |
| |
| return this.fRendering; |
| } |
| |
| /* |
| * We are duplicating the reference to the GoToAddress command because it is private in the platform. |
| * This is not going to change at this point so just live with it. |
| */ |
| private static final String ID_GO_TO_ADDRESS_COMMAND = "org.eclipse.debug.ui.command.gotoaddress"; //$NON-NLS-1$ |
| private AbstractHandler fGoToAddressHandler; |
| |
| @Override |
| public void activated() |
| { |
| super.activated(); |
| |
| IWorkbench workbench = PlatformUI.getWorkbench(); |
| ICommandService commandSupport = workbench.getAdapter(ICommandService.class); |
| |
| if (commandSupport != null) |
| { |
| Command gotoCommand = commandSupport.getCommand(ID_GO_TO_ADDRESS_COMMAND); |
| |
| if (fGoToAddressHandler == null) |
| { |
| fGoToAddressHandler = new AbstractHandler() |
| { |
| @Override |
| public Object execute(ExecutionEvent event) throws ExecutionException |
| { |
| return null; |
| } |
| }; |
| } |
| gotoCommand.setHandler(fGoToAddressHandler); |
| } |
| } |
| |
| @Override |
| public void deactivated() |
| { |
| IWorkbench workbench = PlatformUI.getWorkbench(); |
| ICommandService commandSupport = workbench.getAdapter(ICommandService.class); |
| |
| if (commandSupport != null) |
| { |
| // remove handler |
| Command command = commandSupport.getCommand(ID_GO_TO_ADDRESS_COMMAND); |
| command.setHandler(null); |
| } |
| |
| super.deactivated(); |
| } |
| |
| public void setSelection(BigInteger start, BigInteger end) |
| { |
| fRendering.getSelection().setStart(start, start); |
| fRendering.getSelection().setEnd(end, end); |
| } |
| |
| public void gotoAddress(final BigInteger address) |
| { |
| this.fRendering.gotoAddress(address); |
| } |
| |
| public void updateRenderingLabels() |
| { |
| UIJob job = new UIJob("updateLabels") { //$NON-NLS-1$ |
| @SuppressWarnings("synthetic-access") |
| @Override |
| public IStatus runInUIThread(IProgressMonitor monitor) |
| { |
| |
| // Update tab labels |
| String fLabel = getLabel(); |
| firePropertyChangedEvent(new PropertyChangeEvent(FPRendering.this, IBasicPropertyConstants.P_TEXT, null, fLabel)); |
| return Status.OK_STATUS; |
| } |
| }; |
| job.setSystem(true); |
| job.schedule(); |
| } |
| |
| private Color colorBackground; |
| private Color colorChanged; |
| private Color colorsChanged[] = null; |
| private Color colorEdit; |
| private Color colorSelection; |
| private Color colorText; |
| private Color colorTextAlternate; |
| |
| public void allocateColors() |
| { |
| IPreferenceStore store = FPRenderingPlugin.getDefault().getPreferenceStore(); |
| |
| colorBackground = new Color(Display.getDefault(), PreferenceConverter.getColor(store, FPRenderingPreferenceConstants.MEM_COLOR_BACKGROUND)); |
| colorChanged = new Color(Display.getDefault(), PreferenceConverter.getColor(store, FPRenderingPreferenceConstants.MEM_COLOR_CHANGED)); |
| colorEdit = new Color(Display.getDefault(), PreferenceConverter.getColor(store, FPRenderingPreferenceConstants.MEM_COLOR_EDIT)); |
| colorSelection = new Color(Display.getDefault(), PreferenceConverter.getColor(store, FPRenderingPreferenceConstants.MEM_COLOR_SELECTION)); |
| colorText = new Color(Display.getDefault(), PreferenceConverter.getColor(store, FPRenderingPreferenceConstants.MEM_COLOR_TEXT)); |
| |
| // alternate cell color |
| Color textColor = getColorText(); |
| int red = textColor.getRed(); |
| int green = textColor.getGreen(); |
| int blue = textColor.getBlue(); |
| |
| float scale = store.getInt(FPRenderingPreferenceConstants.MEM_LIGHTEN_DARKEN_ALTERNATE_CELLS); |
| |
| red = (int) Math.min(red + ((255 - red) / 10) * scale, 255); |
| green = (int) Math.min(green + ((255 - green) / 10) * scale, 255); |
| blue = (int) Math.min(blue + ((255 - blue) / 10) * scale, 255); |
| |
| colorTextAlternate = new Color(Display.getDefault(), new RGB(red, green, blue)); |
| } |
| |
| public void disposeColors() |
| { |
| if (colorBackground != null) colorBackground.dispose(); |
| colorBackground = null; |
| |
| if (colorChanged != null) colorChanged.dispose(); |
| colorChanged = null; |
| |
| if (colorEdit != null) colorEdit.dispose(); |
| colorEdit = null; |
| |
| if (colorSelection != null) colorSelection.dispose(); |
| colorSelection = null; |
| |
| if (colorText != null) colorText.dispose(); |
| colorText = null; |
| |
| if (colorTextAlternate != null) colorTextAlternate.dispose(); |
| colorTextAlternate = null; |
| |
| disposeChangedColors(); |
| } |
| |
| public void applyPreferences() |
| { |
| if (fRendering != null && !fRendering.isDisposed()) |
| { |
| IPreferenceStore store = FPRenderingPlugin.getDefault().getPreferenceStore(); |
| fRendering.setHistoryDepth(store.getInt(FPRenderingPreferenceConstants.MEM_HISTORY_TRAILS_COUNT)); |
| fRendering.setBackground(getColorBackground()); |
| |
| FPAbstractPane panes[] = fRendering.getRenderingPanes(); |
| for (int index = 0; index < panes.length; index++) |
| panes[index].setBackground(getColorBackground()); |
| |
| setRenderingPadding(FPRenderingPlugin.getDefault().getPreferenceStore().getString(IDebugUIConstants.PREF_PADDED_STR)); |
| |
| fRendering.redrawPanes(); |
| } |
| } |
| |
| public Color getColorBackground() |
| { |
| IPreferenceStore store = FPRenderingPlugin.getDefault().getPreferenceStore(); |
| |
| if (store.getBoolean(FPRenderingPreferenceConstants.MEM_USE_GLOBAL_BACKGROUND)) |
| return Display.getDefault().getSystemColor(SWT.COLOR_LIST_BACKGROUND); |
| |
| return colorBackground; |
| } |
| |
| public Color getColorChanged() |
| { |
| return colorChanged; |
| } |
| |
| private void disposeChangedColors() |
| { |
| if (colorsChanged != null) |
| for (int index = 0; index < colorsChanged.length; index++) |
| colorsChanged[index].dispose(); |
| colorsChanged = null; |
| } |
| |
| public Color[] getColorsChanged() |
| { |
| if (colorsChanged != null && colorsChanged.length != fRendering.getHistoryDepth()) |
| { |
| disposeChangedColors(); |
| } |
| |
| if (colorsChanged == null) |
| { |
| colorsChanged = new Color[fRendering.getHistoryDepth()]; |
| colorsChanged[0] = colorChanged; |
| int shades = fRendering.getHistoryDepth() + 4; |
| int red = (255 - colorChanged.getRed()) / shades; |
| int green = (255 - colorChanged.getGreen()) / shades; |
| int blue = (255 - colorChanged.getBlue()) / shades; |
| for (int index = 1; index < fRendering.getHistoryDepth(); index++) |
| { |
| colorsChanged[index] = new Color(colorChanged.getDevice(), colorChanged.getRed() + ((shades - index) * red), colorChanged.getGreen() |
| + ((shades - index) * green), colorChanged.getBlue() + ((shades - index) * blue)); |
| } |
| } |
| |
| return colorsChanged; |
| } |
| |
| public Color getColorEdit() |
| { |
| return colorEdit; |
| } |
| |
| public Color getColorSelection() |
| { |
| IPreferenceStore store = FPRenderingPlugin.getDefault().getPreferenceStore(); |
| |
| if (store.getBoolean(FPRenderingPreferenceConstants.MEM_USE_GLOBAL_SELECTION)) |
| return Display.getDefault().getSystemColor(SWT.COLOR_LIST_SELECTION); |
| |
| return colorSelection; |
| } |
| |
| public Color getColorText() |
| { |
| IPreferenceStore store = FPRenderingPlugin.getDefault().getPreferenceStore(); |
| |
| if (store.getBoolean(FPRenderingPreferenceConstants.MEM_USE_GLOBAL_TEXT)) |
| return Display.getDefault().getSystemColor(SWT.COLOR_LIST_FOREGROUND); |
| |
| return colorText; |
| } |
| |
| public Color getColorTextAlternate() |
| { |
| return colorTextAlternate; |
| } |
| |
| // Menu creation |
| |
| public void createMenus() |
| { |
| // Add the menu to each of the rendering panes |
| |
| Control[] renderingControls = this.fRendering.getRenderingPanes(); |
| |
| for (int index = 0; index < renderingControls.length; index++) |
| super.createPopupMenu(renderingControls[index]); |
| |
| super.createPopupMenu(this.fRendering); |
| |
| // Copy |
| |
| final Action copyAction = new CopyAction(this.fRendering); |
| |
| // Copy address |
| |
| final Action copyAddressAction = new Action(FPRenderingMessages.getString("FPRendering.COPY_ADDRESS")) //$NON-NLS-1$ |
| { |
| @Override |
| public void run() |
| { |
| Display.getDefault().asyncExec(new Runnable() |
| { |
| @Override |
| public void run() |
| { |
| FPRendering.this.fRendering.copyAddressToClipboard(); |
| } |
| }); |
| } |
| }; |
| |
| // Reset to base address |
| |
| final Action gotoBaseAddressAction = new Action(FPRenderingMessages.getString("FPRendering.RESET_TO_BASE_ADDRESS")) //$NON-NLS-1$ |
| { |
| @Override |
| public void run() |
| { |
| Display.getDefault().asyncExec(new Runnable() |
| { |
| @Override |
| public void run() |
| { |
| FPRendering.this.fRendering.gotoAddress(FPRendering.this.fRendering.fBaseAddress); |
| } |
| }); |
| } |
| }; |
| |
| // Refresh |
| |
| final Action refreshAction = new Action(FPRenderingMessages.getString("FPRendering.REFRESH")) //$NON-NLS-1$ |
| { |
| @Override |
| public void run() |
| { |
| Display.getDefault().asyncExec(new Runnable() |
| { |
| @Override |
| public void run() |
| { |
| // For compatibility with DSF update modes (hopefully this will either be replaced |
| // by an enhanced platform interface or the caching will move out of the data layer) |
| |
| try |
| { |
| Method m = fRendering.getMemoryBlock().getClass().getMethod("clearCache", new Class[0]); //$NON-NLS-1$ |
| if (m != null) |
| m.invoke(fRendering.getMemoryBlock(), new Object[0]); |
| } |
| catch (Exception e) |
| { |
| } |
| |
| FPRendering.this.fRendering.refresh(); |
| } |
| }); |
| } |
| }; |
| |
| // Little Endian |
| |
| actionDisplayLittleEndian = new Action(FPRenderingMessages.getString("FPRendering.ENDIAN_LITTLE"), IAction.AS_RADIO_BUTTON) //$NON-NLS-1$ |
| { |
| @Override |
| public void run() |
| { |
| fRendering.setDisplayLittleEndian(true); |
| setRMCvalue(IFPRConstants.ENDIAN_KEY, Endian.LITTLE.getValue()); |
| } |
| }; |
| |
| // Big Endian |
| |
| actionDisplayBigEndian = new Action(FPRenderingMessages.getString("FPRendering.ENDIAN_BIG"), IAction.AS_RADIO_BUTTON) //$NON-NLS-1$ |
| { |
| @Override |
| public void run() |
| { |
| fRendering.setDisplayLittleEndian(false); |
| setRMCvalue(IFPRConstants.ENDIAN_KEY, Endian.BIG.getValue()); |
| } |
| }; |
| |
| // Endian settings |
| |
| int endian = getRMCvalue(IFPRConstants.ENDIAN_KEY); |
| |
| endian = endian != -1 ? endian : (fRendering.isDisplayLittleEndian() ? Endian.LITTLE.getValue() : Endian.BIG.getValue()); |
| boolean le = (endian == Endian.LITTLE.getValue()); |
| |
| fRendering.setDisplayLittleEndian(le); |
| actionDisplayLittleEndian.setChecked(le); |
| actionDisplayBigEndian.setChecked(!le); |
| |
| // Float |
| |
| boolean dtFloat = getRMCvalue(IFPRConstants.DATATYPE_KEY) == FPDataType.FLOAT.getValue(); |
| this.fRendering.setFPDataType(dtFloat ? FPDataType.FLOAT : FPDataType.DOUBLE); |
| |
| actionFloatingPoint32 = new Action(FPRenderingMessages.getString("FPRendering.FLOATING_POINT_32"), IAction.AS_RADIO_BUTTON) //$NON-NLS-1$ |
| { |
| @Override |
| public void run() |
| { |
| fRendering.setDisplayedPrecision(getRMCvalue(IFPRConstants.FLOAT_DISP_KEY)); |
| fRendering.setFPDataType(FPDataType.FLOAT); |
| setRMCvalue(IFPRConstants.DATATYPE_KEY, FPDataType.FLOAT.getValue()); |
| setSelections(); |
| } |
| }; |
| |
| // Double |
| |
| actionFloatingPoint64 = new Action(FPRenderingMessages.getString("FPRendering.FLOATING_POINT_64"), IAction.AS_RADIO_BUTTON) //$NON-NLS-1$ |
| { |
| @Override |
| public void run() |
| { |
| fRendering.setDisplayedPrecision(getRMCvalue(IFPRConstants.DOUBLE_DISP_KEY)); |
| fRendering.setFPDataType(FPDataType.DOUBLE); |
| setRMCvalue(IFPRConstants.DATATYPE_KEY, FPDataType.DOUBLE.getValue()); |
| setSelections(); |
| } |
| }; |
| |
| // Displayed precision: 4 digits |
| |
| int savedPrecision = getDisplayedPrecision(); |
| |
| actionDisplay4Digits = new Action(FPRenderingMessages.getString("FPRendering.DISPLAYED_PRECISION_4"), IAction.AS_RADIO_BUTTON) //$NON-NLS-1$ |
| { |
| @Override |
| public void run() |
| { |
| FPRendering.this.fRendering.setDisplayedPrecision(4); |
| setDisplayedPrecision(4); |
| } |
| }; |
| |
| if (savedPrecision == 4) |
| { |
| FPRendering.this.fRendering.setDisplayedPrecision(4); |
| actionDisplay4Digits.setChecked(savedPrecision == 4); |
| } |
| |
| // Displayed precision: 8 digits |
| |
| actionDisplay8Digits = new Action(FPRenderingMessages.getString("FPRendering.DISPLAYED_PRECISION_8"), IAction.AS_RADIO_BUTTON) //$NON-NLS-1$ |
| { |
| @Override |
| public void run() |
| { |
| FPRendering.this.fRendering.setDisplayedPrecision(8); |
| setDisplayedPrecision(8); |
| } |
| }; |
| |
| if (savedPrecision == 8) |
| { |
| FPRendering.this.fRendering.setDisplayedPrecision(8); |
| actionDisplay8Digits.setChecked(savedPrecision == 8); |
| } |
| |
| // Displayed precision: 16 digits (doubles only) |
| |
| actionDisplay16Digits = new Action(FPRenderingMessages.getString("FPRendering.DISPLAYED_PRECISION_16"), IAction.AS_RADIO_BUTTON) //$NON-NLS-1$ |
| { |
| @Override |
| public void run() |
| { |
| FPRendering.this.fRendering.setDisplayedPrecision(16); |
| setDisplayedPrecision(16); |
| } |
| }; |
| |
| if (savedPrecision == 16) |
| { |
| FPRendering.this.fRendering.setDisplayedPrecision(16); |
| actionDisplay16Digits.setChecked(savedPrecision == 16); |
| } |
| |
| // Set RMC selections based on datatype and displayed precision settings in effect |
| |
| setSelections(); |
| |
| // Columns |
| |
| int savedColumnCount = getRMCvalue(IFPRConstants.COLUMN_COUNT_KEY); |
| |
| final Action displayColumnCountAuto = new Action(FPRenderingMessages.getString("FPRendering.COLUMN_COUNT_AUTO"), IAction.AS_RADIO_BUTTON) //$NON-NLS-1$ |
| { |
| @Override |
| public void run() |
| { |
| FPRendering.this.fRendering.setColumnsSetting(Rendering.COLUMNS_AUTO_SIZE_TO_FIT); |
| setRMCvalue(IFPRConstants.COLUMN_COUNT_KEY, Rendering.COLUMNS_AUTO_SIZE_TO_FIT); |
| } |
| }; |
| |
| boolean autoMode = savedColumnCount == Rendering.COLUMNS_AUTO_SIZE_TO_FIT; |
| displayColumnCountAuto.setChecked(autoMode); |
| |
| final Action[] displayColumnCounts = new Action[MAX_MENU_COLUMN_COUNT]; |
| |
| for (int index = 0, j = 1; index < MAX_MENU_COLUMN_COUNT; index++, j *= 2) |
| { |
| final int finali = j; |
| displayColumnCounts[index] = new Action(FPRenderingMessages.getString("FPRendering.COLUMN_COUNT_" + finali), IAction.AS_RADIO_BUTTON) //$NON-NLS-1$ |
| { |
| @Override |
| public void run() |
| { |
| FPRendering.this.fRendering.setColumnsSetting(finali); |
| setRMCvalue(IFPRConstants.COLUMN_COUNT_KEY, finali); |
| } |
| }; |
| displayColumnCounts[index].setChecked(fRendering.getColumnsSetting() == finali); |
| } |
| |
| // Set/clear column count selections as appropriate |
| |
| int countValue = getRMCvalue(IFPRConstants.COLUMN_COUNT_KEY); |
| |
| for (int index = 0; index < MAX_MENU_COLUMN_COUNT; index++) |
| displayColumnCounts[index].setChecked(countValue != Rendering.COLUMNS_AUTO_SIZE_TO_FIT && (countValue == (1 << index))); |
| |
| fRendering.setColumnsSetting(getRMCvalue(IFPRConstants.COLUMN_COUNT_KEY)); |
| |
| final Action displayColumnCountCustomValue = new Action("", IAction.AS_RADIO_BUTTON) //$NON-NLS-1$ |
| { |
| @Override |
| public void run() |
| { |
| } |
| }; |
| |
| final Action displayColumnCountCustom = new Action(FPRenderingMessages.getString("FPRendering.COLUMN_COUNT_CUSTOM"), IAction.AS_RADIO_BUTTON) //$NON-NLS-1$ |
| { |
| @Override |
| public void run() |
| { |
| InputDialog inputDialog = new InputDialog |
| ( |
| fRendering.getShell(), "Set Column Count", "Please enter column count", "", new IInputValidator() //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| { |
| @Override |
| public String isValid(String input) |
| { |
| try |
| { |
| int index = Integer.parseInt(input); |
| |
| if (index <= 0) |
| return "Please enter a positive integer"; //$NON-NLS-1$ |
| |
| if (index > 200) |
| return "Please enter a positive integer not greater than 200"; //$NON-NLS-1$ |
| } |
| catch (NumberFormatException x) |
| { |
| return "Please enter a positive integer"; //$NON-NLS-1$ |
| } |
| |
| return null; |
| } |
| } |
| ); |
| |
| if (inputDialog.open() != Window.OK) |
| { |
| this.setChecked(false); |
| int currentColumnSetting = FPRendering.this.fRendering.getColumnsSetting(); |
| |
| if (currentColumnSetting == Rendering.COLUMNS_AUTO_SIZE_TO_FIT) |
| displayColumnCountAuto.setChecked(true); |
| else |
| { |
| boolean currentCountIsCustom = true; |
| |
| for (int index = 0, j = 1; index < MAX_MENU_COLUMN_COUNT && currentCountIsCustom; index++, j *= 2) |
| { |
| currentCountIsCustom = (j != fRendering.getColumnsSetting()); |
| if (j == fRendering.getColumnsSetting()) |
| displayColumnCounts[index].setChecked(true); |
| } |
| |
| if (currentCountIsCustom) |
| displayColumnCountCustomValue.setChecked(true); |
| } |
| |
| return; |
| } |
| |
| int newColumnCount = -1; |
| |
| try |
| { |
| newColumnCount = Integer.parseInt(inputDialog.getValue()); |
| } |
| catch (NumberFormatException x) |
| { |
| assert false; |
| } |
| |
| boolean customIsOneOfStandardListChoices = false; |
| |
| for (int index = 0, j = 1; index < MAX_MENU_COLUMN_COUNT; index++, j *= 2) |
| { |
| if (newColumnCount == j) |
| { |
| customIsOneOfStandardListChoices = true; |
| FPRendering.this.fRendering.setColumnsSetting(newColumnCount); |
| setRMCvalue(IFPRConstants.COLUMN_COUNT_KEY, newColumnCount); |
| this.setChecked(false); |
| displayColumnCountCustomValue.setChecked(false); |
| displayColumnCounts[index].setChecked(true); |
| break; |
| } |
| } |
| |
| if (!customIsOneOfStandardListChoices) |
| { |
| FPRendering.this.fRendering.setColumnsSetting(newColumnCount); |
| setRMCvalue(IFPRConstants.COLUMN_COUNT_KEY, newColumnCount); |
| this.setChecked(false); |
| |
| displayColumnCountCustomValue.setChecked(true); |
| displayColumnCountCustomValue.setText(Integer.valueOf(fRendering.getColumnsSetting()).toString()); |
| } |
| } |
| }; |
| |
| // Check for a custom value: If we're not in "Auto Fill" mode, check for standard column sizes. |
| // If none of the standard sizes were entered, then it's a custom value; set it and display it. |
| |
| boolean customColumnCountSet = true; |
| countValue = getRMCvalue(IFPRConstants.COLUMN_COUNT_KEY); |
| |
| if (countValue != Rendering.COLUMNS_AUTO_SIZE_TO_FIT) |
| { |
| for (int index = 0; index < MAX_MENU_COLUMN_COUNT; index++) |
| { |
| // If the column count is one of the standard values, set flag to false and exit the loop |
| |
| if (countValue == (1 << index)) |
| { |
| customColumnCountSet = false; |
| break; |
| } |
| } |
| |
| if (customColumnCountSet) |
| { |
| FPRendering.this.fRendering.setColumnsSetting(countValue); |
| displayColumnCountCustomValue.setChecked(true); |
| displayColumnCountCustomValue.setText(Integer.valueOf(fRendering.getColumnsSetting()).toString()); |
| } |
| } |
| |
| // Add the right-mouse-click (RMC) context menu items |
| |
| getPopupMenuManager().addMenuListener(new IMenuListener() |
| { |
| @Override |
| public void menuAboutToShow(IMenuManager manager) |
| { |
| manager.add(new Separator()); |
| |
| MenuManager sub = new MenuManager(FPRenderingMessages.getString("FPRendering.PANES")); //$NON-NLS-1$ |
| |
| sub = new MenuManager(FPRenderingMessages.getString("FPRendering.ENDIAN")); //$NON-NLS-1$ |
| sub.add(actionDisplayBigEndian); |
| sub.add(actionDisplayLittleEndian); |
| manager.add(sub); |
| |
| sub = new MenuManager(FPRenderingMessages.getString("FPRendering.NUMBER_TYPE")); //$NON-NLS-1$ |
| sub.add(actionFloatingPoint32); |
| sub.add(actionFloatingPoint64); |
| manager.add(sub); |
| |
| sub = new MenuManager(FPRenderingMessages.getString("FPRendering.PRECISION")); //$NON-NLS-1$ |
| sub.add(actionDisplay4Digits); |
| sub.add(actionDisplay8Digits); |
| sub.add(actionDisplay16Digits); |
| manager.add(sub); |
| |
| // TODO: Add separator for FP group here: manager.add(new Separator()); |
| |
| sub = new MenuManager(FPRenderingMessages.getString("FPRendering.COLUMN_COUNT")); //$NON-NLS-1$ |
| sub.add(displayColumnCountAuto); |
| |
| for (int index = 0; index < displayColumnCounts.length; index++) |
| sub.add(displayColumnCounts[index]); |
| |
| boolean currentCountIsCustom = fRendering.getColumnsSetting() != 0; |
| |
| for (int index = 0, j = 1; index < MAX_MENU_COLUMN_COUNT && currentCountIsCustom; index++, j *= 2) |
| currentCountIsCustom = (j != fRendering.getColumnsSetting()); |
| |
| if (currentCountIsCustom) |
| sub.add(displayColumnCountCustomValue); |
| |
| sub.add(displayColumnCountCustom); |
| manager.add(sub); |
| |
| // Update modes |
| |
| int updateMode = getRMCvalue(IFPRConstants.UPDATEMODE_KEY); |
| |
| final Action updateAlwaysAction = new Action(FPRenderingMessages.getString("FPRendering.UPDATE_ALWAYS"), IAction.AS_RADIO_BUTTON) //$NON-NLS-1$ |
| { |
| @Override |
| public void run() |
| { |
| fRendering.setUpdateMode(Rendering.UPDATE_ALWAYS); |
| setRMCvalue(IFPRConstants.UPDATEMODE_KEY, Rendering.UPDATE_ALWAYS); |
| } |
| }; |
| updateAlwaysAction.setChecked(updateMode == Rendering.UPDATE_ALWAYS); |
| |
| final Action updateOnBreakpointAction = new Action(FPRenderingMessages.getString("FPRendering.UPDATE_ON_BREAKPOINT"), IAction.AS_RADIO_BUTTON) //$NON-NLS-1$ |
| { |
| @Override |
| public void run() |
| { |
| fRendering.setUpdateMode(Rendering.UPDATE_ON_BREAKPOINT); |
| setRMCvalue(IFPRConstants.UPDATEMODE_KEY, Rendering.UPDATE_ON_BREAKPOINT); |
| } |
| }; |
| updateOnBreakpointAction.setChecked(updateMode == Rendering.UPDATE_ON_BREAKPOINT); |
| |
| final Action updateManualAction = new Action(FPRenderingMessages.getString("FPRendering.UPDATE_MANUAL"), IAction.AS_RADIO_BUTTON) //$NON-NLS-1$ |
| { |
| @Override |
| public void run() |
| { |
| fRendering.setUpdateMode(Rendering.UPDATE_MANUAL); |
| setRMCvalue(IFPRConstants.UPDATEMODE_KEY, Rendering.UPDATE_MANUAL); |
| } |
| }; |
| updateManualAction.setChecked(updateMode == Rendering.UPDATE_MANUAL); |
| |
| // Add menu |
| |
| sub = new MenuManager(FPRenderingMessages.getString("FPRendering.UPDATEMODE")); //$NON-NLS-1$ |
| sub.add(updateAlwaysAction); |
| sub.add(updateOnBreakpointAction); |
| sub.add(updateManualAction); |
| manager.add(sub); |
| manager.add(new Separator()); |
| |
| BigInteger start = fRendering.getSelection().getStart(); |
| BigInteger end = fRendering.getSelection().getEnd(); |
| copyAction.setEnabled(start != null && end != null); |
| |
| manager.add(copyAction); |
| manager.add(copyAddressAction); |
| |
| manager.add(gotoBaseAddressAction); |
| manager.add(refreshAction); |
| manager.add(new Separator()); |
| manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS)); |
| } |
| }); |
| } |
| |
| // Set/clear selections as appropriate |
| |
| public void setSelections() |
| { |
| if (actionDisplay4Digits == null || actionDisplay8Digits == null || actionDisplay16Digits == null) return; |
| |
| // Enable/disable and set/clear menu RMC elements based on currently selected datatype |
| |
| boolean dtFloat = FPRendering.this.fRendering.getFPDataType() == FPDataType.FLOAT; |
| |
| actionDisplay16Digits.setEnabled(!dtFloat); |
| actionFloatingPoint32.setChecked(dtFloat); |
| actionFloatingPoint64.setChecked(!dtFloat); |
| |
| // Set/clear RMC elements based on displayed precision |
| |
| int displayedPrecision = getRMCvalue(dtFloat ? IFPRConstants.FLOAT_DISP_KEY : IFPRConstants.DOUBLE_DISP_KEY); |
| |
| actionDisplay4Digits.setChecked (displayedPrecision == 4); |
| actionDisplay8Digits.setChecked (displayedPrecision == 8); |
| actionDisplay16Digits.setChecked(displayedPrecision == 16); |
| } |
| |
| |
| @Override |
| public Control getControl() |
| { |
| return this.fRendering; |
| } |
| |
| // Selection is terminology for caret position |
| |
| @Override |
| public BigInteger getSelectedAddress() |
| { |
| FPIMemorySelection selection = fRendering.getSelection(); |
| if (selection == null || selection.getStart() == null) |
| return fRendering.getCaretAddress(); |
| |
| return selection.getStartLow(); |
| } |
| |
| @Override |
| public MemoryByte[] getSelectedAsBytes() |
| { |
| try |
| { |
| // default to the caret address and the cell count size |
| BigInteger startAddr = fRendering.getCaretAddress(); |
| int byteCount = fRendering.getCharsPerColumn(); |
| |
| // Now see if there's a selection |
| FPIMemorySelection selection = fRendering.getSelection(); |
| if (selection != null && selection.getStart() != null) |
| { |
| // The implementation is such that just having a caret somewhere (without multiple cells |
| // being selected) constitutes a selection, except for when the rendering is in its initial |
| // state, i.e. just because we get here doesn't mean the user has selected more than one cell. |
| |
| startAddr = getSelectedAddress(); |
| |
| if (selection.getHigh() != null) |
| byteCount = selection.getHigh().subtract(selection.getLow()).intValue() * fRendering.getAddressableSize(); |
| } |
| |
| return fRendering.getViewportCache().getBytes(startAddr, byteCount); |
| |
| } |
| catch (DebugException de) |
| { |
| return new MemoryByte[0]; |
| } |
| } |
| |
| @Override |
| public void goToAddress(final BigInteger address) throws DebugException |
| { |
| Display.getDefault().asyncExec(new Runnable() |
| { |
| @Override |
| public void run() |
| { |
| fRendering.gotoAddress(address); |
| } |
| }); |
| } |
| |
| protected void setTargetMemoryLittleEndian(boolean littleEndian) |
| { |
| // Once we actually read memory we can determine the endianess and need to set these actions accordingly. |
| actionDisplayBigEndian.setChecked(!littleEndian); |
| actionDisplayLittleEndian.setChecked(littleEndian); |
| |
| // When target endian changes, force display endian to track. User can then change display endian if desired. |
| fRendering.setDisplayLittleEndian(littleEndian); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.core.runtime.PlatformObject#getAdapter(java.lang.Class) |
| */ |
| @Override |
| public Object getAdapter(Class adapter) |
| { |
| if (adapter == IWorkbenchAdapter.class) |
| { |
| if (this.fWorkbenchAdapter == null) |
| { |
| this.fWorkbenchAdapter = new IWorkbenchAdapter() |
| { |
| @Override |
| public Object[] getChildren(Object o) |
| { |
| return new Object[0]; |
| } |
| |
| @Override |
| public ImageDescriptor getImageDescriptor(Object object) |
| { |
| return null; |
| } |
| |
| @Override |
| public String getLabel(Object o) |
| { |
| return FPRenderingMessages.getString("FPRendering.RENDERING_NAME"); //$NON-NLS-1$ |
| } |
| |
| @Override |
| public Object getParent(Object o) |
| { |
| return null; |
| } |
| }; |
| } |
| return this.fWorkbenchAdapter; |
| } |
| |
| if (adapter == IMemoryBlockConnection.class) |
| { |
| if (fConnection == null) |
| { |
| fConnection = new IMemoryBlockConnection() |
| { |
| @Override |
| public void update() |
| { |
| // update UI asynchronously |
| Display display = FPRenderingPlugin.getDefault().getWorkbench().getDisplay(); |
| display.asyncExec(new Runnable() |
| { |
| @Override |
| public void run() |
| { |
| try |
| { |
| if (fBigBaseAddress != FPRendering.this.fRendering.getMemoryBlock().getBigBaseAddress()) |
| { |
| fBigBaseAddress = FPRendering.this.fRendering.getMemoryBlock().getBigBaseAddress(); |
| FPRendering.this.fRendering.gotoAddress(fBigBaseAddress); |
| } |
| FPRendering.this.fRendering.refresh(); |
| } |
| catch (DebugException e) |
| { |
| } |
| } |
| }); |
| } |
| }; |
| } |
| |
| return fConnection; |
| } |
| |
| return super.getAdapter(adapter); |
| } |
| |
| @Override |
| public void resetRendering() throws DebugException |
| { |
| fRendering.gotoAddress(fRendering.fBaseAddress); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.cdt.debug.internal.core.model.provisional. |
| * IMemoryRenderingViewportProvider#getViewportAddress() |
| */ |
| @Override |
| public BigInteger getViewportAddress() |
| { |
| return fRendering.getViewportStartAddress(); |
| } |
| |
| // Persistence methods |
| |
| void setDisplayedPrecision(int precision) |
| { |
| // Save the appropriate displayed precision value, based on data type, in the store |
| |
| if (FPRendering.this.fRendering.getFPDataType() == FPDataType.FLOAT) |
| setRMCvalue(IFPRConstants.FLOAT_DISP_KEY, precision); |
| else |
| setRMCvalue(IFPRConstants.DOUBLE_DISP_KEY, precision); |
| } |
| |
| private int getDisplayedPrecision() |
| { |
| // Retrieve the persisted data value from the store |
| |
| IPreferenceStore store = FPRenderingPlugin.getDefault().getPreferenceStore(); |
| |
| FPDataType dataType = FPRendering.this.fRendering.getFPDataType(); |
| |
| if (store != null) |
| return store.getInt(dataType == FPDataType.FLOAT ? IFPRConstants.FLOAT_DISP_KEY : IFPRConstants.DOUBLE_DISP_KEY); |
| |
| // If there's nothing persisted, return the default precision for data type |
| |
| return dataType == FPDataType.FLOAT ? FPDataType.FLOAT.getDisplayedPrecision() : FPDataType.DOUBLE.getDisplayedPrecision(); |
| } |
| |
| void setRMCvalue(String key, int value) |
| { |
| // Save the specified key and int value |
| |
| IPreferenceStore store = FPRenderingPlugin.getDefault().getPreferenceStore(); |
| if (store != null) store.setValue(key, value); |
| } |
| |
| int getRMCvalue(String key) |
| { |
| // Return the value for the specified key |
| |
| IPreferenceStore store = FPRenderingPlugin.getDefault().getPreferenceStore(); |
| return (store != null) ? store.getInt(key) : 0; |
| } |
| } |
| |
| // Copy class |
| |
| class CopyAction extends Action |
| { |
| // TODO for the sake of large copies, this action should probably read in |
| // blocks on a Job. |
| |
| private Rendering fRendering; |
| private int fType = DND.CLIPBOARD; |
| |
| public CopyAction(Rendering rendering) |
| { |
| this(rendering, DND.CLIPBOARD); |
| } |
| |
| @SuppressWarnings("restriction") // using platform's labels and images; acceptable build risk |
| public CopyAction(Rendering rendering, int clipboardType) |
| { |
| super(); |
| fType = clipboardType; |
| fRendering = rendering; |
| setText(DebugUIMessages.CopyViewToClipboardAction_title); |
| setToolTipText(DebugUIMessages.CopyViewToClipboardAction_tooltip); |
| setImageDescriptor(DebugPluginImages |
| .getImageDescriptor(IInternalDebugUIConstants.IMG_ELCL_COPY_VIEW_TO_CLIPBOARD)); |
| setHoverImageDescriptor(DebugPluginImages |
| .getImageDescriptor(IInternalDebugUIConstants.IMG_LCL_COPY_VIEW_TO_CLIPBOARD)); |
| setDisabledImageDescriptor(DebugPluginImages |
| .getImageDescriptor(IInternalDebugUIConstants.IMG_DLCL_COPY_VIEW_TO_CLIPBOARD)); |
| } |
| |
| @Override |
| public void run() |
| { |
| Clipboard clip = null; |
| final String PANE_SPACING = " "; //$NON-NLS-1$ |
| |
| try |
| { |
| clip = new Clipboard(fRendering.getDisplay()); |
| |
| BigInteger start = fRendering.getSelection().getStart(); |
| BigInteger end = fRendering.getSelection().getEnd(); |
| |
| if (end == null) return; // End will be null when there is nothing selected |
| |
| if (start.compareTo(end) > 0) |
| { |
| // Swap start and end |
| |
| BigInteger bigI = end; |
| end = start; |
| start = bigI; |
| } |
| |
| final FPDataType numberType = fRendering.getFPDataType(); |
| final int bytesPerColumn = numberType.getByteLength(); |
| final boolean isLittleEndian = fRendering.isTargetLittleEndian(); |
| final int columns = fRendering.getColumnCount(); |
| BigInteger lengthToRead = end.subtract(start); |
| |
| int rows = lengthToRead.divide(BigInteger.valueOf(columns * (fRendering.getFPDataType().getByteLength()))).intValue(); |
| |
| if (rows * columns * bytesPerColumn < lengthToRead.intValue()) rows++; |
| |
| StringBuilder buffer = new StringBuilder(); |
| |
| for (int row = 0; row < rows; row++) |
| { |
| BigInteger rowAddress = start.add(BigInteger.valueOf(row * columns * bytesPerColumn)); |
| |
| if (fRendering.getPaneVisible(Rendering.PANE_ADDRESS)) |
| { |
| buffer.append(fRendering.getAddressString(rowAddress)); |
| buffer.append(PANE_SPACING); |
| } |
| |
| if (fRendering.getPaneVisible(Rendering.PANE_DATA)) |
| { |
| for(int col = 0; col < columns; col++) |
| { |
| BigInteger cellAddress = rowAddress.add(BigInteger.valueOf(col * bytesPerColumn)); |
| |
| if (cellAddress.compareTo(end) < 0) |
| { |
| try |
| { |
| FPMemoryByte bytes[] = fRendering.getBytes(cellAddress, bytesPerColumn); |
| buffer.append(fRendering.sciNotationString(bytes, numberType, isLittleEndian)); |
| } |
| catch(DebugException de) |
| { |
| fRendering |
| .logError( |
| FPRenderingMessages |
| .getString("FPRendering.FAILURE_COPY_OPERATION"), de); //$NON-NLS-1$ |
| return; |
| } |
| } |
| else |
| { |
| for(int i = fRendering.getCharsPerColumn(); i > 0; i--) |
| buffer.append(' '); |
| } |
| |
| if (col != columns - 1) |
| buffer.append(' '); |
| } |
| } |
| |
| if (fRendering.getPaneVisible(Rendering.PANE_DATA)) |
| buffer.append(PANE_SPACING); |
| |
| buffer.append("\n"); //$NON-NLS-1$ |
| } |
| |
| if (buffer.length() > 0) |
| { |
| TextTransfer plainTextTransfer = TextTransfer.getInstance(); |
| clip.setContents(new Object[] { buffer.toString() }, new Transfer[] { plainTextTransfer }, fType); |
| } |
| } |
| finally |
| { |
| if (clip != null) |
| { |
| clip.dispose(); |
| } |
| } |
| } |
| } |
