LINQPad Snippets

Drawing.Extensions.cs

public static class PointExtensions
{
	public static Point CenterOffset(this Point p, Size region)
	{
		return new Point(p.X - region.Width / 2, p.Y - region.Height / 2);
	}
}
public static class ImageExtensions
{
	public static Bitmap ScaleUp(this Bitmap image, int scale)
	{
		if (scale < 1) throw new ArgumentException();
		if (scale == 1) return image;

		var result = new Bitmap(image.Width * scale, image.Height * scale, image.PixelFormat);
		for (int x = 0; x < image.Width; x++)
			for (int y = 0; y < image.Height; y++)
			{
				var color = image.GetPixel(x, y);

				for (int dx = scale * x; dx < scale *x + scale; dx++)
					for (int dy = scale * y; dy < scale * y + scale; dy++)
						result.SetPixel(dx, dy, color);
			}

		return result;
	}
}

Graphic.cs

public class Graphic
{
	public static Bitmap Screenshot(int x, int y, int width, int height) => Screenshot(new Point(x, y), new Size(width, height));
	public static Bitmap Screenshot(Point location, Size size)
	{
		var result = new Bitmap(size.Width, size.Height, PixelFormat.Format32bppArgb);

		using (var source = Graphics.FromHwnd(IntPtr.Zero))
		using (var destination = Graphics.FromImage(result))
		{
			var ret = BitBlt(
				destination.GetHdc(),
				0, 0,
				size.Width, size.Height,
				source.GetHdc(),
				location.X, location.Y,
				(int)CopyPixelOperation.SourceCopy);

			source.ReleaseHdc();
			destination.ReleaseHdc();
		}

		return result;
	}
}

Keyboard.cs

// usage
var trigger = Observable.Using(
    () => new KeyboardHook().RegisterHotKey(Modifiers, Hotkey),
    hook => Observable.FromEventPattern<KeyPressedEventArgs>(
        h => hook.KeyPressed += h,
        h => hook.KeyPressed -= h));

#region KeyboardHook
// source: https://stackoverflow.com/a/27309185

public sealed class KeyboardHook : IDisposable
{
	// Registers a hot key with Windows.
	[DllImport("user32.dll")]
	private static extern bool RegisterHotKey(IntPtr hWnd, int id, uint fsModifiers, uint vk);
	// Unregisters the hot key with Windows.
	[DllImport("user32.dll")]
	private static extern bool UnregisterHotKey(IntPtr hWnd, int id);

	/// <summary>
	/// Represents the window that is used internally to get the messages.
	/// </summary>
	private class Window : NativeWindow, IDisposable
	{
		private static int WM_HOTKEY = 0x0312;

		public Window()
		{
			// create the handle for the window.
			this.CreateHandle(new CreateParams());
		}

		/// <summary>
		/// Overridden to get the notifications.
		/// </summary>
		/// <param name="m"></param>
		protected override void WndProc(ref Message m)
		{
			base.WndProc(ref m);

			// check if we got a hot key pressed.
			if (m.Msg == WM_HOTKEY)
			{
				// get the keys.
				Keys key = (Keys)(((int)m.LParam >> 16) & 0xFFFF);
				ModifierKeys modifier = (ModifierKeys)((int)m.LParam & 0xFFFF);

				// invoke the event to notify the parent.
				if (KeyPressed != null)
					KeyPressed(this, new KeyPressedEventArgs(modifier, key));
			}
		}

		public event EventHandler<KeyPressedEventArgs> KeyPressed;

		#region IDisposable Members

		public void Dispose()
		{
			this.DestroyHandle();
		}

		#endregion
	}

	private Window _window = new Window();
	private int _currentId;

	public KeyboardHook()
	{
		// register the event of the inner native window.
		_window.KeyPressed += delegate (object sender, KeyPressedEventArgs args)
		{
			if (KeyPressed != null)
				KeyPressed(this, args);
		};
	}

	/// <summary>
	/// Registers a hot key in the system.
	/// </summary>
	/// <param name="modifier">The modifiers that are associated with the hot key.</param>
	/// <param name="key">The key itself that is associated with the hot key.</param>
	public KeyboardHook RegisterHotKey(ModifierKeys modifier, Keys key)
	{
		// increment the counter.
		_currentId = _currentId + 1;

		// register the hot key.
		if (!RegisterHotKey(_window.Handle, _currentId, (uint)modifier, (uint)key))
			throw new InvalidOperationException("Couldn’t register the hot key.");

		return this;
	}

	/// <summary>
	/// A hot key has been pressed.
	/// </summary>
	public event EventHandler<KeyPressedEventArgs> KeyPressed;

	#region IDisposable Members

	public void Dispose()
	{
		// unregister all the registered hot keys.
		for (int i = _currentId; i > 0; i--)
		{
			UnregisterHotKey(_window.Handle, i);
		}

		// dispose the inner native window.
		_window.Dispose();
	}

	#endregion
}

/// <summary>
/// Event Args for the event that is fired after the hot key has been pressed.
/// </summary>
public class KeyPressedEventArgs : EventArgs
{
	private ModifierKeys _modifier;
	private Keys _key;

	internal KeyPressedEventArgs(ModifierKeys modifier, Keys key)
	{
		_modifier = modifier;
		_key = key;
	}

	public ModifierKeys Modifier
	{
		get { return _modifier; }
	}

	public Keys Key
	{
		get { return _key; }
	}
}

/// <summary>
/// The enumeration of possible modifiers.
/// </summary>
[Flags]
public enum ModifierKeys : uint
{
	None = 0,
	Alt = 1,
	Control = 2,
	Shift = 4,
	Win = 8
}

#endregion