public override void CopyFrom (BreakEvent ev)
		{
			base.CopyFrom (ev);
			
			FunctionBreakpoint bp = (FunctionBreakpoint) ev;
			FunctionName = bp.FunctionName;
		}

		public override void CopyFrom (BreakEvent ev)
		{
			base.CopyFrom (ev);
			Catchpoint cp = (Catchpoint) ev;
			exceptionName = cp.exceptionName;
			includeSubclasses = cp.includeSubclasses;
		}

		internal void AttachSession (DebuggerSession s, BreakEvent ev)
		{
			session = s;
			BreakEvent = ev;
			session.NotifyBreakEventStatusChanged (BreakEvent);
			if (adjustedLine != -1)
				session.AdjustBreakpointLocation ((Breakpoint)BreakEvent, adjustedLine);
		}

		public override void CopyFrom (BreakEvent ev)
		{
			base.CopyFrom (ev);
			
			Breakpoint bp = (Breakpoint) ev;
			
			breakIfConditionChanges = bp.breakIfConditionChanges;
			conditionExpression = bp.conditionExpression;
			fileName = bp.fileName;
			column = bp.column;
			line = bp.line;
		}

		protected override object OnInsertBreakEvent (BreakEvent be, bool activate)
		{
			lock (documents) {
				Breakpoint bp = be as Breakpoint;
				if (bp != null) {
					DocInfo doc;
					if (!documents.TryGetValue (System.IO.Path.GetFullPath (bp.FileName), out doc))
						return null;

					int line;
                    try {
                        line = doc.Document.FindClosestLine(bp.Line);
                    }
                    catch {
                        // Invalid line
                        return null;
                    }
					ISymbolMethod met = doc.Reader.GetMethodFromDocumentPosition (doc.Document, line, 0);
					if (met == null)
						return null;

					int offset = -1;
					foreach (SequencePoint sp in met.GetSequencePoints ()) {
						if (sp.Line == line && sp.Document.URL == doc.Document.URL) {
							offset = sp.Offset;
							break;
						}
					}
					if (offset == -1)
						return null;

					CorFunction func = doc.Module.GetFunctionFromToken (met.Token.GetToken ());
					CorFunctionBreakpoint corBp = func.ILCode.CreateBreakpoint (offset);
					corBp.Activate (activate);
					return corBp;
				}
			}
			return null;
		}

		BreakInfo GetBreakInfo (BreakEvent be)
		{
			object bi;
			if (GetBreakpointHandle (be, out bi))
				return (BreakInfo) bi;
			else
				return null;
		}

		public BreakpointPropertiesDialog (BreakEvent be, BreakpointType breakpointType)
		{
			this.be = be;
			LoadExceptionList ();
			Initialize ();
			SetInitialData ();
			SetLayout ();
			if (be == null) {
				switch (breakpointType) {
				case BreakpointType.Location:
					stopOnLocation.Active = true;
					entryLocationFile.SetFocus ();
					break;
				case BreakpointType.Function:
					stopOnFunction.Active = true;
					entryFunctionName.SetFocus ();
					break;
				case BreakpointType.Catchpoint:
					stopOnException.Active = true;
					entryExceptionType.SetFocus ();
					break;
				}
			}
		}

		void UpdateBreakEvent (BreakEvent be)
		{
			lock (breakpoints) {
				BreakEventInfo binfo;
				if (breakpoints.TryGetValue (be, out binfo))
					OnUpdateBreakEvent (binfo);
			}
		}

		bool RemoveBreakEvent (BreakEvent be)
		{
			lock (breakpoints) {
				BreakEventInfo binfo;
				if (breakpoints.TryGetValue (be, out binfo)) {
					try {
						OnRemoveBreakEvent (binfo);
					} catch (Exception ex) {
						if (started)
							OnDebuggerOutput (false, ex.Message);
						HandleException (ex);
						return false;
					}
					breakpoints.Remove (be);
				}
				return true;
			}
		}

		protected override object OnUpdateBreakEvent (object handle, BreakEvent be)
		{
			return controller.DebuggerServer.UpdateBreakEvent (handle, be);
		}

		//breakpoints etc

		// returns a handle
		protected override object OnInsertBreakEvent (BreakEvent be, bool activate)
		{
			return controller.DebuggerServer.InsertBreakEvent (be, activate);
		}

        protected override BreakEventInfo OnInsertBreakEvent(BreakEvent be)
        {
            LogWriter(false, "Break inserted\n");
            Breakpoint bp = be as Breakpoint;
            if (bp == null)
                throw new NotSupportedException ();

            BreakEventInfo bi = new BreakEventInfo ();

            //lock (debuggerLock) {
                LogWriter(false, "Location is " + PathHelper.CutOffClassPath(classPathes, bp.FileName) + ":" + bp.Line + '\n');
                breaks.Add (new Break (PathHelper.CutOffClassPath (classPathes, bp.FileName), bp.Line));
            //}

            //bi.Handle = TODO: add returned success value (break count etc)
            bi.SetStatus (BreakEventStatus.Bound, null);
            return bi;
        }

		protected bool GetBreakpointHandle (BreakEvent be, out object handle)
		{
			BreakEventInfo binfo;
			if (!breakpoints.TryGetValue (be, out binfo)) {
				handle = null;
				return false;
			}
			handle = binfo.Handle;
			return true;
		}

		void UpdateBreakEvent (BreakEvent be)
		{
			lock (breakpoints) {
				object handle;
				if (GetBreakpointHandle (be, out handle)) {
					if (handle != null) {
						object newHandle = OnUpdateBreakEvent (handle, be);
						if (newHandle != handle && (newHandle == null || !newHandle.Equals (handle))) {
							// Update the handle if it has changed, and notify the status change
							SetBreakEventHandle (be, newHandle);
						}
						Breakpoints.NotifyStatusChanged (be);
					} else {
						// Try inserting the breakpoint again
						try {
							handle = OnInsertBreakEvent (be, be.Enabled);
							if (handle != null) {
								// This time worked
								SetBreakEventHandle (be, handle);
								Breakpoints.NotifyStatusChanged (be);
							}
						} catch (Exception ex) {
							Breakpoint bp = be as Breakpoint;
							if (bp != null)
								OnDebuggerOutput (false, "Could not set breakpoint at location '" + bp.FileName + ":" + bp.Line + " (" + ex.Message + ")\n");
							else
								OnDebuggerOutput (false, "Could not set catchpoint for exception '" + ((Catchpoint)be).ExceptionName + "' (" + ex.Message + ")\n");
							HandleException (ex);
						}
					}
				}
			}
		}

		void UpdateBreakEventStatus (BreakEvent be)
		{
			lock (breakpoints) {
				object handle;
				if (GetBreakpointHandle (be, out handle) && handle != null) {
					try {
						OnEnableBreakEvent (handle, be.Enabled);
					} catch (Exception ex) {
						if (started)
							OnDebuggerOutput (false, ex.Message);
						HandleException (ex);
					}
				}
			}
		}

		/// <summary>
		/// Returns a status message of a breakpoint for this debugger session.
		/// </summary>
		public string GetBreakEventStatusMessage (BreakEvent be)
		{
			if (started) {
				BreakEventInfo binfo;
				lock (breakpoints) {
					if (breakpoints.TryGetValue (be, out binfo)) {
						if (binfo.StatusMessage != null)
							return binfo.StatusMessage;
						switch (binfo.Status) {
						case BreakEventStatus.BindError: return "The breakpoint could not be bound";
						case BreakEventStatus.Bound: return "";
						case BreakEventStatus.Disconnected: return "";
						case BreakEventStatus.Invalid: return "The breakpoint location is invalid. Perhaps the source line does " +
							"not contain any statements, or the source does not correspond to the current binary";
						case BreakEventStatus.NotBound: return "The breakpoint could not yet be bound to a valid location";
						}
					}
				}
			}
			return "The breakpoint will not currently be hit";
		}

		void AddBreakEvent (BreakEvent be)
		{
			try {
				var eventInfo = OnInsertBreakEvent (be);
				if (eventInfo == null)
					throw new InvalidOperationException ("OnInsertBreakEvent can't return a null value. If the breakpoint can't be bound or is invalid, a BreakEventInfo with the corresponding status must be returned");
				lock (breakpoints) {
					breakpoints [be] = eventInfo;
				}
				eventInfo.AttachSession (this, be);
				
			} catch (Exception ex) {
				Breakpoint bp = be as Breakpoint;
				string msg;
				if (bp != null)
					msg = "Could not set breakpoint at location '" + bp.FileName + ":" + bp.Line + "'";
				else
					msg = "Could not set catchpoint for exception '" + ((Catchpoint)be).ExceptionName + "'";
				
				msg += " (" + ex.Message + ")";
				OnDebuggerOutput (false, msg + "\n");
				HandleException (ex);
				return;
			}
		}

		public override void CopyFrom (BreakEvent ev)
		{
			base.CopyFrom (ev);
			
			Breakpoint bp = (Breakpoint) ev;

			fileName = bp.fileName;
			column = bp.column;
			line = bp.line;
		}

		void UpdateBreakEventStatus (BreakEvent be)
		{
			lock (breakpoints) {
				BreakEventInfo binfo;
				if (breakpoints.TryGetValue (be, out binfo)) {
					try {
						OnEnableBreakEvent (binfo, be.Enabled);
					} catch (Exception ex) {
						if (started)
							OnDebuggerOutput (false, ex.Message);
						HandleException (ex);
					}
				}
			}
		}

		protected override BreakEventInfo OnInsertBreakEvent (BreakEvent be)
		{
			BreakEventInfo binfo = new BreakEventInfo ();

			lock (documents) {
				Breakpoint bp = be as Breakpoint;
				if (bp != null) {
					if (bp is FunctionBreakpoint) {
						// FIXME: implement breaking on function name
						binfo.SetStatus (BreakEventStatus.Invalid, null);
						return binfo;
					} else {
						DocInfo doc;
						if (!documents.TryGetValue (System.IO.Path.GetFullPath (bp.FileName), out doc)) {
							binfo.SetStatus (BreakEventStatus.NotBound, null);
							return binfo;
						}
						
						int line;
						try {
							line = doc.Document.FindClosestLine(bp.Line);
						}
						catch {
							// Invalid line
							binfo.SetStatus (BreakEventStatus.Invalid, null);
							return binfo;
						}
						ISymbolMethod met = doc.Reader.GetMethodFromDocumentPosition (doc.Document, line, 0);
						if (met == null) {
							binfo.SetStatus (BreakEventStatus.Invalid, null);
							return binfo;
						}
						
						int offset = -1;
						foreach (SequencePoint sp in met.GetSequencePoints ()) {
							if (sp.Line == line && sp.Document.URL == doc.Document.URL) {
								offset = sp.Offset;
								break;
							}
						}
						if (offset == -1) {
							binfo.SetStatus (BreakEventStatus.Invalid, null);
							return binfo;
						}
						
						CorFunction func = doc.Module.GetFunctionFromToken (met.Token.GetToken ());
						CorFunctionBreakpoint corBp = func.ILCode.CreateBreakpoint (offset);
						corBp.Activate (bp.Enabled);
						breakpoints[corBp] = binfo;
						
						binfo.Handle = corBp;
						binfo.SetStatus (BreakEventStatus.Bound, null);
						return binfo;
					}
				}
			}
			return null;
		}