*/

using System;

using System.IO;

namespace DesertPaintLab

{

    // ReactionRecorder - business logic for recording paint reactions

    public class ReactionRecorder

    {

        public delegate void CaptureProgressHandler(int x, int y);

        public CaptureProgressHandler OnCaptureProgress;

        const int COLOR_TOLERANCE = 3;

        const InterfaceSize DEFAULT_INTERFACE_SIZE = InterfaceSize.Small;

        public static readonly int[] SWATCH_HEIGHT = 

        {

            24, // tiny

            24, // small

            24, // medium

            24, // large

            24 // huge

        };

        public static readonly int[] SWATCH_WIDTH =

        {

            260, // tiny

            260, // small

            260, // medium

            274, // large

            304 // huge

        };

        public static readonly int[] COLOR_BAR_WIDTH =

        {

            306, // tiny

            306, // small

            306, // medium

            320, // large

            350 // huge

        };

        public static readonly int[] RED_BAR_SPACING =

        {

            32, // tiny

            32, // small

            32, // medium

            32, // large

            32 // huge

        };

        public static readonly int[] GREEN_BAR_SPACING =

        {

            42, // tiny

            42, // small

            42, // medium

            42, // large

            42 // huge

        };

        public static readonly int[] BLUE_BAR_SPACING =

        {

            52, // tiny

            52, // small

            52, // medium

            52, // large

            52 // huge

        };

        // width to test on ends of swatch (10% on either end)

        public static readonly int[] SWATCH_TEST_WIDTH =

        {

            26, // tiny

            26, // small

            26, // medium

            28, // large

            31  // huge

        };

        int swatchHeight = SWATCH_HEIGHT[(int)DEFAULT_INTERFACE_SIZE];

        int swatchWidth = SWATCH_WIDTH[(int)DEFAULT_INTERFACE_SIZE];

        int swatchTestWidth = SWATCH_TEST_WIDTH[(int)DEFAULT_INTERFACE_SIZE];

        int colorBarWidth = COLOR_BAR_WIDTH[(int)DEFAULT_INTERFACE_SIZE];

        int redBarSpacing = RED_BAR_SPACING[(int)DEFAULT_INTERFACE_SIZE];

        int greenBarSpacing = GREEN_BAR_SPACING[(int)DEFAULT_INTERFACE_SIZE];

        int blueBarSpacing = BLUE_BAR_SPACING[(int)DEFAULT_INTERFACE_SIZE];

        public int SwatchHeight {  get { return swatchHeight; } }

        public int SwatchWidth {  get { return swatchWidth; } }

        public int ColorBarWidth { get { return colorBarWidth;  } }

        public int RedBarSpacing {  get { return redBarSpacing; } }

        public int GreenBarSpacing { get { return greenBarSpacing; } }

        public int BlueBarSpacing {  get { return blueBarSpacing; } }

        // Current Status

        public bool IsCaptured { get; private set; }

        public int X { get; private set; }

        public int Y { get; private set; }

        public int ScreenWidth { get; private set; }

        public int ScreenHeight { get; private set; }

        public int RedBarX { get; private set; }

        public int RedBarY { get; private set; }

        int pixelMultiplier = 1;

        InterfaceSize interfaceSize;

        bool firstRun = true;

        int lastSwatchX = -1;

        int lastSwatchY = -1;

        public int SwatchX { get { return lastSwatchX; } }

        public int SwatchY { get { return lastSwatchY; } }

        private static ReactionRecorder _instance;

        public static ReactionRecorder Instance

        {

            get {

                if (_instance == null)

                {

                    _instance = new ReactionRecorder();

                }

                return _instance;

            }

        }

        public StreamWriter Log { get; set; }

        private void WriteLog(string format, params object[] args)

        {

            if (Log != null)

            {

                Log.WriteLine(format, args);

            }

        }

        public delegate void ReactionRecordedHandler(Reagent reagent1, Reagent reagent2, Reaction reaction);

        public ReactionRecordedHandler OnReactionRecorded;

        public ReactionRecorder()

