Worked on breakpoints

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@216 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Service/WindowsDebugger.cs

@@ -315,13 +315,21 @@ namespace ICSharpCode.SharpDevelop.Services
 			debugger.ProcessExited           += new EventHandler<ProcessEventArgs>(ProcessExited);
 			debugger.IsDebuggingChanged      += new EventHandler<DebuggerEventArgs>(OnIsDebuggingChanged);
 			debugger.IsProcessRunningChanged += new EventHandler<DebuggerEventArgs>(DebuggerStateChanged);
-			debugger.BreakpointStateChanged  += new EventHandler<BreakpointEventArgs>(RestoreSharpdevelopBreakpoint);
-
-			DebuggerService.BreakPointAdded   += new EventHandler(RestoreNDebuggerBreakpoints);
-			DebuggerService.BreakPointRemoved += new EventHandler(RestoreNDebuggerBreakpoints);
-			DebuggerService.BreakPointChanged += new EventHandler(RestoreNDebuggerBreakpoints);
-
-			RestoreNDebuggerBreakpoints(this, EventArgs.Empty);
+			debugger.BreakpointStateChanged  += delegate (object sender, BreakpointEventArgs e) {
+				RestoreSharpdevelopBreakpoint(e.Breakpoint);
+			};
+			DebuggerService.BreakPointAdded   += delegate (object sender, BreakpointBookmarkEventArgs e) {
+				AddBreakpoint(e.BreakpointBookmark);
+			};
+			DebuggerService.BreakPointRemoved += delegate (object sender, BreakpointBookmarkEventArgs e) {
+				RemoveBreakpoint(e.BreakpointBookmark);
+			};
+			DebuggerService.BreakPointChanged += delegate (object sender, BreakpointBookmarkEventArgs e) {
+				RemoveBreakpoint(e.BreakpointBookmark);
+				AddBreakpoint(e.BreakpointBookmark);
+			};
+
+			RestoreNDebuggerBreakpoints();
 
 			isDebuggingCache = debugger.IsDebugging;
 			isProcessRunningCache = debugger.IsProcessRunning;
@@ -343,36 +351,43 @@ namespace ICSharpCode.SharpDevelop.Services
 			debugger.ProcessExited           -= new EventHandler<ProcessEventArgs>(ProcessExited);
 			debugger.IsDebuggingChanged      -= new EventHandler<DebuggerEventArgs>(OnIsDebuggingChanged);
 			debugger.IsProcessRunningChanged -= new EventHandler<DebuggerEventArgs>(DebuggerStateChanged);
-			debugger.BreakpointStateChanged  -= new EventHandler<BreakpointEventArgs>(RestoreSharpdevelopBreakpoint);
-
-			DebuggerService.BreakPointAdded   -= new EventHandler(RestoreNDebuggerBreakpoints);
-			DebuggerService.BreakPointRemoved -= new EventHandler(RestoreNDebuggerBreakpoints);
-			DebuggerService.BreakPointChanged -= new EventHandler(RestoreNDebuggerBreakpoints);
 			
 			if (Unload != null) {
 				Unload(this, null);	
 			}
 		}
