ATITD-Tools/Desert-Paint-Codex Changeset

Changeset - f419334a476f

Parent rev.

Child rev.

[Not reviewed]

R_T10_1.0 default

0 6 0

Tess Snider (Malkyne) - 4 years ago 2021-07-19 15:16:24
this@malkyne.org

Improved up behavior for clipped reactions and 3-way reactions, and fixed
related bugs.

6 files changed with 77 insertions and 27 deletions:

Models/PlayerProfile.cs

Models/ReactionTest.cs

Models/ReactionTestService.cs

ViewModels/ReactionTestViewModel.cs

Views/MainWindow.axaml

Views/ReactionTestView.axaml

0 comments (0 inline, 0 general)

Models/PlayerProfile.cs

➞

Show inline comments

 using System;
 using System.IO;
 using System.IO.Compression;
 using System.Collections.Generic;
 using System.Text.RegularExpressions;
 using DesertPaintCodex.Util;
 using DesertPaintCodex.Services;
 namespace DesertPaintCodex.Models
+{
     public class PlayerProfile
+    {
         private const string PaintRecipeFile = "dp_recipes.txt";
         private const string RibbonRecipeFile = "dp_ribbons.txt";
         private readonly string _reactFile;
         private readonly string _settingsFile;
         private readonly string _clipFile;
         private static readonly Regex _recipeHeaderRegex     = new(@"^--- Recipe: (?<colorname>(\w*\s)*\w+)\s*");
         private static readonly Regex _recipeIngredientRegex = new(@"(?<ingredient>(\w+\s)?\w+)\s*\|\s*(?<quantity>\d+)\s*");
         private Settings ProfileSettings { get; } = new();
         public string Directory { get; }
         public string Name { get; private set; }
         public ReactionSet Reactions { get; } = new();
-        private Dictionary<string, Dictionary<string, ClipType>> Clippers { get; } = new();
+        public Dictionary<string, Dictionary<string, ClipType>> Clippers { get; } = new();
         public string ReagentFile { get; }
         public Dictionary<string, PaintRecipe> Recipes { get; } = new();
         public Dictionary<string, PaintRecipe> RibbonRecipes { get; } = new();
         public int RecipeCount
+        {
             get
+            {
                 int count = 0;
                 foreach (PaintRecipe recipe in Recipes.Values)
+                {
                     if (recipe.IsValidForConcentration(PaintRecipe.PaintRecipeMinConcentration))
+                    {
                         ++count;
+                    }
+                }
                 return count;
+            }
+        }
         public int RibbonCount
+        {
             get
+            {
                 int count = 0;
                 foreach (PaintRecipe recipe in RibbonRecipes.Values)
+                {
                     if (recipe.IsValidForConcentration(PaintRecipe.RibbonRecipeMinConcentration))
+                    {
                         ++count;
+                    }
+                }
                 return count;
+            }
+        }
         public PlayerProfile(string name, string directory)
+        {
             Name          = name;
             Directory     = directory;
             _reactFile    = Path.Combine(directory, "dp_reactions.txt");
             ReagentFile   = Path.Combine(directory, "ingredients.txt");
             _settingsFile = Path.Combine(directory, "settings");
             _clipFile     = Path.Combine(directory, "clips.txt");
             foreach (PaintColor color in PaletteService.Colors)
+            {
                 Recipes.Add(color.Name, new PaintRecipe());
+            }
             foreach (PaintColor color in PaletteService.Colors)
+            {
                 RibbonRecipes.Add(color.Name, new PaintRecipe());
+            }
+        }
         public bool Initialize()
+        {
             // Copy template files into new directory.
             string? templatePath = FileUtils.FindApplicationResourceDirectory("template");
             if (templatePath == null)
+            {
                 return false;
+            }
             // Create new directory.
             System.IO.Directory.CreateDirectory(Directory);
             DirectoryInfo di = new(templatePath);
             FileInfo[] templateFiles = di.GetFiles();
             foreach (FileInfo file in templateFiles)
+            {
                 string destFile = Path.Combine(Directory, file.Name);
                 File.Copy(file.FullName, destFile, true);
                 if (!File.Exists(destFile)) return false;
+            }
             return true;
+        }
         private static void WriteReaction(TextWriter writer, string reagent1, string reagent2, string r, string g, string b)
+        {
             writer.Write(reagent1);
             writer.Write(" ");
             writer.Write(reagent2);
             writer.Write(" ");
             writer.Write(r);
             writer.Write(" ");
             writer.Write(g);
             writer.Write(" ");
             writer.WriteLine(b);
+        }
         public static void ConvertFromPP(string ppFile, string dpFile)
+        {
             using StreamReader reader = new(ppFile);
             using StreamWriter writer = new(dpFile);
             string?            line;
             while ((line = reader.ReadLine()) != null)
+            {
                 string[] tokens = line.Split('|');
                 //if ((tokens.Length > 0) && (tokens [0] != "//"))
                 if ((tokens.Length != 5) && (tokens[0].Trim() != "//"))
+                {
                     string reagent1  = tokens[0].Trim();
                     string reagent2  = tokens[1].Trim();
                     string colorCode = tokens[2].Trim();
                     string change1   = tokens[3].Trim();
                     string change2   = tokens[4].Trim();
                     // Write reaction.
                     switch (colorCode)
+                    {
                         case "W":
                             WriteReaction(writer, reagent1, reagent2, change1, change1, change1);
                             WriteReaction(writer, reagent2, reagent1, change2, change2, change2);
                             break;
                         case "R":
                             WriteReaction(writer, reagent1, reagent2, change1, "0", "0");
                             WriteReaction(writer, reagent2, reagent1, change2, "0", "0");
                             break;
                         case "G":
                             WriteReaction(writer, reagent1, reagent2, "0", change1, "0");
                             WriteReaction(writer, reagent2, reagent1, "0", change2, "0");
                             break;
                         case "B":
                             WriteReaction(writer, reagent1, reagent2, "0", "0", change1);
                             WriteReaction(writer, reagent2, reagent1, "0", "0", change2);
                             break;
+                    }
+                }
+            }
+        }
         public bool SaveToPP(string ppFile)
+        {
             Reaction? reaction1, reaction2;
             using (StreamWriter writer = new(ppFile))
+            {
                 foreach (string reagentName1 in ReagentService.Names)
+                {
                     // TODO: could be more efficient by only iterating over the names after reagent1
                     foreach (string reagentName2 in ReagentService.Names)
+                    {
                         if (reagentName1.Equals(reagentName2)) continue;
                         Reagent reagent1 = ReagentService.GetReagent(reagentName1);
                         Reagent reagent2 = ReagentService.GetReagent(reagentName2);
                         reaction1 = Reactions.Find(reagent1, reagent2);
                         if (reaction1 is not {Exported: false}) continue;
                         reaction2 = Reactions.Find(reagent2, reagent1);
                         if (reaction2 == null) continue;
                         writer.Write(reagent1.PracticalPaintName + " | " + reagent2.PracticalPaintName + " | ");
                         if ((Math.Abs(reaction1.Red) > Math.Abs(reaction1.Green)) ||
                             (Math.Abs(reaction2.Red) > Math.Abs(reaction2.Green)))
+                        {
                             writer.WriteLine("R | " + reaction1.Red + " | " + reaction2.Red);
+                        }
                         else if ((Math.Abs(reaction1.Green) > Math.Abs(reaction1.Red)) ||
                             (Math.Abs(reaction2.Green) > Math.Abs(reaction2.Red)))
+                        {
                             writer.WriteLine("G | " + reaction1.Green + " | " + reaction2.Green);
+                        }
                         else if ((Math.Abs(reaction1.Blue) > Math.Abs(reaction1.Red)) ||
                             (Math.Abs(reaction2.Blue) > Math.Abs(reaction2.Red)))
+                        {
                             writer.WriteLine("B | " + reaction1.Blue + " | " + reaction2.Blue);
+                        }
                         else
+                        {
                             writer.WriteLine("W | " + reaction1.Red + " | " + reaction2.Red);
+                        }
                         reaction1.Exported = true;
                         reaction2.Exported = true;
+                    }
+                }
+            }
             // Clear Exported flags.
             foreach (string reagentName1 in ReagentService.Names)
+            {
                 // TODO: could be more efficient by only iterating over the names after reagent1
                 foreach (string reagentName2 in ReagentService.Names)
+                {
                     if (reagentName1.Equals(reagentName2))
+                    {
                         continue;
+                    }
                     Reagent reagent1 = ReagentService.GetReagent(reagentName1);
                     Reagent reagent2 = ReagentService.GetReagent(reagentName2);
                     reaction1 = Reactions.Find(reagent1, reagent2);
                     if (reaction1 != null)
+                    {
                         reaction1.Exported = false;
+                    }
                     reaction2 = Reactions.Find(reagent2, reagent1);
                     if (reaction2 != null)
+                    {
                         reaction2.Exported = false;
+                    }
+                }
+            }
             return true;
+        }
         public void ImportFromPP(string importDir)
+        {
             // Convert old file.
             ConvertFromPP(
                 Path.Combine(importDir, "reactions.txt"),
                 _reactFile);
             try
+            {
                 // If there is an ingredients file, move it in.
                 File.Copy(
                     Path.Combine(importDir, "ingredients.txt"),
                     Path.Combine(Directory, "ingredients.txt"),
                     true);
+            }
             catch (Exception)
+            {
                 // If there is no ingredients file, we don't really care.
+            }
+        }
         public void Import(string file)
+        {
             ZipFile.ExtractToDirectory(file, Directory);
+        }
         public void Export(string file)
+        {
             ZipFile.CreateFromDirectory(Directory, file);
+        }
         public bool Load()
+        {
             string? line;
             ProfileSettings.Reset();
             ProfileSettings.Load(_settingsFile);
             Reactions.Clear();
             if (File.Exists(ReagentFile))
+            {
                 ReagentService.LoadProfileReagents(ReagentFile);
+            }
             else
+            {
                 return false;
+            }
             ReagentService.InitializeReactions(Reactions);
             if (!File.Exists(_reactFile))
+            {
                 return false;
+            }
             using (StreamReader reader = new(_reactFile))
+            {
                 while ((line = reader.ReadLine()) != null)
+                {
                     string[] tokens = line.Split(' ');
                     if (tokens.Length == 5)
+                    {
                         Reagent reagent1 = ReagentService.GetReagent(tokens[0].Trim());
                         Reagent reagent2 = ReagentService.GetReagent(tokens[1].Trim());
                         Reaction reaction = new(
                             int.Parse(tokens[2].Trim()),
                             int.Parse(tokens[3].Trim()),
                             int.Parse(tokens[4].Trim())
                             );
                         Reactions.Set(reagent1, reagent2, reaction);
+                    }
+                }
+            }
             if (!File.Exists(_clipFile)) return true;
+            {
-                using StreamReader reader = new StreamReader(_clipFile);
                 using StreamReader reader = new(_clipFile);
                 while ((line = reader.ReadLine()) != null)
+                {
                     string[] tokens = line.Split(' ');
                     if (tokens.Length != 3) continue;
                     string reagent1 = tokens[0].Trim();
                     if (!Clippers.ContainsKey(reagent1))
+                    {
                         Clippers.Add(reagent1, new Dictionary<string, ClipType>());
+                    }
                     Clippers[reagent1][tokens[1].Trim()] = (ClipType)int.Parse(tokens[2].Trim());
+                }
+            }
             return true;
+        }
         public void Save()
+        {
             ProfileSettings.Save(_settingsFile);
             Reaction? reaction;
             using (StreamWriter writer = new(_reactFile, false))
+            {
                 foreach (string reagentName1 in ReagentService.Names)
+                {
                     // TODO: could be more efficient by only iterating over the names after reagent1
                     foreach (string reagentName2 in ReagentService.Names)
+                    {
                         if (reagentName1.Equals(reagentName2))
+                        {
                             continue;
+                        }
                         Reagent reagent1 = ReagentService.GetReagent(reagentName1);
                         Reagent reagent2 = ReagentService.GetReagent(reagentName2);
                         reaction = Reactions.Find(reagent1, reagent2);
                         if (reaction != null)
+                        {
                             writer.WriteLine(reagent1.PracticalPaintName + " " + reagent2.PracticalPaintName + " " +
                             reaction.Red + " " + reaction.Green + " " + reaction.Blue);
+                        }
+                    }
+                }
+            }
-            using (StreamWriter writer = new StreamWriter(_clipFile, false))
             using (StreamWriter writer = new(_clipFile, false))
+            {
                 foreach (var item1 in Clippers)
+                {
                     foreach (var item2 in item1.Value)
+                    {
                         if (item2.Value == ClipType.None) continue;
                         writer.WriteLine(item1.Key + " " + item2.Key + " " + (int)item2.Value);
+                    }
+                }
+            }
+        }
-        public ClipType PairClipStatus(string reagent1, string reagent2)
+        public ClipType PairClipStatus(Reagent reagent1, Reagent reagent2)
+        {
             if (Clippers.TryGetValue(reagent1, out var item1))
+            if (Clippers.TryGetValue(reagent1.PracticalPaintName, out var item1))
+            {
                 if (item1.TryGetValue(reagent2, out var clipType))
+                if (item1.TryGetValue(reagent2.PracticalPaintName, out var clipType))
+                {
                     return clipType;
+                }
+            }
             return ClipType.None;
+        }
         public void SetPairClipStatus(Reagent reagent1, Reagent reagent2, ClipType clip)
+        {
             if (Clippers.TryGetValue(reagent1.PracticalPaintName, out var item1))
+            {
                 if (item1.TryGetValue(reagent2.PracticalPaintName, out var clipType))
+                {
                     if (clipType == clip) return;
+                }
+            }
             else
+            {
                 item1 = new Dictionary<string, ClipType>();
                 Clippers.Add(reagent1.PracticalPaintName, item1);
+            }
             item1[reagent2.PracticalPaintName] = clip;
             Save();
+        }
         private void LoadRecipes(Dictionary<string, PaintRecipe> recipeDict, string filename, uint concentration)
+        {
             foreach (PaintRecipe recipe in recipeDict.Values)
+            {
                 recipe.Clear();
+            }
             string      recipeFile         = Path.Combine(Directory, filename);
             bool        inRecipe           = false;
             PaintRecipe testRecipe         = new();
             string?     currentRecipeColor = null;
             if (!File.Exists(recipeFile)) return;
             using StreamReader reader = new(recipeFile);
             string? line;
             while ((line = reader.ReadLine()) != null)
+            {
                 Match match = _recipeHeaderRegex.Match(line);
                 if (match.Success)
+                {
                     // Store previous recipe.
                     if ((currentRecipeColor != null) && testRecipe.IsValidForConcentration(concentration))
+                    {
                         SetRecipe(currentRecipeColor, testRecipe);
+                    }
                     testRecipe.Clear();
                     currentRecipeColor = match.Groups["colorname"].Value;
                     inRecipe  = true;
+                }
                 else if (inRecipe)
+                {
                     match = _recipeIngredientRegex.Match(line);
                     if (!match.Success) continue;
                     string ingredient = match.Groups["ingredient"].Value;
                     uint   quantity   = uint.Parse(match.Groups["quantity"].Value);
                     testRecipe.AddReagent(ingredient, quantity);
+                }
+            }
             if (!inRecipe || (currentRecipeColor == null)) return;
             // Store final recipe.
             if (testRecipe.IsValidForConcentration(concentration))
+            {
                 SetRecipe(currentRecipeColor, testRecipe);
+            }
+        }
         private void SaveRecipes(Dictionary<string, PaintRecipe> recipeDict, string filename)
+        {
             string recipeFile = Path.Combine(Directory, filename);
             using StreamWriter writer = new(recipeFile, false);
             foreach (KeyValuePair<string, PaintRecipe> pair in recipeDict)
+            {
                 writer.WriteLine("--- Recipe: {0}", pair.Key);
                 foreach (PaintRecipe.ReagentQuantity ingredient in pair.Value.Reagents)
+                {
                     writer.WriteLine("{0,-14} | {1}", ingredient.Name, ingredient.Quantity);
+                }
+            }
+        }
         private void DeleteRecipes(Dictionary<string, PaintRecipe> recipeDict, string filename)
+        {
             string recipeFile = Path.Combine(Directory, filename);
             File.Delete(recipeFile);
             recipeDict.Clear();
+        }
         public void LoadRecipes()
+        {
             LoadRecipes(Recipes, PaintRecipeFile, PaintRecipe.PaintRecipeMinConcentration);
             LoadRecipes(RibbonRecipes, RibbonRecipeFile, PaintRecipe.RibbonRecipeMinConcentration);
+        }
         public void SaveRecipes()
+        {
             SaveRecipes(Recipes, PaintRecipeFile);
             SaveRecipes(RibbonRecipes, RibbonRecipeFile);
+        }
         public void ClearRecipes()
+        {
             DeleteRecipes(Recipes, PaintRecipeFile);
             DeleteRecipes(RibbonRecipes, RibbonRecipeFile);
+        }
         public void ClearPaintRecipes()
+        {
             DeleteRecipes(Recipes, PaintRecipeFile);
+        }
         public void ClearRibbonRecipes()
+        {
             DeleteRecipes(RibbonRecipes, RibbonRecipeFile);
+        }
         public void ExportWikiRecipes(string file)
+        {
             StreamWriter writer = new(file);
             ExportWikiFormat(writer, Recipes);
+        }
         public void ExportWikiRibbons(string file)
+        {
             StreamWriter writer = new StreamWriter(file);
             ExportWikiFormat(writer, this.RibbonRecipes);
+        }
         public void ExportWikiRecipes(TextWriter writer)
+        {
             ExportWikiFormat(writer, this.Recipes);
+        }
         public void ExportWikiRibbons(TextWriter writer)
+        {
             ExportWikiFormat(writer, this.RibbonRecipes);
+        }
         public static void ExportWikiFormat(TextWriter writer, Dictionary<string, PaintRecipe> recipeDict)
+        {
             using (writer)
+            {
                 writer.WriteLine("{| class='wikitable sortable' border=\"1\" style=\"background-color:#DEB887;\"");
                 writer.WriteLine("! Color !! Recipe !! Missing Reactions? || Verified");
                 foreach (PaintColor color in PaletteService.Colors)
+                {
                     writer.WriteLine("|-");
                     string colorLine = "| ";
                     colorLine += "style=\"font-weight: bold; background-color: #" + color.Red.ToString("X2") + color.Green.ToString("X2") + color.Blue.ToString("X2") + ";";
                     if (color.UseWhiteText)
+                    {
                         // dark color gets light text
                         colorLine += " color: #FFFFFF;";
+                    }
                     else
+                    {
                         colorLine += "color: #000000;";
+                    }
                     colorLine += "\" | " + color.Name + " || ";
                     if (recipeDict.TryGetValue(color.Name, out PaintRecipe? recipe))
+                    {
                         foreach (PaintRecipe.ReagentQuantity ingredient in recipe.Reagents)
+                        {
                             colorLine += " " + ingredient;
+                        }
+                    }
                     else
+                    {
                         // no recipe
+                    }
                     colorLine += " || ";
                     if (recipe == null)
+                    {
                         colorLine += "?";
+                    }
                     else if (recipe.HasMissingReactions())
+                    {
                         colorLine += "Y";
+                    }
                     else
+                    {
                         colorLine += "N";
+                    }
                     colorLine += " || N";
                     writer.WriteLine(colorLine);
+                }
                 writer.WriteLine("|}");
+            }
+        }
         public Reaction? FindReaction(Reagent? reagent1, Reagent? reagent2)
+        {
             if ((reagent1 == null) || (reagent2 == null)) return null;
             return Reactions.Find(reagent1, reagent2);
+        }
         public void SetReaction(Reagent reagent1, Reagent reagent2, Reaction reaction)
+        {
             Reactions.Set(reagent1, reagent2, reaction);
+        }
         public void ClearReaction(Reagent reagent1, Reagent reagent2)
+        {
             Reactions.Remove(reagent1, reagent2);
+        }
         public void SetRecipe(PaintRecipe recipe)
+        {
             SetRecipe(PaletteService.FindNearest(recipe.ReactedColor), recipe);
+        }
         public void SetRecipe(string colorName, PaintRecipe recipe)
+        {
             if (Recipes.TryGetValue(colorName, out PaintRecipe? profileRecipe))
+            {
                 profileRecipe.CopyFrom(recipe);
+            }
             else
+            {
                 Recipes.Add(colorName, new PaintRecipe(recipe));
+            }
+        }
         public void SetRibbonRecipe(PaintRecipe recipe)
+        {
             SetRibbonRecipe(PaletteService.FindNearest(recipe.ReactedColor), recipe);
+        }
         public void SetRibbonRecipe(string colorName, PaintRecipe recipe)
+        {
             if (RibbonRecipes.TryGetValue(colorName, out PaintRecipe? profileRecipe))
+            {
                 profileRecipe.CopyFrom(recipe);
+            }
             else
+            {
                 RibbonRecipes.Add(colorName, new PaintRecipe(recipe));
+            }
+        }
+    }
+}

