-Add/update documentation

-Add feature to Dialog: allow modal dialog and allow to prevent user from closing the dialog.
-refactoring

Author: BionicCode

BionicCode.Net/BionicCode.Net.Framework.Wpf.BionicCharts.Ui.Test/MainWindow.xaml

@@ -6,19 +6,25 @@
         xmlns:local="clr-namespace:BionicCode.Net.Framework.Wpf.BionicCharts.Ui.Test"
         xmlns:bionicCharts="clr-namespace:BionicCode.Controls.Net.Framework.Wpf.BionicCharts;assembly=BionicCode.Controls.Net.Framework.Wpf"
         xmlns:bionicFramework="clr-namespace:BionicCode.Utilities.Net.Framework.Wpf.Markup;assembly=BionicCode.Utilities.Net.Framework.Wpf"
+        xmlns:attachedBehaviors="clr-namespace:BionicCode.Utilities.Net.Framework.Wpf.AttachedBehaviors;assembly=BionicCode.Utilities.Net.Framework.Wpf"
         mc:Ignorable="d"
         Title="MainWindow" Height="800" Width="800">
   <Window.DataContext>
     <local:CartesianChartViewModel />
   </Window.DataContext>
   <StackPanel>
-    <ComboBox ItemsSource="{bionicFramework:Enum EnumType={x:Type local:MyEnum}}"/>
+    <TextBlock attachedBehaviors:TextControl.HighlightBackground="Chocolate" attachedBehaviors:TextControl.HighlightForeground="Cornsilk" attachedBehaviors:TextControl.IsHighlightingEnabled="True" attachedBehaviors:TextControl.Text="0123456789" >
+      <attachedBehaviors:TextControl.HighlightRanges>
+        <attachedBehaviors:HighlightRange StartIndex="2" EndIndex="8"/>
+      </attachedBehaviors:TextControl.HighlightRanges>
+    </TextBlock>
+    <ComboBox ItemsSource="{bionicFramework:Enum {x:Type local:MyEnum}}"/>
     <TextBox Text="{Binding  RelativeSource={RelativeSource AncestorType=Window}, Path=Text, UpdateSourceTrigger=PropertyChanged}"/>
     <TextBlock Text="{bionicFramework:Invert {Binding RelativeSource={RelativeSource AncestorType=Window}, Path=Text}}"/>
     <TextBlock Text="{bionicFramework:Invert 12}"/>
     <TextBlock Text="{bionicFramework:Invert {x:Static Visibility.Visible}}"/>
     <TextBlock Text="{bionicFramework:Invert True}"/>
-    <TextBlock Text="{bionicFramework:Invert 0.12}"/>
+    <TextBlock Text="{bionicFramework:Invert Value=0.12}"/>
     <TextBlock Text="{bionicFramework:Invert False}"/>
     <TextBox Text="{bionicFramework:Invert {Binding  RelativeSource={RelativeSource AncestorType=Window}, Path=Text}, Mode=TwoWay}"/>
     <TextBlock Text="{Binding RelativeSource={RelativeSource AncestorType=Window}, Path=Text}"/>

BionicCode.Net/BionicCode.Net.Framework.Wpf.BionicCharts.Ui.Test/MainWindow.xaml.cs

@@ -36,6 +36,7 @@ public partial class MainWindow : Window
     public MainWindow()
     {
       InitializeComponent();
+      this.Text = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
     }
 
     private void ButtonBase_OnClick(object sender, RoutedEventArgs e)

BionicCode.Net/BionicCode.Utilities.Net.Core.Wpf/AsyncAsyncRelayCommand.cs

@@ -12,8 +12,23 @@ namespace BionicCode.Utilities.Net.Core.Wpf
   /// <remarks><c>AsyncRelayCommand</c> implements <see cref="System.Windows.Input.ICommand" /></remarks>
   public class AsyncRelayCommand : IAsyncRelayCommand
   {
+    /// <summary>
+    /// The registered parameterless async execute delegate.
+    /// </summary>
+    /// <value>
+    /// A delegate that takes no parameter and returns a <see cref="Task"/>.</value>
     protected readonly Func<Task> ExecuteAsyncNoParam;
+    /// <summary>
+    /// The registered parameterless synchronous execute delegate.
+    /// </summary>
+    /// <value>
+    /// A delegate that takes no parameter and returns void.</value>
     protected readonly Action ExecuteNoParam;
+    /// <summary>
+    /// The registered parameterless CanExecute delegate.
+    /// </summary>
+    /// <value>
+    /// <c>true</c> if the command can execute, otherwise <c>false</c>.</value>
     protected readonly Func<bool> CanExecuteNoParam;
     private readonly Func<object, Task> executeAsync;
     private readonly Action<object> execute;
@@ -29,7 +44,7 @@ public event EventHandler CanExecuteChanged
     }
 
     /// <summary>
