A bit of refactoring to be able to find some issue...

GreenshotPlugin/UnmanagedHelpers/Structs/CursorInfo.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace GreenshotPlugin.UnmanagedHelpers.Structs
+{
+    [StructLayout(LayoutKind.Sequential)]
+    public struct CursorInfo {
+        public int cbSize;
+        public int flags;
+        public IntPtr hCursor;
+        public POINT ptScreenPos;
+    }
+}

GreenshotPlugin/UnmanagedHelpers/Structs/IconInfo.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace GreenshotPlugin.UnmanagedHelpers.Structs
+{
+    [StructLayout(LayoutKind.Sequential)]
+    public struct IconInfo {
+        public bool fIcon;
+        public int xHotspot;
+        public int yHotspot;
+        public IntPtr hbmMask;
+        public IntPtr hbmColor;
+    }
+}

GreenshotPlugin/UnmanagedHelpers/Structs/POINT.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Drawing;
+using System.Runtime.InteropServices;
+
+namespace GreenshotPlugin.UnmanagedHelpers.Structs
+{
+    [StructLayout(LayoutKind.Sequential), Serializable()]
+    public struct POINT {
+        public int X;
+        public int Y;
+
+        public POINT(int x, int y) {
+            X = x;
+            Y = y;
+        }
+        public POINT(Point point) {
+            X = point.X;
+            Y = point.Y;
+        }
+
+        public static implicit operator Point(POINT p) {
+            return new Point(p.X, p.Y);
+        }
+
+        public static implicit operator POINT(Point p) {
+            return new POINT(p.X, p.Y);
+        }
+
+        public Point ToPoint() {
+            return new Point(X, Y);
+        }
+
+        public override string ToString() {
+            return X + "," + Y;
+        }
+    }
+}

GreenshotPlugin/UnmanagedHelpers/Structs/RECT.cs

@@ -0,0 +1,148 @@
+using System;
+using System.Drawing;
+using System.Runtime.InteropServices;
+
+namespace GreenshotPlugin.UnmanagedHelpers.Structs
+{
+    [StructLayout(LayoutKind.Sequential), Serializable()]
+    public struct RECT {
+        private int _Left;
+        private int _Top;
+        private int _Right;
+        private int _Bottom;
+
+        public RECT(RECT rectangle)
+            : this(rectangle.Left, rectangle.Top, rectangle.Right, rectangle.Bottom) {
+        }
+        public RECT(Rectangle rectangle)
+            : this(rectangle.Left, rectangle.Top, rectangle.Right, rectangle.Bottom) {
+        }
+        public RECT(int left, int top, int right, int bottom) {
+            _Left = left;
+            _Top = top;
+            _Right = right;
+            _Bottom = bottom;
+        }
+
+        public int X {
+            get {
+                return _Left;
+            }
+            set {
+                _Left = value;
+            }
+        }
+        public int Y {
+            get {
+                return _Top;
+            }
+            set {
+                _Top = value;
+            }
+        }
+        public int Left {
+            get {
+                return _Left;
+            }
+            set {
+                _Left = value;
+            }
+        }
+        public int Top {
+            get {
+                return _Top;
+            }
+            set {
+                _Top = value;
+            }
+        }
+        public int Right {
+            get {
+                return _Right;
+            }
+            set {
+                _Right = value;
+            }
+        }
+        public int Bottom {
+            get {
+                return _Bottom;
+            }
+            set {
+                _Bottom = value;
+            }
+        }
+        public int Height {
+            get {
+                return _Bottom - _Top;
+            }
+            set {
+                _Bottom = value - _Top;
+            }
+        }
+        public int Width {
+            get {
+                return _Right - _Left;
+            }
+            set {
+                _Right = value + _Left;
+            }
+        }
+        public Point Location {
+            get {
+                return new Point(Left, Top);
+            }
+            set {
+                _Left = value.X;
+                _Top = value.Y;
+            }
+        }
+        public Size Size {
+            get {
+                return new Size(Width, Height);
+            }
+            set {
+                _Right = value.Width + _Left;
+                _Bottom = value.Height + _Top;
+            }
+        }
+
+        public static implicit operator Rectangle(RECT rectangle) {
+            return new Rectangle(rectangle.Left, rectangle.Top, rectangle.Width, rectangle.Height);
+        }
+        public static implicit operator RECT(Rectangle rectangle) {
+            return new RECT(rectangle.Left, rectangle.Top, rectangle.Right, rectangle.Bottom);
+        }
+        public static bool operator ==(RECT rectangle1, RECT rectangle2) {
+            return rectangle1.Equals(rectangle2);
+        }
+        public static bool operator !=(RECT rectangle1, RECT rectangle2) {
+            return !rectangle1.Equals(rectangle2);
+        }
+
+        public override string ToString() {
+            return "{Left: " + _Left + "; " + "Top: " + _Top + "; Right: " + _Right + "; Bottom: " + _Bottom + "}";
+        }
+
+        public override int GetHashCode() {
+            return ToString().GetHashCode();
+        }
+
+        public bool Equals(RECT rectangle) {
+            return rectangle.Left == _Left && rectangle.Top == _Top && rectangle.Right == _Right && rectangle.Bottom == _Bottom;
+        }
+
+        public Rectangle ToRectangle() {
+            return new Rectangle(Left, Top, Width, Height);
+        }
+        public override bool Equals(object Object) {
+            if (Object is RECT) {
+                return Equals((RECT)Object);
+            } else if (Object is Rectangle) {
+                return Equals(new RECT((Rectangle)Object));
+            }
+
+            return false;
+        }
+    }
+}

