Taking screenshots (screens) in a format convenient for WPF

Some time ago I needed a tool with which I could programmatically create snapshots from the whole monitor screen or from some of its areas. In this case, it is necessary to specify the area not only programmatically, but also manually by the user with the mouse. The result obtained should be immediately packed into an instance of one of the classes, which I would be convenient to use to display the resulting screen in the GUI (graphical user interface):

System.Drawing.Bitmap
System.Windows.Media.Imaging.BitmapImage
System.IO.MemoryStream

My decision on which class of objects should be packed into the final result is due to the convenience of their (classes) use in WPF:

The System.Drawing.Bitmap class contains the Save method, which allows you to write the resulting snapshot into a raster image file (specifying what type of file you should create).

The System.Windows.Media.Imaging.BitmapImage class is often used as a data source for System.Windows.Controls.Image, used in WPF to display bitmap images.

The System.IO.MemoryStream class was necessary for me in order to be able to save an image to a database table, although, of course, this is far from the only case in which an image presented in this form may be needed.

Searching Google for a ready-made solution and not finding something that would completely correspond to my desire - I sat down to write my library. I decided to implement the necessary functionality as methods of a static class. I assign the class the name ScreenManager. It should implement the following methods:

')

The end result should be presented as a dll-library with an xml-file containing information about it.

The ScreenManager class is made partial in order to distribute the code among different cs files in accordance with the logic of the actions they perform. I will have three such files:

ProgramMethods.cs
ManuallyMethods.cs
InnerMethods.cs

The ProgramMethods.cs file will contain those methods that will allow you to take pictures of the entire screen or its region in transparent mode, without requiring the user to specify the boundaries of the region manually.

The file ManuallyMethods.cs, on the contrary, should encapsulate in itself methods that will prompt the user to specify the screen area with which to take the picture. The user will have to press the left mouse button, thereby indicating the first corner of the area and, without releasing the button, indicate the opposite diagonal angle, releasing the button on it. In the process of moving the mouse pointer on the screen, the area of the selectable border should be indicated by a rectangle of a certain color, which dynamically changes its size as the mouse moves around the monitor screen. If during the selection process, the user presses the Escape key, the snapshot command should be interrupted. The color of the rectangle and the thickness of the lines should be customizable through the static RectangleBrush and RectangleLineWeigth properties of the ScreenManager class.

The InnerMethods.cs file will contain a set of helper methods necessary for the operation of the code for the ManuallyMethods.cs file.

