init

Common/DTS.CommonCore/.svn/pristine/85/85575aa16e4a5805e630ec4e4d88a995229082ec.svn-base

@@ -0,0 +1,54 @@
+using System.Collections.Specialized;
+using System.Windows;
+using System.Windows.Controls;
+using Microsoft.Practices.Prism.Regions;
+
+namespace DTS.Common
+{
+    public class ViewerStackPanelRegionAdapter : RegionAdapterBase<StackPanel>
+    {
+
+        public ViewerStackPanelRegionAdapter(IRegionBehaviorFactory regionBehaviorFactory)
+            : base(regionBehaviorFactory)
+        {
+        }
+
+        protected override void Adapt(IRegion region, StackPanel regionTarget)
+        {
+            if (region == null) return;
+
+            region.Views.CollectionChanged += (sender, e) =>
+            {
+                switch (e.Action)
+                {
+                    case NotifyCollectionChangedAction.Add:
+
+                        foreach (UIElement element in e.NewItems)
+                        {
+                            regionTarget.Children.Add(element);
+                        }
+                        break;
+
+                    case NotifyCollectionChangedAction.Remove:
+
+                        foreach (UIElement elementLoopVariable in e.OldItems)
+                        {
+                            var element = elementLoopVariable;
+
+                            if (regionTarget.Children.Contains(element))
+                            {
+                                regionTarget.Children.Remove(element);
+                            }
+                        }
+                        break;
+                }
+            };
+        }
+
+        protected override IRegion CreateRegion()
+        {
+            return new AllActiveRegion();
+        }
+    }
+
+}

Common/DTS.CommonCore/.svn/pristine/85/85b8d3b539d016845fb667b2842375241b320065.svn-base

