public partial class MainWindow : Gtk.Window

{

	bool unsavedData = false;

	bool shouldShutDown = false;

	string appDataPath;

        reagents[2] = null;

        string colorsPath = FileUtils.FindApplicationResourceFile("colors.txt");

		Palette.Load(colorsPath);

        string ingredientsPath = FileUtils.FindApplicationResourceFile("ingredients.txt");

        ReagentManager.Load(ingredientsPath);

		Build();

				// Set profile name.

				SetProfileName(newProfileDialog.ProfileName);

			}

		}

		newProfileDialog.Destroy();

		if (profileSelected)

		{

		}

		return profileSelected;

		if (NewProfile())

		{

		}

	}

		}

		if (profileSelected)

		{

		}

	}

		AboutDialog aboutDialog = new AboutDialog();

        aboutDialog.ProgramName = "Desert Paint Lab";

        aboutDialog.Comments = "Desert Paint Lab paint reaction recorder for A Tale in the Desert";

        aboutDialog.Authors = new string [] {"Tess Snider", "Jason Maltzen"};

        //aboutDialog.Website = "http://www.google.com/";

            {

                profile.Import(targetFile);

            }

        }

        fileDialog.Destroy();

    }

        byte CalculateColor(int baseSum, uint pigmentCount, int reactSum)

        {

            // Changed to Math.Floor from Math.Round, since Round appears to be incorrect.

        }

        // Compute the color including reactions based on the player's profile

 THE SOFTWARE.

*/

using System;

using System.IO;