-    ///   Creates a new command that can always execute (<see cref="CanExecute()"/> always returns <code>true</code>).
+    ///   Creates a new command that can always execute (<see cref="CanExecute()"/> will always return <c>true</c>).
     /// </summary>
     /// <param name="execute">The awaitable execution handler.</param>
     public AsyncRelayCommand(Action<object> execute)
@@ -38,7 +53,7 @@ public AsyncRelayCommand(Action<object> execute)
     }
 
     /// <summary>
-    ///   Creates a new parameterless command that can always execute (<see cref="CanExecute()"/> always returns <code>true</code>).
+    ///   Creates a new parameterless command that can always execute (<see cref="CanExecute()"/> will always return <c>true</c>).
     /// </summary>
     /// <param name="executeNoParam">The awaitable execution handler.</param>
     public AsyncRelayCommand(Action executeNoParam)
@@ -47,7 +62,7 @@ public AsyncRelayCommand(Action executeNoParam)
     }
 
     /// <summary>
-    ///   Creates a new command that can always execute (<see cref="CanExecute()"/> always returns <code>true</code>).
+    ///   Creates a new command that can always execute (<see cref="CanExecute()"/> will always return <c>true</c>).
     /// </summary>
     /// <param name="executeAsync">The awaitable execution handler.</param>
     public AsyncRelayCommand(Func<object, Task> executeAsync)
@@ -56,7 +71,7 @@ public AsyncRelayCommand(Func<object, Task> executeAsync)
     }
 
     /// <summary>
-    ///   Creates a new parameterless asynchronous command that can always execute (<see cref="CanExecute()")/> always returns <code>true</code>).
+    ///   Creates a new parameterless asynchronous command that can always execute (<see cref="CanExecute()"/> will always return <c>true</c>).
     /// </summary>
     /// <param name="executeAsyncNoParam">The awaitable execution handler.</param>
     public AsyncRelayCommand(Func<Task> executeAsyncNoParam)
