X-Git-Url: http://secure.phpeclipse.com

diff --git a/net.sourceforge.phpeclipse.xdebug.core/src/net/sourceforge/phpeclipse/xdebug/php/model/XDebugTarget.java b/net.sourceforge.phpeclipse.xdebug.core/src/net/sourceforge/phpeclipse/xdebug/php/model/XDebugTarget.java
index 04099c4..9f31828 100644
--- a/net.sourceforge.phpeclipse.xdebug.core/src/net/sourceforge/phpeclipse/xdebug/php/model/XDebugTarget.java
+++ b/net.sourceforge.phpeclipse.xdebug.core/src/net/sourceforge/phpeclipse/xdebug/php/model/XDebugTarget.java
@@ -3,394 +3,419 @@
  */
 package net.sourceforge.phpeclipse.xdebug.php.model;
 
-import net.sourceforge.phpeclipse.xdebug.core.Base64;
-import net.sourceforge.phpeclipse.xdebug.core.DebugConnection;
-import net.sourceforge.phpeclipse.xdebug.core.PHPDebugUtils;
+import java.util.List;
+
+import net.sourceforge.phpeclipse.xdebug.core.AbstractDebugConnection;
+import net.sourceforge.phpeclipse.xdebug.core.IDebugConnection;
+import net.sourceforge.phpeclipse.xdebug.core.IPHPDebugEvent;
+import net.sourceforge.phpeclipse.xdebug.core.IProxyEventListener;
+import net.sourceforge.phpeclipse.xdebug.core.PathMapItem;
 import net.sourceforge.phpeclipse.xdebug.core.XDebugCorePlugin;
-import net.sourceforge.phpeclipse.xdebug.core.DebugConnection.DebugResponse;
+import net.sourceforge.phpeclipse.xdebug.core.XDebugProxy;
 import net.sourceforge.phpeclipse.xdebug.php.launching.IXDebugConstants;
 
 import org.eclipse.core.resources.IMarker;
 import org.eclipse.core.resources.IMarkerDelta;
 import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
 import org.eclipse.debug.core.DebugEvent;
 import org.eclipse.debug.core.DebugException;
 import org.eclipse.debug.core.DebugPlugin;
 import org.eclipse.debug.core.IDebugEventSetListener;
 import org.eclipse.debug.core.ILaunch;
+
+import org.eclipse.debug.core.ILaunchListener;
+
 import org.eclipse.debug.core.model.IBreakpoint;
 import org.eclipse.debug.core.model.IDebugTarget;
-import org.eclipse.debug.core.model.ILineBreakpoint;
 import org.eclipse.debug.core.model.IMemoryBlock;
 import org.eclipse.debug.core.model.IProcess;
 import org.eclipse.debug.core.model.IStackFrame;
 import org.eclipse.debug.core.model.IThread;
 import org.eclipse.debug.core.model.IValue;
-import org.w3c.dom.Node;
-import org.w3c.dom.NodeList;
+import org.eclipse.debug.core.model.IVariable;
+
+import net.sourceforge.phpeclipse.xdebug.core.xdebug.ResponseListener.DebugResponse;
 
 /**
  * @author Christian
- * 
+ *
  */