        {

            pixelMultiplier = 1;

            interfaceSize = DEFAULT_INTERFACE_SIZE;

            swatchHeight = SWATCH_HEIGHT[(int)interfaceSize] * pixelMultiplier;

            swatchWidth = SWATCH_WIDTH[(int)interfaceSize] * pixelMultiplier;

            colorBarWidth = COLOR_BAR_WIDTH[(int)interfaceSize] * pixelMultiplier;

            redBarSpacing = RED_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            greenBarSpacing = GREEN_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            blueBarSpacing = BLUE_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            swatchTestWidth = SWATCH_TEST_WIDTH[(int)interfaceSize] * pixelMultiplier;

        }

        public ReactionRecorder(int pixelMultiplier)

        {

            this.pixelMultiplier = pixelMultiplier;

            this.interfaceSize = DEFAULT_INTERFACE_SIZE;

            swatchHeight = SWATCH_HEIGHT[(int)interfaceSize] * pixelMultiplier;

            swatchWidth = SWATCH_WIDTH[(int)interfaceSize] * pixelMultiplier;

            colorBarWidth = COLOR_BAR_WIDTH[(int)interfaceSize] * pixelMultiplier;

            redBarSpacing = RED_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            greenBarSpacing = GREEN_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            blueBarSpacing = BLUE_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            swatchTestWidth = SWATCH_TEST_WIDTH[(int)interfaceSize] * pixelMultiplier;

        }

        public ReactionRecorder(int pixelMultiplier, InterfaceSize interfaceSize)

        {

            this.pixelMultiplier = pixelMultiplier;

            this.interfaceSize = interfaceSize;

            swatchHeight = SWATCH_HEIGHT[(int)interfaceSize] * pixelMultiplier;

            swatchWidth = SWATCH_WIDTH[(int)interfaceSize] * pixelMultiplier;

            colorBarWidth = COLOR_BAR_WIDTH[(int)interfaceSize] * pixelMultiplier;

            redBarSpacing = RED_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            greenBarSpacing = GREEN_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            blueBarSpacing = BLUE_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            swatchTestWidth = SWATCH_TEST_WIDTH[(int)interfaceSize] * pixelMultiplier;

        }

        private static bool IsPapyTexture(byte r, byte g, byte b)

        {

            // red between 208 and 244

            // green between 192 and 237

            // blue between 145 and 205

            return ((r > 0xD0) && (g >= 0xC0) && (b >= 0x91)) &&

                   ((r < 0xF4) && (g <= 0xED) && (b <= 0xCD));

        }

        public void SetPixelMultiplier(int pixelMultiplier)

        {

            this.pixelMultiplier = pixelMultiplier;

            swatchHeight = SWATCH_HEIGHT[(int)interfaceSize] * pixelMultiplier;

            swatchWidth      = SWATCH_WIDTH[(int)interfaceSize] * pixelMultiplier;

            colorBarWidth    = COLOR_BAR_WIDTH[(int)interfaceSize] * pixelMultiplier;

            redBarSpacing    = RED_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            greenBarSpacing  = GREEN_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            blueBarSpacing   = BLUE_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            swatchTestWidth  = SWATCH_TEST_WIDTH[(int)interfaceSize] * pixelMultiplier;

        }

            pixel_r = pixBytes[pixelStart];

            pixel_g = pixBytes[pixelStart + 1];

            pixel_b = pixBytes[pixelStart + 2];

            bool foundSwatch = IsPossibleSwatchUpperLeft(pixBytes, x, y, stride); // ((pixel_r < 0x46) && (pixel_g < 0x46) && (pixel_b < 0x46));

            if (foundSwatch)

            {

                int borderXOffset = 0;

                for (borderXOffset = (2 * pixelMultiplier); foundSwatch && (borderXOffset < swatchTestWidth); ++borderXOffset)

                {

                    foundSwatch &= IsPossibleSwatchSlice(pixBytes, x + borderXOffset, y, stride);

                    foundSwatch &= IsPossibleSwatchSlice(pixBytes, x + swatchWidth - borderXOffset, y, stride);

                }

            }

