Refactoring the Pipette logic, also fixed some small issue...

git-svn-id: http://svn.code.sf.net/p/greenshot/code/trunk@1658 7dccd23d-a4a3-4e1f-8c07-b4c1b4018ab4

Greenshot/Controls/Pipette.cs

@@ -32,131 +32,159 @@ namespace Greenshot.Controls {
 	/// This code was supplied by Hi-Coder as a patch for Greenshot
 	/// Needed some modifications to be stable.
 	/// </summary>
-    public class Pipette : Label, IMessageFilter, IDisposable {
+	public class Pipette : Label, IMessageFilter, IDisposable {
-        private Zoomer zoomer;
+		private MovableShowColorForm movableShowColorForm;
-        private bool dragging;
+		private bool dragging;
-        private Cursor _cursor;
+		private Cursor _cursor;
 		private Bitmap _image;
-        private const int VK_ESC = 27;
+		private const int VK_ESC = 27;
 
-        public event EventHandler<PipetteUsedArgs> PipetteUsed;
+		public event EventHandler<PipetteUsedArgs> PipetteUsed;
 
-        public Pipette() {
+		public Pipette() {
-            BorderStyle = BorderStyle.FixedSingle;
+			BorderStyle = BorderStyle.FixedSingle;
-            dragging = false;
+			dragging = false;
 			_image = (Bitmap)new System.ComponentModel.ComponentResourceManager(typeof(ColorDialog)).GetObject("pipette.Image");
 			Image = _image;
-			_cursor = CreateCursor((Bitmap)_image, 0, 15);
+			_cursor = CreateCursor((Bitmap)_image, 1, 14);
-            zoomer = new Zoomer();
+			movableShowColorForm = new MovableShowColorForm();
-            Application.AddMessageFilter(this);
+			Application.AddMessageFilter(this);
-        }
+		}
 
-		/**
+		/// <summary>
-		 * Destructor
+		/// Create a cursor from the supplied bitmap & hotspot coordinates
-		 */
+		/// </summary>
+		/// <param name="bitmap">Bitmap to create an icon from</param>
+		/// <param name="hotspotX">Hotspot X coordinate</param>
+		/// <param name="hotspotY">Hotspot Y coordinate</param>
+		/// <returns>Cursor</returns>
+		private static Cursor CreateCursor(Bitmap bitmap, int hotspotX, int hotspotY) {
+			IntPtr iconHandle = bitmap.GetHicon();
+			IntPtr icon;
+			IconInfo iconInfo = new IconInfo();
+			User32.GetIconInfo(iconHandle, out iconInfo);
+			iconInfo.xHotspot = hotspotX;
+			iconInfo.yHotspot = hotspotY;
+			iconInfo.fIcon = false;
+			icon = User32.CreateIconIndirect(ref iconInfo);
+			Cursor returnCursor = new Cursor(icon);
+			//User32.DestroyIcon(icon);
+			User32.DestroyIcon(iconHandle);
+			return returnCursor;
+		}
+
+		/// <summary>
+		/// Destructor
+		/// </summary>
 		~Pipette() {
 			Dispose(false);
 		}
 
-		// The bulk of the clean-up code is implemented in Dispose(bool)
+		/// <summary>
+		/// The bulk of the clean-up code is implemented in Dispose(bool)
+		/// </summary>
+		public new void Dispose() {
+			Dispose(true);
+		}
 
-		/**
+		/// <summary>
-		 * This Dispose is called from the Dispose and the Destructor.
+		/// This Dispose is called from the Dispose and the Destructor.
-		 * When disposing==true all non-managed resources should be freed too!
+		/// </summary>
-		 */
+		/// <param name="disposing">When disposing==true all non-managed resources should be freed too!</param>
 		protected override void Dispose(bool disposing) {
-			base.Dispose();
 			if (disposing) {
 				if (_cursor != null) {
 					_cursor.Dispose();
 				}
-				if (zoomer != null) {
+				if (movableShowColorForm != null) {
-					zoomer.Dispose();
+					movableShowColorForm.Dispose();
 				}
 			}
-			zoomer = null;
+			movableShowColorForm = null;
 			_cursor = null;
+			base.Dispose();
 		}
 
+		/// <summary>
+		/// Handle the mouse down on the Pipette "label", we take the capture and move the zoomer to the current location
+		/// </summary>
+		/// <param name="e">MouseEventArgs</param>
 		protected override void OnMouseDown(MouseEventArgs e) {
-            if (e.Button == MouseButtons.Left) {
+			if (e.Button == MouseButtons.Left) {
-                User32.SetCapture(this.Handle);
+				User32.SetCapture(this.Handle);
-                zoomer.setHotSpot(PointToScreen(new Point(e.X, e.Y)));
+				movableShowColorForm.MoveTo(PointToScreen(new Point(e.X, e.Y)));
-            }
+			}
-            base.OnMouseDown(e);
+			base.OnMouseDown(e);
-        }
+		}
 
-        protected override void OnMouseUp(MouseEventArgs e) {
+		/// <summary>
-            if (e.Button == MouseButtons.Left) {
+		/// Handle the mouse up on the Pipette "label", we release the capture and fire the PipetteUsed event
-                //Release Capture should consume MouseUp when canceled with the escape key 
+		/// </summary>
-                User32.ReleaseCapture();
+		/// <param name="e">MouseEventArgs</param>
-                PipetteUsed(this, new PipetteUsedArgs(zoomer.color));
+		protected override void OnMouseUp(MouseEventArgs e) {
-            }
+			if (e.Button == MouseButtons.Left) {
-            base.OnMouseUp(e);
+				//Release Capture should consume MouseUp when canceled with the escape key 
-        }
+				User32.ReleaseCapture();
+				PipetteUsed(this, new PipetteUsedArgs(movableShowColorForm.color));
+			}
+			base.OnMouseUp(e);
+		}
 
-        protected override void OnMouseMove(MouseEventArgs e) {
+		/// <summary>
-            if (dragging) {
+		/// Handle the mouse Move event, we move the ColorUnderCursor to the current location.
-                //display the form on the right side of the cursor by default;
+		/// </summary>
-                Point zp = PointToScreen(new Point(e.X, e.Y));
+		/// <param name="e">MouseEventArgs</param>
-                zoomer.setHotSpot(zp);
+		protected override void OnMouseMove(MouseEventArgs e) {
-            }
+			if (dragging) {
-            base.OnMouseMove(e);
+				//display the form on the right side of the cursor by default;
-        }
+				Point zp = PointToScreen(new Point(e.X, e.Y));
+				movableShowColorForm.MoveTo(zp);
+			}
+			base.OnMouseMove(e);
+		}
 
-        private Cursor CreateCursor(Bitmap bitmap, int x, int y) {
+		/// <summary>
-            IntPtr iconHandle = bitmap.GetHicon();
+		/// Handle the MouseCaptureChanged event
-			IntPtr icon;
+		/// </summary>
-            IconInfo iconInfo = new IconInfo();
+		/// <param name="e"></param>
-			User32.GetIconInfo(iconHandle, out iconInfo);
+		protected override void OnMouseCaptureChanged(EventArgs e) {
-            iconInfo.xHotspot = 0;
+			if (this.Capture) {
-            iconInfo.yHotspot = 15;
+				dragging = true;
-            iconInfo.fIcon = false;
+				Image = null;
-            icon = User32.CreateIconIndirect(ref iconInfo);
+				Cursor c = _cursor;
-			Cursor returnCursor = new Cursor(icon);
+				Cursor = c;
-			//User32.DestroyIcon(icon);
+				movableShowColorForm.Visible = true;
-			User32.DestroyIcon(iconHandle);
+			} else {
-            return returnCursor;
+				dragging = false;
-        }
+				Image = _image;
-
+				Cursor = Cursors.Arrow;
-        protected override void OnMouseCaptureChanged(EventArgs e) {
+				movableShowColorForm.Visible = false;
-            if (this.Capture) {
+			}
-                dragging = true;
-                Image = null;
-                Cursor c = _cursor;
-                Cursor = c;
-                zoomer.Visible = true;
-            } else {
-                dragging = false;
-                Image = _image;
-                Cursor = Cursors.Arrow;
-                zoomer.Visible = false;
-            }
 			Update();
-            base.OnMouseCaptureChanged(e);
+			base.OnMouseCaptureChanged(e);
-        }
+		}
 
-        #region IMessageFilter Members
+		#region IMessageFilter Members
 
-        public bool PreFilterMessage(ref Message m) {
+		public bool PreFilterMessage(ref Message m) {
-            if (dragging) {
+			if (dragging) {
 				if (m.Msg == (int)WindowsMessages.WM_CHAR) {
 					if ((int)m.WParam == VK_ESC) {
 						User32.ReleaseCapture();
 					}
 				}
-            }
+			}
-            return false;
+			return false;
-        }
+		}
 
-        #endregion
+		#endregion
-    }
+	}
 
-    public class PipetteUsedArgs : EventArgs {
+	public class PipetteUsedArgs : EventArgs {
-        public Color color;
+		public Color color;
 
-        public PipetteUsedArgs(Color c) {
+		public PipetteUsedArgs(Color c) {
-            color = c;
+			color = c;
-        }
+		}
-    }
+	}
 }

