示例#1
0
 public void FromFilterWheelInfo(FilterWheelInfo info)
 {
     if (info.Connected)
     {
         if (string.IsNullOrWhiteSpace(FilterWheel.Name))
         {
             FilterWheel.Name = info.Name;
         }
         FilterWheel.Filter = info.SelectedFilter?.Name ?? string.Empty;
     }
 }
示例#2
0
        public void FromFilterWheelInfoConnectedTest()
        {
            var info = new FilterWheelInfo()
            {
                Connected      = true,
                Name           = "TestFilterWheel",
                SelectedFilter = new FilterInfo {
                    Name = "Red"
                }
            };

            var sut = new ImageMetaData();

            sut.FromFilterWheelInfo(info);

            Assert.AreEqual("TestFilterWheel", sut.FilterWheel.Name);
            Assert.AreEqual("Red", sut.FilterWheel.Filter);
        }
示例#3
0
 public void UpdateDeviceInfo(FilterWheelInfo deviceInfo)
 {
     this.filterWheelInfo = deviceInfo;
 }
示例#4
0
        private async Task <bool> ChooseFW()
        {
            await ss.WaitAsync();

            try {
                await Disconnect();

                if (FilterWheelChooserVM.SelectedDevice.Id == "No_Device")
                {
                    profileService.ActiveProfile.FilterWheelSettings.Id = FilterWheelChooserVM.SelectedDevice.Id;
                    return(false);
                }

                applicationStatusMediator.StatusUpdate(
                    new ApplicationStatus()
                {
                    Source = Title,
                    Status = Locale.Loc.Instance["LblConnecting"]
                }
                    );

                var fW = (IFilterWheel)FilterWheelChooserVM.SelectedDevice;
                _cancelChooseFilterWheelSource?.Dispose();
                _cancelChooseFilterWheelSource = new CancellationTokenSource();
                if (fW != null)
                {
                    try {
                        var connected = await fW?.Connect(_cancelChooseFilterWheelSource.Token);

                        _cancelChooseFilterWheelSource.Token.ThrowIfCancellationRequested();
                        if (connected)
                        {
                            this.FW = fW;

                            FilterWheelInfo = new FilterWheelInfo {
                                Connected = true,
                                IsMoving  = false,
                                Name      = FW.Name
                            };

                            Notification.ShowSuccess(Locale.Loc.Instance["LblFilterwheelConnected"]);
                            profileService.ActiveProfile.FilterWheelSettings.Id = FW.Id;
                            if (FW.Position > -1)
                            {
                                FilterWheelInfo.SelectedFilter = FW.Filters[FW.Position];
                            }

                            // Auto import filters to profile, when profile does not have any filters set yet.
                            if (FW.Filters.Count > 0 && profileService.ActiveProfile.FilterWheelSettings.FilterWheelFilters.Count == 0)
                            {
                                var l = FW.Filters.OrderBy(x => x.Position);
                                foreach (var filter in l)
                                {
                                    profileService.ActiveProfile.FilterWheelSettings.FilterWheelFilters.Add(filter);
                                }
                            }

                            TargetFilter = FilterWheelInfo.SelectedFilter;

                            BroadcastFilterWheelInfo();

                            Logger.Info($"Successfully connected Filter Wheel. Id: {FW.Id} Name: {FW.Name} Driver Version: {FW.DriverVersion}");

                            return(true);
                        }
                        else
                        {
                            this.FW = null;
                            return(false);
                        }
                    } catch (OperationCanceledException) {
                        if (fW?.Connected == true)
                        {
                            await Disconnect();
                        }
                        return(false);
                    }
                }
                else
                {
                    return(false);
                }
            } finally {
                ss.Release();
                applicationStatusMediator.StatusUpdate(
                    new ApplicationStatus()
                {
                    Source = Title,
                    Status = string.Empty
                }
                    );
            }
        }