DataTemplateSelector in Analysis/CodeAnalysis/Src/AnalysisProjectOptionsPanelXaml.xaml

src/AddIns/Analysis/CodeAnalysis/CodeAnalysis.csproj

@@ -72,6 +72,7 @@
       <DependentUpon>AnalysisProjectOptionsPanelXaml.xaml</DependentUpon>
       <SubType>Code</SubType>
     </Compile>
+    <Compile Include="Src\AnalysisProjectOptionsTreeNodes.cs" />
     <Compile Include="Src\FxCopWrapper.cs" />
     <Compile Include="Src\FxCopRule.cs" />
     <Compile Include="Src\CheckCurrentProjectCommand.cs" />

src/AddIns/Analysis/CodeAnalysis/Src/AnalysisProjectOptionsPanelXaml.xaml

@@ -10,7 +10,41 @@
 	xmlns:core="http://icsharpcode.net/sharpdevelop/core">
 	<optionpanels:ProjectOptionPanel.Resources>
 		<local:ImageConverter x:Key="imageConverter"></local:ImageConverter>
+		
+		<DataTemplate x:Key="comboTemplate">
+			<ComboBox  Background="Transparent" Width="100"
+			          HorizontalAlignment="Center" VerticalAlignment="Center"
+			          ItemsSource="{Binding Path=RuleState}"
+			          IsReadOnly="False"
+			          SelectedIndex="{Binding Index}">
+				
+				<ComboBox.ItemTemplate>
+					<DataTemplate>
+						
+						<StackPanel Orientation="Horizontal">
+							<Image VerticalAlignment="Center" Height="15" Margin="3,0,5,0"
+							       Source="{Binding Item1,
+							Converter={StaticResource imageConverter}}"></Image>
+							<TextBlock  VerticalAlignment="Center" Text="{Binding Item2}"></TextBlock>
+						
+						</StackPanel>
+					
+					</DataTemplate>
+				</ComboBox.ItemTemplate>
+			
+			</ComboBox>
+		</DataTemplate>
+		
+		<DataTemplate x:Key="txtTemplate">
+			<TextBox Text="DDDDDDDDDDDD"></TextBox>
+		</DataTemplate>
+		
+		
+		<local:TypeSelector x:Key="TypeSelector" ComboTemplate="{StaticResource comboTemplate}"
+			TxtTemplate="{StaticResource txtTemplate}"></local:TypeSelector>
+	
 	</optionpanels:ProjectOptionPanel.Resources>
+	
 	<ScrollViewer VerticalScrollBarVisibility="Auto">
 		<Grid >
 			<Grid.RowDefinitions>
@@ -51,24 +85,36 @@
 							</GridViewColumn>
 						
 							
-							<GridViewColumn Header="Action">
+							<!--	http://finercode.net/2012/06/05/using-a-different-datatemplate-when-a-wpf-combobox-is-expanded/		-->
+							
+							<GridViewColumn Header="Action"
+							                CellTemplateSelector="{StaticResource TypeSelector}">
+							</GridViewColumn>
+						
+						</tv:SharpGridView.Columns>
+						
+						
+						<!--<GridViewColumn Header="Action" x:Name="xxx">
 								<GridViewColumn.CellTemplate>
 									<DataTemplate>
 										<ComboBox  Background="Transparent" Width="100"
 										          HorizontalAlignment="Center" VerticalAlignment="Center"
 										          ItemsSource="{Binding Path=RuleState}"
+										          IsReadOnly="False"
 										          SelectedIndex="{Binding Index}">
+											
 											<ComboBox.ItemTemplate>
 												<DataTemplate>
+													
 													<StackPanel Orientation="Horizontal">
 														<Image VerticalAlignment="Center" Height="15" Margin="3,0,5,0"
 														       Source="{Binding Item1,
 														Converter={StaticResource imageConverter}}"></Image>
 														<TextBlock  VerticalAlignment="Center" Text="{Binding Item2}"></TextBlock>
+													
 													</StackPanel>
 										
 												</DataTemplate>
-											
 											</ComboBox.ItemTemplate>
 										
 										</ComboBox>
@@ -76,7 +122,9 @@
 								</GridViewColumn.CellTemplate>
 							</GridViewColumn>
 
-						</tv:SharpGridView.Columns>
+						</tv:SharpGridView.Columns>-->
+					
+					
 					</tv:SharpGridView>
 				</ListView.View>
 			</tv:SharpTreeView>

src/AddIns/Analysis/CodeAnalysis/Src/AnalysisProjectOptionsPanelXaml.xaml.cs