            if (foundSwatch)

            {

                // found a swatch with an appropriate dark top border with papyrus texture above it and papyrus a jump below it

                // 4.) Scan the left border of the potential swatch

                // location.

                colorMatch = true;

                for (int i = 2; i < swatchHeight - (2 * pixelMultiplier); ++i)

                {

                    otherPixelStart = pixelStart + (stride * i);

                    if (!IsColorMatch(pixel_r, pixel_g, pixel_b, pixBytes[otherPixelStart], pixBytes[otherPixelStart + 1], pixBytes[otherPixelStart + 2]))

                    {

                        colorMatch = false;

                        break;

                    }

                }

                if (colorMatch)

                {

                    // WE FOUND THE SWATCH!

                    // Now we know where the color bars are.

                    redPixelStart = pixelStart + (redBarSpacing * stride);

                    int redPixel = redPixelStart;

                    int redPixelCount = 0;

                    while ((pixBytes[redPixel] > 0x9F) &&

                           (pixBytes[redPixel + 1] < 0x62) &&

                           (pixBytes[redPixel + 2] < 0x62))

                    {

                        redPixelCount++;

                        // pixBytes[redPixel] = 0x00;

                        // pixBytes[redPixel + 1] = 0xFF;

                        // pixBytes[redPixel + 2] = 0xFF;

                        redPixel += 3;

                    }

                    WriteLog("Color {0}, {1}, {2} is no longer red at {3},{4}", pixBytes[redPixel], pixBytes[redPixel + 1], pixBytes[redPixel + 2], (redPixel % stride)/3, redPixel / stride);

                    reactedColor.Red = (byte)Math.Round((float)redPixelCount * 255f / (float)colorBarWidth);

                    int greenPixelStart = pixelStart + (greenBarSpacing * stride);

                    int greenPixelCount = 0;

                    while ((pixBytes[greenPixelStart] < 0x62) &&

                           (pixBytes[greenPixelStart + 1] > 0x9F) &&

                           (pixBytes[greenPixelStart + 2] < 0x62))

                    {

                        greenPixelCount++;

                        // pixBytes[greenPixelStart] = 0x00;

                        // pixBytes[greenPixelStart + 1] = 0xFF;

                        // pixBytes[greenPixelStart + 2] = 0xFF;

                        greenPixelStart += 3;

                    }

                    WriteLog("Color {0}, {1}, {2} is no longer green at pixel offset {3},{4}", pixBytes[greenPixelStart], pixBytes[greenPixelStart + 1], pixBytes[greenPixelStart + 2], (greenPixelStart % stride)/3, greenPixelStart / stride);

                    reactedColor.Green = (byte)Math.Round((float)greenPixelCount * 255f / (float)colorBarWidth);

                    int bluePixelStart = pixelStart + (blueBarSpacing * stride);

                    int bluePixelCount = 0;

                    while ((pixBytes[bluePixelStart] < 0x62) &&

                        (pixBytes[bluePixelStart + 1] < 0x62) &&

                        (pixBytes[bluePixelStart + 2] > 0x9F))

                    {

                        bluePixelCount++;

                        // pixBytes[bluePixelStart] = 0x00;

                        // pixBytes[bluePixelStart + 1] = 0xFF;

                        // pixBytes[bluePixelStart + 2] = 0xFF;

                        bluePixelStart += 3;

                    }

                    WriteLog("Color {0}, {1}, {2} is no longer blue at pixel offset {3},{4}", pixBytes[bluePixelStart], pixBytes[bluePixelStart + 1], pixBytes[bluePixelStart + 2], (bluePixelStart % stride)/3, bluePixelStart / stride);

                    reactedColor.Blue = (byte)Math.Round((float)bluePixelCount * 255f / (float)colorBarWidth);

                    WriteLog("Found the color swatch at {0}, {1}. Color={2} Red={3}px Green={4}px Blue={5}px", x, y, reactedColor, redPixelCount, greenPixelCount, bluePixelCount);

                    return true;

                }

            }