@@ -111,16 +126,15 @@ public AsyncRelayCommand(Func<object, Task> executeAsync, Predicate<object> canE
     /// <summary>
     ///   Determines whether this AsyncRelayCommand can execute.
     /// </summary>
-    /// <returns><code>true</code>code> if this command can be executed, otherwise <code>false</code>.</returns>
+    /// <returns><c>true</c> if this command can be executed, otherwise <c>false</c>.</returns>
     public bool CanExecute() => this.CanExecuteNoParam != null && this.CanExecuteNoParam() || this.canExecute != null && this.canExecute(null);
-
+    
     /// <summary>
-    ///   Executes the AsyncRelayCommand on the current command target. 
+    /// Executes the <see cref="ICommand"/> on the current command target.
     /// </summary>
-    /// <param name="parameter">
-    ///   Data used by the command. 
-    /// </param>
-    /// <remarks>If the execute delegate is asynchronous (awaitable) then the execution is asynchronous otherwise synchronous.</remarks>
+    /// <remarks> When this method is called although an asynchronous execute delegate was registered, this asynchronous delegate will be executed asynchronously, but since the <see cref="Execute()"/> does not return a <see cref="Task"/> and is declared as <c>async void</c>, the execution is not awaitable and more important exceptions from an <c>async void</c> method can’t be caught with <c>catch</c>!
+    /// <para></para>Async void methods have different error-handling semantics. When an exception is thrown out of an <c>async Task</c> or <c>async Task&lt;T&gt;</c> method, that exception is captured and placed on the <see cref="Task"/> object. With <c>async void</c> methods, there is no Task object, so any exceptions thrown out of an <c>async void</c> method will be raised directly on the SynchronizationContext that was active when the async void method started. Exceptions thrown from <c>async void</c> methods can’t be caught naturally.
+    /// <para></para>In such a scenario it is highly recommended to always call <see cref="ExecuteAsync()"/> instead.</remarks>
     public async void Execute()
     {
       if (this.executeAsync != null)
@@ -171,7 +185,7 @@ public async Task ExecuteAsync()
     /// <param name="parameter">
     ///   Data used by the command. 
     /// </param>
-    /// <returns><code>true</code>code> if this command can be executed, otherwise <code>false</code>.</returns>
+    /// <returns><c>true</c> if this command can be executed, otherwise <c>false</c>.</returns>
     public bool CanExecute(object parameter) => this.canExecute != null && this.canExecute(parameter) || this.CanExecuteNoParam != null && this.CanExecuteNoParam();
 
     /// <summary>

BionicCode.Net/BionicCode.Utilities.Net.Core.Wpf/AttachedBehaviors/HighLightRangeCollection.cs

@@ -9,7 +9,17 @@
 
 namespace BionicCode.Utilities.Net.Core.Wpf.AttachedBehaviors
 {
-  public class HighLightRangeCollection : ObservableCollection<HighlightRange>
+  /// <summary>
+  /// A collection of <see cref="HighlightRange"/> items. Can be used in XAML.
+  /// </summary>
+  /// <example>
+  /// <code>
+  /// &lt;HighlightRangeCollection&gt;
+  ///   &lt;HighlightRange StartIndex="5" EndIndex="20" /&gt;
+  /// &lt;/HighlightRangeCollection&gt;
+  /// </code>
+  /// </example>
+  public class HighlightRangeCollection : ObservableCollection<HighlightRange>
   {
 
   }

BionicCode.Net/BionicCode.Utilities.Net.Core.Wpf/AttachedBehaviors/HighlightRange.cs

@@ -1,14 +1,30 @@
 namespace BionicCode.Utilities.Net.Core.Wpf.AttachedBehaviors
 {
+  /// <summary>
+  /// Represents a text range, described by a <see cref="StartIndex"/> and <see cref="EndIndex"/>.
+  /// </summary>
   public struct HighlightRange
   {
+    /// <summary>
+    /// Creates a new instance of <see cref="HighlightRange"/>
+    /// </summary>
+    /// <param name="startIndex"></param>
+    /// <param name="endIndex"></param>
     public HighlightRange(int startIndex, int endIndex)
     {
       this.StartIndex = startIndex;
       this.EndIndex = endIndex;
     }
 
+    /// <summary>
+    /// Holds the starting index of the text range.
+    /// </summary>
+    /// <value>An integer that describes the starting index of a index based text representation.</value>
     public int StartIndex { get; set; }
+    /// <summary>
+    /// Holds the end index of the text range.
+    /// </summary>
+    /// <value>An integer that describes the end index of a index based text representation.</value>
     public int EndIndex { get; set; }
   }
 }

BionicCode.Net/BionicCode.Utilities.Net.Core.Wpf/AttachedBehaviors/PasswordBox.cs

@@ -1,24 +1,44 @@
 using System;
 using System.Security;
 using System.Windows;
+using System.Windows.Controls;
 using System.Windows.Input;
 
 namespace BionicCode.Utilities.Net.Core.Wpf.AttachedBehaviors
 {
+  /// <summary>
+  /// Attached behavior for <see cref="System.Windows.Controls.PasswordBox"/> that will send the <see cref="SecureString"/> of the <see cref="System.Windows.Controls.PasswordBox.SecurePassword"/> property to a command target e.g., view model using a registered <see cref="ICommand"/> registered with the <see cref="CommandProperty"/> attached property.
+  /// </summary>
+  /// <remarks>The attached behavior does at no point unwrap the the <see cref="SecureString"/> returned from the <see cref="System.Windows.Controls.PasswordBox.SecurePassword"/> property, nor does it access the security critical <see cref="System.Windows.Controls.PasswordBox.Password"/> property. The <see cref="System.Windows.Controls.PasswordBox.SecurePassword"/> value is simply forwarded to the command target of the registered <see cref="CommandProperty"/> attached property.</remarks>
+  /// <seealso href="https://github.com/BionicCode/BionicCode.Net#passwordbox">See advanced example</seealso>
   public class PasswordBox : DependencyObject
   {
     #region Command attached property
 
+    /// <summary>
+    /// Holds the <see cref="ICommand"/> which will be invoked with the <see cref="System.Windows.Controls.PasswordBox.SecurePassword"/> of type <see cref="SecureString"/> as command parameter. 
+    /// </summary>
+    /// <value>An <see cref="ICommand"/> implementation.</value>
     public static readonly DependencyProperty CommandProperty =
       DependencyProperty.RegisterAttached(
         "Command",
         typeof(ICommand),
         typeof(PasswordBox),
         new PropertyMetadata(default(bool), PasswordBox.OnSendPasswordCommandChanged));
 
+    /// <summary>
+    /// The set method of the attached <see cref="PasswordBox"/> property.
+    /// </summary>
+    /// <param name="attachingElement">The <see cref="System.Windows.Controls.PasswordBox"/> element.</param>
+    /// <param name="value">An <see cref="ICommand"/> implementation.</param>
     public static void SetCommand(DependencyObject attachingElement, ICommand value) =>
       attachingElement.SetValue(PasswordBox.CommandProperty, value);
 
+    /// <summary>
+    /// The set method of the attached <see cref="PasswordBox"/> property.
+    /// </summary>
+    /// <param name="attachingElement">The <see cref="System.Windows.Controls.PasswordBox"/> element.</param>
+    /// <returns>The <see cref="ICommand"/> implementation registered with the <paramref name="attachingElement"/>.</returns>
     public static ICommand GetCommand(DependencyObject attachingElement) =>
       (ICommand)attachingElement.GetValue(PasswordBox.CommandProperty);
 

BionicCode.Net/BionicCode.Utilities.Net.Core.Wpf/AttachedBehaviors/Popup.cs

@@ -2,24 +2,42 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Windows;
+using System.Windows.Controls.Primitives;
 using BionicCode.Utilities.Net.Core.Wpf.Extensions;
 
 namespace BionicCode.Utilities.Net.Core.Wpf.AttachedBehaviors
 {
+  /// <summary>
+  /// Set of attached behaviors for the <see cref="System.Windows.Controls.Primitives.Popup"/> control.
+  /// </summary>
+  /// <seealso href="https://github.com/BionicCode/BionicCode.Net#popup">See advanced example</seealso>
   public class Popup : DependencyObject
   {
     #region IsFollowPlacementTargetPositionEnabled attached property
 
+    /// <summary>
+    /// When set to <c>true</c>, the <see cref="System.Windows.Controls.Primitives.Popup"/> is forced to stick to the current <see cref="System.Windows.Controls.Primitives.Popup.PlacementTarget"/>. The <see cref="System.Windows.Controls.Primitives.Popup"/> will follow the <see cref="System.Windows.Controls.Primitives.Popup.PlacementTarget"/> whenever it changes it's screen coordinates.
+    /// </summary>
     public static readonly DependencyProperty IsStickyProperty =
       DependencyProperty.RegisterAttached(
         "IsSticky",
         typeof(bool),
         typeof(Popup),
         new PropertyMetadata(default(bool), Popup.OnIsStickyChanged));
 
+    /// <summary>
+    /// The set method of the attached <see cref="IsStickyProperty"/> property.
+    /// </summary>
+    /// <param name="attachingElement">The <see cref="System.Windows.Controls.Primitives.Popup"/> element.</param>
+    /// <param name="value"><c>true</c> to enable the behavior or <c>false</c> to disable it.</param>
     public static void SetIsSticky(DependencyObject attachingElement, bool value) =>
       attachingElement.SetValue(Popup.IsStickyProperty, value);
 
+    /// <summary>
+    /// Get method of the attachecd <see cref="IsStickyProperty"/> property.
+    /// </summary>
+    /// <param name="attachingElement">The <see cref="System.Windows.Controls.Primitives.Popup"/> element.</param>
+    /// <returns><c>true</c> if the behavior is enabled or <c>false</c> if disabled.</returns>
     public static bool GetIsSticky(DependencyObject attachingElement) =>
       (bool)attachingElement.GetValue(Popup.IsStickyProperty);