Esempio n. 1
0
        public void SavePresetAs(string newPresetName)
        {
            var newPreset = new Preset
            {
                IsBuiltIn       = false,
                IsModified      = false,
                Name            = newPresetName,
                EncodingProfile = this.SelectedPreset.Preset.EncodingProfile.Clone()
            };

            var newPresetVM = new PresetViewModel(newPreset);

            this.InsertNewPreset(newPresetVM);

            if (this.SelectedPreset.Preset.IsModified)
            {
                this.RevertPreset(userInitiated: false);
            }

            this.selectedPreset = null;
            this.SelectedPreset = newPresetVM;

            this.main.StartAnimation("PresetGlowHighlight");
            this.SaveUserPresets();
        }
Esempio n. 2
0
        public async Task DeleteAsync(PresetViewModel preset)
        {
            var presetSection = (await GetAllConfigsAsync()).ToList();

            presetSection.RemoveAll(x => x.Id == preset.Id);
            await File.WriteAllTextAsync(PresetFile.ListingFilePath, JsonConvert.SerializeObject(presetSection));
        }
Esempio n. 3
0
        private void InsertNewPreset(PresetViewModel presetVM)
        {
            this.customPresetFolder.AddItem(presetVM);

            // If the Custom folder hasn't been added to the tree, add it now.
            if (!this.AllPresetsTree.Contains(this.customPresetFolder))
            {
                this.AllPresetsTree.Insert(0, this.customPresetFolder);
            }

            for (int i = 0; i < this.AllPresets.Count; i++)
            {
                if (this.AllPresets[i].Preset.IsBuiltIn)
                {
                    this.AllPresets.Insert(i, presetVM);
                    return;
                }

                if (string.Compare(presetVM.Preset.Name, this.AllPresets[i].Preset.Name, StringComparison.CurrentCultureIgnoreCase) < 0)
                {
                    this.AllPresets.Insert(i, presetVM);
                    return;
                }
            }

            Trace.Assert(true, "Did not find place to insert new preset.");
        }
Esempio n. 4
0
        public void HandleKey(KeyEventArgs args)
        {
            if (args.Key == Key.Up)
            {
                int selectedIndex = this.AllPresets.IndexOf(this.SelectedPreset);
                if (selectedIndex > 0)
                {
                    this.SelectedPreset = this.AllPresets[selectedIndex - 1];
                    this.EnsurePresetVisible(this.SelectedPreset);

                    args.Handled = true;
                }
            }
            else if (args.Key == Key.Down)
            {
                int selectedIndex = this.AllPresets.IndexOf(this.SelectedPreset);
                if (selectedIndex < this.AllPresets.Count - 1)
                {
                    this.SelectedPreset = this.AllPresets[selectedIndex + 1];
                    this.EnsurePresetVisible(this.SelectedPreset);

                    args.Handled = true;
                }
            }
        }
Esempio n. 5
0
        public ActionResult Create()
        {
            var model = new PresetViewModel {
                LedValues = ledController.GetAllLeds(), Name = "Name"
            };

            return(View(model));
        }
Esempio n. 6
0
        /// <summary>
        /// Deletes the current preset.
        /// </summary>
        public void DeletePreset()
        {
            this.AllPresets.Remove(this.SelectedPreset);
            this.selectedPreset = null;
            this.SelectedPreset = this.AllPresets[0];

            this.main.StartAnimation("PresetGlowHighlight");
            this.SaveUserPresets();
        }
Esempio n. 7
0
        public static void InitializeOkCancelDialog(PresetViewModel dialogViewModel, DialogResults buttonResult)
        {
            var dialogResult  = new NestedDialogResults <PresetViewModel>(dialogViewModel, buttonResult);
            var dialogService = Substitute.For <INestedViewDialog <PresetViewModel> >();

            dialogService.Show(Arg.Any <NestedViewModel <PresetViewModel> >()).Returns(dialogResult);

            CrudDialogProvider.AddDialog <PresetViewModel>(dialogService);
        }
Esempio n. 8
0
        public async Task UpdateAsync(PresetViewModel preset)
        {
            var presetConfig  = _mapper.Map <PresetConfig>(preset);
            var presetSection = (await GetAllConfigsAsync()).ToList();
            var presetIndex   = presetSection.FindIndex(x => x.Id == presetConfig.Id);

            presetSection[presetIndex] = presetConfig;
            await File.WriteAllTextAsync(PresetFile.ListingFilePath, JsonConvert.SerializeObject(presetSection));
        }
        public PresetsPageViewModel(IEventAggregator eventAggregator, IAsyncXmlFileManager manager, PresetViewModel preset, SavedFilesViewModel savedFiles)
        {
            this.eventAggregator  = eventAggregator;
            PresetViewModel       = preset;
            SavedPresetsViewModel = savedFiles;
            this.manager          = manager;
            IsAppBarVisible       = true;

            ActivateItem(PresetViewModel);
        }