using System.IO.Compression;

                return current;

            }

        }

		public PlayerProfile(string name, string directory)

		{

            }

        }

		{

			// Create new directory.

			System.IO.Directory.CreateDirectory(directory);

            if (!System.IO.Directory.Exists(templatePath))

            {

            }

			DirectoryInfo di = new DirectoryInfo(templatePath);

			foreach (FileInfo file in templateFiles)

			{

			}

		}

		public void ConvertFromPP(string ppFile, string dpFile)

            ZipFile.CreateFromDirectory(directory, file);

		}

		{

			string line;

			reactions.Clear();

			ReagentManager.InitializeReactions(ref reactions);

			using (StreamReader reader = new StreamReader(reactFile))

			{

				while ((line = reader.ReadLine()) != null) 

					reactions.Set(reagent1, reagent2, new Reaction(int.Parse(tokens[2]), int.Parse(tokens[3]), int.Parse(tokens[4])));

				}

			}

		}

		public void Save()

        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 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

                recipes.Add(color.Name, new PaintRecipe());

                recipeCosts.Add(color.Name, uint.MaxValue);

            }

        }

        public SortedDictionary<string, PaintRecipe> Recipes

            costSortedReagents.Sort(new ReagentCostSort());

        }

        {

            if (running)

            {

            }

            this.MaxQuantity = maxQuantity;

            this.MaxReagents = maxReagents;

            this.FullQuantity = fullQuantity;

            this.FullQuantityDepth = fullQuantityDepth;

                }

            }

            this.MaxReagents = (uint)Math.Min(enabledReagentCount, this.MaxReagents);

            while (!searchQueue.IsEmpty)

            {

                    initialNode.FullQuantity = FullQuantity;

                    initialNode.FullQuantityDepth = FullQuantityDepth;

                    initialNode.MaxQuantity = maxQuantity;

                    initialNode.MaxReagents = maxReagents;

                    searchQueue.Enqueue(initialNode);

                }

            if (log != null)

            {

            }

            // start worker threads to do the actual work

            using (StreamWriter writer = new StreamWriter(file, false))

            {

                writer.WriteLine("MaxReagents: {0}", MaxReagents);

                writer.WriteLine("FullQuantityDepth: {0}", FullQuantityDepth);

                writer.WriteLine("FullQuantity: {0}", FullQuantity);

                        string value = match.Groups["value"].Value;

                        switch(match.Groups["key"].Value)

                        {

                            case "MaxReagents":

                                MaxReagents = uint.Parse(value);

                                break;

                            case "FullQuantityDepth":

                                FullQuantityDepth = uint.Parse(value);

                                    RecipeSearchNode node = new RecipeSearchNode(costSortedReagents);

                                    node.FullQuantity = FullQuantity;

                                    node.FullQuantityDepth = FullQuantityDepth;

                                    node.MaxReagents = MaxReagents;

                                    node.MaxQuantity = MaxQuantity;

                                    success = success && node.LoadState(reader);

            {

                if (!node.AddNextReagent())

                {

                    {

                        node.RemoveLastReagent();

                    }

                    {

                        // done

                        return false;

                    }

                    uint nextReagent = node.NextFreeReagent(node.LastReagent);

                    {

                        // No more reagents to try at this level

                        node.RemoveLastReagent();

                        {

                            nextReagent = node.NextFreeReagent(node.LastReagent);

                        }

                    }

                    {

                        // done

                        return false;

                do {

                    recipeFound = false;

                    // back out until we find a node that can be incremented

                    {

                        {

                            if (node.LastReagent < (totalReagents - 1))

                            {

                                    // shouldn't happen

                                    //Console.WriteLine("No available reagents at depth {0}!", node.ReagentCount);

                                    node.RemoveLastReagent();

                                    {

                                        // just popped the last reagent at the top level

                                        ++currentDepth;

                            {

                                //Console.WriteLine("Pop last reagent");

                                node.RemoveLastReagent();

                                {

                                    // just popped the last reagent at the top level

                                    ++currentDepth;

                            }

                        }

                        // fill in the nodes up to the current depth

                        {

                            recipeFound = true;

                            while (node.ReagentCount < currentDepth)

                            }

                        }

                    }

                if (recipeFound)

                {

                    break;

        {

            this.profile = profile;

            this.Build();

            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);

            Gtk.TreeViewColumn recipeColorColumn = new Gtk.TreeViewColumn();

            ShowAll();

        }

        protected void OnMaxIngredientsChanged(object sender, EventArgs e)

        {

            // TODO: save profile setting

            // TODO: no longer permit resume

        }

        protected void OnBegin(object sender, EventArgs e)

        {

            maxIngredientsSpinButton.Sensitive = false;

            ExportToWikiAction.Sensitive = false;

            IngredientsAction.Sensitive = false;

            pauseForCheckpoint = false;

            stopResumeButton.Label = "Pause";

        }

        protected void OnStopResume(object sender, EventArgs e)

                    ExportToWikiAction.Sensitive = false;

                    IngredientsAction.Sensitive = false;

                    reagentListView.Sensitive = false;

                    maxIngredientsSpinButton.Sensitive = false;

                    maxRecipeSpinButton.Sensitive = false;

                    beginButton.Sensitive = false;

                ExportToWikiAction.Sensitive = true;

                IngredientsAction.Sensitive = true;

                stopResumeButton.Sensitive = false;

                maxIngredientsSpinButton.Sensitive = true;

                maxRecipeSpinButton.Sensitive = true;

                fullQuantitySpinButton.Sensitive = true;

            }

        }

        public uint CurrentTargetQuantity { get; set; }

        public uint MaxQuantity { get; set; }

        public uint UsedQuantity { get; private set; }

        public uint CatalystCount { get; set; }

        public uint FullQuantityDepth { get; set; }

        public uint FullQuantity { get; set; }

        uint maxReagents;

        public uint MaxReagents

                    reagentInUse[reagentIdx] = true;

                }

            }

            MaxReagents = (uint)nextReagentPos; // better set this later!

            UsedQuantity = 0;

        }

            }

            this.reagents[nextReagentPos++] = NextFreeReagent(startReagent);

            //Console.WriteLine("Added reagent {0} at pos {1}", this.reagents[nextReagentPos-1], nextReagentPos-1);

            MaxReagents = 1;

            UsedQuantity = 0;

        }

                reagentInUse[reagentIdx] = false;

            }

            this.reagents[nextReagentPos++] = NextFreeReagent(0);

            MaxReagents = 1;

            UsedQuantity = 0;

        }

        public void SaveState(StreamWriter writer)

        {

            writer.WriteLine("---SearchNode---");

            writer.WriteLine("MaxReagents: {0}", MaxReagents);

            writer.WriteLine("Reagents: {0}", nextReagentPos);

            for (int i = 0; i < nextReagentPos; ++i)

            writer.WriteLine("MaxQuantity: {0}", MaxQuantity);

            writer.WriteLine("UsedQuantity: {0}", UsedQuantity);

            writer.WriteLine("CatalystCount: {0}", CatalystCount);

            writer.WriteLine("FullQuantity: {0}", FullQuantity);

            writer.WriteLine("FullQuantityDepth: {0}", FullQuantityDepth);

            writer.WriteLine("---EndNode---");

                                MaxQuantity = value;

                            }

                            break;

                        case "MaxReagents":

                            {

                                uint value = uint.Parse(match.Groups[2].Value);

                            break;

                        case "InitialCount":

                            {

                            }

                            break;

                        case "FullQuantity":

		private global::Gtk.HBox hbox2;

		private global::Gtk.SpinButton maxIngredientsSpinButton;

		private global::Gtk.Label label3;

			this.hbox2.Name = "hbox2";

			this.hbox2.Spacing = 6;

			// Container child hbox2.Gtk.Box+BoxChild

			w3.Position = 0;

			w3.Expand = false;

			w3.Fill = false;

			// Container child hbox2.Gtk.Box+BoxChild

			w4.Position = 1;

			w4.Expand = false;

			w4.Fill = false;

			w5.Expand = false;

			w5.Fill = false;

			// Container child vbox8.Gtk.Box+BoxChild

			this.hseparator3 = new global::Gtk.HSeparator ();

			this.hseparator3.Name = "hseparator3";

			this.vbox8.Add (this.hseparator3);

			// Container child vbox8.Gtk.Box+BoxChild

			this.hbox4 = new global::Gtk.HBox ();

			this.hbox4.Name = "hbox4";

			this.hbox4.Spacing = 6;

			// Container child hbox4.Gtk.Box+BoxChild

			this.maxRecipeSpinButton.CanFocus = true;

			this.maxRecipeSpinButton.Name = "maxRecipeSpinButton";

			this.maxRecipeSpinButton.Adjustment.PageIncrement = 10;

			this.maxRecipeSpinButton.ClimbRate = 1;

			this.maxRecipeSpinButton.Numeric = true;

			this.hbox4.Add (this.maxRecipeSpinButton);

			// Container child hbox4.Gtk.Box+BoxChild

			this.label4 = new global::Gtk.Label ();

			this.label4.Name = "label4";

			this.label4.UseMarkup = true;

			this.label4.Wrap = true;

			this.hbox4.Add (this.label4);

			this.vbox8.Add (this.hbox4);

			// Container child vbox8.Gtk.Box+BoxChild

			this.hseparator4 = new global::Gtk.HSeparator ();

			this.hseparator4.Name = "hseparator4";

			this.vbox8.Add (this.hseparator4);

			// Container child vbox8.Gtk.Box+BoxChild

			this.hbox5 = new global::Gtk.HBox ();

			this.hbox5.Name = "hbox5";

			this.fullQuantityDepthSpinButton.Adjustment.PageIncrement = 10;

			this.fullQuantityDepthSpinButton.ClimbRate = 1;

			this.fullQuantityDepthSpinButton.Numeric = true;

			this.hbox5.Add (this.fullQuantityDepthSpinButton);