GreenshotPlugin/UnmanagedHelpers/Structs/RECTF.cs

@@ -0,0 +1,102 @@
+using System.Drawing;
+using System.Runtime.InteropServices;
+
+namespace GreenshotPlugin.UnmanagedHelpers.Structs
+{
+    /// <summary>
+    /// A floating point GDI Plus width/hight based rectangle.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    public struct RECTF {
+        /// <summary>
+        /// The X corner location of the rectangle.
+        /// </summary>
+        public float X;
+
+        /// <summary>
+        /// The Y corner location of the rectangle.
+        /// </summary>
+        public float Y;
+
+        /// <summary>
+        /// The width of the rectangle.
+        /// </summary>
+        public float Width;
+
+        /// <summary>
+        /// The height of the rectangle.
+        /// </summary>
+        public float Height;
+
+        /// <summary>
+        /// Creates a new GDI Plus rectangle.
+        /// </summary>
+        /// <param name="x">The X corner location of the rectangle.</param>
+        /// <param name="y">The Y corner location of the rectangle.</param>
+        /// <param name="width">The width of the rectangle.</param>
+        /// <param name="height">The height of the rectangle.</param>
+        public RECTF(float x, float y, float width, float height) {
+            X = x;
+            Y = y;
+            Width = width;
+            Height = height;
+        }
+
+        /// <summary>
+        /// Creates a new GDI Plus rectangle from a System.Drawing.RectangleF.
+        /// </summary>
+        /// <param name="rect">The rectangle to base this GDI Plus rectangle on.</param>
+        public RECTF(RectangleF rect) {
+            X = rect.X;
+            Y = rect.Y;
+            Width = rect.Width;
+            Height = rect.Height;
+        }
+
+        /// <summary>
+        /// Creates a new GDI Plus rectangle from a System.Drawing.Rectangle.
+        /// </summary>
+        /// <param name="rect">The rectangle to base this GDI Plus rectangle on.</param>
+        public RECTF(Rectangle rect) {
+            X = rect.X;
+            Y = rect.Y;
+            Width = rect.Width;
+            Height = rect.Height;
+        }
+
+        /// <summary>
+        /// Returns a RectangleF for this GDI Plus rectangle.
+        /// </summary>
+        /// <returns>A System.Drawing.RectangleF structure.</returns>
+        public RectangleF ToRectangle() {
+            return new RectangleF(X, Y, Width, Height);
+        }
+
+        /// <summary>
+        /// Returns a RectangleF for a GDI Plus rectangle.
+        /// </summary>
+        /// <param name="rect">The GDI Plus rectangle to get the RectangleF for.</param>
+        /// <returns>A System.Drawing.RectangleF structure.</returns>
+        public static RectangleF ToRectangle(RECTF rect) {
+            return rect.ToRectangle();
+        }
+
+        /// <summary>
+        /// Returns a GDI Plus rectangle for a RectangleF structure.
+        /// </summary>
+        /// <param name="rect">The RectangleF to get the GDI Plus rectangle for.</param>
+        /// <returns>A GDI Plus rectangle structure.</returns>
+        public static RECTF FromRectangle(RectangleF rect) {
+            return new RECTF(rect);
+        }
+
+        /// <summary>
+        /// Returns a GDI Plus rectangle for a Rectangle structure.
+        /// </summary>
+        /// <param name="rect">The Rectangle to get the GDI Plus rectangle for.</param>
+        /// <returns>A GDI Plus rectangle structure.</returns>
+        public static RECTF FromRectangle(Rectangle rect) {
+            return new RECTF(rect);
+        }
+    }
+}

