Merge pull request #604 from jogibear9988/AppXamlParsing

WPF Designer Fixes (App.Xaml support, Load of AdditionalDlls,...)

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.AddIn/Src/MyTypeFinder.cs

@@ -17,6 +17,7 @@
 // DEALINGS IN THE SOFTWARE.
 
 using System;
+using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Runtime.ExceptionServices;
@@ -73,6 +74,36 @@ namespace ICSharpCode.WpfDesign.AddIn
 			}
 		}
 		
+		public override Uri ConvertUriToLocalUri(Uri uri)
+		{
+			if (!uri.IsAbsoluteUri)
+			{
+				var compilation = SD.ParserService.GetCompilationForFile(file.FileName);
+				var assembly = this.typeResolutionService.LoadAssembly(compilation.MainAssembly);
+				var prj = SD.ProjectService.CurrentProject;
+
+				if (uri.OriginalString.Contains(";"))
+				{
+					var parts = uri.OriginalString.Split(';');
+					if (prj.Name == parts[0].Substring(1))
+					{
+						var newUri = new Uri(("file://" + Path.Combine(prj.Directory, parts[1].Substring("component".Length + 1))).Replace("\\", "/"), UriKind.RelativeOrAbsolute);
+						return newUri;
+					}
+				}
+				else
+				{
+					var strg = uri.OriginalString;
+					if (strg.StartsWith("/"))
+						strg = strg.Substring(1);
+					var newUri = new Uri(("file://" + Path.Combine(prj.Directory, strg)).Replace("\\", "/"), UriKind.RelativeOrAbsolute);
+					return newUri;
+				}
+			}
+			
+			return uri;
+		}
+		
 		Assembly FindAssemblyInProjectReferences(string name)
 		{
 			IProject pc = GetProject(file);

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.AddIn/Src/WpfViewContent.cs

@@ -22,16 +22,20 @@ using System.ComponentModel;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Windows;
+using System.Windows.Controls;
 using System.Windows.Input;
 using System.Windows.Markup;
 using System.Xml;
 
+using ICSharpCode.Core;
 using ICSharpCode.Core.Presentation;
 using ICSharpCode.NRefactory.TypeSystem;
 using ICSharpCode.SharpDevelop;
+using ICSharpCode.SharpDevelop.Designer;
 using ICSharpCode.SharpDevelop.Dom;
 using ICSharpCode.SharpDevelop.Editor;
 using ICSharpCode.SharpDevelop.Gui;
@@ -44,6 +48,7 @@ using ICSharpCode.WpfDesign.Designer.OutlineView;
 using ICSharpCode.WpfDesign.Designer.PropertyGrid;
 using ICSharpCode.WpfDesign.Designer.Services;
 using ICSharpCode.WpfDesign.Designer.Xaml;
+using ICSharpCode.WpfDesign.XamlDom;
 
 namespace ICSharpCode.WpfDesign.AddIn
 {
@@ -60,6 +65,10 @@ namespace ICSharpCode.WpfDesign.AddIn
 			
 			this.TabPageText = "${res:FormsDesigner.DesignTabPages.DesignTabPage}";
 			this.IsActiveViewContentChanged += OnIsActiveViewContentChanged;
+			
+			var compilation = SD.ParserService.GetCompilationForFile(file.FileName);
+			_path = Path.GetDirectoryName(compilation.MainAssembly.UnresolvedAssembly.Location);
+			AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
 		}
 		
 		static WpfViewContent()
@@ -101,6 +110,8 @@ namespace ICSharpCode.WpfDesign.AddIn
 			if (outline != null) {
 				outline.Root = null;
 			}
+			
+			
 			using (XmlTextReader r = new XmlTextReader(stream)) {
 				XamlLoadSettings settings = new XamlLoadSettings();
 				settings.DesignerAssemblies.Add(typeof(WpfViewContent).Assembly);
@@ -117,7 +128,20 @@ namespace ICSharpCode.WpfDesign.AddIn
 					settings.ReportErrors = UpdateTasks;
 					designer.LoadDesigner(r, settings);
 					
-					designer.ContextMenuOpening += (sender, e) => MenuService.ShowContextMenu(e.OriginalSource as UIElement, designer, "/AddIns/WpfDesign/Designer/ContextMenu");
+					designer.DesignPanel.ContextMenuHandler = (contextMenu) => {
+						var newContextmenu = new ContextMenu();
+						var sdContextMenuItems = MenuService.CreateMenuItems(newContextmenu, designer, "/AddIns/WpfDesign/Designer/ContextMenu", "ContextMenu");
+						foreach(var entry in sdContextMenuItems)
+							newContextmenu.Items.Add(entry);
+						newContextmenu.Items.Add(new Separator());
+						
+						var items = contextMenu.Items.Cast<Object>().ToList();
+						contextMenu.Items.Clear();
+						foreach(var entry in items)
+							newContextmenu.Items.Add(entry);
+						
+						designer.DesignPanel.ContextMenu = newContextmenu;
+					};
 					
 					if (outline != null && designer.DesignContext != null && designer.DesignContext.RootItem != null) {
 						outline.Root = OutlineNode.Create(designer.DesignContext.RootItem);
@@ -129,9 +153,46 @@ namespace ICSharpCode.WpfDesign.AddIn
 				} catch (Exception e) {
 					this.UserContent = new WpfDocumentError(e);
 				}
+				
+				try{
+					var appXaml = SD.ProjectService.CurrentProject.Items.FirstOrDefault(x=>x.FileName.GetFileName().ToLower() == ("app.xaml"));
+					if (appXaml!=null){
+						var f=appXaml as FileProjectItem;
+						OpenedFile a = SD.FileService.GetOrCreateOpenedFile(f.FileName);
+						
+						var xml = XmlReader.Create(a.OpenRead());
+						var doc=new XmlDocument();
+						doc.Load(xml);
+						var node = doc.FirstChild.ChildNodes.Cast<XmlNode>().FirstOrDefault(x=>x.Name=="Application.Resources");
+						
+						foreach (XmlAttribute att in doc.FirstChild.Attributes.Cast<XmlAttribute>().ToList())
+						{
+							if (att.Name.StartsWith("xmlns"))
+								node.Attributes.Append(att);
+						}
+						
+						var appXamlXml = XmlReader.Create(new StringReader(node.InnerXml));
+						var parsed = XamlParser.Parse(appXamlXml, ((XamlDesignContext) designer.DesignContext).ParserSettings);
+						var dict = (ResourceDictionary)parsed.RootInstance;
+						designer.DesignPanel.Resources.MergedDictionaries.Add(dict);
+					}
+				} catch (Exception ex) { 
+					LoggingService.Error("Error in loading app.xaml", ex);
 				}
 			}
+		}
+		
+		System.Reflection.Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
+		{
+			var assemblyName = (new AssemblyName(args.Name));
+			string fileName = Path.Combine(_path, assemblyName.Name) + ".dll";
+			if (File.Exists(fileName))
+				return typeResolutionService.LoadAssembly(fileName);
+			return null;
+		}
 		
+		private TypeResolutionService typeResolutionService = new TypeResolutionService();
+		private string _path;
 		private MemoryStream _stream;
 		bool wasChangedInDesigner;
 		