Greenshot/Forms/MovableShowColorForm.Designer.cs

@@ -1,6 +1,6 @@
 namespace Greenshot.Forms
 {
-    partial class Zoomer
+    partial class MovableShowColorForm
     {
         /// <summary>
         /// Required designer variable.

Greenshot/Forms/MovableShowColorForm.cs

@@ -28,19 +28,23 @@ namespace Greenshot.Forms {
 	/// This code was supplied by Hi-Coder as a patch for Greenshot
 	/// Needed some modifications to be stable.
 	/// </summary>
-	public partial class Zoomer : Form {
+	public partial class MovableShowColorForm : Form {
 		public Color color {
 			get {
 				return preview.BackColor;
 			}
 		}
 
-		public Zoomer() {
+		public MovableShowColorForm() {
 			InitializeComponent();
 		}
 
-		public void setHotSpot(int x, int y) {
+		/// <summary>
-			Color c = GetPixelColor(x, y);
+		/// Move the MovableShowColorForm to the specified location and display the color under the (current mouse) coordinates
+		/// </summary>
+		/// <param name="screenCoordinates">Coordinates</param>
+		public void MoveTo(Point screenCoordinates) {
+			Color c = GetPixelColor(screenCoordinates);
 			preview.BackColor = c;
 			html.Text = "#" + c.Name.Substring(2).ToUpper();
 			red.Text = "" + c.R;
@@ -51,23 +55,23 @@ namespace Greenshot.Forms {
 			Size cursorSize = Cursor.Current.Size;
 			Point hotspot = Cursor.Current.HotSpot;
 
-			Point zoomerLocation = new Point(x, y);
+			Point zoomerLocation = new Point(screenCoordinates.X, screenCoordinates.Y);
 			zoomerLocation.X += cursorSize.Width + 5 - hotspot.X;
 			zoomerLocation.Y += cursorSize.Height + 5 - hotspot.Y;
 
 			foreach (Screen screen in Screen.AllScreens) {
 				Rectangle screenRectangle = screen.Bounds;
-				if (screen.Bounds.Contains(x, y)) {
+				if (screen.Bounds.Contains(screenCoordinates)) {
 					if (zoomerLocation.X < screenRectangle.X) {
 						zoomerLocation.X = screenRectangle.X;
 					} else if (zoomerLocation.X + Width > screenRectangle.X + screenRectangle.Width) {
-						zoomerLocation.X = x - Width - 5 - hotspot.X;
+						zoomerLocation.X = screenCoordinates.X - Width - 5 - hotspot.X;
 					}
 
 					if (zoomerLocation.Y < screenRectangle.Y) {
 						zoomerLocation.Y = screenRectangle.Y;
 					} else if (zoomerLocation.Y + Height > screenRectangle.Y + screenRectangle.Height) {
-						zoomerLocation.Y = y - Height - 5 - hotspot.Y;
+						zoomerLocation.Y = screenCoordinates.Y - Height - 5 - hotspot.Y;
 					}
 					break;
 				}
@@ -76,14 +80,15 @@ namespace Greenshot.Forms {
 			Update();
 		}
 
-		public void setHotSpot(Point screenCoordinates) {
+		/// <summary>
-			setHotSpot(screenCoordinates.X, screenCoordinates.Y);
+		/// Get the color from the pixel on the screen at "x,y"
-		}
+		/// </summary>
-
+		/// <param name="screenCoordinates">Point with the coordinates</param>
-		static private Color GetPixelColor(int x, int y) {
+		/// <returns>Color at the specified screenCoordinates</returns>
+		static private Color GetPixelColor(Point screenCoordinates) {
 			IntPtr hdc = User32.GetDC(IntPtr.Zero);
 			try {
-				uint pixel = GDI32.GetPixel(hdc, x, y);
+				uint pixel = GDI32.GetPixel(hdc, screenCoordinates.X, screenCoordinates.Y);
 				Color color = Color.FromArgb(255, (int)(pixel & 0xFF), (int)(pixel & 0xFF00) >> 8, (int)(pixel & 0xFF0000) >> 16);
 				return color;
 			} catch (Exception) {

Greenshot/Greenshot.csproj

@@ -154,9 +154,9 @@
     <Compile Include="Forms\BugReportForm.Designer.cs">
       <DependentUpon>BugReportForm.cs</DependentUpon>
     </Compile>
-    <Compile Include="Forms\Zoomer.cs" />
+    <Compile Include="Forms\MovableShowColorForm.cs" />
-    <Compile Include="Forms\Zoomer.Designer.cs">
+    <Compile Include="Forms\MovableShowColorForm.Designer.cs">
-      <DependentUpon>Zoomer.cs</DependentUpon>
+      <DependentUpon>MovableShowColorForm.cs</DependentUpon>
     </Compile>
     <Compile Include="Helpers\AviHelper.cs" />
     <Compile Include="Helpers\CaptureHelper.cs" />