Merge pull request #72 from jogibear9988/WPFDesignerFixes

Wpf designer fixes & Extensions

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

@@ -13,6 +13,7 @@ using System.Windows.Threading;
 
 using ICSharpCode.WpfDesign.Adorners;
 using ICSharpCode.WpfDesign.Designer.Controls;
+using ICSharpCode.WpfDesign.Designer.Xaml;
 
 namespace ICSharpCode.WpfDesign.Designer
 {
@@ -35,20 +36,29 @@ namespace ICSharpCode.WpfDesign.Designer
 			}
 		}
 		
-		static void RunHitTest(Visual reference, Point point, HitTestFilterCallback filterCallback, HitTestResultCallback resultCallback)
+		void RunHitTest(Visual reference, Point point, HitTestFilterCallback filterCallback, HitTestResultCallback resultCallback)
 		{
 			VisualTreeHelper.HitTest(reference, filterCallback, resultCallback,
 			                         new PointHitTestParameters(point));
 		}
 		
-		static HitTestFilterBehavior FilterHitTestInvisibleElements(DependencyObject potentialHitTestTarget)
+		HitTestFilterBehavior FilterHitTestInvisibleElements(DependencyObject potentialHitTestTarget)
 		{
 			UIElement element = potentialHitTestTarget as UIElement;
+						
 			if (element != null) {
 				if (!(element.IsHitTestVisible && element.Visibility == Visibility.Visible)) {
 					return HitTestFilterBehavior.ContinueSkipSelfAndChildren;
 				}
+				
+				var designItem = Context.Services.Component.GetDesignItem(element) as XamlDesignItem;
+			
+				if (designItem != null && designItem.IsDesignTimeLocked) {
+					return HitTestFilterBehavior.ContinueSkipSelfAndChildren;
 			}
+			
+			}
+						
 			return HitTestFilterBehavior.Continue;
 		}
 		

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

@@ -31,7 +31,7 @@ namespace ICSharpCode.WpfDesign.Designer
 	/// </summary>
 	[TemplatePart(Name = "PART_DesignContent", Type = typeof(ContentControl))]
 	[TemplatePart(Name = "PART_Zoom", Type = typeof(ZoomControl))]
-	public class DesignSurface : ContentControl
+	public partial class DesignSurface : ContentControl
 	{
 		private FocusNavigator _focusNav;
 		
@@ -74,9 +74,20 @@ namespace ICSharpCode.WpfDesign.Designer
 			base.OnApplyTemplate();
 		}
 		
+		private bool enableBringIntoView = false;
+		
+		public void ScrollIntoView(DesignItem designItem)
+		{
+			enableBringIntoView = true;
+			LogicalTreeHelper.BringIntoView(designItem.View);
+			enableBringIntoView = false;
+		}
+
 		void _partDesignContent_RequestBringIntoView(object sender, RequestBringIntoViewEventArgs e)
 		{
+			if (!enableBringIntoView)
 				e.Handled = true;
+			enableBringIntoView = false;
 		}
 
 		protected override void OnPreviewMouseLeftButtonDown(MouseButtonEventArgs e)

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

@@ -147,6 +147,15 @@ namespace ICSharpCode.WpfDesign.Designer.Extensions
 			if (alignment.Vertical == VerticalAlignment.Bottom) dy = drag.Delta.Y;
 			
 			var designPanel = ExtendedItem.Services.DesignPanel as DesignPanel;
+			
+			if ((Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl)) && alignment.Horizontal != HorizontalAlignment.Center && alignment.Vertical != VerticalAlignment.Center)
+			{
+				if (dx > dy)
+					dx = dy;
+				else
+					dy = dx;
+			}
+			
 			if (zoom != null)
 			{
 				dx = dx * (1 / zoom.CurrentZoom);

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.Designer/Project/Images/license.txt

@@ -14,6 +14,7 @@ Copied from the Fugue Icon Library and left unmodified:
     - Icons.16x16.WpfOutline.EyeClosed.png
     - Icons.16x16.GuideSnap.png
     - Icons.16x16.GridSnap.png
+    - lock.png
 
 Copied from the Fugue Icon Library and modified or mashed up with other Fugue
 Icons or parts taken from them:

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.Designer/Project/OutlineView/DragTreeView.cs

@@ -54,10 +54,32 @@ namespace ICSharpCode.WpfDesign.Designer.OutlineView
 			set { SetValue(RootProperty, value); }
 		}
 		