@@ -0,0 +1,250 @@
+using System;
+using System.Linq;
+using System.Runtime.Remoting.Lifetime;
+using System.Threading.Tasks;
+using System.Windows;
+using DTS.Common.Classes;
+using DTS.Common.Events;
+using DTS.Common.Interface;
+using DTS.Common.Base;
+using Microsoft.Practices.Prism.Regions;
+using Microsoft.Practices.Prism.Events;
+using Microsoft.Practices.Unity;
+namespace DTS.Common
+{
+    public class DTSRegionManager : IDTSRegionManager
+    {
+        /// <summary>
+        /// Injected unity container
+        /// </summary>
+        private readonly IUnityContainer _unityContainer;
+
+        /// <summary>
+        /// Injected region manager
+        /// </summary>
+        private readonly IRegionManager _regionManager;
+
+        /// <summary>
+        /// Injected event aggregator
+        /// </summary>
+        private readonly IEventAggregator _eventAggregator;
+
+        /// <summary>
+        /// Creates a new instance of the <see cref="DTSRegionManager"/> class.
+        /// </summary>
+        /// <param name="unityContainer">Obtained reference of the unity container by using dependency injection.</param>
+        /// <param name="regionManager">Obtained reference of the region manager by using dependency injection.</param>
+        /// <param name="eventAggregator">Obtained reference of the event aggregator by using dependency injection.</param>
+        public DTSRegionManager(IUnityContainer unityContainer, IRegionManager regionManager, IEventAggregator eventAggregator)
+        {
+            _unityContainer = unityContainer;
+            _regionManager = regionManager;
+            _eventAggregator = eventAggregator;
+        }
+
+        /// <summary>
+        /// Adds View to the Main Region.
+        /// </summary>
+        /// <param name="viewDefinition">The View definition.</param>
+        /// <param name="parameter">The parameter which uses to initialize the View.</param>
+        public void AddView(ViewDefinition viewDefinition, object parameter)
+        {
+            AddView(viewDefinition, parameter, false);
+        }
+
+        private IShellViewModel GetShellViewModelByRegionName(string regionName)
+        {
+            IShellViewModel shellVm = null;
+
+            shellVm = _unityContainer.Resolve<IShellViewModel>();
+            //TODO: Add more stuff
+            return shellVm;
+        }
+
+        /// <summary>
+        /// Adds View to the Main Region.
+        /// </summary>
+        /// <param name="viewDefinition">The View definition.</param>
+        /// <param name="parameter">The parameter which uses to initialize the View.</param>
+        /// <param name="allowMultipleInstances">A value indicating whether to allow to create the multiple views.</param>
+        public void AddView(ViewDefinition viewDefinition, object parameter, bool allowMultipleInstances)
+        {
+            var shell = _unityContainer.Resolve<IShellViewModel>();
+
+            var viewModel = (IBaseViewModel)_unityContainer.Resolve(viewDefinition.ViewModelInterfaceType);
+            var view = (IBaseView)_unityContainer.Resolve(viewDefinition.ViewInterfaceType);
+            view.DataContext = viewModel;
+
+            _regionManager.AddViewToRegion(viewDefinition.RegionName, view);
+            _regionManager.ActivateViewIfExists(viewDefinition.RegionName, viewDefinition.ViewInterfaceType);
+
+            if (parameter == null)
+                viewModel.Initialize();
+            else
+                viewModel.Initialize(parameter);
+
+            switch (viewDefinition.RegionName)
+            {
+                case RegionNames.MainRegion:
+                    shell.ContextMainRegion = view;
+                    break;
+            }
+
+            //IShellViewModel shellVm = GetShellViewModelByRegionName(viewDefinition.RegionName);
+            //if (shellVm != null)
+            //{
+            //    shellVm.ContextMainRegion = view;
+            //}
+        }
+
+        /// <summary>
+        /// Adds View to the Main Region asynchronously.
+        /// </summary>
+        /// <param name="viewDefinition">The View definition.</param>
+        /// <param name="parameter">The parameter which uses to initialize the View.</param>
+        public async Task AddViewAsync(ViewDefinition viewDefinition, object parameter)
+        {
+            await AddViewAsync(viewDefinition, parameter, false);
+        }
+
+        /// <summary>
+        /// Adds View to the Main Region asynchronously.
+        /// </summary>
+        /// <param name="viewDefinition">The View definition.</param>
+        /// <param name="parameter">The parameter which uses to initialize the View.</param>
+        /// <param name="allowMultipleInstances">A value indicating whether to allow to create the multiple views.</param>
+        public async Task AddViewAsync(ViewDefinition viewDefinition, object parameter, bool allowMultipleInstances)
+        {
+            try
+            {
+                if (!allowMultipleInstances)
+                {
+                    if (_regionManager.ActivateViewIfExists(viewDefinition.RegionName, viewDefinition.ViewInterfaceType))
+                        return;
+                }
+
+                var viewModel = (IBaseViewModel)_unityContainer.Resolve(viewDefinition.ViewModelInterfaceType);
+                var view = (IBaseView)_unityContainer.Resolve(viewDefinition.ViewInterfaceType);
+                view.DataContext = viewModel;
+
+                _regionManager.AddViewToRegion(viewDefinition.RegionName, view);
+                _regionManager.ActivateViewIfExists(viewDefinition.RegionName, viewDefinition.ViewInterfaceType);
+
+                if (parameter == null)
+                    await viewModel.InitializeAsync();
+                else
+                    await viewModel.InitializeAsync(parameter);
+
+                var shellVm = GetShellViewModelByRegionName(viewDefinition.RegionName);
+
+                if (shellVm != null)
+                {
+                    shellVm.ContextMainRegion = view;
+                }
+            }
+            catch (Exception ex)
+            {
+                _eventAggregator.GetEvent<RaiseNotification>()
+                                .Publish(new NotificationContentEventArgs(Utility.GetAllErrorMessages(ex)));
+            }
+        }
+
+        /// <summary>
+        /// Removes View from the Main Region asynchronously.
+        /// </summary>
+        /// <param name="viewModel">The View-model.</param>
+        public void RemoveView(IBaseViewModel viewModel)
+        {
+            // Jtacc is composed of three regions(three shells)
+            foreach (var region in _regionManager.Regions)
+            {
+                var view =
+                    region.Views.FirstOrDefault(
+                        v => v is IBaseView && ReferenceEquals(((IBaseView)v).DataContext, viewModel));
+
+                if (view != null)
+                {
+                    viewModel.Cleanup();
+                    region.Deactivate(view);
+                    region.Remove(view);
+                }
+            }
+        }
+
+        public void RemoveViewByRegionName(string regionName)
+        {
+            _regionManager.ClearRegion(regionName);
+        }
+
+        /// <summary>
+        /// Reloads data for the specified View.
+        /// </summary>
+        /// <param name="interfaceForView">Type of the View's interface.</param>
+        /// <param name="parameter">The parameter which uses to initialize the View.</param>
+        public void RefreshView(Type interfaceForView, object parameter)
+        {
+            try
+            {
+                foreach (var region in _regionManager.Regions)
+                {
+                    var existingView = _regionManager.GetView(region.Name, interfaceForView) as IBaseView;
+
+                    if (existingView != null)
+                    {
+                        var viewModel = existingView.DataContext as IBaseViewModel;
+                        if (viewModel != null)
+                        {
+                            viewModel.Cleanup();
+
+                            if (parameter == null)
+                                viewModel.Initialize();
+                            else
+                                viewModel.Initialize(parameter);
+                        }
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                _eventAggregator.GetEvent<RaiseNotification>().Publish(new NotificationContentEventArgs(Utility.GetAllErrorMessages(ex)));
+            }
+        }
+
+        /// <summary>
+        /// Reloads data for the specified View asynchronously.
+        /// </summary>
+        /// <param name="interfaceForView">Type of the View's interface.</param>
+        /// <param name="parameter">The parameter which uses to initialize the View.</param>
+        public async Task RefreshViewAsync(Type interfaceForView, object parameter)
+        {
+            //TODO: fix so that it finds view in right view.
+            try
+            {
+                foreach (var region in _regionManager.Regions)
+                {
+                    var existingView =
+                        _regionManager.GetView(region.Name, interfaceForView) as IBaseView;
+                    if (existingView == null) continue;
+                    var viewModel = existingView.DataContext as IBaseViewModel;
+                    if (viewModel == null) continue;
+                    await viewModel.CleanupAsync();
+
+                    if (parameter == null)
+                        await viewModel.InitializeAsync();
+                    else
+                        await viewModel.InitializeAsync(parameter);
+                }
+            }
+            catch (Exception ex)
+            {
+                _eventAggregator.GetEvent<RaiseNotification>().Publish(new NotificationContentEventArgs(Utility.GetAllErrorMessages(ex)));
+            }
+        }
+
+        public IRegionCollection Regions { get; private set; }
+        public IRegionManager CreateRegionManager()
+        {
+            return  new RegionManager();
+        }
+    }
+}

Common/DTS.CommonCore/.svn/pristine/85/85b95484d6858f43c596e1ee757c33898a1b364f.svn-base

@@ -0,0 +1,14 @@
+using DTS.Common.Interface.GroupTemplate;
+using Microsoft.Practices.Prism.Events;
+
+namespace DTS.Common.Events.GroupTemplates.TemplateChannelList
+{
+
+    /// <summary>
+    /// The GroupTemplateListGroupTemplateSelectedEvent event.
+    /// </summary>
+    /// 
+    /// <remarks>called when a template is selected.</remarks>
+    ///
+    public class TemplateChannelListOrderChangedEvent : CompositePresentationEvent<IGroupTemplateChannel> { }
+}

Common/DTS.CommonCore/.svn/pristine/85/85dd3a4b768beecb32cef345978ef5b0f9a6a747.svn-base

@@ -0,0 +1,190 @@
+using System;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Configuration;
+using System.Globalization;
+using System.Linq;
+using DTS.Common.Classes;
+using DTS.Common.Enums;
+using DTS.Common.Events;
+using DTS.Common.Base;
+using Microsoft.Practices.Prism.Events;
+using Microsoft.Practices.Prism.Regions;
+using Microsoft.Windows.Controls.Ribbon;
+
+//https://fluent.codeplex.com/SourceControl/latest
+namespace DTS.Common.RibbonControl
+{
+    /// <summary>
+    /// Enables use of the <see cref="Microsoft.Windows.Controls.Ribbon.Ribbon"/> in a Prism <see cref="RegionNames.RibbonRegion"/>.
+    /// To install Ribbon Controls Library, run the following command in the Package Manager Console - Install-Package RibbonControlsLibrary
+    /// or install from https://www.microsoft.com/en-us/download/details.aspx?id=11877
+    /// </summary>
+    /// <remarks>
+    /// The <see cref="RibbonRegionAdapter"/> adapts controls derived from the class <see cref="Microsoft.Windows.Controls.Ribbon.Ribbon"/> such as <see cref="RibbonTab"/>.
+    /// </remarks>
+    public class RibbonRegionAdapter : RegionAdapterBase<Ribbon>, IDisposable
+    {
+        /// <summary>
+        /// Injected region manager
+        /// </summary>
+        private readonly IRegionManager _regionManager;
+
+        /// <summary>
+        /// Injected event aggregator
+        /// </summary>
+        private readonly IEventAggregator _eventAggregator;
+
+        private static readonly object Lock = new object();
+
+        /// <summary>
+        /// Creates a new instance of the <see cref="RibbonRegionAdapter"/> class.
+        /// </summary>
+        /// <param name="regionBehaviorFactory">Allows the registration of the default set of RegionBehaviors.</param>
+        /// <param name="regionManager">Obtained reference of the region manager by using dependency injection.</param>
+        /// <param name="eventAggregator">Obtained reference of the revent aggregator by using dependency injection.</param>
+        public RibbonRegionAdapter(IRegionBehaviorFactory regionBehaviorFactory, IRegionManager regionManager, IEventAggregator eventAggregator)
+            : base(regionBehaviorFactory)
+        {
+            _regionManager = regionManager;
+            _eventAggregator = eventAggregator;
+            _eventAggregator.GetEvent<TabControlSelectionChanged>().Subscribe(OnTabControlSelectionChanged);
+        }
+
+        /// <summary>
+        /// Adapts the <see cref="Microsoft.Windows.Controls.Ribbon.Ribbon"/> to an <see cref="IRegion"/>. 
+        /// </summary>
+        /// <param name="region">The new region being used.</param>
+        /// <param name="regionTarget">The object to adapt.</param>
+        protected override void Adapt(IRegion region, Ribbon regionTarget)
+        {
+            if (regionTarget == null)
+                throw new ArgumentNullException("regionTarget");
+
+            region.ActiveViews.CollectionChanged += (o, e) =>
+            {
+                switch (e.Action)
+                {
+                    case NotifyCollectionChangedAction.Add:
+                        foreach (var item in e.NewItems.OfType<RibbonTab>())
+                            AddRibbonTabToRegion(item, regionTarget);
+                        foreach (var item in e.NewItems.OfType<RibbonApplicationMenu>())
+                            AddApplicationMenuToRegion(item, regionTarget);
+
+                        break;
+                    case NotifyCollectionChangedAction.Remove:
+                        foreach (var item in e.OldItems.OfType<RibbonTab>())
+                            RemoveRibbonTabFromRibbonRegion(item, regionTarget);
+
+                        break;
+                }
+            };
+        }
+
+        private void AddRibbonTabToRegion(RibbonTab ribbonTab, Ribbon regionTarget)
+        {
+            lock (Lock)
+            {
+                if (string.IsNullOrEmpty(ribbonTab.Uid))
+                    ribbonTab.Uid = Guid.NewGuid().GetHashCode().ToString(CultureInfo.InvariantCulture);
+
+                regionTarget.Items.Add(ribbonTab);
+            }
+
+            regionTarget.Items.SortDescriptions.Add(new SortDescription("TabIndex", ListSortDirection.Ascending));
+
+            var config = ConfigurationManager.AppSettings["DefaultRibbonTab"];
+            if (!string.IsNullOrWhiteSpace(config))
+            {
+                ribbonTab.IsSelected = ribbonTab.Header.ToString().ToLower() == config.ToLower();
+            }
+        }
+
+        private void AddApplicationMenuToRegion(RibbonApplicationMenu applicationMenu, Ribbon regionTarget)
+        {
+            if (string.IsNullOrEmpty(applicationMenu.Uid))
+                applicationMenu.Uid = Guid.NewGuid().GetHashCode().ToString(CultureInfo.InvariantCulture);
+
+            regionTarget.ApplicationMenu = applicationMenu;
+        }
+
+        private void RemoveRibbonTabFromRibbonRegion(RibbonTab ribbonTab, Ribbon regionTarget)
+        {
+            regionTarget.Items.Remove(ribbonTab);
+        }
+
+        private void OnTabControlSelectionChanged(TabControlSelectionEventArgs e)
+        {
+            if (e.Operation == TabControlOperation.RemovedItem) return;
+
+            var view = e.Item as IBaseView;
+            if (view == null) return;
+            if (view.DataContext == null) return;
+
+            var ribbonTabInfo = view.DataContext as IRibbonTabInfoProvider;
+            if (ribbonTabInfo == null) return;
+            if (string.IsNullOrEmpty(ribbonTabInfo.RibbonTabUid)) return;
+
+            var currentTab = _regionManager.Regions[RegionNames.RibbonRegion].ActiveViews.OfType<RibbonTab>().FirstOrDefault(t => t.IsSelected);
+            if (currentTab == null) return;
+
+            if (ribbonTabInfo.RibbonTabUid != currentTab.Uid)
+            {
+                var selectedTab = _regionManager.Regions[RegionNames.RibbonRegion].ActiveViews.OfType<RibbonTab>().FirstOrDefault(t => t.Uid == ribbonTabInfo.RibbonTabUid);
+
+                if (selectedTab != null)
+                    selectedTab.IsSelected = true;
+            }
+        }
+
+        /// <summary>
+        /// Template method to create a new instance of <see cref="Microsoft.Practices.Prism.Regions.IRegion"/>
+        /// that will be used to adapt the object.
+        /// </summary>
+        /// <returns>
+        /// A new instance of <see cref="Microsoft.Practices.Prism.Regions.IRegion"/>.
+        /// </returns>
+        protected override IRegion CreateRegion()
+        {
+            return new AllActiveRegion();
+        }
+
+        #region IDisposable Support
+
+        private bool _disposedValue; // To detect redundant calls.
+
+        /// <summary>
+        /// Disposes the object.
+        /// </summary>
+        /// <param name="disposing">True if called by the public Dispose method.</param>
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!_disposedValue)
+            {
+                if (_eventAggregator != null)
+                    _eventAggregator.GetEvent<TabControlSelectionChanged>().Unsubscribe(OnTabControlSelectionChanged);
+            }
+            _disposedValue = true;
+        }
+
+        /// <summary>
+        /// Disposes the object.
+        /// </summary>
+        public void Dispose()
+        {
+            // Do not change this code.  Put cleanup code in Dispose(bool disposing) above.
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Object finalizer.
+        /// </summary>
+        ~RibbonRegionAdapter()
+        {
+            Dispose(false);
+        }
+
+        #endregion
+    }
+}

Common/DTS.CommonCore/.svn/pristine/85/85ff333dfb48c2e6bd155500dbb33b2c4693c485.svn-base

@@ -0,0 +1,102 @@
+using System.Collections.Generic;
+using static DTS.Common.Enums.DASFactory.DFConstantsAndEnums;
+
+namespace DTS.Common.Interface.DASFactory
+{
+    public interface IDiscoveredDevice
+    {
+        /// <summary>
+        /// Device Serial Number
+        /// </summary>
+        string Serial { get; set; }
+        MultiCastDeviceClasses DevClass { get; set; }
+        /// <summary>
+        /// Device Mac
+        /// </summary>
+        string Mac { get; set; }
+
+        IDiscoveredDevice Parent { get; set; }
+        bool IsParent(IDiscoveredDevice possibleChild);
+        int GetPort(IDiscoveredDevice device);
+        int GetSlot(IDiscoveredDevice child, Dictionary<string, IDiscoveredDevice> lookup);
+        int GetSlotOnPort(IDiscoveredDevice child, Dictionary<string, IDiscoveredDevice> lookup);
+        bool IsModule { get; set; }        
+
+        /// <summary>
+        /// if I'm on a SLICE6DB, what port am I on
+        /// </summary>
+        int Port { get; set; }
+        /// <summary>
+        /// starting at the first device in the chain on the first point, up until the last device on the last chain/port, where is this device
+        /// this is used to as we don't show SLICE6 devices when on a SLICE6Db, but we still need to know which devices is where for showing
+        /// the channels in the UI
+        /// </summary>
+        int PositionOnDistributor { get; set; }
+        /// <summary>
+        /// where is this device in a chain of devices, only used for SLICE6 on a SLICE6Db right now
+        /// </summary>
+        int PositionOnChain { get; set; }
+        /// <summary>
+        /// Is DHCP enabled
+        /// </summary>
+        bool Dhcp { get; set; }
+
+        /// <summary>
+        /// Device IP
+        /// </summary>
+        string Ip { get; set; }
+
+        /// <summary>
+        /// Device Subnet
+        /// </summary>
+        string Subnet { get; set; }
+        
+        /// <summary>
+        /// Device Gateway
+        /// </summary>
+        string Gateway { get; set; }
+        
+        /// <summary>
+        ///  Device DNS Sever
+        /// </summary>
+        string Dns { get; set; }
+
+        /// <summary>
+        ///  Is Device connected to another host
+        /// </summary>
+        bool Connected { get; set; }
+
+        /// <summary>
+        /// Host IP that device is connected to
+        /// </summary>
+        string ConnectedIp { get; set; }
+
+        /// <summary>
+        /// Host Name Resolution that device is connected to
+        /// </summary>
+        string ConnectedHost { get; set; }
+
+        /// <summary>
+        /// User entry for Distributor ID that device is connected to
+        /// </summary>
+        ushort SystemId { get; set; }
+
+        /// <summary>
+        /// User entry for location of device
+        /// </summary>
+        string Location { get; set; }
+
+        /// <summary>
+        /// Firmware version string
+        /// [Product Name]-[FW/BL]-[REL/DBG]-[Board #]-[FW Ver Name]
+        /// </summary>
+        string FirmwareVersion { get; set; }
+
+        /// <summary>
+        /// Build Server number for the firmware
+        /// </summary>
+        string BuildId { get; set; }        
+        
+        IConnectedEthernetDevice [] Connections { get; set; }
+    }
+}