Esempio n. 10
0
        public void DpiDisabledForVectors(FileType fileType, bool dpiEnabled)
        {
            Preset s = new Preset()
            {
                FileType = fileType
            };
            PresetViewModel svm = new PresetViewModel(s);

            Assert.AreEqual(dpiEnabled, svm.IsDpiEnabled);
        }
Esempio n. 11
0
        public void ColorSpaceDisabledForVectors(FileType fileType, bool csEnabled)
        {
            Preset s = new Preset()
            {
                FileType = fileType
            };
            PresetViewModel svm = new PresetViewModel(s);

            Assert.AreEqual(csEnabled, svm.IsColorSpaceEnabled);
        }
Esempio n. 12
0
        public void DefaultNameIsUpdatedWhenSettingsChange()
        {
            PresetViewModel svm = new PresetViewModel(new Preset());

            svm.FileType.AsEnum = FileType.Emf;
            string originalName = svm.Name;

            svm.FileType.AsEnum = FileType.Png;
            Assert.AreNotEqual(originalName, svm.Name);
        }
Esempio n. 13
0
        public ActionResult Edit(string name)
        {
            var model = new PresetViewModel
            {
                LedValues = ledController.GetPreset(name).SelectMany(x => x.Value).ToList(),
                Name      = name
            };

            return(View(nameof(Create), model));
        }
Esempio n. 14
0
 private void RemovePresetFromTree(PresetViewModel presetViewModel)
 {
     foreach (PresetFolderViewModel folder in this.AllPresetsTree)
     {
         if (this.RemovePresetFromFolder(folder, presetViewModel))
         {
             return;
         }
     }
 }
Esempio n. 15
0
        /// <summary>
        /// Deletes the current preset.
        /// </summary>
        public void DeletePreset()
        {
            PresetViewModel presetToDelete = this.SelectedPreset;

            this.RemovePresetFromTreeAndList(presetToDelete);

            this.selectedPreset = null;
            this.SelectedPreset = this.AllPresets[0];

            this.SaveUserPresets();
        }
Esempio n. 16
0
        public PresetModel EditPreset(Window owner, PresetModel preset)
        {
            var viewModel = new PresetViewModel(preset);
            var view      = new PresetView {
                Owner = owner, DataContext = viewModel
            };

            view.ShowDialog();

            return(viewModel.GetResult());
        }
Esempio n. 17
0
        public void NameIsNotUpdatedOnceEdited()
        {
            string          testName = "test name";
            PresetViewModel svm      = new PresetViewModel(new Preset());

            svm.FileType.AsEnum = FileType.Emf;
            // Simulate manually editing the settings name
            svm.Name            = testName;
            svm.FileType.AsEnum = FileType.Png;
            Assert.AreEqual(testName, svm.Name);
        }
Esempio n. 18
0
 public ActionResult Save([FromBody] PresetViewModel collection)
 {
     try
     {
         ledController.SavePreset(collection.Name, collection.LedValues);
         return(RedirectToAction(nameof(Index)));
     }
     catch
     {
         return(RedirectToAction("Error", "Home"));
     }
 }
Esempio n. 19
0
        public PresetWindow(MainViewModel pViewModel, int pChangeIndex = 0, bool pIsModified = false)
        {
            InitializeComponent();
            presetVM    = new PresetViewModel();
            DataContext = presetVM;
            presetVM.DataTable.Columns.Add("Review Qustions");
            presetVM.DataTable.Columns.Add("Coordinates");
            MultiReviewResult.ItemsSource = presetVM.DataTable.AsDataView();

            mainVM     = pViewModel;
            isModified = pIsModified;
        }
Esempio n. 20
0
        /// <summary>
        /// Deletes the current preset.
        /// </summary>
        public void DeletePreset()
        {
            this.AllPresets.Remove(this.SelectedPreset);
            this.selectedPreset = null;
            this.SelectedPreset = this.AllPresets[0];

            this.main.StartAnimation("PresetGlowHighlight");
            this.SaveUserPresets();

            this.main.RefreshChapterMarkerUI();
            Messenger.Default.Send(new RefreshPreviewMessage());
        }
Esempio n. 21
0
 public RealTimeControlModel()
 {
     StreamType                   = new CollectionViewSource();
     SelectedStreamType           = DefaultStreamType;
     VideoInfoMessage             = new VideoInfoMessageViewModel();
     PTZControl                   = new PTZControlModel();
     PresetModel                  = new PresetViewModel();
     SwitchModel                  = new SwitchPanelViewModel();
     TrackSource                  = new VideoTrackViewModel(VideoId);
     PropertyChanged             += onPropertyChanged;
     PTZControl.PropertyChanged  += PTZControl_PropertyChanged;
     TrackSource.PropertyChanged += TrackSource_PropertyChanged;
 }