@@ -44,14 +44,14 @@ namespace ICSharpCode.CodeAnalysis
 		private bool userCheck;
 		private Dictionary<string, RuleTreeNode> rules = new Dictionary<string, RuleTreeNode>();
 		
-		private List<Tuple<Icon,string>> bla = new List<Tuple<Icon,string>>();
+		private List<Tuple<Icon,string,int>> bla = new List<Tuple<Icon,string,int>>();
 		
 		public AnalysisProjectOptionsPanelXaml()
 		{
 			InitializeComponent();
 			DataContext = this;
-			bla.Add(Tuple.Create<Icon,string>(SystemIcons.Warning,"Warning"));
+			bla.Add(Tuple.Create<Icon,string,int>(SystemIcons.Warning,"Warning",0));
-			bla.Add(Tuple.Create<Icon,string>(SystemIcons.Error,"Error"));
+			bla.Add(Tuple.Create<Icon,string,int>(SystemIcons.Error,"Error",1));
 //			bla.Add(Tuple.Create<Icon,string>(null,"None"));
 		}
 		
@@ -86,12 +86,12 @@ namespace ICSharpCode.CodeAnalysis
 					ruleAssemblies = value;
 					
 					if (initSuccess) {
-						////						OnOptionChanged(EventArgs.Empty);
 						ReloadRuleList();
 					}
 				}
 			}
 		}
+		
 		#endregion
 		
 		#region Rule string Property
@@ -106,20 +106,18 @@ namespace ICSharpCode.CodeAnalysis
 							b.Append(';');
 						if ((bool)rule.IsChecked)
 							b.Append('+');
-						
 						else
 							b.Append('-');
 						if (rule.isError)
 							b.Append('!');
 						b.Append(rule.Identifier);
 					}
-					Console.WriteLine("");
-					Console.WriteLine(b.ToString());
 				}
 			}
 			return b.ToString();
 		}
 		
+		
 		void ReadRuleString()
 		{
 			userCheck = false;
@@ -150,21 +148,42 @@ namespace ICSharpCode.CodeAnalysis
 					ruleNode.isError = error;
 				}
 			}
+			userCheck = true;
+//			SetCategoryIcon();
+			SetCategoryIcon();
+		}
+
 		/*
-			foreach (SharpTreeNode cat in ruleTreeView.Root.Children) {
+		void oldSetCategoryIcon()
-				bool noneChecked = true;
+		{
-				foreach (RuleTreeNode rtn in cat.Children) {
+			foreach (CategoryTreeNode element in ruleTreeView.Root.Children) {
-					if ((bool)rtn.IsChecked) {
+				Console.WriteLine(" {0} - errorstate {1}",element.Text, element.ErrorState.ToString());
-						noneChecked = false;
+				if (element.ErrorState > -1) {
-						break;
+					element.Index = element.ErrorState;
 				}
+				Console.WriteLine("-------------------------");
 			}
-				cat.IsChecked = !noneChecked;
+			
-			} */
-			userCheck = true;
 		}
+		 */
 		
 		
+		void SetCategoryIcon() {
+			foreach (CategoryTreeNode element in ruleTreeView.Root.Children) {
+//				Console.WriteLine(" {0} ",element.Text);
+				if (!element.NewErrorState.HasValue) {
+					Console.WriteLine (" {0} is Mixed Mode",element.Text);
+				} else{
+					if (element.NewErrorState == true) {
+						Console.WriteLine (" {0} is Error",element.Text);
+						element.Index = 1;
+					} else {
+						Console.WriteLine (" {0} is Warning",element.Text);
+					}
+				}
+			}
+		}
+		
 		string ruleString = "";
 		
 		public string RuleString {
@@ -229,18 +248,16 @@ namespace ICSharpCode.CodeAnalysis
 				} else {
 					foreach (FxCopCategory cat in ruleList) {
 						CategoryTreeNode catNode = new CategoryTreeNode(cat,bla);
+						catNode.PropertyChanged += OnPropertyChanged;
 						ruleTreeView.Root.Children.Add(catNode);
 						foreach (RuleTreeNode ruleNode in catNode.Children) {
+							ruleNode.PropertyChanged += OnPropertyChanged;
 							rules[ruleNode.Identifier] = ruleNode;
 						}
 					}
-					initSuccess = true;
+					
 					ReadRuleString();
-					foreach (var element in ruleTreeView.Root.Children) {
+					initSuccess = true;
-						element.PropertyChanged += delegate {
-							base.IsDirty = true;
-						};
-					}
 				}
 			}
 		}
