init

Common/DTS.Common/Behaviors/InteractivityTemplate.cs

@@ -0,0 +1,61 @@
+using System.Collections.Generic;
+using System.Windows;
+using TriggerBase = Microsoft.Xaml.Behaviors.TriggerBase;
+using Microsoft.Xaml.Behaviors;
+
+namespace DTS.Common.Behaviors
+{
+    public class InteractivityTemplate : DataTemplate
+    {
+
+    }
+    /// <summary>
+    /// Holder for interactivity entries
+    /// </summary>
+    public class InteractivityItems : FrameworkElement
+    {
+        private List<Behavior> _behaviors;
+        private List<TriggerBase> _triggers;
+
+        /// <summary>
+        /// Storage for triggers
+        /// </summary>
+        public new List<TriggerBase> Triggers => _triggers ?? (_triggers = new List<TriggerBase>());
+
+        /// <summary>
+        /// Storage for Behaviors
+        /// </summary>
+        public List<Behavior> Behaviors => _behaviors ?? (_behaviors = new List<Behavior>());
+
+        #region Template attached property
+
+        public static InteractivityTemplate GetTemplate(DependencyObject obj)
+        {
+            return (InteractivityTemplate)obj.GetValue(TemplateProperty);
+        }
+
+        public static void SetTemplate(DependencyObject obj, InteractivityTemplate value)
+        {
+            obj.SetValue(TemplateProperty, value);
+        }
+
+        public static readonly DependencyProperty TemplateProperty = DependencyProperty.RegisterAttached("Template", typeof(InteractivityTemplate), typeof(InteractivityItems), new PropertyMetadata(default(InteractivityTemplate), OnTemplateChanged));
+
+        private static void OnTemplateChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            if (e.NewValue == null) return;
+            var interactivityTemplate = (InteractivityTemplate)e.NewValue;
+            var interactivityItems = (InteractivityItems)interactivityTemplate.LoadContent();
+            var bc = Interaction.GetBehaviors(d);
+            var tc = Interaction.GetTriggers(d);
+
+            foreach (var behavior in interactivityItems.Behaviors)
+                bc.Add(behavior);
+
+            foreach (var trigger in interactivityItems.Triggers)
+                tc.Add(trigger);
+        }
+
+        #endregion
+    }
+}

Common/DTS.Common/Behaviors/MultiSelectionBehavior.cs

