//******************************************************************************************************
//  ScreenArea.cs - Gbtc
//
//  Copyright © 2012, Grid Protection Alliance.  All Rights Reserved.
//
//  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See
//  the NOTICE file distributed with this work for additional information regarding copyright ownership.
//  The GPA licenses this file to you under the MIT License (MIT), the "License"; you may
//  not use this file except in compliance with the License. You may obtain a copy of the License at:
//
//      http://www.opensource.org/licenses/MIT
//
//  Unless agreed to in writing, the subject software distributed under the License is distributed on an
//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the
//  License for the specific language governing permissions and limitations.
//
//  Code Modification History:
//  ----------------------------------------------------------------------------------------------------
//  10/01/2008 - J. Ritchie Carroll
//       Generated original version of source code.
//  08/10/2009 - Josh L. Patterson
//       Edited Comments.
//  09/14/2009 - Stephen C. Wills
//       Added new header and license agreement.
//  12/14/2012 - Starlynn Danyelle Gilliam
//       Modified Header.
//
//******************************************************************************************************

using System.Drawing;
using System.Drawing.Imaging;
using System.Windows.Forms;
using GSF.Drawing;

namespace GSF.Windows.Forms
{
    /// <summary>Returns screen area statistics and capture functionality for all connected screens.</summary>
    public static class ScreenArea
    {
        /// <summary>
        /// Gets the least "x" coordinate of all screens on the system
        /// </summary>
        /// <returns>The smallest visible "x" screen coordinate</returns>
        public static int LeftMostBound
        {
            get
            {
                int leftBound = int.MaxValue;

                // Return the left-most "x" screen coordinate
                foreach (Screen display in Screen.AllScreens)
                {
                    if (leftBound > display.Bounds.X)
                        leftBound = display.Bounds.X;
                }

                return leftBound;
            }
        }

        /// <summary>
        /// Gets the greatest "x" coordinate of all screens on the system
        /// </summary>
        /// <returns>The largest visible "x" screen coordinate</returns>
        public static int RightMostBound
        {
            get
            {
                int rightBound = int.MinValue;

                // Return the right-most "x" screen coordinate
                foreach (Screen display in Screen.AllScreens)
                {
                    if (rightBound < display.Bounds.X + display.Bounds.Width)
                        rightBound = display.Bounds.X + display.Bounds.Width;
                }

                return rightBound;
            }
        }

        /// <summary>
        /// Gets the least "y" coordinate of all screens on the system
        /// </summary>
        /// <returns>The smallest visible "y" screen coordinate</returns>
        public static int TopMostBound
        {
            get
            {
                int topBound = int.MaxValue;

                // Return the top-most "y" screen coordinate
                foreach (Screen display in Screen.AllScreens)
                {
                    if (topBound > display.Bounds.Y)
                        topBound = display.Bounds.Y;
                }

                return topBound;
            }
        }

        /// <summary>
        /// Gets the greatest "y" coordinate of all screens on the system
        /// </summary>
        /// <returns>The largest visible "y" screen coordinate</returns>
        public static int BottomMostBound
        {
            get
            {
                int bottomBound = int.MinValue;

                // Return the bottom-most "y" screen coordinate
                foreach (Screen display in Screen.AllScreens)
                {
                    if (bottomBound < display.Bounds.Y + display.Bounds.Height)
                        bottomBound = display.Bounds.Y + display.Bounds.Height;
                }

                return bottomBound;
            }
        }

        /// <summary>
        /// Gets the width of the screen with the highest resolution.
        /// </summary>
        /// <returns>The width of the screen with the highest resolution.</returns>
        public static int MaximumWidth
        {
            get
            {
                int maxWidth = int.MinValue;

                // In this case we just get the largest screen height
                foreach (Screen display in Screen.AllScreens)
                {
                    if (maxWidth < display.Bounds.Width)
                        maxWidth = display.Bounds.Width;
                }

                return maxWidth;
            }
        }

        /// <summary>
        /// Gets the width of the screen with the lowest resolution.
        /// </summary>
        /// <returns>The width of the screen with the lowest resolution.</returns>
        public static int MinimumWidth
        {
            get
            {
                int minWidth = int.MaxValue;

                // In this case we just get the smallest screen height
                foreach (Screen display in Screen.AllScreens)
                {
                    if (minWidth > display.Bounds.Width)
                        minWidth = display.Bounds.Width;
                }

                return minWidth;
            }
        }

        /// <summary>
        /// Gets the height of the screen with the highest resolution.
        /// </summary>
        /// <returns>The height of the screen with the highest resolution.</returns>
        public static int MaximumHeight
        {
            get
            {
                int maxHeight = int.MinValue;

                // In this case we just get the largest screen height
                foreach (Screen display in Screen.AllScreens)
                {
                    if (maxHeight < display.Bounds.Height)
                        maxHeight = display.Bounds.Height;
                }

                return maxHeight;
            }
        }

