#region License Information (GPL v3)
/*
ShareX - A program that allows you to take screenshots and share any file type
Copyright (C) 2007-2015 ShareX Developers
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 2
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, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
Optionally you can also view the license at .
*/
#endregion License Information (GPL v3)
using System;
using System.Drawing;
using System.Globalization;
using System.Runtime.InteropServices;
namespace ShareX.HelpersLib
{
[StructLayout(LayoutKind.Sequential)]
public struct RECT
{
public int Left, Top, Right, Bottom;
public RECT(int left, int top, int right, int bottom)
{
Left = left;
Top = top;
Right = right;
Bottom = bottom;
}
public RECT(Rectangle r)
: this(r.Left, r.Top, r.Right, r.Bottom)
{
}
public int X
{
get { return Left; }
set { Right -= (Left - value); Left = value; }
}
public int Y
{
get { return Top; }
set { Bottom -= (Top - value); Top = value; }
}
public int Width
{
get { return Right - Left; }
set { Right = value + Left; }
}
public int Height
{
get { return Bottom - Top; }
set { Bottom = value + Top; }
}
public Point Location
{
get { return new Point(Left, Top); }
set { X = value.X; Y = value.Y; }
}
public Size Size
{
get { return new Size(Width, Height); }
set { Width = value.Width; Height = value.Height; }
}
public static implicit operator Rectangle(RECT r)
{
return new Rectangle(r.Left, r.Top, r.Width, r.Height);
}
public static implicit operator RECT(Rectangle r)
{
return new RECT(r);
}
public static bool operator ==(RECT r1, RECT r2)
{
return r1.Equals(r2);
}
public static bool operator !=(RECT r1, RECT r2)
{
return !r1.Equals(r2);
}
public bool Equals(RECT r)
{
return r.Left == Left && r.Top == Top && r.Right == Right && r.Bottom == Bottom;
}
public override bool Equals(object obj)
{
if (obj is RECT)
{
return Equals((RECT)obj);
}
if (obj is Rectangle)
{
return Equals(new RECT((Rectangle)obj));
}
return false;
}
public override int GetHashCode()
{
return ((Rectangle)this).GetHashCode();
}
public override string ToString()
{
return string.Format(CultureInfo.CurrentCulture, "{{Left={0},Top={1},Right={2},Bottom={3}}}", Left, Top, Right, Bottom);
}
}
[StructLayout(LayoutKind.Sequential)]
public struct SIZE
{
public int Width;
public int Height;
public SIZE(int width, int height)
{
Width = width;
Height = height;
}
public static explicit operator Size(SIZE s)
{
return new Size(s.Width, s.Height);
}
public static explicit operator SIZE(Size s)
{
return new SIZE(s.Width, s.Height);
}
public override string ToString()
{
return string.Format("{0}x{1}", Width, Height);
}
}
[StructLayout(LayoutKind.Sequential)]
public struct POINT
{
public int X;
public int Y;
public POINT(int x, int y)
{
X = x;
Y = y;
}
public static explicit operator Point(POINT p)
{
return new Point(p.X, p.Y);
}
public static explicit operator POINT(Point p)
{
return new POINT(p.X, p.Y);
}
}
[StructLayout(LayoutKind.Sequential)]
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;
public WINDOWINFO(Boolean? filler)
: this() // Allows automatic initialization of "cbSize" with "new WINDOWINFO(null/true/false)".
{
cbSize = (UInt32)(Marshal.SizeOf(typeof(WINDOWINFO)));
}
}
public struct WINDOWPLACEMENT
{
public int length;
public int flags;
public WindowShowStyle showCmd;
public POINT ptMinPosition;
public POINT ptMaxPosition;
public RECT rcNormalPosition;
}
public struct BLENDFUNCTION
{
public byte BlendOp;
public byte BlendFlags;
public byte SourceConstantAlpha;
public byte AlphaFormat;
}
[StructLayout(LayoutKind.Sequential)]
public struct APPBARDATA
{
public int cbSize;
public IntPtr hWnd;
public int uCallbackMessage;
public int uEdge;
public RECT rc;
public IntPtr lParam;
public static APPBARDATA NewAPPBARDATA()
{
APPBARDATA abd = new APPBARDATA();
abd.cbSize = Marshal.SizeOf(typeof(APPBARDATA));
return abd;
}
}
[StructLayout(LayoutKind.Sequential)]
public struct DWM_BLURBEHIND
{
public DWM_BB dwFlags;
public bool fEnable;
public IntPtr hRgnBlur;
public bool fTransitionOnMaximized;
}
[StructLayout(LayoutKind.Sequential)]
public struct MARGINS
{
public int leftWidth;
public int rightWidth;
public int topHeight;
public int bottomHeight;
}
[StructLayout(LayoutKind.Sequential)]
public struct DWM_THUMBNAIL_PROPERTIES
{
public int dwFlags;
public RECT rcDestination;
public RECT rcSource;
public byte opacity;
public bool fVisible;
public bool fSourceClientAreaOnly;
}
[StructLayout(LayoutKind.Sequential)]
public struct CursorInfo
{
public Int32 cbSize; // Specifies the size, in bytes, of the structure.
public Int32 flags; // Specifies the cursor state. This parameter can be one of the following values:
public IntPtr hCursor; // Handle to the cursor.
public Point ptScreenPos; // A POINT structure that receives the screen coordinates of the cursor.
}
[StructLayout(LayoutKind.Sequential)]
public struct IconInfo
{
public bool fIcon; // Specifies whether this structure defines an icon or a cursor. A value of TRUE specifies
public Int32 xHotspot; // Specifies the x-coordinate of a cursor's hot spot. If this structure defines an icon, the hot
public Int32 yHotspot; // Specifies the y-coordinate of the cursor's hot spot. If this structure defines an icon, the hot
public IntPtr hbmMask; // (HBITMAP) Specifies the icon bitmask bitmap. If this structure defines a black and white icon,
public IntPtr hbmColor; // (HBITMAP) Handle to the icon color bitmap. This member can be optional if this
}
///
/// Structure, which contains information for a single stream .
///
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode, Pack = 1)]
public struct AVISTREAMINFO
{
///
/// Four-character code indicating the stream type.
///
///
[MarshalAs(UnmanagedType.I4)]
public int type;
///
/// Four-character code of the compressor handler that will compress this video stream when it is saved.
///
///
[MarshalAs(UnmanagedType.I4)]
public int handler;
///
/// Applicable flags for the stream.
///
///
[MarshalAs(UnmanagedType.I4)]
public int flags;
///
/// Capability flags; currently unused.
///
///
[MarshalAs(UnmanagedType.I4)]
public int Capabilities;
///
/// Priority of the stream.
///
///
[MarshalAs(UnmanagedType.I2)]
public short priority;
///
/// Language of the stream.
///
///
[MarshalAs(UnmanagedType.I2)]
public short language;
///
/// Time scale applicable for the stream.
///
///
/// Dividing rate by scale gives the playback rate in number of samples per second.
///
[MarshalAs(UnmanagedType.I4)]
public int scale;
///
/// Rate in an integer format.
///
///
[MarshalAs(UnmanagedType.I4)]
public int rate;
///
/// Sample number of the first frame of the AVI file.
///
///
[MarshalAs(UnmanagedType.I4)]
public int start;
///
/// Length of this stream.
///
///
/// The units are defined by rate and scale.
///
[MarshalAs(UnmanagedType.I4)]
public int length;
///
/// Audio skew. This member specifies how much to skew the audio data ahead of the video frames in interleaved files.
///
///
[MarshalAs(UnmanagedType.I4)]
public int initialFrames;
///
/// Recommended buffer size, in bytes, for the stream.
///
///
[MarshalAs(UnmanagedType.I4)]
public int suggestedBufferSize;
///
/// Quality indicator of the video data in the stream.
///
///
/// Quality is represented as a number between 0 and 10,000.
///
[MarshalAs(UnmanagedType.I4)]
public int quality;
///
/// Size, in bytes, of a single data sample.
///
///
[MarshalAs(UnmanagedType.I4)]
public int sampleSize;
///
/// Dimensions of the video destination rectangle.
///
///
[MarshalAs(UnmanagedType.Struct, SizeConst = 16)]
public RECT rectFrame;
///
/// Number of times the stream has been edited.
///
///
[MarshalAs(UnmanagedType.I4)]
public int editCount;
///
/// Number of times the stream format has changed.
///
///
[MarshalAs(UnmanagedType.I4)]
public int formatChangeCount;
///
/// Description of the stream.
///
///
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
public string name;
}
///
/// Structure, which contains information about a stream and how it is compressed and saved.
///
[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct AVICOMPRESSOPTIONS
{
///
/// Four-character code indicating the stream type.
///
///
[MarshalAs(UnmanagedType.I4)]
public int type;
///
/// Four-character code for the compressor handler that will compress this video stream when it is saved.
///
///
[MarshalAs(UnmanagedType.I4)]
public int handler;
///
/// Maximum period between video key frames.
///
///
[MarshalAs(UnmanagedType.I4)]
public int keyFrameEvery;
///
/// Quality value passed to a video compressor.
///
///
[MarshalAs(UnmanagedType.I4)]
public int quality;
///
/// Video compressor data rate.
///
///
[MarshalAs(UnmanagedType.I4)]
public int bytesPerSecond;
///
/// Flags used for compression.
///
///
[MarshalAs(UnmanagedType.I4)]
public int flags;
///
/// Pointer to a structure defining the data format.
///
///
[MarshalAs(UnmanagedType.I4)]
public int format;
///
/// Size, in bytes, of the data referenced by format.
///
///
[MarshalAs(UnmanagedType.I4)]
public int formatSize;
///
/// Video-compressor-specific data; used internally.
///
///
[MarshalAs(UnmanagedType.I4)]
public int parameters;
///
/// Size, in bytes, of the data referenced by parameters.
///
[MarshalAs(UnmanagedType.I4)]
public int parametersSize;
///
/// Interleave factor for interspersing stream data with data from the first stream.
///
///
[MarshalAs(UnmanagedType.I4)]
public int interleaveEvery;
}
[StructLayout(LayoutKind.Sequential)]
public struct BITMAPINFOHEADER
{
public uint biSize;
public int biWidth;
public int biHeight;
public ushort biPlanes;
public ushort biBitCount;
public BitmapCompressionMode biCompression;
public uint biSizeImage;
public int biXPelsPerMeter;
public int biYPelsPerMeter;
public uint biClrUsed;
public uint biClrImportant;
public BITMAPINFOHEADER(int width, int height, ushort bitCount)
{
biSize = (uint)Marshal.SizeOf(typeof(BITMAPINFOHEADER));
biWidth = width;
biHeight = height;
biPlanes = 1;
biBitCount = bitCount;
biCompression = BitmapCompressionMode.BI_RGB;
biSizeImage = 0;
biXPelsPerMeter = 0;
biYPelsPerMeter = 0;
biClrUsed = 0;
biClrImportant = 0;
}
}
}