-		//public object[] SelectedItems
-		//{
-		//    get { return Selection.Select(item => item.DataContext).ToArray(); }
-		//}
+		#region Filtering
+		
+		public static readonly DependencyProperty FilterProperty =
+			DependencyProperty.Register("Filter", typeof(string), typeof(DragTreeView), new PropertyMetadata(OnFilterPropertyChanged));
+
+		public string Filter {
+			get { return (string)GetValue(FilterProperty); }
+			set { SetValue(FilterProperty, value); }
+		}
+		
+		private static void OnFilterPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+		{
+			var ctl = d as DragTreeView;
+			var ev = ctl.FilterChanged;
+			if (ev != null)
+				ev(ctl.Filter);
+		}
+		
+		public event Action<string> FilterChanged;	
+		
+		public virtual bool ShouldItemBeVisible(DragTreeViewItem dragTreeViewitem)
+		{
+			return true;
+		}
+
+		#endregion
 		
 		protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
 		{
@@ -261,7 +283,7 @@ namespace ICSharpCode.WpfDesign.Designer.OutlineView
 			OnSelectionChanged();
 		}
 
-		void SelectOnly(DragTreeViewItem item)
+		protected virtual void SelectOnly(DragTreeViewItem item)
 		{
 			ClearSelection();
 			Select(item);

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.Designer/Project/OutlineView/DragTreeViewItem.cs

@@ -20,6 +20,8 @@ namespace ICSharpCode.WpfDesign.Designer.OutlineView
 {
 	public class DragTreeViewItem : TreeViewItem
 	{
+		ContentPresenter part_header;
+		
 		static DragTreeViewItem()
 		{
 			DefaultStyleKeyProperty.OverrideMetadata(typeof(DragTreeViewItem),
@@ -37,17 +39,36 @@ namespace ICSharpCode.WpfDesign.Designer.OutlineView
 			ParentTree = this.GetVisualAncestors().OfType<DragTreeView>().FirstOrDefault();
 			if (ParentTree != null) {
 				ParentTree.ItemAttached(this);
+				ParentTree.FilterChanged += ParentTree_FilterChanged;
 			}
 		}
 
+		void ParentTree_FilterChanged(string obj)
+		{
+			var v = ParentTree.ShouldItemBeVisible(this);
+			if (v)
+				part_header.Visibility = Visibility.Visible;
+			else
+				part_header.Visibility = Visibility.Collapsed;
+		}
+
 		void DragTreeViewItem_Unloaded(object sender, RoutedEventArgs e)
 		{
 			if (ParentTree != null) {
 				ParentTree.ItemDetached(this);
+				ParentTree.FilterChanged -= ParentTree_FilterChanged;
 			}
 			ParentTree = null;
 		}
 		
+		
+		public override void OnApplyTemplate()
+		{
+			base.OnApplyTemplate();
+			
+			part_header = GetTemplateChild("PART_Header") as ContentPresenter;
+		}
+
 		public new static readonly DependencyProperty IsSelectedProperty =
 			Selector.IsSelectedProperty.AddOwner(typeof(DragTreeViewItem), new FrameworkPropertyMetadata(OnIsSelectedChanged));
 

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

@@ -2,7 +2,8 @@
              x:Name="root"
              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             xmlns:Default="clr-namespace:ICSharpCode.WpfDesign.Designer.OutlineView">
+             xmlns:Default="clr-namespace:ICSharpCode.WpfDesign.Designer.OutlineView"
+             xmlns:Controls="clr-namespace:ICSharpCode.WpfDesign.Designer.Controls">
 	
 	<UserControl.Resources>
 		
@@ -34,9 +35,38 @@
 			</Setter>
 		</Style>
 		
+		<Style TargetType="ToggleButton" x:Key="lockedStyle">
+			<Setter Property="Template">
+				<Setter.Value>
+					<ControlTemplate TargetType="ToggleButton">
+						<Grid Background="Transparent" IsHitTestVisible="True">
+							<VisualStateManager.VisualStateGroups>
+								<VisualStateGroup x:Name="CheckStates">
+									<VisualState x:Name="Checked">
+										<Storyboard>
+											<ObjectAnimationUsingKeyFrames BeginTime="00:00:00" Storyboard.TargetName="locked" Storyboard.TargetProperty="(UIElement.Visibility)">
+												<DiscreteObjectKeyFrame KeyTime="00:00:00" Value="{x:Static Visibility.Visible}"/>
+											</ObjectAnimationUsingKeyFrames>
+											<ObjectAnimationUsingKeyFrames BeginTime="00:00:00" Storyboard.TargetName="unlocked" Storyboard.TargetProperty="(UIElement.Visibility)">
+												<DiscreteObjectKeyFrame KeyTime="00:00:00" Value="{x:Static Visibility.Collapsed}"/>
+											</ObjectAnimationUsingKeyFrames>
+										</Storyboard>
+									</VisualState>
+									<VisualState x:Name="Unchecked"/>
+								</VisualStateGroup>
+							</VisualStateManager.VisualStateGroups>
+							<Image Width="16" Height="16" x:Name="locked" Stretch="Uniform" Visibility="Hidden" Source="pack://application:,,,/ICSharpCode.WpfDesign.Designer;component/Images/lock.png" />
+							<Ellipse x:Name="unlocked" Width="6" Height="6" Stroke="Black" StrokeThickness="1" />
+						</Grid>
+					</ControlTemplate>
+				</Setter.Value>
+			</Setter>
+		</Style>
+		
 		<HierarchicalDataTemplate DataType="{x:Type Default:OutlineNode}"
 			ItemsSource="{Binding Children}">
 			<DockPanel>
+				<ToggleButton Style="{StaticResource lockedStyle}" DockPanel.Dock="Right" Width="20" Margin="0,0,5,0" IsChecked="{Binding IsDesignTimeLocked}" />
 				<ToggleButton Style="{StaticResource eyeStyle}" DockPanel.Dock="Right" Width="20" Margin="0,0,5,0" IsChecked="{Binding IsDesignTimeVisible}" />
 				<Default:IconItem Icon="../Images/Tag.png" Text="{Binding Name}" />
 			</DockPanel>
@@ -44,7 +74,11 @@
 	
 	</UserControl.Resources>
 	
-	<Default:OutlineTreeView Root="{Binding Root, ElementName=root}">
+	
+	<DockPanel LastChildFill="True">
+		<Controls:ClearableTextBox DockPanel.Dock="Top" Height="20" Text="{Binding Filter, ElementName=OutlineTreeView}" />
+		
+		<Default:OutlineTreeView x:Name="OutlineTreeView" Root="{Binding Root, ElementName=root}">
 			<ItemsControl.ItemContainerStyle>
 				<Style TargetType="{x:Type Default:DragTreeViewItem}">
 					<Setter Property="IsSelected"
@@ -54,5 +88,6 @@
 				</Style>
 			</ItemsControl.ItemContainerStyle>
 		</Default:OutlineTreeView>
+	</DockPanel>
 
 </UserControl>

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.Designer/Project/OutlineView/OutlineNode.cs

@@ -2,19 +2,21 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
 using System.Linq;
 using System.Text;
-using System.ComponentModel;
-using ICSharpCode.WpfDesign;
-using System.Collections.ObjectModel;
-using System.Collections;
-using ICSharpCode.WpfDesign.Designer;
-using ICSharpCode.WpfDesign.XamlDom;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Input;
 
+using ICSharpCode.WpfDesign;
+using ICSharpCode.WpfDesign.Designer;
+using ICSharpCode.WpfDesign.Designer.Xaml;
+using ICSharpCode.WpfDesign.XamlDom;
+
 namespace ICSharpCode.WpfDesign.Designer.OutlineView
 {
 	public class OutlineNode : INotifyPropertyChanged
@@ -50,6 +52,11 @@ namespace ICSharpCode.WpfDesign.Designer.OutlineView
 				((FrameworkElement) this.DesignItem.Component).Visibility = Visibility.Hidden;
 			}
 
+			var locked = designItem.Properties.GetAttachedProperty(DesignTimeProperties.IsLockedProperty).ValueOnInstance;
+			if (locked != null && (bool) locked == true) {
+				this._isDesignTimeLocked = true;
+			}
+			
 			//TODO
 			DesignItem.NameChanged += new EventHandler(DesignItem_NameChanged);
 			DesignItem.PropertyChanged += new PropertyChangedEventHandler(DesignItem_PropertyChanged);
@@ -90,7 +97,6 @@ namespace ICSharpCode.WpfDesign.Designer.OutlineView
 			}
 		}
 		
-		
 		bool _isDesignTimeVisible = true;
 
 		public bool IsDesignTimeVisible
@@ -112,6 +118,26 @@ namespace ICSharpCode.WpfDesign.Designer.OutlineView
 			}
 		}
 