        /// <summary>
        /// Gets the height of the screen with the lowest resolution.
        /// </summary>
        /// <returns>The height of the screen with the lowest resolution.</returns>
        public static int MinimumHeight
        {
            get
            {
                int minHeight = int.MaxValue;

                // In this case we just get the smallest screen height
                foreach (Screen display in Screen.AllScreens)
                {
                    if (minHeight > display.Bounds.Height)
                        minHeight = display.Bounds.Height;
                }

                return minHeight;
            }
        }

        /// <summary>
        /// Gets the total width of all the screens relative to their arrangement.
        /// </summary>
        /// <returns>The total width of all the screens relative to their arrangement.</returns>
        public static int TotalWidth
        {
            get
            {
                return RightMostBound - LeftMostBound;
            }
        }

        /// <summary>
        /// Gets the total height of all the screens relative to their arrangement.
        /// </summary>
        /// <returns>The total height of all the screens relative to their arrangement.</returns>
        public static int TotalHeight
        {
            get
            {
                return BottomMostBound - TopMostBound;
            }
        }

        /// <summary>
        /// Performs screen capture over all monitors.
        /// </summary>
        /// <returns>Captured screen image over all monitors.</returns>
        /// <remarks>
        /// Size captured will be for total width and height of all screens relative to their arrangement.
        /// An image square will be created large enough to cover all screens for the capture.
        /// </remarks>
        public static Bitmap Capture()
        {
            return Capture(new Rectangle(LeftMostBound, TopMostBound, TotalWidth, TotalHeight));
        }

        /// <summary>
        /// Performs screen capture over all monitors.
        /// </summary>
        /// <param name="imageFormat">Desired <see cref="ImageFormat"/> for captured <see cref="Bitmap"/>.</param>
        /// <returns>Captured screen image over all monitors.</returns>
        /// <remarks>
        /// Size captured will be for total width and height of all screens relative to their arrangement.
        /// An image square will be created large enough to cover all screens for the capture.
        /// </remarks>
        public static Bitmap Capture(ImageFormat imageFormat)
        {
            return Capture(new Rectangle(LeftMostBound, TopMostBound, TotalWidth, TotalHeight), imageFormat);
        }

        /// <summary>
        /// Performs screen capture for given <see cref="Screen"/>.
        /// </summary>
        /// <param name="captureScreen">A <see cref="Screen"/> object to capture.</param>
        /// <returns>Captured screen image for given <see cref="Screen"/>.</returns>
        public static Bitmap Capture(Screen captureScreen)
        {
            return Capture(captureScreen.Bounds);
        }

        /// <summary>
        /// Performs screen capture for given <see cref="Screen"/> and <see cref="ImageFormat"/>.
        /// </summary>
        /// <param name="captureScreen">Desired <see cref="Screen"/> to capture</param>
        /// <param name="imageFormat">Desired <see cref="ImageFormat"/> for captured <see cref="Bitmap"/>.</param>
        /// <returns>Captured screen image for given <see cref="Screen"/>.</returns>
        public static Bitmap Capture(Screen captureScreen, ImageFormat imageFormat)
        {
            return Capture(captureScreen.Bounds, imageFormat);
        }

        /// <summary>
        /// Performs a screen capture the given <see cref="Rectangle"/>.
        /// </summary>
        /// <param name="captureArea">Screen area <see cref="Rectangle"/> to capture.</param>
        /// <returns>Captured screen image for given area.</returns>
        public static Bitmap Capture(Rectangle captureArea)
        {
            return Capture(captureArea, ImageFormat.Bmp);
        }

        /// <summary>
        /// Performs a screen capture the given <see cref="Rectangle"/> and <see cref="ImageFormat"/>.
        /// </summary>
        /// <param name="captureArea">Screen area <see cref="Rectangle"/> to capture.</param>
        /// <param name="imageFormat">Desired <see cref="ImageFormat"/> for captured <see cref="Bitmap"/>.</param>
        /// <returns>Captured screen image for given area.</returns>
        public static Bitmap Capture(Rectangle captureArea, ImageFormat imageFormat)
        {
            // Create a blank image of the specified size.
            using (Bitmap screenCaptureImage = new Bitmap(captureArea.Width, captureArea.Height))
            {
                using (Graphics screenCaptureGraphics = Graphics.FromImage(screenCaptureImage))
                {
                    // Copy the area of the screen to the blank image.
                    screenCaptureGraphics.CopyFromScreen(captureArea.X, captureArea.Y, 0, 0, captureArea.Size);
                }

                // We'll return the captured screenshot in the specified image format.
                return screenCaptureImage.ConvertTo(imageFormat, true);
            }
        }
    }
}