/*******************************************************************************
* Copyright (c) 2004, 2015 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial implementation
*******************************************************************************/
package org.eclipse.jdt.internal.debug.ui.actions;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.debug.core.DebugEvent;
import org.eclipse.debug.core.DebugException;
import org.eclipse.debug.core.model.IValue;
import org.eclipse.debug.core.model.IVariable;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.debug.ui.IDebugUIConstants;
import org.eclipse.debug.ui.actions.IVariableValueEditor;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.debug.core.IJavaDebugTarget;
import org.eclipse.jdt.debug.core.IJavaStackFrame;
import org.eclipse.jdt.debug.core.IJavaThread;
import org.eclipse.jdt.debug.core.IJavaVariable;
import org.eclipse.jdt.debug.eval.IAstEvaluationEngine;
import org.eclipse.jdt.debug.eval.IEvaluationListener;
import org.eclipse.jdt.debug.eval.IEvaluationResult;
import org.eclipse.jdt.internal.debug.core.JDIDebugPlugin;
import org.eclipse.jdt.internal.debug.core.JavaDebugUtils;
import org.eclipse.jdt.internal.debug.ui.JDIDebugUIPlugin;
import org.eclipse.jface.window.Window;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.progress.UIJob;
import com.sun.jdi.InvalidTypeException;
import com.sun.jdi.InvocationException;
import com.sun.jdi.ObjectReference;
/**
* A variable value editor which prompts the user to enter an expression
* for evaluation. The result of the evaluation is assigned to the variable.
*/
public class JavaObjectValueEditor implements IVariableValueEditor {
/* (non-Javadoc)
* @see org.eclipse.debug.ui.actions.IVariableValueEditor#editVariable(org.eclipse.debug.core.model.IVariable, org.eclipse.swt.widgets.Shell)
*/
@Override
public boolean editVariable(IVariable variable, Shell shell) {
try {
IJavaVariable javaVariable = (IJavaVariable) variable;
String signature = javaVariable.getSignature();
if ("Ljava/lang/String;".equals(signature)) { //$NON-NLS-1$
StringValueInputDialog dialog= new StringValueInputDialog(shell, javaVariable);
if (dialog.open() == Window.OK) {
String result = dialog.getResult();
if (dialog.isUseLiteralValue()) {
variable.setValue(result);
} else {
setValue(variable, result);
}
}
} else {
ExpressionInputDialog dialog= new ExpressionInputDialog(shell, javaVariable);
if (dialog.open() == Window.OK) {
String result = dialog.getResult();
setValue(variable, result);
}
}
} catch (DebugException e) {
handleException(e);
}
return true;
}
/* (non-Javadoc)
* @see org.eclipse.debug.ui.actions.IVariableValueEditor#saveVariable(org.eclipse.debug.core.model.IVariable, java.lang.String, org.eclipse.swt.widgets.Shell)
*/
@Override
public boolean saveVariable(IVariable variable, String expression, Shell shell) {
IJavaVariable javaVariable = (IJavaVariable) variable;
String signature= null;
try {
signature = javaVariable.getSignature();
if ("Ljava/lang/String;".equals(signature)) { //$NON-NLS-1$
return false;
}
setValue(variable, expression);
} catch (DebugException e) {
handleException(e);
}
return true;
}
/**
* Evaluates the given expression and sets the given variable's value
* using the result.
*
* @param variable the variable whose value should be set
* @param expression the expression to evaluate
* @throws DebugException if an exception occurs evaluating the expression
* or setting the variable's value
*/
protected void setValue(final IVariable variable, final String expression){
UIJob job = new UIJob("Setting Variable Value"){ //$NON-NLS-1$
@Override
public IStatus runInUIThread(IProgressMonitor monitor) {
try {
IValue newValue = evaluate(expression);
if (newValue != null) {
variable.setValue(newValue);
} else {
variable.setValue(expression);
}
} catch (DebugException de) {
handleException(de);
}
return Status.OK_STATUS;
}
};
job.setSystem(true);
job.schedule();
}
/**
* Handles the given exception, which occurred during edit/save.
*/
protected void handleException(DebugException e) {
Throwable cause = e.getStatus().getException();
if (cause instanceof InvalidTypeException) {
IStatus status = new Status(IStatus.ERROR, JDIDebugUIPlugin.getUniqueIdentifier(), IDebugUIConstants.INTERNAL_ERROR, cause.getMessage(), null);
JDIDebugUIPlugin.statusDialog(ActionMessages.JavaObjectValueEditor_3, status);
} else {
JDIDebugUIPlugin.statusDialog(e.getStatus());
}
}
/**
* Evaluates the given snippet. Reports any errors to the user.
* @param stringValue the snippet to evaluate
* @return the value that was computed or <code>null</code> if any errors occurred.
*/
private IValue evaluate(String stringValue) throws DebugException {
IAdaptable adaptable = DebugUITools.getDebugContext();
IJavaStackFrame frame = adaptable.getAdapter(IJavaStackFrame.class);
if (frame != null) {
IJavaThread thread = (IJavaThread) frame.getThread();
IJavaProject project= getProject(frame);
if (project != null) {
final IEvaluationResult[] results= new IEvaluationResult[1];
IAstEvaluationEngine engine = JDIDebugPlugin.getDefault().getEvaluationEngine(project, (IJavaDebugTarget) thread.getDebugTarget());
IEvaluationListener listener= new IEvaluationListener() {
@Override
public void evaluationComplete(IEvaluationResult result) {
synchronized (JavaObjectValueEditor.this) {
results[0]= result;
JavaObjectValueEditor.this.notifyAll();
}
}
};
synchronized(this) {
engine.evaluate(stringValue, frame, listener, DebugEvent.EVALUATION_IMPLICIT, false);
try {
this.wait();
} catch (InterruptedException e) {
if (results[0] == null){
IStatus status= new Status(IStatus.ERROR, JDIDebugUIPlugin.getUniqueIdentifier(), IStatus.ERROR, ActionMessages.JavaObjectValueEditor_0, e);
throw new DebugException(status);
}
}
}
IEvaluationResult result= results[0];
if (result == null) {
return null;
}
if (result.hasErrors()) {
DebugException exception = result.getException();
StringBuffer buffer = new StringBuffer();
if (exception == null) {
String[] messages = result.getErrorMessages();
for (int i = 0; i < messages.length; i++) {
buffer.append(messages[i]).append("\n "); //$NON-NLS-1$
}
} else {
buffer.append(EvaluateAction.getExceptionMessage(exception));
}
IStatus status= new Status(IStatus.ERROR, JDIDebugUIPlugin.getUniqueIdentifier(), IStatus.ERROR, buffer.toString(), null);
throw new DebugException(status);
}
return result.getValue();
}
}
return null;
}
/**
* (copied from EvaluateAction)
*/
protected String getExceptionMessage(Throwable exception) {
if (exception instanceof CoreException) {
CoreException ce = (CoreException)exception;
Throwable throwable= ce.getStatus().getException();
if (throwable instanceof com.sun.jdi.InvocationException) {
return getInvocationExceptionMessage((com.sun.jdi.InvocationException)throwable);
} else if (throwable instanceof CoreException) {
// Traverse nested CoreExceptions
return getExceptionMessage(throwable);
}
return ce.getStatus().getMessage();
}
String message= NLS.bind(ActionMessages.Evaluate_error_message_direct_exception, new Object[] { exception.getClass() });
if (exception.getMessage() != null) {
message= NLS.bind(ActionMessages.Evaluate_error_message_exception_pattern, new Object[] { message, exception.getMessage() });
}
return message;
}
/**
* Returns a message for the exception wrapped in an invocation exception
*/
protected String getInvocationExceptionMessage(com.sun.jdi.InvocationException exception) {
InvocationException ie= exception;
ObjectReference ref= ie.exception();
return NLS.bind(ActionMessages.Evaluate_error_message_wrapped_exception, new Object[] { ref.referenceType().name() });
}
/**
* Return the project associated with the given stack frame.
* (copied from JavaWatchExpressionDelegate)
*/
private IJavaProject getProject(IJavaStackFrame javaStackFrame) {
return JavaDebugUtils.resolveJavaProject(javaStackFrame);
}
}