+		bool _isDesignTimeLocked = false;
+		
+		public bool IsDesignTimeLocked
+		{
+			get {
+				return _isDesignTimeLocked;
+			}
+			set {
+				_isDesignTimeLocked = value;
+				((XamlDesignItem)DesignItem).IsDesignTimeLocked = _isDesignTimeLocked;
+				
+				RaisePropertyChanged("IsDesignTimeLocked");
+
+//				if (value)
+//					DesignItem.Properties.GetAttachedProperty(DesignTimeProperties.IsLockedProperty).SetValue(true);
+//				else
+//					DesignItem.Properties.GetAttachedProperty(DesignTimeProperties.IsLockedProperty).Reset();
+			}
+		}
+		
 		ObservableCollection<OutlineNode> children = new ObservableCollection<OutlineNode>();
 
 		public ObservableCollection<OutlineNode> Children  {
@@ -168,6 +194,21 @@ namespace ICSharpCode.WpfDesign.Designer.OutlineView
 					var node = OutlineNode.Create(item);
 					Children.Add(node);
 				}
+				else
+				{
+					var content = item.ContentProperty;
+					if (content != null)
+					{
+						if (content.IsCollection) {
+							UpdateChildrenCore(content.CollectionElements);
+						}
+						else {
+							if (content.Value != null) {
+								UpdateChildrenCore(new[] { content.Value });
+							}
+						}
+					}
+				}
 			}
 		}
 

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.Designer/Project/OutlineView/OutlineTreeView.cs