-public class XDebugTarget extends XDebugElement implements IDebugTarget,
-		IDebugEventSetListener {
+public class XDebugTarget extends XDebugElement implements IDebugTarget, ILaunchListener, IDebugEventSetListener, IProxyEventListener{
 	// associated system process (VM)
 	private IProcess fProcess;
-
+	
 	// containing launch object
 	private ILaunch fLaunch;
-
+	
 	// debugPort
 	private int fDebugPort;
-
-	// program name
-	// private String fName;
-
+	
 	// suspend state
-	private boolean fSuspended = true;
-
+	private boolean fSuspended = false;
+	
 	// terminated state
 	private boolean fTerminated = false;
-
+	
 	// threads
 	private XDebugThread fThread;
-
 	private IThread[] fThreads;
+	
+	private AbstractDebugConnection fDebugConnection;
 
-	// event dispatch job
-	// private EventDispatchJob fEventDispatch;
+	private String fIdeKey;
 
-	private DebugConnection fDebugConnection;
 
-	// private DebugResponse lastResponse;
+	public XDebugTarget() {
+		super(null);
+	}
 
 	/**
-	 * Constructs a new debug target in the given launch for the associated PDA
-	 * VM process.
+	 * Constructs a new debug target in the given launch and waits until
+	 * someone with the ideKey connects to the Debugproxy
+	 *  
 	 * 
-	 * @param launch
-	 *            containing launch
-	 * @param debugPort
-	 *            port to read events from
-	 * @exception CoreException
-	 *                if unable to connect to host
-	 */
-	public XDebugTarget(ILaunch launch, IProcess process, int debugPort)
-			throws CoreException {
+	 * @param launch containing launch
+	 * @param process process of the interpreter
+	 * @param ideKey 
+	 * @exception CoreException if unable to connect to host
+	 */
+	
+	public XDebugTarget(ILaunch launch, IProcess process, String ideKey) throws CoreException {
+		init(launch, process, ideKey);
+	}
+
+	/**
+	 * Constructs a new debug target in the given launch and waits until
+	 * someone with the ideKey connects to the Debugproxy
+	 *  
+	 * 
+	 * @param launch containing launch
+	 * @param process process of the interpreter
+	 * @param ideKey 
+	 * @param pathMap Pathmap for the debug session
+	 * @exception CoreException if unable to connect to host
+	 */
+	
+	/*public XDebugTarget(ILaunch launch, IProcess process, String ideKey, List<String> pathMap) throws CoreException {
 		super(null);
+		init(launch, process, ideKey,pathMap);
+	}*/
+	
+	private void init(ILaunch launch, IProcess process, String ideKey/*,List<String> pathMap*/) {
 		fLaunch = launch;
 		fProcess = process;
 		fTarget = this;
-		fDebugConnection = new DebugConnection(this, debugPort);
-		fThread = new XDebugThread(this);
-		fThreads = new IThread[] { fThread };
-		DebugPlugin.getDefault().getBreakpointManager().addBreakpointListener(
-				this);
+		fDebugConnection = null;
+		fThread = null;
+		fThreads = new IThread[0];
+		fIdeKey = ideKey;
+		
+		XDebugProxy proxy = XDebugCorePlugin.getDefault().getXDebugProxy();
+		proxy.addProxyEventListener(this,ideKey);
+		if (!proxy.isRunning())
+			proxy.start();
+		
+		proxy.setTarget(this);
+
+		fDebugPort = proxy.getProxyPort();
+		
+		DebugPlugin.getDefault().getBreakpointManager().addBreakpointListener(this);
 		DebugPlugin.getDefault().addDebugEventListener(this);
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * 
+	/* (non-Javadoc)
 	 * @see org.eclipse.debug.core.model.IDebugTarget#getProcess()
 	 */
 	public IProcess getProcess() {
 		return fProcess;
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * 
+	/* (non-Javadoc)
 	 * @see org.eclipse.debug.core.model.IDebugTarget#getThreads()
 	 */
 	public IThread[] getThreads() throws DebugException {
 		return fThreads;
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * 
+	/* (non-Javadoc)
 	 * @see org.eclipse.debug.core.model.IDebugTarget#hasThreads()
 	 */
 	public boolean hasThreads() throws DebugException {
-		return (fThreads.length > 0);
+		return (fThreads.length>0);
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * 
+	/* (non-Javadoc)
 	 * @see org.eclipse.debug.core.model.IDebugTarget#getName()
 	 */
 	public String getName() throws DebugException {
 		return "PHP XDebug Client at localhost:" + fDebugPort;
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * 
+	/* (non-Javadoc)
 	 * @see org.eclipse.debug.core.model.IDebugTarget#supportsBreakpoint(org.eclipse.debug.core.model.IBreakpoint)
 	 */
 	public boolean supportsBreakpoint(IBreakpoint breakpoint) {
-		if (breakpoint.getModelIdentifier().equals(
-				IXDebugConstants.ID_PHP_DEBUG_MODEL)) {
+		if (breakpoint.getModelIdentifier().equals(IXDebugConstants.ID_PHP_DEBUG_MODEL)) {
 			return true;
 		}
 		return false;
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * 
+	/* (non-Javadoc)
 	 * @see org.eclipse.debug.core.model.IDebugElement#getDebugTarget()
 	 */
 	public IDebugTarget getDebugTarget() {
 		return this;
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * 
+	/* (non-Javadoc)
 	 * @see org.eclipse.debug.core.model.IDebugElement#getLaunch()
 	 */
 	public ILaunch getLaunch() {
 		return fLaunch;
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * 
+	/* (non-Javadoc)
 	 * @see org.eclipse.debug.core.model.ITerminate#canTerminate()
 	 */
 	public boolean canTerminate() {
-		return getProcess().canTerminate();
-		// return false;
+		if (getProcess()!=null)  // ther is no running Process in remote debugging
+			return getProcess().canTerminate();
+		return true;
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * 
+	/* (non-Javadoc)
 	 * @see org.eclipse.debug.core.model.ITerminate#isTerminated()
 	 */
 	public boolean isTerminated() {
-		// return getProcess().isTerminated();
+//		return getProcess().isTerminated();
 		return fTerminated;
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * 
+	/* (non-Javadoc)
 	 * @see org.eclipse.debug.core.model.ITerminate#terminate()
 	 */
 	public void terminate() throws DebugException {
-		fDebugConnection.sendRequest("stop");
+		//IThread  t = fThreads.length();
+		//fTerminated=true;
+		XDebugProxy proxy=XDebugCorePlugin.getDefault().getXDebugProxy();
+		proxy.stop();
+		proxy.removeProxyEventListener(this,fIdeKey);
+		System.out.println("XDebug.Target: ProxyEventlistener removed");
+		fTerminated = true;
+		//fDisconnected = true;
+		fSuspended = false;
+		XDebugCorePlugin.getBreakpointManager().removeBreakpointListener(this);
+		fireTerminateEvent();
+		DebugPlugin.getDefault().removeDebugEventListener(this);
+		if (fThread!=null)
+			fThread.removeEventListeners();
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * 
+	/* (non-Javadoc)
 	 * @see org.eclipse.debug.core.model.ISuspendResume#canResume()
 	 */
 	public boolean canResume() {
-		return !isTerminated() && isSuspended();
+//		return !isTerminated() && isSuspended();
+		return false;
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * 
+	/* (non-Javadoc)
 	 * @see org.eclipse.debug.core.model.ISuspendResume#canSuspend()
 	 */
 	public boolean canSuspend() {
-		return !isTerminated() && !isSuspended();
+//		return !isTerminated() && !isSuspended();
+		return false;
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * 
+	/* (non-Javadoc)
 	 * @see org.eclipse.debug.core.model.ISuspendResume#isSuspended()
 	 */
 	public boolean isSuspended() {
 		return fSuspended;
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * 
+	/* (non-Javadoc)
 	 * @see org.eclipse.debug.core.model.ISuspendResume#resume()
 	 */
 	public void resume() throws DebugException {
-		fDebugConnection.sendRequest("run");
+		if (fDebugConnection != null) {
+			fThread.setBreakpoints(null);
+			fDebugConnection.run();
+		}			
 	}
-
+	
 	/**
 	 * Notification the target has resumed for the given reason
 	 * 
-	 * @param detail
-	 *            reason for the resume
+	 * @param detail reason for the resume
 	 */
 	private void resumed(int detail) {
 		fSuspended = false;
 		fThread.fireResumeEvent(detail);
 	}
-
+	
 	/**
 	 * Notification the target has suspended for the given reason
 	 * 
-	 * @param detail
-	 *            reason for the suspend
+	 * @param detail reason for the suspend
 	 */
 	public void suspended(int detail) {
 		fSuspended = true;
 		fThread.fireSuspendEvent(detail);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
+	}	
+	
+	/* (non-Javadoc)
 	 * @see org.eclipse.debug.core.model.ISuspendResume#suspend()
 	 */
 	public void suspend() throws DebugException {
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * 
+	/* (non-Javadoc)
 	 * @see org.eclipse.debug.core.IBreakpointListener#breakpointAdded(org.eclipse.debug.core.model.IBreakpoint)
 	 */
 	public void breakpointAdded(IBreakpoint breakpoint) {
+		IMarker marker = breakpoint.getMarker();
+		IPath path = marker.getResource().getLocation();
+		IPath cp = path.removeLastSegments(1);
+		List pathMap = null;
+		try {
+			pathMap = fLaunch.getLaunchConfiguration().getAttribute(IXDebugConstants.ATTR_PHP_PATHMAP,(List)null);
+		} catch (CoreException e2) {
+			// TODO Auto-generated catch block
+			e2.printStackTrace();
+		}
 
-		if (supportsBreakpoint(breakpoint)) {
-			try {
-				if (breakpoint.isEnabled()) {
-					IMarker marker = breakpoint.getMarker();
-					if (marker != null) {
-						try {
-							String fileName = PHPDebugUtils.escapeString(marker
-									.getResource().getLocation().toString());
-							String arg = "-t line -f file:///"
-									+ fileName
-									+ " -n "
-									+ ((ILineBreakpoint) breakpoint)
-											.getLineNumber();
-							int id = fDebugConnection.sendRequest(
-									"breakpoint_set", arg);
-							// set the marker Attribute to make later
-							// idetification possible
-							// TODO: make sure that attribute is set before
-							// response from debugger is beeing prosessed
-							marker.setAttribute(
-									XDebugLineBreakpoint.BREAKPOINT_ID, id);
-
-						} catch (CoreException e) {
+		if (!fDebugConnection.isClosed()) {
+			if (fProcess == null) {
+				PathMapItem pmi = null;
+				for (int i = 0; i < pathMap.size(); i++) {
+					pmi = new PathMapItem((String) pathMap.get(i));
+					IPath local = (IPath)pmi.getLocalPath().clone();
+					local = local./*removeFirstSegments(1).*/makeAbsolute();
+					int matchedSegments = local.segmentCount();
+					if (local.matchingFirstSegments(cp) == matchedSegments) {
+						IPath newPath = pmi.getRemotePath();
+						//newPath = newPath.removeFirstSegments(1);						
+						newPath = newPath.append(path.removeFirstSegments(matchedSegments));
+						newPath = newPath.makeAbsolute();
+						if (supportsBreakpoint(breakpoint)) {
+							try {
+								fDebugConnection.addBreakpoint(breakpoint, newPath);
+							} catch (DebugException e) {
+								e.printStackTrace();
+							}
 						}
 					}
+				}			
+			} else {
+				if (supportsBreakpoint(breakpoint)) {
+					try {
+						fDebugConnection.addBreakpoint(breakpoint, path);
+					} catch (DebugException e) {
+						e.printStackTrace();
+					}
 				}
-			} catch (CoreException e) {
-
 			}
 		}
 	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.debug.core.IBreakpointListener#breakpointRemoved(org.eclipse.debug.core.model.IBreakpoint,
-	 *      org.eclipse.core.resources.IMarkerDelta)
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.debug.core.IBreakpointListener#breakpointRemoved(org.eclipse.debug.core.model.IBreakpoint, org.eclipse.core.resources.IMarkerDelta)
 	 */
 	public void breakpointRemoved(IBreakpoint breakpoint, IMarkerDelta delta) {
 		if (supportsBreakpoint(breakpoint)) {
 			try {
-				int id = ((XDebugLineBreakpoint) breakpoint).getID();
-				if (id > 0)
-					fDebugConnection.sendRequest("breakpoint_remove", "-d "
-							+ id);
+				fDebugConnection.removeBreakpoint(breakpoint);
 			} catch (CoreException e) {
 			}
 		}
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.debug.core.IBreakpointListener#breakpointChanged(org.eclipse.debug.core.model.IBreakpoint,
-	 *      org.eclipse.core.resources.IMarkerDelta)
+	/* (non-Javadoc)
+	 * @see org.eclipse.debug.core.IBreakpointListener#breakpointChanged(org.eclipse.debug.core.model.IBreakpoint, org.eclipse.core.resources.IMarkerDelta)
 	 */
 	public void breakpointChanged(IBreakpoint breakpoint, IMarkerDelta delta) {
-		// if (supportsBreakpoint(breakpoint)) {
-		// try {
-		// if (breakpoint.isEnabled()) {
-		// breakpointAdded(breakpoint);
-		// } else {
-		// breakpointRemoved(breakpoint, null);
-		// }
-		// } catch (CoreException e) {
-		// }
-		// }
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
+//		if (supportsBreakpoint(breakpoint)) {
+//			try {
+//				if (breakpoint.isEnabled()) {
+//					breakpointAdded(breakpoint);
+//				} else {
+//					breakpointRemoved(breakpoint, null);
+//				}
+//			} catch (CoreException e) {
+//			}
+//		}
+	}
+
+	/* (non-Javadoc)
 	 * @see org.eclipse.debug.core.model.IDisconnect#canDisconnect()
 	 */
 	public boolean canDisconnect() {
 		return false;
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * 
+	/* (non-Javadoc)
 	 * @see org.eclipse.debug.core.model.IDisconnect#disconnect()
 	 */
 	public void disconnect() throws DebugException {
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * 
+	/* (non-Javadoc)
 	 * @see org.eclipse.debug.core.model.IDisconnect#isDisconnected()
 	 */
 	public boolean isDisconnected() {
-		return false;
+		return (fDebugConnection==null);
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * 
+	/* (non-Javadoc)
 	 * @see org.eclipse.debug.core.model.IMemoryBlockRetrieval#supportsStorageRetrieval()
 	 */
 	public boolean supportsStorageRetrieval() {
 		return false;
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.debug.core.model.IMemoryBlockRetrieval#getMemoryBlock(long,
-	 *      long)
+	/* (non-Javadoc)
+	 * @see org.eclipse.debug.core.model.IMemoryBlockRetrieval#getMemoryBlock(long, long)
 	 */
-	public IMemoryBlock getMemoryBlock(long startAddress, long length)
-			throws DebugException {
+	public IMemoryBlock getMemoryBlock(long startAddress, long length) throws DebugException {
 		return null;
 	}
 
 	/**
-	 * Notification we have connected to the PHP debugger and it has started.
+	 * Notification we have connected to the PHP debugger and it has been started.
 	 * Resume the the debugger.
 	 */
-	public void started() {
-
+	public void started() throws DebugException {
 		fThread.setBreakpoints(null);
 		fThread.setStepping(false);
 
+		/*boolean CanDisconnect =*/ Integer.parseInt(fDebugConnection.featureGet("detach").getValue()) /*!= 0*/;
+
+		System.out.println("in Target.started()");
+		DebugResponse response = fDebugConnection.featureGet("max_children");
+		String a1 = response.getValue();
+		System.out.println("max children:"+a1);
+		DebugResponse response1 = fDebugConnection.featureGet("max_children");
+		String a2 = response1.getValue();
+		System.out.println("max depth:"+a2);
+		
+		
+		boolean res = fDebugConnection.featureSet("max_depth", "100" );
+		if( res == true ) {
+			System.out.println("Set depth to 100 (hack)");
+		}
+		
 		installDeferredBreakpoints();
 		try {
 			resume();
-			// step();
+//			step();
 		} catch (DebugException e) {
+			e.printStackTrace();
 		}
 	}
-
+	
 	/**
 	 * Install breakpoints that are already registered with the breakpoint
 	 * manager.
@@ -401,7 +426,7 @@ public class XDebugTarget extends XDebugElement implements IDebugTarget,
 			breakpointAdded(breakpoints[i]);
 		}
 	}
-
+	
 	/**
 	 * Called when this debug target terminates.
 	 */
@@ -411,228 +436,181 @@ public class XDebugTarget extends XDebugElement implements IDebugTarget,
 		XDebugCorePlugin.getBreakpointManager().removeBreakpointListener(this);
 		fireTerminateEvent();
 		DebugPlugin.getDefault().removeDebugEventListener(this);
-		fThread.removeEventListeners();
+		fThread.removeEventListeners();	
 	}
-
+	
 	/**
 	 * Returns the current stack frames in the target.
 	 * 
 	 * @return the current stack frames in the target
-	 * @throws DebugException
-	 *             if unable to perform the request
+	 * @throws DebugException if unable to perform the request
 	 */
 	protected IStackFrame[] getStackFrames() throws DebugException {
-		int id = fDebugConnection.sendRequest("stack_get");
-		DebugResponse lastResponse = fDebugConnection.waitforTransID(id);
-		if (lastResponse.isError())
-			return new IStackFrame[0];
-		Node response = lastResponse.getParentNode();
-		NodeList frames = response.getChildNodes();
-		IStackFrame[] theFrames = new IStackFrame[frames.getLength()];
-		for (int i = 0; i < frames.getLength(); i++) {
-			Node stackNode = frames.item(i);
-			theFrames[i] = new XDebugStackFrame(fThread, stackNode, i);
-		}
-		return theFrames;
+		return fDebugConnection.getStackFrames(fThread);
 	}
-
+	
 	/**
 	 * Single step the interpreter.
 	 * 
-	 * @throws DebugException
-	 *             if the request fails
+	 * @throws DebugException if the request fails
 	 */
 	protected void step_over() throws DebugException {
 		fThread.setStepping(true);
 		resumed(DebugEvent.STEP_OVER);
-		fDebugConnection.sendRequest("step_over");
+		fDebugConnection.stepOver();
 	}
-
+	
 	/**
 	 * Single step the interpreter.
 	 * 
-	 * @throws DebugException
-	 *             if the request fails
+	 * @throws DebugException if the request fails
 	 */
 	protected void step_into() throws DebugException {
 		fThread.setStepping(true);
 		resumed(DebugEvent.STEP_INTO);
-		fDebugConnection.sendRequest("step_into");
+		fDebugConnection.stepInto();
 	}
-
+	
 	/**
 	 * Single step the interpreter.
 	 * 
-	 * @throws DebugException
-	 *             if the request fails
+	 * @throws DebugException if the request fails
 	 */
 	protected void step_out() throws DebugException {
 		fThread.setStepping(true);
 		resumed(DebugEvent.STEP_RETURN);
-		fDebugConnection.sendRequest("step_out");
+		fDebugConnection.stepOut();
 	}
-
+	
 	/**
 	 * Returns the current value of the given variable.
 	 * 
 	 * @param variable
 	 * @return variable value
-	 * @throws DebugException
-	 *             if the request fails
-	 */
-	protected IValue getVariableValue(XDebugVariable variable)
-			throws DebugException {
-		// synchronized (fDebugSocket) {
-		// fDebugConnection.sendRequest("var","" +
-		// variable.getStackFrame().getIdentifier() + " " + variable.getName());
-		// try {
-		// String value = fDebugReader.readLine();
-		// //return new XDebugValue(this, value);
-		//				
-		// } catch (IOException e) {
-		// abort(MessageFormat.format("Unable to retrieve value for variable
-		// {0}", new String[]{variable.getName()}), e);
-		// }
-		// }
+	 * @throws DebugException if the request fails
+	 */
+	protected IValue getVariableValue(XDebugVariable variable) throws DebugException {
 		return null;
 	}
-
+	
 	/**
 	 * Returns the values on the data stack (top down)
 	 * 
 	 * @return the values on the data stack (top down)
 	 */
 	public IValue[] getDataStack() throws DebugException {
-		// synchronized (fDebugSocket) {
-		// fDebugConnection.sendRequest ("data");
-		// try {
-		// String valueString = fDebugReader.readLine();
-		// if (valueString != null && valueString.length() > 0) {
-		// String[] values = valueString.split("\\|");
-		// IValue[] theValues = new IValue[values.length];
-		// for (int i = 0; i < values.length; i++) {
-		// String value = values[values.length - i - 1];
-		// // theValues[i] = new XDebugValue(this, value);
-		// }
-		// return theValues;
-		// }
-		// } catch (IOException e) {
-		// abort("Unable to retrieve data stack", e);
-		// }
-		// }
-		return new IValue[0];
+		return new IValue[0];		
 	}
-
+	
 	public boolean setVarValue(String name, String value) {
-		int id = -1;
-		String str = Base64.encodeBytes(value.getBytes());
-		int len = str.length();
-
-		try {
-			id = fDebugConnection.sendRequest("property_set", "-n " + name
-					+ " -l " + len + " -- " + str);
-		} catch (DebugException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
+		return fDebugConnection.setVarValue(name,value);
+	}
+	
+	public void handleDebugEvents(DebugEvent[] events) {
+		for (int i=0;i<events.length;i++) {
+			DebugEvent event=events[i];
+			if(event.getKind()==DebugEvent.MODEL_SPECIFIC) {
+				if (event.getDetail()==IPHPDebugEvent.BREAKPOINT_HIT) {
+					IBreakpoint breakpoint = (IBreakpoint) event.getData();
+					fThread.setBreakpoints(new IBreakpoint[]{breakpoint});
+					fThread.incrementStepCounter();
+					suspended(DebugEvent.BREAKPOINT);
+				} else if (event.getDetail()==IPHPDebugEvent.STEP_END) {
+					fThread.incrementStepCounter();
+					suspended(DebugEvent.STEP_END);
+				} else if (event.getDetail()==IPHPDebugEvent.STOPPED) {
+					//fDebugConnection.removeBreakpoint(breakpoint);
+					fThread.removeEventListeners();
+					fThread=null;
+					fThreads= new IThread[0];
+					fSuspended=false;
+					// TODO Dirty hack to check debugging mode (remote or local)
+					if (fProcess!=null) {
+						try {
+							terminate();
+						} catch (DebugException e) {
+							e.printStackTrace();
+						}
+					} else {
+						fDebugConnection = null;
+						fireEvent(new DebugEvent(this, DebugEvent.CHANGE, DebugEvent.CONTENT));
+					}
+				} else {
+					int a = 20;
+					a *= 10;
+				}
+			} else {
+				int b = 10;
+				b *= 1;
+			}
 		}
-		DebugResponse dr = getResponse(id);
-		if ((dr.getAttributeValue("success")).equals("1"))
-			return true;
-
-		return false;
+		
+	}
+	
+	public void handleProxyEvent(String ideKey, String initString, AbstractDebugConnection connection) {
+		System.out.println("* New Connection - XDebug.Target: "+ideKey);
+		setDebugConnection(connection);
+		
+		XDebugProxy proxy=XDebugCorePlugin.getDefault().getXDebugProxy();
+		fDebugPort=proxy.getProxyPort();
+		fireEvent(new DebugEvent(this, DebugEvent.CHANGE, DebugEvent.CHANGE));
+
+		
+//		proxy.removeProxyEventListener(this,ideKey);
+//		System.out.println("XDebug.Target: ProxyEventlistener removed");
+		fThread = new XDebugThread(this);
+		fThreads = new IThread[] {fThread};
+		try {
+			started();
+		} catch( DebugException e ){
+			e.printStackTrace();		
+		}		
 	}
 
-	public DebugResponse getResponse(int id) {
-		return fDebugConnection.waitforTransID(id);
+	private void setDebugConnection(AbstractDebugConnection connection) {
+		if (connection != null) {
+			fDebugConnection = connection;
+			fDebugConnection.startListener();
+		}
 	}
-
+	
 	/**
-	 * Sends a request to the Debugengine and waits for an OK.
-	 * 
-	 * @param command
-	 *            debug command
-	 * @throws DebugException
-	 *             if the request fails
+	 * @return Returns the fDebugConnection.
 	 */
+	public IDebugConnection getDebugConnection() {
+		return fDebugConnection;
+	}	
+	
+	public void addProcess(IProcess p) {
+		fProcess = p;
+
+	}
 
-	public int sendRequest(String command) throws DebugException {
-		return fDebugConnection.sendRequest(command, "");
+	public void launchRemoved(ILaunch launch) {
 	}
 
 	/**
-	 * Sends a request to the Debugengine and waits for an OK.
+	 * Notifies this listener that the specified launch
+	 * has been added.
 	 * 
-	 * @param command
-	 *            debug command
-	 * @arguments arguments for the command
-	 * @throws DebugException
-	 *             if the request fails
+	 * @param launch the newly added launch
+	 * @since 2.0
 	 */
-
-	public int sendRequest(String command, String arguments)
-			throws DebugException {
-		return fDebugConnection.sendRequest(command, arguments);
+	public void launchAdded(ILaunch launch){
 	}
 
 	/**
-	 * Notification a breakpoint was encountered. Determine which breakpoint was
-	 * hit and fire a suspend event.
+	 * Notifies this listener that the specified launch
+	 * has changed. For example, a process or debug target
+	 * has been added to the launch.
 	 * 
-	 * @param event
-	 *            debug event
-	 */
-	public void breakpointHit(Node node) {
-		// determine which breakpoint was hit, and set the thread's breakpoint
-		Node child = node.getFirstChild();
-		if (child.getNodeName().equals("stack")) {
-			int lineNumber = Integer.parseInt(PHPDebugUtils.getAttributeValue(
-					child, "lineno"));
-			String filename = PHPDebugUtils
-					.getAttributeValue(child, "filename").substring(8); // remove
-																		// file:///
-			IBreakpoint[] breakpoints = XDebugCorePlugin.getBreakpoints();
-			for (int i = 0; i < breakpoints.length; i++) {
-				IBreakpoint breakpoint = breakpoints[i];
-				if (supportsBreakpoint(breakpoint)) {
-					if (breakpoint instanceof ILineBreakpoint) {
-						ILineBreakpoint lineBreakpoint = (ILineBreakpoint) breakpoint;
-						try {
-							if (breakpoint.isEnabled()) {
-								IMarker marker = breakpoint.getMarker();
-								if (marker != null) {
-
-									String name = marker.getResource()
-											.getLocation().toOSString();
-									if (name.equals(PHPDebugUtils
-											.unescapeString(filename))
-											&& (lineBreakpoint.getLineNumber() == lineNumber)) {
-										fThread
-												.setBreakpoints(new IBreakpoint[] { breakpoint });
-										break;
-									}
-								}
-
-							}
-						} catch (CoreException e) {
-						}
-					}
-				}
-			}
-		}
-		suspended(DebugEvent.BREAKPOINT);
+	 * @param launch the changed launch
+	 * @since 2.0
+	 */
+	public void launchChanged(ILaunch launch) {
 	}
-
-	public void handleDebugEvents(DebugEvent[] events) {
-		for (int i = 0; i < events.length; i++) {
-			DebugEvent event = events[i];
-			if ((event.getKind() == DebugEvent.CREATE)
-					&& (event.getSource() instanceof XDebugElement)) {
-				if (((XDebugElement) event.getSource()).getModelIdentifier() == IXDebugConstants.ID_PHP_DEBUG_MODEL) {
-					if (event.getKind() == DebugEvent.CREATE)
-						started();
-				}
-			}
-		}
-
+	
+	public IVariable[] getVariables(XDebugStackFrame StackFrame, int Level) {
+		return fDebugConnection.getVariables(StackFrame, Level);
 	}
 }
\ No newline at end of file