use Toolbox instances instead of static service, solve problems with logging service

src/AddIns/BackendBindings/WixBinding/Project/Src/Gui/SetupDialogControlsSideTab.cs

@@ -17,7 +17,7 @@ namespace ICSharpCode.WixBinding
 	public sealed class SetupDialogControlsSideTab : SideTabDesigner
 	{
 		SetupDialogControlsSideTab(SideBarControl sideBar, Category category, IToolboxService toolboxService)
-			: base(sideBar, category, toolboxService)
+			: base(null/*TODO!!!!!!!!!!!!!!!!!!!!!!!!!*/, sideBar, category, toolboxService)
 		{
 		}
 		

src/AddIns/DisplayBindings/FormsDesigner/FormsDesigner.AddIn/Commands/FormsCommands.cs

@@ -9,6 +9,7 @@ using System.Windows.Forms.Design;
 
 using ICSharpCode.Core;
 using ICSharpCode.Core.WinForms;
+using ICSharpCode.FormsDesigner.Services;
 using ICSharpCode.SharpDevelop;
 using ICSharpCode.SharpDevelop.Gui;
 
@@ -19,11 +20,11 @@ namespace ICSharpCode.FormsDesigner.Commands
 	/// </summary>
 	public abstract class AbstractFormsDesignerCommand : AbstractMenuCommand
 	{
-		public abstract CommandID CommandID {
+		public abstract CommandIDEnum CommandID {
 			get;
 		}
 		
-		protected virtual bool CanExecuteCommand(IDesignerHost host)
+		protected virtual bool CanExecuteCommand(FormsDesignerAppDomainHost host)
 		{
 			return true;
 		}
@@ -42,9 +43,9 @@ namespace ICSharpCode.FormsDesigner.Commands
 			
 			try {
 				FormsDesignerViewContent formDesigner = FormDesigner;
-				if (formDesigner != null && CanExecuteCommand(formDesigner.AppDomainHost.Host)) {
+				if (formDesigner != null && CanExecuteCommand(formDesigner.AppDomainHost)) {
-					IMenuCommandService menuCommandService = (IMenuCommandService)formDesigner.AppDomainHost.Host.GetService(typeof(IMenuCommandService));
+					IMenuCommandService menuCommandService = (IMenuCommandService)formDesigner.AppDomainHost.GetService(typeof(IMenuCommandService));
-					menuCommandService.GlobalInvoke(CommandID);
+					menuCommandService.GlobalInvoke(CommandIDEnumConverter.ToCommandID(CommandID));
 				}
 			} catch (Exception e) {
 				MessageService.ShowException(e);
@@ -57,14 +58,8 @@ namespace ICSharpCode.FormsDesigner.Commands
 		}
 	}
 
-	public class ViewCode : AbstractFormsDesignerCommand
+	public class ViewCode : AbstractMenuCommand
 	{
-		public override CommandID CommandID {
-			get {
-				return StandardCommands.ViewCode;
-			}
-		}
-
 		FormsDesignerViewContent FormDesigner {
 			get {
 				IWorkbenchWindow window = WorkbenchSingleton.Workbench.ActiveWorkbenchWindow;
@@ -89,14 +84,8 @@ namespace ICSharpCode.FormsDesigner.Commands
 		}
 	}
 
-	public class ShowProperties : AbstractFormsDesignerCommand
+	public class ShowProperties : AbstractMenuCommand
 	{
-		public override CommandID CommandID {
-			get {
-				return StandardCommands.PropertiesWindow;
-			}
-		}
-
 		public override void Run()
 		{
 			PadDescriptor padContent = WorkbenchSingleton.Workbench.GetPad(typeof(ICSharpCode.SharpDevelop.Gui.PropertyPad));
@@ -153,63 +142,63 @@ namespace ICSharpCode.FormsDesigner.Commands
 	#region Align Commands
 	public class AlignToGrid : AbstractFormsDesignerCommand
 	{
-		public override CommandID CommandID {
+		public override CommandIDEnum CommandID {
 			get {
-				return StandardCommands.AlignToGrid;
+				return CommandIDEnum.AlignToGrid;
 			}
 		}
 	}
 	
 	public class AlignLeft : AbstractFormsDesignerCommand
 	{
-		public override CommandID CommandID {
+		public override CommandIDEnum CommandID {
 			get {
-				return StandardCommands.AlignLeft;
+				return CommandIDEnum.AlignLeft;
 			}
 		}
 	}
 	
 	public class AlignRight : AbstractFormsDesignerCommand
 	{
-		public override CommandID CommandID {
+		public override CommandIDEnum CommandID {
 			get {
-				return StandardCommands.AlignRight;
+				return CommandIDEnum.AlignRight;
 			}
 		}
 	}
 	
 	public class AlignTop : AbstractFormsDesignerCommand
 	{
-		public override CommandID CommandID {
+		public override CommandIDEnum CommandID {
 			get {
-				return StandardCommands.AlignTop;
+				return CommandIDEnum.AlignTop;
 			}
 		}
 	}
 	
 	public class AlignBottom : AbstractFormsDesignerCommand
 	{
-		public override CommandID CommandID {
+		public override CommandIDEnum CommandID {
 			get {
-				return StandardCommands.AlignBottom;
+				return CommandIDEnum.AlignBottom;
 			}
 		}
 	}
 	
 	public class AlignHorizontalCenters : AbstractFormsDesignerCommand
 	{
-		public override CommandID CommandID {
+		public override CommandIDEnum CommandID {
 			get {
-				return StandardCommands.AlignHorizontalCenters;
+				return CommandIDEnum.AlignHorizontalCenters;
 			}
 		}
 	}
 	
 	public class AlignVerticalCenters : AbstractFormsDesignerCommand
 	{
-		public override CommandID CommandID {
+		public override CommandIDEnum CommandID {
 			get {
-				return StandardCommands.AlignVerticalCenters;
+				return CommandIDEnum.AlignVerticalCenters;
 			}
 		}
 	}
@@ -218,36 +207,36 @@ namespace ICSharpCode.FormsDesigner.Commands
 	#region Make Same Size Commands
 	public class SizeToGrid : AbstractFormsDesignerCommand
 	{
-		public override CommandID CommandID {
+		public override CommandIDEnum CommandID {
 			get {
-				return StandardCommands.SizeToGrid;
+				return CommandIDEnum.SizeToGrid;
 			}
 		}
 	}
 	
 	public class SizeToControl : AbstractFormsDesignerCommand
 	{
-		public override CommandID CommandID {
+		public override CommandIDEnum CommandID {
 			get {
-				return StandardCommands.SizeToControl;
+				return CommandIDEnum.SizeToControl;
 			}
 		}
 	}
 	
 	public class SizeToControlHeight : AbstractFormsDesignerCommand
 	{
-		public override CommandID CommandID {
+		public override CommandIDEnum CommandID {
 			get {
-				return StandardCommands.SizeToControlHeight;
+				return CommandIDEnum.SizeToControlHeight;
 			}
 		}
 	}
 	
 	public class SizeToControlWidth : AbstractFormsDesignerCommand
 	{
-		public override CommandID CommandID {
+		public override CommandIDEnum CommandID {
 			get {
-				return StandardCommands.SizeToControlWidth;
+				return CommandIDEnum.SizeToControlWidth;
 			}
 		}
 	}
@@ -256,13 +245,13 @@ namespace ICSharpCode.FormsDesigner.Commands
 	#region Horizontal Spacing Commands
 	public class HorizSpaceMakeEqual : AbstractFormsDesignerCommand
 	{
-		public override CommandID CommandID {
+		public override CommandIDEnum CommandID {
 			get {
-				return StandardCommands.HorizSpaceMakeEqual;
+				return CommandIDEnum.HorizSpaceMakeEqual;
 			}
 		}
 		
-		protected override bool CanExecuteCommand(IDesignerHost host)
+		protected override bool CanExecuteCommand(FormsDesignerAppDomainHost host)
 		{
 			ISelectionService selectionService = (ISelectionService)host.GetService(typeof(ISelectionService));
 			return selectionService.SelectionCount > 1;
@@ -271,27 +260,27 @@ namespace ICSharpCode.FormsDesigner.Commands
 	
 	public class HorizSpaceIncrease : AbstractFormsDesignerCommand
 	{
-		public override CommandID CommandID {
+		public override CommandIDEnum CommandID {
 			get {
-				return StandardCommands.HorizSpaceIncrease;
+				return CommandIDEnum.HorizSpaceIncrease;
 			}
 		}
 	}
 	
 	public class HorizSpaceDecrease : AbstractFormsDesignerCommand
 	{
-		public override CommandID CommandID {
+		public override CommandIDEnum CommandID {
 			get {
-				return StandardCommands.HorizSpaceDecrease;
+				return CommandIDEnum.HorizSpaceDecrease;
 			}
 		}
 	}
 	
 	public class HorizSpaceConcatenate : AbstractFormsDesignerCommand
 	{
-		public override CommandID CommandID {
+		public override CommandIDEnum CommandID {
 			get {
-				return StandardCommands.HorizSpaceConcatenate;
+				return CommandIDEnum.HorizSpaceConcatenate;
 			}
 		}
 	}
@@ -300,13 +289,13 @@ namespace ICSharpCode.FormsDesigner.Commands
 	#region Vertical Spacing Commands
 	public class VertSpaceMakeEqual : AbstractFormsDesignerCommand
 	{
-		public override CommandID CommandID {
+		public override CommandIDEnum CommandID {
 			get {
-				return StandardCommands.VertSpaceMakeEqual;
+				return CommandIDEnum.VertSpaceMakeEqual;
 			}
 		}
 		
-		protected override bool CanExecuteCommand(IDesignerHost host)
+		protected override bool CanExecuteCommand(FormsDesignerAppDomainHost host)
 		{
 			ISelectionService selectionService = (ISelectionService)host.GetService(typeof(ISelectionService));
 			return selectionService.SelectionCount > 1;
@@ -316,27 +305,27 @@ namespace ICSharpCode.FormsDesigner.Commands
 	
 	public class VertSpaceIncrease : AbstractFormsDesignerCommand
 	{
-		public override CommandID CommandID {
+		public override CommandIDEnum CommandID {
 			get {
-				return StandardCommands.VertSpaceIncrease;
+				return CommandIDEnum.VertSpaceIncrease;
 			}
 		}
 	}
 	
 	public class VertSpaceDecrease : AbstractFormsDesignerCommand
 	{
-		public override CommandID CommandID {
+		public override CommandIDEnum CommandID {
 			get {
-				return StandardCommands.VertSpaceDecrease;
+				return CommandIDEnum.VertSpaceDecrease;
 			}
 		}
 	}
 	
 	public class VertSpaceConcatenate : AbstractFormsDesignerCommand
 	{
-		public override CommandID CommandID {
+		public override CommandIDEnum CommandID {
 			get {
-				return StandardCommands.VertSpaceConcatenate;
+				return CommandIDEnum.VertSpaceConcatenate;
 			}
 		}
 	}
@@ -345,17 +334,17 @@ namespace ICSharpCode.FormsDesigner.Commands
 	#region Center Commands
 	public class CenterHorizontally : AbstractFormsDesignerCommand
 	{
-		public override CommandID CommandID {
+		public override CommandIDEnum CommandID {
 			get {
-				return StandardCommands.CenterHorizontally;
+				return CommandIDEnum.CenterHorizontally;
 			}
 		}
 	}
 	public class CenterVertically : AbstractFormsDesignerCommand
 	{
-		public override CommandID CommandID {
+		public override CommandIDEnum CommandID {
 			get {
-				return StandardCommands.CenterVertically;
+				return CommandIDEnum.CenterVertically;
 			}
 		}
 	}
@@ -364,18 +353,18 @@ namespace ICSharpCode.FormsDesigner.Commands
 	#region Order Commands
 	public class SendToBack : AbstractFormsDesignerCommand
 	{
-		public override CommandID CommandID {
+		public override CommandIDEnum CommandID {
 			get {
-				return StandardCommands.SendToBack;
+				return CommandIDEnum.SendToBack;
 			}
 		}
 	}
 	
 	public class BringToFront : AbstractFormsDesignerCommand
 	{
-		public override CommandID CommandID {
+		public override CommandIDEnum CommandID {
 			get {
-				return StandardCommands.BringToFront;
+				return CommandIDEnum.BringToFront;
 			}
 		}
 	}
@@ -385,9 +374,9 @@ namespace ICSharpCode.FormsDesigner.Commands
 	
 	public class LineUpIcons : AbstractFormsDesignerCommand
 	{
-		public override CommandID CommandID {
+		public override CommandIDEnum CommandID {
 			get {
-				return StandardCommands.LineupIcons;
+				return CommandIDEnum.LineupIcons;
 			}
 		}
 	}
@@ -422,7 +411,7 @@ namespace ICSharpCode.FormsDesigner.Commands
 			get {
 				FormsDesignerViewContent formDesigner = FormDesigner;
 				if (formDesigner != null) {
-					return formDesigner.AppDomainHost.Host.GetService(typeof(ComponentTray)) as ComponentTray;
+					return formDesigner.AppDomainHost.GetService(typeof(ComponentTray)) as ComponentTray;
 				}
 				return null;
 				
@@ -437,9 +426,9 @@ namespace ICSharpCode.FormsDesigner.Commands
 	#region Global Commands
 	public class LockControls : AbstractFormsDesignerCommand
 	{
-		public override CommandID CommandID {
+		public override CommandIDEnum CommandID {
 			get {
-				return StandardCommands.LockControls;
+				return CommandIDEnum.LockControls;
 			}
 		}
 	}

src/AddIns/DisplayBindings/FormsDesigner/FormsDesigner.AddIn/Commands/SideBarCommands.cs

@@ -10,11 +10,15 @@ namespace ICSharpCode.FormsDesigner
 {
 	public class CustomizeSideBar : AbstractMenuCommand
 	{
-		public override void Run()		
+		public override void Run()
 		{
-			using (ConfigureSideBarDialog configureSideBarDialog = new ConfigureSideBarDialog()) {
+			#warning test this!
-				if (configureSideBarDialog.ShowDialog(ICSharpCode.SharpDevelop.Gui.WorkbenchSingleton.MainWin32Window) == DialogResult.OK) {
+			var sidebar = Owner as SideTabDesigner;
-					ToolboxProvider.ReloadSideTabs(true);
+			if (sidebar != null) {
+				using (ConfigureSideBarDialog configureSideBarDialog = new ConfigureSideBarDialog(sidebar.Toolbox)) {
+					if (configureSideBarDialog.ShowDialog(ICSharpCode.SharpDevelop.Gui.WorkbenchSingleton.MainWin32Window) == DialogResult.OK) {
+						sidebar.Toolbox.ReloadSideTabs(true);
+					}
 				}
 			}
 		}

src/AddIns/DisplayBindings/FormsDesigner/FormsDesigner.AddIn/FormKeyHandler.cs

@@ -9,7 +9,7 @@ using System.ComponentModel.Design;
 using System.Reflection;
 using System.Windows.Forms;
 using System.Windows.Forms.Design;
-
+using System.Windows.Forms.Integration;
 using ICSharpCode.Core;
 using ICSharpCode.SharpDevelop.Gui;
 
@@ -69,7 +69,7 @@ namespace ICSharpCode.FormsDesigner
 			
 			FormsDesignerViewContent formDesigner = WorkbenchSingleton.Workbench.ActiveContent as FormsDesignerViewContent;
 			
-			if (formDesigner == null || formDesigner.AppDomainHost.Host == null) {
+			if (formDesigner == null || formDesigner.AppDomainHost == null) {
 				return false;
 			}
 			if (formDesigner.UserContent != null && !((Control)formDesigner.UserContent).ContainsFocus) {
@@ -77,7 +77,7 @@ namespace ICSharpCode.FormsDesigner
 			}
 			
 			Control originControl = Control.FromChildHandle(m.HWnd);
-			if (originControl != null && formDesigner.UserContent != null && !(formDesigner.UserContent == originControl || formDesigner.UserContent.Contains(originControl))) {
+			if (originControl != null && formDesigner.UserContent != null && !(formDesigner.UserContent == originControl || ((WindowsFormsHost)formDesigner.UserContent).Child.Contains(originControl))) {
 				// Ignore if message origin not in forms designer
 				// (e.g. navigating the main menu)
 				return false;
@@ -102,8 +102,8 @@ namespace ICSharpCode.FormsDesigner
 				}
 				LoggingService.Debug("Run menu command: " + commandWrapper.CommandID);
 				
-				IMenuCommandService menuCommandService = (IMenuCommandService)formDesigner.AppDomainHost.Host.GetService(typeof(IMenuCommandService));
+				IMenuCommandService menuCommandService = (IMenuCommandService)formDesigner.AppDomainHost.GetService(typeof(IMenuCommandService));
-				ISelectionService   selectionService = (ISelectionService)formDesigner.AppDomainHost.Host.GetService(typeof(ISelectionService));
+				ISelectionService   selectionService = (ISelectionService)formDesigner.AppDomainHost.GetService(typeof(ISelectionService));
 				ICollection components = selectionService.GetSelectedComponents();
 				if (components.Count == 1) {
 					foreach (IComponent component in components) {
@@ -128,7 +128,7 @@ namespace ICSharpCode.FormsDesigner
 			Assembly asm = typeof(WindowsFormsDesignerOptionService).Assembly;
 			// Microsoft made ToolStripKeyboardHandlingService internal, so we need Reflection
 			Type keyboardType = asm.GetType("System.Windows.Forms.Design.ToolStripKeyboardHandlingService");
-			object keyboardService = formDesigner.AppDomainHost.Host.GetService(keyboardType);
+			object keyboardService = formDesigner.AppDomainHost.GetService(keyboardType);
 			if (keyboardService == null) {
 				LoggingService.Debug("no ToolStripKeyboardHandlingService found");
 				return false; // handle command normally

src/AddIns/DisplayBindings/FormsDesigner/FormsDesigner.AddIn/FormsDesigner.AddIn.csproj

@@ -39,6 +39,10 @@
     <Reference Include="PresentationCore" />
     <Reference Include="PresentationFramework" />
     <Reference Include="System" />
+    <Reference Include="System.AddIn" />
+    <Reference Include="System.AddIn.Contract">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
     <Reference Include="System.Core">
       <RequiredTargetFramework>3.5</RequiredTargetFramework>
     </Reference>
@@ -50,12 +54,18 @@
     <Reference Include="System.Drawing" />
     <Reference Include="System.Drawing.Design" />
     <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Windows.Presentation">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
     <Reference Include="System.Xaml" />
     <Reference Include="System.Xml" />
     <Reference Include="System.Xml.Linq">
       <RequiredTargetFramework>3.5</RequiredTargetFramework>
     </Reference>
     <Reference Include="WindowsBase" />
+    <Reference Include="WindowsFormsIntegration">
+      <RequiredTargetFramework>3.0</RequiredTargetFramework>
+    </Reference>
   </ItemGroup>
   <ItemGroup>
     <None Include="FormsDesigner.addin">
@@ -104,9 +114,13 @@
     <Compile Include="Toolbox\ConfigureSideBarDialog.cs">
       <SubType>Form</SubType>
     </Compile>
+    <Compile Include="Toolbox\ConfigureSideBarDialog.Designer.cs">
+      <DependentUpon>ConfigureSideBarDialog.cs</DependentUpon>
+    </Compile>
     <Compile Include="Toolbox\CustomComponentsSideTab.cs" />
-    <Compile Include="Toolbox\RenameCategoryDialog.cs">
+    <Compile Include="Toolbox\RenameCategoryDialog.cs" />
-      <SubType>Form</SubType>
+    <Compile Include="Toolbox\RenameCategoryDialog.Designer.cs">
+      <DependentUpon>RenameCategoryDialog.cs</DependentUpon>
     </Compile>
     <Compile Include="Toolbox\SideTabDesigner.cs" />
     <Compile Include="Toolbox\SideTabItemDesigner.cs" />
@@ -168,6 +182,12 @@
     <EmbeddedResource Include="OptionPanels\LocalizationModelOptionsPanel.resx">
       <DependentUpon>LocalizationModelOptionsPanel.cs</DependentUpon>
     </EmbeddedResource>
+    <EmbeddedResource Include="Toolbox\ConfigureSideBarDialog.resx">
+      <DependentUpon>ConfigureSideBarDialog.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Toolbox\RenameCategoryDialog.resx">
+      <DependentUpon>RenameCategoryDialog.cs</DependentUpon>
+    </EmbeddedResource>
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.Targets" />
 </Project>

src/AddIns/DisplayBindings/FormsDesigner/FormsDesigner.AddIn/FormsDesignerLoggingServiceImpl.cs

@@ -10,7 +10,7 @@ namespace ICSharpCode.FormsDesigner
 	/// <summary>
 	/// Description of FormsDesignerLoggingServiceImpl.
 	/// </summary>
-	public class FormsDesignerLoggingServiceImpl : IFormsDesignerLoggingService
+	public class FormsDesignerLoggingServiceImpl : MarshalByRefObject, IFormsDesignerLoggingService
 	{
 		public void Debug(string message)
 		{

src/AddIns/DisplayBindings/FormsDesigner/FormsDesigner.AddIn/FormsDesignerViewContent.cs

@@ -2,16 +2,19 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
+using System.AddIn.Pipeline;
 using System.Collections;
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.ComponentModel.Design;
 using System.ComponentModel.Design.Serialization;
+using System.Diagnostics;
 using System.Drawing;
 using System.IO;
 using System.Linq;
 using System.Text;
 using System.Windows.Forms;
+
 using ICSharpCode.Core;
 using ICSharpCode.FormsDesigner.Gui;
 using ICSharpCode.FormsDesigner.Gui.OptionPanels;
@@ -37,6 +40,8 @@ namespace ICSharpCode.FormsDesigner
 		readonly ResourceStore resourceStore;
 		FormsDesignerUndoEngine undoEngine;
 		FormsDesignerAppDomainHost appDomainHost;
+		EventHandlers eventHandlers;
+		ToolboxProvider toolbox;
 		
 		public FormsDesignerAppDomainHost AppDomainHost {
 			get { return appDomainHost; }
@@ -116,6 +121,10 @@ namespace ICSharpCode.FormsDesigner
 			
 			FileService.FileRemoving += this.FileServiceFileRemoving;
 			ICSharpCode.SharpDevelop.Debugging.DebuggerService.DebugStarting += this.DebugStarting;
+			
+			appDomain = null;
+			appDomainHost = FormsDesignerAppDomainHost.CreateFormsDesignerInAppDomain(ref appDomain, PrimaryFileName, new DomTypeLocator(PrimaryFileName), new DomGacWrapper(), new SharpDevelopCommandProvider(this), new ViewContentIFormsDesignerProxy(this), new FormsDesignerLoggingServiceImpl());
+			toolbox = new ToolboxProvider(appDomainHost);
 		}
 		
 		public FormsDesignerViewContent(IViewContent primaryViewContent, IDesignerLoaderProvider loaderProvider, IDesignerGenerator generator, IDesignerSourceProvider sourceProvider)
@@ -131,6 +140,7 @@ namespace ICSharpCode.FormsDesigner
 			this.generator = generator;
 			this.sourceProvider = sourceProvider;
 			this.sourceProvider.Attach(this);
+			this.eventHandlers = new FormsDesignerViewContent.EventHandlers(this);
 			
 			this.Files.Add(this.primaryViewContent.PrimaryFile);
 		}
@@ -151,8 +161,9 @@ namespace ICSharpCode.FormsDesigner
 		protected override void LoadInternal(OpenedFile file, System.IO.Stream stream)
 		{
 			LoggingService.Debug("Forms designer: Load " + file.FileName + "; inMasterLoadOperation=" + this.inMasterLoadOperation);
-			appDomain = null;
+			
-			appDomainHost = FormsDesignerAppDomainHost.CreateFormsDesignerInAppDomain(ref appDomain, new DomTypeLocator(PrimaryFileName), new DomGacWrapper());
+			propertyContainer.PropertyGridReplacementContent = FrameworkElementAdapters.ContractToViewAdapter(appDomainHost.CreatePropertyGrid());
+			// TODO : init PropertyGrid
 			
 			if (inMasterLoadOperation) {
 				
@@ -170,7 +181,7 @@ namespace ICSharpCode.FormsDesigner
 					throw new InvalidOperationException("Designer loading a source code file while DesignerLoader is loading and the view is not in a master load operation. This must not happen.");
 				}
 				
-				if (appDomainHost.DesignSurface != null) {
+				if (appDomainHost.DesignSurfaceName != null) {
 					this.UnloadDesigner();
 				}
 				
@@ -256,6 +267,85 @@ namespace ICSharpCode.FormsDesigner
 			this.Files.Add(file);
 		}
 		
+		#region Proxies
+		class EventHandlers : MarshalByRefObject
+		{
+			object vc;
+			
+			public EventHandlers(object vc)
+			{
+				this.vc = vc;
+			}
+			
+			internal void DesignerLoading(object sender, EventArgs e)
+			{
+//				vc.DesignerLoading(sender, e);
+			}
+			
+			internal void DesignerLoaded(object sender, LoadedEventArgs e)
+			{
+//				vc.DesignerLoaded(sender, e);
+			}
+			
+			internal void DesignerUnloading(object sender, EventArgs e)
+			{
+//				vc.DesignerUnloading(sender, e);
+			}
+			
+			internal void DesignerFlushed(object sender, EventArgs e)
+			{
+//				vc.DesignerFlushed(sender, e);
+			}
+			
+			internal void TransactionClose(object sender, DesignerTransactionCloseEventArgs e)
+			{
+//				vc.TransactionClose(sender, e);
+			}
+		}
+		
+		class ViewContentIFormsDesignerProxy : MarshalByRefObject, IFormsDesigner
+		{
+			FormsDesignerViewContent vc;
+			
+			public ViewContentIFormsDesignerProxy(FormsDesignerViewContent vc)
+			{
+				this.vc = vc;
+			}
+			
+			public IDesignerGenerator Generator {
+				get {
+					return vc.generator;
+				}
+			}
+			
+			public SharpDevelopDesignerOptions DesignerOptions {
+				get {
+					return vc.DesignerOptions;
+				}
+			}
+			
+			public IntPtr GetDialogOwnerWindowHandle()
+			{
+				return vc.GetDialogOwnerWindowHandle();
+			}
+			
+			public void ShowSourceCode()
+			{
+				vc.ShowSourceCode();
+			}
+			
+			public void ShowSourceCode(int lineNumber)
+			{
+				vc.ShowSourceCode(lineNumber);
+			}
+			
+			public void ShowSourceCode(IComponent component, EventDescriptor edesc, string methodName)
+			{
+				vc.ShowSourceCode(component, edesc, methodName);
+			}
+		}
+		#endregion
+		
 		void LoadDesigner()
 		{
 			LoggingService.Info("Form Designer: BEGIN INITIALIZE");
@@ -264,7 +354,7 @@ namespace ICSharpCode.FormsDesigner
 			
 			appDomainHost.Services.AddService(typeof(IMessageService), new FormsMessageService());
 			appDomainHost.Services.AddService(typeof(System.Windows.Forms.Design.IUIService), new UIService(this));
-			appDomainHost.Services.AddService(typeof(System.Drawing.Design.IToolboxService), ToolboxProvider.ToolboxService);
+			appDomainHost.Services.AddService(typeof(System.Drawing.Design.IToolboxService), toolbox.ToolboxService);
 			
 			appDomainHost.Services.AddService(typeof(IHelpService), new HelpService());
 			appDomainHost.Services.AddService(typeof(System.Drawing.Design.IPropertyValueUIService), new PropertyValueUIService());
@@ -284,33 +374,29 @@ namespace ICSharpCode.FormsDesigner
 				appDomainHost.Services.AddService(typeof(System.CodeDom.Compiler.CodeDomProvider), generator.CodeDomProvider);
 			}
 			
-			appDomainHost.DesignSurface.Loading += this.DesignerLoading;
+			appDomainHost.DesignSurfaceLoading += eventHandlers.DesignerLoading;
-			appDomainHost.DesignSurface.Loaded += this.DesignerLoaded;
+			appDomainHost.DesignSurfaceLoaded += eventHandlers.DesignerLoaded;
-			appDomainHost.DesignSurface.Flushed += this.DesignerFlushed;
+			appDomainHost.DesignSurfaceFlushed += eventHandlers.DesignerFlushed;
-			appDomainHost.DesignSurface.Unloading += this.DesignerUnloading;
+			appDomainHost.DesignSurfaceUnloading += eventHandlers.DesignerUnloading;
-			
+
-			appDomainHost.Services.AddService(typeof(System.ComponentModel.Design.IMenuCommandService), new ICSharpCode.FormsDesigner.Services.MenuCommandService(new SharpDevelopCommandProvider(this), appDomainHost.DesignSurface));
+			this.loader = new SharpDevelopDesignerLoader(appDomainHost, generator, loaderProvider.CreateLoader(generator));
-			ICSharpCode.FormsDesigner.Services.EventBindingService eventBindingService = new ICSharpCode.FormsDesigner.Services.EventBindingService(this, appDomainHost.DesignSurface);
+			appDomainHost.BeginDesignSurfaceLoad(this.loader);
-			appDomainHost.Services.AddService(typeof(System.ComponentModel.Design.IEventBindingService), eventBindingService);
+
-			
+			if (!appDomainHost.IsDesignSurfaceLoaded) {
-			this.loader = new SharpDevelopDesignerLoader(generator, loaderProvider.CreateLoader(generator));
+				throw new FormsDesignerLoadException(appDomainHost.LoadErrors);
-			appDomainHost.DesignSurface.BeginLoad(this.loader);
-			
-			if (!appDomainHost.DesignSurface.IsLoaded) {
-				throw new FormsDesignerLoadException(FormatLoadErrors(appDomainHost.DesignSurface));
 			}
 			
-			undoEngine = new FormsDesignerUndoEngine(appDomainHost.Host);
+			undoEngine = new FormsDesignerUndoEngine(appDomainHost);
 			appDomainHost.Services.AddService(typeof(UndoEngine), undoEngine);
 			
-			IComponentChangeService componentChangeService = (IComponentChangeService)appDomainHost.DesignSurface.GetService(typeof(IComponentChangeService));
+			IComponentChangeService componentChangeService = (IComponentChangeService)appDomainHost.GetService(typeof(IComponentChangeService));
 			componentChangeService.ComponentChanged += ComponentChanged;
 			componentChangeService.ComponentAdded   += ComponentListChanged;
 			componentChangeService.ComponentRemoved += ComponentListChanged;
 			componentChangeService.ComponentRename  += ComponentListChanged;
-			appDomainHost.Host.TransactionClosed += TransactionClose;
+			appDomainHost.Host.TransactionClosed += eventHandlers.TransactionClose;
 			
-			ISelectionService selectionService = (ISelectionService)appDomainHost.DesignSurface.GetService(typeof(ISelectionService));
+			ISelectionService selectionService = (ISelectionService)appDomainHost.GetService(typeof(ISelectionService));
 			selectionService.SelectionChanged  += SelectionChangedHandler;
 			
 			if (IsTabOrderMode) { // fixes SD2-1015
@@ -415,13 +501,13 @@ namespace ICSharpCode.FormsDesigner
 			// in the PropertyPad, "InvalidOperationException: The container cannot be disposed
 			// at design time" is thrown.
 			// This is solved by calling dispose after the double-click event has been processed.
-			if (appDomainHost.DesignSurface != null) {
+			if (appDomainHost.DesignSurfaceName != null) {
-				appDomainHost.DesignSurface.Loading -= this.DesignerLoading;
+				appDomainHost.DesignSurfaceLoading -= eventHandlers.DesignerLoading;
-				appDomainHost.DesignSurface.Loaded -= this.DesignerLoaded;
+				appDomainHost.DesignSurfaceLoaded -= eventHandlers.DesignerLoaded;
-				appDomainHost.DesignSurface.Flushed -= this.DesignerFlushed;
+				appDomainHost.DesignSurfaceFlushed -= eventHandlers.DesignerFlushed;
-				appDomainHost.DesignSurface.Unloading -= this.DesignerUnloading;
+				appDomainHost.DesignSurfaceUnloading -= eventHandlers.DesignerUnloading;
 				
-				IComponentChangeService componentChangeService = appDomainHost.DesignSurface.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
+				IComponentChangeService componentChangeService = appDomainHost.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
 				if (componentChangeService != null) {
 					componentChangeService.ComponentChanged -= ComponentChanged;
 					componentChangeService.ComponentAdded   -= ComponentListChanged;
@@ -429,18 +515,18 @@ namespace ICSharpCode.FormsDesigner
 					componentChangeService.ComponentRename  -= ComponentListChanged;
 				}
 				if (appDomainHost.Host != null) {
-					appDomainHost.Host.TransactionClosed -= TransactionClose;
+					appDomainHost.Host.TransactionClosed -= eventHandlers.TransactionClose;
 				}
 				
-				ISelectionService selectionService = appDomainHost.DesignSurface.GetService(typeof(ISelectionService)) as ISelectionService;
+				ISelectionService selectionService = appDomainHost.GetService(typeof(ISelectionService)) as ISelectionService;
 				if (selectionService != null) {
 					selectionService.SelectionChanged -= SelectionChangedHandler;
 				}
 				
 				if (disposing) {
-					appDomainHost.DesignSurface.Dispose();
+					appDomainHost.DisposeDesignSurface();
 				} else {
-					WorkbenchSingleton.SafeThreadAsyncCall(appDomainHost.DesignSurface.Dispose);
+					WorkbenchSingleton.SafeThreadAsyncCall(appDomainHost.DisposeDesignSurface);
 				}
 //				host.DesignSurface = null;
 			}
@@ -464,11 +550,11 @@ namespace ICSharpCode.FormsDesigner
 		
 		public void ShowHelp()
 		{
-			if (appDomainHost.Host == null) {
+			if (appDomainHost == null) {
 				return;
 			}
 			
-			ISelectionService selectionService = (ISelectionService)appDomainHost.Host.GetService(typeof(ISelectionService));
+			ISelectionService selectionService = (ISelectionService)appDomainHost.GetService(typeof(ISelectionService));
 			if (selectionService != null) {
 				Control ctl = selectionService.PrimarySelection as Control;
 				if (ctl != null) {
@@ -489,8 +575,8 @@ namespace ICSharpCode.FormsDesigner
 					throw new FormsDesignerLoadException(e.InnerException.Message, e);
 				} else if (e is FormsDesignerLoadException) {
 					throw;
-				} else if (appDomainHost.DesignSurface != null && !appDomainHost.DesignSurface.IsLoaded && appDomainHost.DesignSurface.LoadErrors != null) {
+				} else if (appDomainHost.DesignSurfaceName != null && !appDomainHost.IsDesignSurfaceLoaded && appDomainHost.LoadErrors != null) {
-					throw new FormsDesignerLoadException(FormatLoadErrors(appDomainHost.DesignSurface), e);
+					throw new FormsDesignerLoadException(appDomainHost.LoadErrors, e);
 				} else {
 					throw;
 				}
@@ -498,8 +584,8 @@ namespace ICSharpCode.FormsDesigner
 			}
 		}
 		
-		internal new Control UserContent {
+		internal new object UserContent {
-			get { return base.UserContent as Control; }
+			get { return base.UserContent; }
 			set { base.UserContent = value; }
 		}
 		
@@ -535,16 +621,16 @@ namespace ICSharpCode.FormsDesigner
 			if (e.HasSucceeded) {
 				// Display the designer on the view content
 				bool savedIsDirty = this.DesignerCodeFile.IsDirty;
-				Control designView = (Control)appDomainHost.DesignSurface.View;
+				System.Windows.FrameworkElement designView = FrameworkElementAdapters.ContractToViewAdapter(appDomainHost.DesignSurfaceView);
 				
-				designView.BackColor = Color.White;
+//				designView.BackColor = Color.White;
-				designView.RightToLeft = RightToLeft.No;
+//				designView.RightToLeft = RightToLeft.No;
 				// Make sure auto-scaling is based on the correct font.
 				// This is required on Vista, I don't know why it works correctly in XP
-				designView.Font = System.Windows.Forms.Control.DefaultFont;
+//				designView.Font = System.Windows.Forms.Control.DefaultFont;
 				
 				this.UserContent = designView;
-				LoggingService.Debug("FormsDesigner loaded, setting ActiveDesignSurface to " + appDomainHost.DesignSurface.ToString());
+				LoggingService.Debug("FormsDesigner loaded, setting ActiveDesignSurface to " + appDomainHost.DesignSurfaceName);
 				appDomainHost.ActivateDesignSurface();
 				this.DesignerCodeFile.IsDirty = savedIsDirty;
 				this.UpdatePropertyPad();
@@ -555,9 +641,7 @@ namespace ICSharpCode.FormsDesigner
 				// When a load error occurs there, we are not somewhere
 				// below the Load method which handles load errors.
 				// That is why we create an error text box here anyway.
-				TextBox errorTextBox = new TextBox() { Multiline=true, ScrollBars=ScrollBars.Both, ReadOnly=true, BackColor=SystemColors.Window, Dock=DockStyle.Fill };
+				ShowError(new Exception(appDomainHost.LoadErrors));
-				errorTextBox.Text = String.Concat(this.LoadErrorHeaderText, FormatLoadErrors(appDomainHost.DesignSurface));
-				this.UserContent = errorTextBox;
 			}
 		}
 		
@@ -567,19 +651,9 @@ namespace ICSharpCode.FormsDesigner
 			this.hasUnmergedChanges = false;
 		}
 		
-		static string FormatLoadErrors(DesignSurface designSurface)
-		{
-			StringBuilder sb = new StringBuilder();
-			foreach(Exception le in designSurface.LoadErrors) {
-				sb.AppendLine(le.ToString());
-				sb.AppendLine();
-			}
-			return sb.ToString();
-		}
-		
 		public virtual void MergeFormChanges()
 		{
-			if (this.HasLoadError || appDomainHost.DesignSurface == null) {
+			if (this.HasLoadError || appDomainHost.DesignSurfaceName == null) {
 				LoggingService.Debug("Forms designer: Cannot merge form changes because the designer is not loaded successfully or not loaded at all");
 				return;
 			} else if (this.DesignerCodeFile == null) {
@@ -587,7 +661,7 @@ namespace ICSharpCode.FormsDesigner
 			}
 			bool isDirty = this.DesignerCodeFile.IsDirty;
 			LoggingService.Info("Merging form changes...");
-			appDomainHost.DesignSurface.Flush();
+			appDomainHost.FlushDesignSurface();
 			this.resourceStore.CommitAllResourceChanges();
 			LoggingService.Info("Finished merging form changes");
 			hasUnmergedChanges = false;
@@ -624,31 +698,31 @@ namespace ICSharpCode.FormsDesigner
 		
 		void IsActiveViewContentChangedHandler(object sender, EventArgs e)
 		{
-			if (this.IsActiveViewContent) {
+			if (this.IsActiveViewContent && appDomainHost != null) {
 				
-				LoggingService.Debug("FormsDesigner view content activated, setting ActiveDesignSurface to " + ((appDomainHost.DesignSurface == null) ? "null" : appDomainHost.DesignSurface.ToString()));
+				LoggingService.Debug("FormsDesigner view content activated, setting ActiveDesignSurface to " + appDomainHost.DesignSurfaceName);
 				appDomainHost.ActivateDesignSurface();
 				
-				if (appDomainHost.DesignSurface != null && appDomainHost.Host != null) {
+				if (appDomainHost.DesignSurfaceName != null) {
 					// Reload designer when a referenced assembly has changed
 					// (the default Load/Save logic using OpenedFile cannot catch this case)
-//					if (this.typeResolutionService.ReferencedAssemblyChanged) {
+					if (appDomainHost.ReferencedAssemblyChanged) {
-//						IDesignerLoaderService loaderService = this.DesignSurface.GetService(typeof(IDesignerLoaderService)) as IDesignerLoaderService;
+						IDesignerLoaderService loaderService = appDomainHost.GetService(typeof(IDesignerLoaderService)) as IDesignerLoaderService;
-//						if (loaderService != null) {
+						if (loaderService != null) {
-//							if (!this.Host.Loading) {
+							if (!appDomainHost.Host.Loading) {
-//								LoggingService.Info("Forms designer reloading due to change in referenced assembly");
+								LoggingService.Info("Forms designer reloading due to change in referenced assembly");
-//								this.reloadPending = true;
+								this.reloadPending = true;
-//								if (!loaderService.Reload()) {
+								if (!loaderService.Reload()) {
-//									this.reloadPending = false;
+									this.reloadPending = false;
-//									MessageService.ShowMessage("The designer has detected that a referenced assembly has been changed, but the designer loader did not accept the reload command. Please reload the designer manually by closing and reopening this file.");
+									MessageService.ShowMessage("The designer has detected that a referenced assembly has been changed, but the designer loader did not accept the reload command. Please reload the designer manually by closing and reopening this file.");
-//								}
+								}
-//							} else {
+							} else {
-//								LoggingService.Debug("Forms designer detected change in referenced assembly, but is in load operation");
+								LoggingService.Debug("Forms designer detected change in referenced assembly, but is in load operation");
-//							}
+							}
-//						} else {
+						} else {
-//							MessageService.ShowMessage("The designer has detected that a referenced assembly has been changed, but it cannot reload itself because IDesignerLoaderService is unavailable. Please reload the designer manually by closing and reopening this file.");
+							MessageService.ShowMessage("The designer has detected that a referenced assembly has been changed, but it cannot reload itself because IDesignerLoaderService is unavailable. Please reload the designer manually by closing and reopening this file.");
-//						}
+						}
-//					}
+					}
 				}
 				
 			} else {
@@ -706,7 +780,7 @@ namespace ICSharpCode.FormsDesigner
 			if (appDomainHost.Host != null) {
 				propertyContainer.Host = appDomainHost.Host;
 				propertyContainer.SelectableObjects = appDomainHost.Host.Container.Components;
-				ISelectionService selectionService = (ISelectionService)appDomainHost.Host.GetService(typeof(ISelectionService));
+				ISelectionService selectionService = (ISelectionService)appDomainHost.GetService(typeof(ISelectionService));
 				if (selectionService != null) {
 					UpdatePropertyPadSelection(selectionService);
 				}
@@ -748,11 +822,11 @@ namespace ICSharpCode.FormsDesigner
 		#region IClipboardHandler implementation
 		bool IsMenuCommandEnabled(CommandID commandID)
 		{
-			if (appDomainHost.DesignSurface == null) {
+			if (appDomainHost.DesignSurfaceName == null) {
 				return false;
 			}
 			
-			IMenuCommandService menuCommandService = (IMenuCommandService)appDomainHost.DesignSurface.GetService(typeof(IMenuCommandService));
+			IMenuCommandService menuCommandService = (IMenuCommandService)appDomainHost.GetService(typeof(IMenuCommandService));
 			if (menuCommandService == null) {
 				return false;
 			}
@@ -793,37 +867,37 @@ namespace ICSharpCode.FormsDesigner
 		
 		public bool EnableSelectAll {
 			get {
-				return appDomainHost.DesignSurface != null;
+				return appDomainHost.DesignSurfaceName != null;
 			}
 		}
 		
 		public void Cut()
 		{
-			IMenuCommandService menuCommandService = (IMenuCommandService)appDomainHost.DesignSurface.GetService(typeof(IMenuCommandService));
+			IMenuCommandService menuCommandService = (IMenuCommandService)appDomainHost.GetService(typeof(IMenuCommandService));
 			menuCommandService.GlobalInvoke(StandardCommands.Cut);
 		}
 		
 		public void Copy()
 		{
-			IMenuCommandService menuCommandService = (IMenuCommandService)appDomainHost.DesignSurface.GetService(typeof(IMenuCommandService));
+			IMenuCommandService menuCommandService = (IMenuCommandService)appDomainHost.GetService(typeof(IMenuCommandService));
 			menuCommandService.GlobalInvoke(StandardCommands.Copy);
 		}
 		
 		public void Paste()
 		{
-			IMenuCommandService menuCommandService = (IMenuCommandService)appDomainHost.DesignSurface.GetService(typeof(IMenuCommandService));
+			IMenuCommandService menuCommandService = (IMenuCommandService)appDomainHost.GetService(typeof(IMenuCommandService));
 			menuCommandService.GlobalInvoke(StandardCommands.Paste);
 		}
 		
 		public void Delete()
 		{
-			IMenuCommandService menuCommandService = (IMenuCommandService)appDomainHost.DesignSurface.GetService(typeof(IMenuCommandService));
+			IMenuCommandService menuCommandService = (IMenuCommandService)appDomainHost.GetService(typeof(IMenuCommandService));
 			menuCommandService.GlobalInvoke(StandardCommands.Delete);
 		}
 		
 		public void SelectAll()
 		{
-			IMenuCommandService menuCommandService = (IMenuCommandService)appDomainHost.DesignSurface.GetService(typeof(IMenuCommandService));
+			IMenuCommandService menuCommandService = (IMenuCommandService)appDomainHost.GetService(typeof(IMenuCommandService));
 			menuCommandService.GlobalInvoke(StandardCommands.SelectAll);
 		}
 		#endregion
@@ -839,7 +913,7 @@ namespace ICSharpCode.FormsDesigner
 		public virtual void ShowTabOrder()
 		{
 			if (!IsTabOrderMode) {
-				IMenuCommandService menuCommandService = (IMenuCommandService)appDomainHost.DesignSurface.GetService(typeof(IMenuCommandService));
+				IMenuCommandService menuCommandService = (IMenuCommandService)appDomainHost.GetService(typeof(IMenuCommandService));
 				menuCommandService.GlobalInvoke(StandardCommands.TabOrder);
 				tabOrderMode = true;
 			}
@@ -848,7 +922,7 @@ namespace ICSharpCode.FormsDesigner
 		public virtual void HideTabOrder()
 		{
 			if (IsTabOrderMode) {
-				IMenuCommandService menuCommandService = (IMenuCommandService)appDomainHost.DesignSurface.GetService(typeof(IMenuCommandService));
+				IMenuCommandService menuCommandService = (IMenuCommandService)appDomainHost.GetService(typeof(IMenuCommandService));
 				menuCommandService.GlobalInvoke(StandardCommands.TabOrder);
 				tabOrderMode = false;
 			}
@@ -874,7 +948,7 @@ namespace ICSharpCode.FormsDesigner
 		}
 		
 		public virtual object ToolsContent {
-			get { return ToolboxProvider.FormsDesignerSideBar; }
+			get { return toolbox.FormsDesignerSideBar; }
 		}
 		
 		void FileServiceFileRemoving(object sender, FileCancelEventArgs e)

src/AddIns/DisplayBindings/FormsDesigner/FormsDesigner.AddIn/SecondaryDisplayBinding.cs

@@ -117,8 +117,6 @@ namespace ICSharpCode.FormsDesigner
 			IDesignerGenerator generator;
 			IDesignerSourceProvider sourceProvider;
 			
-			FormsDesignerLoggingService.Service = new FormsDesignerLoggingServiceImpl();
-			
 			switch (fileExtension) {
 				case ".cs":
 					loader    = new NRefactoryDesignerLoaderProvider(SupportedLanguage.CSharp);

src/AddIns/DisplayBindings/FormsDesigner/FormsDesigner.AddIn/Services/DomTypeLocator.cs

@@ -9,7 +9,7 @@ using ICSharpCode.SharpDevelop.Project;
 
 namespace ICSharpCode.FormsDesigner.Services
 {
-	public class DomTypeLocator : ITypeLocator
+	public class DomTypeLocator : MarshalByRefObject, ITypeLocator
 	{
 		string formSourceFileName;
 		IProjectContent callingProject;
@@ -117,7 +117,7 @@ namespace ICSharpCode.FormsDesigner.Services
 		}
 	}
 	
-	public class DomGacWrapper : IGacWrapper
+	public class DomGacWrapper : MarshalByRefObject, IGacWrapper
 	{
 		public bool IsGacAssembly(string path)
 		{

src/AddIns/DisplayBindings/FormsDesigner/FormsDesigner.AddIn/Services/FormsMessageService.cs

@@ -38,5 +38,10 @@ namespace ICSharpCode.FormsDesigner.Services
 				return sw.ToString().TrimEnd();
 			}
 		}
+		
+		public void ShowPropertiesPad()
+		{
+			WorkbenchSingleton.Workbench.GetPad(typeof(PropertyPad)).BringPadToFront();
+		}
 	}
 }

src/AddIns/DisplayBindings/FormsDesigner/FormsDesigner.AddIn/Services/SharpDevelopCommandProvider.cs

@@ -2,17 +2,20 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
+using System.Collections.Generic;
 using System.ComponentModel.Design;
 using System.Drawing;
 using System.Windows.Forms;
 using System.Windows.Forms.Design;
+using System.Windows.Forms.Integration;
 
 using ICSharpCode.Core.WinForms;
 using ICSharpCode.FormsDesigner.Commands;
+using ICSharpCode.SharpDevelop.Gui;
 
 namespace ICSharpCode.FormsDesigner.Services
 {
-	public class SharpDevelopCommandProvider : ICommandProvider
+	public class SharpDevelopCommandProvider : MarshalByRefObject, ICommandProvider
 	{
 		FormsDesignerViewContent vc;
 		
@@ -21,23 +24,6 @@ namespace ICSharpCode.FormsDesigner.Services
 			this.vc = vc;
 		}
 		
-		public void InitializeGlobalCommands(IMenuCommandService service)
-		{
-			// Most commands like Delete, Cut, Copy and paste are all added to the MenuCommandService
-			// by the other services like the DesignerHost.  Commands like ViewCode and ShowProperties
-			// need to be added by the IDE because only the IDE would know how to perform those actions.
-			// This allows people to call MenuCommandSerice.GlobalInvoke( StandardCommands.ViewCode );
-			// from designers and what not.  .Net Control Designers like the TableLayoutPanelDesigner
-			// build up their own context menus instead of letting the MenuCommandService build it.
-			// The context menus they build up are in the format that Visual studio expects and invokes
-			// the ViewCode and Properties commands by using GlobalInvoke.
-
-			AbstractFormsDesignerCommand viewCodeCommand = new ViewCode();
-			AbstractFormsDesignerCommand propertiesCodeCommand = new ShowProperties();
-			service.AddCommand(new System.ComponentModel.Design.MenuCommand(viewCodeCommand.CommandCallBack, viewCodeCommand.CommandID));
-			service.AddCommand(new System.ComponentModel.Design.MenuCommand(propertiesCodeCommand.CommandCallBack, propertiesCodeCommand.CommandID));
-		}
-		
 		public void ShowContextMenu(CommandID menuID, int x, int y)
 		{
 			string contextMenuPath = "/SharpDevelop/FormsDesigner/ContextMenus/";
@@ -54,7 +40,7 @@ namespace ICSharpCode.FormsDesigner.Services
 				throw new Exception();
 			}
 			
-			Control panel = vc.UserContent;
+			Control panel = ((WindowsFormsHost)vc.UserContent).Child;
 			if (panel != null) {
 				Point p = panel.PointToClient(new Point(x, y));
 				

src/AddIns/DisplayBindings/FormsDesigner/FormsDesigner.AddIn/Toolbox/SideTabDesigner.cs

@@ -32,19 +32,27 @@ namespace ICSharpCode.FormsDesigner.Gui
 			this.Items.Add(new SideTabItemDesigner());
 		}
 		
+		ToolboxProvider toolbox;
+		
+		public ToolboxProvider Toolbox {
+			get { return toolbox; }
+		}
+		
 		///<summary>Load an assembly's controls</summary>
-		public SideTabDesigner(SideBarControl sideBar, Category category, IToolboxService toolboxService) : this(sideBar, category.Name, toolboxService)
+		public SideTabDesigner(ToolboxProvider toolbox, SideBarControl sideBar, Category category, IToolboxService toolboxService)
+			: this(sideBar, category.Name, toolboxService)
 		{
+			this.toolbox = toolbox;
 			foreach (ToolComponent component in category.ToolComponents) {
 				if (component.IsEnabled) {
 					ToolboxItem toolboxItem = new ToolboxItem();
 					toolboxItem.TypeName    = component.FullName;
-					toolboxItem.Bitmap      = ToolboxProvider.ComponentLibraryLoader.GetIcon(component);
+					toolboxItem.Bitmap      = toolbox.ComponentLibraryLoader.GetIcon(component);
 					toolboxItem.DisplayName = component.Name;
 					Assembly asm = component.LoadAssembly();
 					toolboxItem.AssemblyName = asm.GetName();
 					
-					this.Items.Add(new SideTabItemDesigner(toolboxItem));
+					this.Items.Add(new SideTabItemDesigner(toolbox, toolboxItem));
 				}
 			}
 		}

src/AddIns/DisplayBindings/FormsDesigner/FormsDesigner.AddIn/Toolbox/SideTabItemDesigner.cs

@@ -28,17 +28,21 @@ namespace ICSharpCode.FormsDesigner.Gui
 {
 	public class SideTabItemDesigner : SharpDevelopSideTabItem
 	{
+		ToolboxProvider provider;
+		
 		///<summary>create a tabitem from a toolboxitem. It init Icon and name from the tag</summary>
-		public SideTabItemDesigner(ToolboxItem tag) : base(tag.DisplayName, tag)
+		public SideTabItemDesigner(ToolboxProvider provider, ToolboxItem tag) : base(tag.DisplayName, tag)
 		{
+			this.provider = provider;
 			CanBeRenamed = false;
 			this.Icon = tag.Bitmap;
 			ReloadToolBox();
 		}
 		
 		///<summary>create a tabitem from a toolboxitem. It init Icon from the tag</summary>
-		public SideTabItemDesigner(string name, ToolboxItem tag) : base(name, tag)
+		public SideTabItemDesigner(ToolboxProvider provider, string name, ToolboxItem tag) : base(name, tag)
 		{
+			this.provider = provider;
 			CanBeRenamed = false;
 			this.Icon = tag.Bitmap;
 			ReloadToolBox();
@@ -62,7 +66,7 @@ namespace ICSharpCode.FormsDesigner.Gui
 		public void ReloadToolBox()
 		{
 			if (this.Name != "Pointer") {
-				ToolboxProvider.ToolboxService.AddToolboxItem(this.Tag as ToolboxItem);
+				provider.ToolboxService.AddToolboxItem(this.Tag as ToolboxItem);
 			}
 		}
 	}

src/AddIns/DisplayBindings/FormsDesigner/FormsDesigner.AddIn/Toolbox/ToolboxProvider.cs

@@ -20,49 +20,53 @@ namespace ICSharpCode.FormsDesigner
 {
 	public class ToolboxProvider
 	{
-		static ICSharpCode.FormsDesigner.Services.ToolboxService toolboxService = null;
+		ICSharpCode.FormsDesigner.Services.ToolboxService toolboxService = null;
+		SharpDevelopSideBar sideBar;
+		CustomComponentsSideTab customTab;
+		ComponentLibraryLoader componentLibraryLoader;
+		IServiceProvider services;
 		
-		static SharpDevelopSideBar sideBar;
+		public ToolboxProvider(IServiceProvider services)
-		
+		{
-		static CustomComponentsSideTab customTab;
+			this.services = services;
-		
+			componentLibraryLoader = new ComponentLibraryLoader(services);
-		static ComponentLibraryLoader componentLibraryLoader = new ComponentLibraryLoader();
+		}
 
-		public static ComponentLibraryLoader ComponentLibraryLoader {
+		public ComponentLibraryLoader ComponentLibraryLoader {
 			get {
 				return componentLibraryLoader;
 			}
 		}
-		public static ICSharpCode.FormsDesigner.Services.ToolboxService ToolboxService {
+		public ICSharpCode.FormsDesigner.Services.ToolboxService ToolboxService {
 			get {
 				CreateToolboxService();
 				return toolboxService;
 			}
 		}
 		
-		public static SharpDevelopSideBar FormsDesignerSideBar {
+		public SharpDevelopSideBar FormsDesignerSideBar {
 			get {
 				CreateToolboxService();
 				return sideBar;
 			}
 		}
 		
-		static void CreateToolboxService()
+		void CreateToolboxService()
 		{
 			Debug.Assert(WorkbenchSingleton.InvokeRequired == false);
 			if (toolboxService == null) {
 				sideBar = new SharpDevelopSideBar();
 				LoadToolbox();
-				toolboxService = new ICSharpCode.FormsDesigner.Services.ToolboxService();
+				toolboxService = new ICSharpCode.FormsDesigner.Services.ToolboxService(services);
 				ReloadSideTabs(false);
 				toolboxService.SelectedItemUsed += new EventHandler(SelectedToolUsedHandler);
 				sideBar.SideTabDeleted += SideTabDeleted;
 			}
 		}
 		
-		static string componentLibraryFile = "SharpDevelopControlLibrary.sdcl";
+		string componentLibraryFile = "SharpDevelopControlLibrary.sdcl";
 		
-		static string GlobalConfigFile {
+		string GlobalConfigFile {
 			get {
 				return PropertyService.DataDirectory + Path.DirectorySeparatorChar +
 					"options" + Path.DirectorySeparatorChar +
@@ -70,18 +74,18 @@ namespace ICSharpCode.FormsDesigner
 			}
 		}
 		
-		static string UserConfigFile {
+		string UserConfigFile {
 			get {
 				return Path.Combine(PropertyService.ConfigDirectory, componentLibraryFile);
 			}
 		}
 		
-		public static void SaveToolbox()
+		public void SaveToolbox()
 		{
 			componentLibraryLoader.SaveToolComponentLibrary(UserConfigFile);
 		}
 		
-		public static void LoadToolbox()
+		public void LoadToolbox()
 		{
 			if (!componentLibraryLoader.LoadToolComponentLibrary(UserConfigFile)) {
 				if (!componentLibraryLoader.LoadToolComponentLibrary(GlobalConfigFile)) {
@@ -91,7 +95,7 @@ namespace ICSharpCode.FormsDesigner
 			}
 		}
 		
-		public static void ReloadSideTabs(bool doInsert)
+		public void ReloadSideTabs(bool doInsert)
 		{
 			CreateToolboxService();
 			
@@ -99,7 +103,7 @@ namespace ICSharpCode.FormsDesigner
 			foreach (Category category in componentLibraryLoader.Categories) {
 				if (category.IsEnabled) {
 					try {
-						SideTabDesigner newTab = new SideTabDesigner(sideBar, category, toolboxService);
+						SideTabDesigner newTab = new SideTabDesigner(this, sideBar, category, toolboxService);
 						newTab.ItemRemoved += SideTabItemRemoved;
 						newTab.ItemsExchanged += SideTabItemsExchanged;
 						sideBar.Tabs.Add(newTab);
@@ -111,7 +115,7 @@ namespace ICSharpCode.FormsDesigner
 			if (customTab != null) {
 				customTab.Dispose();
 			}
-			customTab = new CustomComponentsSideTab(sideBar, ResourceService.GetString("ICSharpCode.SharpDevelop.FormDesigner.ToolboxProvider.CustomComponents"), toolboxService);
+			customTab = new CustomComponentsSideTab(this, sideBar, ResourceService.GetString("ICSharpCode.SharpDevelop.FormDesigner.ToolboxProvider.CustomComponents"), toolboxService);
 			customTab.ItemRemoved += SideTabItemRemoved;
 			customTab.ItemsExchanged += SideTabItemsExchanged;
 			sideBar.Tabs.Add(customTab);
@@ -121,7 +125,7 @@ namespace ICSharpCode.FormsDesigner
 			toolboxService.SetSelectedToolboxItem(null);
 		}
 		
-		static void SelectedToolUsedHandler(object sender, EventArgs e)
+		void SelectedToolUsedHandler(object sender, EventArgs e)
 		{
 			LoggingService.Debug("SelectedToolUsedHandler");
 			SideTab tab = sideBar.ActiveTab;
@@ -163,7 +167,7 @@ namespace ICSharpCode.FormsDesigner
 			sideBar.Refresh();
 		}
 		
-		static bool ProjectContainsReference(IProject project, AssemblyName referenceName)
+		bool ProjectContainsReference(IProject project, AssemblyName referenceName)
 		{
 			LoggingService.Debug("Checking project has reference: " + referenceName.FullName);
 			bool isAlreadyInRefFolder = false;
@@ -194,11 +198,11 @@ namespace ICSharpCode.FormsDesigner
 			return isAlreadyInRefFolder;
 		}
 		
-		static void AddReferenceToProject(IProject project, AssemblyName referenceName)
+		void AddReferenceToProject(IProject project, AssemblyName referenceName)
 		{
 			LoggingService.Warn("Adding reference to project: " + referenceName.FullName);
 			ReferenceProjectItem reference = new ReferenceProjectItem(project, "Reference");
-			ToolComponent toolComponent = ToolboxProvider.ComponentLibraryLoader.GetToolComponent(referenceName.FullName);
+			ToolComponent toolComponent = ComponentLibraryLoader.GetToolComponent(referenceName.FullName);
 			if (toolComponent == null || toolComponent.HintPath == null) {
 				reference.Include = referenceName.FullName;
 				LoggingService.Debug("Added GAC reference to project: " + reference.Include);
@@ -232,7 +236,7 @@ namespace ICSharpCode.FormsDesigner
 			return null;
 		}
 
-		static void AddProjectReferenceToProject(IProject project, IProject referenceTo)
+		void AddProjectReferenceToProject(IProject project, IProject referenceTo)
 		{
 			LoggingService.Warn("Adding project reference to project.");
 			ProjectReferenceProjectItem reference = new ProjectReferenceProjectItem(project, referenceTo);
@@ -240,13 +244,13 @@ namespace ICSharpCode.FormsDesigner
 			project.Save();
 		}
 		
-		static void SideTabDeleted(object source, SideTabEventArgs e)
+		void SideTabDeleted(object source, SideTabEventArgs e)
 		{
 			componentLibraryLoader.RemoveCategory(e.SideTab.Name);
 			SaveToolbox();
 		}
 		
-		static void SideTabItemRemoved(object source, SideTabItemEventArgs e)
+		void SideTabItemRemoved(object source, SideTabItemEventArgs e)
 		{
 			SideTabDesigner tab = source as SideTabDesigner;
 			ToolboxItem toolboxItem = e.Item.Tag as ToolboxItem;
@@ -256,7 +260,7 @@ namespace ICSharpCode.FormsDesigner
 			}
 		}
 		
-		static void SideTabItemsExchanged(object source, SideTabItemExchangeEventArgs e)
+		void SideTabItemsExchanged(object source, SideTabItemExchangeEventArgs e)
 		{
 			SideTabDesigner tab = source as SideTabDesigner;
 			ToolboxItem toolboxItem1 = e.Item1.Tag as ToolboxItem;

src/AddIns/DisplayBindings/FormsDesigner/Project/FormsDesignerAppDomainHost.cs

@@ -1,9 +1,16 @@
 // Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 using System;
+using System.AddIn.Contract;
+using System.AddIn.Pipeline;
 using System.ComponentModel.Design;
 using System.ComponentModel.Design.Serialization;
-
+using System.IO;
+using System.Reflection;
+using System.Runtime.Remoting.Lifetime;
+using System.Text;
+using System.Windows.Forms;
+using System.Windows.Forms.Integration;
 using ICSharpCode.FormsDesigner.Services;
 
 namespace ICSharpCode.FormsDesigner
@@ -11,15 +18,14 @@ namespace ICSharpCode.FormsDesigner
 	/// <summary>
 	/// Description of FormsDesignerAppDomainHost.
 	/// </summary>
-	public class FormsDesignerAppDomainHost : MarshalByRefObject
+	public class FormsDesignerAppDomainHost : MarshalByRefObject, IServiceProvider
 	{
 		DesignSurface designSurface;
 		ServiceContainer container;
-		string fileName;
 		
-		public DesignSurface DesignSurface {
+		public string DesignSurfaceName {
 			get {
-				return designSurface;
+				return (designSurface == null) ? null : designSurface.ToString();
 			}
 		}
 		
@@ -37,12 +43,12 @@ namespace ICSharpCode.FormsDesigner
 		
 		static readonly DesignSurfaceManager designSurfaceManager = new DesignSurfaceManager();
 		
-		public static FormsDesignerAppDomainHost CreateFormsDesignerInAppDomain(ref AppDomain appDomain, ITypeLocator typeLocator, IGacWrapper gacWrapper)
+		public static FormsDesignerAppDomainHost CreateFormsDesignerInAppDomain(ref AppDomain appDomain, string fileName, ITypeLocator typeLocator, IGacWrapper gacWrapper, ICommandProvider commands, IFormsDesigner formsDesignerProxy, IFormsDesignerLoggingService logger)
 		{
 			if (appDomain == null) {
 				// Construct and initialize settings for a second AppDomain.
 				AppDomainSetup formsDesignerAppDomainSetup = new AppDomainSetup();
-				// bamlDecompilerAppDomainSetup.ApplicationBase = "file:///" + Path.GetDirectoryName(assemblyFileName);
+				formsDesignerAppDomainSetup.ApplicationBase = Path.GetDirectoryName(typeof(FormsDesignerAppDomainHost).Assembly.Location);
 				formsDesignerAppDomainSetup.DisallowBindingRedirects = false;
 				formsDesignerAppDomainSetup.DisallowCodeDownload = true;
 				formsDesignerAppDomainSetup.ConfigurationFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile;
@@ -51,24 +57,93 @@ namespace ICSharpCode.FormsDesigner
 				appDomain = AppDomain.CreateDomain("FormsDesigner AD", null, formsDesignerAppDomainSetup);
 			}
 			var host = (FormsDesignerAppDomainHost)appDomain.CreateInstanceAndUnwrap(typeof(FormsDesignerAppDomainHost).Assembly.FullName, typeof(FormsDesignerAppDomainHost).FullName);
-			
+			host.Initialize(fileName, typeLocator, gacWrapper, commands, formsDesignerProxy, logger);
-			ServiceContainer container = host.InitServices(typeLocator, gacWrapper);
-			host.designSurface = designSurfaceManager.CreateDesignSurface(container);
-			
 			return host;
 		}
 		
-		ServiceContainer InitServices(ITypeLocator typeLocator, IGacWrapper gacWrapper)
+		void Initialize(string fileName, ITypeLocator typeLocator, IGacWrapper gacWrapper, ICommandProvider commands, IFormsDesigner formsDesignerProxy, IFormsDesignerLoggingService logger)
 		{
 			this.container = new DefaultServiceContainer();
-			
+			container.AddService(typeof(IFormsDesignerLoggingService), logger);
 			container.AddService(typeof(System.Drawing.Design.IPropertyValueUIService), new PropertyValueUIService());
 			container.AddService(typeof(ITypeResolutionService), new TypeResolutionService(fileName, container, typeLocator));
-			container.AddService(typeof(ITypeDiscoveryService), new TypeDiscoveryService(gacWrapper));
+			container.AddService(typeof(ITypeDiscoveryService), new TypeDiscoveryService(gacWrapper, container));
-			container.AddService(typeof(MemberRelationshipService), new DefaultMemberRelationshipService());
+			container.AddService(typeof(MemberRelationshipService), new DefaultMemberRelationshipService(container));
+			
+			this.designSurface = designSurfaceManager.CreateDesignSurface(container);
 			
-			return container;
+			container.AddService(typeof(System.ComponentModel.Design.IMenuCommandService), new ICSharpCode.FormsDesigner.Services.MenuCommandService(commands, designSurface).Proxy);
+			Services.EventBindingService eventBindingService = new Services.EventBindingService(formsDesignerProxy, designSurface);
+			container.AddService(typeof(System.ComponentModel.Design.IEventBindingService), eventBindingService);
+			
+			InitializeEvents();
+		}
+		
+		#region Events
+		public event EventHandler DesignSurfaceLoading;
+		
+		protected virtual void OnDesignSurfaceLoading(EventArgs e)
+		{
+			if (DesignSurfaceLoading != null) {
+				DesignSurfaceLoading(this, e);
+			}
+		}
+		
+		public event LoadedEventHandler DesignSurfaceLoaded;
+		
+		protected virtual void OnDesignSurfaceLoaded(LoadedEventArgs e)
+		{
+			if (DesignSurfaceLoaded != null) {
+				DesignSurfaceLoaded(this, e);
+			}
+		}
+		
+		public event EventHandler DesignSurfaceFlushed;
+		
+		protected virtual void OnDesignSurfaceFlushed(EventArgs e)
+		{
+			if (DesignSurfaceFlushed != null) {
+				DesignSurfaceFlushed(this, e);
+			}
+		}
+
+		public event EventHandler DesignSurfaceUnloading;
+		
+		protected virtual void OnDesignSurfaceUnloading(EventArgs e)
+		{
+			if (DesignSurfaceUnloading != null) {
+				DesignSurfaceUnloading(this, e);
+			}
+		}
+		
+		void InitializeEvents()
+		{
+			designSurface.Loading += designSurface_Loading;
+			designSurface.Loaded += designSurface_Loaded;
+			designSurface.Flushed += designSurface_Flushed;
+			designSurface.Unloading += designSurface_Unloading;
+		}
+
+		void designSurface_Unloading(object sender, EventArgs e)
+		{
+			OnDesignSurfaceUnloading(e);
+		}
+
+		void designSurface_Flushed(object sender, EventArgs e)
+		{
+			OnDesignSurfaceFlushed(e);
+		}
+
+		void designSurface_Loaded(object sender, LoadedEventArgs e)
+		{
+			OnDesignSurfaceLoaded(e);
 		}
+
+		void designSurface_Loading(object sender, EventArgs e)
+		{
+			OnDesignSurfaceLoading(e);
+		}
+		#endregion
 		
 		public void ActivateDesignSurface()
 		{
@@ -83,5 +158,75 @@ namespace ICSharpCode.FormsDesigner
 		public bool IsActiveDesignSurface {
 			get { return designSurfaceManager.ActiveDesignSurface == this.designSurface; }
 		}
+		
+		public object GetService(Type serviceType)
+		{
+			return designSurface.GetService(serviceType);
+		}
+		
+		public void BeginDesignSurfaceLoad(DesignerLoader loader)
+		{
+			designSurface.BeginLoad(loader);
+		}
+		
+		static string FormatLoadErrors(DesignSurface designSurface)
+		{
+			StringBuilder sb = new StringBuilder();
+			foreach(Exception le in designSurface.LoadErrors) {
+				sb.AppendLine(le.ToString());
+				sb.AppendLine();
+			}
+			return sb.ToString();
+		}
+		
+		public string LoadErrors {
+			get { return FormatLoadErrors(designSurface); }
+		}
+		
+		public bool IsDesignSurfaceLoaded {
+			get { return designSurface.IsLoaded; }
+		}
+		
+		public bool ReferencedAssemblyChanged {
+			get { return ((TypeResolutionService)GetService(typeof(ITypeResolutionService))).ReferencedAssemblyChanged; }
+		}
+		
+		public void FlushDesignSurface()
+		{
+			designSurface.Flush();
+		}
+		
+		WindowsFormsHost host;
+		
+		public INativeHandleContract DesignSurfaceView {
+			get {
+				if (host == null) {
+					host = new WindowsFormsHost();
+					host.Child = (Control)designSurface.View;
+				}
+				
+				return FrameworkElementAdapters.ViewToContractAdapter(host);
+			}
+		}
+		
+		public void DisposeDesignSurface()
+		{
+			designSurface.Dispose();
+		}
+		
+		public INativeHandleContract CreatePropertyGrid()
+		{
+			var grid = new PropertyGrid() { Dock = DockStyle.Fill };
+			var host = new WindowsFormsHost();
+			host.Child = grid;
+			
+			return FrameworkElementAdapters.ViewToContractAdapter(host);
+		}
+		
+		public IFormsDesignerLoggingService LoggingService {
+			get {
+				return GetService(typeof(IFormsDesignerLoggingService)) as IFormsDesignerLoggingService;
+			}
+		}
 	}
 }

src/AddIns/DisplayBindings/FormsDesigner/Project/Src/DesignerAppDomainManager.cs

@@ -14,7 +14,7 @@ namespace ICSharpCode.FormsDesigner
 		/// Gets whether this is a designer domain (and not the SharpDevelop domain)
 		/// </summary>
 		public static bool IsDesignerDomain {
-			get { throw new NotImplementedException(); }
+			get { return AppDomain.CurrentDomain.FriendlyName == "FormsDesigner AD"; }
 		}
 	}
 }

src/AddIns/DisplayBindings/FormsDesigner/Project/Src/DesignerLoader/SharpDevelopDesignerLoader.cs

@@ -23,6 +23,7 @@ namespace ICSharpCode.FormsDesigner
 		ITypeResolutionService typeResolutionService = null;
 		readonly IDesignerLoader loader;
 		readonly IDesignerGenerator generator;
+		readonly IFormsDesignerLoggingService logger;
 		
 		public override bool Loading {
 			get { return base.Loading || loading; }
@@ -44,7 +45,7 @@ namespace ICSharpCode.FormsDesigner
 			get { return this.generator; }
 		}
 		
-		public SharpDevelopDesignerLoader(IDesignerGenerator generator, IDesignerLoader loader)
+		public SharpDevelopDesignerLoader(IServiceProvider services, IDesignerGenerator generator, IDesignerLoader loader)
 		{
 			if (generator == null) {
 				throw new ArgumentNullException("generator", "Generator cannot be null");
@@ -54,6 +55,7 @@ namespace ICSharpCode.FormsDesigner
 
 			this.generator = generator;
 			this.loader = loader;
+			this.logger = (IFormsDesignerLoggingService)services.GetService(typeof(IFormsDesignerLoggingService));
 		}
 		
 		public override void Dispose()
@@ -61,10 +63,10 @@ namespace ICSharpCode.FormsDesigner
 			try {
 				IComponentChangeService componentChangeService = (IComponentChangeService)this.GetService(typeof(IComponentChangeService));
 				if (componentChangeService != null) {
-					FormsDesignerLoggingService.Debug("Forms designer: Removing ComponentAdded handler for nested container setup");
+					logger.Debug("Forms designer: Removing ComponentAdded handler for nested container setup");
 					componentChangeService.ComponentAdded -= ComponentContainerSetUp;
 				} else {
-					FormsDesignerLoggingService.Info("Forms designer: Could not remove ComponentAdding handler because IComponentChangeService is no longer available");
+					logger.Info("Forms designer: Could not remove ComponentAdding handler because IComponentChangeService is no longer available");
 				}
 			} finally {
 				base.Dispose();
@@ -80,7 +82,7 @@ namespace ICSharpCode.FormsDesigner
 			base.BeginLoad(host);
 		}
 		
-		static void ComponentContainerSetUp(object sender, ComponentEventArgs e)
+		void ComponentContainerSetUp(object sender, ComponentEventArgs e)
 		{
 			// HACK: This reflection mess fixes SD2-1374 and SD2-1375. However I am not sure why it is needed in the first place.
 			// There seems to be a problem with the nested container class used
@@ -98,7 +100,7 @@ namespace ICSharpCode.FormsDesigner
 			if (nestedContainer != null) {
 				MethodInfo getServiceMethod = nestedContainer.GetType().GetMethod("GetService", BindingFlags.Instance | BindingFlags.NonPublic, null, new [] {typeof(Type)}, null);
 				if (getServiceMethod != null) {
-					FormsDesignerLoggingService.Debug("Forms designer: Initializing nested service container of " + e.Component.ToString() + " using Reflection");
+					logger.Debug("Forms designer: Initializing nested service container of " + e.Component.ToString() + " using Reflection");
 					getServiceMethod.Invoke(nestedContainer, BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.NonPublic, null, new [] {typeof(IServiceContainer)}, null);
 				}
 			}
@@ -110,16 +112,16 @@ namespace ICSharpCode.FormsDesigner
 			
 			CodeDomLocalizationProvider localizationProvider = new CodeDomLocalizationProvider(designerLoaderHost, model);
 			IDesignerSerializationManager manager = (IDesignerSerializationManager)designerLoaderHost.GetService(typeof(IDesignerSerializationManager));
-			manager.AddSerializationProvider(new SharpDevelopSerializationProvider());
+			manager.AddSerializationProvider(new SharpDevelopSerializationProvider(designerLoaderHost));
 			manager.AddSerializationProvider(localizationProvider);
 			base.Initialize();
 			
 			IComponentChangeService componentChangeService = (IComponentChangeService)this.GetService(typeof(IComponentChangeService));
 			if (componentChangeService != null) {
-				FormsDesignerLoggingService.Debug("Forms designer: Adding ComponentAdded handler for nested container setup");
+				logger.Debug("Forms designer: Adding ComponentAdded handler for nested container setup");
 				componentChangeService.ComponentAdded += ComponentContainerSetUp;
 			} else {
-				FormsDesignerLoggingService.Warn("Forms designer: Cannot add ComponentAdded handler for nested container setup because IComponentChangeService is unavailable");
+				logger.Warn("Forms designer: Cannot add ComponentAdded handler for nested container setup because IComponentChangeService is unavailable");
 			}
 		}
 		
@@ -132,13 +134,13 @@ namespace ICSharpCode.FormsDesigner
 			try {
 				base.OnEndLoad(successful, errors);
 			} catch(ExceptionCollection e) {
-				FormsDesignerLoggingService.Error("DesignerLoader.OnEndLoad error " + e.Message, e);
+				logger.Error("DesignerLoader.OnEndLoad error " + e.Message, e);
 				foreach(Exception ine in e.Exceptions) {
-					FormsDesignerLoggingService.Error("DesignerLoader.OnEndLoad error " + ine.Message, ine);
+					logger.Error("DesignerLoader.OnEndLoad error " + ine.Message, ine);
 				}
 				throw;
 			} catch(Exception e) {
-				FormsDesignerLoggingService.Error("DesignerLoader.OnEndLoad error " + e.Message, e);
+				logger.Error("DesignerLoader.OnEndLoad error " + e.Message, e);
 				throw;
 			}
 		}

src/AddIns/DisplayBindings/FormsDesigner/Project/Src/Gui/ComponentLibraryLoader.cs

@@ -223,6 +223,15 @@ namespace ICSharpCode.FormsDesigner.Gui
 		ArrayList assemblies = new ArrayList();
 		ArrayList categories = new ArrayList();
 		
+		IServiceProvider provider;
+		IFormsDesignerLoggingService logger;
+		
+		public ComponentLibraryLoader(IServiceProvider provider)
+		{
+			this.provider = provider;
+			logger = (IFormsDesignerLoggingService)provider.GetService(typeof(IFormsDesignerLoggingService));
+		}
+		
 		public ArrayList Categories {
 			get {
 				return categories;
@@ -326,15 +335,15 @@ namespace ICSharpCode.FormsDesigner.Gui
 						Category newCategory = new Category(name);
 						foreach (XmlNode componentNode in node.ChildNodes) {
 							ToolComponent newToolComponent = new ToolComponent(componentNode.Attributes["class"].InnerText,
-								(ComponentAssembly)assemblies[Int32.Parse(componentNode.Attributes["assembly"].InnerText)],
+							                                                   (ComponentAssembly)assemblies[Int32.Parse(componentNode.Attributes["assembly"].InnerText)],
-								IsEnabled(componentNode.Attributes["enabled"]));
+							                                                   IsEnabled(componentNode.Attributes["enabled"]));
 							newCategory.ToolComponents.Add(newToolComponent);
 						}
 						categories.Add(newCategory);
 					}
 				}
 			} catch (Exception e) {
-				FormsDesignerLoggingService.Warn("ComponentLibraryLoader.LoadToolComponentLibrary: " + e.Message);
+				logger.Warn("ComponentLibraryLoader.LoadToolComponentLibrary: " + e.Message);
 				return false;
 			}
 			return true;
@@ -364,7 +373,7 @@ namespace ICSharpCode.FormsDesigner.Gui
 						b.MakeTransparent();
 					}
 				} catch (Exception e) {
-					FormsDesignerLoggingService.Warn("ComponentLibraryLoader.GetIcon: " + e.Message);
+					logger.Warn("ComponentLibraryLoader.GetIcon: " + e.Message);
 				}
 			}
 			

src/AddIns/DisplayBindings/FormsDesigner/Project/Src/Gui/CustomComponentToolBoxItem.cs

@@ -26,7 +26,7 @@ namespace ICSharpCode.FormsDesigner.Gui
 		
 		void Init(IDesignerHost host)
 		{
-			FormsDesignerLoggingService.Debug("Initializing MyToolBoxItem: " + className);
+			((IFormsDesignerLoggingService)host.GetService(typeof(IFormsDesignerLoggingService))).Debug("Initializing MyToolBoxItem: " + className);
 			if (host == null) throw new ArgumentNullException("host");
 			if (sourceFileName != null) {
 				TypeResolutionService typeResolutionService = host.GetService(typeof(ITypeResolutionService)) as TypeResolutionService;

src/AddIns/DisplayBindings/FormsDesigner/Project/Src/Services/DefaultMemberRelationshipService.cs

@@ -10,14 +10,17 @@ namespace ICSharpCode.FormsDesigner.Services
 {
 	public class DefaultMemberRelationshipService : MemberRelationshipService
 	{
-		public DefaultMemberRelationshipService()
+		IServiceProvider services;
+		
+		public DefaultMemberRelationshipService(IServiceProvider services)
 		{
+			this.services = services;
 		}
 		
 		public override bool SupportsRelationship(MemberRelationship source, MemberRelationship relationship)
 		{
 			#if WFDESIGN_LOG_MEMBERRELATIONSHIPSERVICE
-			FormsDesignerLoggingService.Debug("MemberRelationshipService: SupportsRelationship called, source=" + ToString(source) + ", relationship=" + ToString(relationship));
+			((IFormsDesignerLoggingService)services.GetService(typeof(IFormsDesignerLoggingService))).Debug("MemberRelationshipService: SupportsRelationship called, source=" + ToString(source) + ", relationship=" + ToString(relationship));
 			#endif
 			return true;
 		}
@@ -25,9 +28,9 @@ namespace ICSharpCode.FormsDesigner.Services
 		#if WFDESIGN_LOG_MEMBERRELATIONSHIPSERVICE
 		protected override MemberRelationship GetRelationship(MemberRelationship source)
 		{
-			FormsDesignerLoggingService.Debug("MemberRelationshipService: GetRelationship called, source=" + ToString(source));
+			((IFormsDesignerLoggingService)services.GetService(typeof(IFormsDesignerLoggingService))).Debug("MemberRelationshipService: GetRelationship called, source=" + ToString(source));
 			var mrs = base.GetRelationship(source);
-			FormsDesignerLoggingService.Debug("MemberRelationshipService: -> returning " + ToString(mrs));
+			((IFormsDesignerLoggingService)services.GetService(typeof(IFormsDesignerLoggingService))).Debug("MemberRelationshipService: -> returning " + ToString(mrs));
 			return mrs;
 		}
 		

src/AddIns/DisplayBindings/FormsDesigner/Project/Src/Services/IProjectResourceService.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.CodeDom;
+using System.Collections.Generic;
 using System.ComponentModel.Design;
 using System.IO;
 using System.Linq;
@@ -20,6 +21,7 @@ namespace ICSharpCode.FormsDesigner.Services
 	public interface IMessageService
 	{
 		void ShowOutputPad();
+		void ShowPropertiesPad();
 		void AppendTextToBuildMessages(string text);
 		void ShowException(Exception ex, string message);
 		string CodeStatementToString(CodeStatement statement);
@@ -34,7 +36,186 @@ namespace ICSharpCode.FormsDesigner.Services
 	
 	public interface ICommandProvider
 	{
-		void InitializeGlobalCommands(IMenuCommandService service);
 		void ShowContextMenu(CommandID menuID, int x, int y);
 	}
+	
+	public static class CommandIDEnumConverter
+	{
+		public static CommandID ToCommandID(CommandIDEnum key)
+		{
+			switch (key) {
+				case CommandIDEnum.AlignBottom:
+					return StandardCommands.AlignBottom;
+				case CommandIDEnum.AlignHorizontalCenters:
+					return StandardCommands.AlignHorizontalCenters;
+				case CommandIDEnum.AlignLeft:
+					return StandardCommands.AlignLeft;
+				case CommandIDEnum.AlignRight:
+					return StandardCommands.AlignRight;
+				case CommandIDEnum.AlignToGrid:
+					return StandardCommands.AlignToGrid;
+				case CommandIDEnum.AlignTop:
+					return StandardCommands.AlignTop;
+				case CommandIDEnum.AlignVerticalCenters:
+					return StandardCommands.AlignVerticalCenters;
+				case CommandIDEnum.ArrangeBottom:
+					return StandardCommands.ArrangeBottom;
+				case CommandIDEnum.ArrangeRight:
+					return StandardCommands.ArrangeRight;
+				case CommandIDEnum.BringForward:
+					return StandardCommands.BringForward;
+				case CommandIDEnum.BringToFront:
+					return StandardCommands.BringToFront;
+				case CommandIDEnum.CenterHorizontally:
+					return StandardCommands.CenterHorizontally;
+				case CommandIDEnum.CenterVertically:
+					return StandardCommands.CenterVertically;
+				case CommandIDEnum.ViewCode:
+					return StandardCommands.ViewCode;
+				case CommandIDEnum.DocumentOutline:
+					return StandardCommands.DocumentOutline;
+				case CommandIDEnum.Copy:
+					return StandardCommands.Copy;
+				case CommandIDEnum.Cut:
+					return StandardCommands.Cut;
+				case CommandIDEnum.Delete:
+					return StandardCommands.Delete;
+				case CommandIDEnum.Group:
+					return StandardCommands.Group;
+				case CommandIDEnum.HorizSpaceConcatenate:
+					return StandardCommands.HorizSpaceConcatenate;
+				case CommandIDEnum.HorizSpaceDecrease:
+					return StandardCommands.HorizSpaceDecrease;
+				case CommandIDEnum.HorizSpaceIncrease:
+					return StandardCommands.HorizSpaceIncrease;
+				case CommandIDEnum.HorizSpaceMakeEqual:
+					return StandardCommands.HorizSpaceMakeEqual;
+				case CommandIDEnum.Paste:
+					return StandardCommands.Paste;
+				case CommandIDEnum.Properties:
+					return StandardCommands.Properties;
+				case CommandIDEnum.Redo:
+					return StandardCommands.Redo;
+				case CommandIDEnum.MultiLevelRedo:
+					return StandardCommands.MultiLevelRedo;
+				case CommandIDEnum.SelectAll:
+					return StandardCommands.SelectAll;
+				case CommandIDEnum.SendBackward:
+					return StandardCommands.SendBackward;
+				case CommandIDEnum.SendToBack:
+					return StandardCommands.SendToBack;
+				case CommandIDEnum.SizeToControl:
+					return StandardCommands.SizeToControl;
+				case CommandIDEnum.SizeToControlHeight:
+					return StandardCommands.SizeToControlHeight;
+				case CommandIDEnum.SizeToControlWidth:
+					return StandardCommands.SizeToControlWidth;
+				case CommandIDEnum.SizeToFit:
+					return StandardCommands.SizeToFit;
+				case CommandIDEnum.SizeToGrid:
+					return StandardCommands.SizeToGrid;
+				case CommandIDEnum.SnapToGrid:
+					return StandardCommands.SnapToGrid;
+				case CommandIDEnum.TabOrder:
+					return StandardCommands.TabOrder;
+				case CommandIDEnum.Undo:
+					return StandardCommands.Undo;
+				case CommandIDEnum.MultiLevelUndo:
+					return StandardCommands.MultiLevelUndo;
+				case CommandIDEnum.Ungroup:
+					return StandardCommands.Ungroup;
+				case CommandIDEnum.VertSpaceConcatenate:
+					return StandardCommands.VertSpaceConcatenate;
+				case CommandIDEnum.VertSpaceDecrease:
+					return StandardCommands.VertSpaceDecrease;
+				case CommandIDEnum.VertSpaceIncrease:
+					return StandardCommands.VertSpaceIncrease;
+				case CommandIDEnum.VertSpaceMakeEqual:
+					return StandardCommands.VertSpaceMakeEqual;
+				case CommandIDEnum.ShowGrid:
+					return StandardCommands.ShowGrid;
+				case CommandIDEnum.ViewGrid:
+					return StandardCommands.ViewGrid;
+				case CommandIDEnum.Replace:
+					return StandardCommands.Replace;
+				case CommandIDEnum.PropertiesWindow:
+					return StandardCommands.PropertiesWindow;
+				case CommandIDEnum.LockControls:
+					return StandardCommands.LockControls;
+				case CommandIDEnum.F1Help:
+					return StandardCommands.F1Help;
+				case CommandIDEnum.ArrangeIcons:
+					return StandardCommands.ArrangeIcons;
+				case CommandIDEnum.LineupIcons:
+					return StandardCommands.LineupIcons;
+				case CommandIDEnum.ShowLargeIcons:
+					return StandardCommands.ShowLargeIcons;
+				case CommandIDEnum.VerbFirst:
+					return StandardCommands.VerbFirst;
+				case CommandIDEnum.VerbLast:
+					return StandardCommands.VerbLast;
+				default:
+					throw new Exception("Invalid value for CommandIDEnum");
+			}
+		}
+	}
+	
+	public enum CommandIDEnum
+	{
+		AlignBottom,
+		AlignHorizontalCenters,
+		AlignLeft,
+		AlignRight,
+		AlignToGrid,
+		AlignTop,
+		AlignVerticalCenters,
+		ArrangeBottom,
+		ArrangeRight,
+		BringForward,
+		BringToFront,
+		CenterHorizontally,
+		CenterVertically,
+		ViewCode,
+		DocumentOutline,
+		Copy,
+		Cut,
+		Delete,
+		Group,
+		HorizSpaceConcatenate,
+		HorizSpaceDecrease,
+		HorizSpaceIncrease,
+		HorizSpaceMakeEqual,
+		Paste,
+		Properties,
+		Redo,
+		MultiLevelRedo,
+		SelectAll,
+		SendBackward,
+		SendToBack,
+		SizeToControl,
+		SizeToControlHeight,
+		SizeToControlWidth,
+		SizeToFit,
+		SizeToGrid,
+		SnapToGrid,
+		TabOrder,
+		Undo,
+		MultiLevelUndo,
+		Ungroup,
+		VertSpaceConcatenate,
+		VertSpaceDecrease,
+		VertSpaceIncrease,
+		VertSpaceMakeEqual ,
+		ShowGrid,
+		ViewGrid,
+		Replace,
+		PropertiesWindow,
+		LockControls,
+		F1Help,
+		ArrangeIcons,
+		LineupIcons,
+		ShowLargeIcons,
+		VerbFirst,
+		VerbLast
+	}
 }

src/AddIns/DisplayBindings/FormsDesigner/Project/Src/Services/ImageResourceEditor.cs

@@ -49,9 +49,11 @@ namespace ICSharpCode.FormsDesigner.Services
 				return value;
 			}
 			
+			IFormsDesignerLoggingService logger = provider.GetService(typeof(IFormsDesignerLoggingService)) as IFormsDesignerLoggingService;
+			
 			IComponent component = context.Instance as IComponent;
 			if (component == null || component.Site == null) {
-				FormsDesignerLoggingService.Info("Editing of image properties on objects not implementing IComponent and components without Site is not supported by the ImageResourceEditor.");
+				logger.Info("Editing of image properties on objects not implementing IComponent and components without Site is not supported by the ImageResourceEditor.");
 				if (typeof(Icon).IsAssignableFrom(context.PropertyDescriptor.PropertyType)) {
 					return new IconEditor().EditValue(context, provider, value);
 				} else {

src/AddIns/DisplayBindings/FormsDesigner/Project/Src/Services/MenuCommandService.cs

@@ -4,26 +4,93 @@
 using System;
 using System.Drawing;
 using System.Windows.Forms;
-using System.Windows.Forms.Design;
-
 using CommandID = System.ComponentModel.Design.CommandID;
 using MenuCommand = System.ComponentModel.Design.MenuCommand;
+using StandardCommands = System.ComponentModel.Design.StandardCommands;
 
 namespace ICSharpCode.FormsDesigner.Services
 {
 	public class MenuCommandService : System.ComponentModel.Design.MenuCommandService
 	{
+		public readonly MenuCommandServiceProxy Proxy;
+		
 		ICommandProvider commandProvider;
 		
 		public MenuCommandService(ICommandProvider commandProvider, IServiceProvider serviceProvider) : base(serviceProvider)
 		{
+			Proxy = new MenuCommandServiceProxy(this);
 			this.commandProvider = commandProvider;
-			commandProvider.InitializeGlobalCommands(this);
+			AddProxyCommand(delegate {
+			                	IFormsDesigner fd = serviceProvider.GetService(typeof(IFormsDesigner)) as IFormsDesigner;
+			                	if (fd != null)
+			                		fd.ShowSourceCode();
+			                }, StandardCommands.ViewCode);
+			AddProxyCommand(delegate {
+			                	IMessageService ms = serviceProvider.GetService(typeof(IMessageService)) as IMessageService;
+			                	if (ms != null)
+			                		ms.ShowPropertiesPad();
+			                }, StandardCommands.PropertiesWindow);
 		}
 
 		public override void ShowContextMenu(CommandID menuID, int x, int y)
 		{
 			commandProvider.ShowContextMenu(menuID, x, y);
 		}
+		
+		public void AddProxyCommand(EventHandler commandCallBack, CommandID commandID)
+		{
+			AddCommand(new MenuCommand(commandCallBack, commandID));
+		}
+	}
+	
+	public class MenuCommandServiceProxy : MarshalByRefObject, System.ComponentModel.Design.IMenuCommandService
+	{
+		MenuCommandService mcs;
+		
+		public MenuCommandServiceProxy(MenuCommandService mcs)
+		{
+			this.mcs = mcs;
+		}
+		
+		public System.ComponentModel.Design.DesignerVerbCollection Verbs {
+			get {
+				return mcs.Verbs;
+			}
+		}
+		
+		public void AddCommand(MenuCommand command)
+		{
+			mcs.AddCommand(command);
+		}
+		
+		public MenuCommand FindCommand(CommandID commandID)
+		{
+			return mcs.FindCommand(commandID);
+		}
+		
+		public void ShowContextMenu(CommandID menuID, int x, int y)
+		{
+			mcs.ShowContextMenu(menuID, x, y);
+		}
+		
+		public void AddVerb(System.ComponentModel.Design.DesignerVerb verb)
+		{
+			mcs.AddVerb(verb);
+		}
+		
+		public bool GlobalInvoke(CommandID commandID)
+		{
+			return mcs.GlobalInvoke(commandID);
+		}
+		
+		public void RemoveCommand(MenuCommand command)
+		{
+			mcs.RemoveCommand(command);
+		}
+		
+		public void RemoveVerb(System.ComponentModel.Design.DesignerVerb verb)
+		{
+			mcs.RemoveVerb(verb);
+		}
 	}
 }

src/AddIns/DisplayBindings/FormsDesigner/Project/Src/Services/ProjectResourcesComponentCodeDomSerializer.cs

@@ -17,12 +17,16 @@ namespace ICSharpCode.FormsDesigner.Services
 	internal sealed class ProjectResourcesComponentCodeDomSerializer : CodeDomSerializer
 	{
 		readonly CodeDomSerializer baseSerializer;
+		readonly IServiceProvider provider;
+		IFormsDesignerLoggingService logger;
 		
-		internal ProjectResourcesComponentCodeDomSerializer(CodeDomSerializer baseSerializer)
+		internal ProjectResourcesComponentCodeDomSerializer(IServiceProvider provider, CodeDomSerializer baseSerializer)
 		{
 			if (baseSerializer == null)
 				throw new ArgumentNullException("baseSerializer");
 			this.baseSerializer = baseSerializer;
+			this.provider = provider;
+			logger = (IFormsDesignerLoggingService)provider.GetService(typeof(IFormsDesignerLoggingService));
 		}
 		
 		public override object Deserialize(IDesignerSerializationManager manager, object codeObject)
@@ -94,16 +98,16 @@ namespace ICSharpCode.FormsDesigner.Services
 			
 			IMessageService messenger = manager.GetService(typeof(IMessageService)) as IMessageService;
 			
-			FormsDesignerLoggingService.Debug("Forms designer: deserializing a property assignment:");
+			logger.Debug("Forms designer: deserializing a property assignment:");
-			FormsDesignerLoggingService.Debug("-> " + messenger.CodeStatementToString(assignStatement));
+			logger.Debug("-> " + messenger.CodeStatementToString(assignStatement));
 			
 			IComponent component = this.baseSerializer.Deserialize(manager, propRefTarget.TargetObject) as IComponent;
 			if (component == null) {
-				FormsDesignerLoggingService.Info("Forms designer: ProjectResourcesComponentCodeDomSerializer could not deserialze the target object to IComponent");
+				logger.Info("Forms designer: ProjectResourcesComponentCodeDomSerializer could not deserialze the target object to IComponent");
 				return false;
 			}
 			if (component.Site == null) {
-				FormsDesignerLoggingService.Info("Forms designer: ProjectResourcesComponentCodeDomSerializer: The deserialized component '" + component.ToString() + "' does not have a Site.");
+				logger.Info("Forms designer: ProjectResourcesComponentCodeDomSerializer: The deserialized component '" + component.ToString() + "' does not have a Site.");
 				return false;
 			}
 			
@@ -147,8 +151,8 @@ namespace ICSharpCode.FormsDesigner.Services
 			
 			IMessageService messenger = manager.GetService(typeof(IMessageService)) as IMessageService;
 			
-			FormsDesignerLoggingService.Debug("Forms designer: deserializing a method invocation:");
+			logger.Debug("Forms designer: deserializing a method invocation:");
-			FormsDesignerLoggingService.Debug("-> " + messenger.CodeStatementToString(new CodeExpressionStatement(invokeExpression)));
+			logger.Debug("-> " + messenger.CodeStatementToString(new CodeExpressionStatement(invokeExpression)));
 			
 			object extenderProvider = this.baseSerializer.Deserialize(manager, invokeExpression.Method.TargetObject);
 			if (extenderProvider == null) {
@@ -157,11 +161,11 @@ namespace ICSharpCode.FormsDesigner.Services
 			
 			IComponent targetComponent = this.baseSerializer.Deserialize(manager, invokeExpression.Parameters[0]) as IComponent;
 			if (targetComponent == null) {
-				FormsDesignerLoggingService.Info("Forms designer: ProjectResourcesComponentCodeDomSerializer could not deserialze the target object to IComponent");
+				logger.Info("Forms designer: ProjectResourcesComponentCodeDomSerializer could not deserialze the target object to IComponent");
 				return false;
 			}
 			if (targetComponent.Site == null) {
-				FormsDesignerLoggingService.Info("Forms designer: ProjectResourcesComponentCodeDomSerializer: The deserialized component '" + targetComponent.ToString() + "' does not have a Site.");
+				logger.Info("Forms designer: ProjectResourcesComponentCodeDomSerializer: The deserialized component '" + targetComponent.ToString() + "' does not have a Site.");
 				return false;
 			}
 			

src/AddIns/DisplayBindings/FormsDesigner/Project/Src/Services/ProjectResourcesMemberCodeDomSerializer.cs

@@ -20,12 +20,16 @@ namespace ICSharpCode.FormsDesigner.Services
 	internal sealed class ProjectResourcesMemberCodeDomSerializer : MemberCodeDomSerializer
 	{
 		readonly MemberCodeDomSerializer baseSerializer;
+		readonly IServiceProvider provider;
+		IFormsDesignerLoggingService logger;
 		
-		public ProjectResourcesMemberCodeDomSerializer(MemberCodeDomSerializer baseSerializer)
+		public ProjectResourcesMemberCodeDomSerializer(IServiceProvider provider, MemberCodeDomSerializer baseSerializer)
 		{
 			if (baseSerializer == null)
 				throw new ArgumentNullException("baseSerializer");
 			this.baseSerializer = baseSerializer;
+			this.provider = provider;
+			logger = (IFormsDesignerLoggingService)provider.GetService(typeof(IFormsDesignerLoggingService));
 		}
 		
 		public override void Serialize(IDesignerSerializationManager manager, object value, MemberDescriptor descriptor, CodeStatementCollection statements)
@@ -52,7 +56,7 @@ namespace ICSharpCode.FormsDesigner.Services
 			
 			var prs = manager.GetService(typeof(IProjectResourceService)) as IProjectResourceService;
 			if (prs == null) {
-				FormsDesignerLoggingService.Warn("ProjectResourceService not found");
+				logger.Warn("ProjectResourceService not found");
 				return false;
 			}
 			
@@ -60,7 +64,7 @@ namespace ICSharpCode.FormsDesigner.Services
 			if (resourceInfo == null) return false;
 			
 			if (!Object.ReferenceEquals(resourceInfo.OriginalValue, propDesc.GetValue(value))) {
-				FormsDesignerLoggingService.Info("Value of property '" + propDesc.Name + "' on component '" + value.ToString() + "' is not equal to stored project resource value. Ignoring this resource.");
+				logger.Info("Value of property '" + propDesc.Name + "' on component '" + value.ToString() + "' is not equal to stored project resource value. Ignoring this resource.");
 				return false;
 			}
 			
@@ -72,16 +76,16 @@ namespace ICSharpCode.FormsDesigner.Services
 			
 			// Now do the actual serialization.
 			
-			FormsDesignerLoggingService.Debug("Serializing project resource: Component '" + component.ToString() + "', Property: '" + propDesc.Name + "', Resource class: '" + resourceClassFullyQualifiedName + "', Resource property: '" + resourcePropertyName + "'");
+			logger.Debug("Serializing project resource: Component '" + component.ToString() + "', Property: '" + propDesc.Name + "', Resource class: '" + resourceClassFullyQualifiedName + "', Resource property: '" + resourcePropertyName + "'");
 			
 			var targetObjectExpr = base.SerializeToExpression(manager, value);
 			if (targetObjectExpr == null) {
-				FormsDesignerLoggingService.Info("Target object could not be serialized: " + value.ToString());
+				logger.Info("Target object could not be serialized: " + value.ToString());
 				return false;
 			}
 			
 			if (propDesc.SerializationVisibility == DesignerSerializationVisibility.Content) {
-				FormsDesignerLoggingService.Debug("-> is a content property, ignoring this.");
+				logger.Debug("-> is a content property, ignoring this.");
 				return false;
 			}
 			

src/AddIns/DisplayBindings/FormsDesigner/Project/Src/Services/SharpDevelopSerializationProvider.cs

@@ -12,8 +12,11 @@ namespace ICSharpCode.FormsDesigner.Services
 	/// </summary>
 	internal sealed class SharpDevelopSerializationProvider : IDesignerSerializationProvider
 	{
-		internal SharpDevelopSerializationProvider()
+		IServiceProvider provider;
+		
+		internal SharpDevelopSerializationProvider(IServiceProvider provider)
 		{
+			this.provider = provider;
 		}
 		
 		object IDesignerSerializationProvider.GetSerializer(IDesignerSerializationManager manager, object currentSerializer, Type objectType, Type serializerType)
@@ -23,17 +26,16 @@ namespace ICSharpCode.FormsDesigner.Services
 				return null;
 			}
 			
-			
 			if (serializerType == typeof(MemberCodeDomSerializer)) {
 				
 				if (typeof(PropertyDescriptor).IsAssignableFrom(objectType) && !(currentSerializer is ProjectResourcesMemberCodeDomSerializer)) {
-					return new ProjectResourcesMemberCodeDomSerializer((MemberCodeDomSerializer)currentSerializer);
+					return new ProjectResourcesMemberCodeDomSerializer(provider, (MemberCodeDomSerializer)currentSerializer);
 				}
 				
 			} else if (serializerType == typeof(CodeDomSerializer)) {
 				
 				if (typeof(IComponent).IsAssignableFrom(objectType) && !(currentSerializer is ProjectResourcesComponentCodeDomSerializer)) {
-					return new ProjectResourcesComponentCodeDomSerializer((CodeDomSerializer)currentSerializer);
+					return new ProjectResourcesComponentCodeDomSerializer(provider, (CodeDomSerializer)currentSerializer);
 				}
 				
 			}

src/AddIns/DisplayBindings/FormsDesigner/Project/Src/Services/ToolboxService.cs

@@ -65,14 +65,20 @@ namespace ICSharpCode.FormsDesigner.Services
 		string selectedCategory  = null;
 		ToolboxItem selectedItem = null;
 		
+		IServiceProvider provider;
+		IFormsDesignerLoggingService logger;
+		
 		// Constructor
-		public ToolboxService()
+		public ToolboxService(IServiceProvider provider)
 		{
 			IList list = new ArrayList();
 			toolboxByCategory.Add(ALL_CATEGORIES, list);
 			
 			list = new ArrayList();
 			toolboxByHost.Add(ALL_HOSTS, list);
+			
+			this.provider = provider;
+			logger = (IFormsDesignerLoggingService)provider.GetService(typeof(IFormsDesignerLoggingService));
 		}
 		
 		// Properties
@@ -178,7 +184,7 @@ namespace ICSharpCode.FormsDesigner.Services
 		/// </remarks>
 		public void AddCreator(ToolboxItemCreatorCallback creator, string format, IDesignerHost host)
 		{
-			FormsDesignerLoggingService.DebugFormatted("\tDefaultToolboxService:AddCreator({0}, {1}, {2})", creator, format, host);
+			logger.DebugFormatted("\tDefaultToolboxService:AddCreator({0}, {1}, {2})", creator, format, host);
 			if (host == null) {
 				creators.Add(format, creator);
 			} else {
@@ -249,7 +255,7 @@ namespace ICSharpCode.FormsDesigner.Services
 		
 		public ToolboxItem DeserializeToolboxItem(object serializedObject, IDesignerHost host)
 		{
-			FormsDesignerLoggingService.DebugFormatted("DeserializeToolboxItem {0} host {1}", serializedObject, host);
+			logger.DebugFormatted("DeserializeToolboxItem {0} host {1}", serializedObject, host);
 			if (serializedObject is System.Windows.Forms.IDataObject) {
 				if (((System.Windows.Forms.IDataObject)serializedObject).GetDataPresent(typeof(ToolboxItem))) {
 					ToolboxItem item = (ToolboxItem) ((System.Windows.Forms.IDataObject)serializedObject).GetData(typeof(ToolboxItem));
@@ -258,7 +264,7 @@ namespace ICSharpCode.FormsDesigner.Services
 					if (host != null) {
 						list = (ArrayList)toolboxByHost[host];
 						if (list != null && list.Contains(item)) {
-							FormsDesignerLoggingService.Warn(item.TypeName);
+							logger.Warn(item.TypeName);
 							return item;
 						}
 					}
@@ -268,7 +274,7 @@ namespace ICSharpCode.FormsDesigner.Services
 					}
 				}
 			}
-			FormsDesignerLoggingService.WarnFormatted("DeserializeToolboxItem {0} host {1} return null", serializedObject, host);
+			logger.WarnFormatted("DeserializeToolboxItem {0} host {1} return null", serializedObject, host);
 			return null;
 		}
 		
@@ -293,7 +299,7 @@ namespace ICSharpCode.FormsDesigner.Services
 		
 		public ToolboxItemCollection GetToolboxItems()
 		{
-			FormsDesignerLoggingService.Debug("ToolboxService: GetToolboxItems");
+			logger.Debug("ToolboxService: GetToolboxItems");
 			ToolboxItem[] items = new ToolboxItem[toolboxItems.Count];
 			toolboxItems.CopyTo(items);
 			return new ToolboxItemCollection(items);
@@ -301,7 +307,7 @@ namespace ICSharpCode.FormsDesigner.Services
 		
 		public ToolboxItemCollection GetToolboxItems(string category)
 		{
-			FormsDesignerLoggingService.Debug("ToolboxService: GetToolboxItems category " + category);
+			logger.Debug("ToolboxService: GetToolboxItems category " + category);
 			if (category == null) {
 				category = ALL_CATEGORIES;
 			}
@@ -315,7 +321,7 @@ namespace ICSharpCode.FormsDesigner.Services
 		
 		public ToolboxItemCollection GetToolboxItems(string category, IDesignerHost host)
 		{
-			FormsDesignerLoggingService.DebugFormatted("ToolboxService: GetToolboxItems category {0} host {1}", category, host);
+			logger.DebugFormatted("ToolboxService: GetToolboxItems category {0} host {1}", category, host);
 			if (category == null) {
 				category = ALL_CATEGORIES;
 			}

src/AddIns/DisplayBindings/FormsDesigner/Project/Src/Services/TypeDiscoveryService.cs

@@ -13,10 +13,14 @@ namespace ICSharpCode.FormsDesigner.Services
 	public class TypeDiscoveryService : ITypeDiscoveryService
 	{
 		IGacWrapper gacWrapper;
+		IServiceProvider services;
+		IFormsDesignerLoggingService logger;
 		
-		public TypeDiscoveryService(IGacWrapper gacWrapper)
+		public TypeDiscoveryService(IGacWrapper gacWrapper, IServiceProvider services)
 		{
 			this.gacWrapper = gacWrapper;
+			this.services = services;
+			this.logger = ((IFormsDesignerLoggingService)services.GetService(typeof(IFormsDesignerLoggingService)));
 		}
 		
 		/// <summary>
@@ -33,7 +37,7 @@ namespace ICSharpCode.FormsDesigner.Services
 				baseType = typeof(object);
 			}
 			
-			FormsDesignerLoggingService.Debug("TypeDiscoveryService.GetTypes for " + baseType.FullName
+			logger.Debug("TypeDiscoveryService.GetTypes for " + baseType.FullName
 			                     + "excludeGlobalTypes=" + excludeGlobalTypes.ToString());
 			//seek in all assemblies
 			//allow to work designers like columns editor in datagridview
@@ -50,7 +54,7 @@ namespace ICSharpCode.FormsDesigner.Services
 					// ignore assembly load errors
 				}
 			}
-			FormsDesignerLoggingService.Debug("TypeDiscoveryService returns " + types.Count + " types");
+			logger.Debug("TypeDiscoveryService returns " + types.Count + " types");
 			
 			// TODO - Don't look in all assemblies.
 			// Should use the current project and its referenced assemblies

src/AddIns/DisplayBindings/FormsDesigner/Project/Src/Services/TypeResolutionService.cs

@@ -70,6 +70,7 @@ namespace ICSharpCode.FormsDesigner.Services
 		string formSourceFileName;
 		ServiceContainer serviceContainer;
 		ITypeLocator typeLocator;
+		static IFormsDesignerLoggingService logger;
 		
 		/// <summary>
 		/// Dictionary of file name -> hash of loaded assemblies for the currently designed document.
@@ -86,6 +87,7 @@ namespace ICSharpCode.FormsDesigner.Services
 			this.formSourceFileName = formSourceFileName;
 			this.serviceContainer = serviceContainer;
 			this.typeLocator = typeLocator;
+			logger = (IFormsDesignerLoggingService)serviceContainer.GetService(typeof(IFormsDesignerLoggingService));
 		}
 		
 		static string GetHash(string fileName)
@@ -99,10 +101,10 @@ namespace ICSharpCode.FormsDesigner.Services
 			try {
 				return new Uri(asm.CodeBase, UriKind.Absolute).LocalPath;
 			} catch (UriFormatException ex) {
-				FormsDesignerLoggingService.Warn("Could not determine path for assembly '" + asm.ToString() + "', CodeBase='" + asm.CodeBase + "': " + ex.Message);
+				logger.Warn("Could not determine path for assembly '" + asm.ToString() + "', CodeBase='" + asm.CodeBase + "': " + ex.Message);
 				return asm.Location;
 			} catch (InvalidOperationException ex) {
-				FormsDesignerLoggingService.Warn("Could not determine path for assembly '" + asm.ToString() + "', CodeBase='" + asm.CodeBase + "': " + ex.Message);
+				logger.Warn("Could not determine path for assembly '" + asm.ToString() + "', CodeBase='" + asm.CodeBase + "': " + ex.Message);
 				return asm.Location;
 			}
 		}
@@ -134,12 +136,12 @@ namespace ICSharpCode.FormsDesigner.Services
 				Assembly asm;
 				if (assemblyDict.TryGetValue(hash, out asm))
 					return asm;
-				FormsDesignerLoggingService.Debug("Loading assembly " + fileName + " (hash " + hash + ")");
+				logger.Debug("Loading assembly " + fileName + " (hash " + hash + ")");
 				try {
 					asm = Assembly.Load(File.ReadAllBytes(fileName));
 				} catch (BadImageFormatException e) {
 					if (e.Message.Contains("HRESULT: 0x8013141D")) {
-						FormsDesignerLoggingService.Debug("Get HRESULt 0x8013141D, loading netmodule");
+						logger.Debug("Get HRESULt 0x8013141D, loading netmodule");
 						//netmodule
 						string tempPath = Path.GetTempFileName();
 						File.Delete(tempPath);
@@ -171,14 +173,14 @@ namespace ICSharpCode.FormsDesigner.Services
 						// but do not prevent the designer from loading.
 						// The error might be caused by an assembly that is
 						// not even needed for the designer to load.
-						FormsDesignerLoggingService.Error("Error loading assembly " + fileName, e);
+						logger.Error("Error loading assembly " + fileName, e);
 						messenger.ShowOutputPad();
 						messenger.AppendTextToBuildMessages("${res:FileUtilityService.ErrorWhileLoading}\r\n" + fileName + "\r\n" + e.Message + "\r\n");
 						return null;
 					}
 				} catch (FileLoadException e) {
 					if (e.Message.Contains("HRESULT: 0x80131402")) {
-						FormsDesignerLoggingService.Debug("Get HRESULt 0x80131402, loading mixed modes asm from disk");
+						logger.Debug("Get HRESULt 0x80131402, loading mixed modes asm from disk");
 						//this is C++/CLI Mixed assembly which can only be loaded from disk, not in-memory
 						string tempPath = Path.GetTempFileName();
 						File.Delete(tempPath);
@@ -285,7 +287,7 @@ namespace ICSharpCode.FormsDesigner.Services
 			}
 			#if DEBUG
 			if (!name.StartsWith("System.")) {
-				FormsDesignerLoggingService.Debug("TypeResolutionService: Looking for " + name);
+				logger.Debug("TypeResolutionService: Looking for " + name);
 			}
 			#endif
 			try {
@@ -323,7 +325,7 @@ namespace ICSharpCode.FormsDesigner.Services
 						try {
 							assembly = Assembly.Load(assemblyName);
 						} catch (Exception e) {
-							FormsDesignerLoggingService.Error(e);
+							logger.Error(e);
 						}
 						if (assembly != null) {
 							string fileName = GetOriginalAssemblyFullPath(assembly);
@@ -365,14 +367,14 @@ namespace ICSharpCode.FormsDesigner.Services
 				
 				return type;
 			} catch (Exception e) {
-				FormsDesignerLoggingService.Error(e);
+				logger.Error(e);
 			}
 			return null;
 		}
 		
 		public void ReferenceAssembly(AssemblyName name)
 		{
-			FormsDesignerLoggingService.Warn("TODO: Add Assembly reference : " + name);
+			logger.Warn("TODO: Add Assembly reference : " + name);
 		}
 		
 		/// <summary>
@@ -442,7 +444,7 @@ namespace ICSharpCode.FormsDesigner.Services
 		
 		static Assembly AssemblyResolveEventHandler(object sender, ResolveEventArgs args)
 		{
-			FormsDesignerLoggingService.Debug("TypeResolutionService: AssemblyResolveEventHandler: " + args.Name);
+			logger.Debug("TypeResolutionService: AssemblyResolveEventHandler: " + args.Name);
 			
 			Assembly lastAssembly = null;
 			
@@ -459,7 +461,7 @@ namespace ICSharpCode.FormsDesigner.Services
 			}
 			if (lastAssembly != null) {
 				TypeResolutionService.DesignerAssemblies.Add(lastAssembly);
-				FormsDesignerLoggingService.Info("ICSharpAssemblyResolver found..." + args.Name);
+				logger.Info("ICSharpAssemblyResolver found..." + args.Name);
 			}
 			return lastAssembly;
 		}

src/Main/Base/Project/Src/Gui/AbstractViewContentHandlingLoadErrors.cs

@@ -79,7 +79,7 @@ namespace ICSharpCode.SharpDevelop.Gui
 		
 		TextBox errorTextBox;
 		
-		void ShowError(Exception ex)
+		protected void ShowError(Exception ex)
 		{
 			if (errorTextBox == null) {
 				errorTextBox = new TextBox();