init

Common/DTS.Common/.svn/pristine/22/224f58e53a207689cd7bf664488c723761a6cad6.svn-base

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml.Serialization;
+
+namespace DTS.Common.XMLUtils
+{
+    public class DASHardwareXMLClass
+    {
+        public string SerialNumber { get; set; }
+        public string SamplesPerSecond { get; set; }
+        public string IsClockMaster { get; set; }
+    }
+}

Common/DTS.Common/.svn/pristine/22/224ff28969d6b3c2717e326e02a19d349fc38276.svn-base

@@ -0,0 +1,40 @@
+namespace DTS.Common.Enums.Sensors.SensorsList
+{
+    public enum AnalogSensorFields
+    {
+        Included,
+        SerialNumber,
+        Description,
+        Manufacturer,
+        Model,
+        Capacity,
+        CalInterval,
+        Sensitivity,
+        LinearSensitivity,
+        Resistance,
+        Excitation,
+        Units,
+        Id,
+        CalDate,
+        CalDueDate,
+        ModifiedBy,
+        LastModified,
+        IEPE,
+        OutOfDate,
+        InWarningPeriod,
+        UsageMaximized,
+        InUsageWarningPeriod,
+        NonLinearCalucationType,
+        ZeroMethod,
+        ZeroMethodStart,
+        ZeroMethodEnd,
+        //13065 Sensor "First Use" Date
+        FirstUseDate,
+        UserValue1,
+        UserValue2,
+        UserValue3,
+        Assembly,
+        UsageCount,
+        MaximumUsage
+    }
+}

Common/DTS.Common/.svn/pristine/22/2254a00d11ed8032c4603f308018187240094c53.svn-base

@@ -0,0 +1,13 @@
+using DTS.Common.Base;
+using DTS.Common.Enums.Sensors;
+
+namespace DTS.Common.Interface.Sensors.SensorsList
+{
+    public interface ISensorsListView : IBaseView
+    {
+        void HandleColumns(CalibrationBehaviors calibrationBehavior);
+        void SetIncludedVisible(bool bUsesIncludeColumn);
+        void HandleAssemblyVisibilityColumns(bool bDontAllowDataCollectionIfOverused);
+        void HandleInspectBeforeUseVisibilityColumn(bool show);
+    }
+}

Common/DTS.Common/.svn/pristine/22/227723d815da504e3af736234acb9570ea71dbb3.svn-base

