ATITD-Tools/Desert-Paint-Lab Changeset

Changeset - d792b40d3ef9

Parent rev.

Child rev.

[Not reviewed]

VERSION_T8_RC4 default

0 2 0

Jason Maltzen - 7 years ago 2018-05-17 21:16:24
jason@hiddenachievement.com

Disabling the capture button then re-updating the ingredients to fix button states was having the side effect of clearing the reacted color swatch. That was done to re-enable UI elements that were disabled during recording. Now enabling them explicitly to fix the problem.

2 files changed with 6 insertions and 6 deletions:

ReactionRecorder.cs

UI/CaptureView.cs

0 comments (0 inline, 0 general)

ReactionRecorder.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;
 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 =
+        {
 , // tiny
 , // small
 , // medium
 , // large
 // huge
         };
         public static readonly int[] SWATCH_WIDTH =
+        {
 , // tiny
 , // small
 , // medium
 , // large
 // huge
         };
         public static readonly int[] COLOR_BAR_WIDTH =
+        {
 , // tiny
 , // small
 , // medium
 , // large
 // huge
         };
         public static readonly int[] RED_BAR_SPACING =
+        {
 , // tiny
 , // small
 , // medium
 , // large
 // huge
         };
         public static readonly int[] GREEN_BAR_SPACING =
+        {
 , // tiny
 , // small
 , // medium
 , // large
 // huge
         };
         public static readonly int[] BLUE_BAR_SPACING =
+        {
 , // tiny
 , // small
 , // medium
 , // large
 // huge
         };
         // width to test on ends of swatch (10% on either end)
         public static readonly int[] SWATCH_TEST_WIDTH =
+        {
 , // tiny
 , // small
 , // medium
 , // large
 // 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 PaintColor RecordedColor { get; private set; }
         private PaintColor _recordedColor = new PaintColor();
         public PaintColor RecordedColor { get { return _recordedColor; } private set { _recordedColor.Set(value); } }
         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;
+        }
         public void SetInterfaceSize(InterfaceSize interfaceSize)
+        {
             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;
+        }
         unsafe private void ColorAt(byte *pixBytes, int x, int y, int stride, out byte r, out byte g, out byte b)
+        {
             int pixelStart = (y * stride) + (x * 3);
                     r = pixBytes[pixelStart];
                     g = pixBytes[pixelStart + 1];
                     b = pixBytes[pixelStart + 2];
+        }
         private bool IsDarkPixel(int r, int g, int b)
+        {
             return ((r < 0x46) && (g < 0x46) && (b < 0x47));
+        }
         private bool IsColorMatch(byte test_r, byte test_g, byte test_b, byte target_r, byte target_g, byte target_b)
+        {
             return ((Math.Abs(test_r - target_r) <= COLOR_TOLERANCE) &&
                 (Math.Abs(test_g - target_g) <= COLOR_TOLERANCE) &&
                 (Math.Abs(test_b - target_b) <= COLOR_TOLERANCE));
@@ ... / @@ -334,223 +335,225 @@ namespace DesertPaintLab @@
                     papyErrorCount += (IsPapyTexture(pixBytes[otherPixelStart], pixBytes[otherPixelStart + 1], pixBytes[otherPixelStart + 2]) ? 0 : 1);
+                }
                 else
+                {
                     papyErrorCount++;
+                }
                 // Checking along the bottom of the swatch -
                 otherPixelStart = testPixelStart + (stride * swatchHeight) + (3 * i);
                 papyErrorCount += (IsPapyTexture(pixBytes[otherPixelStart], pixBytes[otherPixelStart+1], pixBytes[otherPixelStart+2]) ? 0 : 1);
+            }
             result &= (papyErrorCount < (swatchWidth / 20)); // allow up to 5% error rate checking for papy texture, because this seems to be inconsistent
             if (!result && ((i > (swatchWidth*0.8)) || (papyErrorCount >= (swatchWidth/20))))
+            {
                 if (!borderError && (papyErrorCount < swatchWidth))
+                {
                     WriteLog("Found a potential swatch candidate of width {0} at {1},{2} that had {3} failures matching papyrus texture", i, x, y, papyErrorCount);
+                }
+            }
             return result;
+        }
         unsafe private bool TestPosition(int x, int y, byte* pixBytes, int screenshotWidth, int screenshotHeight, int stride, ref PaintColor reactedColor, ref int redPixelStart)
+        {
             byte pixel_r, pixel_g, pixel_b;
             int pixelStart, otherPixelStart;
             bool colorMatch = true;
             // Look for the color swatch.
             pixelStart = (y * stride) + (x * 3);
             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;
             _recordedColor.Clear();
             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;
+        }
+    }
+}

UI/CaptureView.cs

➞

Show inline comments

@@ ... / @@ -163,372 +163,369 @@ namespace DesertPaintLab @@
                 reactionSwatch.Clear();
                 captureButton.Sensitive = false;
                 return;
+            }
             recipe.AddReagent(reagentName);
             reagents[0] = ReagentManager.GetReagent(reagentName);
             ingredient2ComboBox.Sensitive = true;
             if ((reagentName = GetSelectedReagentName(2)) == null)
+            {
                 ingredient3ComboBox.Sensitive = false;
                 recordButton.Sensitive = false;
                 reactionKnown = false;
                 reactionSwatch.Clear();
                 return;
+            }
             recipe.AddReagent(reagentName);
             reagents[1] = ReagentManager.GetReagent(reagentName);
             ingredient3ComboBox.Sensitive = true;
             captureButton.Sensitive = true;
             reaction1 = profile.FindReaction(reagents[0], reagents[1]);
             // TODO: really should handle reagent0==reagent1 better
             if ((reaction1 != null) || (reagents[0] == reagents[1]))
+            {
                 clearReactionButton.Sensitive = recordEnabled;
                 clearReactionButton.Visible = true;
                 ingredient3ComboBox.Sensitive = true;
                 if ((reagentName = GetSelectedReagentName(3)) != null)
+                {
                     clearReactionButton.Sensitive = false;
                     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));
+            }
-            this.reactionSwatch.Color = new PaintColor("Searching", "00", "00", "00");
+            this.reactionSwatch.Clear();
             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;
+                }
                 captureButton.Sensitive = false;
+            }
             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;
             ingredient3ComboBox.Sensitive = false;
             UpdateIngredients();
             ingredient3ComboBox.Sensitive = (GetSelectedReagentName(1) != null) && (GetSelectedReagentName(2) != null);
+        }
         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();
+                }
+            }
+        }
+    }
+}

0 comments (0 inline, 0 general)