Xaml Designer:

- Support IsLocked Design Time Property
  - Support Filtering in Outline View

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,28 @@ 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/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

@@ -53,12 +53,34 @@ namespace ICSharpCode.WpfDesign.Designer.OutlineView
 			get { return (object)GetValue(RootProperty); }
 			set { SetValue(RootProperty, value); }
 		}
+		
+		#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;
+		}
 
-		//public object[] SelectedItems
+		#endregion
-		//{
+		
-		//    get { return Selection.Select(item => item.DataContext).ToArray(); }
-		//}
-
 		protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
 		{
 			base.OnPropertyChanged(e);

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

@@ -20,10 +20,12 @@ namespace ICSharpCode.WpfDesign.Designer.OutlineView
 {
 	public class DragTreeViewItem : TreeViewItem
 	{
+		ContentPresenter part_header;
+		
 		static DragTreeViewItem()
 		{
 			DefaultStyleKeyProperty.OverrideMetadata(typeof(DragTreeViewItem),
-				new FrameworkPropertyMetadata(typeof(DragTreeViewItem)));
+			                                         new FrameworkPropertyMetadata(typeof(DragTreeViewItem)));
 		}
 
 		public DragTreeViewItem()
@@ -37,16 +39,35 @@ 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}">
+			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,15 +74,20 @@
 	
 	</UserControl.Resources>
 	
-	<Default:OutlineTreeView Root="{Binding Root, ElementName=root}">
+	
-		<ItemsControl.ItemContainerStyle>
+	<DockPanel LastChildFill="True">
-			<Style TargetType="{x:Type Default:DragTreeViewItem}">
+		<Controls:ClearableTextBox DockPanel.Dock="Top" Height="20" Text="{Binding Filter, ElementName=OutlineTreeView}" />
-				<Setter Property="IsSelected"
+		
-				        Value="{Binding IsSelected}" />
+		<Default:OutlineTreeView x:Name="OutlineTreeView" Root="{Binding Root, ElementName=root}">
-				<Setter Property="IsExpanded"
+			<ItemsControl.ItemContainerStyle>
-				        Value="{Binding IsExpanded, Mode=TwoWay}" />
+				<Style TargetType="{x:Type Default:DragTreeViewItem}">
-			</Style>
+					<Setter Property="IsSelected"
-		</ItemsControl.ItemContainerStyle>
+					        Value="{Binding IsSelected}" />
-	</Default:OutlineTreeView>
+					<Setter Property="IsExpanded"
+					        Value="{Binding IsExpanded, Mode=TwoWay}" />
+				</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);
@@ -87,10 +94,9 @@ namespace ICSharpCode.WpfDesign.Designer.OutlineView
 					                                       value ? SelectionTypes.Add : SelectionTypes.Remove);
 					RaisePropertyChanged("IsSelected");
 				}
-			}
+			}			
 		}
 		
-		
 		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  {

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

@@ -33,5 +33,12 @@ 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());
+		}
 	}
 }

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/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;