@@ -0,0 +1,269 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Media;
+using DTS.Common.Base;
+using DTS.Common.Events;
+using DTS.Common.Utilities.Logging;
+using Prism.Events;
+using Prism.Ioc;
+
+namespace DTS.Common.Controls
+{
+    /// <inheritdoc cref="IBasePropertyChanged" />
+    /// <summary>
+    /// Interaction logic for GridViewColumnHeaderSelectable.xaml
+    /// </summary>
+    public partial class GridViewColumnHeaderSearchableCheckBox : UserControl, IBasePropertyChanged
+    {
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        public bool SetProperty<T>(ref T storage, T value, string propertyName = null)
+        {
+            if (Equals(storage, value)) return false;
+
+            storage = value;
+            OnPropertyChanged(propertyName);
+            return true;
+        }
+
+        public void OnPropertyChanged(string propertyName = null)
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
+        public GridViewColumnHeaderSearchableCheckBox()
+        {
+            InitializeComponent();
+            var eventAggregator = ContainerLocator.Container.Resolve<IEventAggregator>();
+            eventAggregator.GetEvent<ListViewStatusEvent>().Subscribe(OnListviewStatusEvent, ThreadOption.UIThread);
+        }
+
+        public override string ToString()
+        {
+            return HeaderTitle;
+        }
+
+        private void OnListviewStatusEvent(ListViewStatusArg arg)
+        {
+            if (arg.Status != ListViewStatusArg.ListViewStatus.Unloaded)
+            {
+                return;
+            }
+            if (arg.Id == ListviewId)
+            {
+
+            }
+        }
+        public string ListviewId
+        {
+            get => (string)GetValue(ListviewIdProperty);
+            set => SetValue(ListviewIdProperty, value);
+        }
+
+        public static readonly DependencyProperty ListviewIdProperty =
+            DependencyProperty.Register(
+                "ListviewId",
+                typeof(string),
+                typeof(GridViewColumnHeaderSearchableCheckBox), new PropertyMetadata(""));
+
+        public string HeaderTitle
+        {
+            get => (string)GetValue(HeaderTitleProperty);
+            set => SetValue(HeaderTitleProperty, value);
+        }
+
+        // Using a DependencyProperty enables animation, styling, binding, etc.
+        public static readonly DependencyProperty HeaderTitleProperty =
+            DependencyProperty.Register(
+                "HeaderTitle", // The name of the DependencyProperty
+                typeof(string), // The type of the DependencyProperty
+                typeof(GridViewColumnHeaderSearchableCheckBox), // The type of the owner of the DependencyProperty
+                new PropertyMetadata( // OnHeaderTitleChanged will be called when HeaderTitle changes
+                    "Awesome", // The default value of the DependencyProperty
+                    OnHeaderTitleChanged
+                )
+            );
+
+        private static void OnHeaderTitleChanged(
+            DependencyObject d,
+            DependencyPropertyChangedEventArgs e
+        )
+        {
+            if (d is GridViewColumnHeaderSearchableCheckBox instance)
+            {
+                instance.HeaderTitle = (string)e.NewValue;
+            }
+        }
+
+        private bool _toggleButtonIsChecked = false;
+        /// <summary>
+        /// holds whether the toggle button is checked or not and controls whether the popup is open or not
+        /// </summary>
+        public bool ToggleButtonIsChecked
+        {
+            get => _toggleButtonIsChecked;
+            set
+            {
+                if (value == _toggleButtonIsChecked) return;
+                _toggleButtonIsChecked = value;
+                OnPropertyChanged("ToggleButtonIsChecked");
+                OnPropertyChanged("ToggleIconGeometry");
+                RaiseOpenChangedEvent(value);
+            }
+        }
+        public Geometry ToggleIconGeometry
+        {
+            get
+            {
+                if (string.IsNullOrEmpty(HeaderSearchTerm))
+                {
+                    return (Geometry)dtsGridViewColumnHeader.FindResource("DownArrowIconGeometry");
+                }
+                return (Geometry)dtsGridViewColumnHeader.FindResource("FilterIconGeometry");
+            }
+        }
+        public string HeaderSearchTerm
+        {
+            get => (string)GetValue(HeaderSearchTermProperty);
+            set => SetValue(HeaderSearchTermProperty, value);
+        }
+
+        // Using a DependencyProperty enables animation, styling, binding, etc.
+        public static readonly DependencyProperty HeaderSearchTermProperty =
+            DependencyProperty.Register(
+                "HeaderSearchTerm", // The name of the DependencyProperty
+                typeof(string), // The type of the DependencyProperty
+                typeof(GridViewColumnHeaderSearchableCheckBox), // The type of the owner of the DependencyProperty
+                new PropertyMetadata( // OnHeaderTitleChanged will be called when HeaderTitle changes
+                    "", // The default value of the DependencyProperty
+                    OnHeaderSearchTermChanged
+                )
+            );
+
+        private static void OnHeaderSearchTermChanged(
+            DependencyObject d,
+            DependencyPropertyChangedEventArgs e
+        )
+        {
+            if (!(d is GridViewColumnHeaderSearchableCheckBox instance)) return;
+            instance.HeaderSearchTerm = (string)e.NewValue;
+            instance.RaiseSearchEvent((string)e.NewValue);
+        }
+
+        // Create a custom routed event by first registering a RoutedEventID
+        // This event uses the bubbling routing strategy
+        public static readonly RoutedEvent SearchEvent = EventManager.RegisterRoutedEvent(
+            "SearchCheckBox", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(GridViewColumnHeaderSearchableCheckBox));
+
+        // Provide CLR accessors for the event
+        public event RoutedEventHandler Search
+        {
+            add => AddHandler(SearchEvent, value);
+            remove => RemoveHandler(SearchEvent, value);
+        }
+
+        // This method raises the Tap event
+        private void RaiseSearchEvent(string searchTerm)
+        {
+            var newEventArgs = new RoutedEventArgs(SearchEvent, searchTerm);
+            RaiseEvent(newEventArgs);
+            OnPropertyChanged("ToggleIconGeometry");
+        }
+        public static readonly DependencyProperty HeaderIsCheckedProperty =
+            DependencyProperty.Register(
+                "ToggleButtonIsChecked",
+                typeof(bool),
+                typeof(GridViewColumnHeaderSearchableCheckBox),
+                new PropertyMetadata(
+                    false,
+                    OnHeaderIsOpenChanged
+                )
+            );
+
+        private static void OnHeaderIsOpenChanged(
+            DependencyObject d,
+            DependencyPropertyChangedEventArgs e)
+        {
+            if (!(d is GridViewColumnHeaderSearchableCheckBox instance)) return;
+            instance.ToggleButtonIsChecked = (bool)e.NewValue;
+            var isOpen = instance.ToggleButtonIsChecked;
+            instance.RaiseOpenChangedEvent(isOpen);
+        }
+
+        // Create a custom routed event by first registering a RoutedEventID
+        // This event uses the bubbling routing strategy
+        public static readonly RoutedEvent OpenChangedEvent = EventManager.RegisterRoutedEvent(
+            "OpenChanged", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(GridViewColumnHeaderSearchableCheckBox));
+
+        // Provide CLR accessors for the event
+        public event RoutedEventHandler OpenChanged
+        {
+            add => AddHandler(OpenChangedEvent, value);
+            remove => RemoveHandler(OpenChangedEvent, value);
+        }
+
+        // This method raises the Tap event
+        private void RaiseOpenChangedEvent(bool isOpen)
+        {
+            var newEventArgs = new RoutedEventArgs(OpenChangedEvent, isOpen);
+            RaiseEvent(newEventArgs);
+        }
+
+        public static readonly RoutedEvent ClickEvent = EventManager.RegisterRoutedEvent(
+            "ClickHandler", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(GridViewColumnHeaderSearchableCheckBox));
+
+        public event RoutedEventHandler ClickHandler
+        {
+            add => AddHandler(ClickEvent, value);
+            remove => RemoveHandler(ClickEvent, value);
+        }
+
+        private void RaiseClickEvent(object tag)
+        {
+            var newEventArgs = new RoutedEventArgs(ClickEvent, tag);
+            RaiseEvent(newEventArgs);
+        }
+
+        private void PreviewLeftButtonUp(object sender, System.Windows.Input.MouseButtonEventArgs e)
+        {
+            RaiseClickEvent(Tag);
+        }
+
+        private void SelectAllButton_OnClick(object sender, RoutedEventArgs e)
+        {
+            RaiseFilterEvent(@"All");
+        }
+        private void TrueButton_OnClick(object sender, RoutedEventArgs e)
+        {
+            RaiseFilterEvent("True");
+        }
+
+        private void FalseButton_OnClick(object sender, RoutedEventArgs e)
+        {
+            RaiseFilterEvent("False");
+        }
+
+        // Create a custom routed event by first registering a RoutedEventID
+        // This event uses the bubbling routing strategy
+        public static readonly RoutedEvent FilterEvent = EventManager.RegisterRoutedEvent(
+            "Filter", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(GridViewColumnHeaderSearchableCheckBox));
+
+        // Provide CLR accessors for the event
+        public event RoutedEventHandler Filter
+        {
+            add => AddHandler(FilterEvent, value);
+            remove => RemoveHandler(FilterEvent, value);
+        }
+
+        // This method raises the Tap event
+        private void RaiseFilterEvent(string filter)
+        {
+            var newEventArgs = new RoutedEventArgs(FilterEvent, filter);
+            RaiseEvent(newEventArgs);
+            OnPropertyChanged("ToggleIconGeometry");
+        }
+    }
+}