After the library code is completely written, you will need to create a test application (let's call it “WPF test”), demonstrating the work of the library. This will be a small WPF window, with an Image and Button object, sufficient for the required demonstration.

Well, that's all ... The following is the source code for the cs-files I mentioned above:

ProgramMethods.cs file

1: using System; 2: using System.Collections. Generic ; 3: using System.Linq; 4: using System.Text; 5: using System.Windows.Forms; 6: using System.Drawing; 7: using System.Drawing.Imaging; 8: using System.Windows.Media.Imaging; 9: using System.IO; 10: using System.Windows.Shapes; 11: using System.Windows.Controls; 12: using System.Windows.Input; 13: using System.Windows; 14: 15: namespace Bushman.Screens 16: { 17: /// <summary> 18: /// 19: /// 20: /// </summary> 21: public static partial class ScreenManager 22: { 23: // , (.. ). 24: /// <summary> 25: /// , BitmapImage. . 26: /// </summary> 27: /// <param name="rect"> System.Drawing.Rectangle, , 28: /// </param> 29: /// <param name="format"> , </param> 30: /// <returns> , BitmapImage</returns> 31: public static BitmapImage GetBitmapImageFromScreen(System.Drawing.Rectangle rect, ImageFormat format) 32: { 33: using (MemoryStream ms = new MemoryStream()) 34: { 35: Screen screen = Screen.FromRectangle(rect); 36: Bitmap bitmap = new Bitmap (rect.Width, rect.Height, System.Drawing.Imaging.PixelFormat.Format32bppArgb); 37: Graphics graphics = Graphics .FromImage(bitmap); 38: graphics.CopyFromScreen(rect.X, rect.Y, 0, 0, rect.Size, CopyPixelOperation.SourceCopy); 39: bitmap.Save(ms, format); 40: BitmapImage img = new BitmapImage(); 41: img.BeginInit(); 42: img.CacheOption = BitmapCacheOption.OnLoad; 43: img.StreamSource = ms; 44: img.EndInit(); 45: return img; 46: } 47: } 48: /// <summary> 49: /// , BitmapImage. . 50: /// </summary> 51: /// <returns> , BitmapImage</returns> 52: public static BitmapImage GetBitmapImageFromScreen( ImageFormat format) 53: { 54: System.Drawing.Rectangle rect = new System.Drawing.Rectangle(0, 0, Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height); 55: return GetBitmapImageFromScreen(rect, format); 56: } 57: 58: /// <summary> 59: /// , MemoryStream. . 60: /// </summary> 61: /// <param name="rect"> System.Drawing.Rectangle, , 62: /// </param> 63: /// <param name="format"> , </param> 64: /// <returns> , MemoryStream</returns> 65: public static MemoryStream GetMemoryStreamFromScreen(System.Drawing.Rectangle rect, ImageFormat format) 66: { 67: MemoryStream ms = new MemoryStream(); 68: Screen screen = Screen.FromRectangle(rect); 69: Bitmap bitmap = new Bitmap (rect.Width, rect.Height, System.Drawing.Imaging.PixelFormat.Format32bppArgb); 70: Graphics graphics = Graphics .FromImage(bitmap); 71: graphics.CopyFromScreen(rect.X, rect.Y, 0, 0, rect.Size, CopyPixelOperation.SourceCopy); 72: bitmap.Save(ms, format); 73: return ms; 74: } 75: 76: /// <summary> 77: /// , MemoryStream. . 78: /// </summary> 79: /// <returns> , MemoryStream</returns> 80: public static MemoryStream GetMemoryStreamFromScreen( ImageFormat format) 81: { 82: System.Drawing.Rectangle rect = new System.Drawing.Rectangle(0, 0, Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height); 83: return GetMemoryStreamFromScreen(rect, format); 84: } 85: 86: /// <summary> 87: /// , Bitmap. . 88: /// </summary> 89: /// <param name="rect"> System.Drawing.Rectangle, , 90: /// </param> 91: /// <returns> , Bitmap</returns> 92: public static Bitmap GetBitmapFromScreen(System.Drawing.Rectangle rect) 93: { 94: Screen screen = Screen.FromRectangle(rect); 95: Bitmap bitmap = new Bitmap (rect.Width, rect.Height, System.Drawing.Imaging.PixelFormat.Format32bppArgb); 96: Graphics graphics = Graphics .FromImage(bitmap); 97: graphics.CopyFromScreen(rect.X, rect.Y, 0, 0, rect.Size, CopyPixelOperation.SourceCopy); 98: return bitmap; 99: } 100: 101: /// <summary> 102: /// , Bitmap. . 103: /// </summary> 104: /// <returns> , Bitmap</returns> 105: public static Bitmap GetBitmapFromScreen() 106: { 107: System.Drawing.Rectangle rect = new System.Drawing.Rectangle(0, 0, Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height); 108: return GetBitmapFromScreen(rect); 109: } 110: } 111: } * This source code was highlighted with Source Code Highlighter .

ManuallyMethods.cs file

1: using System; 2: using System.Collections. Generic ; 3: using System.Linq; 4: using System.Text; 5: using System.Windows.Forms; 6: using System.Drawing; 7: using System.Drawing.Imaging; 8: using System.Windows.Media.Imaging; 9: using System.IO; 10: using System.Windows.Shapes; 11: using System.Windows.Controls; 12: using System.Windows.Input; 13: using System.Windows; 14: 15: namespace Bushman.Screens 16: { 17: // , () 18: public static partial class ScreenManager 19: { 20: // , () , 21: //************************************** 22: 23: // , : 24: static Window win; //, 25: static System.Windows.Point firstPoint; // 26: static System.Windows.Point secondPoint; // ( ) 27: static Canvas canvas; 28: static System.Windows.Controls.Image image; 29: static List <Line> lines; // , 30: static ImageFormat format; 31: static MemoryStream result; 32: static System.Windows.Media.Brush rectangleBrush = System.Windows.Media.Brushes.Black; 33: static double rectangleLineWeigth = 5; 34: 35: /// <summary> 36: /// , 37: /// </summary> 38: public static System.Windows.Media.Brush RectangleBrush 39: { 40: get { return rectangleBrush; } 41: set { rectangleBrush = value ; } 42: } 43: /// <summary> 44: /// , 45: /// </summary> 46: public static double RectangleLineWeigth 47: { 48: get { return rectangleLineWeigth; } 49: set { rectangleLineWeigth = value ; } 50: } 51: 52: /// <summary> 53: /// , 54: /// </summary> 55: /// <param name="imgFormat"> , </param> 56: /// <returns> MemoryStream</returns> 57: public static MemoryStream GetMemoryStreamFromScreenManually( ImageFormat imgFormat) 58: { 59: format = imgFormat; 60: // , 61: win = new Window() { WindowState = WindowState.Maximized, WindowStyle = WindowStyle.None }; 62: 63: // , BitmapImage 64: BitmapImage bitmapImage = ScreenManager.GetBitmapImageFromScreen( ImageFormat .Png); 65: 66: // 67: image = new System.Windows.Controls.Image() { Source = bitmapImage }; 68: canvas = new Canvas() { Width = Screen.PrimaryScreen.Bounds.Width, Height = Screen.PrimaryScreen.Bounds.Height }; 69: canvas.Children.Add(image); 70: Canvas.SetTop(image, 0); 71: Canvas.SetLeft(image, 0); 72: win.Content = canvas; 73: 74: // 75: image.MouseLeftButtonDown += new MouseButtonEventHandler(image_MouseLeftButtonDown); 76: // 77: // 78: image.MouseMove += new System.Windows.Input.MouseEventHandler(image_MouseMove); 79: 80: //================ 81: //************************************************************ 82: //================ 83: 84: // , 2- , 85: // , 86: image.MouseLeftButtonUp += new MouseButtonEventHandler(image_MouseLeftButtonUp); 87: // Escape , , 88: image.KeyDown += new System.Windows.Input.KeyEventHandler(image_KeyDown); 89: // 90: win.ShowDialog(); 91: return result; 92: } 93: 94: /// <summary> 95: /// , 96: /// </summary> 97: /// <param name="imgFormat"> , </param> 98: /// <returns> Bitmap</returns> 99: public static Bitmap GetBitmapFromScreenManually( ImageFormat imgFormat) 100: { 101: MemoryStream ms = GetMemoryStreamFromScreenManually(imgFormat); 102: return new Bitmap (ms); 103: } 104: 105: /// <summary> 106: /// , 107: /// </summary> 108: /// <param name="imgFormat"> , </param> 109: /// <returns> BitmapImage</returns> 110: public static BitmapImage GetBitmapImageFromScreenManually( ImageFormat imgFormat) 111: { 112: MemoryStream ms = GetMemoryStreamFromScreenManually(imgFormat); 113: BitmapImage bitmapImg = new BitmapImage(); 114: bitmapImg.BeginInit(); 115: bitmapImg.CacheOption = BitmapCacheOption.OnLoad; 116: bitmapImg.StreamSource = ms; 117: bitmapImg.EndInit(); 118: bitmapImg.Freeze(); 119: return bitmapImg; 120: } 121: } 122: } * This source code was highlighted with Source Code Highlighter .

InnerMethods.cs file

1: using System; 2: using System.Collections. Generic ; 3: using System.Linq; 4: using System.Text; 5: using System.Windows.Forms; 6: using System.Drawing; 7: using System.Drawing.Imaging; 8: using System.Windows.Media.Imaging; 9: using System.IO; 10: using System.Windows.Shapes; 11: using System.Windows.Controls; 12: using System.Windows.Input; 13: using System.Windows; 14: 15: namespace Bushman.Screens 16: { 17: // , () 18: public static partial class ScreenManager 19: { 20: static void image_KeyDown( object sender, System.Windows.Input.KeyEventArgs e) 21: { 22: if (e.Key == Key.Escape) win.Close(); 23: } 24: 25: static void image_MouseLeftButtonDown( object sender, MouseButtonEventArgs e) 26: { 27: firstPoint = e.GetPosition(win); 28: lines = new List <Line>(); 29: for ( int i = 0; i < 4; i++) 30: { 31: Line item = new Line(); 32: item.Stroke = RectangleBrush; 33: item.StrokeThickness = RectangleLineWeigth; 34: canvas.Children.Add(item); 35: Canvas.SetTop(item, firstPoint.Y); 36: Canvas.SetLeft(item, firstPoint.X); 37: item.StrokeEndLineCap = System.Windows.Media.PenLineCap.Round; 38: item.StrokeStartLineCap = System.Windows.Media.PenLineCap.Round; 39: item.Y2 = 0; 40: item.X2 = 0; 41: lines.Add(item); 42: item.MouseLeftButtonUp += new MouseButtonEventHandler(image_MouseLeftButtonUp); 43: item.KeyDown += new System.Windows.Input.KeyEventHandler(image_KeyDown); 44: } 45: } 46: 47: static void image_MouseMove( object sender, System.Windows.Input.MouseEventArgs e) 48: { 49: if (e.LeftButton == MouseButtonState.Pressed) 50: { 51: lines[0].Y2 = e.GetPosition(win).Y - firstPoint.Y; 52: 53: lines[1].X2 = e.GetPosition(win).X - firstPoint.X; 54: 55: lines[2].Y1 = lines[0].Y2; 56: lines[2].Y2 = lines[2].Y1; 57: lines[2].X2 = lines[1].X2; 58: 59: lines[3].X1 = lines[1].X2; 60: lines[3].X2 = lines[3].X1; 61: lines[3].Y2 = lines[0].Y2; 62: } 63: } 64: 65: static void image_MouseLeftButtonUp( object sender, MouseButtonEventArgs e) 66: { 67: GetSecondPoint(e.GetPosition(win)); 68: } 69: 70: static void GetSecondPoint(System.Windows.Point point) 71: { 72: foreach (Line line in lines) 73: { 74: canvas.Children.Remove(line); 75: } 76: secondPoint = point; 77: int top = ( int ) Math .Min(firstPoint.Y, secondPoint.Y); 78: int left = ( int ) Math .Min(firstPoint.X, secondPoint.X); 79: int height = ( int )( Math .Max(firstPoint.Y, secondPoint.Y) - Math .Min(firstPoint.Y, secondPoint.Y)); 80: int width = ( int )( Math .Max(firstPoint.X, secondPoint.X) - Math .Min(firstPoint.X, secondPoint.X)); 81: 82: // , , 83: System.Drawing.Rectangle rect = new System.Drawing.Rectangle(left, top, width, height); 84: result = ScreenManager.GetMemoryStreamFromScreen(rect, format); 85: // 86: win.Close(); 87: } 88: //************************************** 89: } 90: } * This source code was highlighted with Source Code Highlighter .

The following is the code for the WpfTest test application:

Window1.xaml file

1: < Window x:Class ="WpfTest.Window1" 2: xmlns ="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 3: xmlns:x ="http://schemas.microsoft.com/winfx/2006/xaml" 4: Title ="ScreenManager testing" Height ="300" Width ="300" > 5: < Grid > 6: < Grid.RowDefinitions > 7: < RowDefinition Height ="100*" /> 8: < RowDefinition Height ="Auto" /> 9: </ Grid.RowDefinitions > 10: < Image Name ="img" HorizontalAlignment ="Center" ></ Image > 11: < StackPanel Name ="stack" Grid . Row ="1" > 12: < Button Name ="btnSaveScreen" > Save screen (manually method) </ Button > 13: </ StackPanel > 14: </ Grid > 15: </ Window > * This source code was highlighted with Source Code Highlighter .

Window1.xaml.cs file

1: using System; 2: using System.Collections. Generic ; 3: using System.Linq; 4: using System.Text; 5: using System.Windows; 6: using System.Windows.Controls; 7: using System.Windows.Data; 8: using System.Windows.Documents; 9: using System.Windows.Input; 10: using System.Windows.Media; 11: using System.Windows.Media.Imaging; 12: using System.Windows.Navigation; 13: using System.Windows.Shapes; 14: using System.Drawing.Imaging; 15: using System.Drawing; 16: using Bushman.Screens; 17: using System.IO; 18: 19: namespace WpfTest 20: { 21: /// <summary> 22: /// Interaction logic for Window1.xaml 23: /// </summary> 24: public partial class Window1 : Window 25: { 26: public Window1() 27: { 28: InitializeComponent(); 29: MyInitialize(); 30: } 31: void MyInitialize() 32: { 33: btnSaveScreen.Click += new RoutedEventHandler(btnSaveScreenManually_Click); 34: } 35: 36: void btnSaveScreenManually_Click( object sender, RoutedEventArgs e) 37: { 38: string dirName = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "ScreenResults" ); 39: DirectoryInfo dir = new DirectoryInfo(dirName); 40: if (!dir.Exists) dir = Directory .CreateDirectory(dirName); 41: System.Drawing.Rectangle rect = new System.Drawing.Rectangle(50, 50, 300, 200); 42: Bitmap bitmap; 43: MemoryStream ms; 44: 45: /// , . , 46: /// . 47: 48: // 1 49: //bitmap = ScreenManager.GetBitmapFromScreen(); 50: //bitmap.Save(System.IO.Path.Combine(dir.FullName, "GetBitmapFromScreen_0.png")); 51: //bitmap.Dispose(); 52: 53: // 2 54: //bitmap = ScreenManager.GetBitmapFromScreen(rect); 55: //bitmap.Save(System.IO.Path.Combine(dir.FullName, "GetBitmapFromScreen_1.png")); 56: //bitmap.Dispose(); 57: 58: // 3 59: //bitmap = ScreenManager.GetBitmapFromScreenManually(ImageFormat.Png); 60: //bitmap.Save(System.IO.Path.Combine(dir.FullName, "GetBitmapFromScreenManually.png")); 61: //bitmap.Dispose(); 62: 63: // 4 64: //img.Source = ScreenManager.GetBitmapImageFromScreen(ImageFormat.Png); 65: 66: // 5 67: //img.Source = ScreenManager.GetBitmapImageFromScreen(rect, ImageFormat.Png); 68: 69: // 6 70: img.Source = ScreenManager.GetBitmapImageFromScreenManually( ImageFormat .Png); 71: 72: // 7 73: //ms = ScreenManager.GetMemoryStreamFromScreen(ImageFormat.Png); 74: //bitmap = new Bitmap(ms); 75: //bitmap.Save(System.IO.Path.Combine(dir.FullName, "GetMemoryStreamFromScreen_0.png")); 76: //bitmap.Dispose(); 77: 78: // 8 79: //ms = ScreenManager.GetMemoryStreamFromScreen(rect, ImageFormat.Png); 80: //bitmap = new Bitmap(ms); 81: //bitmap.Save(System.IO.Path.Combine(dir.FullName, "GetMemoryStreamFromScreen_1.png")); 82: //bitmap.Dispose(); 83: 84: // 9 85: //ms = ScreenManager.GetMemoryStreamFromScreenManually(ImageFormat.Png); 86: //bitmap = new Bitmap(ms); 87: //bitmap.Save(System.IO.Path.Combine(dir.FullName, "GetMemoryStreamFromScreenManually.png")); 88: //bitmap.Dispose(); 89: } 90: } 91: } * This source code was highlighted with Source Code Highlighter .

The result of the test application is as follows (the result is displayed in the “ScreenManager testing” window):

The code is written using MS Visual Studio 2008 SP1 and .Net Framework 3.5 SP1.

The source code of the project is here .

Release version of the library here .

Source: https://habr.com/ru/post/94292/

All Articles

Taking screenshots (screens) in a format convenient for WPF

More articles: