mirror of
https://github.com/ShareX/ShareX.git
synced 2024-08-20 12:41:29 +12:00
Merge commits from Greenshot up through bd71f47e95a46642fe6a83bdd76cc4d2a7eed7c2. Some bug fixes, but mostly structural cleanup.
496 lines
No EOL
13 KiB
C#
496 lines
No EOL
13 KiB
C#
/*
|
|
* Greenshot - a free and open source screenshot tool
|
|
* Copyright (C) 2007-2015 Thomas Braun, Jens Klingen, Robin Krom
|
|
*
|
|
* For more information see: http://getgreenshot.org/
|
|
* The Greenshot project is hosted on Sourceforge: http://sourceforge.net/projects/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
|
|
{
|
|
[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);
|
|
}
|
|
}
|
|
|
|
[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);
|
|
}
|
|
|
|
override public string ToString()
|
|
{
|
|
return X + "," + Y;
|
|
}
|
|
}
|
|
|
|
[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;
|
|
}
|
|
}
|
|
|
|
/// <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);
|
|
}
|
|
}
|
|
|
|
/// <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(Boolean? filler) : this()
|
|
{
|
|
cbSize = (UInt32)(Marshal.SizeOf(typeof(WindowInfo)));
|
|
}
|
|
}
|
|
|
|
/// <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;
|
|
}
|
|
}
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct CursorInfo
|
|
{
|
|
public Int32 cbSize;
|
|
public Int32 flags;
|
|
public IntPtr hCursor;
|
|
public POINT ptScreenPos;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct IconInfo
|
|
{
|
|
public bool fIcon;
|
|
public Int32 xHotspot;
|
|
public Int32 yHotspot;
|
|
public IntPtr hbmMask;
|
|
public IntPtr hbmColor;
|
|
}
|
|
|
|
[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;
|
|
}
|
|
} |