Esempio n. 22
0
        public void InsertQueuePreset(PresetViewModel queuePreset)
        {
            // Bring in encoding profile and put in a placeholder preset.
            if (this.AllPresets[0].Preset.IsQueue)
            {
                this.AllPresets.RemoveAt(0);
            }

            this.AllPresets.Insert(0, queuePreset);

            this.selectedPreset = queuePreset;
            this.NotifySelectedPresetChanged();
        }
Esempio n. 23
0
        public void MovePresetToFolder(PresetViewModel presetViewModel, PresetFolderViewModel targetFolder)
        {
            PresetFolderViewModel previousFolder = this.FindFolderViewModel(presetViewModel.Preset.FolderId);

            previousFolder.RemoveItem(presetViewModel);

            targetFolder.AddItem(presetViewModel);
            presetViewModel.Preset.FolderId = targetFolder.Id;

            targetFolder.IsExpanded = true;

            this.SaveUserPresets();
        }
Esempio n. 24
0
        /// <summary>
        /// Deletes the current preset.
        /// </summary>
        public void DeletePreset()
        {
            PresetViewModel presetToDelete = this.SelectedPreset;

            this.RemovePresetFromTree(presetToDelete);
            this.AllPresets.Remove(presetToDelete);

            this.selectedPreset = null;
            this.SelectedPreset = this.AllPresets[0];

            this.main.StartAnimation("PresetGlowHighlight");
            this.SaveUserPresets();
        }
Esempio n. 25
0
        public void InsertQueuePreset(PresetViewModel queuePreset)
        {
            // Bring in encoding profile and put in a placeholder preset.

            if (this.AllPresets[0].Preset.IsQueue)
            {
                this.RemovePresetFromTreeAndList(this.AllPresets[0]);
            }

            this.InsertNewPreset(queuePreset, insertAtStart: true);

            this.selectedPreset = null;
            this.SelectedPreset = queuePreset;
        }
Esempio n. 26
0
        public void AddPreset(Preset newPreset)
        {
            var newPresetVM = new PresetViewModel(newPreset);

            this.InsertNewPreset(newPresetVM);

            // Switch to the new preset if we can do it cleanly.
            if (!this.SelectedPreset.Preset.IsModified)
            {
                this.selectedPreset = null;
                this.SelectedPreset = newPresetVM;
            }

            this.SaveUserPresets();
        }
Esempio n. 27
0
        public void AddPreset(Preset newPreset)
        {
            var newPresetVM = new PresetViewModel(newPreset);

            this.InsertNewPreset(newPresetVM);

            // Switch to the new preset if we can do it cleanly.
            if (!this.SelectedPreset.Preset.IsModified)
            {
                this.selectedPreset = null;
                this.SelectedPreset = newPresetVM;

                this.main.StartAnimation("PresetGlowHighlight");
            }

            this.SaveUserPresets();
        }
Esempio n. 28
0
        private bool RemovePresetFromFolder(PresetFolderViewModel folder, PresetViewModel presetViewModel)
        {
            if (folder.Items.Contains(presetViewModel))
            {
                folder.RemoveItem(presetViewModel);
                return(true);
            }

            foreach (var subFolder in folder.SubFolders)
            {
                if (this.RemovePresetFromFolder(subFolder, presetViewModel))
                {
                    return(true);
                }
            }

            return(false);
        }
Esempio n. 29
0
        public async Task <PresetViewModel> CreateAsync(string name, string processName)
        {
            var id        = Guid.NewGuid();
            var newPreset = new PresetViewModel()
            {
                Id          = id,
                Name        = name,
                FilePath    = $"{id}.json",
                ProcessName = processName
            };

            var presetSection = (await GetAllConfigsAsync()).ToList();

            presetSection.Add(_mapper.Map <PresetConfig>(newPreset));
            await File.WriteAllTextAsync(PresetFile.ListingFilePath, JsonConvert.SerializeObject(presetSection));

            return(newPreset);
        }
Esempio n. 30
0
        private void InsertNewPreset(PresetViewModel presetVM)
        {
            for (int i = 0; i < this.AllPresets.Count; i++)
            {
                if (this.AllPresets[i].Preset.IsBuiltIn)
                {
                    this.AllPresets.Insert(i, presetVM);
                    return;
                }

                if (string.CompareOrdinal(presetVM.Preset.Name, this.AllPresets[i].Preset.Name) < 0)
                {
                    this.AllPresets.Insert(i, presetVM);
                    return;
                }
            }

            Trace.Assert(true, "Did not find place to insert new preset.");
        }