GreenshotPlugin/UnmanagedHelpers/Structs/SCROLLINFO.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace GreenshotPlugin.UnmanagedHelpers.Structs
+{
+    [Serializable, StructLayout(LayoutKind.Sequential)]
+    public struct SCROLLINFO {
+        public int cbSize;
+        public int fMask;
+        public int nMin;
+        public int nMax;
+        public int nPage;
+        public int nPos;
+        public int nTrackPos;
+    }
+}

GreenshotPlugin/UnmanagedHelpers/Structs/SIZE.cs

@@ -0,0 +1,44 @@
+/*
+ * Greenshot - a free and open source screenshot tool
+ * Copyright (C) 2007-2020 Thomas Braun, Jens Klingen, Robin Krom
+ * 
+ * For more information see: http://getgreenshot.org/
+ * The Greenshot project is hosted on GitHub https://github.com/greenshot/greenshot
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 1 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System;
+using System.Drawing;
+using System.Runtime.InteropServices;
+
+namespace GreenshotPlugin.UnmanagedHelpers.Structs {
+	[StructLayout(LayoutKind.Sequential), Serializable()]
+	public struct SIZE {
+		public int Width;
+		public int Height;
+		public SIZE(Size size) : this(size.Width, size.Height) {
+			
+		}
+
+		public SIZE(int width, int height) {
+			Width = width;
+			Height = height;
+		}
+
+		public Size ToSize() {
+			return new Size(Width, Height);
+		}
+	}
+}

GreenshotPlugin/UnmanagedHelpers/Structs/WindowInfo.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace GreenshotPlugin.UnmanagedHelpers.Structs
+{
+    /// <summary>
+    /// The structure for the WindowInfo
+    /// See: http://msdn.microsoft.com/en-us/library/windows/desktop/ms632610%28v=vs.85%29.aspx
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential), Serializable]
+    public struct WindowInfo {
+        public uint cbSize;
+        public RECT rcWindow;
+        public RECT rcClient;
+        public uint dwStyle;
+        public uint dwExStyle;
+        public uint dwWindowStatus;
+        public uint cxWindowBorders;
+        public uint cyWindowBorders;
+        public ushort atomWindowType;
+        public ushort wCreatorVersion;
+        // Allows automatic initialization of "cbSize" with "new WINDOWINFO(null/true/false)".
+        public WindowInfo(bool? filler) : this() {
+            cbSize = (uint)(Marshal.SizeOf(typeof(WindowInfo)));
+        }
+    }
+}

GreenshotPlugin/UnmanagedHelpers/Structs/WindowPlacement.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Runtime.InteropServices;
+using GreenshotPlugin.UnmanagedHelpers.Enums;
+
+namespace GreenshotPlugin.UnmanagedHelpers.Structs
+{
+    /// <summary>
+    /// Contains information about the placement of a window on the screen.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential), Serializable()]
+    public struct WindowPlacement {
+        /// <summary>
+        /// The length of the structure, in bytes. Before calling the GetWindowPlacement or SetWindowPlacement functions, set this member to sizeof(WINDOWPLACEMENT).
+        /// <para>
+        /// GetWindowPlacement and SetWindowPlacement fail if this member is not set correctly.
+        /// </para>
+        /// </summary>
+        public int Length;
+
+        /// <summary>
+        /// Specifies flags that control the position of the minimized window and the method by which the window is restored.
+        /// </summary>
+        public WindowPlacementFlags Flags;
+
+        /// <summary>
+        /// The current show state of the window.
+        /// </summary>
+        public ShowWindowCommand ShowCmd;
+
+        /// <summary>
+        /// The coordinates of the window's upper-left corner when the window is minimized.
+        /// </summary>
+        public POINT MinPosition;
+
+        /// <summary>
+        /// The coordinates of the window's upper-left corner when the window is maximized.
+        /// </summary>
+        public POINT MaxPosition;
+
+        /// <summary>
+        /// The window's coordinates when the window is in the restored position.
+        /// </summary>
+        public RECT NormalPosition;
+
+        /// <summary>
+        /// Gets the default (empty) value.
+        /// </summary>
+        public static WindowPlacement Default {
+            get {
+                WindowPlacement result = new WindowPlacement();
+                result.Length = Marshal.SizeOf(result);
+                return result;
+            }
+        }
+    }
+}