@@ -33,5 +33,23 @@ namespace ICSharpCode.WpfDesign.Designer.OutlineView
 			foreach (var item in items)
 				_customOutlineNodes.Add(item.DataContext as OutlineNode);
 		}
+		
+		public override bool ShouldItemBeVisible(DragTreeViewItem dragTreeViewitem)
+		{
+			var node = dragTreeViewitem.DataContext as OutlineNode;
+			
+			return string.IsNullOrEmpty(Filter) || node.Name.ToLower().Contains(Filter.ToLower());
+		}
+		
+		protected override void SelectOnly(DragTreeViewItem item)
+		{
+			base.SelectOnly(item);
+			
+			var node = item.DataContext as OutlineNode;
+			
+			var surface = node.DesignItem.View.TryFindParent<DesignSurface>();
+			if (surface != null)
+				surface.ScrollIntoView(node.DesignItem);
+		}
 	}
 }

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

@@ -98,20 +98,20 @@
 				<ControlTemplate TargetType="{x:Type Default:DragTreeViewItem}">
 					
 					<DockPanel Background="White">
-						<DockPanel x:Name="bg"
+						<Grid x:Name="bg"
+						           Margin="{TemplateBinding Level, Converter={StaticResource LevelConverter}}"
 						           DockPanel.Dock="Top"
 						           Background="{TemplateBinding Background}">