Esempio n. 31
0
		public void SavePresetAs(string newPresetName)
		{
			var newPreset = new Preset
			{
				IsBuiltIn = false,
				IsModified = false,
				Name = newPresetName,
				EncodingProfile = this.SelectedPreset.Preset.EncodingProfile.Clone()
			};

			var newPresetVM = new PresetViewModel(newPreset);

			this.InsertNewPreset(newPresetVM);

			if (this.SelectedPreset.IsModified)
			{
				this.RevertPreset(userInitiated: false);
				this.SelectedPreset.RefreshView();
			}

			this.selectedPreset = null;
			this.SelectedPreset = newPresetVM;

			this.main.StartAnimation("PresetGlowHighlight");
			this.SaveUserPresets();
		}
Esempio n. 32
0
		private void InsertNewPreset(PresetViewModel presetVM)
		{
			for (int i = 0; i < this.AllPresets.Count; i++)
			{
				if (this.AllPresets[i].IsBuiltIn)
				{
					this.AllPresets.Insert(i, presetVM);
					return;
				}

				if (string.CompareOrdinal(presetVM.PresetName, this.AllPresets[i].PresetName) < 0)
				{
					this.AllPresets.Insert(i, presetVM);
					return;
				}
			}

			Trace.Assert(true, "Did not find place to insert new preset.");
		}
Esempio n. 33
0
		public void InsertQueuePreset(PresetViewModel queuePreset)
		{
			// Bring in encoding profile and put in a placeholder preset.
			if (this.AllPresets[0].IsQueue)
			{
				this.AllPresets.RemoveAt(0);
			}

			this.AllPresets.Insert(0, queuePreset);

			this.selectedPreset = queuePreset;
			this.NotifySelectedPresetChanged();
		}
Esempio n. 34
0
		/// <summary>
		/// Deletes the current preset.
		/// </summary>
		public void DeletePreset()
		{
			this.AllPresets.Remove(this.SelectedPreset);
			this.selectedPreset = null;
			this.SelectedPreset = this.AllPresets[0];

			this.main.StartAnimation("PresetGlowHighlight");
			this.SaveUserPresets();

			this.main.RefreshChapterMarkerUI();
			Messenger.Default.Send(new RefreshPreviewMessage());
		}
Esempio n. 35
0
		public PresetsViewModel()
		{
			this.builtInPresets = Presets.BuiltInPresets;
			List<Preset> userPresets = Presets.UserPresets;

			this.allPresets = new ObservableCollection<PresetViewModel>();
			var unmodifiedPresets = userPresets.Where(preset => !preset.IsModified);
			Preset modifiedPreset = userPresets.FirstOrDefault(preset => preset.IsModified);
			int modifiedPresetIndex = -1;

			foreach (Preset userPreset in unmodifiedPresets)
			{
				PresetViewModel presetVM;
				if (modifiedPreset != null && modifiedPreset.Name == userPreset.Name)
				{
					modifiedPresetIndex = this.allPresets.Count;
					presetVM = new PresetViewModel(modifiedPreset);
					presetVM.OriginalProfile = userPreset.EncodingProfile;
				}
				else
				{
					presetVM = new PresetViewModel(userPreset);
				}

				this.allPresets.Add(presetVM);
			}

			foreach (Preset builtInPreset in this.builtInPresets)
			{
				PresetViewModel presetVM;
				if (modifiedPreset != null && modifiedPreset.Name == builtInPreset.Name)
				{
					presetVM = new PresetViewModel(modifiedPreset);
					presetVM.OriginalProfile = builtInPreset.EncodingProfile;
				}
				else
				{
					presetVM = new PresetViewModel(builtInPreset);
				}

				this.allPresets.Add(presetVM);
			}

			// Always select the modified preset if it exists.
			// Otherwise, choose the last selected preset.
			int presetIndex;
			if (modifiedPresetIndex >= 0)
			{
				presetIndex = modifiedPresetIndex;
			}
			else
			{
				presetIndex = Config.LastPresetIndex;
			}

			if (presetIndex >= this.allPresets.Count)
			{
				presetIndex = 0;
			}

			this.SelectedPreset = this.allPresets[presetIndex];
		}
Esempio n. 36
0
		public void AddPreset(Preset newPreset)
		{
			var newPresetVM = new PresetViewModel(newPreset);

			this.InsertNewPreset(newPresetVM);

			// Switch to the new preset if we can do it cleanly.
			if (!this.SelectedPreset.IsModified)
			{
				this.selectedPreset = null;
				this.SelectedPreset = newPresetVM;

				this.main.StartAnimation("PresetGlowHighlight");
			}

			this.SaveUserPresets();
		}