Models/ReactionTest.cs

➞

Show inline comments

 using System;
 using System.ComponentModel;
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 using DesertPaintCodex.Services;
 using JetBrains.Annotations;
 namespace DesertPaintCodex.Models
+{
     public class ReactionTest : INotifyPropertyChanged, IProgress<float>, IComparable<ReactionTest>
+    {
         public enum TestState
+        {
             Unset = -1,
             Untested,
             Scanning,
             LabNotFound,
             ClippedResult,
             GoodResult,
             Saved
+        }
         public Reagent Reagent1 { get; }
         public Reagent Reagent2 { get; }
         private Reagent? _bufferReagent;
         public Reagent? BufferReagent
+        {
             get => _bufferReagent;
             set
+            {
                 if (_bufferReagent == value) return;
                 _bufferReagent = value;
                 _recipe.Clear();
                 if (_bufferReagent == null)
+                {
                     _recipe.AddReagent(Reagent1.Name);
                     _recipe.AddReagent(Reagent2.Name);
+                }
                 else
+                {
                     _recipe.AddReagent(_bufferReagent.Name);
                     _recipe.AddReagent(Reagent1.Name);
                     _recipe.AddReagent(Reagent2.Name);
+                }
                 NotifyPropertyChanged(nameof(BufferReagent));
                 NotifyPropertyChanged(nameof(HypotheticalColor));
                 NotifyPropertyChanged(nameof(CanScan));
                 UpdateHypotheticalColor();
+            }
+        }
         private ClipType _clipType;
         public ClipType Clipped {
             get => _clipType;
             set
+            {
                 _clipType = value;
                 NotifyPropertyChanged(nameof(Clipped));
+            }
+        }
         public bool IsAllCatalysts { get; }
         private Reaction? _reaction;
         public Reaction? Reaction { get => _reaction; set { _reaction = value; NotifyPropertyChanged(nameof(Reaction)); } }
         private Reaction? _badReaction;
         public Reaction? BadReaction { get => _badReaction; set { _badReaction = value; NotifyPropertyChanged(nameof(BadReaction)); } }
         private int _scanProgress;
         public int ScanProgress { get => _scanProgress; set { _scanProgress = value; NotifyPropertyChanged(nameof(ScanProgress)); } }
         private TestState _state;
         public TestState State
+        {
             get => _state;
             set
+            {
                 _state = value;
                 NotifyPropertyChanged(nameof(State));
                 NotifyPropertyChanged(nameof(Requires3Way));
                 NotifyPropertyChanged(nameof(CanScan));
                 NotifyPropertyChanged(nameof(IsScanning));
                 NotifyPropertyChanged(nameof(HasResults));
                 NotifyPropertyChanged(nameof(HasReaction));
                 NotifyPropertyChanged(nameof(CanClear));
                 NotifyPropertyChanged(nameof(CanSave));
                 NotifyPropertyChanged(nameof(NoLab));
                 NotifyPropertyChanged(nameof(CanPickBuffer));
+            }
+        }
         public bool Requires3Way =>
             (State == TestState.ClippedResult) || IsAllCatalysts;
         public bool CanScan => (State == TestState.Untested) || (State == TestState.LabNotFound) ||
             ((State == TestState.ClippedResult) && (BufferReagent != null));
         public bool CanScan => (State is TestState.Untested or TestState.LabNotFound) || ((State == TestState.ClippedResult) && (BufferReagent != null));
         public bool IsScanning => State == TestState.Scanning;
         public bool HasResults => State is TestState.ClippedResult or TestState.GoodResult or TestState.LabNotFound;
+        public bool HasResults => (ObservedColor != null) && (State is TestState.ClippedResult or TestState.GoodResult or TestState.LabNotFound);
         public bool HasReaction => State is TestState.ClippedResult or TestState.GoodResult or TestState.Saved;
         public bool CanClear => State is TestState.ClippedResult or TestState.GoodResult or TestState.Saved;
         public bool CanSave => State == TestState.GoodResult;
         public bool NoLab => State == TestState.LabNotFound;
         public bool CanPickBuffer => (State == TestState.ClippedResult) || IsAllCatalysts;
         public PaintColor? HypotheticalColor => (IsAllCatalysts && (BufferReagent == null)) ? null : _recipe.BaseColor;
         private PaintColor? _hypotheticalColor;
         public PaintColor? HypotheticalColor { get => _hypotheticalColor; set { _hypotheticalColor = value; NotifyPropertyChanged(nameof(HypotheticalColor)); } }
         private PaintColor? _observedColor;
         public PaintColor? ObservedColor { get => _observedColor; set { _observedColor = value; NotifyPropertyChanged(nameof(ObservedColor)); } }
         private readonly PaintRecipe _recipe = new();
         public bool IsStub { get; }
         public ReactionTest(Reagent reagent1, Reagent reagent2, Reaction? reaction, ClipType clipType, bool isStub = false)
+        {
             Reagent1 = reagent1;
             Reagent2 = reagent2;
             IsAllCatalysts = reagent1.IsCatalyst && reagent2.IsCatalyst;
             Clipped = clipType;
             Reaction = reaction;
             State = (reaction != null) ? TestState.Saved :
                 (clipType == ClipType.None) ? TestState.Untested : TestState.ClippedResult;
             _recipe.AddReagent(reagent1.Name);
             _recipe.AddReagent(reagent2.Name);
             IsStub = isStub;
             UpdateHypotheticalColor();
+        }
         #region Actions
         public async Task StartScan()
+        {
             Clipped = ClipType.None;
             ScanProgress = 0;
             Reaction = null;
             BadReaction = null;
             State = TestState.Scanning;
             bool foundLab = await ReactionScannerService.Instance.CaptureReactionAsync(this);
             if (foundLab)
+            {
                 ObservedColor = ReactionScannerService.Instance.RecordedColor;
                 if (_observedColor != null)
+                {
                     Clipped = _observedColor.Red switch
+                        {
 => ClipType.RedLow,
 => ClipType.RedHigh,
                             _   => ClipType.None
+                        }
                         | _observedColor.Green switch
+                        {
 => ClipType.GreenLow,
 => ClipType.GreenHigh,
                             _   => ClipType.None
+                        }
                         | _observedColor.Blue switch
+                        {
 => ClipType.BlueLow,
 => ClipType.BlueHigh,
                             _   => ClipType.None
                         };
                     if (Clipped == ClipType.None)
+                    {
                         State = TestState.GoodResult;
                         Reaction = CalculateReaction();
+                    }
                     else
+                    {
                         State = TestState.ClippedResult;
                         BadReaction = CalculateReaction();
+                    }
                     PlayerProfile? profile = ProfileManager.CurrentProfile;
                     profile?.SetPairClipStatus(Reagent1, Reagent2, Clipped);
+                }
+            }
             else
+            {
                 Debug.WriteLine("ERROR: Lab UI not found.");
                 State = TestState.LabNotFound;
+            }
+        }
         public void CancelScan()
+        {
             ReactionScannerService.Instance.CancelScan();
             State = TestState.Untested;
+        }
         public void MarkInert()
+        {
             Reaction = new Reaction(0, 0, 0);
             State = TestState.GoodResult;
+        }
         public void ClearReaction()
+        {
             PlayerProfile? profile = ProfileManager.CurrentProfile;
             if (profile == null) return;
             profile.Reactions.Remove(Reagent1, Reagent2);
             profile.SetPairClipStatus(Reagent1, Reagent2, ClipType.None);
             if (State == TestState.Saved)
+            {
                 profile.Save();
+            }
             Reaction = null;
             BadReaction = null;
             State = TestState.Untested;
+        }
         public void SaveReaction()
+        {
             PlayerProfile? profile = ProfileManager.CurrentProfile;
             if (profile == null) return;
             profile.Reactions.Set(Reagent1, Reagent2, Reaction);
             profile.Save();
             State = TestState.Saved;
+        }
         #endregion
         #region Internals
         private Reaction? CalculateReaction()
+        {
             if (ProfileManager.CurrentProfile == null) return null;
             if (HypotheticalColor == null) return null;
             if (ObservedColor == null) return null;
-            if (Requires3Way)
+            if (BufferReagent != null)
+            {
                 if (BufferReagent == null) return null;
                 return ReactionScannerService.Calculate3WayReaction(ProfileManager.CurrentProfile, HypotheticalColor,
                     ObservedColor, BufferReagent, Reagent1, Reagent2);
+            }
             return ReactionScannerService.CalculateReaction(HypotheticalColor, ObservedColor);
+        }
         private void UpdateHypotheticalColor()
+        {
             HypotheticalColor = null;
             HypotheticalColor = (IsAllCatalysts && (BufferReagent == null)) ? null : _recipe.BaseColor;
+        }
         #endregion
         #region Interface Implementations
         public event PropertyChangedEventHandler? PropertyChanged;
         [NotifyPropertyChangedInvocator]
         private void NotifyPropertyChanged([CallerMemberName] string? propertyName = null)
+        {
             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
         public void Report(float value)
+        {
             ScanProgress = (int)Math.Round(value * 100);
+        }
         #endregion
         public int CompareTo(ReactionTest? other)
+        {
             if (other == null) return 1;
             if (Clipped == ClipType.None)
+            {
                 if (other.Clipped != ClipType.None) return -1;
+            }
             else if (other.Clipped == ClipType.None) return 1;
             if (IsAllCatalysts)
+            {
                 if (!other.IsAllCatalysts) return 1;
+            }
             else if (other.IsAllCatalysts) return -1;
             return string.CompareOrdinal(Reagent1.Name, other.Reagent1.Name) switch
+            {
                 < 0 => -1,
                 > 0 => 1,
                 _   => string.CompareOrdinal(Reagent2.Name, other.Reagent2.Name)
             };
+        }
+    }
+}

Models/ReactionTestService.cs

➞

Show inline comments

 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Diagnostics;
 using System.Linq;
 using DesertPaintCodex.Services;
 using DynamicData;
 namespace DesertPaintCodex.Models
+{
     public static class ReactionTestService
+    {
         private static readonly List<ReactionTest> _allTests = new();
         static ReactionTestService()
+        {
+        }
         public static void Initialize()
+        {
             _allTests.Clear();
             PlayerProfile? profile = ProfileManager.CurrentProfile;
             Debug.Assert(profile != null);
             List<string> reagentNames = ReagentService.Names;
             foreach (Reagent reagent1 in reagentNames.Select(ReagentService.GetReagent))
+            {
                 foreach (Reagent reagent2 in reagentNames.Select(ReagentService.GetReagent))
+                {
                     if (reagent1 == reagent2) continue;
                     Reaction? reaction = profile.FindReaction(reagent1, reagent2);
-                    ClipType clipType = profile.PairClipStatus(reagent1.Name, reagent2.Name);
                     ClipType clipType = profile.PairClipStatus(reagent1, reagent2);
                     ReactionTest test = new(reagent1, reagent2, reaction, clipType)
+                    {
                         Clipped  = clipType,
                         Reaction = reaction,
                     };
                     _allTests.Add(test);
+                }
+            }
+        }
         public static void PopulateRemainingTests(ObservableCollection<ReactionTest> collection)
+        {
             collection.Clear();
             collection.AddRange(_allTests.Where(test => test.State != ReactionTest.TestState.Saved).OrderBy(test => test));
+        }
         public static void PopulateCompletedTests(ObservableCollection<ReactionTest> collection)
+        {
             collection.Clear();
             collection.AddRange(_allTests.Where(test => test.State == ReactionTest.TestState.Saved).OrderBy(test => test));
+        }
+    }
+}
@@ ... / \ No newline at end of file @@

ViewModels/ReactionTestViewModel.cs

➞

Show inline comments

 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Diagnostics;
 using System.Linq;
 using System.Reactive;
 using System.Reactive.Linq;
 using System.Threading.Tasks;
 using DesertPaintCodex.Models;
 using DesertPaintCodex.Services;
 using DesertPaintCodex.Util;
 using ReactiveUI;
 using DynamicData;
 namespace DesertPaintCodex.ViewModels
+{
     public class ReactionTestViewModel : ViewModelBase
+    {
         private ReactionTest _reactionTest = Constants.StubReactionTest;
         public ReactionTest ReactionTest
+        {
             get => _reactionTest;
             set => this.RaiseAndSetIfChanged(ref _reactionTest, value);
+        }
         private readonly List<Reagent> _allPigmentList = new();
         public ObservableCollection<Reagent> BufferPigmentList { get; } = new();
         private readonly List<Reagent> _allReagentList = new();
         public ObservableCollection<Reagent> BufferList { get; } = new();
         public ReactionTestViewModel()
+        {
             List<string> reagentNames = ReagentService.Names;
-            foreach (var reagent in reagentNames.Select(ReagentService.GetReagent).Where(x => !x.IsCatalyst))
             foreach (var reagent in reagentNames.Select(ReagentService.GetReagent))
+            {
                 _allPigmentList.Add(reagent);
                 if (!reagent.IsCatalyst)
+                {
                     _allPigmentList.Add(reagent);
+                }
                 _allReagentList.Add(reagent);
+            }
             this.WhenAnyValue(x => x.ReactionTest)
                 .Subscribe(_ => UpdateDerivedState());
             ShowScreenSettingsDialog = new Interaction<ScreenSettingsViewModel, Unit>();
             SaveReaction = ReactiveCommand.Create(() => ReactionTest.SaveReaction());
             ClearReaction = ReactiveCommand.Create(() => ReactionTest.ClearReaction());
             FinalizeTestResults = ReactiveCommand.Create(Test);
+        }
         private void UpdateDerivedState()
+        {
             // There are more "reactive" ways to pull this off, but I don't have time to figure out all those recipes
             // right now.
             SetupTest();
+        }
         private void SetupTest()
+        {
             if (ReactionTest.Requires3Way)
+            {
                 FilterBufferPigments();
+            }
+        }
         private void FilterBufferPigments()
+        {
             // Avalonia doesn't really have proper filtering for listy controls yet.
             BufferPigmentList.Clear();
             PlayerProfile? profile = ProfileManager.CurrentProfile;
             if (profile == null) return;
             ReactionSet reactions = profile.Reactions;
             BufferList.Clear();
             List<Reagent> bufferList = ReactionTest.IsAllCatalysts ? _allPigmentList : _allReagentList;
             foreach (Reagent pigment in bufferList)
+            {
                 if (pigment == ReactionTest.Reagent1) continue;
                 if (pigment == ReactionTest.Reagent2) continue;
                 if (reactions.Find(pigment, ReactionTest.Reagent1) == null) continue;
                 if (reactions.Find(pigment, ReactionTest.Reagent2) == null) continue;
                 BufferList.Add(pigment);
+            }
             BufferPigmentList.AddRange(_allPigmentList.Where(pigment =>
                     pigment != ReactionTest.Reagent1 && pigment != ReactionTest.Reagent2));
             // BufferPigmentList.AddRange(_allPigmentList.Where(pigment =>
             //         pigment != ReactionTest.Reagent1 && pigment != ReactionTest.Reagent2));
+        }
         public async void Analyze()
+        {
             Debug.WriteLine("Analyze");
             try
+            {
                 await ReactionTest.StartScan();
                 await FinalizeTestResults.Execute();
+            }
             catch (OperationCanceledException)
+            {
                 Debug.WriteLine("Scan canceled.");
+            }
+        }
         public void MarkInert()
+        {
             ReactionTest.MarkInert();
+        }
         public void CancelScan()
+        {
             ReactionTest.CancelScan();
+        }
         public async Task OpenScreenSettings()
+        {
             await ShowScreenSettingsDialog.Handle(new ScreenSettingsViewModel());
+        }
         public async Task ShowClipInfo()
+        {
             await ShowInfoBox("Clipped Reactions", "The Pigment Lab is only capable of displaying color channel values in the 0-255 range. However, sometimes, your reactions will push one or more channels outside of that range. When that happens, the value will be clamped either to 0 or 255. In this case, we say that the reaction was \"Clipped.\"\n\nThis is nothing to panic about, though. We solve this issue by using a third (buffer) reagent to offset the extreme value, so that it falls within measurable range, similar to how we test Catalyst+Catalyst reactions. Desert Paint Codex will automatically do the math for this, but it does move clipped reactions towards the end of your test list, because you'll want any reactions between the buffer reagent and your two test reagents already known, prior to running your buffered test.");
+        }
         private void Test()
+        {
             Debug.WriteLine("Test complete");
+        }
         public Interaction<ScreenSettingsViewModel, Unit> ShowScreenSettingsDialog { get; }
         public ReactiveCommand<Unit, Unit> ClearReaction { get; }
         public ReactiveCommand<Unit, Unit> SaveReaction { get; }
         public ReactiveCommand<Unit, Unit> FinalizeTestResults { get; }
+    }
+}
@@ ... / \ No newline at end of file @@

Views/MainWindow.axaml

➞

Show inline comments

 <Window xmlns="https://github.com/avaloniaui"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:vm="using:DesertPaintCodex.ViewModels"
         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
         xmlns:views="clr-namespace:DesertPaintCodex.Views"
         mc:Ignorable="d" d:DesignWidth="640" d:DesignHeight="800"
         Width="640" Height="800"
         MinWidth="600" MinHeight="500"
         Topmost="True"
         x:Class="DesertPaintCodex.Views.MainWindow"
         Icon="/Assets/desert_paint_codex_icon.ico"
         Title="Desert Paint Codex">
     <Design.DataContext>
         <vm:MainWindowViewModel/>
     </Design.DataContext>
     <Window.DataContext>
         <vm:MainWindowViewModel/>
     </Window.DataContext>
     <Window.Styles>
         <!--
         <Style Selector="Menu">
             <Setter Property="Background" Value="#282828"/>
         </Style>
         -->
         <Style Selector="ContentControl">
             <Setter Property="Margin" Value="0 5 0 0"/>
         </Style>
         <Style Selector="TextBlock.StatusBar">
             <Setter Property="Margin" Value="5"/>
         </Style>
         <Style Selector="TabControl.ActivityPicker WrapPanel">
             <Setter Property="Background" Value="{DynamicResource GutterBackgroundBrush}"/>
         </Style>
         <Style Selector="TabControl.ActivityPicker">
             <Setter Property="Background" Value="{DynamicResource FlatBackgroundBrush}"/>
         </Style>
         <Style Selector="TabControl.ActivityPicker > TabItem">
             <Setter Property="Padding" Value="15 5"/>
         </Style>
         <Style Selector="TabControl.ActivityPicker > TabItem:pointerover">
             <Setter Property="Foreground" Value="#000000"/>
         </Style>
         <Style Selector="TabControl.ActivityPicker > TabItem:selected">
             <Setter Property="Background" Value="{DynamicResource FlatBackgroundBrush}"/>
             <Setter Property="Foreground" Value="#FFFFFF"/>
         </Style>
         <Style Selector="TabControl.ActivityPicker > TabItem:selected /template/ ContentPresenter#PART_ContentPresenter">
             <Setter Property="Background" Value="{DynamicResource FlagBackgroundBrush}"/>
         </Style>
     </Window.Styles>
     <Grid ColumnDefinitions="*" RowDefinitions="*">
         <DockPanel Name="Main" Grid.Row="0" Grid.Column="0">
             <Menu DockPanel.Dock="Top" Margin="0, 5">
                 <MenuItem Header="_File">
                     <MenuItem Header="Profile">
                         <MenuItem Header="Manage Profiles..." Command="{Binding ManageProfiles}"></MenuItem>
                         <MenuItem Header="Import Profile..." Command="{Binding ImportProfile}">
                             <ToolTip.Tip>
                                 Will overwrite the current profile with a profile from a zipped folder.
                             </ToolTip.Tip>
                         </MenuItem>
                         <MenuItem Header="Export Profile..." Command="{Binding ExportProfile}">
                             <ToolTip.Tip>
                                 Will export the current profile to a zipped folder.
                             </ToolTip.Tip>
                         </MenuItem>
                         <MenuItem Header="Export for PracticalPaint..." Command="{Binding ExportForPP}">
                             <ToolTip.Tip>
                                 Will generate a Practical Paint reactions file from the current profile.
                             </ToolTip.Tip>
                         </MenuItem>
                     </MenuItem>
                     <MenuItem Header="Recipes">
                         <MenuItem Header="Export Paint Recipes..." Command="{Binding ExportPaintRecipes}">
                             <ToolTip.Tip>
                                 Exports recipes in Wiki table format.
                             </ToolTip.Tip>
                         </MenuItem>
                         <MenuItem Header="Export Ribbon Recipes..." Command="{Binding ExportRibbonRecipes}">
                             <ToolTip.Tip>
                                 Exports recipes in Wiki table format.
                             </ToolTip.Tip>
                         </MenuItem>
                         <MenuItem Header="Copy Paint Recipes to Clipboard" Command="{Binding CopyPaintRecipes}">
                             <ToolTip.Tip>
                                 Copies recipes in Wiki table format.
                             </ToolTip.Tip>
                         </MenuItem>
                         <MenuItem Header="Copy Ribbon Recipes to Clipboard" Command="{Binding CopyRibbonRecipes}">
                             <ToolTip.Tip>
                                 Copies recipes in Wiki table format.
                             </ToolTip.Tip>
                         </MenuItem>
                     </MenuItem>
                     <Separator/>
                     <MenuItem Header="Screen Settings..." Command="{Binding ShowScreenSettings}"></MenuItem>
                     <Separator/>
                     <MenuItem Header="Exit" Command="{Binding Exit}"></MenuItem>
                 </MenuItem>
                 <MenuItem Header="_Help">
                      <MenuItem Header="Documentation" Command="{Binding OpenBrowser}" CommandParameter="https://repos.malkyne.org/ATITD-Tools/Desert-Paint-Codex"></MenuItem>
                      <MenuItem Header="About..." Command="{Binding ShowAbout}"></MenuItem>
                 </MenuItem>
             </Menu>
             <Border DockPanel.Dock="Top" BorderThickness="2" Background="{DynamicResource GutterBackgroundBrush}"></Border>
             <TextBlock DockPanel.Dock="Bottom" Classes="StatusBar"
                        Text="{Binding StatusText}"
                        HorizontalAlignment="Left" VerticalAlignment="Center" Height="18"/>
             <Border DockPanel.Dock="Bottom" BorderThickness="2" Background="{DynamicResource GutterBackgroundBrush}"></Border>
             <TabControl Classes="ActivityPicker">
                 <TabItem Header="EXPERIMENT LOG" VerticalContentAlignment="Center">
                     <views:ExperimentLogView />
                 </TabItem>
                 <TabItem Header="SIMULATOR" VerticalContentAlignment="Center">
                     <views:SimulatorView />
                 </TabItem>
                 <TabItem Header="RECIPE GENERATOR" VerticalContentAlignment="Center">
                     <views:RecipeGeneratorView />
                 </TabItem>
             </TabControl>
         </DockPanel>
     </Grid>
 </Window>

Views/ReactionTestView.axaml

➞

Show inline comments

 <UserControl xmlns="https://github.com/avaloniaui"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
              xmlns:views="clr-namespace:DesertPaintCodex.Views"
              xmlns:vm="clr-namespace:DesertPaintCodex.ViewModels"
              mc:Ignorable="d" d:DesignWidth="310" d:DesignHeight="450"
              x:Class="DesertPaintCodex.Views.ReactionTestView"
              IsVisible="{Binding Path=!ReactionTest.IsStub}"
+             >
     <Design.DataContext>
         <vm:ReactionTestViewModel />
     </Design.DataContext>
     <UserControl.Styles>
         <Style Selector="StackPanel.ReagentRow">
             <Setter Property="Orientation" Value="Horizontal"/>
             <Setter Property="Spacing" Value="10"/>
             <Setter Property="Height" Value="30"/>
         </Style>
         <Style Selector="TextBlock.ReagentLabel">
             <Setter Property="VerticalAlignment" Value="Center"/>
             <Setter Property="TextAlignment" Value="Right"/>
             <Setter Property="Width" Value="80"/>
         </Style>
         <Style Selector="TextBlock.ReagentName">
             <Setter Property="VerticalAlignment" Value="Center"/>
             <Setter Property="Width" Value="120"/>
         </Style>
     </UserControl.Styles>
     <StackPanel Spacing="20" Margin="20 0 0 0">
         <StackPanel DockPanel.Dock="Top" Orientation="Vertical" Spacing="5">
             <TextBlock Classes="BlockHeader">REAGENTS</TextBlock>
             <Border Classes="ThinFrame">
                 <StackPanel Orientation="Vertical" Spacing="10">
                     <StackPanel Classes="ReagentRow" IsVisible="{Binding ReactionTest.Requires3Way}">
                         <TextBlock Classes="ReagentLabel">Buffer:</TextBlock>
                         <TextBlock Classes="ReagentName" Text="{Binding ReactionTest.BufferReagent.Name, FallbackValue=[Unknown]}" IsVisible="{Binding !ReactionTest.CanScan}"/>
                         <ComboBox Items="{Binding BufferPigmentList}"
                                   IsVisible="{Binding ReactionTest.CanScan}"
                         <TextBlock Classes="ReagentName" Text="{Binding ReactionTest.BufferReagent.Name, FallbackValue=[Unknown]}" IsVisible="{Binding !ReactionTest.CanPickBuffer}"/>
                         <ComboBox Items="{Binding BufferList}"
                                   IsVisible="{Binding ReactionTest.CanPickBuffer}"
                                   SelectedItem="{Binding ReactionTest.BufferReagent}"
                                   PlaceholderText="Choose" Width="120" Height="30">
                             <ComboBox.ItemTemplate>
                                 <DataTemplate>
                                     <TextBlock Text="{Binding Name}" />
                                 </DataTemplate>
                             </ComboBox.ItemTemplate>
                         </ComboBox>
                         <Border Classes="ReagentSwatch"
                             Background="{Binding ReactionTest.BufferReagent.Color, Converter={StaticResource paintToBrush}, FallbackValue=#00000000}" />
                     </StackPanel>
                     <StackPanel Classes="ReagentRow">
                         <TextBlock Classes="ReagentLabel">Reagent #1:</TextBlock>
                         <TextBlock Classes="ReagentName" Text="{Binding ReactionTest.Reagent1.Name}" />
                         <Border Classes="ReagentSwatch"
                             Background="{Binding ReactionTest.Reagent1.Color, Converter={StaticResource paintToBrush}, FallbackValue=#00000000}" />
                     </StackPanel>
                     <StackPanel Classes="ReagentRow">
                         <TextBlock Classes="ReagentLabel">Reagent #2:</TextBlock>
                         <TextBlock Classes="ReagentName" Text="{Binding ReactionTest.Reagent2.Name}" />
                         <Border Classes="ReagentSwatch"
                             Background="{Binding ReactionTest.Reagent2.Color, Converter={StaticResource paintToBrush}, FallbackValue=#00000000}" />
                     </StackPanel>
                 </StackPanel>
             </Border>
         </StackPanel>
         <StackPanel DockPanel.Dock="Top" Orientation="Vertical" Spacing="5">
             <TextBlock Classes="BlockHeader">HYPOTHETICAL COLOR</TextBlock>
             <views:PaintSwatchView ShowName="False" Color="{Binding ReactionTest.HypotheticalColor}"/>
         </StackPanel>
          <Grid ColumnDefinitions="*,15,*" IsVisible="{Binding ReactionTest.CanScan}">
             <Button Grid.Column="0" Padding="11 5 11 5" Command="{Binding Analyze}">Analyze Mixture</Button>
             <Button Grid.Column="2" Padding="11 5 11 5" Command="{Binding MarkInert}">Mark Inert</Button>
         </Grid>
         <StackPanel Orientation="Vertical" Spacing="10" IsVisible="{Binding ReactionTest.IsScanning}">
             <ProgressBar DockPanel.Dock="Top" Value="{Binding ReactionTest.ScanProgress}" Height="20" />
             <Button Command="{Binding CancelScan}">Cancel Scan</Button>
         </StackPanel>
         <StackPanel DockPanel.Dock="Top" Orientation="Vertical" Spacing="5"
                     IsVisible="{Binding ReactionTest.HasResults}">
             <TextBlock Classes="BlockHeader">TEST RESULT</TextBlock>
             <views:PaintSwatchView ShowName="False" IsVisible="{Binding !ReactionTest.NoLab}" Color="{Binding ReactionTest.ObservedColor}"/>
             <views:EmbeddedWarningBox IsVisible="{Binding ReactionTest.NoLab}"
                 Title="🛇 PIGMENT LAB NOT FOUND"
                 Message="You may want to make sure your view of the Pigment Lab is clear, and that your screen settings are correct.">
                 <Button Command="{Binding OpenScreenSettings}">
                     <TextBlock FontWeight="Bold" FontSize="15">SCREEN SETTINGS</TextBlock>
                 </Button>
             </views:EmbeddedWarningBox>
         </StackPanel>
         <StackPanel DockPanel.Dock="Top" Orientation="Vertical" Spacing="5"
                     IsVisible="{Binding ReactionTest.HasReaction}">
             <TextBlock Classes="BlockHeader">REACTION OBSERVED</TextBlock>
             <StackPanel Orientation="Horizontal" Spacing="21" Margin="0 5">
                 <views:ReactionUnitView Reaction="{Binding ReactionTest.Reaction}"/>
             </StackPanel>
             <views:EmbeddedWarningBox Title="🛇 REACTION CLIPPED"
                                       IsVisible="{Binding !!ReactionTest.Clipped}"
                                       Message="Your reaction fell outside of measurable values. We will need to use a buffer pigment to test it.">
                 <StackPanel Orientation="Vertical" Spacing="10">
                     <Button Command="{Binding ShowClipInfo}">LEARN MORE</Button>
                 </StackPanel>
             </views:EmbeddedWarningBox>
         </StackPanel>
         <Button IsVisible="{Binding ReactionTest.CanClear}"
                 Command="{Binding ClearReaction}">Clear Reaction</Button>
         <Button IsVisible="{Binding ReactionTest.CanSave}"
                 Command="{Binding SaveReaction}">Save Reaction</Button>
     </StackPanel>
 </UserControl>
@@ ... / \ No newline at end of file @@

0 comments (0 inline, 0 general)