-							<ToggleButton x:Name="expandButton"
+							<ToggleButton HorizontalAlignment="Left" x:Name="expandButton"
 							              Style="{StaticResource ExpandButtonStyle}"
-							              DockPanel.Dock="Left"
-							              Margin="{TemplateBinding Level, Converter={StaticResource LevelConverter}}"
 							              IsChecked="{Binding IsExpanded, RelativeSource={RelativeSource TemplatedParent}}" />
 							<Border x:Name="contentBorder"
+							        Margin="11,0,0,0"
 							        HorizontalAlignment="Stretch">
 								<ContentPresenter x:Name="PART_Header"
 									ContentSource="Header" />
 							</Border>
-						</DockPanel>
+						</Grid>
 						<ItemsPresenter x:Name="itemsHost" />
 					<DockPanel.ContextMenu>
 					<ContextMenu>
@@ -144,7 +144,7 @@
 						         Value="False">
 							<Setter TargetName="expandButton"
 							        Property="Visibility"
-							        Value="Hidden" />
+							        Value="Collapsed" />
 						</Trigger>
 						<Trigger Property="IsSelected"
 						         Value="True">

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

@@ -361,4 +361,7 @@
     <Resource Include="Images\Icons.16x16.GuideSnap.png" />
     <Resource Include="Images\Icons.16x16.GridSnap.png" />
   </ItemGroup>
+  <ItemGroup>
+    <Resource Include="Images\lock.png" />
+  </ItemGroup>
 </Project>

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

@@ -145,6 +145,23 @@ namespace ICSharpCode.WpfDesign.Designer.Xaml
 			}
 		}
 		
+		/// <summary>
+		/// Item is Locked at Design Time
+		/// </summary>
+		public bool IsDesignTimeLocked { 
+			get {
+				var locked = Properties.GetAttachedProperty(DesignTimeProperties.IsLockedProperty).ValueOnInstance;
+				return (locked != null && (bool) locked == true);
+			}
+			set {
+				if (value)
+					Properties.GetAttachedProperty(DesignTimeProperties.IsLockedProperty).SetValue(true);
+				else
+					Properties.GetAttachedProperty(DesignTimeProperties.IsLockedProperty).Reset();
+			}
+				
+		}
+		
 		public override DesignItem Clone()
 		{
 			DesignItem item = null;

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

@@ -112,5 +112,22 @@ namespace ICSharpCode.WpfDesign.XamlDom
 			DependencyProperty.RegisterAttached("DesignHeight", typeof(double), typeof(DesignTimeProperties));
 		
 		#endregion
+		
+		#region LayoutRounding
+
+		public static bool GetLayoutRounding(DependencyObject obj)
+		{
+			return (bool)obj.GetValue(DesignHeightProperty);
+		}
+
+		public static void SetLayoutRounding(DependencyObject obj, bool value)
+		{
+			obj.SetValue(DesignHeightProperty, value);
+		}
+
+		public static readonly DependencyProperty DesignLayoutRounding =
+			DependencyProperty.RegisterAttached("LayoutRounding", typeof(bool), typeof(DesignTimeProperties));
+		
+		#endregion
 	}
 }

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

@@ -469,6 +469,8 @@ namespace ICSharpCode.WpfDesign.XamlDom
 				return FindAttachedProperty(typeof(DesignTimeProperties), attribute.LocalName);
 			} else if (attribute.LocalName == "IsHidden" && attribute.NamespaceURI == XamlConstants.DesignTimeNamespace) {
 				return FindAttachedProperty(typeof(DesignTimeProperties), attribute.LocalName);
+			} else if (attribute.LocalName == "IsLocked" && attribute.NamespaceURI == XamlConstants.DesignTimeNamespace) {
+				return FindAttachedProperty(typeof(DesignTimeProperties), attribute.LocalName);
 			}
 
 			return null;