@@ -248,7 +265,18 @@ namespace ICSharpCode.CodeAnalysis
 		
 		private void OnPropertyChanged(object sender,System.ComponentModel.PropertyChangedEventArgs e)
 		{
+			if (initSuccess) {
 				base.IsDirty = true;
+				if (e.PropertyName == "Index") {
+					RuleTreeNode r = sender as RuleTreeNode;
+					if (r != null) {
+						var p = r.Parent;
+						if (p != null) {
+							SetCategoryIcon();
+						}
+					}
+				}
+			}
 		}
 		
 		
@@ -270,6 +298,7 @@ namespace ICSharpCode.CodeAnalysis
 			return list.ToArray();
 		}
 		
+		
 		private void ChangeRuleAssembliesButtonClick( object sender, RoutedEventArgs e)
 		{
 			var  stringListDialog = new StringListEditorDialog();
@@ -289,154 +318,31 @@ namespace ICSharpCode.CodeAnalysis
 					this.RuleAssemblies = b.ToString();
 				} finally {
 					initSuccess = oldInitSuccess;
-//					base.IsDirty = true;
 				}
 			}
 		}
 		
-	
 		#endregion
-	
-		
-		#region TreeNodes
-		
-		class BaseTree:SharpTreeNode
-		{
-			private int index;
-			
-			public BaseTree(IEnumerable<Tuple<Icon,string>> ruleState)
-			{
-				this.RuleState = ruleState;
-			}
-			
-			public IEnumerable<Tuple<Icon,string>> RuleState {get;set;}
-			
-			
-			public virtual int Index {
-				get { return index; }
-				set {
-					if (index != value) {
-						index = value;
-						switch (index) {
-							case 0:
-								break;
-							case  1:
-								break;
-							case 2:
-								break;
-							default:
-								break;
-						}
-						base.RaisePropertyChanged("Index");
-					}
-				}
-					
-			}
 	}
 	
 
-		class CategoryTreeNode : BaseTree
+	public class TypeSelector : DataTemplateSelector
 	{
-			internal FxCopCategory category;
 		
-			public CategoryTreeNode(FxCopCategory category,IEnumerable<Tuple<Icon,string>> bla):base(bla)
+		public DataTemplate ComboTemplate { get; set; }
-			{
+		public DataTemplate TxtTemplate { get; set; }
-				this.category = category;
-				foreach (FxCopRule rule in category.Rules) {
-					this.Children.Add(new RuleTreeNode(rule,bla));
-				}
-			}
-			
-			
-			public override bool IsCheckable {
-				get { return true; }
-			}
-			
-			public override object Text {
-				get { return category.DisplayName; }
-			}
-			
-			
-			internal int ErrorState {
-				get {
-					bool allWarn = true;
-					bool allErr = true;
-					foreach (RuleTreeNode tn in Children) {
-						if (tn.isError)
-							allWarn = false;
-						else
-							allErr = false;
-					}
-					if (allErr)
-						return 1;
-					else if (allWarn)
-						return 0;
-					else 
-						return -1;
-				}
-			}
-		}
-		
-		
-		class RuleTreeNode :BaseTree
-		{
-			internal FxCopRule rule;
-//			internal bool isError;
-			bool error;
-			
-			internal bool isError {
-				get { return error; }
-				set { error = value;
-					if (error) {
-						base.Index = 1;
-					}
-				}
-			}
 		
-			public RuleTreeNode(FxCopRule rule,IEnumerable<Tuple<Icon,string>> ruleState):base(ruleState)
+		public override DataTemplate SelectTemplate(object item, DependencyObject container)
 		{
-				this.rule = rule;
+//			var element = item as RuleTreeNode;
+//			if (element != null) {
+//				return ComboTemplate;
+//			} else {
+//				return TxtTemplate;
+//			}
+			return ComboTemplate;
 		}
 			
-			public override bool IsCheckable {
-				get { return true; }
-			}
-			
-			public override object Text {
-				get { return rule.CheckId + " : " + rule.DisplayName; }
-			}
-			
-			public string Identifier {
-				get {
-					return rule.CategoryName + "#" + rule.CheckId;
-				}
-			}
-			
-			public override int Index {
-				get { return base.Index; }
-				set { base.Index = value;
-					if (Index == 1) {
-						error = true;
-					}
-				}
-			}
-		}
-		
-		class MessageNode : SharpTreeNode
-		{
-			private string message;
-			
-			public MessageNode (string message)
-			{
-				this.message = message;
-			}
-			
-			public override object Text {
-				get { return message; }
-			}
-		}
-		#endregion
-		
 	}
 	
 	