-		#endregion		
-		
-		public void RestoreNDebuggerBreakpoints(object sender, EventArgs e)
+		#endregion
+
+		void AddBreakpoint(BreakpointBookmark breakpointBookmark)
+		{
+			SourcecodeSegment seg = new SourcecodeSegment(breakpointBookmark.FileName, breakpointBookmark.LineNumber + 1); 
+			Breakpoint b = debugger.AddBreakpoint(seg, breakpointBookmark.IsEnabled);
+			breakpointBookmark.Tag = b;
+		}
+
+		void RemoveBreakpoint(BreakpointBookmark breakpointBookmark)
+		{
+			Breakpoint b = breakpointBookmark.Tag as Breakpoint;
+			if (b != null) {
+				debugger.RemoveBreakpoint(b);
+			}
+		}
+
+		void RestoreNDebuggerBreakpoints()
 		{
 			debugger.ClearBreakpoints();
-			foreach (ICSharpCode.Core.Breakpoint b in DebuggerService.Breakpoints) {
-				DebuggerLibrary.Breakpoint newBreakpoint = debugger.AddBreakpoint(new SourcecodeSegment(b.FileName, b.LineNumber), b.IsEnabled);
-				b.Tag = newBreakpoint;
+			foreach (BreakpointBookmark b in DebuggerService.Breakpoints) {
+				AddBreakpoint(b);
 			}
 		}
 
-		public void RestoreSharpdevelopBreakpoint(object sender, BreakpointEventArgs e)
+		void RestoreSharpdevelopBreakpoint(Breakpoint breakpoint)
 		{
-			foreach (ICSharpCode.Core.Breakpoint sdBreakpoint in DebuggerService.Breakpoints) {
-				if (sdBreakpoint.Tag == e.Breakpoint) {
-					if (sdBreakpoint != null) {
-						sdBreakpoint.IsEnabled  = e.Breakpoint.Enabled;
-						sdBreakpoint.FileName   = e.Breakpoint.SourcecodeSegment.SourceFullFilename;
-						sdBreakpoint.LineNumber = e.Breakpoint.SourcecodeSegment.StartLine;
-					}
+			foreach (BreakpointBookmark sdBreakpoint in DebuggerService.Breakpoints) {
+				if (sdBreakpoint.Tag == breakpoint) {
+					sdBreakpoint.IsEnabled  = breakpoint.Enabled;
+					sdBreakpoint.FileName   = breakpoint.SourcecodeSegment.SourceFullFilename;
+					sdBreakpoint.LineNumber = breakpoint.SourcecodeSegment.StartLine - 1;
 				}
 			}
 		}

src/Main/Base/Project/ICSharpCode.SharpDevelop.csproj

@@ -56,8 +56,8 @@
     <Compile Include="Src\Internal\Undo\IUndoableOperation.cs" />
     <Compile Include="Src\Internal\Undo\UndoQueue.cs" />
     <Compile Include="Src\Internal\Undo\UndoStack.cs" />
-    <Compile Include="Src\Services\Debugger\Breakpoint.cs" />
     <Compile Include="Src\Services\Debugger\BreakpointBookmark.cs" />
+    <Compile Include="Src\Services\Debugger\BreakpointBookmarkEventArgs.cs" />
     <Compile Include="Src\Services\File\RecentOpen.cs" />
     <Compile Include="Src\Services\Language\LanguageService.cs" />
     <Compile Include="Src\Internal\Auswerter\WindowActiveAuswerter.cs" />
@@ -184,7 +184,7 @@
       <SubType>UserControl</SubType>
     </Compile>
     <Compile Include="Src\Gui\Dialogs\CommonAboutDialog.cs">
-      <SubType>UserControl</SubType>
+      <SubType>Form</SubType>
     </Compile>
     <Compile Include="Src\Gui\Dialogs\DirtyFilesDialog.cs" />
     <Compile Include="Src\Gui\Dialogs\FolderDialog.cs" />
@@ -203,7 +203,7 @@
       <SubType>Form</SubType>
     </Compile>
     <Compile Include="Src\Gui\Dialogs\TreeViewOptions.cs">
-      <SubType>Form</SubType>
+      <SubType>Component</SubType>
     </Compile>
     <Compile Include="Src\Gui\Dialogs\ViewGPLDialog.cs">
       <SubType>Form</SubType>
@@ -268,7 +268,7 @@
       <SubType>Form</SubType>
     </Compile>
     <Compile Include="Src\Gui\Pads\FileScout.cs">
-      <SubType>Component</SubType>
+      <SubType>UserControl</SubType>
     </Compile>
     <Compile Include="Src\Gui\Pads\OpenTaskView.cs" />
     <Compile Include="Src\Gui\Pads\PropertyPad\PropertyPad.cs" />

src/Main/Base/Project/Src/Services/Debugger/Breakpoint.cs

@@ -1,77 +0,0 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Windows.Forms;
-using System.Drawing;
-using System.CodeDom.Compiler;
-using System.Collections;
-using System.IO;
-using System.Diagnostics;
-using ICSharpCode.SharpDevelop.Bookmarks;
-
-namespace ICSharpCode.Core
-{
-	public class Breakpoint 
-	{
-		BreakpointBookmark bookmark;
-		object tag;
-		
-		public BreakpointBookmark Bookmark {
-			get {
-				return bookmark;
-			}
-		}
-		
-		public string FileName {
-			get {
-				return bookmark.FileName;
-			}
-			set {
-				bookmark.FileName = value;
-			}
-		}
-		
-		public int LineNumber {
-			get {
-				return bookmark.LineNumber + 1;
-			}
-			set {
-				bookmark.LineNumber = value - 1;
-			}
-		}
-		
-		public event EventHandler LineNumberChanged {
-			add    { bookmark.LineNumberChanged += value; }
-			remove { bookmark.LineNumberChanged -= value; }
-		}
-
-		public object Tag {
-			get {
-				return tag;
-			}
-			set {
-				tag = value;
-			}
-		}
-		
-		public bool IsEnabled {
-			get {
-				return bookmark.IsEnabled;
-			}
-			set {
-				bookmark.IsEnabled = value;
-			}
-		}
-		
-		public Breakpoint(ICSharpCode.TextEditor.Document.IDocument document, string fileName, int lineNumber)
-		{
-			bookmark = new BreakpointBookmark(this, fileName, document, lineNumber - 1);
-		}
-	}
-}
-

src/Main/Base/Project/Src/Services/Debugger/BreakpointBookmark.cs

@@ -16,19 +16,22 @@ using ICSharpCode.SharpDevelop.Bookmarks;
 
 namespace ICSharpCode.Core
 {
-	public class BreakpointBookmark : SDBookmark
+	public class BreakpointBookmark: SDBookmark
 	{
-		Breakpoint breakpoint;
-		
-		public Breakpoint Breakpoint {
+		object tag;
+
+		public object Tag {
 			get {
-				return breakpoint;
+				return tag;
+			}
+			set {
+				tag = value;
 			}
 		}
-		
-		public BreakpointBookmark(Breakpoint breakpoint, string fileName, ICSharpCode.TextEditor.Document.IDocument document, int lineNumber) : base(fileName, document, lineNumber)
+
+		public BreakpointBookmark(string fileName, ICSharpCode.TextEditor.Document.IDocument document, int lineNumber) : base(fileName, document, lineNumber)
 		{
-			this.breakpoint = breakpoint;
+
 		}
 		
 		public override void Draw(ICSharpCode.TextEditor.IconBarMargin margin, Graphics g, Point p)

src/Main/Base/Project/Src/Services/Debugger/BreakpointBookmarkEventArgs.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ICSharpCode.Core
+{
+	public class BreakpointBookmarkEventArgs: EventArgs
+	{
+		BreakpointBookmark breakpointBookmark;
+
+		public BreakpointBookmark BreakpointBookmark {
+			get {
+				return breakpointBookmark;
+			}
+		}
+
+		public BreakpointBookmarkEventArgs(BreakpointBookmark breakpointBookmark)
+		{
+			this.breakpointBookmark = breakpointBookmark;
+		}
+	}
+}

src/Main/Base/Project/Src/Services/Debugger/DebuggerService.cs

@@ -32,8 +32,25 @@ namespace ICSharpCode.Core
 
 		static DebuggerService()
 		{
-			InitializeService();
-			InitializeService2();
+			AddInTreeNode treeNode = null;
+			try {
+				treeNode = AddInTree.GetTreeNode("/SharpDevelop/Services/DebuggerService/Debugger");
+			} catch (Exception) {
+			}
+			if (treeNode != null) {
+				debuggers = treeNode.BuildChildItems(null);
+			}
+			if (debuggers == null) {
+				debuggers = new ArrayList();
+			}
+			
+			ProjectService.SolutionLoaded += delegate {
+				ClearDebugMessages();
+			};
+
+			WorkbenchSingleton.WorkbenchCreated += new EventHandler(WorkspaceCreated);
+			BM.BookmarkManager.Added   += BookmarkAdded;
+			BM.BookmarkManager.Removed += BookmarkRemoved;
 		}
 		
 		static IDebugger GetCompatibleDebugger()
@@ -65,6 +82,8 @@ namespace ICSharpCode.Core
 		{
 			//oldLayoutConfiguration = LayoutConfiguration.CurrentLayoutName;
 			//LayoutConfiguration.CurrentLayoutName = "Debug";
+
+			ClearDebugMessages();
 		}
 
 		static void DebugStopped(object sender, EventArgs e)
@@ -83,124 +102,123 @@ namespace ICSharpCode.Core
 				compilerMessageView.AddCategory(debugCategory);
 			}
 		}
+
 		public static void ClearDebugMessages()
 		{
 			EnsureDebugCategory();
 			debugCategory.ClearText();
 		}
+
 		public static void PrintDebugMessage(string msg)
-		{
-			try {
-				EnsureDebugCategory();
-				debugCategory.AppendText(msg);
-			} catch (Exception) {}
-		}
-		
-		#region ICSharpCode.Core.IService interface implementation
-		public static void InitializeService()
-		{
-			AddInTreeNode treeNode = null;
-			try {
-				treeNode = AddInTree.GetTreeNode("/SharpDevelop/Services/DebuggerService/Debugger");
-			} catch (Exception) {
-			}
-			if (treeNode != null) {
-				debuggers = treeNode.BuildChildItems(null);
-			}
-			if (debuggers == null) {
-				debuggers = new ArrayList();
-			}
-			
-			ProjectService.SolutionLoaded += new SolutionEventHandler(ClearOnCombineEvent);
-		}
-		
-		static void DebuggerServiceStarted(object sender, EventArgs e)
 		{
 			EnsureDebugCategory();
-			debugCategory.ClearText();
-			CompilerMessageView compilerMessageView = (CompilerMessageView)WorkbenchSingleton.Workbench.GetPad(typeof(CompilerMessageView)).PadContent;
-			compilerMessageView.SelectCategory("Debug");
-		}
-		
-		static void ClearOnCombineEvent(object sender, SolutionEventArgs e)
-		{
-			EnsureDebugCategory();
-			debugCategory.ClearText();
+			debugCategory.AppendText(msg);
 		}
-		#endregion
 
-		public static event EventHandler BreakPointChanged;
-		public static event EventHandler BreakPointAdded;
-		public static event EventHandler BreakPointRemoved;
+
+		public static event EventHandler<BreakpointBookmarkEventArgs> BreakPointChanged;
+		public static event EventHandler<BreakpointBookmarkEventArgs> BreakPointAdded;
+		public static event EventHandler<BreakpointBookmarkEventArgs> BreakPointRemoved;
 		
-		static void OnBreakPointChanged(EventArgs e)
+		static void OnBreakPointChanged(BreakpointBookmarkEventArgs e)
 		{
 			if (BreakPointChanged != null) {
 				BreakPointChanged(null, e);
 			}
 		}
 		
-		static void OnBreakPointAdded(EventArgs e)
+		static void OnBreakPointAdded(BreakpointBookmarkEventArgs e)
 		{
 			if (BreakPointAdded != null) {
 				BreakPointAdded(null, e);
 			}
 		}
 		
-		static void OnBreakPointRemoved(EventArgs e)
+		static void OnBreakPointRemoved(BreakpointBookmarkEventArgs e)
 		{
 			if (BreakPointRemoved != null) {
 				BreakPointRemoved(null, e);
 			}
 		}
 		
-		
-		static List<Breakpoint> breakpoints = new List<Breakpoint>();
-		
-		public static IList<Breakpoint> Breakpoints {
+		public static IList<BreakpointBookmark> Breakpoints {
 			get {
+				List<BreakpointBookmark> breakpoints = new List<BreakpointBookmark>();
+				foreach (BM.SDBookmark bookmark in BM.BookmarkManager.Bookmarks) {
+					BreakpointBookmark breakpoint = bookmark as BreakpointBookmark;
+					if (breakpoint != null) {
+						breakpoints.Add(breakpoint);
+					}
+				}
 				return breakpoints;
 			}
 		}
-		
-		class BreakpointMarker: TextMarker
+
+		static void BookmarkAdded(object sender, BM.BookmarkEventArgs e)
 		{
-			public BreakpointMarker(int offset, int length, TextMarkerType textMarkerType, Color color, Color foreColor):base(offset, length, textMarkerType, color, foreColor)
-			{
+			BreakpointBookmark bb = e.Bookmark as BreakpointBookmark;
+			if (bb != null) {
+				RefreshBreakpointMarkersInDocument(bb.Document);
+				OnBreakPointAdded(new BreakpointBookmarkEventArgs(bb));
 			}
 		}
 		
-		class CurrentLineMarker: TextMarker
+		static void BookmarkRemoved(object sender, BM.BookmarkEventArgs e)
 		{
-			public CurrentLineMarker(int offset, int length, TextMarkerType textMarkerType, Color color, Color foreColor):base(offset, length, textMarkerType, color, foreColor)
-			{
+			BreakpointBookmark bb = e.Bookmark as BreakpointBookmark;
+			if (bb != null) {
+				RefreshBreakpointMarkersInDocument(bb.Document);
+				OnBreakPointRemoved(new BreakpointBookmarkEventArgs(bb));
+			}
+		}
+
+		static void ToggleBreakpointAt(IDocument document, string fileName, int lineNumber)
+		{
+			foreach (Bookmark m in document.BookmarkManager.Marks) {
+				BreakpointBookmark breakpoint = m as BreakpointBookmark;
+				if (breakpoint != null) {
+					if (breakpoint.LineNumber == lineNumber) {
+						document.BookmarkManager.RemoveMark(m);
+						return;
+					}
+				}
 			}
+			document.BookmarkManager.AddMark(new BreakpointBookmark(fileName, document, lineNumber));
 		}
 		
-		public static void InitializeService2()
+		static void RefreshBreakpointMarkersInDocument(IDocument document)
 		{
-			WorkbenchSingleton.WorkbenchCreated += new EventHandler(WorkspaceCreated);
-			BM.BookmarkManager.Added   += BookmarkAdded;
-			BM.BookmarkManager.Removed += BookmarkRemoved;
+			if (document == null) return;
+			List<TextMarker> markers = document.MarkerStrategy.TextMarker;
+			// Remove all breakpoint markers
+			for (int i = 0; i < markers.Count;) {
+				if (markers[i] is BreakpointMarker) {
+					markers.RemoveAt(i);
+				} else {
+					i++; // Check next one
+				}
+			}
+			// Add breakpoint markers
+			foreach (BreakpointBookmark b in Breakpoints) {
+				LineSegment lineSeg = document.GetLineSegment(b.LineNumber);
+				document.MarkerStrategy.TextMarker.Add(new BreakpointMarker(lineSeg.Offset, lineSeg.Length, TextMarkerType.SolidBlock, Color.Red, Color.White));
+			}
+			// Perform editor update
+			document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.WholeTextArea));
+			document.CommitUpdate();
 		}
 		
-		static void BookmarkAdded(object sender, BM.BookmarkEventArgs e)
+		class BreakpointMarker: TextMarker
 		{
-			BreakpointBookmark bb = e.Bookmark as BreakpointBookmark;
-			if (bb != null) {
-				breakpoints.Add(bb.Breakpoint);
-				RefreshBreakpointMarkersInDocument(bb.Document);
-				OnBreakPointAdded(EventArgs.Empty);
+			public BreakpointMarker(int offset, int length, TextMarkerType textMarkerType, Color color, Color foreColor):base(offset, length, textMarkerType, color, foreColor)
+			{
 			}
 		}
 		
-		static void BookmarkRemoved(object sender, BM.BookmarkEventArgs e)
+		class CurrentLineMarker: TextMarker
 		{
-			BreakpointBookmark bb = e.Bookmark as BreakpointBookmark;
-			if (bb != null) {
-				breakpoints.Remove(bb.Breakpoint);
-				RefreshBreakpointMarkersInDocument(bb.Document);
-				OnBreakPointRemoved(EventArgs.Empty);
+			public CurrentLineMarker(int offset, int length, TextMarkerType textMarkerType, Color color, Color foreColor):base(offset, length, textMarkerType, color, foreColor)
+			{
 			}
 		}
 		
@@ -282,49 +300,11 @@ namespace ICSharpCode.Core
 			Point logicPos = iconBar.TextArea.TextView.GetLogicalPosition(0, mousepos.Y - viewRect.Top);
 			
 			if (logicPos.Y >= 0 && logicPos.Y < iconBar.TextArea.Document.TotalNumberOfLines) {
-				ToggleBreakpointAt(iconBar.TextArea.Document, iconBar.TextArea.MotherTextEditorControl.FileName, logicPos.Y + 1);
+				ToggleBreakpointAt(iconBar.TextArea.Document, iconBar.TextArea.MotherTextEditorControl.FileName, logicPos.Y);
 				iconBar.TextArea.Refresh(iconBar);
 			}
 		}
 		
-		static void ToggleBreakpointAt(IDocument document, string fileName, int lineNumber)
-		{
-			foreach (Bookmark m in document.BookmarkManager.Marks) {
-				BreakpointBookmark bb = m as BreakpointBookmark;
-				if (bb != null) {
-					if (bb.Breakpoint.LineNumber == lineNumber) {
-						document.BookmarkManager.RemoveMark(m);
-						return;
-					}
-				}
-			}
-			document.BookmarkManager.AddMark(new Breakpoint(document, fileName, lineNumber).Bookmark);
-		}
-		
-		static void RefreshBreakpointMarkersInDocument(IDocument document)
-		{
-			if (document == null) return;
-			List<TextMarker> markers = document.MarkerStrategy.TextMarker;
-			// Remove all breakpoint markers
-			for (int i = 0; i < markers.Count;) {
-				if (markers[i] is BreakpointMarker) {
-					markers.RemoveAt(i);
-				} else {
-					i++; // Check next one
-				}
-			}
-			// Add breakpoint markers
-			foreach (Bookmark b in document.BookmarkManager.Marks) {
-				if (b is BreakpointBookmark) {
-					LineSegment lineSeg = document.GetLineSegment(b.LineNumber);
-					document.MarkerStrategy.TextMarker.Add(new BreakpointMarker(lineSeg.Offset, lineSeg.Length, TextMarkerType.SolidBlock, Color.Red, Color.White));
-				}
-			}
-			// Perform editor update
-			document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.WholeTextArea));
-			document.CommitUpdate();
-		}
-		
 		/// <summary>
 		/// Draw Breakpoint icon and the yellow arrow in the margin
 		/// </summary>

src/Main/Base/Project/Src/Services/Debugger/DefaultDebugger.cs

@@ -9,7 +9,7 @@ namespace ICSharpCode.Core
 {
 	public class DefaultDebugger : IDebugger
 	{
-		System.Diagnostics.Process attachedProcess = null;
+		Process attachedProcess = null;
 		
 		public bool IsDebugging {
 			get {
@@ -35,7 +35,7 @@ namespace ICSharpCode.Core
 			}
 
 			try {
-				attachedProcess = new System.Diagnostics.Process();
+				attachedProcess = new Process();
 				attachedProcess.StartInfo = processStartInfo;
 				attachedProcess.Exited += new EventHandler(AttachedProcessExited);
 				attachedProcess.EnableRaisingEvents = true;
@@ -62,7 +62,10 @@ namespace ICSharpCode.Core
 
 		public void StartWithoutDebugging(ProcessStartInfo processStartInfo)
 		{
-			throw new NotSupportedException();
+			Process process;
+			process = new Process();
+			process.StartInfo = processStartInfo;
+			process.Start();
 		}
 
 		public bool SupportsStartWithoutDebugging {

src/Main/Base/Project/Src/TextEditor/Bookmarks/BookmarkConverter.cs

@@ -35,7 +35,7 @@ namespace ICSharpCode.SharpDevelop.Bookmarks
 				SDBookmark bookmark;
 				switch (v[0]) {
 					case "Breakpoint":
-						bookmark = new Breakpoint(null, fileName, lineNumber).Bookmark;
+						bookmark = new BreakpointBookmark(fileName, null, lineNumber);
 						break;
 					default:
 						bookmark = new SDBookmark(fileName, null, lineNumber);