diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/CallStackMethodExecutions.java b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/CallStackMethodExecutions.java deleted file mode 100644 index b711506..0000000 --- a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/CallStackMethodExecutions.java +++ /dev/null @@ -1,97 +0,0 @@ -package org.ntlab.reversedebugger; - -import java.util.ArrayList; -import java.util.List; - -import org.eclipse.jface.viewers.TreeNode; -import org.ntlab.debuggingControl.MethodCaller; - -import com.sun.jdi.ClassNotLoadedException; -import com.sun.jdi.IncompatibleThreadStateException; -import com.sun.jdi.IntegerValue; -import com.sun.jdi.InvalidTypeException; -import com.sun.jdi.InvocationException; -import com.sun.jdi.ObjectReference; -import com.sun.jdi.ThreadReference; -import com.sun.jdi.Value; -import com.sun.jdi.VirtualMachine; -import com.sun.jdi.event.MethodEntryEvent; - -public class CallStackMethodExecutions { - private List callStackMethodExecutions = new ArrayList<>(); - - public List getCallStackMethodExecutions() { - return callStackMethodExecutions; - } - - public TreeNode[] getCallStackMethodExecutionsTreeNode() { - TreeNode[] roots = new TreeNode[1]; - if (callStackMethodExecutions.isEmpty()) { - return roots; - } - CallStackModel callStackModel = callStackMethodExecutions.get(0); - roots[0] = new TreeNode(new MethodCaller(callStackModel.getVm(), callStackModel.getThread())); - TreeNode parentNode = roots[0]; - TreeNode[] childrenNode = new TreeNode[callStackMethodExecutions.size()]; - parentNode.setChildren(childrenNode); - for (int i = 0; i < callStackMethodExecutions.size(); i++) { - TreeNode childNode = new TreeNode(callStackMethodExecutions.get(i)); - childNode.setParent(parentNode); - childrenNode[i] = childNode; - } - return roots; - } - - public void reset() { - callStackMethodExecutions.clear(); - } - - public void updateByDebuggerStopMethodExecution(MethodCaller me) { - if (me == null) { - return; - } - try { - VirtualMachine vm = me.getVm(); - ThreadReference thread = me.getThread(); - int lineNo = thread.frame(0).location().lineNumber(); - update(vm, thread, me.getObj(), lineNo); - } catch (InvalidTypeException | ClassNotLoadedException - | InvocationException | IncompatibleThreadStateException e) { - e.printStackTrace(); - } - } - - public void updateByAlias(MethodCaller alias) { - if (alias == null) { - return; - } - VirtualMachine vm = alias.getVm(); - ThreadReference thread = alias.getThread(); - try { - ObjectReference me = (ObjectReference)alias.callInstanceMethod("getMethodExecution"); - int lineNo = ((IntegerValue)alias.callInstanceMethod("getLineNo")).value(); - update(vm, thread, me, lineNo); - } catch (InvalidTypeException | ClassNotLoadedException - | InvocationException | IncompatibleThreadStateException e) { - e.printStackTrace(); - } - } - - private void update(VirtualMachine vm, ThreadReference thread, ObjectReference me, int topMethodCallLineNo) - throws InvalidTypeException, ClassNotLoadedException, InvocationException, IncompatibleThreadStateException { - callStackMethodExecutions.clear(); - ObjectReference childMe = null; - int callLineNo = topMethodCallLineNo; - while (me != null) { - CallStackModel callStackModel = new CallStackModel(vm, thread, me, callLineNo); - callStackMethodExecutions.add(callStackModel); - childMe = me; - me = (ObjectReference)callStackModel.callInstanceMethod("getParent"); - if (me != null) { - MethodCaller mc = new MethodCaller(vm, thread, me); - ObjectReference callStatement = (ObjectReference)mc.callInstanceMethod("getMethodInvocation", childMe); - callLineNo = ((IntegerValue)mc.setObj(callStatement).callInstanceMethod("getLineNo")).value(); - } - } - } -} diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/CallStackModels.java b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/CallStackModels.java new file mode 100644 index 0000000..971ae7a --- /dev/null +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/CallStackModels.java @@ -0,0 +1,97 @@ +package org.ntlab.reversedebugger; + +import java.util.ArrayList; +import java.util.List; + +import org.eclipse.jface.viewers.TreeNode; +import org.ntlab.debuggingControl.MethodCaller; + +import com.sun.jdi.ClassNotLoadedException; +import com.sun.jdi.IncompatibleThreadStateException; +import com.sun.jdi.IntegerValue; +import com.sun.jdi.InvalidTypeException; +import com.sun.jdi.InvocationException; +import com.sun.jdi.ObjectReference; +import com.sun.jdi.ThreadReference; +import com.sun.jdi.Value; +import com.sun.jdi.VirtualMachine; +import com.sun.jdi.event.MethodEntryEvent; + +public class CallStackModels { + private List callStackModels = new ArrayList<>(); + + public List getCallStackModels() { + return callStackModels; + } + + public TreeNode[] getCallStackModelsTreeNodes() { + TreeNode[] roots = new TreeNode[1]; + if (callStackModels.isEmpty()) { + return roots; + } + CallStackModel callStackModel = callStackModels.get(0); + roots[0] = new TreeNode(new MethodCaller(callStackModel.getVm(), callStackModel.getThread())); + TreeNode parentNode = roots[0]; + TreeNode[] childrenNode = new TreeNode[callStackModels.size()]; + parentNode.setChildren(childrenNode); + for (int i = 0; i < callStackModels.size(); i++) { + TreeNode childNode = new TreeNode(callStackModels.get(i)); + childNode.setParent(parentNode); + childrenNode[i] = childNode; + } + return roots; + } + + public void reset() { + callStackModels.clear(); + } + + public void updateByDebuggerStopMethodExecution(MethodCaller me) { + if (me == null) { + return; + } + try { + VirtualMachine vm = me.getVm(); + ThreadReference thread = me.getThread(); + int lineNo = thread.frame(0).location().lineNumber(); + update(vm, thread, me.getObj(), lineNo); + } catch (InvalidTypeException | ClassNotLoadedException + | InvocationException | IncompatibleThreadStateException e) { + e.printStackTrace(); + } + } + + public void updateByAlias(MethodCaller alias) { + if (alias == null) { + return; + } + VirtualMachine vm = alias.getVm(); + ThreadReference thread = alias.getThread(); + try { + ObjectReference me = (ObjectReference)alias.callInstanceMethod("getMethodExecution"); + int lineNo = ((IntegerValue)alias.callInstanceMethod("getLineNo")).value(); + update(vm, thread, me, lineNo); + } catch (InvalidTypeException | ClassNotLoadedException + | InvocationException | IncompatibleThreadStateException e) { + e.printStackTrace(); + } + } + + private void update(VirtualMachine vm, ThreadReference thread, ObjectReference me, int topMethodCallLineNo) + throws InvalidTypeException, ClassNotLoadedException, InvocationException, IncompatibleThreadStateException { + callStackModels.clear(); + ObjectReference childMe = null; + int callLineNo = topMethodCallLineNo; + while (me != null) { + CallStackModel callStackModel = new CallStackModel(vm, thread, me, callLineNo); + callStackModels.add(callStackModel); + childMe = me; + me = (ObjectReference)callStackModel.callInstanceMethod("getParent"); + if (me != null) { + MethodCaller mc = new MethodCaller(vm, thread, me); + ObjectReference callStatement = (ObjectReference)mc.callInstanceMethod("getMethodInvocation", childMe); + callLineNo = ((IntegerValue)mc.setObj(callStatement).callInstanceMethod("getLineNo")).value(); + } + } + } +} diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/CallStackView.java b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/CallStackView.java index 7772e73..2c2ee60 100644 --- a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/CallStackView.java +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/CallStackView.java @@ -19,8 +19,7 @@ public class CallStackView extends ViewPart { private static TreeViewer viewer; private IAction refreshAction; - private IAction resetAction; - private static CallStackMethodExecutions callStackMethodExecutions = new CallStackMethodExecutions(); + private static CallStackModels callStackModels = new CallStackModels(); private JavaEditorOperator javaEditorOperator = new JavaEditorOperator(); public static final String ID = "org.ntlab.reverseDebugger.callStackView"; @@ -70,47 +69,39 @@ refresh(); } }; - refreshAction.setText("���t���b�V��"); - refreshAction.setToolTipText("���t���b�V��"); - refreshAction.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_OBJS_INFO_TSK)); - - resetAction = new Action() { - @Override - public void run() { - reset(); - } - }; - resetAction.setText("���Z�b�g"); - resetAction.setToolTipText("���Z�b�g"); - resetAction.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_OBJS_WARN_TSK)); + refreshAction.setText("refresh"); + refreshAction.setToolTipText("refresh"); + refreshAction.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_ELCL_SYNCED)); } private void createToolBar() { IToolBarManager mgr = getViewSite().getActionBars().getToolBarManager(); mgr.add(refreshAction); - mgr.add(resetAction); } private void createMenuBar() { IMenuManager mgr = getViewSite().getActionBars().getMenuManager(); mgr.add(refreshAction); - mgr.add(resetAction); } public static void updateByAlias(MethodCaller alias) { - callStackMethodExecutions.updateByAlias(alias); + callStackModels.updateByAlias(alias); } public static void refresh() { - if (callStackMethodExecutions.getCallStackMethodExecutions().isEmpty()) { + if (callStackModels.getCallStackModels().isEmpty()) { MethodCaller currentMe = SeedAliasView.getDebuggerStopMethodExecution(); - callStackMethodExecutions.updateByDebuggerStopMethodExecution(currentMe); + callStackModels.updateByDebuggerStopMethodExecution(currentMe); } - viewer.setInput(callStackMethodExecutions.getCallStackMethodExecutionsTreeNode()); + TreeNode[] nodes = callStackModels.getCallStackModelsTreeNodes(); + if (nodes == null || nodes[0] == null) { + return; + } + viewer.setInput(callStackModels.getCallStackModelsTreeNodes()); } public static void reset() { - callStackMethodExecutions.reset(); + callStackModels.reset(); refresh(); } } diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliasLabelProvider.java b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliasLabelProvider.java index cba836b..c102080 100644 --- a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliasLabelProvider.java +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliasLabelProvider.java @@ -36,7 +36,7 @@ case 4: return ((StringReference)mc.callInstanceMethod("getStatementSignature")).value(); case 5: - return getColumnTextOfOccurrenceExp(mc); + return ((StringReference)mc.callInstanceMethod("getOccurrenceText")).value(); } } catch (InvalidTypeException | ClassNotLoadedException | InvocationException | IncompatibleThreadStateException e) { @@ -46,34 +46,6 @@ return "�e�X�g�p�e�L�X�g" + columnIndex; } - private String getColumnTextOfOccurrenceExp(MethodCaller mc) - throws InvalidTypeException, ClassNotLoadedException, InvocationException, IncompatibleThreadStateException { - int occurrenceEXP = ((IntegerValue)mc.callInstanceMethod("getOccurrenceExp")).value(); - String statementType = ((StringReference)mc.callInstanceMethod("getStatementType")).value(); - switch (statementType) { - case "FieldAccess": - case "FieldUpdate": - return (occurrenceEXP == 0) ? "container" : "field"; - case "ArrayAccess": - case "ArrayUpdate": - return (occurrenceEXP == 0) ? "arrayObject" : "arrayValue"; - case "ArrayCreate": - return "return"; - case "MethodInvocation": - if (occurrenceEXP <= 0) { - return (occurrenceEXP == 0) ? "receiver" : "return"; - } - final String[] ORDER_TEXT = {"th", "st", "nd", "rd", "th", "th", "th", "th", "th", "th", "th", "th", "th", "th"}; // 0-13�ɑΉ� - final String ARG = " arg"; - if (occurrenceEXP % 100 >= ORDER_TEXT.length) { - return occurrenceEXP + ORDER_TEXT[occurrenceEXP % 10] + ARG; // ��2����14�ȏ�Ȃ�, ��1���̐����ɑΉ������� - } else if (occurrenceEXP % 100 >= 0) { - return occurrenceEXP + ORDER_TEXT[occurrenceEXP % 100] + ARG; // ��2����0�ȏ�13�ȉ��Ȃ�, ��2���̐����ɑΉ������� - } - } - return String.valueOf(occurrenceEXP); - } - @Override public Image getColumnImage(Object element, int columnIndex) { return getImage(element); diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliasView.java b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliasView.java index 27bf149..daae2d3 100644 --- a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliasView.java +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliasView.java @@ -2,8 +2,11 @@ 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.ArrayContentProvider; import org.eclipse.jface.viewers.ISelection; import org.eclipse.jface.viewers.ISelectionChangedListener; @@ -12,10 +15,12 @@ import org.eclipse.jface.viewers.TableViewer; import org.eclipse.swt.SWT; import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Menu; import org.eclipse.swt.widgets.Table; import org.eclipse.swt.widgets.TableColumn; import org.eclipse.ui.ISelectionListener; import org.eclipse.ui.ISharedImages; +import org.eclipse.ui.IWorkbenchActionConstants; import org.eclipse.ui.IWorkbenchPart; import org.eclipse.ui.PlatformUI; import org.eclipse.ui.part.ViewPart; @@ -24,7 +29,8 @@ public class ObjectFlowAliasView extends ViewPart { private static TableViewer viewer; private IAction refreshAction; - private IAction resetAction; + private IAction findSeedAliasesAction; + private MethodCaller selectObjectFlowAlias; private static ObjectFlowAliases objectFlowAliases = new ObjectFlowAliases(); private JavaEditorOperator javaEditorOperator = new JavaEditorOperator(); public static final String ID = "org.ntlab.reverseDebugger.objectFlowAliasView"; @@ -57,24 +63,38 @@ viewer.setInput(objectFlowAliases.getObjectFlowSingleList(true)); // �I�������J�����ɑΉ�����G�C���A�X������郁�\�b�h���s���̑S�ẴV�[�h�G�C���A�X�̈ꗗ�𐶐����郊�X�i�[��o�^ +// viewer.addSelectionChangedListener(new ISelectionChangedListener() { +// @Override +// public void selectionChanged(SelectionChangedEvent event) { +// IStructuredSelection sel = (IStructuredSelection)event.getSelection(); +// Object element = sel.getFirstElement(); +// if (element instanceof MethodCaller) { +// MethodCaller alias = (MethodCaller)element; +// SeedAliasView.createSeedAliases(alias); +// SeedAliasView.refresh(); +// CallStackView.updateByAlias(alias); +// CallStackView.refresh(); +// javaEditorOperator.openSrcFileOfAlias(alias); +// } +// } +// }); + viewer.addSelectionChangedListener(new ISelectionChangedListener() { @Override public void selectionChanged(SelectionChangedEvent event) { IStructuredSelection sel = (IStructuredSelection)event.getSelection(); Object element = sel.getFirstElement(); if (element instanceof MethodCaller) { - MethodCaller alias = (MethodCaller)element; - SeedAliasView.createSeedAliases(alias); - SeedAliasView.refresh(); - CallStackView.updateByAlias(alias); - CallStackView.refresh(); - javaEditorOperator.openSrcFileOfAlias(alias); + selectObjectFlowAlias = (MethodCaller)element; + javaEditorOperator.openSrcFileOfAlias(selectObjectFlowAlias); } } }); + createActions(); createToolBar(); createMenuBar(); + createPopupMenu(); } @Override @@ -91,37 +111,58 @@ refresh(); } }; - refreshAction.setText("���t���b�V��"); - refreshAction.setToolTipText("���t���b�V��"); - refreshAction.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_OBJS_INFO_TSK)); + refreshAction.setText("refresh"); + refreshAction.setToolTipText("refresh"); + refreshAction.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_ELCL_SYNCED)); - resetAction = new Action() { + findSeedAliasesAction = new Action() { @Override public void run() { - reset(); + findSeedAliases(); } }; - resetAction.setText("���Z�b�g"); - resetAction.setToolTipText("���Z�b�g"); - resetAction.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_OBJS_WARN_TSK)); + findSeedAliasesAction.setText("findSeedAliases"); + findSeedAliasesAction.setToolTipText("findSeedAliases"); + findSeedAliasesAction.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_OBJS_TASK_TSK)); } private void createToolBar() { IToolBarManager mgr = getViewSite().getActionBars().getToolBarManager(); mgr.add(refreshAction); - mgr.add(resetAction); } private void createMenuBar() { IMenuManager mgr = getViewSite().getActionBars().getMenuManager(); mgr.add(refreshAction); - mgr.add(resetAction); + } + + private void createPopupMenu() { + MenuManager menuMgr = new MenuManager("#PopupMenu"); + menuMgr.setRemoveAllWhenShown(true); + menuMgr.addMenuListener(new IMenuListener() { + @Override + public void menuAboutToShow(IMenuManager manager) { + manager.add(findSeedAliasesAction); + manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS)); + } + }); + Menu menu = menuMgr.createContextMenu(viewer.getControl()); + viewer.getControl().setMenu(menu); + getSite().registerContextMenu(menuMgr, viewer); } public static void createObjectFlow(MethodCaller seedAlias) { objectFlowAliases.createObjectFlow(seedAlias); } + private void findSeedAliases() { + SeedAliasView.createSeedAliases(selectObjectFlowAlias); + SeedAliasView.refresh(); + CallStackView.updateByAlias(selectObjectFlowAlias); + CallStackView.refresh(); + javaEditorOperator.openSrcFileOfAlias(selectObjectFlowAlias); + } + public static void refresh() { viewer.setInput(objectFlowAliases.getObjectFlowSingleList(true)); } diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/SeedAliasLabelProvider.java b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/SeedAliasLabelProvider.java index 7a2c73a..fb9b740 100644 --- a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/SeedAliasLabelProvider.java +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/SeedAliasLabelProvider.java @@ -35,7 +35,7 @@ case 4: return ((StringReference)mc.callInstanceMethod("getStatementSignature")).value(); case 5: - return getColumnTextOfOccurrenceExp(mc); + return ((StringReference)mc.callInstanceMethod("getOccurrenceText")).value(); } } catch (InvalidTypeException | ClassNotLoadedException | InvocationException | IncompatibleThreadStateException e) { @@ -45,34 +45,6 @@ return "�e�X�g�p�e�L�X�g" + columnIndex; } - private String getColumnTextOfOccurrenceExp(MethodCaller mc) - throws InvalidTypeException, ClassNotLoadedException, InvocationException, IncompatibleThreadStateException { - int occurrenceEXP = ((IntegerValue)mc.callInstanceMethod("getOccurrenceExp")).value(); - String statementType = ((StringReference)mc.callInstanceMethod("getStatementType")).value(); - switch (statementType) { - case "FieldAccess": - case "FieldUpdate": - return (occurrenceEXP == 0) ? "container" : "field"; - case "ArrayAccess": - case "ArrayUpdate": - return (occurrenceEXP == 0) ? "arrayObject" : "arrayValue"; - case "ArrayCreate": - return "return"; - case "MethodInvocation": - if (occurrenceEXP <= 0) { - return (occurrenceEXP == 0) ? "receiver" : "return"; - } - final String[] ORDER_TEXT = {"th", "st", "nd", "rd", "th", "th", "th", "th", "th", "th", "th", "th", "th", "th"}; // 0-13�ɑΉ� - final String ARG = " arg"; - if (occurrenceEXP % 100 >= ORDER_TEXT.length) { - return occurrenceEXP + ORDER_TEXT[occurrenceEXP % 10] + ARG; // ��2����14�ȏ�Ȃ�, ��1���̐����ɑΉ������� - } else if (occurrenceEXP % 100 >= 0) { - return occurrenceEXP + ORDER_TEXT[occurrenceEXP % 100] + ARG; // ��2����0�ȏ�13�ȉ��Ȃ�, ��2���̐����ɑΉ������� - } - } - return String.valueOf(occurrenceEXP); - } - @Override public Image getColumnImage(Object element, int columnIndex) { return getImage(element); diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/SeedAliasView.java b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/SeedAliasView.java index 9ce1bfa..73568ae 100644 --- a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/SeedAliasView.java +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/SeedAliasView.java @@ -2,32 +2,33 @@ 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.ArrayContentProvider; -import org.eclipse.jface.viewers.ISelection; import org.eclipse.jface.viewers.ISelectionChangedListener; import org.eclipse.jface.viewers.IStructuredSelection; import org.eclipse.jface.viewers.SelectionChangedEvent; import org.eclipse.jface.viewers.TableViewer; import org.eclipse.swt.SWT; -import org.eclipse.swt.events.SelectionListener; import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Menu; import org.eclipse.swt.widgets.Table; import org.eclipse.swt.widgets.TableColumn; -import org.eclipse.ui.ISelectionListener; import org.eclipse.ui.ISharedImages; -import org.eclipse.ui.IWorkbenchPart; +import org.eclipse.ui.IWorkbenchActionConstants; import org.eclipse.ui.PlatformUI; -import org.eclipse.ui.internal.dialogs.ViewLabelProvider; import org.eclipse.ui.part.ViewPart; -import org.ntlab.debuggingControl.DebuggingControlAction; import org.ntlab.debuggingControl.MethodCaller; public class SeedAliasView extends ViewPart { private static TableViewer viewer; private IAction refreshAction; private IAction resetAction; + private IAction getObjectFlowAction; + private MethodCaller selectSeedAlias; private static SeedAliases seedAliases = new SeedAliases(); private static JavaEditorOperator javaEditorOperator = new JavaEditorOperator(); public static final String ID = "org.ntlab.reverseDebugger.seedAliasView"; @@ -61,21 +62,35 @@ CallStackView.refresh(); // �I�������J�����ɑΉ�����V�[�h�G�C���A�X���N�_�ɃI�u�W�F�N�g�t���[�����s�����郊�X�i�[��o�^ +// viewer.addSelectionChangedListener(new ISelectionChangedListener() { +// @Override +// public void selectionChanged(SelectionChangedEvent event) { +// IStructuredSelection sel = (IStructuredSelection)event.getSelection(); +// Object element = sel.getFirstElement(); +// if (element instanceof MethodCaller) { +// MethodCaller seedAlias = (MethodCaller)element; +// ObjectFlowAliasView.createObjectFlow(seedAlias); +// ObjectFlowAliasView.refresh(); +// } +// } +// }); + viewer.addSelectionChangedListener(new ISelectionChangedListener() { @Override public void selectionChanged(SelectionChangedEvent event) { IStructuredSelection sel = (IStructuredSelection)event.getSelection(); Object element = sel.getFirstElement(); if (element instanceof MethodCaller) { - MethodCaller seedAlias = (MethodCaller)element; - ObjectFlowAliasView.createObjectFlow(seedAlias); - ObjectFlowAliasView.refresh(); + selectSeedAlias = (MethodCaller)element; + javaEditorOperator.openSrcFileOfAlias(selectSeedAlias); } } - }); + }); + createActions(); createToolBar(); createMenuBar(); + createPopupMenu(); } @Override @@ -92,9 +107,9 @@ refresh(); } }; - refreshAction.setText("���t���b�V��"); - refreshAction.setToolTipText("���t���b�V��"); - refreshAction.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_OBJS_INFO_TSK)); + refreshAction.setText("refresh"); + refreshAction.setToolTipText("refresh"); + refreshAction.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_ELCL_SYNCED)); resetAction = new Action() { @Override @@ -102,9 +117,19 @@ reset(); } }; - resetAction.setText("���Z�b�g"); - resetAction.setToolTipText("���Z�b�g"); - resetAction.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_OBJS_WARN_TSK)); + resetAction.setText("reset"); + resetAction.setToolTipText("reset"); + resetAction.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_ETOOL_HOME_NAV)); + + getObjectFlowAction = new Action() { + @Override + public void run() { + getObjectFlow(); + } + }; + getObjectFlowAction.setText("getObjectFlow"); + getObjectFlowAction.setToolTipText("getObjectFlow"); + getObjectFlowAction.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_OBJS_TASK_TSK)); } private void createToolBar() { @@ -118,6 +143,21 @@ mgr.add(refreshAction); mgr.add(resetAction); } + + private void createPopupMenu() { + MenuManager menuMgr = new MenuManager("#PopupMenu"); + menuMgr.setRemoveAllWhenShown(true); + menuMgr.addMenuListener(new IMenuListener() { + @Override + public void menuAboutToShow(IMenuManager manager) { + manager.add(getObjectFlowAction); + manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS)); + } + }); + Menu menu = menuMgr.createContextMenu(viewer.getControl()); + viewer.getControl().setMenu(menu); + getSite().registerContextMenu(menuMgr, viewer); + } public static MethodCaller getDebuggerStopMethodExecution() { return seedAliases.getDebuggerStopMethodExecution(); @@ -142,4 +182,11 @@ ObjectFlowAliasView.reset(); refresh(); } + + private void getObjectFlow() { + if (selectSeedAlias != null) { + ObjectFlowAliasView.createObjectFlow(selectSeedAlias); + ObjectFlowAliasView.refresh(); + } + } }