@@ -467,5 +373,4 @@ namespace ICSharpCode.CodeAnalysis
 			return null;
 		}
 	}
-
 }

src/AddIns/Analysis/CodeAnalysis/Src/AnalysisProjectOptionsTreeNodes.cs

@@ -0,0 +1,199 @@
+/*
+ * Created by SharpDevelop.
+ * User: Peter Forstmeier
+ * Date: 30.06.2012
+ * Time: 20:55
+ * To change this template use Tools | Options | Coding | Edit Standard Headers.
+ */
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+
+using ICSharpCode.TreeView;
+
+namespace ICSharpCode.CodeAnalysis
+{
+	/// <summary>
+	/// Description of AnalysisProjectOptionsTreeNodes.
+	/// </summary>
+	public class BaseTree:SharpTreeNode
+	{
+		private int index;
+		
+		public BaseTree(IEnumerable<Tuple<Icon,string,int>> ruleState)
+		{
+			this.RuleState = ruleState;
+		}
+		
+		public IEnumerable<Tuple<Icon,string,int>> RuleState {get;set;}
+		
+		
+		public virtual int Index {
+			get { return index; }
+			set {
+				if (index != value) {
+					index = value;
+					switch (index) {
+						case 0:
+							break;
+						case  1:
+							break;
+						case 2:
+							break;
+						default:
+							break;
+					}
+					base.RaisePropertyChanged("Index");
+				}
+			}
+		}
+	}
+	
+	
+	public class CategoryTreeNode : BaseTree
+	{
+		internal FxCopCategory category;
+		
+		public CategoryTreeNode(FxCopCategory category,IEnumerable<Tuple<Icon,string,int>> bla):base(bla)
+		{
+			this.category = category;
+			foreach (FxCopRule rule in category.Rules) {
+				this.Children.Add(new RuleTreeNode(rule,bla));
+			}
+		}
+		
+		
+		public override bool IsCheckable {
+			get { return true; }
+		}
+		
+		public override object Text {
+			get { return category.DisplayName; }
+		}
+		
+		public override int Index {
+			get { return base.Index; }
+			set {
+				if (value != base.Index) {
+					base.Index = value;
+					foreach (RuleTreeNode rule in this.Children) {
+						rule.Index = Index;
+					}
+				}
+			}
+		}
+		
+
+		
+		public Nullable<bool> NewErrorState {
+			get {
+				bool allWarn = true;
+				bool allErr = true;
+				foreach (RuleTreeNode tn in Children) {
+					if (tn.isError)
+						allWarn = false;
+					else
+						allErr = false;
+				}
+				if (allErr)
+					return true;
+				else if (allWarn)
+					return false;
+				else
+					return null;
+
+			}
+		}
+		
+		/*
+			internal int ErrorState {
+				get {
+					bool allWarn = true;
+					bool allErr = true;
+					foreach (RuleTreeNode tn in Children) {
+						if (tn.isError)
+							allWarn = false;
+						else
+							allErr = false;
+					}
+					if (allErr)
+						return 1;
+					else if (allWarn)
+						return 0;
+					else
+						return -1;
+				}
+			}
+		 */
+	}
+	
+	
+	public class RuleTreeNode :BaseTree
+	{
+		internal FxCopRule rule;
+		bool error;
+		
+		internal bool isError {
+			get { return error; }
+			set {
+				if (error != value) {
+					error = value;
+					if (error) {
+						base.Index = 1;
+					}
+				}
+				
+			}
+		}
+		
+		public RuleTreeNode(FxCopRule rule,IEnumerable<Tuple<Icon,string,int>> ruleState):base(ruleState)
+		{
+			this.rule = rule;
+		}
+		
+		public override bool IsCheckable {
+			get { return true; }
+		}
+		
+		public override object Text {
+			get { return rule.CheckId + " : " + rule.DisplayName; }
+		}
+		
+		public string Identifier {
+			get {
+				return rule.CategoryName + "#" + rule.CheckId;
+			}
+		}
+		
+		
+		public override int Index {
+			get { return base.Index; }
+			set {
+				if (value != Index) {
+					if (Index == 1) {
+						error = true;
+					} else {
+						error = false;
+					}
+					base.Index = value;
+				}
+			}
+		}
+	}
+	
+	
+	public class MessageNode : SharpTreeNode
+	{
+		private string message;
+		
+		public MessageNode (string message)
+		{
+			this.message = message;
+		}
+		
+		public override object Text {
+			get { return message; }
+		}
+	}
+	
+}