            return false;

        }

        unsafe public bool CaptureReaction(byte* pixBytes, int screenshotWidth, int screenshotHeight, int stride)

        {

            PaintColor reactedColor = new PaintColor();

            int redPixelStart = 0;

            ScreenWidth = screenshotWidth;

            ScreenHeight = screenshotHeight;

            IsCaptured = false;

            if (!firstRun)

            {

                // If this is not the first run, let's check the last location, to see if the UI is still there.

                if (TestPosition(lastSwatchX, lastSwatchY, pixBytes, screenshotWidth, screenshotHeight, stride, ref reactedColor, ref redPixelStart))

                {

                    IsCaptured = true;

                    RedBarX = (redPixelStart % stride) / 3;

                    RedBarY = redPixelStart / stride;

                    RecordedColor = reactedColor;

                    return true;

                }

                else

                {

                    firstRun = true;

                }

            }

            for (X = 0; X < screenshotWidth - colorBarWidth; ++X)

            {

                for (int Y = 0; Y < (screenshotHeight - (blueBarSpacing + 10)  /*53*/); ++Y)

                {

                    if (TestPosition(X, Y, pixBytes, screenshotWidth, screenshotHeight, stride, ref reactedColor, ref redPixelStart))

                    {

                        RedBarX = (redPixelStart % stride) / 3;

                        RedBarY = redPixelStart / stride;

                        RecordedColor = reactedColor;

                        lastSwatchX = X;

                        lastSwatchY = Y;

                        firstRun = false;

                        IsCaptured = true;

                        return true;

                    }

                    OnCaptureProgress?.Invoke(X, Y);

                }

            }

            return false;

        }

        public bool RecordReaction(PlayerProfile profile, PaintColor expectedColor, PaintColor reactedColor, Reagent[] reagents)

