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

            canceling = false;

            running = false;

            pauseForCheckpoint = false;

            generator = new RecipeGenerator(profile.Reactions);

            int threads;

            DesertPaintLab.AppSettings.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, PAINT_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.MaxConcentration, 14); //

                    fullQuantitySpinButton.Value = generator.FullQuantity; // TODO: read/save profile info

                    fullQuantityDepthSpinButton.Value = generator.FullQuantityDepth; // TODO: read/save profile info

                    maxIngredientsSpinButton.Value = generator.MaxReagents;

                    checkButtonRibbon.Active = false;

                }

            }

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

            bool ribbons = false;

            profile.ProfileSettings.Get("Generator.Ribbons", out ribbons);

            if (ribbons)

            {

                checkButtonRibbon.Active = true;

                InitStateForRibbons();

            }

            else

            {

                checkButtonRibbon.Active = false;

                InitStateForPaint();

            }

            ShowAll();

        }

        private void InitStateForPaint()

        {

            maxRecipeSpinButton.Adjustment.Lower = PaintRecipe.PAINT_RECIPE_MIN_CONCENTRATION;

            fullQuantitySpinButton.Adjustment.Upper = 30;

            if (generator == null)

            {

                generator = new RecipeGenerator(profile.Reactions);

                int threads;

                DesertPaintLab.AppSettings.Get("GeneratorThreads", out threads);

                if (threads <= 0) { threads = 15; }

                generator.MaxThreads = (uint)threads;

                generator.Progress += OnProgress;

                generator.Finished += OnFinished;

                generator.NewRecipe += OnNewRecipe;

            }

            generator.InitRecipes(profile.Recipes);

            string stateFile = System.IO.Path.Combine(profile.Directory, PAINT_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.MaxConcentration, 14); //

                    fullQuantitySpinButton.Value = generator.FullQuantity; // TODO: read/save profile info

                    fullQuantityDepthSpinButton.Value = generator.FullQuantityDepth; // TODO: read/save profile info

                    maxIngredientsSpinButton.Value = generator.MaxReagents;

                }

            }

            else

            {

                beginButton.Label = "Start";

                stopResumeButton.Label = "Stop";

                stopResumeButton.Sensitive = false;

                maxRecipeSpinButton.Value = 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);

            colorStore.Clear();

            foreach (KeyValuePair<string, PaintRecipe> pair in profile.Recipes)

            {

                if (pair.Value.IsValidForConcentration(PaintRecipe.PAINT_RECIPE_MIN_CONCENTRATION))

                {

                    string colorName = pair.Key;

                    colorStore.AppendValues(colorName);

                }

            }

            recipeList.Show();

        }

        private void InitStateForRibbons()

        {

            maxRecipeSpinButton.Adjustment.Lower = PaintRecipe.RIBBON_RECIPE_MIN_CONCENTRATION;

            fullQuantitySpinButton.Adjustment.Upper = 100;

            if (generator == null)

            {

                generator = new RecipeGenerator(profile.Reactions);

                int threads;

                DesertPaintLab.AppSettings.Get("GeneratorThreads", out threads);

                if (threads <= 0) { threads = 15; }

                generator.MaxThreads = (uint)threads;

                generator.Progress += OnProgress;

                generator.Finished += OnFinished;

                generator.NewRecipe += OnNewRecipe;

            }

            generator.InitRecipes(profile.RibbonRecipes);

            string stateFile = System.IO.Path.Combine(profile.Directory, RIBBON_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.MaxConcentration, PaintRecipe.RIBBON_RECIPE_MIN_CONCENTRATION); //

                    fullQuantitySpinButton.Value = generator.FullQuantity; // TODO: read/save profile info

                    fullQuantityDepthSpinButton.Value = generator.FullQuantityDepth; // TODO: read/save profile info

                    maxIngredientsSpinButton.Value = generator.MaxReagents;

                }

            }

            else

            {

                beginButton.Label = "Start";

                stopResumeButton.Label = "Stop";

                stopResumeButton.Sensitive = false;

                maxRecipeSpinButton.Value = PaintRecipe.RIBBON_RECIPE_MIN_CONCENTRATION

;

                //fullQuantitySpinButton.Value = generator.FullQuantity; // TODO: read/save profile info

                //fullQuantityDepthSpinButton.Value = generator.FullQuantityDepth; // TODO: read/save profile info

                //maxIngredientsSpinButton.Value = generator.MaxReagents;

            }

            countLabel.Text = String.Format("{0} / {1}", profile.RibbonCount, Palette.Count);

            colorStore.Clear();

            foreach (KeyValuePair<string, PaintRecipe> pair in profile.RibbonRecipes)

            {

                if (pair.Value.IsValidForConcentration(PaintRecipe.RIBBON_RECIPE_MIN_CONCENTRATION))

                {

                    string colorName = pair.Key;

                    colorStore.AppendValues(colorName);

                }

            }

            recipeList.Show();

        }

        public PlayerProfile Profile {

            set {

                if (profile != value) {

                    // TODO: ensure not running

                    profile = value;

                    profile.LoadRecipes();

                    generator = new RecipeGenerator(profile.Reactions);

                    int threads;

                    DesertPaintLab.AppSettings.Get("GeneratorThreads", out threads);

                    if (threads <= 0) { threads = 15; }

                    generator.MaxThreads = (uint)threads;

                    generator.Progress += OnProgress;

                    generator.Finished += OnFinished;

                    generator.NewRecipe += OnNewRecipe;

                    if (checkButtonRibbon.Active)

                    {

                        InitStateForRibbons();

                    }

                    else

                    {

                        InitStateForPaint();

                    }

                }

            }

        }

        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;

            //TODO ExportToWikiAction.Sensitive = false;

            maxRecipeSpinButton.Sensitive = false;

            beginButton.Sensitive = false; // TODO: change to "pause"?

            stopResumeButton.Sensitive = true;

            fullQuantitySpinButton.Sensitive = false;

            fullQuantityDepthSpinButton.Sensitive = false;

            reagentListView.Sensitive = false;

            checkButtonRibbon.Sensitive = false;

            countLabel.Text = String.Format("{0} / {1}", checkButtonRibbon.Active ? profile.RibbonCount : 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";

            if (Started != null)

            {

                Started(this, null);

            }

        }

        protected void OnStopResume(object sender, EventArgs e)

        {

            if (generator != null)

            {

                if (running)

                {

                    canceling = true;

                    pauseForCheckpoint = false;

                    generator.Stop();

                }

                else

                {

                    // Resume previous run

                    //TODO ExportToWikiAction.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;

                    checkButtonRibbon.Sensitive = false;

                    lastProgressUpdate = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;

                    lastStatusUpdate = lastProgressUpdate;

                    lastProfileSave = lastProgressUpdate;

                    lastCheckpoint = lastProgressUpdate;

                    canceling = false;

                    pauseForCheckpoint = false;

                    running = true;

                    stopResumeButton.Label = "Pause";

                    if (Started != null)

                    {

                        Started(this, null);

                    }

                    generator.ResumeRecipeGeneration();

                }

            }

        }

        private void HandleFinished()

        {

            generator.Wait();

            if (pauseForCheckpoint)

            {

                pauseForCheckpoint = false;

                generator.SaveState(System.IO.Path.Combine(profile.Directory, checkButtonRibbon.Active ? RIBBON_STATE_FILE : PAINT_STATE_FILE));

                generator.ResumeRecipeGeneration();

            }

            else

            {

                running = false;

                beginButton.Sensitive = true;

                //TODO ExportToWikiAction.Sensitive = true;

                stopResumeButton.Sensitive = false;

                minIngredientsSpinButton.Sensitive = true;

                maxIngredientsSpinButton.Sensitive = true;

                maxRecipeSpinButton.Sensitive = true;

                fullQuantitySpinButton.Sensitive = true;

                fullQuantityDepthSpinButton.Sensitive = true;

                reagentListView.Sensitive = true;

                checkButtonRibbon.Sensitive = true;

                //generator = null; // don't. Hang on to generator for resume.

                profile.SaveRecipes();

                if (canceling)

                {

                    generator.SaveState(System.IO.Path.Combine(profile.Directory, checkButtonRibbon.Active ? RIBBON_STATE_FILE : PAINT_STATE_FILE));

                    stopResumeButton.Label = "Resume";

                    stopResumeButton.Sensitive = true;

                    beginButton.Label = "Restart";

                }

                else

                {

                    System.IO.File.Delete(System.IO.Path.Combine(profile.Directory, checkButtonRibbon.Active ? RIBBON_STATE_FILE : PAINT_STATE_FILE));

                }

                if (Stopped != null)

                {

                    Stopped(this, null);

                }

            }

        }

        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}", recipeColor);

                    //    bool isMissingReactions = args.Recipe.CheckMissingReactions(ref missingReactions);

                    //    string missingReactionLabel = isMissingReactions ? "X" : "";

                    colorStore.AppendValues(recipeColor); // , missingReactionLabel);

                    countLabel.Text = String.Format("{0} / {1}", (checkButtonRibbon.Active ? profile.RibbonCount : profile.RecipeCount)+1, Palette.Count);

                }

                //else

                //{

                //    Console.WriteLine("Updated recipe for {0}", recipeColor);

                //}

                if (checkButtonRibbon.Active)

                {

                    profile.SetRibbonRecipe(recipe);

                }

                else

                {

                    profile.SetRecipe(recipe);

                }

                long progressTime = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;

                long delta = progressTime - lastProfileSave;

                if (delta >= RECIPE_SAVE_INTERVAL)

                {

                    profile.SaveRecipes();

                    lastProfileSave = progressTime;

                }

                Gtk.TreeModel model;

                Gtk.TreeSelection selection = recipeList.Selection;

                if ((selection != null) && selection.GetSelected(out model, out iter))

                {

                    string colorName = (string)colorStore.GetValue(iter, 0);

                    if (colorName.Equals(recipeColor))

                    {

                        ShowColor(recipe);

                    }

                }

            }

        }

        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;

                if (SetStatus != null)

                {

                    SetStatus(this, new StatusUpdateEventArgs(String.Format("Recipes searched: {0:N00}", generator.RecipeCount)));

                }

                //TODO 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();

        }

        private void ShowColor(PaintRecipe recipe)

        {

            Gtk.ListStore store = (Gtk.ListStore)recipeIngredientsView.Model;

            store.Clear();

            if (recipe.CheckMissingReactions(ref missingReactions))

            {

                if (SetStatus != null)

                {

                    SetStatus(this, new StatusUpdateEventArgs("WARNING: This recipe includes reactions that have not yet been recorded."));

                }

                //TODO 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 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 (checkButtonRibbon.Active)

                {

                    if (profile.RibbonRecipes.TryGetValue(colorName, out recipe))

                    {

                        ShowColor(recipe);

                    }

                }

                else

                {

                    if (profile.Recipes.TryGetValue(colorName, out recipe))

                    {

                        ShowColor(recipe);

                    }

                }

            }

        }

        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, checkButtonRibbon.Active ? RIBBON_STATE_FILE : PAINT_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 (checkButtonRibbon.Active)

                {

                    if (profile.RibbonRecipes.TryGetValue(colorName, out recipe))

                    {

                        clipboard.Text = recipe.ToString();

                    }

                }

                else

                {

                    if (profile.Recipes.TryGetValue(colorName, out recipe))

                    {

                        clipboard.Text = recipe.ToString();

                    }

                }

            }

        }

        protected void OnRecipesToggled(object sender, EventArgs e)

        {

            if (checkButtonRibbon.Active)

            {

                // changed to ribbons

                InitStateForRibbons();

            }

            else

            {

                // changed to paints

                InitStateForPaint();

            }

            profile.ProfileSettings.Set("Generator.Ribbons", checkButtonRibbon.Active);

            profile.Save();