@@ -0,0 +1,237 @@
+using DTS.Common.Enums;
+using DTS.Common.Utilities.Logging;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+using Microsoft.Xaml.Behaviors;
+using DTS.Common.Classes;
+using DTS.Common.Interface.Sensors.SensorsList;
+using DTS.Common.Interface.TestSetups.TestSetupsList;
+namespace DTS.Common.Behaviors
+{
+    public class MultiSelectionBehavior : Behavior<ListBox>
+    {
+        protected override void OnAttached()
+        {
+            base.OnAttached();
+            if (SelectedItems != null)
+            {
+                AssociatedObject.SelectedItems.Clear();
+                foreach (var item in SelectedItems)
+                {
+                    AssociatedObject.SelectedItems.Add(item);
+                }
+            }
+        }
+
+        public IList SelectedItems
+        {
+            get => (IList)GetValue(SelectedItemsProperty);
+            set => SetValue(SelectedItemsProperty, value);
+        }
+
+        public static readonly DependencyProperty SelectedItemsProperty =
+            DependencyProperty.Register("SelectedItems", typeof(IList), typeof(MultiSelectionBehavior), new UIPropertyMetadata(null, SelectedItemsChanged));
+
+        private static void SelectedItemsChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
+        {
+            var behavior = o as MultiSelectionBehavior;
+            if (behavior == null)
+                return;
+
+
+            if (e.OldValue is INotifyCollectionChanged oldValue)
+            {
+                oldValue.CollectionChanged -= behavior.SourceCollectionChanged;
+                behavior.AssociatedObject.SelectionChanged -= behavior.ListBoxSelectionChanged;
+            }
+            if (e.NewValue is INotifyCollectionChanged newValue)
+            {
+                behavior.AssociatedObject.SelectedItems.Clear();
+                foreach (var item in (IEnumerable)newValue)
+                {
+                    behavior.AssociatedObject.SelectedItems.Add(item);
+                }
+
+                behavior.AssociatedObject.SelectionChanged += behavior.ListBoxSelectionChanged;
+                newValue.CollectionChanged += behavior.SourceCollectionChanged;
+            }
+        }
+
+        private bool _isUpdatingTarget;
+        private bool _isUpdatingSource;
+
+        private void SourceCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
+        {
+            if (_isUpdatingSource)
+                return;
+
+            try
+            {
+                _isUpdatingTarget = true;
+
+                if (e.OldItems != null)
+                {
+                    foreach (var item in e.OldItems)
+                    {
+                        AssociatedObject.SelectedItems.Remove(item);
+                    }
+                }
+
+                if (e.NewItems != null)
+                {
+                    foreach (var item in e.NewItems)
+                    {
+                        AssociatedObject.SelectedItems.Add(item);
+                    }
+                }
+
+                if (e.Action == NotifyCollectionChangedAction.Reset)
+                {
+                    AssociatedObject.SelectedItems.Clear();
+                }
+            }
+            finally
+            {
+                _isUpdatingTarget = false;
+            }
+        }
+
+        private void ListBoxSelectionChanged(object sender, SelectionChangedEventArgs e)
+        {
+            if (_isUpdatingTarget)
+                return;
+
+            var selectedItems = SelectedItems;
+            if (selectedItems == null)
+                return;
+            //this could be a bulk operation, turn off notifications if consumer is paying attention
+            SelectedItemsStatus.SetUpdating(SelectedItems, true);
+            var itemsToRemove = new List<object>();
+            try
+            {
+                _isUpdatingSource = true;
+                foreach (var item in e.RemovedItems)
+                {
+                    itemsToRemove.Add(item);
+                }
+
+                var itemsToAdd = new List<object>();
+
+                foreach (var item in e.AddedItems)
+                {
+                    if (!selectedItems.Contains(item))
+                    {
+                        itemsToAdd.Add(item);
+                    }
+                }
+                var parentType = selectedItems.GetType();
+                var type = selectedItems.GetType().GenericTypeArguments[0];
+                
+                if (parentType.IsGenericType && parentType.GetGenericTypeDefinition() == typeof(BulkObservableCollection<>)
+                    && type == typeof(IAnalogSensor)||type == typeof(ITestSetup))
+                {
+                    BulkOperations(itemsToRemove, itemsToAdd, selectedItems, type);
+                }
+                else 
+                {
+                    RemoveItems(itemsToRemove, selectedItems);
+                    AddItems(itemsToAdd, type, selectedItems); 
+                }
+            }
+            finally
+            {
+                _isUpdatingSource = false;
+            }
+        }
+        private static void BulkOperations(List<object> itemsToRemove, IList<object> itemsToAdd, IList selectedItems, Type type)
+        {
+            switch (type.Name)
+            {
+                case "IAnalogSensor":
+                    SelectedItemsStatus.SetUpdating(selectedItems, false);
+                    BulkOperationsAnalogSensor(itemsToRemove, itemsToAdd, selectedItems);
+                    break;
+                case "ITestSetup":
+                    SelectedItemsStatus.SetUpdating(selectedItems, false);
+                    BulkOperationsTestSetup(itemsToRemove, itemsToAdd, selectedItems);
+                    break;
+            }            
+        }
+        private static void BulkOperationsAnalogSensor(List<object> itemsToRemove, IList<object> itemsToAdd, IList selectedItems)
+        {
+            var collection = selectedItems as BulkObservableCollection<IAnalogSensor>;
+            var sensorsToAdd = itemsToAdd.Cast<IAnalogSensor>().ToArray();
+            var sensorsToRemove = itemsToRemove.Cast<IAnalogSensor>().ToArray();
+            RemoveItems(sensorsToRemove, collection);
+            AddItems(sensorsToAdd, collection);
+        }
+        private static void BulkOperationsTestSetup(List<object> itemsToRemove, IList<object> itemsToAdd, IList selectedItems)
+        {
+            var collection = selectedItems as BulkObservableCollection<ITestSetup>;
+            var toAdd = itemsToAdd.Cast<ITestSetup>().ToArray();
+            var toRemove = itemsToRemove.Cast<ITestSetup>().ToArray();
+            RemoveItems(toRemove, collection);
+            AddItems(toAdd, collection);
+        }
+        private static void RemoveItems(List<object> itemsToRemove, IList selectedItems)
+        {
+            if (null == itemsToRemove || null == selectedItems) { return; }
+            foreach (var item in itemsToRemove)
+            {
+                selectedItems.Remove(item);
+            }
+        }
+        private static void RemoveItems(IAnalogSensor[] itemsToRemove, BulkObservableCollection<IAnalogSensor> collection)
+        {
+            if (null == itemsToRemove || !itemsToRemove.Any()) { return; }
+            if (null == collection) { return; }
+            collection.RemoveRange(itemsToRemove);
+        }
+        private static void RemoveItems(ITestSetup[] itemsToRemove, BulkObservableCollection<ITestSetup> collection)
+        {
+            if (null == itemsToRemove || !itemsToRemove.Any()) { return; }
+            if (null == collection) { return; }
+            collection.RemoveRange(itemsToRemove);
+        }
+        private static void AddItems(ITestSetup[] itemsToAdd, BulkObservableCollection<ITestSetup> collection)
+        {
+            if (null == itemsToAdd || !itemsToAdd.Any()) { return; }
+            if (null == collection) { return; }
+            collection.AddRange(itemsToAdd);
+        }
+        private static void AddItems(IAnalogSensor[] itemsToAdd, BulkObservableCollection<IAnalogSensor> collection)
+        {
+            if (null == itemsToAdd || !itemsToAdd.Any()) { return; }
+            if (null == collection) { return; }
+            collection.AddRange(itemsToAdd);
+        }
+        private void AddItems(List<object> itemsToAdd, Type type, IList selectedItems)
+        {
+            foreach (var item in itemsToAdd)
+            {
+                if (item == itemsToAdd[itemsToAdd.Count-1])
+                {
+                    //if this is the last item, turn notifications back on
+                    SelectedItemsStatus.SetUpdating(SelectedItems, false);
+                }
+
+                try
+                {
+                    if (type.IsInstanceOfType(item))
+                    {
+                        selectedItems.Add(item);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    APILogger.Log(ex);
+                }
+            }
+        }
+    }
+}

Common/DTS.Common/Behaviors/StringMetaDataAttr.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DTS.Common.Behaviors
+{
+    /// <summary>
+    /// generic attribute to store string meta data on an object or enum
+    /// </summary>
+    public class StringMetaDataAttr : Attribute
+    {
+        public string MetaData { get; }
+
+        internal StringMetaDataAttr(string attr)
+        {
+            MetaData = attr;
+        }
+
+        public static string GetStringMetaData(object o)
+        {
+            var mi = o?.GetType().GetMember(o.ToString());
+            if (null == mi || 0 == mi.Length) { return null; }
+            if (GetCustomAttribute(mi[0], typeof(StringMetaDataAttr)) is StringMetaDataAttr attr)
+            {
+                return attr.MetaData;
+            }
+
+            return null;
+        }
+    }
+}

Common/DTS.Common/Behaviors/TextBoxPasteBehavior.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using DTS.Common.Controls;
+using DTS.Common.Events;
+using Prism.Ioc;
+using Prism.Events;
+
+namespace DTS.Common.Behaviors
+{
+    public class TextBoxPasteBehavior
+    {
+        public static readonly DependencyProperty PasteCommandProperty =
+            DependencyProperty.RegisterAttached(
+                "PasteCommand",
+                typeof(ICommand),
+                typeof(TextBoxPasteBehavior),
+                new FrameworkPropertyMetadata(PasteCommandChanged)
+            );
+
+        public static ICommand GetPasteCommand(DependencyObject target)
+        {
+            return (ICommand)target.GetValue(PasteCommandProperty);
+        }
+
+        public static void SetPasteCommand(DependencyObject target, ICommand value)
+        {
+            target.SetValue(PasteCommandProperty, value);
+        }
+
+        private static void PasteCommandChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
+            TextBox textBox = sender as TextBox;
+            if (null == textBox && sender is ChannelCodeBuilder ccb)
+            {
+                textBox = ccb.MainEditBox;
+            }
+            else if (null == textBox && sender is ChannelNameBuilder cnb)
+            {
+                textBox = cnb.MainEditBox;
+            }
+            if (null == textBox) { return; }
+            var newValue = (ICommand)e.NewValue;
+            textBox.RemoveHandler(CommandManager.ExecutedEvent, new RoutedEventHandler(CommandExecuted));
+            if (newValue != null)
+            {
+                textBox.AddHandler(CommandManager.ExecutedEvent, new RoutedEventHandler(CommandExecuted), true);
+            }
+        }
+
+        private static void CommandExecuted(object sender, RoutedEventArgs e)
+        {
+            if (!(e is ExecutedRoutedEventArgs eArgs)) { return; }
+
+            if (eArgs.Command != ApplicationCommands.Paste)
+            {
+                if (eArgs.Command is RoutedUICommand secureUICommand)
+                {
+                    if (secureUICommand.Name != "Paste") { return; }
+                }
+                else { return; }
+            }
+            TextBox textBox = sender as TextBox;
+            if (null == textBox && sender is ChannelCodeBuilder ccb)
+            {
+                textBox = ccb.MainEditBox;
+            }
+            else if (null == textBox && sender is ChannelNameBuilder cnb)
+            {
+                textBox = cnb.MainEditBox;
+            }
+
+            var command = GetPasteCommand(textBox);
+
+            try
+            {
+                var text = Clipboard.GetText();
+
+                if (command.CanExecute(null))
+                    command.Execute(textBox);
+                e.Handled = true;
+            }
+            catch (Exception ex)
+            {
+                var eventAggregator = ContainerLocator.Container.Resolve<IEventAggregator>();
+                eventAggregator.GetEvent<PageErrorEvent>().Publish(new PageErrorArg(new[] { ex.Message }, null));
+            }
+        }
+    }
+}

Common/DTS.Common/Behaviors/TrimTextBoxBehavior.cs

@@ -0,0 +1,36 @@
+using System.Windows;
+using System.Windows.Controls;
+using Microsoft.Xaml.Behaviors;
+
+namespace DTS.Common.Behaviors
+{
+
+    public class TrimTextBoxBehavior : Behavior<TextBox>
+    {
+        protected override void OnAttached()
+        {
+            base.OnAttached();
+
+            AssociatedObject.LostFocus += AssociatedObject_LostFocus;
+
+        }
+
+        private void AssociatedObject_LostFocus(object sender, RoutedEventArgs e)
+        {
+            var trim = AssociatedObject.Text.Trim();
+            if (trim != AssociatedObject.Text)
+            {
+                AssociatedObject.Text = trim;
+                AssociatedObject.GetBindingExpression(TextBox.TextProperty).UpdateSource();
+            }
+        }
+
+        protected override void OnDetaching()
+        {
+            base.OnDetaching();
+
+            AssociatedObject.LostFocus -= AssociatedObject_LostFocus;
+        }
+    }
+
+}