        {

            bool saved = false;

            int r, g, b;

            if (reagents[2] != null)

            {

                // A 3-reagent reaction.

                Reaction reaction1 = profile.FindReaction(reagents[0], reagents[1]);

                Reaction reaction2 = profile.FindReaction(reagents[0], reagents[2]);

                Reaction reaction3 = profile.FindReaction(reagents[1], reagents[2]);

                r = reactedColor.Red - expectedColor.Red;

                g = reactedColor.Green - expectedColor.Green;

                b = reactedColor.Blue - expectedColor.Blue;

                if (reaction2 == null)

                {

                    r = r - reaction1.Red - reaction3.Red;

                    g = g - reaction1.Green - reaction3.Green;

                    b = b - reaction1.Blue - reaction3.Blue;

                    Reaction reaction = new Reaction(r, g, b);

                    profile.SetReaction(reagents[0], reagents[2], reaction);

                    profile.Save();

                    saved = true;

                    OnReactionRecorded?.Invoke(reagents[0], reagents[2], reaction);

                }

                else if (reaction3 == null)

                {

                    r = r - reaction1.Red - reaction2.Red;

                    g = g - reaction1.Green - reaction2.Green;

                    b = b - reaction1.Blue - reaction2.Blue;

                    Reaction reaction = new Reaction(r, g, b);

                    profile.SetReaction(reagents[1], reagents[2], reaction);

                    profile.Save();

                    saved = true;

                    OnReactionRecorded?.Invoke(reagents[1], reagents[2], reaction);

                }

            }

            else if ((reagents[0] != null) && (reagents[1] != null))

            {

                // A 2-reagent reaction.

                r = reactedColor.Red - expectedColor.Red;

                g = reactedColor.Green - expectedColor.Green;

                b = reactedColor.Blue - expectedColor.Blue;

                Reaction reaction = new Reaction(r, g, b);

                profile.SetReaction(reagents[0], reagents[1], reaction);

                profile.Save();

                saved = true;

                OnReactionRecorded?.Invoke(reagents[0], reagents[1], reaction);

            }

            return saved;

        }

    }

}

                    clearReactionButton.Visible = false;

                    recipe.AddReagent(reagentName);

                    reagents[2] = ReagentManager.GetReagent(reagentName);

                    if (!reactionKnown)

                    {

                        Gtk.MessageDialog md = new Gtk.MessageDialog((Gtk.Window)Toplevel, 

                            Gtk.DialogFlags.DestroyWithParent,

                            Gtk.MessageType.Error, Gtk.ButtonsType.Ok, 

                            "To do a three-ingredient reaction test, " +

                            "you must first recored the reaction of " +

                            "the first two ingredients.");

                        md.Run();

                        md.Destroy();

                        captureButton.Sensitive = false;

                    }

                    reaction1 = profile.FindReaction(reagents[0], reagents[2]);

                    reaction2 = profile.FindReaction(reagents[1], reagents[2]);

                    if (reactionKnown && (reaction1 == null) && (reaction2 == null))

                    {

                        Gtk.MessageDialog md = new Gtk.MessageDialog((Gtk.Window)Toplevel, 

                            Gtk.DialogFlags.DestroyWithParent,

                            Gtk.MessageType.Error, Gtk.ButtonsType.Ok, 

                            "To do a three-ingredient reaction test, " +

                            "you must first record the reaction of " +

                            "either the first or second ingredient " +

                            "with the third ingredient.");

                        md.Run();

                        md.Destroy();   

                        captureButton.Sensitive = false;

                    }

                    if ((reaction1 == null) && (reagents[0] != reagents[2]))

                    {

                        reactionKnown = false;  

                    }

                    if ((reaction2 == null) && (reagents[1] != reagents[2]))

                    {

                        reactionKnown = false;  

                    }

                }

            }

            else

            {

                reactionKnown = false;

                ingredient3ComboBox.Sensitive = false;

            }

            expectedColor.Set(recipe.BaseColor);

            unmodifiedSwatch.Color = expectedColor;

            //SetExpectedColor(recipeColor.Red, recipeColor.Green, recipeColor.Blue);

            if (reactionKnown)

            {

                reactedColor.Set(recipe.ReactedColor);

                reactionSwatch.Color = reactedColor;

            }

            else

            {

                reactionSwatch.Clear(); 

            }

        }

        unsafe void BeginCapture()

        {

            captureButton.Sensitive = false;

            ingredient1ComboBox.Sensitive = false;

            ingredient2ComboBox.Sensitive = false;

            ingredient3ComboBox.Sensitive = false;

            clearReactionButton.Sensitive = false;

            progressBar.Show();

            recordButton.Hide();

            bool enableDebugMenu = false;

            DesertPaintLab.AppSettings.Get("EnableDebugMenu", out enableDebugMenu);

            StreamWriter log = null;

            if (enableDebugMenu)

            {

                string logfile = FileUtils.FindNumberedFile("DesertPaintLab_Capture", "log", Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments));

                log = new StreamWriter(logfile);

                ReactionRecorder.Instance.Log = log;

            }

            if (notifyCaptureProgress == null)

            {

                notifyCaptureProgress = new Gtk.ThreadNotify(new Gtk.ReadyEvent(NotifyCaptureProgress));

                notifyCaptureComplete = new Gtk.ThreadNotify(new Gtk.ReadyEvent(NotifyCaptureComplete));

            }

            Thread thr = new Thread(new ThreadStart(this.CaptureReactionThread));

            thr.Priority = ThreadPriority.AboveNormal;

            thr.Start();

            //OnCaptureComplete(isCaptured, reactedColor, screenWidth, screenHeight, stride, redPixelStart);

        }

        unsafe private void CaptureReactionThread()

        {

            byte* pixBytes = (byte*)screenBuffer.Pixels;

            ReactionRecorder.Instance.OnCaptureProgress += OnCaptureProgress;

            ReactionRecorder.Instance.CaptureReaction(pixBytes, screenBuffer.Width, screenBuffer.Height, screenBuffer.Rowstride);

            ReactionRecorder.Instance.OnCaptureProgress -= OnCaptureProgress;

            notifyCaptureComplete.WakeupMain();

        }

        private void OnCaptureProgress(int x, int y)

        {

            notifyCaptureProgress.WakeupMain();

        }

        private void NotifyCaptureProgress()

        {

            // TODO: progress bar

            //ReactionRecorder.Instance.X;

            //ReactionRecorder.Instance.Y;

            progressBar.Fraction = ((double)(ReactionRecorder.Instance.X) / (double)(ReactionRecorder.Instance.ScreenWidth - ReactionRecorder.Instance.ColorBarWidth));

        }

        void OnCaptureComplete(bool isCaptured, PaintColor reactedColor, int swatchX, int swatchY)

        {

            int screenWidth = screenBuffer.Width;

            int screenHeight = screenBuffer.Height;

            int stride = screenBuffer.Rowstride;

            StreamWriter log = ReactionRecorder.Instance.Log;

            if (log != null)

            {

                log.Flush();

                log.Close();

                log = null;

                ReactionRecorder.Instance.Log = null;

            }

            bool enableDebugMenu = false;

            DesertPaintLab.AppSettings.Get("EnableDebugMenu", out enableDebugMenu);

            bool debugScreenshot = false;

            DesertPaintLab.AppSettings.Get("DebugScreenshot", out debugScreenshot);

            if (enableDebugMenu && debugScreenshot)

            {

                if (!isCaptured)

                {

                    // write out the whole screenshot on a failure to capture

                    string screenshotDir = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

                    string filename = FileUtils.FindNumberedFile("DesertPaintLab_Colormatch", "png", screenshotDir);

                    screenBuffer.Save(filename, "png");

                }

                else

                {

                    // record the swatch that was captured

                    // write out the screenshot

                    string screenshotDir = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

                    string filename = FileUtils.FindNumberedFile("DesertPaintLab_Colormatch", "png", screenshotDir);

                    int x = swatchX - 16;

                    int captureAreaWidth = ReactionRecorder.Instance.ColorBarWidth + 32;

                    captureAreaWidth = Math.Min(screenWidth - x, captureAreaWidth);

                    int y = swatchY - 16;

                    int captureAreaHeight = ReactionRecorder.Instance.BlueBarSpacing + 42;

                    captureAreaHeight = Math.Min(screenHeight - y, captureAreaHeight);

                    Gdk.Pixbuf outPixBuf = new Gdk.Pixbuf(screenBuffer, Math.Max(0, x), Math.Max(0, y), 

                        captureAreaWidth, captureAreaHeight);

                    //Gdk.Pixbuf outPixBuf = new Gdk.Pixbuf(screenBuffer, Math.Max(0, redPixelStartX), Math.Max(0, redPixelStartY),

                    //    ReactionRecorder.Instance.ColorBarWidth, ReactionRecorder.Instance.GreenBarSpacing - ReactionRecorder.Instance.RedBarSpacing);

                    //screenBuffer.Save(filename, "png");

                    outPixBuf.Save(filename, "png");

                }

            }

            //screenBuffer.Save("screenshot.png", "png");

            if (isCaptured)

            {

                string warning = "";

                if (reactedColor.Red == 0)

                {

                    warning = warning + "\nRed is too low.";

                }

                if (reactedColor.Green == 0)

                {

                    warning = warning + "\nGreen is too low.";

                }

                if (reactedColor.Blue == 0)

                {

                    warning = warning + "\nBlue is too low.";

                }

                if (reactedColor.Red == 255)

                {

                    warning = warning + "\nRed is too high.";

                }

                if (reactedColor.Green == 255)

                {

                    warning = warning + "\nGreen is too high.";

                }

                if (reactedColor.Blue == 255)

                {

                    warning = warning + "\nBlue is too high.";

                }

                // Always update the reacted swatch

                this.reactionSwatch.Color = reactedColor;

                if (warning.Length != 0)

                {

                    isCaptured = true;

                    Gtk.MessageDialog md = new Gtk.MessageDialog((Gtk.Window)Toplevel,

                    Gtk.DialogFlags.DestroyWithParent,

                    Gtk.MessageType.Error, Gtk.ButtonsType.Ok,

                    "Reaction clipped.  You will need to do a " +

                    "3-way reaction to test this pair.  Details: " +

                    warning);

                    md.Run();

                    md.Destroy();

                    // reaction clipped - don't let them record

                    recordButton.Sensitive = false;

                }

                else

                {

                    recordButton.Sensitive = recordEnabled;

                }

            }

            else

            {

                Gtk.MessageDialog md = new Gtk.MessageDialog((Gtk.Window)Toplevel,

                    Gtk.DialogFlags.DestroyWithParent,

                    Gtk.MessageType.Error, Gtk.ButtonsType.Ok,

                    "Pigment Lab dialog box NOT FOUND.  Please ensure " +

                    "that there is an unobstructed view of the dialog " +

                    "and that your interface size is set to 'small' " +

                    "when you press the Capture button.");

                md.Run();

                md.Destroy();

            }

            progressBar.Hide();

            recordButton.Show();

            ingredient1ComboBox.Sensitive = true;

            ingredient2ComboBox.Sensitive = true;

        }

        private void NotifyCaptureComplete()

        {

            OnCaptureComplete(

                ReactionRecorder.Instance.IsCaptured,

                ReactionRecorder.Instance.RecordedColor,

                ReactionRecorder.Instance.SwatchX,

                ReactionRecorder.Instance.SwatchY);

        }

        unsafe void CaptureReactionColor()

        {

            // Take a screenshot.

            int screenWidth, screenHeight;

            Gdk.Window rootWindow = Gdk.Global.DefaultRootWindow;

            DesertPaintLab.AppSettings.Get("ScreenWidth", out screenWidth);

            DesertPaintLab.AppSettings.Get("ScreenHeight", out screenHeight);

            Gdk.Image rootImage = rootWindow.GetImage(0, 0, screenWidth, screenHeight);

            screenBuffer.GetFromImage(rootImage, rootImage.Colormap, 0, 0, 0, 0, screenWidth, screenHeight);

            rootImage.Unref();

            System.GC.Collect(); // really, clean up now

            BeginCapture();

        }

        protected virtual void OnCapture(object sender, System.EventArgs e)

        {

            CaptureReactionColor();

        }

        protected virtual void OnRecord(object sender, System.EventArgs e)

        {

            if (ReactionRecorder.Instance.RecordReaction(profile, expectedColor, reactedColor, reagents))

            {

                recordButton.Sensitive = false;

            }

        }

        protected virtual void OnChangedIngredient1(object sender, System.EventArgs e)

        {

            UpdateIngredients();

        }

        protected virtual void OnChangedIngredient2(object sender, System.EventArgs e)

        {

            UpdateIngredients();

        }

        protected virtual void OnChangedIngredient3(object sender, System.EventArgs e)

        {

            UpdateIngredients();

        }

        protected void OnClearReaction(object sender, EventArgs e)

        {

            string reagentName1 = GetSelectedReagentName(1);

            string reagentName2 = GetSelectedReagentName(2);

            string reagentName3 = GetSelectedReagentName(3);

            if ((reagentName1 != null) && (reagentName2 != null) && (reagentName3 == null))

            {

                Reagent reagent1 = ReagentManager.GetReagent(reagentName1);

                Reagent reagent2 = ReagentManager.GetReagent(reagentName2);

                if (null != profile.FindReaction(reagent1, reagent2))

                {

                    Gtk.MessageDialog md = new Gtk.MessageDialog((Gtk.Window)Toplevel, 

                        Gtk.DialogFlags.DestroyWithParent,

                        Gtk.MessageType.Warning, Gtk.ButtonsType.OkCancel, 

                        "This will delete the reaction status between " +

                        // TODO: ingredient1Name + " and " + ingredient2Name + "\n\n" +

                        "ARE YOU SURE?"

                    );

                    Gtk.ResponseType response = (Gtk.ResponseType)md.Run();

                    if (response == Gtk.ResponseType.Ok)

                    {

                        // really delete it

                        profile.ClearReaction(reagent1, reagent2);

                    }

                    md.Destroy();

                }

            }

        }

    }

}