ATITD-Tools/Desert-Paint-Lab Changeset

Changeset - c9ad5ae6640a

Parent rev.

Child rev.

[Not reviewed]

default

0 2 0

Jason Maltzen (jmaltzen) - 9 years ago 2016-01-15 17:25:49
jason.maltzen@unsanctioned.net

Add a thread count for paint recipe generation to settings

2 files changed with 9 insertions and 1 deletions:

RecipeGenerator.cs

RecipeGeneratorWindow.cs

0 comments (0 inline, 0 general)

RecipeGenerator.cs

➞

Show inline comments

 /*
  * Copyright (c) 2015, Jason Maltzen
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
  The above copyright notice and this permission notice shall be included in
  all copies or substantial portions of the Software.
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  THE SOFTWARE.
 */
 using System;
 using System.IO;
 using System.Collections.Generic;
 using System.Collections.Concurrent;
 using System.Text.RegularExpressions;
 using System.Threading;
 namespace DesertPaintLab
+{
     public class NewRecipeEventArgs : EventArgs
+    {
         string color;
         PaintRecipe recipe;
         public NewRecipeEventArgs(string color, PaintRecipe recipe)
+        {
             this.color = color;
             this.recipe = recipe;
+        }
         public string Color
+        {
             get {
                 return color;
+            }
+        }
         public PaintRecipe Recipe
+        {
             get {
                 return recipe;
+            }
+        }
+    }
     public class RecipeGenerator
+    {
         public enum SearchType {
             DEPTH_FIRST,
             BREADTH_FIRST
         };
         public SearchType Mode { get; set; }
         public uint MaxQuantity { get; private set; } // maximum number of total ingredients
         public uint MaxReagents { get; private set; } // maximum number of reagents to use in the recipe
         public uint MinReagents { get; private set; } // minimum number of reagents to use in the recipe
         public uint FullQuantityDepth { get; private set; } // at or equal this number of reagents, ignore ingredient settings for max quantity
         public uint FullQuantity { get; private set; }  // The max number of a reagent to use at full quantity
         public uint MaxThreads { get; set; }
         ReactionSet reactions;
         bool running = false;
         int runningThreads = 0;
         SortedDictionary<string, uint> recipeCosts = new SortedDictionary<string, uint>();
         SortedDictionary<string, PaintRecipe> recipes = new SortedDictionary<string, PaintRecipe>();
         uint totalReagents;
         List<Reagent> costSortedReagents = new List<Reagent>();
         ConcurrentQueue<RecipeSearchNode> searchQueue = new ConcurrentQueue<RecipeSearchNode>();
         ulong recipeCount = 0;
         List<Thread> generatorThreads = new List<Thread>();
         Object workerLock = new Object();
         bool requestCancel = false;
         StreamWriter log;
         // events
         public event EventHandler Finished;
         public event EventHandler Progress;
         public event EventHandler<NewRecipeEventArgs> NewRecipe;
         public RecipeGenerator(ReactionSet reactions)
+        {
             Mode = SearchType.BREADTH_FIRST;
             this.reactions = reactions;
             foreach (PaintColor color in Palette.Colors)
+            {
                 recipes.Add(color.Name, new PaintRecipe());
                 recipeCosts.Add(color.Name, uint.MaxValue);
+            }
             MinReagents = 1;
             MaxReagents = 5;
             MaxQuantity = 20;
+        }
         public SortedDictionary<string, PaintRecipe> Recipes
+        {
             get
+            {
                 return recipes;
+            }
+        }
         public ulong RecipeCount
+        {
             get
+            {
                 return recipeCount;
+            }
+        }
         public bool CanResume
+        {
             get
+            {
                 return (!running && (searchQueue.Count > 0));
+            }
+        }
         public string Log
+        {
             set
+            {
                 if (value != null)
+                {
                     log = new StreamWriter(value);
+                }
                 else
+                {
                     log = null;
+                }
+            }
+        }
         private class ReagentCostSort : IComparer<Reagent>
+        {
             public int Compare(Reagent reagent1, Reagent reagent2)
+            {
                 return (int)reagent1.Cost - (int)reagent2.Cost;
+            }
+        }
         public void InitRecipes(SortedDictionary<string, PaintRecipe> initialRecipes)
+        {
             if (running)
+            {
                 return;
+            }
             foreach (PaintRecipe recipe in initialRecipes.Values)
+            {
                 //PaintRecipe recipeCopy = new PaintRecipe(recipe);
                 AddCheapestRecipe(recipe);
+            }
+        }
         private void InitSortedReagents()
+        {
             costSortedReagents.Clear();
             foreach (string name in ReagentManager.Names)
+            {
                 Reagent reagent = ReagentManager.GetReagent(name);
                 costSortedReagents.Add(reagent);
+            }
             costSortedReagents.Sort(new ReagentCostSort());
+        }
         public void BeginRecipeGeneration(uint maxQuantity, uint minReagents, uint maxReagents, uint fullQuantityDepth, uint fullQuantity)
+        {
             if (running)
+            {
                 // Already running - don't start again
                 return;
+            }
             this.MaxQuantity = maxQuantity;
             this.MinReagents = minReagents;
             this.MaxReagents = maxReagents;
             this.FullQuantity = fullQuantity;
             this.FullQuantityDepth = fullQuantityDepth;
             // first, sort reagents by cost.
             InitSortedReagents();
             totalReagents = (uint)costSortedReagents.Count;
             // Pre-populate recipes list with:
             // 1) 1-ingredient recipes @ 10db for all enabled ingredients with a count >= 10
             // 2) any previously-generated recipes
             int enabledReagentCount = 0;
             PaintRecipe recipe = new PaintRecipe();
             recipe.Reactions = reactions;
             foreach (Reagent reagent in costSortedReagents)
+            {
                 if (reagent.Enabled)
+                {
                     if (!reagent.IsCatalyst && ((reagent.RecipeMax >= 10) || ((FullQuantityDepth > 0) && (FullQuantity >= 10))))
+                    {
                         recipe.Clear();
                         recipe.AddReagent(reagent.Name, 10);
                         AddCheapestRecipe(recipe);
+                    }
                     ++enabledReagentCount;
+                }
+            }
             this.MaxReagents = (uint)Math.Min(enabledReagentCount, this.MaxReagents);
             this.MinReagents = (uint)Math.Min(this.MinReagents, this.MaxReagents);
             while (!searchQueue.IsEmpty)
+            {
                 RecipeSearchNode node;
                 searchQueue.TryDequeue(out node);
+            }
             for (uint reagentIdx = 0; reagentIdx < costSortedReagents.Count; ++reagentIdx)
+            {
                 if (costSortedReagents[(int)reagentIdx].Enabled)
+                {
                     RecipeSearchNode initialNode = new RecipeSearchNode(costSortedReagents, reagentIdx);
                     initialNode.FullQuantity = FullQuantity;
                     initialNode.FullQuantityDepth = FullQuantityDepth;
                     initialNode.MaxQuantity = maxQuantity;
                     initialNode.MinReagents = minReagents;
                     initialNode.MaxReagents = maxReagents;
                     searchQueue.Enqueue(initialNode);
+                }
+            }
             recipeCount = 0;
             if (log != null)
+            {
                 log.WriteLine("Begin recipe generation: MaxQuantity={0} MinReagents={1} MaxReagents={2} FullQuantity={3} FullQuantityDepth={4}", MaxQuantity, MinReagents, MaxReagents, FullQuantity, FullQuantityDepth);
+            }
             // start worker threads to do the actual work
             ResumeRecipeGeneration();
+        }
         public void ResumeRecipeGeneration()
+        {
             if (running)
+            {
                 // Already running - don't start again
                 return;
+            }
             running = true;
             requestCancel = false;
             if (log != null)
+            {
                 log.WriteLine("Resuming recipe generation: pre-threads={0} reagent count={1} search queue={2}", runningThreads, costSortedReagents.Count, searchQueue.Count);
+            }
             runningThreads = 0; // presumably!
             int threadCount = Math.Min(costSortedReagents.Count, searchQueue.Count);
+            int threadCount = Math.Min(Math.Min(costSortedReagents.Count, searchQueue.Count), (int)MaxThreads);
             if (threadCount == 0)
+            {
                 if (Finished != null)
+                {
                     Finished(this, null);
+                }
+            }
             generatorThreads.Clear();
             System.Console.WriteLine("Starting {0} generator threads.", threadCount);
             for (int i = 0; i < threadCount; ++i)
+            {
                 Thread thr = new Thread(new ThreadStart(this.Generate));
                 thr.Priority = ThreadPriority.BelowNormal;
                 generatorThreads.Add(thr);
+            }
             foreach (Thread thr in generatorThreads)
+            {
                 thr.Start();
+            }
+        }
         public bool SaveState(string file)
+        {
             if (running)
+            {
                 // can't save state while running
                 return false;
+            }
             using (StreamWriter writer = new StreamWriter(file, false))
+            {
                 writer.WriteLine("MinReagents: {0}", MinReagents);
                 writer.WriteLine("MaxReagents: {0}", MaxReagents);
                 writer.WriteLine("FullQuantityDepth: {0}", FullQuantityDepth);
                 writer.WriteLine("FullQuantity: {0}", FullQuantity);
                 writer.WriteLine("TotalReagents: {0}", totalReagents);
                 writer.WriteLine("RecipeCount: {0}", recipeCount);
                 writer.WriteLine("SearchType: {0}", Mode.ToString());
                 foreach (KeyValuePair<string, PaintRecipe> pair in recipes)
+                {
                     PaintRecipe recipe = pair.Value;
                     string colorName = Palette.FindNearest(recipe.ReactedColor);
                     writer.WriteLine("BeginRecipe: {0}", colorName);
                     foreach (PaintRecipe.RecipeIngredient ingredient in recipe.Ingredients)
+                    {
                         writer.WriteLine("Ingredient: {0}={1}", ingredient.name, ingredient.quantity);
+                    }
                     writer.WriteLine("EndRecipe: {0}", colorName);
+                }
                 writer.WriteLine("SearchNodes: {0}", searchQueue.Count);
                 foreach (RecipeSearchNode node in searchQueue)
+                {
                     node.SaveState(writer);
+               }
+            }
             return true;
+        }
         static Regex keyValueRegex = new Regex(@"(?<key>\w+)\:\s*(?<value>.+)\s*");
         static Regex ingredientRegex = new Regex(@"(?<ingredient>(\w+\s)*\w+)\s*=\s*(?<quantity>\d)\s*");
         public bool LoadState(string file)
+        {
             // cannot be running, and reactions must be set
             if (running)
+            {
                 return false;
+            }
             InitSortedReagents();
             bool success = true;
             PaintRecipe currentRecipe = null;
             Match match;
             string line;
             using (StreamReader reader = new StreamReader(file, false))
+            {
                 while (success && ((line = reader.ReadLine()) != null))
+                {
                     match = keyValueRegex.Match(line);
                     if (match.Success)
+                    {
                         string value = match.Groups["value"].Value;
                         switch(match.Groups["key"].Value)
+                        {
                             case "MinReagents":
                                 MinReagents = uint.Parse(value);
                                 MaxReagents = (uint)Math.Max(this.MinReagents, this.MaxReagents);
                                 break;
                             case "MaxReagents":
                                 MaxReagents = uint.Parse(value);
                                 MinReagents = (uint)Math.Min(this.MinReagents, this.MaxReagents);
                                 break;
                             case "FullQuantityDepth":
                                 FullQuantityDepth = uint.Parse(value);
                                 break;
                             case "FullQuantity":
                                 FullQuantity = uint.Parse(value);
                                 break;
                             case "TotalReagents":
                                 totalReagents = uint.Parse(value);
                                 break;
                             case "RecipeCount":
                                 if (!ulong.TryParse(value, out recipeCount))
+                                {
                                     // must have rolled to negative - try as an int and convert
                                     int recipeCountInt = int.Parse(value);
                                     recipeCount = (ulong)((long)recipeCountInt & 0x00000000ffffffffL);
+                                }
                                 break;
                             case "BeginRecipe":
                                 currentRecipe = new PaintRecipe();
                                 currentRecipe.Reactions = reactions;
                                 break;
                             case "EndRecipe":
                                 if (currentRecipe != null)
+                                {
                                     PaintColor color = currentRecipe.ReactedColor;
                                     uint cost = currentRecipe.Cost;
                                     recipes[color.Name] = currentRecipe; // replace
                                     recipeCosts[color.Name] = cost;
                                     currentRecipe = null;
+                                }
                                 break;
                             case "Ingredient":
                                 if (currentRecipe != null)
+                                {
                                     Match ingredientMatch = ingredientRegex.Match(match.Groups["value"].Value);
                                     if (ingredientMatch.Success)
+                                    {
                                         uint quantity = uint.Parse(ingredientMatch.Groups["quantity"].Value);
                                         currentRecipe.AddReagent(ingredientMatch.Groups["ingredient"].Value, quantity);
+                                    }
                                     else
+                                    {
                                         success = false;
+                                    }
+                                }
                                 break;
                             case "SearchNodes":
                                 int nodeCount = int.Parse(match.Groups["value"].Value);
                                 for (int i = 0; i < nodeCount; ++i)
+                                {
                                     RecipeSearchNode node = new RecipeSearchNode(costSortedReagents);
                                     node.FullQuantity = FullQuantity;
                                     node.FullQuantityDepth = FullQuantityDepth;
                                     node.MinReagents = MinReagents;
                                     node.MaxReagents = MaxReagents;
                                     node.MaxQuantity = MaxQuantity;
                                     success = success && node.LoadState(reader);
                                     if (success)
+                                    {
                                         searchQueue.Enqueue(node);
+                                    }
+                                }
                                 break;
                             case "SearchType":
                                 Mode = (SearchType)Enum.Parse(typeof(SearchType), match.Groups["value"].Value);
                                 break;
                             default:
                                 success = false;
                                 break;
+                        }
+                    }
                     else
+                    {
                         success = false;
                         break;
+                    }
+                }
                 return success;
+            }
+        }
         private void Generate()
+        {
             RecipeSearchNode node;
             lock(workerLock)
+            {
                 ++runningThreads;
+            }
             bool ok = true;
             do
+            {
                 lock (workerLock)
+                {
                     ok = searchQueue.TryDequeue(out node);
+                }
                 if (ok)
+                {
                     if (Mode == SearchType.DEPTH_FIRST)
+                    {
                         uint targetQuantity = (node.ReagentCount <= FullQuantityDepth) ? ((uint)node.ReagentCount * FullQuantity) : node.MaxQuantity + 1;
                         do {
                             --targetQuantity;
                             node.InitForQuantity(targetQuantity);
                         } while (targetQuantity > 10 && (node.CurrentTargetQuantity != node.UsedQuantity));
                         while ((ok = IterateDepthFirst(node)) && !requestCancel)
+                        {
                             if (Progress != null)
+                            {
                                 Progress(this, null);
+                            }
+                        }
+                    }
                     else
+                    {
                         // breadth-first search
                         uint targetQuantity = 9;
                         uint quantityLimit = (node.ReagentCount <= FullQuantityDepth) ? (FullQuantity * (uint)node.ReagentCount) : node.MaxQuantity;
                         do {
                             ++targetQuantity;
                             node.InitForQuantity(targetQuantity);
                         } while ((targetQuantity <= quantityLimit) && (node.CurrentTargetQuantity != node.UsedQuantity));
                         while ((ok = IterateBreadthFirst(node)) && !requestCancel)
+                        {
                             if (Progress != null)
+                            {
                                 Progress(this, null);
+                            }
+                        }
+                    }
                     if (ok)
+                    {
                         // stopped because cancel was requested - requeue the node in its current state for resume
                         searchQueue.Enqueue(node);
+                    }
+                }
             } while (!requestCancel && ok);
             bool done = false;
             lock(workerLock)
+            {
                 --runningThreads;
                 //generatorThreads.Remove(Thread.CurrentThread);
                 done = (runningThreads == 0);
+            }
             if (done)
+            {
                 running = false;
                 requestCancel = false;
                 if (Finished != null)
+                {
                     Finished(this, null);
+                }
+            }
+        }
         // Add the cheapest recipe to the recipe list
         // returns the discarded recipe from the pair (or null if no original recipe to replace)
         private void AddCheapestRecipe(PaintRecipe recipe)
+        {
             if (recipe.IsValid)
+            {
                 recipe.Reactions = reactions;
                 string colorName = Palette.FindNearest(recipe.ReactedColor);
                 //System.Console.WriteLine("Recipe: {0} {1}:", colorName, recipe.Cost);
                 //foreach (PaintRecipe.RecipeIngredient ingr in recipe.Ingredients)
                 //{
                 //    System.Console.WriteLine("    -> {0} {1}", ingr.quantity, ingr.name);
                 //}
                 uint cost;
                 lock (workerLock)
+                {
                     if (recipeCosts.TryGetValue(colorName, out cost))
+                    {
                         if (cost > recipe.Cost)
+                        {
                             recipes[colorName].CopyFrom(recipe);
                             recipeCosts[colorName] = recipe.Cost;
                             if (NewRecipe != null)
+                            {
                                 NewRecipeEventArgs args = new NewRecipeEventArgs(colorName, recipe);
                                 NewRecipe(this, args);
+                            }
+                        }
+                    }
                     else
+                    {
                         // This would be an error!
                         recipeCosts.Add(colorName, recipe.Cost);
                         recipes.Add(colorName, new PaintRecipe(recipe));
                         if (NewRecipe != null)
+                        {
                             NewRecipeEventArgs args = new NewRecipeEventArgs(colorName, recipe);
                             NewRecipe(this, args);
+                        }
+                    }
+                }
+            }
             //else
             //{
             //    string msg = String.Format("Recipe is invalid ({0} ingredients)\n", recipe.Ingredients.Count);
             //    foreach (PaintRecipe.RecipeIngredient ingr in recipe.Ingredients)
             //    {
             //        msg += String.Format("    -> {0} {1}", ingr.quantity, ingr.name);
             //    }
             //    lock (workerLock) {
             //        Console.WriteLine(msg);
             //    }
             //}
+        }
         private bool IterateDepthFirst(RecipeSearchNode node)
+        {
             TestCurrentRecipe(node);
             // pick recipe quantities at current recipe ingredients/size
             if (NextRecipe(node))
+            {
                 lock(workerLock)
+                {
                     ++recipeCount;
+                }
                 //System.Console.WriteLine("Found next recipe at size {0} qty {1}", node.Reagents.Count, node.CurrentTargetQuantity);
                 return true;
+            }
             if (NextRecipeSize(node))
+            {
                 //System.Console.WriteLine("Found next recipe size {0}", node.CurrentTargetQuantity);
                 return true;
+            }
             // Search for next ingredient combo - all quantity combos for previous were searched
             //System.Console.WriteLine("Finding next ingredient combo");
             do
+            {
                 if (!node.AddNextReagent())
+                {
                     while ((node.ReagentCount > node.MinReagents) && (node.LastReagent == (totalReagents-1)))
+                    {
                         node.RemoveLastReagent();
+                    }
                     if (node.ReagentCount == node.MinReagents)
+                    {
                         // done
                         return false;
+                    }
                     uint nextReagent = node.NextFreeReagent(node.LastReagent);
                     while ((node.ReagentCount > node.MinReagents) && (nextReagent >= totalReagents))
+                    {
                         // No more reagents to try at this level
                         node.RemoveLastReagent();
                         if (node.ReagentCount > node.MinReagents)
+                        {
                             nextReagent = node.NextFreeReagent(node.LastReagent);
+                        }
+                    }
                     if (node.ReagentCount == node.MinReagents)
+                    {
                         // done
                         return false;
+                    }
                     node.ReplaceLastReagent(nextReagent);
+                }
             } while (node.MaxQuantity < (10 + node.CatalystCount));
             node.InitForQuantity(node.MaxQuantity);
             //string outStr = "{0} : {1} : ";
             //for (int i = 0; i < currentReagents.Count; ++i)
             //{
             //    Reagent reagent = costSortedReagents[(int)currentReagents[i]];
             //    if (i > 0)
             //    {
             //        outStr += ", ";
             //    }
             //    outStr += reagent.Name + " (" + reagent.Cost + ")";
             //}
             //Console.WriteLine(outStr, currentReagents.Count, recipeCount);
             return true;
+        }
         private bool IterateBreadthFirst(RecipeSearchNode node)
+        {
             // pick recipe quantities at current recipe ingredients/size
             TestCurrentRecipe(node);
             lock(workerLock)
+            {
                 ++recipeCount;
+            }
             // search all quantities of current recipe
             if (NextRecipe(node))
+            {
                 //System.Console.WriteLine("Found next recipe at size {0} qty {1}", node.ReagentCount, node.CurrentTargetQuantity);
                 return true;
+            }
             // Try next quantity
             uint newQuantity;
             uint quantityLimit = ((uint)node.ReagentCount <= FullQuantityDepth) ? ((uint)node.ReagentCount * FullQuantity) : node.MaxQuantity;
             do {
                 newQuantity = node.CurrentTargetQuantity + 1;
                 //Console.WriteLine("Try quantity {0}", newQuantity);
                 if (newQuantity <= quantityLimit)
+                {
                     node.InitForQuantity(newQuantity);
                     if (node.CurrentTargetQuantity <= node.UsedQuantity)
+                    {
                         if (log != null) { lock(log) { log.WriteLine("Update quantity to {0}", node.CurrentTargetQuantity); } }
                         return true;
+                    }
+                }
             } while (newQuantity < quantityLimit);
             // search all variants at this depth of recipe
             // increase recipe depth
             // next reagent in last position
             // if at end, pop reagent
             //Console.WriteLine("Finding new recipe after quantity {0}/{1} used {2}", newQuantity, node.MaxQuantity, node.UsedQuantity);
             node.InitForQuantity(10+node.CatalystCount); // reset quantity
             int currentDepth = node.ReagentCount;
             bool recipeFound = false;
             uint nextReagent;
             do {
                 //Console.WriteLine("Current depth: {0}/{1}", currentDepth, node.MaxReagents);
                 do {
                     recipeFound = false;
                     // back out until we find a node that can be incremented
                     if (currentDepth > node.MinReagents)
+                    {
                         while (node.ReagentCount > node.MinReagents)
+                        {
                             if (node.LastReagent < (totalReagents - 1))
+                            {
                                 nextReagent = node.NextFreeReagent(node.LastReagent);
                                 if (nextReagent < totalReagents)
+                                {
                                     //Console.WriteLine("Replace last reagent with {0}", nextReagent);
                                     node.ReplaceLastReagent(nextReagent);
                                     break;
+                                }
                                 else
+                                {
                                     // shouldn't happen
                                     //Console.WriteLine("No available reagents at depth {0}!", node.ReagentCount);
                                     node.RemoveLastReagent();
                                     if (node.ReagentCount == node.MinReagents)
+                                    {
                                         // just popped the last reagent at the top level
                                         ++currentDepth;
                                         if (log != null) { lock(log) { log.WriteLine("Increased depth to {0}/{1}", currentDepth, node.MaxReagents); } }
+                                    }
+                                }
+                            }
                             else
+                            {
                                 //Console.WriteLine("Pop last reagent");
                                 node.RemoveLastReagent();
                                 if (node.ReagentCount == node.MinReagents)
+                                {
                                     // just popped the last reagent at the top level
                                     ++currentDepth;
                                     if (log != null) { lock(log) { log.WriteLine("Increased depth to {0}/{1} [pop last reagent at top level]", currentDepth, node.MaxReagents); } }
+                                }
+                            }
+                        }
                         // fill in the nodes up to the current depth
                         if (node.ReagentCount >= node.MinReagents)
+                        {
                             recipeFound = true;
                             while (node.ReagentCount < currentDepth)
+                            {
                                 if (! node.AddNextReagent())
+                                {
                                     if (log != null) { lock(log) { log.WriteLine("Failed to reagent {0}/{1}", node.ReagentCount+1, currentDepth); } }
                                     recipeFound = false;
+                                }
+                            }
+                        }
+                    }
                     //Console.WriteLine("Catalysts: {0} Reagents: {1} Min: {2}", node.CatalystCount, node.ReagentCount, node.MinReagents);
                 } while ((node.CatalystCount >= node.ReagentCount) && (node.ReagentCount >= node.MinReagents)); // make sure to skip all-catalyst combinations
                 if (recipeFound)
+                {
                     break;
+                }
                 else
+                {
                     ++currentDepth;
                     if (log != null) { lock(log) { log.WriteLine("Increased depth to {0}/{1} [no recipe]", currentDepth, node.MaxReagents); } }
+                }
             } while (currentDepth <= node.MaxReagents);
             if (recipeFound)
+            {
                 node.InitForQuantity(10+node.CatalystCount); // minimum quantity for this recipe
                 if (node.TestRecipe == null)
+                {
                     node.TestRecipe = new PaintRecipe();
                     node.TestRecipe.Reactions = reactions;
+                }
                 node.TestRecipe.Clear();
                 for (int i = 0; i < node.ReagentCount; ++i)
+                {
                     node.TestRecipe.AddReagent(node.Reagent(i).Name, node.CurrentWeights[i]);
+                }
                 if (log != null) {
                     string combo = "";
                     foreach (PaintRecipe.RecipeIngredient ingr in node.TestRecipe.Ingredients)
+                    {
                         combo += " " + ingr.name;
+                    }
                     lock(log) { log.WriteLine("New ingredients: " + combo); }
+                }
+            }
             return recipeFound;
+        }
         private void TestCurrentRecipe(RecipeSearchNode node)
+        {
             if (node.TestRecipe == null)
+            {
                 node.TestRecipe = new PaintRecipe();
                 node.TestRecipe.Reactions = reactions;
+            }
             node.TestRecipe.Clear();
             for (int i = 0; i < node.ReagentCount; ++i)

RecipeGeneratorWindow.cs

➞

Show inline comments

 /*
  * Copyright (c) 2015, Jason Maltzen
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
  The above copyright notice and this permission notice shall be included in
  all copies or substantial portions of the Software.
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  THE SOFTWARE.
 */
 using System;
 using System.IO;
 using System.Collections.Generic;
 using System.Collections.Concurrent;
 namespace DesertPaintLab
+{
     public partial class RecipeGeneratorWindow : Gtk.Window
+    {
         RecipeGenerator generator;
         PlayerProfile profile;
         bool canceling = false;
         bool running = false;
         bool pauseForCheckpoint = false;
         const long RECIPE_SAVE_INTERVAL = 30000; // msec between saving recipes
         const long CHECKPOINT_INTERVAL = 17000; // msec between saving out generator state
         const string STATE_FILE = "dp_generator_state";
         static Gtk.ListStore colorStore = new Gtk.ListStore(typeof(string));
         List<KeyValuePair<string, string>> missingReactions = new List<KeyValuePair<string, string>>();
         long lastProgressUpdate;
         long lastStatusUpdate;
         long lastProfileSave;
         long lastCheckpoint;
         static public Gtk.ListStore RecipeModel
+        {
             get
+            {
                 return colorStore;
+            }
+        }
         Gtk.ThreadNotify notifyFinished;
         Gtk.ThreadNotify notifyProgress;
         Gtk.ThreadNotify notifyNewRecipe;
         ConcurrentQueue<PaintRecipe> pendingNewRecipes = new ConcurrentQueue<PaintRecipe>();
         Gtk.ListStore reagentListStore;
         // end reagent view
         public RecipeGeneratorWindow(PlayerProfile profile) : base(Gtk.WindowType.Toplevel)
+        {
             this.profile = profile;
             this.Build();
             minIngredientsSpinButton.Value = 1; // TODO: read/save profile info
             maxIngredientsSpinButton.Value = 5; // TODO: read/save profile info
             maxRecipeSpinButton.Value = 20; // TODO: read/save profile info
             fullQuantitySpinButton.Value = 20; // TODO: read/save profile info
             fullQuantityDepthSpinButton.Value = 4; // TODO: read/save profile info
             fullQuantityDepthSpinButton.SetRange(0, ReagentManager.Names.Count);
             maxIngredientsSpinButton.SetRange(1, ReagentManager.Names.Count);
             minIngredientsSpinButton.SetRange(1, ReagentManager.Names.Count);
             Gtk.TreeViewColumn recipeColorColumn = new Gtk.TreeViewColumn();
             Gtk.CellRendererText recipeColumnCell = new Gtk.CellRendererText();
             recipeColorColumn.PackStart(recipeColumnCell, true);
             recipeColorColumn.Title = "Color";
             recipeList.AppendColumn(recipeColorColumn);
             recipeColorColumn.AddAttribute(recipeColumnCell, "text", 0);
             colorStore.Clear();
             colorStore.SetSortColumnId(0, Gtk.SortType.Ascending);
             recipeList.Model = RecipeModel;
             recipeList.Selection.Changed += OnColorSelected;
             recipeIngredientsView.AppendColumn("Quantity", new Gtk.CellRendererText(), "text", 0);
             recipeIngredientsView.AppendColumn("Ingredient", new Gtk.CellRendererText(), "text", 1);
             recipeIngredientsView.Model = new Gtk.ListStore(typeof(string), typeof(string));
             profile.LoadRecipes();
             // init UI
             foreach (KeyValuePair<string, PaintRecipe> pair in profile.Recipes)
+            {
                 if (pair.Value.IsValid)
+                {
                     string colorName = pair.Key;
                     colorStore.AppendValues(colorName);
+                }
+            }
             canceling = false;
             running = false;
             pauseForCheckpoint = false;
             generator = new RecipeGenerator(profile.Reactions);
             int threads;
             DesertPaintLab.Settings.Get("GeneratorThreads", out threads);
             if (threads <= 0) { threads = 15; }
             generator.MaxThreads = (uint)threads;
             generator.InitRecipes(profile.Recipes);
             generator.Progress += OnProgress;
             generator.Finished += OnFinished;
             generator.NewRecipe += OnNewRecipe;
             string stateFile = System.IO.Path.Combine(profile.Directory, STATE_FILE);
             if (System.IO.File.Exists(stateFile))
+            {
                 generator.LoadState(stateFile);
                 if (generator.CanResume)
+                {
                     beginButton.Label = "Restart";
                     stopResumeButton.Label = "Resume";
                     stopResumeButton.Sensitive = true;
                     maxRecipeSpinButton.Value = Math.Max(generator.MaxQuantity, 14); //
                     fullQuantitySpinButton.Value = generator.FullQuantity; // TODO: read/save profile info
                     fullQuantityDepthSpinButton.Value = generator.FullQuantityDepth; // TODO: read/save profile info
                     maxIngredientsSpinButton.Value = generator.MaxReagents;
+                }
+            }
             //generator.Log = System.IO.Path.Combine(profile.Directory, "dp_log.txt");
             countLabel.Text = String.Format("{0} / {1}", profile.RecipeCount, Palette.Count);
             Destroyed += OnDestroyed;
             notifyFinished = new Gtk.ThreadNotify(new Gtk.ReadyEvent(HandleFinished));
             notifyProgress = new Gtk.ThreadNotify(new Gtk.ReadyEvent(HandleProgress));
             notifyNewRecipe = new Gtk.ThreadNotify(new Gtk.ReadyEvent(HandleNewRecipe));
             // initialize reagent list
             // Add the columns to the TreeView
             Gtk.TreeViewColumn reagentEnabledColumn = new Gtk.TreeViewColumn ();
             reagentEnabledColumn.Title = "Enabled";
             Gtk.CellRendererToggle reagentEnabledCell = new Gtk.CellRendererToggle ();
             reagentEnabledCell.Activatable = true;
             reagentEnabledCell.Sensitive = true;
             reagentEnabledCell.Mode = Gtk.CellRendererMode.Activatable;
             reagentEnabledCell.Visible = true;
             reagentEnabledCell.Toggled += new Gtk.ToggledHandler(OnReagentEnableToggled);
             reagentEnabledColumn.PackStart (reagentEnabledCell, true);
             //reagentEnabledColumn.AddAttribute(reagentEnabledCell, "active", 0);
             Gtk.TreeViewColumn reagentNameColumn = new Gtk.TreeViewColumn ();
             reagentNameColumn.Title = "Ingredient";
             Gtk.CellRendererText reagentNameCell = new Gtk.CellRendererText ();
             reagentNameCell.Mode = Gtk.CellRendererMode.Inert;
             reagentNameColumn.PackStart (reagentNameCell, true);
             reagentNameColumn.AddAttribute(reagentNameCell, "text", 1);
             reagentNameColumn.Expand = true;
             Gtk.TreeViewColumn reagentCostColumn = new Gtk.TreeViewColumn ();
             reagentCostColumn.Title = "Cost";
             Gtk.CellRendererText reagentCostCell = new Gtk.CellRendererText ();
             reagentCostCell.Edited += OnReagentCostChanged;
             reagentCostCell.Editable = true;
             reagentCostCell.Sensitive = true;
             reagentCostCell.Mode = Gtk.CellRendererMode.Editable;
             reagentCostColumn.PackStart (reagentCostCell, true);
             //reagentCostColumn.AddAttribute(reagentCostCell, "text", 0);
             Gtk.TreeViewColumn reagentMaxColumn = new Gtk.TreeViewColumn ();
             reagentMaxColumn.Title = "Max";
             Gtk.CellRendererText reagentMaxCell = new Gtk.CellRendererText ();
             reagentMaxCell.Edited += OnReagentQuantityChanged;
             reagentMaxCell.Editable = true;
             reagentMaxCell.Sensitive = true;
             reagentCostCell.Mode = Gtk.CellRendererMode.Editable;
             reagentMaxColumn.PackStart (reagentMaxCell, true);
             //reagentMaxColumn.AddAttribute(reagentMaxCell, "text", 0);
             reagentListStore = new Gtk.ListStore(typeof(Reagent), typeof(string), typeof(Reagent), typeof(Reagent));
             foreach (string reagentName in ReagentManager.Names)
+            {
                 Reagent reagent = ReagentManager.GetReagent(reagentName);
                 reagentListStore.AppendValues(reagent, reagentName); // , reagent, reagent);
+            }
             reagentEnabledColumn.SetCellDataFunc (reagentEnabledCell, new Gtk.TreeCellDataFunc (RenderReagentToggle));
             reagentCostColumn.SetCellDataFunc (reagentCostCell, new Gtk.TreeCellDataFunc (RenderReagentCost));
             reagentMaxColumn.SetCellDataFunc (reagentMaxCell, new Gtk.TreeCellDataFunc (RenderReagentQuantity));
             // Assign the model to the TreeView
             reagentListView.Model = reagentListStore;
             reagentListView.Sensitive = true;
             reagentListView.AppendColumn(reagentEnabledColumn);
             reagentListView.AppendColumn(reagentNameColumn);
             reagentListView.AppendColumn(reagentCostColumn);
             reagentListView.AppendColumn(reagentMaxColumn);
             reagentListView.
             ShowAll();
+        }
         protected void OnMinIngredientsChanged(object sender, EventArgs e)
+        {
             Gtk.SpinButton button = (Gtk.SpinButton) sender;
             if (button.ValueAsInt > maxIngredientsSpinButton.ValueAsInt)
+            {
                 maxIngredientsSpinButton.Value = button.ValueAsInt;
+            }
             maxIngredientsSpinButton.SetRange(button.ValueAsInt, maxIngredientsSpinButton.Adjustment.Upper);
+        }
         protected void OnMaxIngredientsChanged(object sender, EventArgs e)
+        {
             Gtk.SpinButton button = (Gtk.SpinButton) sender;
             if (button.ValueAsInt < minIngredientsSpinButton.ValueAsInt)
+            {
                 minIngredientsSpinButton.Value = button.ValueAsInt;
+            }
             minIngredientsSpinButton.SetRange(1, button.ValueAsInt);
             // TODO: save profile setting
             // TODO: no longer permit resume
+        }
         protected void OnMaxRecipeChanged(object sender, EventArgs e)
+        {
             // TODO: save profile setting
             // TODO: no longer permit resume
+        }
         protected void OnFullQuantityDepthChanged(object sender, EventArgs e)
+        {
             // TODO: save profile setting
             // TODO: no longer permit resume
+        }
         protected void OnFullQuantityChanged(object sender, EventArgs e)
+        {
             // TODO: save profile setting
             // TODO: no longer permit resume
+        }
         protected void OnBegin(object sender, EventArgs e)
+        {
             minIngredientsSpinButton.Sensitive = false;
             maxIngredientsSpinButton.Sensitive = false;
             ExportToWikiAction.Sensitive = false;
             IngredientsAction.Sensitive = false;
             maxRecipeSpinButton.Sensitive = false;
             beginButton.Sensitive = false; // TODO: change to "pause"?
             stopResumeButton.Sensitive = true;
             fullQuantitySpinButton.Sensitive = false;
             fullQuantityDepthSpinButton.Sensitive = false;
             reagentListView.Sensitive = false;
             countLabel.Text = String.Format("{0} / {1}", profile.RecipeCount, Palette.Count);
             // TODO: hook up event notifications
             // - progress
             // - complete
             // - new recipe / recipe update
             // Total recipe search count
             //int current = ReagentManager.Names.Count;
             //long recipePermutations = 1;
             //for (int i = 0; i < maxIngredientsSpinButton.ValueAsInt; ++i)
             //{
             //    recipePermutations *= current;
             //    --current;
             //}
             //System.Console.WriteLine("Will search {0} reagent permutations.", recipePermutations);
             lastProgressUpdate = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
             lastStatusUpdate = lastProgressUpdate;
             lastProfileSave = lastProgressUpdate;
             lastCheckpoint = lastProgressUpdate;
             running = true;
             canceling = false;
             pauseForCheckpoint = false;
             stopResumeButton.Label = "Pause";
             generator.BeginRecipeGeneration((uint)maxRecipeSpinButton.ValueAsInt, (uint)minIngredientsSpinButton.Value, (uint)maxIngredientsSpinButton.ValueAsInt, (uint)fullQuantityDepthSpinButton.ValueAsInt, (uint)fullQuantitySpinButton.ValueAsInt);
+        }
         protected void OnStopResume(object sender, EventArgs e)
+        {
             if (generator != null)
+            {
                 if (running)
+                {
                     canceling = true;
                     pauseForCheckpoint = false;
                     generator.Stop();
+                }
                 else
+                {
                     // Resume previous run
                     ExportToWikiAction.Sensitive = false;
                     IngredientsAction.Sensitive = false;
                     reagentListView.Sensitive = false;
                     minIngredientsSpinButton.Sensitive = false;
                     maxIngredientsSpinButton.Sensitive = false;
                     maxRecipeSpinButton.Sensitive = false;
                     beginButton.Sensitive = false;
                     stopResumeButton.Sensitive = true;
                     fullQuantitySpinButton.Sensitive = false;
                     fullQuantityDepthSpinButton.Sensitive = false;
                     reagentListView.Sensitive = false;
                     lastProgressUpdate = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
                     lastStatusUpdate = lastProgressUpdate;
                     lastProfileSave = lastProgressUpdate;
                     lastCheckpoint = lastProgressUpdate;
                     canceling = false;
                     pauseForCheckpoint = false;
                     running = true;
                     stopResumeButton.Label = "Pause";
                     generator.ResumeRecipeGeneration();
+                }
+            }
+        }
         private void HandleFinished()
+        {
             generator.Wait();
             if (pauseForCheckpoint)
+            {
                 pauseForCheckpoint = false;
                 generator.SaveState(System.IO.Path.Combine(profile.Directory, STATE_FILE));
                 generator.ResumeRecipeGeneration();
+            }
             else
+            {
                 running = false;
                 beginButton.Sensitive = true;
                 ExportToWikiAction.Sensitive = true;
                 IngredientsAction.Sensitive = true;
                 stopResumeButton.Sensitive = false;
                 minIngredientsSpinButton.Sensitive = true;
                 maxIngredientsSpinButton.Sensitive = true;
                 maxRecipeSpinButton.Sensitive = true;
                 fullQuantitySpinButton.Sensitive = true;
                 fullQuantityDepthSpinButton.Sensitive = true;
                 reagentListView.Sensitive = true;
                 //generator = null; // don't. Hang on to generator for resume.
                 profile.SaveRecipes();
                 if (canceling)
+                {
                     generator.SaveState(System.IO.Path.Combine(profile.Directory, STATE_FILE));
                     stopResumeButton.Label = "Resume";
                     stopResumeButton.Sensitive = true;
                     beginButton.Label = "Restart";
+                }
                 else
+                {
                     System.IO.File.Delete(System.IO.Path.Combine(profile.Directory, STATE_FILE));
+                }
+            }
+        }
         protected void OnFinished(object sender, EventArgs args)
+        {
             notifyFinished.WakeupMain();
             //Gtk.Application.Invoke(delegate {
             //    HandleFinished();
             //});
+        }
         private void HandleNewRecipe()
+        {
             progressBar.Pulse();
             PaintRecipe recipe = null;
             if (pendingNewRecipes.TryDequeue(out recipe))
+            {
                 string recipeColor = Palette.FindNearest(recipe.ReactedColor);
                 // TODO: Add item to recipe list only if not already listed
                 bool exists = false;
                 Gtk.TreeIter iter;
                 if (colorStore.GetIterFirst(out iter))
+                {
                     do
+                    {
                         string color = (string)colorStore.GetValue(iter, 0);
                         if (color.Equals(recipeColor))
+                        {
                             exists = true;
                             break;
+                        }
                     } while (colorStore.IterNext(ref iter));
+                }
                 if (!exists)
+                {
                     //Console.WriteLine("Add new recipe for {0}", args.Color);
                     //    bool isMissingReactions = args.Recipe.CheckMissingReactions(ref missingReactions);
                     //    string missingReactionLabel = isMissingReactions ? "X" : "";
                     colorStore.AppendValues(recipeColor); // , missingReactionLabel);
                     countLabel.Text = String.Format("{0} / {1}", profile.RecipeCount+1, Palette.Count);
+                }
                 profile.SetRecipe(recipe);
                 long progressTime = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
                 long delta = progressTime - lastProfileSave;
                 if (delta >= RECIPE_SAVE_INTERVAL)
+                {
                     profile.SaveRecipes();
                     lastProfileSave = progressTime;
+                }
+            }
+        }
         protected void OnNewRecipe(object sender, NewRecipeEventArgs args)
+        {
             PaintRecipe recipe = new PaintRecipe(args.Recipe); // copy it, so the worker thread can release
             lock(this) {
                 pendingNewRecipes.Enqueue(recipe);
+            }
             notifyNewRecipe.WakeupMain();
             //Gtk.Application.Invoke(delegate {
             //    HandleNewRecipe();
             //});
+        }
         private void HandleProgress()
+        {
             long progressTime = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
             long delta = progressTime - lastProgressUpdate;
             if (delta > 30)
+            {
                 lastProgressUpdate = progressTime;
                 progressBar.Pulse();
+            }
             delta = progressTime - lastStatusUpdate;
             if (delta > 500)
+            {
                 lastStatusUpdate = progressTime;
                 statusLabel.Text = String.Format("Recipes searched: {0:N00}", generator.RecipeCount);
+            }
             delta = progressTime - lastCheckpoint;
             if (delta > CHECKPOINT_INTERVAL)
+            {
                 lastCheckpoint = progressTime;
                 pauseForCheckpoint = true;
                 generator.Stop();
+            }
+        }
         protected void OnProgress(object sender, EventArgs args)
+        {
             notifyProgress.WakeupMain();
+        }
         protected void OnColorSelected(object o, EventArgs args)
+        {
             Gtk.TreeModel model;
             Gtk.TreeIter iter;
             Gtk.TreeSelection selection = recipeList.Selection;
             if ((selection != null) && selection.GetSelected(out model, out iter))
+            {
                 string colorName = (string)colorStore.GetValue(iter, 0);
                 PaintRecipe recipe;
                 if (profile.Recipes.TryGetValue(colorName, out recipe))
+                {
                     Gtk.ListStore store = (Gtk.ListStore)recipeIngredientsView.Model;
                     store.Clear();
                     if (recipe.CheckMissingReactions(ref missingReactions))
+                    {
                         statusLabel.Text = "WARNING: This recipe includes reactions that have not yet been recorded.";
+                    }
                     foreach (PaintRecipe.RecipeIngredient ingredient in recipe.Ingredients)
+                    {
                         store.AppendValues(ingredient.quantity.ToString(), ingredient.name);
+                    }
+                }
                 paintSwatch.Color = recipe.ReactedColor;
+            }
+        }
         protected void OnExportToWiki(object sender, EventArgs e)
+        {
             Gtk.FileChooserDialog fileDialog =
                 new Gtk.FileChooserDialog("Select destination file.",
                         this, Gtk.FileChooserAction.Save,
                         Gtk.Stock.Cancel, Gtk.ResponseType.Cancel,
                         Gtk.Stock.Save, Gtk.ResponseType.Accept);
             Gtk.ResponseType resp = (Gtk.ResponseType)fileDialog.Run();
             if (resp == Gtk.ResponseType.Accept)
+            {
                 string fileName = fileDialog.Filename;
                 string directory = fileDialog.CurrentFolder;
                 profile.ExportWikiRecipes(System.IO.Path.Combine(directory, fileName));
+            }
             fileDialog.Destroy();
+        }
         protected void OnShowIngredients(object sender, EventArgs e)
+        {
             ReagentWindow win = new ReagentWindow(profile);
             win.Show();
+        }
         protected void OnDestroyed(object o, EventArgs args)
+        {
             if (running)
+            {
                 // window closed while generator running: stop and save
                 generator.Finished -= OnFinished;
                 generator.Progress -= OnProgress;
                 generator.NewRecipe -= OnNewRecipe;
                 generator.Stop();
                 generator.Wait();
                 generator.SaveState(System.IO.Path.Combine(profile.Directory, STATE_FILE));
+            }
+        }
         // Reagent view handling
         private void RenderReagentToggle (Gtk.TreeViewColumn column, Gtk.CellRenderer cell, Gtk.TreeModel model, Gtk.TreeIter iter)
+        {
             Reagent reagent = (Reagent) model.GetValue (iter, 0);
             Gtk.CellRendererToggle toggle = (cell as Gtk.CellRendererToggle);
             toggle.Active = reagent.Enabled;
             toggle.Activatable = !reagent.IsCatalyst;
             toggle.Mode = reagent.IsCatalyst ? Gtk.CellRendererMode.Inert : Gtk.CellRendererMode.Activatable;
+        }
         private void RenderReagentCost (Gtk.TreeViewColumn column, Gtk.CellRenderer cell, Gtk.TreeModel model, Gtk.TreeIter iter)
+        {
             Reagent reagent = (Reagent) model.GetValue (iter, 0);
             (cell as Gtk.CellRendererText).Text = reagent.Cost.ToString();
+        }
         private void RenderReagentQuantity (Gtk.TreeViewColumn column, Gtk.CellRenderer cell, Gtk.TreeModel model, Gtk.TreeIter iter)
+        {
             Reagent reagent = (Reagent) model.GetValue (iter, 0);
             (cell as Gtk.CellRendererText).Text = reagent.RecipeMax.ToString();
+        }
         private void OnReagentCostChanged(object o, Gtk.EditedArgs args)
+        {
             uint newCost;
             if (uint.TryParse(args.NewText, out newCost))
+            {
                 Gtk.TreeIter iter;
                 reagentListStore.GetIter (out iter, new Gtk.TreePath (args.Path));
                 Reagent reagent = (Reagent) reagentListStore.GetValue (iter, 0);
                 if (reagent.Cost != newCost)
+                {
                     reagent.Cost = newCost;
                     SaveReagentSettings();
+                }
+            }
+        }
         private void OnReagentQuantityChanged(object o, Gtk.EditedArgs args)
+        {
             uint newMax;
             if (uint.TryParse(args.NewText, out newMax))
+            {
                 Gtk.TreeIter iter;
                 reagentListStore.GetIter (out iter, new Gtk.TreePath (args.Path));
                 Reagent reagent = (Reagent) reagentListStore.GetValue (iter, 0);
                 if (reagent.RecipeMax != newMax)
+                {
                     reagent.RecipeMax = newMax;
                     SaveReagentSettings();
+                }
+            }
+        }
         private void OnReagentEnableToggled(object o, Gtk.ToggledArgs args)
+        {
             Gtk.TreeIter iter;
             reagentListStore.GetIter (out iter, new Gtk.TreePath (args.Path));
             Reagent reagent = (Reagent) reagentListStore.GetValue (iter, 0);
             reagent.Enabled = !reagent.Enabled;
             SaveReagentSettings();
+        }
         private void SaveReagentSettings()
+        {
             // save out state
             ReagentManager.SaveProfileReagents(profile.ReagentFile);
+        }
         protected void OnCopyRecipeToClipboard(object sender, EventArgs e)
+        {
             Gtk.TreeModel model;
             Gtk.TreeIter iter;
             Gtk.Clipboard clipboard = recipeIngredientsView.GetClipboard(Gdk.Selection.Clipboard);
             Gtk.TreeSelection selection = recipeList.Selection;
             if ((selection != null) && selection.GetSelected(out model, out iter))
+            {
                 string colorName = (string)colorStore.GetValue(iter, 0);
                 PaintRecipe recipe;
                 if (profile.Recipes.TryGetValue(colorName, out recipe))
+                {
                     clipboard.Text = recipe.ToString();
+                }
+            }
+        }
         protected void OnCopyRecipeListToClipboard(object sender, EventArgs e)
+        {
             Gtk.Clipboard clipboard = recipeList.GetClipboard(Gdk.Selection.Clipboard);
             StringWriter writer = new StringWriter();
             profile.ExportWikiFormat(writer);
             clipboard.Text = writer.ToString();
+        }

0 comments (0 inline, 0 general)