Refactoring Search and combine selection and search highlight

Author: Sébastien Geiser

RegexDialog/BracketColorizer.cs

@@ -20,7 +20,7 @@ protected override void ColorizeLine(DocumentLine line)
             {
                 if (StartOffset >= line.Offset && EndOffset <= line.Offset + line.Length)
                 {
-                    ChangeLinePart(StartOffset, EndOffset, delegate(VisualLineElement element)
+                    ChangeLinePart(StartOffset, EndOffset, delegate (VisualLineElement element)
                     {
                         element.TextRunProperties.SetBackgroundBrush(Brushes.LightGray);
                     });

RegexDialog/Converters/CustomBoolToVisibilityConverter.cs

@@ -43,7 +43,7 @@ public object Convert(object value, Type targetType, object parameter, CultureIn
             if (DesignerProperties.GetIsInDesignMode(new DependencyObject()) && InDesigner != null) return InDesigner;
             else if (value == null) return OnNullValue;
             else if (value == DependencyProperty.UnsetValue) return OnUnsetValue;
-            
+
 
             return (value is bool && (bool)value ? TrueValue : FalseValue);
         }

RegexDialog/Converters/ExpressionEvalMultiBindingConverter.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Windows.Data;
+using System.Windows.Markup;
+
+namespace RegexDialog.Converters
+{
+    /// <summary>
+    /// MultiBinding Converter that use a string mathematical or pseudo C# expression to make the conversion.
+    /// Use <c>bindings</c> as an array of object to inject bindings values in the expression (example <c>Abs(bindings[0]) + bindings[1]</c>)
+    /// </summary>
+    [ContentProperty("Expression")]
+    public class ExpressionEvalMultiBindingConverter : BaseConverter, IMultiValueConverter
+    {
+        /// <summary>
+        /// To specify a list of namespaces separated by the ; character to add as usings for the evaluator
+        /// </summary>
+        public string NamespacesToAdd { get; set; } = string.Empty;
+
+        /// <summary>
+        /// The expression to evaluate to make the conversion. Use <c>bindings</c>  as an array of object to inject bindings values in the expression. By default just <c>bindings</c>
+        /// </summary>
+        public string Expression { get; set; } = "bindings";
+
+        /// <summary>
+        /// The expression to evaluate to make the back conversion. Use <c>binding</c> to inject the binding value in the expression. By default just <c>binding</c>
+        /// Must return an array of object
+        /// </summary>
+        public string ExpressionForConvertBack { get; set; } = "binding";
+
+        /// <summary>
+        /// If <c>>= 0</c> evaluate the binding at corresponding index as an expression, if  just inject the binding in the Expression, By default : <c>-1</c>
+        /// </summary>
+        public int EvaluateBindingAtIndexAsAnExpression { get; set; } = -1;
+
+        /// <summary>
+        /// If <c>true</c> evaluate a string binding as an expression, if <c>false</c> just inject the binding in the ExpressionForConvertBack, By default : <c>false</c>
+        /// </summary>
+        public bool EvaluateBindingAsAnExpressionForConvertBack { get; set; }
+
+        /// <summary>
+        /// If <c>true</c> Evaluate function is callables in an expression. If <c>false</c> Evaluate is not callable.
+        /// By default : false for security
+        /// </summary>
+        public bool OptionEvaluateFunctionActive { get; set; }
+
+        /// <summary>
+        /// if true all evaluation are case sensitives, if false evaluations are case insensitive.
+        /// By default = true
+        /// </summary>
+        public bool OptionCaseSensitiveEvaluationActive { get; set; } = true;
+
+        /// <summary>
+        /// If <c>true</c> throw up all evaluate exceptions, if <c>false</c> just return the exception message as a string, By default <c>false</c>
+        /// </summary>
+        public bool ThrowExceptions { get; set; }
+
+        public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
+        {
+            Dictionary<string, object> variables = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
+
+            try
+            {
+                ExpressionEvaluator evaluator = new ExpressionEvaluator()
+                {
+                    OptionCaseSensitiveEvaluationActive = OptionCaseSensitiveEvaluationActive
+                };
+
+                evaluator.Namespaces.NamespacesListForWPFConverters();
+
+                NamespacesToAdd.Split(';').ToList().ForEach(namespaceName =>
+                {
+                    if (!string.IsNullOrWhiteSpace(namespaceName))
+                    {
+                        evaluator.Namespaces.Add(namespaceName);
+                    }
+                });
+
+                evaluator.OptionEvaluateFunctionActive = OptionEvaluateFunctionActive;
+
+                variables["bindings"] = values;
+
+                evaluator.Variables = variables;
+
+                if (EvaluateBindingAtIndexAsAnExpression >= 0)
+                {
+                    return evaluator.Evaluate(values[EvaluateBindingAtIndexAsAnExpression].ToString());
+                }
+                else
+                {
+                    return evaluator.Evaluate(Expression);
+                }
+            }
+            catch (Exception ex)
+            {
+                if (ThrowExceptions)
+                {
+                    throw;
+                }
+                else
+                {
+                    return ex.Message;
+                }
+            }
+        }
+
+        public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
+        {
+            Dictionary<string, object> variables = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
+
+            try
+            {
+                ExpressionEvaluator evaluator = new ExpressionEvaluator()
+                {
+                    OptionCaseSensitiveEvaluationActive = OptionCaseSensitiveEvaluationActive
+                };
+
+                evaluator.Namespaces.NamespacesListForWPFConverters();
+
+                evaluator.OptionEvaluateFunctionActive = OptionEvaluateFunctionActive;
+
+                if (EvaluateBindingAsAnExpressionForConvertBack)
+                {
+                    variables["binding"] = evaluator.Evaluate(value.ToString());
+                }
+                else
+                {
+                    variables["binding"] = value;
+                }
+
+                evaluator.Variables = variables;
+
+                return (object[])evaluator.Evaluate(ExpressionForConvertBack);
+            }
+            catch (Exception ex)
+            {
+                if (ThrowExceptions)
+                {
+                    throw;
+                }
+                else
+                {
+                    return new object[] { ex.Message };
+                }
+            }
+        }
+    }
+}

RegexDialog/Model/RegExOptionModel.cs

@@ -1,38 +1,36 @@
 using System;
-using System.ComponentModel;
-using System.Runtime.CompilerServices;
 using System.Text.RegularExpressions;
 
 namespace RegexDialog
 {
-    internal class RegExOptionViewModel : INotifyPropertyChanged
+    internal class RegExOptionViewModel : NotifyPropertyChangedBaseClass
     {
         /// <summary>
         /// Sélectionné
         /// </summary>
         public bool Selected
         {
-            get 
-            { 
-                return Config.Instance.RegexOptionsSelection.ContainsKey(Name) && Config.Instance.RegexOptionsSelection[Name]; 
+            get
+            {
+                return Config.Instance.RegexOptionsSelection.ContainsKey(Name) && Config.Instance.RegexOptionsSelection[Name];
             }
-            set 
+            set
             {
                 Config.Instance.RegexOptionsSelection[Name] = value;
                 Config.Instance.Save();
                 NotifyPropertyChanged();
             }
         }
 
-        private RegexOptions regexOptions = RegexOptions.None;
+        private RegexOptions regexOptions;
 
         /// <summary>
         /// L'option d'expression régulière représentée
         /// </summary>
         public RegexOptions RegexOptions
         {
             get { return regexOptions; }
-            set 
+            set
             {
                 regexOptions = value;
                 NotifyPropertyChanged();
@@ -44,26 +42,10 @@ public RegexOptions RegexOptions
         /// </summary>
         public string Name
         {
-            get 
+            get
             {
                 return Enum.GetName(typeof(RegexOptions), regexOptions);
             }
         }
-
-        #region INotifyPropertyChanged Membres
-
-        /// <summary>
-        /// Génère l'évènement PropertyChanged pour la propriété spécifiée
-        /// </summary>
-        /// <param name="propertyName"></param>
-        protected void NotifyPropertyChanged([CallerMemberName] string propertyName = "")
-        {
-            if (PropertyChanged != null)
-                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
-        }
-
-        public event PropertyChangedEventHandler PropertyChanged;
-
-        #endregion
     }
 }

RegexDialog/Model/RegexCaptureResult.cs

@@ -5,7 +5,7 @@ namespace RegexDialog
     internal class RegexCaptureResult : RegexResult
     {
         public RegexCaptureResult(Regex regex, Capture capture, int captureNb, string fileName = "", int selectionIndex = 0) : base(regex, capture, captureNb, fileName, selectionIndex)
-        {}
+        { }
 
         public override string ElementType
         {

RegexDialog/Model/RegexFileResult.cs

@@ -5,7 +5,7 @@ namespace RegexDialog
     internal class RegexFileResult : RegexResult
     {
         public RegexFileResult(Regex regex, Capture regexElement, int regexElementNb, string fileName) : base(regex, regexElement, regexElementNb, fileName, 0)
-        {}
+        { }
 
         public override string Name => $"File {RegexElementNb}: {Children.Count} matches found in \"{FileName}\"";
 

RegexDialog/Model/RegexGroupResult.cs

@@ -12,7 +12,7 @@ public RegexGroupResult(Regex regex, Group group, int groupNb, string fileName =
             Children = group.Captures
                 .Cast<Capture>()
                 .ToList()
-                .ConvertAll(delegate(Capture c)
+                .ConvertAll(delegate (Capture c)
                 {
                     RegexResult result = new RegexCaptureResult(regex, c, i, fileName, selectionIndex)
                     {

RegexDialog/Model/RegexMatchResult.cs

@@ -5,7 +5,7 @@ namespace RegexDialog
 {
     internal class RegexMatchResult : RegexResult
     {
-        public RegexMatchResult(Regex regex, Match match, int matchNb, string fileName = "", int selectionIndex = 0) : base(regex, match, matchNb, fileName, selectionIndex) 
+        public RegexMatchResult(Regex regex, Match match, int matchNb, string fileName = "", int selectionIndex = 0) : base(regex, match, matchNb, fileName, selectionIndex)
         {
             int i = 0;
 
@@ -23,8 +23,8 @@ public RegexMatchResult(Regex regex, Match match, int matchNb, string fileName =
 
                     return result;
                 });
-            
-            if(Children.Count > 0)
+
+            if (Children.Count > 0)
                 Children.RemoveAt(0);
 
             IsExpanded = Config.Instance.MatchesShowLevel > 1;