@@ -285,6 +346,7 @@ namespace ICSharpCode.WpfDesign.AddIn
 		
 		public override void Dispose()
 		{
+			AppDomain.CurrentDomain.AssemblyResolve -= CurrentDomain_AssemblyResolve;
 			SD.ProjectService.ProjectItemAdded -= OnReferenceAdded;
 
 			propertyContainer.Clear();

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.AddIn/WpfDesign.addin

@@ -49,7 +49,7 @@
 	-->
 	<Path name="/AddIns/WpfDesign/Designer/ContextMenu">
 		<MenuItem label="${res:ICSharpCode.WPFDesigner.ContextMenu.ViewXAML}" id="viewXaml" icon="Icons.16x16.XMLFileIcon" class="ICSharpCode.WpfDesign.AddIn.Commands.ViewXaml" />
-		<MenuItem label="seperator1" type="Separator" />
+		<!--<MenuItem label="seperator1" type="Separator" />
 		<Condition name="IsCutCopyEnabled" action="Disable">
 			<MenuItem id="cut" label="${res:ICSharpCode.WPFDesigner.ContextMenu.Cut}" icon="Icons.16x16.CutIcon" shortcut="Control|X" class="ICSharpCode.WpfDesign.AddIn.Commands.Cut" />
 			<MenuItem id="copy" label="${res:ICSharpCode.WPFDesigner.ContextMenu.Copy}" icon="Icons.16x16.CopyIcon" shortcut="Control|C" class="ICSharpCode.WpfDesign.AddIn.Commands.Copy" />
@@ -66,7 +66,7 @@
 		</Condition>
 		<Condition name="IsRedoEnabled" action="Disable">
 			<MenuItem id="redo" label="${res:ICSharpCode.WPFDesigner.ContextMenu.Redo}" icon="Icons.16x16.RedoIcon" shortcut="Control|R" class="ICSharpCode.WpfDesign.AddIn.Commands.Redo" />
-		</Condition>
+		</Condition>-->
 		<MenuItem label="seperator3" type="Separator" />
 		<MenuItem id="tools" label="${res:ICSharpCode.WPFDesigner.ContextMenu.Tools}" icon="PadIcons.Toolbar" shortcut="Control|Alt|X" class="ICSharpCode.WpfDesign.AddIn.Commands.Tools" />
 		<MenuItem id="properties" label="${res:ICSharpCode.WPFDesigner.ContextMenu.Properties}" icon="Icons.16x16.PropertiesIcon" shortcut="F4" class="ICSharpCode.WpfDesign.AddIn.Commands.Properties" />

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.Designer/Project/DesignPanel.cs

@@ -32,6 +32,7 @@ using System.Windows.Threading;
 
 using ICSharpCode.WpfDesign.Adorners;
 using ICSharpCode.WpfDesign.Designer.Controls;
+using ICSharpCode.WpfDesign.Designer.UIExtensions;
 using ICSharpCode.WpfDesign.Designer.Xaml;
 
 namespace ICSharpCode.WpfDesign.Designer
@@ -468,6 +469,8 @@ namespace ICSharpCode.WpfDesign.Designer
 
 		private Dictionary<ContextMenu, Tuple<int,List<object>>> contextMenusAndEntries = new Dictionary<ContextMenu, Tuple<int,List<object>>>();
 
+		public Action<ContextMenu> ContextMenuHandler { get; set; }
+		
 		public void AddContextMenu(ContextMenu contextMenu)
 		{
 			contextMenusAndEntries.Add(contextMenu, new Tuple<int, List<object>>(contextMenusAndEntries.Count, new List<object>(contextMenu.Items.Cast<object>())));
@@ -491,24 +494,32 @@ namespace ICSharpCode.WpfDesign.Designer
 
 		private void UpdateContextMenu()
 		{
-			if (contextMenusAndEntries.Count == 0)
+			if (this.ContextMenu != null)
+			{
+				this.ContextMenu.Items.Clear();
 				this.ContextMenu = null;
+			}
 			
-			if (this.ContextMenu == null)
+			var contextMenu = new ContextMenu();
-				this.ContextMenu = new ContextMenu();
-			
-			this.ContextMenu.Items.Clear();
 			
 			foreach (var entries in contextMenusAndEntries.Values.OrderBy(x => x.Item1).Select(x => x.Item2))
 			{
-				if (this.ContextMenu.Items.Count > 0)
+				if (contextMenu.Items.Count > 0)
-					this.ContextMenu.Items.Add(new Separator());
+					contextMenu.Items.Add(new Separator());
 
 				foreach (var entry in entries)
 				{
-					ContextMenu.Items.Add(entry);
+					var ctl = ((FrameworkElement)entry).TryFindParent<ItemsControl>();
+					if (ctl != null)
+						ctl.Items.Remove(entry);
+					contextMenu.Items.Add(entry);
 				}
 			}
+			
+			if (ContextMenuHandler != null)
+				ContextMenuHandler(contextMenu);
+			else
+				this.ContextMenu = contextMenu;
 		}
 
 		#endregion

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.Designer/Project/Extensions/DefaultCommandsContextMenu.xaml

@@ -0,0 +1,38 @@
+<ContextMenu x:Class="ICSharpCode.WpfDesign.Designer.Extensions.DefaultCommandsContextMenu"
+             xmlns="http://schemas.microsoft.com/netfx/2007/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:Translation="clr-namespace:ICSharpCode.WpfDesign.Designer"
+>
+	<MenuItem Command="ApplicationCommands.Cut">
+		<MenuItem.Icon>
+			<Image Source="/ICSharpCode.WpfDesign.Designer;component/Images/Icons.16x16.CutIcon.png" />
+		</MenuItem.Icon>
+	</MenuItem>
+	<MenuItem Command="ApplicationCommands.Copy">
+		<MenuItem.Icon>
+			<Image Source="/ICSharpCode.WpfDesign.Designer;component/Images/Icons.16x16.CopyIcon.png" />
+		</MenuItem.Icon>
+	</MenuItem>
+	<MenuItem Command="ApplicationCommands.Paste">
+		<MenuItem.Icon>
+			<Image Source="/ICSharpCode.WpfDesign.Designer;component/Images/Icons.16x16.PasteIcon.png" />
+		</MenuItem.Icon>
+	</MenuItem>
+	<Separator />
+	<MenuItem Command="ApplicationCommands.Delete">
+		<MenuItem.Icon>
+			<Image Source="/ICSharpCode.WpfDesign.Designer;component/Images/Icons.16x16.DeleteIcon.png" />
+		</MenuItem.Icon>
+	</MenuItem>
+	<Separator />
+	<MenuItem Command="ApplicationCommands.Undo">
+		<MenuItem.Icon>
+			<Image Source="/ICSharpCode.WpfDesign.Designer;component/Images/Icons.16x16.UndoIcon.png" />
+		</MenuItem.Icon>
+	</MenuItem>
+	<MenuItem Command="ApplicationCommands.Redo">
+		<MenuItem.Icon>
+			<Image Source="/ICSharpCode.WpfDesign.Designer;component/Images/Icons.16x16.RedoIcon.png" />
+		</MenuItem.Icon>
+	</MenuItem>
+</ContextMenu>

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.Designer/Project/Extensions/DefaultCommandsContextMenu.xaml.cs

@@ -0,0 +1,43 @@
+// Copyright (c) 2014 AlphaSierraPapa for the SharpDevelop Team
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this
+// software and associated documentation files (the "Software"), to deal in the Software
+// without restriction, including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+// to whom the Software is furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all copies or
+// substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+using System;
+using System.IO;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Markup;
+using System.Xml;
+using ICSharpCode.WpfDesign.Designer.PropertyGrid.Editors.FormatedTextEditor;
+using ICSharpCode.WpfDesign.Designer.Xaml;
+using ICSharpCode.WpfDesign.XamlDom;
+
+namespace ICSharpCode.WpfDesign.Designer.Extensions
+{
+	public partial class DefaultCommandsContextMenu
+	{
+		private DesignItem designItem;
+
+		public DefaultCommandsContextMenu(DesignItem designItem)
+		{
+			this.designItem = designItem;
+			
+			InitializeComponent();
+		}
+	}
+}

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.Designer/Project/Extensions/DefaultCommandsContextMenuExtension.cs

@@ -0,0 +1,54 @@
+// Copyright (c) 2014 AlphaSierraPapa for the SharpDevelop Team
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this
+// software and associated documentation files (the "Software"), to deal in the Software
+// without restriction, including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+// to whom the Software is furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all copies or
+// substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+using System;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+using ICSharpCode.WpfDesign.Adorners;
+using ICSharpCode.WpfDesign.Extensions;
+
+namespace ICSharpCode.WpfDesign.Designer.Extensions
+{
+	[ExtensionServer(typeof(PrimarySelectionExtensionServer))]
+	[ExtensionFor(typeof (UIElement))]
+	[Extension(Order = 10)]
+	public class DefaultCommandsContextMenuExtension : SelectionAdornerProvider
+	{
+		DesignPanel panel;
+		ContextMenu contextMenu;
+
+		protected override void OnInitialized()
+		{
+			base.OnInitialized();
+
+			contextMenu = new DefaultCommandsContextMenu(ExtendedItem);
+			panel = ExtendedItem.Context.Services.DesignPanel as DesignPanel;
+			if (panel != null)
+				panel.AddContextMenu(contextMenu);
+		}
+
+		protected override void OnRemove()
+		{
+			if (panel != null)
+				panel.RemoveContextMenu(contextMenu);
+
+			base.OnRemove();
+		}
+	}
+}

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.Designer/Project/Extensions/DefaultPlacementBehavior.cs

@@ -38,26 +38,8 @@ namespace ICSharpCode.WpfDesign.Designer.Extensions
 	[ExtensionFor(typeof(Viewbox))]
 	public class DefaultPlacementBehavior : BehaviorExtension, IPlacementBehavior
 	{
-		static List<Type> _contentControlsNotAllowedToAdd;
-
 		static DefaultPlacementBehavior()
-		{
+		{ }
-			_contentControlsNotAllowedToAdd = new List<Type>();
-			_contentControlsNotAllowedToAdd.Add(typeof (Frame));
-			_contentControlsNotAllowedToAdd.Add(typeof (GroupItem));
-			_contentControlsNotAllowedToAdd.Add(typeof (HeaderedContentControl));
-			_contentControlsNotAllowedToAdd.Add(typeof (Label));
-			_contentControlsNotAllowedToAdd.Add(typeof (ListBoxItem));
-			//_contentControlsNotAllowedToAdd.Add(typeof (ButtonBase));
-			_contentControlsNotAllowedToAdd.Add(typeof (StatusBarItem));
-			_contentControlsNotAllowedToAdd.Add(typeof (ToolTip));
-		}
-
-		public static bool CanContentControlAdd(ContentControl control)
-		{
-			Debug.Assert(control != null);
-			return !_contentControlsNotAllowedToAdd.Any(type => type.IsAssignableFrom(control.GetType()));
-		}
 
 		protected override void OnInitialized()
 		{
@@ -68,7 +50,7 @@ namespace ICSharpCode.WpfDesign.Designer.Extensions
 			ExtendedItem.AddBehavior(typeof(IPlacementBehavior), this);
 		}
 
-		public virtual bool CanPlace(ICollection<DesignItem> childItems, PlacementType type, PlacementAlignment position)
+		public virtual bool CanPlace(IEnumerable<DesignItem> childItems, PlacementType type, PlacementAlignment position)
 		{
 			return true;
 		}
@@ -98,6 +80,11 @@ namespace ICSharpCode.WpfDesign.Designer.Extensions
 		{
 		}
 
+		public virtual bool CanPlaceItem(PlacementInformation info)
+		{
+			return true;
+		}
+
 		public virtual void SetPosition(PlacementInformation info)
 		{
 			if (info.Operation.Type != PlacementType.Move)
@@ -158,11 +145,6 @@ namespace ICSharpCode.WpfDesign.Designer.Extensions
 			if (ExtendedItem.ContentProperty.IsCollection)
 				return CollectionSupport.CanCollectionAdd(ExtendedItem.ContentProperty.ReturnType,
 				                                          operation.PlacedItems.Select(p => p.Item.Component));
-			if (ExtendedItem.View is ContentControl) {
-				if (!CanContentControlAdd((ContentControl) ExtendedItem.View)) {
-					return false;
-				}
-			}
 			
 			if (ExtendedItem.ContentProperty.ReturnType == typeof(string))
 				return false;

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.Designer/Project/Extensions/EditStyleContextMenuExtension.cs

@@ -26,7 +26,7 @@ namespace ICSharpCode.WpfDesign.Designer.Extensions
 {
 	[ExtensionServer(typeof (OnlyOneItemSelectedExtensionServer))]
 	[ExtensionFor(typeof (Control))]
-	[Extension(Order = 10)]
+	[Extension(Order = 30)]
 	public class EditStyleContextMenuExtension : PrimarySelectionAdornerProvider
 	{
 		DesignPanel panel;

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.Designer/Project/Extensions/RightClickContextMenuExtension.cs

@@ -30,6 +30,7 @@ namespace ICSharpCode.WpfDesign.Designer.Extensions
 	/// </summary>
 	[ExtensionServer(typeof(OnlyOneItemSelectedExtensionServer))]
 	[ExtensionFor(typeof(UIElement))]
+	[Extension(Order = 20)]
 	public sealed class RightClickContextMenuExtension : PrimarySelectionAdornerProvider
 	{
 		DesignPanel panel;

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.Designer/Project/Extensions/SnaplinePlacementBehavior.cs

@@ -225,9 +225,12 @@ namespace ICSharpCode.WpfDesign.Designer.Extensions
 			
 			AddLines(containerRect, 0, false);
 
+			if (!CanPlace(operation.PlacedItems.Select(x => x.Item), operation.Type, PlacementAlignment.Center))
+				return;
+
 			foreach (var item in AllDesignItems() /* ExtendedItem.ContentProperty.CollectionElements */
 			         .Except(operation.PlacedItems.Select(f => f.Item))
-			         .Where(x=>!GetDisableSnaplines(x.View))) {
+			         .Where(x=> x.View != null && !GetDisableSnaplines(x.View))) {
 				if (item != null) {
 					var bounds = GetPosition(operation, item);
 					

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.Designer/Project/Extensions/TextBlockRightClickContextMenuExtension.cs

@@ -26,7 +26,7 @@ namespace ICSharpCode.WpfDesign.Designer.Extensions
 {
 	[ExtensionServer(typeof (OnlyOneItemSelectedExtensionServer))]
 	[ExtensionFor(typeof (TextBlock))]
-	[Extension(Order = 10)]
+	[Extension(Order = 40)]
 	public class TextBlockRightClickContextMenuExtension : PrimarySelectionAdornerProvider
 	{
 		DesignPanel panel;

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.Designer/Project/OutlineView/OutlineView.xaml

@@ -97,7 +97,7 @@
 			<Setter.Value>
 				<ControlTemplate TargetType="{x:Type Default:DragTreeViewItem}">
 					
-					<DockPanel Background="White">
+					<DockPanel Background="White" ContextMenu="{Binding DesignItem.Services.DesignPanel.ContextMenu}">
 						<Grid x:Name="bg"
 						           Margin="{TemplateBinding Level, Converter={StaticResource LevelConverter}}"
 						           DockPanel.Dock="Top"
@@ -113,7 +113,7 @@
 							</Border>
 						</Grid>
 						<ItemsPresenter x:Name="itemsHost" />						
-					<DockPanel.ContextMenu>
+					<!-- <DockPanel.ContextMenu>
 					<ContextMenu>
 						<MenuItem Command="ApplicationCommands.Cut" />
 						<MenuItem Command="ApplicationCommands.Copy" />
@@ -121,7 +121,7 @@
 						<Separator />
 						<MenuItem Command="ApplicationCommands.Delete" />
 					</ContextMenu>
-					</DockPanel.ContextMenu>
+					</DockPanel.ContextMenu>-->
 						<DockPanel.ToolTip>
 							<ToolTip Background="White">
 								<Rectangle Width="50" Height="50">

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.Designer/Project/RootItemBehavior.cs

@@ -38,12 +38,9 @@ namespace ICSharpCode.WpfDesign.Designer
 			_rootItem.AddBehavior(typeof(IRootPlacementBehavior),this);
 		}
 
-		public bool CanPlace(System.Collections.Generic.ICollection<DesignItem> childItems, PlacementType type, PlacementAlignment position)
+		public bool CanPlace(IEnumerable<DesignItem> childItems, PlacementType type, PlacementAlignment position)
 		{
-			return type == PlacementType.Resize &&
+			return type == PlacementType.Resize && (position == PlacementAlignment.Right || position == PlacementAlignment.BottomRight || position == PlacementAlignment.Bottom);
-				(position == PlacementAlignment.Right
-				 || position == PlacementAlignment.BottomRight
-				 || position == PlacementAlignment.Bottom);
 		}
 		
 		public void BeginPlacement(PlacementOperation operation)

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.Designer/Project/Services/ClickOrDragMouseGesture.cs

@@ -26,7 +26,7 @@ namespace ICSharpCode.WpfDesign.Designer.Services
 	/// <summary>
 	/// Base class for mouse gestures that should start dragging only after a minimum drag distance.
 	/// </summary>
-	abstract class ClickOrDragMouseGesture : MouseGestureBase
+	public abstract class ClickOrDragMouseGesture : MouseGestureBase
 	{
 		protected Point startPoint;
 		protected bool hasDragStarted;

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.Designer/Project/Services/DragMoveMouseGesture.cs

@@ -28,13 +28,13 @@ namespace ICSharpCode.WpfDesign.Designer.Services
 	/// Mouse gesture for moving elements inside a container or between containers.
 	/// Belongs to the PointerTool.
 	/// </summary>
-	sealed class DragMoveMouseGesture : ClickOrDragMouseGesture
+	public sealed class DragMoveMouseGesture : ClickOrDragMouseGesture
 	{
 		bool isDoubleClick;
 		bool setSelectionIfNotMoving;
 		MoveLogic moveLogic;
 
-		internal DragMoveMouseGesture(DesignItem clickedOn, bool isDoubleClick, bool setSelectionIfNotMoving = false)
+		public DragMoveMouseGesture(DesignItem clickedOn, bool isDoubleClick, bool setSelectionIfNotMoving = false)
 		{
 			Debug.Assert(clickedOn != null);
 			

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.Designer/Project/Services/MouseGestureBase.cs

@@ -25,7 +25,7 @@ namespace ICSharpCode.WpfDesign.Designer.Services
 	/// <summary>
 	/// Base class for classes handling mouse gestures on the design surface.
 	/// </summary>
-	abstract class MouseGestureBase
+	public abstract class MouseGestureBase
 	{
 		/// <summary>
 		/// Checks if <paramref name="button"/> is the only button that is currently pressed.

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.Designer/Project/WpfDesign.Designer.csproj

@@ -86,6 +86,11 @@
     <Compile Include="ArrangeDirection.cs" />
     <Compile Include="Controls\RenderTransformOriginThumb.cs" />
     <Compile Include="Extensions\BorderForImageControl.cs" />
+    <Compile Include="Extensions\DefaultCommandsContextMenu.xaml.cs">
+      <DependentUpon>DefaultCommandsContextMenu.xaml</DependentUpon>
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Extensions\DefaultCommandsContextMenuExtension.cs" />
     <Compile Include="Extensions\PartialPanelSelectionHandler.cs" />
     <Compile Include="Extensions\EditStyleContextMenu.xaml.cs">
       <DependentUpon>EditStyleContextMenu.xaml</DependentUpon>
@@ -289,6 +294,7 @@
     <Resource Include="Images\Tag.png" />
   </ItemGroup>
   <ItemGroup>
+    <Page Include="Extensions\DefaultCommandsContextMenu.xaml" />
     <Page Include="Extensions\EditStyleContextMenu.xaml">
       <SubType>Designer</SubType>
     </Page>
@@ -468,4 +474,12 @@
   <ItemGroup>
     <Resource Include="Images\Icons.32x32.EmptyProjectIcon.png" />
   </ItemGroup>
+  <ItemGroup>
+    <Resource Include="Images\Icons.16x16.CopyIcon.png" />
+    <Resource Include="Images\Icons.16x16.CutIcon.png" />
+    <Resource Include="Images\Icons.16x16.DeleteIcon.png" />
+    <Resource Include="Images\Icons.16x16.PasteIcon.png" />
+    <Resource Include="Images\Icons.16x16.RedoIcon.png" />
+    <Resource Include="Images\Icons.16x16.UndoIcon.png" />
+  </ItemGroup>
 </Project>

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.Designer/Project/Xaml/XamlDesignItem.cs

@@ -20,8 +20,11 @@
 //#define EventHandlerDebugging
 
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
+using System.Linq;
 using System.Windows;
+using System.Windows.Data;
 using ICSharpCode.WpfDesign.XamlDom;
 using ICSharpCode.WpfDesign.Designer.Services;
 using System.Windows.Markup;
@@ -65,7 +68,11 @@ namespace ICSharpCode.WpfDesign.Designer.Xaml
 		
 		void SetNameInternal(string newName)
 		{
+			var oldName = Name;
+
 			_xamlObject.Name = newName;
+
+			FixDesignItemReferencesOnNameChange(oldName, Name);
 		}
 
 		public override string Name {
@@ -75,8 +82,100 @@ namespace ICSharpCode.WpfDesign.Designer.Xaml
 				if (undoService != null)
 					undoService.Execute(new SetNameAction(this, value));
 				else
+				{
 					SetNameInternal(value);
 				}
+
+			}
+		}
+
+		/// <summary>
+		/// Fixes {x:Reference and {Binding ElementName to this Element in XamlDocument
+		/// </summary>
+		/// <param name="oldName"></param>
+		/// <param name="newName"></param>
+		public void FixDesignItemReferencesOnNameChange(string oldName, string newName)
+		{
+			var root = GetRootXamlObject(this.XamlObject);
+			var references = GetAllChildXamlObjects(root).Where(x => x.ElementType == typeof(Reference) && Equals(x.FindOrCreateProperty("Name").ValueOnInstance, oldName));
+			foreach (var designItem in references)
+			{
+				var property = designItem.FindOrCreateProperty("Name");
+				var propertyValue = designItem.OwnerDocument.CreatePropertyValue(newName, property);
+				this.ComponentService.RegisterXamlComponentRecursive(propertyValue as XamlObject);
+				property.PropertyValue = propertyValue;
+			}
+
+			root = GetRootXamlObject(this.XamlObject, true);
+			var bindings = GetAllChildXamlObjects(root, true).Where(x => x.ElementType == typeof(Binding) && Equals(x.FindOrCreateProperty("ElementName").ValueOnInstance, oldName));
+			foreach (var designItem in bindings)
+			{
+				var property = designItem.FindOrCreateProperty("ElementName");
+				var propertyValue = designItem.OwnerDocument.CreatePropertyValue(newName, property);
+				this.ComponentService.RegisterXamlComponentRecursive(propertyValue as XamlObject);
+				property.PropertyValue = propertyValue;
+			}
+		}
+
+		/// <summary>
+		/// Find's the Root XamlObject (real Root, or Root Object in Namescope)
+		/// </summary>
+		/// <param name="item"></param>
+		/// <param name="onlyFromSameNamescope"></param>
+		/// <returns></returns>
+		private XamlObject GetRootXamlObject(XamlObject item, bool onlyFromSameNamescope = false)
+		{
+			var root = item;
+			while (root.ParentObject != null)
+			{
+				if (onlyFromSameNamescope && NameScopeHelper.GetNameScopeFromObject(root) != NameScopeHelper.GetNameScopeFromObject(root.ParentObject))
+					break;
+				root = root.ParentObject;
+			}
+
+			return root;
+		}
+
+		/// <summary>
+		/// Get's all Child XamlObject Instances
+		/// </summary>
+		/// <param name="item"></param>
+		/// <param name="onlyFromSameNamescope"></param>
+		/// <returns></returns>
+		private IEnumerable<XamlObject> GetAllChildXamlObjects(XamlObject item, bool onlyFromSameNamescope = false)
+		{
+			foreach (var prop in item.Properties)
+			{
+				if (prop.PropertyValue as XamlObject != null)
+				{
+					if (!onlyFromSameNamescope || NameScopeHelper.GetNameScopeFromObject(item) == NameScopeHelper.GetNameScopeFromObject(prop.PropertyValue as XamlObject))
+						yield return prop.PropertyValue as XamlObject;
+
+					foreach (var i in GetAllChildXamlObjects(prop.PropertyValue as XamlObject))
+					{
+						if (!onlyFromSameNamescope || NameScopeHelper.GetNameScopeFromObject(item) == NameScopeHelper.GetNameScopeFromObject(i))
+							yield return i;
+					}
+				}
+
+				if (prop.IsCollection)
+				{
+					foreach (var collectionElement in prop.CollectionElements)
+					{
+						if (collectionElement as XamlObject != null)
+						{
+							if (!onlyFromSameNamescope || NameScopeHelper.GetNameScopeFromObject(item) == NameScopeHelper.GetNameScopeFromObject(collectionElement as XamlObject))
+								yield return collectionElement as XamlObject;
+
+							foreach (var i in GetAllChildXamlObjects(collectionElement as XamlObject))
+							{
+								if (!onlyFromSameNamescope || NameScopeHelper.GetNameScopeFromObject(item) == NameScopeHelper.GetNameScopeFromObject(i))
+									yield return i;
+							}
+						}
+					}
+				}
+			}
 		}
 
 		public override string Key {

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.Designer/Project/Xaml/XamlEditOperations.cs

@@ -131,7 +131,7 @@ namespace ICSharpCode.WpfDesign.Designer.Xaml
 								AddInParent(parent, pastedItems);
 								pasted = true;
 							}
-						} else if (pastedItems.Count == 1 && parent.ContentProperty.Value == null && parent.ContentProperty.ValueOnInstance == null && parent.View is ContentControl && DefaultPlacementBehavior.CanContentControlAdd((ContentControl)parent.View)) {
+						} else if (pastedItems.Count == 1 && parent.ContentProperty.Value == null && parent.ContentProperty.ValueOnInstance == null && parent.View is ContentControl) {
 							AddInParent(parent, pastedItems);
 							pasted = true;
 						}

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.Designer/Tests/XamlDom/SamplesTests.cs

@@ -452,7 +452,6 @@ namespace ICSharpCode.WpfDesign.Tests.XamlDom
 		}
 
 		[Test]
-		[Ignore("Xaml writer creates different XAML")]
 		public void Style3()
 		{
 			TestLoading(@"<Window xmlns=""http://schemas.microsoft.com/winfx/2006/xaml/presentation""
@@ -504,6 +503,26 @@ namespace ICSharpCode.WpfDesign.Tests.XamlDom
 </Window>");
 		}
 
+		[Test]
+		public void Template2()
+		{
+			TestLoading(@"<Window xmlns=""http://schemas.microsoft.com/winfx/2006/xaml/presentation""
+        xmlns:x=""http://schemas.microsoft.com/winfx/2006/xaml"">
+<Window.Resources>
+<ResourceDictionary>
+
+   <SolidColorBrush Color=""Blue"" x:Key=""bb"" />
+                      
+                    <ControlTemplate x:Key=""aa"" TargetType=""Button"">
+                        <Grid HorizontalAlignment=""Left"">
+                            <Rectangle Fill=""{StaticResource bb}"" />
+                        </Grid>
+                    </ControlTemplate>
+        
+</ResourceDictionary>
+</Window.Resources>
+</Window>");
+		}
 
 		[Test]
 		public void ListBox1()

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.Designer/Tests/XamlDom/SimpleLoadTests.cs

@@ -293,7 +293,6 @@ namespace ICSharpCode.WpfDesign.Tests.XamlDom
 		}
 		
 		[Test]
-		[Ignore("Own XamlParser should handle different namespaces pointing to same types, because builtin XamlReader does.")]
 		public void ResourceDictionaryExplicitNetfx2007()
 		{
 			// The reason this test case fails is because own XamlParser cannot always handle the case where multiple xmlns points to the same type.

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.XamlDom/Project/DesignInstanceExtension.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Windows.Markup;
+
+namespace ICSharpCode.WpfDesign.XamlDom
+{
+	public class DesignInstanceExtension : MarkupExtension
+	{
+		public DesignInstanceExtension(Type type)
+		{
+			this.Type = type;
+		}
+
+		public Type Type { get; set; }
+
+		public bool IsDesignTimeCreatable { get; set; }
+
+		public bool CreateList { get; set; }
+
+		public override object ProvideValue(IServiceProvider serviceProvider)
+		{
+			return null;
+		}
+	}
+}

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.XamlDom/Project/TemplateHelper.cs

@@ -17,6 +17,7 @@
 // DEALINGS IN THE SOFTWARE.
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -24,6 +25,7 @@ using System.Reflection;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Markup;
+using System.Xaml;
 using System.Xml;
 using System.Xml.XPath;
 
@@ -31,8 +33,9 @@ namespace ICSharpCode.WpfDesign.XamlDom
 {
 	public static class TemplateHelper
 	{
-		public static FrameworkTemplate GetFrameworkTemplate(XmlElement xmlElement)
+		public static FrameworkTemplate GetFrameworkTemplate(XmlElement xmlElement, XamlObject parentObject)
 		{
+
 			var nav = xmlElement.CreateNavigator();
 
 			var ns = new Dictionary<string, string>();
@@ -48,15 +51,88 @@ namespace ICSharpCode.WpfDesign.XamlDom
 					break;
 			}
 			
-			foreach (var dictentry in ns)
+			xmlElement = (XmlElement)xmlElement.CloneNode(true);
+
+			foreach (var dictentry in ns.ToList())
 			{
 				xmlElement.SetAttribute("xmlns:" + dictentry.Key, dictentry.Value);
 			}
 
+			var keyAttrib = xmlElement.GetAttribute("Key", XamlConstants.XamlNamespace);
+
+			if (string.IsNullOrEmpty(keyAttrib)) {
+				xmlElement.SetAttribute("Key", XamlConstants.XamlNamespace, "$$temp&&§§%%__");
+			}
+
 			var xaml = xmlElement.OuterXml;
+			xaml = "<ResourceDictionary xmlns=\"http://schemas.microsoft.com/netfx/2007/xaml/presentation\" xmlns:x=\"http://schemas.microsoft.com/winfx/2006/xaml\">" + xaml + "</ResourceDictionary>";
 			StringReader stringReader = new StringReader(xaml);
 			XmlReader xmlReader = XmlReader.Create(stringReader);
-			return (FrameworkTemplate)XamlReader.Load(xmlReader);
+			var xamlReader = new XamlXmlReader(xmlReader, parentObject.ServiceProvider.SchemaContext);
+
+			var seti = new XamlObjectWriterSettings();
+
+			var resourceDictionary = new ResourceDictionary();
+			var obj = parentObject;
+			while (obj != null)
+			{
+				if (obj.Instance is ResourceDictionary)
+				{
+					var r = obj.Instance as ResourceDictionary;
+					foreach (var k in r.Keys)
+					{
+						if (!resourceDictionary.Contains(k))
+							resourceDictionary.Add(k, r[k]);
+					}
+				}
+				else if (obj.Instance is FrameworkElement)
+				{
+					var r = ((FrameworkElement)obj.Instance).Resources;
+					foreach (var k in r.Keys)
+					{
+						if (!resourceDictionary.Contains(k))
+							resourceDictionary.Add(k, r[k]);
+					}
+				}
+
+				obj = obj.ParentObject;
+			}
+
+			seti.BeforePropertiesHandler = (s, e) =>
+			{
+				if (seti.BeforePropertiesHandler != null)
+				{
+					var rr = e.Instance as ResourceDictionary;
+					rr.MergedDictionaries.Add(resourceDictionary);
+					seti.BeforePropertiesHandler = null;
+				}
+			};
+
+			var writer = new XamlObjectWriter(parentObject.ServiceProvider.SchemaContext, seti);
+
+			XamlServices.Transform(xamlReader, writer);
+
+			var result = (ResourceDictionary)writer.Result;
+
+			var enr = result.Keys.GetEnumerator();
+			enr.MoveNext();
+			var rdKey = enr.Current;
+
+			var template = result[rdKey] as FrameworkTemplate;
+			
+			result.Remove(rdKey);
+			return template;
+		}
+
+		
+		private static Stream GenerateStreamFromString(string s)
+		{
+			MemoryStream stream = new MemoryStream();
+			StreamWriter writer = new StreamWriter(stream);
+			writer.Write(s);
+			writer.Flush();
+			stream.Position = 0;
+			return stream;
 		}
 	}
 }

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.XamlDom/Project/WpfDesign.XamlDom.csproj

@@ -69,6 +69,7 @@
     <Compile Include="AssemblyInfo.cs" />
     <Compile Include="CollectionElementsCollection.cs" />
     <Compile Include="CollectionSupport.cs" />
+    <Compile Include="DesignInstanceExtension.cs" />
     <Compile Include="DesignTimeProperties.cs" />
     <Compile Include="IXamlErrorSink.cs" />
     <Compile Include="MarkupCompatibilityProperties.cs" />

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.XamlDom/Project/XamlDocument.cs

@@ -229,6 +229,16 @@ namespace ICSharpCode.WpfDesign.XamlDom
 			return _typeFinder.GetXmlNamespaceFor(type.Assembly, type.Namespace, getClrNamespace);
 		}
 		
+		internal List<string> GetNamespacesFor(Type type, bool getClrNamespace = false)
+		{
+			if (type == typeof (DesignTimeProperties))
+				return new List<string>(){XamlConstants.DesignTimeNamespace};
+			if (type == typeof (MarkupCompatibilityProperties))
+				return new List<string>(){XamlConstants.MarkupCompatibilityNamespace};
+
+			return _typeFinder.GetXmlNamespacesFor(type.Assembly, type.Namespace, getClrNamespace);
+		}
+
 		internal string GetPrefixForNamespace(string @namespace)
 		{
 			if (@namespace == XamlConstants.PresentationNamespace)

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.XamlDom/Project/XamlObject.cs

@@ -426,11 +426,23 @@ namespace ICSharpCode.WpfDesign.XamlDom
 			PropertyDescriptorCollection propertyDescriptors = TypeDescriptor.GetProperties(instance);
 			PropertyDescriptor propertyInfo = propertyDescriptors[propertyName];
 			XamlProperty newProperty;
+
+			if (propertyInfo == null) {
+				propertyDescriptors = TypeDescriptor.GetProperties(this.elementType);
+				propertyInfo = propertyDescriptors[propertyName];
+			}
+
 			if (propertyInfo != null) {
 				newProperty = new XamlProperty(this, new XamlNormalPropertyInfo(propertyInfo));
 			} else {
 				EventDescriptorCollection events = TypeDescriptor.GetEvents(instance);
 				EventDescriptor eventInfo = events[propertyName];
+
+				if (eventInfo == null) {
+					events = TypeDescriptor.GetEvents(this.elementType);
+					eventInfo = events[propertyName];
+				}
+
 				if (eventInfo != null) {
 					newProperty = new XamlProperty(this, new XamlEventPropertyInfo(eventInfo));
 				} else {
@@ -502,8 +514,18 @@ namespace ICSharpCode.WpfDesign.XamlDom
 
 			if (value == null)
 				element.RemoveAttribute(name, XamlConstants.XamlNamespace);
+			else
+			{
+				var prefix = element.GetPrefixOfNamespace(XamlConstants.XamlNamespace);
+				if (!string.IsNullOrEmpty(prefix))
+				{
+					var attribute = element.OwnerDocument.CreateAttribute(prefix, name, XamlConstants.XamlNamespace);
+					attribute.InnerText = value;
+					element.SetAttributeNode(attribute);
+				}
 				else
 					element.SetAttribute(name, XamlConstants.XamlNamespace, value);
+			}
 			
 			if (isNameChange) {
 				bool nameChangedAlreadyRaised = false;

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.XamlDom/Project/XamlObjectServiceProvider.cs

@@ -136,7 +136,7 @@ namespace ICSharpCode.WpfDesign.XamlDom
 		{
 			get
 			{
-				return iCsharpXamlSchemaContext = iCsharpXamlSchemaContext ?? new XamlSchemaContext();
+				return iCsharpXamlSchemaContext = iCsharpXamlSchemaContext ?? System.Windows.Markup.XamlReader.GetWpfSchemaContext(); // new XamlSchemaContext();
 			}
 		}
 

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.XamlDom/Project/XamlParser.cs

@@ -28,6 +28,7 @@ using System.Windows;
 using System.Windows.Interop;
 using System.Windows.Markup;
 using System.Xml;
+using System.Windows.Media;
 
 namespace ICSharpCode.WpfDesign.XamlDom
 {
@@ -146,6 +147,8 @@ namespace ICSharpCode.WpfDesign.XamlDom
 		static Type FindType(XamlTypeFinder typeFinder, string namespaceUri, string localName)
 		{
 			Type elementType = typeFinder.GetType(namespaceUri, localName);
+			if (elementType == null)
+				elementType = typeFinder.GetType(namespaceUri, localName+"Extension");
 			if (elementType == null)
 				throw new XamlLoadException("Cannot find type " + localName + " in " + namespaceUri);
 			return elementType;
@@ -195,7 +198,7 @@ namespace ICSharpCode.WpfDesign.XamlDom
 
 			if (typeof (FrameworkTemplate).IsAssignableFrom(elementType))
 			{
-				var xamlObj = new XamlObject(document, element, elementType, TemplateHelper.GetFrameworkTemplate(element));
+				var xamlObj = new XamlObject(document, element, elementType, TemplateHelper.GetFrameworkTemplate(element, currentXamlObject));
 				xamlObj.ParentObject = currentXamlObject;
 				return xamlObj;
 			}
@@ -323,8 +326,11 @@ namespace ICSharpCode.WpfDesign.XamlDom
 			if (defaultProperty == null && obj.Instance != null && CollectionSupport.IsCollectionType(obj.Instance.GetType())) {
 				XamlObject parentObj = obj.ParentObject;
 				var parentElement = element.ParentNode;
-				XamlPropertyInfo propertyInfo = GetPropertyInfo(settings.TypeFinder, parentObj.Instance, parentObj.ElementType, parentElement.NamespaceURI, parentElement.LocalName);
+				XamlPropertyInfo propertyInfo;
+				if (parentObj != null) {
+					propertyInfo = GetPropertyInfo(settings.TypeFinder, parentObj.Instance, parentObj.ElementType, parentElement.NamespaceURI, parentElement.LocalName);
 					collectionProperty = FindExistingXamlProperty(parentObj, propertyInfo);
+				}
 				collectionInstance = obj.Instance;
 				collectionType = obj.ElementType;
 				collectionPropertyElement = element;
@@ -500,6 +506,7 @@ namespace ICSharpCode.WpfDesign.XamlDom
 			if (eventInfo != null) {
 				return new XamlEventPropertyInfo(eventInfo);
 			}
+
 			throw new XamlLoadException("property " + propertyName + " not found");
 		}
 		
@@ -507,7 +514,7 @@ namespace ICSharpCode.WpfDesign.XamlDom
 		{
 			MethodInfo getMethod = elementType.GetMethod("Get" + propertyName, BindingFlags.Public | BindingFlags.Static);
 			MethodInfo setMethod = elementType.GetMethod("Set" + propertyName, BindingFlags.Public | BindingFlags.Static);
-			if (getMethod != null && setMethod != null) {
+			if (getMethod != null || setMethod != null) {
 				FieldInfo field = elementType.GetField(propertyName + "Property", BindingFlags.Public | BindingFlags.Static);
 				if (field != null && field.FieldType == typeof(DependencyProperty)) {
 					return new XamlDependencyPropertyInfo((DependencyProperty)field.GetValue(null), true);
@@ -521,9 +528,28 @@ namespace ICSharpCode.WpfDesign.XamlDom
 			return null;
 		}
 
+		internal static XamlPropertyInfo TryFindAttachedEvent(Type elementType, string propertyName)
+		{
+			FieldInfo fieldEvent = elementType.GetField(propertyName + "Event", BindingFlags.Public | BindingFlags.Static);
+			if (fieldEvent != null && fieldEvent.FieldType == typeof(RoutedEvent))
+			{
+				return new XamlEventPropertyInfo(TypeDescriptor.GetEvents(elementType)[propertyName]);
+			}
+
+			if (elementType.BaseType != null)
+			{
+				return TryFindAttachedEvent(elementType.BaseType, propertyName);
+			}
+
+			return null;
+		}
 		static XamlPropertyInfo FindAttachedProperty(Type elementType, string propertyName)
 		{
 			XamlPropertyInfo pi = TryFindAttachedProperty(elementType, propertyName);
+
+			if (pi == null) {
+				pi = TryFindAttachedEvent(elementType, propertyName);
+			}
 			if (pi != null) {
 				return pi;
 			} else {
@@ -555,8 +581,13 @@ namespace ICSharpCode.WpfDesign.XamlDom
 				return FindAttachedProperty(typeof(DesignTimeProperties), attribute.LocalName);
 			} else if (attribute.LocalName == "IsLocked" && attribute.NamespaceURI == XamlConstants.DesignTimeNamespace) {
 				return FindAttachedProperty(typeof(DesignTimeProperties), attribute.LocalName);
+			} else if (attribute.LocalName == "LayoutOverrides" && attribute.NamespaceURI == XamlConstants.DesignTimeNamespace) {
+				return FindAttachedProperty(typeof(DesignTimeProperties), attribute.LocalName);
+			} else if (attribute.LocalName == "LayoutRounding" && attribute.NamespaceURI == XamlConstants.DesignTimeNamespace) {
+				return FindAttachedProperty(typeof(DesignTimeProperties), attribute.LocalName);
 			}
 			
+
 			return null;
 		}
 		
@@ -674,6 +705,7 @@ namespace ICSharpCode.WpfDesign.XamlDom
 				else {
 					collectionInstance = collectionProperty.propertyInfo.GetValue(obj.Instance);
 					collectionProperty.ParserSetPropertyElement(element);
+					collectionInstance = collectionInstance ?? Activator.CreateInstance(collectionProperty.propertyInfo.ReturnType);
 				}
 			}
 			
@@ -712,6 +744,13 @@ namespace ICSharpCode.WpfDesign.XamlDom
 
 		internal static object CreateObjectFromAttributeText(string valueText, XamlPropertyInfo targetProperty, XamlObject scope)
 		{
+			if (targetProperty.ReturnType == typeof(Uri)) {
+				return scope.OwnerDocument.TypeFinder.ConvertUriToLocalUri(new Uri(valueText, UriKind.RelativeOrAbsolute));
+			} else if (targetProperty.ReturnType == typeof(ImageSource)) {
+				var uri = scope.OwnerDocument.TypeFinder.ConvertUriToLocalUri(new Uri(valueText, UriKind.RelativeOrAbsolute));
+				return targetProperty.TypeConverter.ConvertFromString(scope.OwnerDocument.GetTypeDescriptorContext(scope), CultureInfo.InvariantCulture, uri.ToString());
+			}
+
 			return targetProperty.TypeConverter.ConvertFromString(
 				scope.OwnerDocument.GetTypeDescriptorContext(scope),
 				CultureInfo.InvariantCulture, valueText);
@@ -768,6 +807,19 @@ namespace ICSharpCode.WpfDesign.XamlDom
 		/// <param name="settings">Parser settings used by <see cref="XamlParser"/>.</param>
 		/// <returns>Returns the XamlObject of the parsed <paramref name="xaml"/>.</returns>
 		public static XamlObject ParseSnippet(XamlObject root, string xaml, XamlParserSettings settings)
+		{
+			return ParseSnippet(root, xaml, settings, null);
+		}
+
+		/// <summary>
+		/// Method use to parse a piece of Xaml.
+		/// </summary>
+		/// <param name="root">The Root XamlObject of the current document.</param>
+		/// <param name="xaml">The Xaml being parsed.</param>
+		/// <param name="settings">Parser settings used by <see cref="XamlParser"/>.</param>
+		/// <param name="parentObject">Parent Object, where the Parsed snippet will be inserted (Needed for Example for Bindings).</param>
+		/// <returns>Returns the XamlObject of the parsed <paramref name="xaml"/>.</returns>
+		public static XamlObject ParseSnippet(XamlObject root, string xaml, XamlParserSettings settings, XamlObject parentObject)
 		{
 			XmlTextReader reader = new XmlTextReader(new StringReader(xaml));
 			var element = root.OwnerDocument.XmlDocument.ReadNode(reader);
@@ -785,6 +837,7 @@ namespace ICSharpCode.WpfDesign.XamlDom
 				parser.settings = settings;
 				parser.errorSink = (IXamlErrorSink)settings.ServiceProvider.GetService(typeof(IXamlErrorSink));
 				parser.document = root.OwnerDocument;
+				parser.currentXamlObject = parentObject;
 				var xamlObject = parser.ParseObject(element as XmlElement);
 
 				RemoveRootNamespacesFromNodeAndChildNodes(root, element);

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.XamlDom/Project/XamlProperty.cs

@@ -356,19 +356,19 @@ namespace ICSharpCode.WpfDesign.XamlDom
 		static XmlNode FindChildNode(XmlNode node, Type elementType, string propertyName, XamlDocument xamlDocument)
 		{
 			var localName = elementType.Name + "." + propertyName;
-			var namespaceURI = xamlDocument.GetNamespaceFor(elementType);
+			var namespacesURI = xamlDocument.GetNamespacesFor(elementType);
 			var clrNamespaceURI = xamlDocument.GetNamespaceFor(elementType, true);
 
 			foreach (XmlNode childNode in node.ChildNodes)
 			{
-				if (childNode.LocalName == localName && (childNode.NamespaceURI == namespaceURI || childNode.NamespaceURI == clrNamespaceURI))
+				if (childNode.LocalName == localName && (namespacesURI.Contains(childNode.NamespaceURI) || childNode.NamespaceURI == clrNamespaceURI))
 				{
 					return childNode;
 				}
 			}
 
 			var type = elementType.BaseType;
-			namespaceURI = xamlDocument.GetNamespaceFor(type);
+			namespacesURI = xamlDocument.GetNamespacesFor(type);
 
 			while (type != typeof(object))
 			{
@@ -379,7 +379,7 @@ namespace ICSharpCode.WpfDesign.XamlDom
 
 				foreach (XmlNode childNode in node.ChildNodes)
 				{
-					if (childNode.LocalName == localName && childNode.NamespaceURI == namespaceURI)
+					if (childNode.LocalName == localName && namespacesURI.Contains(childNode.NamespaceURI))
 					{
 						return childNode;
 					}
@@ -556,7 +556,13 @@ namespace ICSharpCode.WpfDesign.XamlDom
 				}
 			}
 			set {
-				propertyInfo.SetValue(parentObject.Instance, value);
+				var setValue = value;
+				if (propertyInfo.ReturnType == typeof(Uri))
+				{
+					setValue = this.ParentObject.OwnerDocument.TypeFinder.ConvertUriToLocalUri((Uri)value);
+				}
+				
+				propertyInfo.SetValue(parentObject.Instance, setValue);
 				if (ValueOnInstanceChanged != null)
 					ValueOnInstanceChanged(this, EventArgs.Empty);
 			}

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.XamlDom/Project/XamlTypeFinder.cs

@@ -19,6 +19,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Linq;
 using System.Reflection;
 using System.Windows.Markup;
 using System.Xaml;
@@ -82,6 +83,7 @@ namespace ICSharpCode.WpfDesign.XamlDom
 		
 		Dictionary<string, XamlNamespace> namespaces = new Dictionary<string, XamlNamespace>();
 		Dictionary<AssemblyNamespaceMapping, string> reverseDict = new Dictionary<AssemblyNamespaceMapping, string>();
+		Dictionary<AssemblyNamespaceMapping, List<string>> reverseDictList = new Dictionary<AssemblyNamespaceMapping, List<string>>();
 		
 		/// <summary>
 		/// Gets a type referenced in XAML.
@@ -128,6 +130,20 @@ namespace ICSharpCode.WpfDesign.XamlDom
 			}
 		}
 
+		/// <summary>
+		/// Gets the XML namespaces that can be used for the specified assembly/namespace combination.
+		/// </summary>
+		public List<string> GetXmlNamespacesFor(Assembly assembly, string @namespace, bool getClrNamespace = false)
+		{
+			AssemblyNamespaceMapping mapping = new AssemblyNamespaceMapping(assembly, @namespace);
+			List<string> xmlNamespaces;
+			if (!getClrNamespace && reverseDictList.TryGetValue(mapping, out xmlNamespaces)) {
+				return xmlNamespaces;
+			} else {
+				return new List<string>() { "clr-namespace:" + mapping.Namespace + ";assembly=" + mapping.Assembly.GetName().Name };
+			}
+		}
+		
 		/// <summary>
 		/// Gets the prefix to use for the specified XML namespace,
 		/// or null if no suitable prefix could be found.
@@ -178,6 +194,14 @@ namespace ICSharpCode.WpfDesign.XamlDom
 		{
 			ns.ClrNamespaces.Add(mapping);
 
+			List<string> xmlNamespaceList;
+			if (reverseDictList.TryGetValue(mapping, out xmlNamespaceList)) {
+				if (!xmlNamespaceList.Contains(ns.XmlNamespace))
+					xmlNamespaceList.Add(ns.XmlNamespace);
+			}
+			else
+				reverseDictList.Add(mapping, new List<string>(){ ns.XmlNamespace });
+			
 			string xmlNamespace;
 			if (reverseDict.TryGetValue(mapping, out xmlNamespace)) {
 				if (xmlNamespace == XamlConstants.PresentationNamespace) {
@@ -262,6 +286,9 @@ namespace ICSharpCode.WpfDesign.XamlDom
 			foreach (KeyValuePair<AssemblyNamespaceMapping, string> pair in source.reverseDict) {
 				this.reverseDict.Add(pair.Key, pair.Value);
 			}
+			foreach (KeyValuePair<AssemblyNamespaceMapping, List<string>> pair in source.reverseDictList) {
+				this.reverseDictList.Add(pair.Key, pair.Value.ToList());
+			}
 		}
 		
 		object ICloneable.Clone()
@@ -277,6 +304,11 @@ namespace ICSharpCode.WpfDesign.XamlDom
 			return WpfTypeFinder.Instance.Clone();
 		}
 		
+		public virtual Uri ConvertUriToLocalUri(Uri uri)
+		{
+			return uri;
+		}
+		
 		static class WpfTypeFinder
 		{
 			internal static readonly XamlTypeFinder Instance;
@@ -291,6 +323,7 @@ namespace ICSharpCode.WpfDesign.XamlDom
 				Instance.RegisterAssembly(typeof(IAddChild).Assembly); // PresentationCore
 				Instance.RegisterAssembly(typeof(XamlReader).Assembly); // PresentationFramework
 				Instance.RegisterAssembly(typeof(XamlType).Assembly); // System.Xaml
+				Instance.RegisterAssembly(typeof(Type).Assembly); // mscorelib
 			}
 		}
 	}

src/AddIns/DisplayBindings/WpfDesign/WpfDesign/Project/DesignItem.cs

@@ -161,6 +161,13 @@ namespace ICSharpCode.WpfDesign
 			for (int i = 0; i < _extensionServers.Length; i++) {
 				if (_extensionServers[i] == server) {
 					bool shouldApply = server.ShouldApplyExtensions(this);
+
+					if (server.ShouldBeReApplied() && shouldApply && shouldApply == _extensionServerIsApplied[i])
+					{
+						_extensionServerIsApplied[i] = false;
+						ApplyUnapplyExtensionServer(extensionManager, false, server);
+					}
+
 					if (shouldApply != _extensionServerIsApplied[i]) {
 						_extensionServerIsApplied[i] = shouldApply;
 						ApplyUnapplyExtensionServer(extensionManager, shouldApply, server);

src/AddIns/DisplayBindings/WpfDesign/WpfDesign/Project/Extensions/Extension.cs

@@ -18,6 +18,7 @@
 
 using System;
 using System.Diagnostics;
+using System.Windows;
 
 namespace ICSharpCode.WpfDesign.Extensions
 {
@@ -32,5 +33,19 @@ namespace ICSharpCode.WpfDesign.Extensions
 	/// </remarks>
 	public abstract class Extension
 	{
+		public static string GetDisabledExtensions(DependencyObject obj)
+		{
+			return (string)obj.GetValue(DisabledExtensionsProperty);
+		}
+
+		public static void SetDisabledExtensions(DependencyObject obj, string value)
+		{
+			obj.SetValue(DisabledExtensionsProperty, value);
+		}
+
+		public static readonly DependencyProperty DisabledExtensionsProperty =
+			DependencyProperty.RegisterAttached("DisabledExtensions", typeof(string), typeof(Extension), new PropertyMetadata(null));
+
+		
 	}
 }

src/AddIns/DisplayBindings/WpfDesign/WpfDesign/Project/Extensions/ExtensionManager.cs

@@ -151,6 +151,9 @@ namespace ICSharpCode.WpfDesign.Extensions
 			
 			foreach (ExtensionEntry entry in GetExtensionEntries(item)) {
 				if (entry.Server == server) {
+					
+					var disabledExtensions = Extension.GetDisabledExtensions(item.View);
+					if (disabledExtensions == null || !disabledExtensions.Split(';').Contains(entry.ExtensionType.Name))
 						yield return server.CreateExtension(entry.ExtensionType, item);
 				}
 			}

src/AddIns/DisplayBindings/WpfDesign/WpfDesign/Project/Extensions/ExtensionServer.cs

@@ -74,6 +74,14 @@ namespace ICSharpCode.WpfDesign.Extensions
 		/// </summary>
 		public abstract bool ShouldApplyExtensions(DesignItem extendedItem);
 		
+		// <summary>
+		/// Set if the Extension Server should be reaplied (For multiple Selection extension Server for Example!)
+		/// </summary>
+		public virtual bool ShouldBeReApplied() 
+		{
+			return false;
+		}
+		
 		/// <summary>
 		/// Create an extension of the specified type.
 		/// Is called by the ExtensionManager.

src/AddIns/DisplayBindings/WpfDesign/WpfDesign/Project/Extensions/SelectionExtensionServer.cs

@@ -121,6 +121,11 @@ namespace ICSharpCode.WpfDesign.Extensions
 			ReapplyExtensions(this.Services.Selection.SelectedItems);
 		}
 		
+		public override bool ShouldBeReApplied()
+		{
+			return true;
+		}
+		
 		/// <summary>
 		/// Gets if the item is in the secondary selection.
 		/// </summary>

src/AddIns/DisplayBindings/WpfDesign/WpfDesign/Project/PlacementBehavior.cs

@@ -31,7 +31,7 @@ namespace ICSharpCode.WpfDesign
 		/// <summary>
 		/// Gets if the child element can be resized.
 		/// </summary>
-		bool CanPlace(ICollection<DesignItem> childItems, PlacementType type, PlacementAlignment position);
+		bool CanPlace(IEnumerable<DesignItem> childItems, PlacementType type, PlacementAlignment position);
 		
 		/// <summary>
 		/// Starts placement mode for this container.

src/AddIns/DisplayBindings/WpfDesign/WpfDesign/Project/PropertyGrid/TypeHelper.cs

@@ -102,7 +102,6 @@ namespace ICSharpCode.WpfDesign.PropertyGrid
 			}
 			else
 			{
-				var l=TypeDescriptor.GetProperties(element);
 				foreach(PropertyDescriptor p in TypeDescriptor.GetProperties(element)){
 					if (!p.IsBrowsable) continue;
 					if (p.IsReadOnly  && !typeof(ICollection).IsAssignableFrom(p.PropertyType)) continue;
@@ -119,32 +118,14 @@ namespace ICSharpCode.WpfDesign.PropertyGrid
 		/// <returns></returns>
 		public static IEnumerable<PropertyDescriptor> GetCommonAvailableProperties(IEnumerable<object> elements)
 		{
-			foreach (var pd1 in GetAvailableProperties(elements.First())) {
+			var properties = TypeDescriptor.GetProperties(elements.First()).Cast<PropertyDescriptor>();
-				bool propertyOk = true;
+			foreach (var element in elements.Skip(1))
-				foreach (var element in elements.Skip(1)) {
+			{
-					bool typeOk = false;
+				var currentProperties = TypeDescriptor.GetProperties(element).Cast<PropertyDescriptor>();
-					foreach (var pd2 in GetAvailableProperties(element)) {
+				properties = Enumerable.Intersect(properties, currentProperties);
-						if (pd1 == pd2) {
-							typeOk = true;
-							break;
 			}
 			
-						/* Check if it is attached property.*/
+			return properties;
-						if(pd1.Name.Contains(".") && pd2.Name.Contains(".")){
-							if(pd1.Name==pd2.Name){
-								typeOk=true;
-								break;
-							}
-						}
 		}
-					if (!typeOk) {
-						propertyOk = false;
-						break;
-					}
-				}
-				if (propertyOk) yield return pd1;
-			}
-		}
-		
 	}
 }