Common/DTS.Common/.svn/pristine/22/227e235277cf79824d3d243d592ff70231750467.svn-base

@@ -0,0 +1,153 @@
+using System.ComponentModel;
+using DTS.Common.Converters;
+using DTS.Common.Enums.DASFactory;
+using DTS.Common.Utils;
+using Xceed.Wpf.Toolkit.PropertyGrid.Attributes;
+using DTS.Common.Attributes;
+
+namespace DTS.Common.Enums
+{
+    [TypeConverter(typeof(EnumDescriptionTypeConverter))]
+    public enum RecordingModes
+    {
+        [Description("RecordingModes_CircularBuffer")]
+        [ProgrammableTriggers(true, true)]
+        CircularBuffer,
+
+        [Description("RecordingModes_Recorder")]
+        [ProgrammableTriggers(false, true)]
+        Recorder,
+
+        [ProgrammableTriggers(false, true)]
+        [Description("RecordingModes_HybridRecorder")]
+        HybridRecorder,
+
+        [ProgrammableTriggers(false, false)]
+        [Description("RecordingModes_S6A_DeviceStreamingOnly")]
+        S6A_DeviceStreamingOnly,
+
+        [ProgrammableTriggers(true, true)]
+        [Description("RecordingModes_CircularBufferPlusUART")]
+        CircularBufferPlusUART,
+
+        [ProgrammableTriggers(false, true)]
+        [Description("RecordingModes_RecorderPlusUART")]
+        RecorderPlusUART,
+
+        [ProgrammableTriggers(true, true)]
+        [Description("RecordingModes_MultipleEventCircularBuffer")]
+        MultipleEventCircularBuffer,
+
+        [ProgrammableTriggers(false, true)]
+        [Description("RecordingModes_MultipleEventRecorder")]
+        MultipleEventRecorder,
+
+        [ProgrammableTriggers(false, false)]
+        [Description("RecordingModes_ContinuousRecorder")]
+        ContinuousRecorder,
+
+        [ProgrammableTriggers(false, true)]
+        [Description("RecordingModes_RecorderAndStreamSubSample")]
+        RecorderAndStreamSubSample,
+
+        [ProgrammableTriggers(true, true)]
+        [Description("RecordingModes_CircularBufferAndStreamSubSample")]
+        CircularBufferAndStreamSubSample,
+
+        [Description("RecordingModes_Active")]
+        [ProgrammableTriggers(true, true)]
+        Active,
+
+        [Description("RecordingModes_MultipleEventActive")]
+        [ProgrammableTriggers(true, true)]
+        MultipleEventActive,
+
+        [ProgrammableTriggers(false, true)]
+        [Description("RecordingModes_MultipleEventHybridRecorder")]
+        MultipleEventHybridRecorder,
+
+        [ProgrammableTriggers(false, false)]
+        [Description("RecordingModes_Streaming")]
+        Streaming,
+
+        [ProgrammableTriggers(false, true)]
+        [Description("RecordingModes_Scheduled")]
+        Scheduled,
+
+        [ProgrammableTriggers(false, true)]
+        [Description("RecordingModes_Interval")]
+        Interval,
+
+        [ProgrammableTriggers(true, true)]
+        [Description("RecordingModes_MultipleEventCircularBufferPlusUART")]
+        MultipleEventCircularBufferPlusUART,
+
+        [ProgrammableTriggers(false, true)]
+        [Description("RecordingModes_MultipleEventRecorderPlusUART")]
+        MultipleEventRecorderPlusUART,
+
+        [ProgrammableTriggers(false, false)]
+        [Description("RecordingModes_ContinuousRecorderPlusUART")]
+        ContinuousRecorderPlusUART,
+
+        [ProgrammableTriggers(true, true)]
+        [Description("RecordingModes_RAMActive")]
+        RAMActive,
+
+        [ProgrammableTriggers(true, true)]
+        [Description("RecordingModes_MultipleEventRAMActive")]
+        MultipleEventRAMActive,
+
+        [ProgrammableTriggers(false, false)]
+        [Description("RecordingModes_RecordOnBoot")]
+        RecordOnBoot,
+
+        [ProgrammableTriggers(false, false)]
+        [Description("RecordingModes_RecordOnBootPlusUART")]
+        RecordOnBootPlusUART,
+
+        [ProgrammableTriggers(false, true)]
+        [Description("RecordingModes_MultipleEventHybridAndStream")]
+        MultipleEventHybridAndStream,
+
+        [ProgrammableTriggers(false, true)]
+        [Description("RecordingModes_HybridAndStream")]
+        HybridAndStream,
+
+        [ProgrammableTriggers(true, true)]
+        [Description("RecordingModes_MultipleEventCircularBufferAndStream")]
+        MultipleEventCircularBufferAndStream,
+
+        [ProgrammableTriggers(false, true)]
+        [Description("RecordingModes_MultipleEventRecorderAndStream")]
+        MultipleEventRecorderAndStream
+
+    }
+
+    // FB15520 Restrict Recording Mode Test Setup Default selections to non-streaming
+    public class NonStreamingRecordingModeItemsSource : RecordingModeItemsSource
+    {
+        public override ItemCollection GetValues()
+        {
+            return FromModes(Constants.NonStreamingRecordingModes);
+        }
+    }
+
+    public abstract class RecordingModeItemsSource : IItemsSource
+    {
+        protected ItemCollection FromModes(RecordingModes[] modes)
+        {
+            var values = new ItemCollection();
+            foreach (var mode in modes)
+            {
+                values.Add(mode, Strings.Strings.ResourceManager.GetString(mode.GetEnumDescription()));
+            }
+            return values;
+        }
+
+        public virtual ItemCollection GetValues()
+        {
+            return FromModes(new RecordingModes[] { });
+        }
+    }
+}