Exemple #1
0
        /// <summary>
        /// A képernyő egy adott régiójáról készít képernyőképet.
        /// </summary>
        /// <param name="hWnd">Az ablak Handle</param>
        /// <param name="x">x koordináta</param>
        /// <param name="y">y koordináta</param>
        /// <param name="width">A kép szélessége (A terület szélessége)</param>
        /// <param name="height">A kép/terület magassága</param>
        /// <param name="addToClipboard">Nem használt, jövőbeni funkciónak fenntartott</param>
        /// <returns>BitmapSource amelyből a kép kinyerhető</returns>
        /// <example>
        /// <code lang='cs'>
        ///   bitmapsource = CaptureRegion(((HwndSource)HwndSource.FromVisual(Application.Current.MainWindow)).Handle,
        ///   (int)Application.Current.MainWindow.Left, (int)Application.Current.MainWindow.Top,
        ///   (int)Application.Current.MainWindow.Width, (int)Application.Current.MainWindow.Height, false);
        /// </code>
        /// </example>
        public static BitmapSource CaptureRegion(
            IntPtr hWnd, int x, int y, int width, int height, bool addToClipboard)
        {
            IntPtr       sourceDC = IntPtr.Zero;
            IntPtr       targetDC = IntPtr.Zero;
            IntPtr       compatibleBitmapHandle = IntPtr.Zero;
            BitmapSource bitmap = null;

            try
            {
                sourceDC = User32.GetDC(User32.GetDesktopWindow());
                targetDC = Gdi32.CreateCompatibleDC(sourceDC);
                compatibleBitmapHandle = Gdi32.CreateCompatibleBitmap(sourceDC, width, height);
                Gdi32.SelectObject(targetDC, compatibleBitmapHandle);
                Gdi32.BitBlt(targetDC, 0, 0, width, height, sourceDC, x, y, Gdi32.SRCCOPY);
                bitmap = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
                    compatibleBitmapHandle, IntPtr.Zero, Int32Rect.Empty,
                    BitmapSizeOptions.FromEmptyOptions());
            }
            catch (Exception ex)
            {
                throw new ScreenCaptureException(string.Format("Error capturing region {0},{1},{2},{3}", x, y, width, height), ex);
            }
            finally
            {
                Gdi32.DeleteObject(compatibleBitmapHandle);
                User32.ReleaseDC(IntPtr.Zero, sourceDC);
                User32.ReleaseDC(IntPtr.Zero, targetDC);
            }

            return(bitmap);
        }
Exemple #2
0
        public Image CaptureWindow(IntPtr handle)
        {
            // get te hDC of the target window
            var hdcSrc = User32.GetWindowDC(handle);
            // get the size
            var windowRect = new User32.Rect();

            User32.GetWindowRect(handle, ref windowRect);
            var width  = windowRect.right - windowRect.left;
            var height = windowRect.bottom - windowRect.top;
            // create a device context we can copy to
            var hdcDest = Gdi32.CreateCompatibleDC(hdcSrc);
            // create a bitmap we can copy it to,
            // using GetDeviceCaps to get the width/height
            var hBitmap = Gdi32.CreateCompatibleBitmap(hdcSrc, width, height);
            // select the bitmap object
            var hOld = Gdi32.SelectObject(hdcDest, hBitmap);

            // bitblt over
            Gdi32.BitBlt(hdcDest, 0, 0, width, height, hdcSrc, 0, 0, Gdi32.Srccopy);
            // restore selection
            Gdi32.SelectObject(hdcDest, hOld);
            // clean up
            Gdi32.DeleteDC(hdcDest);
            User32.ReleaseDC(handle, hdcSrc);
            // get a .NET image object for it
            Image img = Image.FromHbitmap(hBitmap);

            // free up the Bitmap object
            Gdi32.DeleteObject(hBitmap);
            return(img);
        }
        public static Bitmap Capture(IntPtr Window)
        {
            IntPtr SourceDC = User32.GetWindowDC(Window),
                   MemoryDC = Gdi32.CreateCompatibleDC(SourceDC);

            var rect = new RECT();

            User32.GetWindowRect(Window, ref rect);

            int Width  = rect.Right - rect.Left,
                Height = rect.Bottom - rect.Top;

            // Create a bitmap we can copy it to
            var hBmp = Gdi32.CreateCompatibleBitmap(SourceDC, Width, Height);

            try
            {
                // select the bitmap object
                var hOld = Gdi32.SelectObject(MemoryDC, hBmp);

                // bitblt over
                Gdi32.BitBlt(MemoryDC, 0, 0, Width, Height, SourceDC, 0, 0, CopyPixelOperation.SourceCopy);

                // restore selection
                Gdi32.SelectObject(MemoryDC, hOld);

                // get a .NET image object for it
                return(Bitmap.FromHbitmap(hBmp));
            }
            finally { Gdi32.DeleteObject(hBmp); }
        }
Exemple #4
0
        /// <summary>
        /// Creates a Bitmap containing the screen of the window
        /// </summary>
        /// <param name="handle">The handle to the window.</param>
        /// <returns>Bitmap containing the screen of the window</returns>
        static private Bitmap CaptureWindowByHandle(IntPtr handle)
        {
            IntPtr hSrc;
            IntPtr hDest;
            IntPtr hBitmap;
            IntPtr hOld;

            //create the rectangle and get image size
            User32.RECT windowRect = new User32.RECT();
            User32.GetWindowRect(handle, ref windowRect);
            int height = windowRect.bottom - windowRect.top;
            int width  = windowRect.right - windowRect.left;

            //get all handle device context
            hSrc    = User32.GetWindowDC(handle);
            hDest   = Gdi32.CreateCompatibleDC(hSrc);
            hBitmap = Gdi32.CreateCompatibleBitmap(hSrc, width, height);
            hOld    = Gdi32.SelectObject(hDest, hBitmap);

            //get the image
            Gdi32.BitBlt(hDest, 0, 0, width, height, hSrc, 0, 0, Gdi32.SRCC);
            Gdi32.SelectObject(hDest, hOld);
            Bitmap img = Image.FromHbitmap(hBitmap);

            //free the memory
            Gdi32.DeleteDC(hDest);
            User32.ReleaseDC(handle, hSrc);
            Gdi32.DeleteObject(hBitmap);

            //return the image
            return(img);
        }
Exemple #5
0
        //通过鼠标前后两个位置来获取图片
        public Image GetPic_ByMouse(IntPtr hWnd)
        {
            Image img;


            // 获取设备上下文环境句柄
            IntPtr hscrdc = User32.GetWindowDC(hWnd);

            // 创建一个与指定设备兼容的内存设备上下文环境(DC)
            IntPtr hmemdc  = Gdi32.CreateCompatibleDC(hscrdc);
            IntPtr myMemdc = Gdi32.CreateCompatibleDC(hscrdc);

            // 返回指定窗体的矩形尺寸
            User32.RECT windowRect = new User32.RECT();
            User32.GetWindowRect(hWnd, ref windowRect);

            // 返回指定设备环境句柄对应的位图区域句柄
            IntPtr myBitmap = Gdi32.CreateCompatibleBitmap(hscrdc, width, height);
            IntPtr hbitmap  = Gdi32.CreateCompatibleBitmap(hscrdc, windowRect.right - windowRect.left, windowRect.bottom - windowRect.top);

            //把位图选进内存DC

            Gdi32.SelectObject(hmemdc, hbitmap);
            Gdi32.SelectObject(myMemdc, myBitmap);


            Gdi32.BitBlt(myMemdc, 0, 0, width, height, hscrdc, Point_push.X, Point_push.Y, Gdi32.SRCCOPY);
            img = Image.FromHbitmap(myBitmap);
            Gdi32.DeleteDC(hscrdc);
            Gdi32.DeleteDC(hmemdc);
            Gdi32.DeleteDC(myMemdc);
            return(img);
        }
        private static BitmapSource CaptureRegion(IntPtr hWnd, int x, int y, int width, int height, bool addToClipboard)
        {
            IntPtr       sourceDC = IntPtr.Zero;
            IntPtr       targetDC = IntPtr.Zero;
            IntPtr       compatibleBitmapHandle = IntPtr.Zero;
            BitmapSource bitmap = null;

            sourceDC = User32.GetDC(User32.GetDesktopWindow());
            targetDC = Gdi32.CreateCompatibleDC(sourceDC);

            compatibleBitmapHandle = Gdi32.CreateCompatibleBitmap(sourceDC, width, height);

            Gdi32.SelectObject(targetDC, compatibleBitmapHandle);

            Gdi32.BitBlt(targetDC, 0, 0, width, height, sourceDC, x, y, Gdi32.SRCCOPY);

            bitmap = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
                compatibleBitmapHandle, IntPtr.Zero, Int32Rect.Empty,
                BitmapSizeOptions.FromEmptyOptions());

            if (addToClipboard)
            {
                IDataObject data = new DataObject();
                data.SetData(DataFormats.Dib, bitmap, false);
                Clipboard.SetDataObject(data, false);
            }
            Gdi32.DeleteObject(compatibleBitmapHandle);

            User32.ReleaseDC(IntPtr.Zero, sourceDC);
            User32.ReleaseDC(IntPtr.Zero, targetDC);

            return(bitmap);
        }
        public RegionProvider(Rectangle Region, bool IncludeCursor, Func <Point> LocationFunc = null)
        {
            _region        = Region;
            _includeCursor = IncludeCursor;
            _locationFunc  = LocationFunc ?? (() => Region.Location);

            // Width and Height must be even.
            // Use these for Bitmap size, but capture as per region size
            Width = _region.Width;
            if (Width % 2 == 1)
            {
                ++Width;
            }

            Height = _region.Height;
            if (Height % 2 == 1)
            {
                ++Height;
            }

            PointTransform = P => new Point(P.X - _region.X, P.Y - _region.Y);

            _hdcSrc = User32.GetDC(IntPtr.Zero);

            _hdcDest = Gdi32.CreateCompatibleDC(_hdcSrc);
            _hBitmap = Gdi32.CreateCompatibleBitmap(_hdcSrc, Width, Height);

            Gdi32.SelectObject(_hdcDest, _hBitmap);
        }
        /// <summary>
        /// Creates screenshot of all available screens. <br/>
        /// If <paramref name="cropRectangle"/> is not null, returns image of this region.
        /// </summary>
        /// <param name="cropRectangle"></param>
        /// <returns></returns>
        public static Bitmap Shot(Rectangle?cropRectangle = null)
        {
            var rectangle = (cropRectangle ?? GetPhysicalScreenRectangle()).Normalize();

            var window = User32.GetDesktopWindow();

            using var dc   = User32.GetWindowDC(window);
            using var toDc = Gdi32.CreateCompatibleDC(dc);
            var hBmp    = Gdi32.CreateCompatibleBitmap(dc, rectangle.Width, rectangle.Height);
            var hOldBmp = Gdi32.SelectObject(toDc, hBmp);

            // ReSharper disable once BitwiseOperatorOnEnumWithoutFlags
            Gdi32.BitBlt(toDc.DangerousGetHandle(),
                         0,
                         0,
                         rectangle.Width,
                         rectangle.Height,
                         dc.DangerousGetHandle(),
                         rectangle.X,
                         rectangle.Y,
                         (int)(CopyPixelOperation.CaptureBlt | CopyPixelOperation.SourceCopy));

            var bitmap = Image.FromHbitmap(hBmp);

            Gdi32.SelectObject(toDc, hOldBmp);
            Gdi32.DeleteObject(hBmp).Check();
            Gdi32.DeleteDC(toDc).Check();                              //?
            User32.ReleaseDC(window, dc.DangerousGetHandle()).Check(); //?

            return(bitmap);
        }
Exemple #9
0
    public override void Start(int delay, int left, int top, int width, int height, double scale, ProjectInfo project)
    {
        base.Start(delay, left, top, width, height, scale, project);

        #region Pointers

        //http://winprog.org/tutorial/bitmaps.html
        //_desktopWindow = User32.GetDesktopWindow();
        WindowDeviceContext     = User32.GetWindowDC(_desktopWindow);
        CompatibleDeviceContext = Gdi32.CreateCompatibleDC(WindowDeviceContext);
        CompatibleBitmap        = Gdi32.CreateCompatibleBitmap(WindowDeviceContext, Width, Height);
        _oldBitmap = Gdi32.SelectObject(CompatibleDeviceContext, CompatibleBitmap);

        #endregion

        var pixelOp = CopyPixelOperations.SourceCopy;

        //If not in a remote desktop connection or if the improvement was disabled, capture layered windows too.
        if (!System.Windows.Forms.SystemInformation.TerminalServerSession || !UserSettings.All.RemoteImprovement)
        {
            pixelOp |= CopyPixelOperations.CaptureBlt;
        }

        PixelOperations = pixelOp;
    }
Exemple #10
0
        public Bitmap CaptureWindowGDI(IntPtr handle)
        {
            var hdcSrc = User32.GetWindowDC(handle);

            var windowRect = new RECT();

            User32.GetWindowRect(handle, ref windowRect);

            var width  = windowRect.right - windowRect.left;
            var height = windowRect.bottom - windowRect.top;

            var hdcDest = Gdi32.CreateCompatibleDC(hdcSrc);
            var hBitmap = Gdi32.CreateCompatibleBitmap(hdcSrc, width, height);

            var hOld = Gdi32.SelectObject(hdcDest, hBitmap);

            Gdi32.BitBlt(hdcDest, 0, 0, width, height, hdcSrc, 0, 0, 13369376);
            Gdi32.SelectObject(hdcDest, hOld);
            Gdi32.DeleteDC(hdcDest);
            User32.ReleaseDC(handle, hdcSrc);

            var image = Image.FromHbitmap(hBitmap);

            Gdi32.DeleteObject(hBitmap);

            return(image);
        }
Exemple #11
0
        /// <summary>
        /// Captures the screen using the SourceCopy | CaptureBlt.
        /// </summary>
        /// <param name="height">Height of the capture region.</param>
        /// <param name="positionX">Source capture Left position.</param>
        /// <param name="positionY">Source capture Top position.</param>
        /// <param name="width">Width of the capture region.</param>
        /// <returns>A bitmap with the capture rectangle.</returns>
        public static Image CaptureScreenAsBitmap(int width, int height, int positionX, int positionY)
        {
            var hDesk   = User32.GetDesktopWindow();
            var hSrce   = User32.GetWindowDC(hDesk);
            var hDest   = Gdi32.CreateCompatibleDC(hSrce);
            var hBmp    = Gdi32.CreateCompatibleBitmap(hSrce, width, height);
            var hOldBmp = Gdi32.SelectObject(hDest, hBmp);

            try
            {
                var b = Gdi32.BitBlt(hDest, 0, 0, width, height, hSrce, positionX, positionY, CopyPixelOperations.SourceCopy | CopyPixelOperations.CaptureBlt);

                return(b ? Image.FromHbitmap(hBmp) : null);
            }
            catch (Exception)
            {
                //LogWriter.Log(ex, "Impossible to get screenshot of the screen");
            }
            finally
            {
                Gdi32.SelectObject(hDest, hOldBmp);
                Gdi32.DeleteObject(hBmp);
                Gdi32.DeleteDC(hDest);
                User32.ReleaseDC(hDesk, hSrce);
            }

            return(null);
        }
Exemple #12
0
        public static Image CaptureWindow(IntPtr handle, double scale)
        {
            var rectangle = Windows.GetWindowRect(handle);
            var posX      = (int)((rectangle.X + Util.Constants.LeftOffset) * scale);
            var posY      = (int)((rectangle.Y + Util.Constants.TopOffset) * scale);
            var width     = (int)((rectangle.Width - Util.Constants.HorizontalOffset) * scale);
            var height    = (int)((rectangle.Height - Util.Constants.VerticalOffset) * scale);

            var hDesk   = User32.GetDesktopWindow();
            var hSrce   = User32.GetWindowDC(hDesk);
            var hDest   = Gdi32.CreateCompatibleDC(hSrce);
            var hBmp    = Gdi32.CreateCompatibleBitmap(hSrce, width, height);
            var hOldBmp = Gdi32.SelectObject(hDest, hBmp);

            var b = Gdi32.BitBlt(hDest, 0, 0, width, height, hSrce, posX, posY, CopyPixelOperations.SourceCopy | CopyPixelOperations.CaptureBlt);

            try
            {
                return(Image.FromHbitmap(hBmp));
            }
            catch (Exception ex)
            {
                LogWriter.Log(ex, "Impossible to get screenshot of the screen");
            }
            finally
            {
                Gdi32.SelectObject(hDest, hOldBmp);
                Gdi32.DeleteObject(hBmp);
                Gdi32.DeleteDC(hDest);
                User32.ReleaseDC(hDesk, hSrce);
            }

            return(null);
        }
Exemple #13
0
        /// <summary>
        /// Captures the screen using the SourceCopy | CaptureBlt.
        /// </summary>
        /// <param name="width">The size of the final image.</param>
        /// <param name="height">The size of the final image.</param>
        /// <param name="positionX">Source capture Left position.</param>
        /// <param name="positionY">Source capture Top position.</param>
        /// <returns>A bitmap with the capture rectangle.</returns>
        public static BitmapSource CaptureScreenAsBitmapSource(int width, int height, int positionX, int positionY)
        {
            var hDesk   = User32.GetDesktopWindow();
            var hSrce   = User32.GetWindowDC(hDesk);
            var hDest   = Gdi32.CreateCompatibleDC(hSrce);
            var hBmp    = Gdi32.CreateCompatibleBitmap(hSrce, width, height);
            var hOldBmp = Gdi32.SelectObject(hDest, hBmp);

            try
            {
                var b = Gdi32.BitBlt(hDest, 0, 0, width, height, hSrce, positionX, positionY, CopyPixelOperations.SourceCopy | CopyPixelOperations.CaptureBlt);

                //return Image.FromHbitmap(hBmp);
                return(System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(hBmp, IntPtr.Zero, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions()));
            }
            catch (Exception ex)
            {
                LogWriter.Log(ex, "Impossible to get screenshot of the screen");
            }
            finally
            {
                Gdi32.SelectObject(hDest, hOldBmp);
                Gdi32.DeleteObject(hBmp);
                Gdi32.DeleteDC(hDest);
                User32.ReleaseDC(hDesk, hSrce);
            }

            return(null);
        }
Exemple #14
0
        public Bitmap Capture()
        {
            if (GetWindowThreadProcessId() == 0)
            {
                return(new Bitmap(1, 1, PixelFormat.Format24bppRgb));
            }

            var deviceSrc = User32.GetWindowDC(this.windowHandle);

            User32.GetWindowRect(this.windowHandle, ref this.rect);
            var deviceDest   = Gdi32.CreateCompatibleDC(deviceSrc);
            var bitmapHandle = Gdi32.CreateCompatibleBitmap(
                deviceSrc,
                this.rect.Width,
                this.rect.Height);
            var oldHandle = Gdi32.SelectObject(deviceDest, bitmapHandle);

            Gdi32.BitBlt(deviceDest, 0, 0, this.rect.Width, this.rect.Height, deviceSrc, 0, 0, 0x00CC0020);
            Gdi32.SelectObject(deviceDest, oldHandle);
            Gdi32.DeleteDC(deviceDest);
            User32.ReleaseDC(this.windowHandle, deviceSrc);

            var img = Image.FromHbitmap(bitmapHandle);

            Gdi32.DeleteObject(bitmapHandle);

            return(img);
        }
Exemple #15
0
        private static Image CaptureWindow(IntPtr handler)
        {
            IntPtr hdcScr     = User32.GetWindowDC(handler);
            var    windowRect = new User32.RECT();

            User32.GetWindowRect(handler, ref windowRect);

            int width  = windowRect.right - windowRect.left;
            int height = windowRect.bottom - windowRect.top;

            var hdcDesc = Gdi32.CreateCompatibleDC(hdcScr);
            var hBitmap = Gdi32.CreateCompatibleBitmap(hdcScr, width, height);

            var hOld = Gdi32.SelectObject(hdcDesc, hBitmap);

            Gdi32.BitBlt(hdcDesc, 0, 0, width, height, hdcScr, 0, 0, Gdi32.SRCCOPY);

            Gdi32.SelectObject(hdcDesc, hOld);
            Gdi32.DeleteDC(hdcDesc);
            User32.ReleaseDC(handler, hdcScr);

            var img = Image.FromHbitmap(hBitmap);

            Gdi32.DeleteObject(hBitmap);
            return(img);
        }
Exemple #16
0
        /// <summary>
        /// Captures a Specific Window.
        /// </summary>
        /// <param name="Window">The <see cref="Window"/> to Capture</param>
        /// <param name="IncludeCursor">Whether to include the Mouse Cursor.</param>
        /// <returns>The Captured Image.</returns>
        public static Bitmap Capture(Window Window, bool IncludeCursor = false)
        {
            User32.GetWindowRect(Window.Handle, out var r);
            var region = r.ToRectangle();

            IntPtr hSrc    = GetWindowDC(Window.Handle),
                   hDest   = Gdi32.CreateCompatibleDC(hSrc),
                   hBmp    = Gdi32.CreateCompatibleBitmap(hSrc, region.Width, region.Height),
                   hOldBmp = Gdi32.SelectObject(hDest, hBmp);

            Gdi32.BitBlt(hDest, 0, 0,
                         region.Width, region.Height,
                         hSrc,
                         region.Left, region.Top,
                         CopyPixelOperation.SourceCopy | CopyPixelOperation.CaptureBlt);

            var bmp = Image.FromHbitmap(hBmp);

            Gdi32.SelectObject(hDest, hOldBmp);
            Gdi32.DeleteObject(hBmp);
            Gdi32.DeleteDC(hDest);
            Gdi32.DeleteDC(hSrc);

            var clone = bmp.Clone(new Rectangle(Point.Empty, bmp.Size), PixelFormat.Format24bppRgb);

            if (IncludeCursor)
            {
                new MouseCursor().Draw(clone, region.Location);
            }

            return(clone);
        }
Exemple #17
0
        private Gdi32.HBITMAP GetCompatibleBitmap(Bitmap bm)
        {
            using var screenDC = User32.GetDcScope.ScreenDC;

            // GDI+ returns a DIBSECTION based HBITMAP. The clipboard deals well
            // only with bitmaps created using CreateCompatibleBitmap(). So, we
            // convert the DIBSECTION into a compatible bitmap.
            Gdi32.HBITMAP hBitmap = bm.GetHBITMAP();

            // Create a compatible DC to render the source bitmap.
            using var sourceDC = new Gdi32.CreateDcScope(screenDC);
            using var sourceBitmapSelection = new Gdi32.SelectObjectScope(sourceDC, hBitmap);

            // Create a compatible DC and a new compatible bitmap.
            using var destinationDC = new Gdi32.CreateDcScope(screenDC);
            Gdi32.HBITMAP bitmap = Gdi32.CreateCompatibleBitmap(screenDC, bm.Size.Width, bm.Size.Height);

            // Select the new bitmap into a compatible DC and render the blt the original bitmap.
            using var destinationBitmapSelection = new Gdi32.SelectObjectScope(destinationDC, bitmap);
            Gdi32.BitBlt(
                destinationDC,
                0,
                0,
                bm.Size.Width,
                bm.Size.Height,
                sourceDC,
                0,
                0,
                Gdi32.ROP.SRCCOPY);

            return(bitmap);
        }
Exemple #18
0
        static Bitmap CaptureRegionUnmanaged(Rectangle Region, bool IncludeCursor = false)
        {
            IntPtr hSrc    = Gdi32.CreateDC("DISPLAY", null, null, 0),
                   hDest   = Gdi32.CreateCompatibleDC(hSrc),
                   hBmp    = Gdi32.CreateCompatibleBitmap(hSrc, Region.Width, Region.Height),
                   hOldBmp = Gdi32.SelectObject(hDest, hBmp);

            Gdi32.BitBlt(hDest, 0, 0,
                         Region.Width, Region.Height,
                         hSrc,
                         Region.Left, Region.Top,
                         CopyPixelOperation.SourceCopy | CopyPixelOperation.CaptureBlt);

            var bmp = Image.FromHbitmap(hBmp);

            Gdi32.SelectObject(hDest, hOldBmp);
            Gdi32.DeleteObject(hBmp);
            Gdi32.DeleteDC(hDest);
            Gdi32.DeleteDC(hSrc);

            var clone = bmp.Clone(new Rectangle(Point.Empty, bmp.Size), PixelFormat.Format24bppRgb);

            if (IncludeCursor)
            {
                new MouseCursor().Draw(clone, Region.Location);
            }

            return(clone);
        }
Exemple #19
0
        // 特定窗口的截图对象
        private Image CaptureWindow(IntPtr handle)
        {
            // 获得目标窗口的hDC
            SafeDCHandle hdcSrc     = User32.GetWindowDC(handle);
            var          screenSize = GetScreenPhysicalSzie();
            // create a device context we can copy to
            var hdcDest = Gdi32.CreateCompatibleDC(hdcSrc);
            // create a bitmap we can copy it to,
            // using GetDeviceCaps to get the width/height
            IntPtr hBitmap = Gdi32.CreateCompatibleBitmap(hdcSrc, screenSize.Width, screenSize.Height);
            // select the bitmap object
            IntPtr hOld = Gdi32.SelectObject(hdcDest, hBitmap);

            // bitblt over
            Gdi32.BitBlt(hdcDest.HWnd, 0, 0, screenSize.Width, screenSize.Height, hdcSrc.HWnd, 0, 0, WindowsAPIUtils.SRCCOPY);
            // restore selection
            Gdi32.SelectObject(hdcDest, hOld);
            // clean up
            Gdi32.DeleteDC(hdcDest);
            User32.ReleaseDC(handle, hdcSrc.HWnd);
            // get a .NET image object for it
            Image img = Image.FromHbitmap(hBitmap);

            // free up the Bitmap object
            Gdi32.DeleteObject(hBitmap);
            return(img);
        }
Exemple #20
0
        // this DC is cached and should only be deleted on Dispose or when the size changes.

        public Gdi32.HDC GetCachedItemDC(Gdi32.HDC toolStripHDC, Size bitmapSize)
        {
            if (_cachedHDCSize.Width < bitmapSize.Width ||
                _cachedHDCSize.Height < bitmapSize.Height)
            {
                if (_cachedItemHDC.IsNull)
                {
                    // Create a new DC - we don't have one yet.
                    _cachedItemHDC = Gdi32.CreateCompatibleDC(toolStripHDC);
                }

                // Create compatible bitmap with the correct size.
                _cachedItemBitmap = Gdi32.CreateCompatibleBitmap(toolStripHDC, bitmapSize.Width, bitmapSize.Height);
                Gdi32.HGDIOBJ oldBitmap = Gdi32.SelectObject(_cachedItemHDC, _cachedItemBitmap);

                // Delete the old bitmap
                if (!oldBitmap.IsNull)
                {
                    Gdi32.DeleteObject(oldBitmap);
                }

                // remember what size we created.
                _cachedHDCSize = bitmapSize;
            }

            return(_cachedItemHDC);
        }
Exemple #21
0
        private void SetSpotInfo()
        {
            int x = _originX;
            int y = _originY;

            IntPtr hwnd  = User32.GetDesktopWindow();
            IntPtr dc    = User32.GetWindowDC(hwnd);
            IntPtr memDC = Gdi32.CreateCompatibleDC(dc);
            IntPtr hbm   = Gdi32.CreateCompatibleBitmap(dc, _spotWidth, _spotHeight);
            IntPtr oldbm = Gdi32.SelectObject(memDC, hbm);

            Gdi32.BitBlt(
                memDC,
                0, 0,
                this.SpotWidth, this.SpotHeight,
                dc,
                x, y,
                0x40CC0020
                );

            _currentSpotBmp = Image.FromHbitmap(hbm);

            Gdi32.SelectObject(memDC, oldbm);
            Gdi32.DeleteObject(hbm);
            Gdi32.DeleteDC(memDC);
            User32.ReleaseDC(hwnd, dc);
        }
Exemple #22
0
        public RegionProvider(Rectangle region, bool includeCursor, Func <Point> locationFunc)
        {
            _region        = region;
            _includeCursor = includeCursor;
            _locationFunc  = locationFunc;

            // Width and Height must be even.
            // Use these for Bitmap size, but capture as per region size
            Width = _region.Width;
            if (Width % 2 == 1)
            {
                ++Width;
            }

            Height = _region.Height;
            if (Height % 2 == 1)
            {
                ++Height;
            }

            _transform = point => new Point(point.X - _region.X, point.Y - _region.Y);

            _hdcSrc = User32.GetDC(IntPtr.Zero);

            _hdcDest = Gdi32.CreateCompatibleDC(_hdcSrc);
            _hBitmap = Gdi32.CreateCompatibleBitmap(_hdcSrc, Width, Height);

            Gdi32.SelectObject(_hdcDest, _hBitmap);
        }
Exemple #23
0
        private void FromWindow(IntPtr hwnd)
        {
            IntPtr hDc = User32.GetDC(hwnd);

            IntPtr memhDC = Gdi32.CreateCompatibleDC(hDc);

            User32.RECT clientSize;
            User32.GetClientRect(hwnd, out clientSize);

            Point bounds = new Point(clientSize.Right - clientSize.Left, clientSize.Bottom - clientSize.Top);

            IntPtr hBmp = Gdi32.CreateCompatibleBitmap(hDc, bounds.X, bounds.Y);

            Gdi32.SelectObject(memhDC, hBmp);

            Gdi32.BitBlt(memhDC, 0, 0, bounds.X, bounds.Y, hDc, 0, 0, Gdi32.TernaryRasterOperations.SRCCOPY);

            Bitmap bmp = Bitmap.FromHbitmap(hBmp);

            Gdi32.DeleteObject(hBmp);
            User32.ReleaseDC(hwnd, hDc);
            Gdi32.DeleteDC(memhDC);

            FromBitmap(bmp);
        }
Exemple #24
0
        public GdiTargetDeviceContext(IntPtr SrcDc, int Width, int Height)
        {
            _hdcDest = Gdi32.CreateCompatibleDC(SrcDc);
            _hBitmap = Gdi32.CreateCompatibleBitmap(SrcDc, Width, Height);

            Gdi32.SelectObject(_hdcDest, _hBitmap);
        }
Exemple #25
0
        /// <summary>
        /// Windows only window capture by handle
        /// </summary>
        /// <param name="handle"></param>
        /// <returns></returns>
        public static byte[] WindowsCapturePng(IntPtr handle)
        {
            // get te hDC of the target window
            IntPtr hdcSrc = User32.GetWindowDC(handle);

            // get the size
            User32.RECT windowRect = new User32.RECT();
            User32.GetWindowRect(handle, ref windowRect);
            int width  = windowRect.right - windowRect.left;
            int height = windowRect.bottom - windowRect.top;
            // create a device context we can copy to
            IntPtr hdcDest = Gdi32.CreateCompatibleDC(hdcSrc);
            // create a bitmap we can copy it to,
            // using GetDeviceCaps to get the width/height
            IntPtr hBitmap = Gdi32.CreateCompatibleBitmap(hdcSrc, width, height);
            // select the bitmap object
            IntPtr hOld = Gdi32.SelectObject(hdcDest, hBitmap);

            // bitblt over
            Gdi32.BitBlt(hdcDest, 0, 0, width, height, hdcSrc, 0, 0, Gdi32.SRCCOPY);
            // restore selection
            Gdi32.SelectObject(hdcDest, hOld);
            // clean up
            Gdi32.DeleteDC(hdcDest);
            User32.ReleaseDC(handle, hdcSrc);
            byte[] ret = HbitmapToPng(hBitmap);
            // free up the Bitmap object
            Gdi32.DeleteObject(hBitmap);
            return(ret);
        }
        public Bitmap CaptureWindow(IntPtr handle)
        {
            IntPtr hdcSrc = User32.GetWindowDC(handle);

            User32.RECT windowRect = new User32.RECT();
            User32.GetWindowRect(handle, ref windowRect);

            int width  = windowRect.right - windowRect.left;
            int height = windowRect.bottom - windowRect.top;

            IntPtr hdcDest = Gdi32.CreateCompatibleDC(hdcSrc);
            IntPtr hBitmap = Gdi32.CreateCompatibleBitmap(hdcSrc, width, height);

            IntPtr hOld = Gdi32.SelectObject(hdcDest, hBitmap);

            Gdi32.BitBlt(hdcDest, 0, 0, width, height, hdcSrc, 0, 0, Gdi32.SRCCOPY);
            Gdi32.SelectObject(hdcDest, hOld);
            Gdi32.DeleteDC(hdcDest);
            User32.ReleaseDC(handle, hdcSrc);

            Image image = Image.FromHbitmap(hBitmap);

            Gdi32.DeleteObject(hBitmap);

            return(new Bitmap(image));
        }
        private Image CaptureWindow(IntPtr handle)
        {
            // get te hDC of the target window
            IntPtr hdcSrc = User32.GetWindowDC(handle);
            // get the size
            RECT windowRect = new RECT();

            User32.GetWindowRect(handle, out windowRect);
            int width  = windowRect.Right - windowRect.Left;
            int height = windowRect.Bottom - windowRect.Top;
            // create a device context we can copy to
            IntPtr hdcDest = Gdi32.CreateCompatibleDC(hdcSrc);
            // create a bitmap we can copy it to,
            // using GetDeviceCaps to get the width/height
            IntPtr hBitmap = Gdi32.CreateCompatibleBitmap(hdcSrc, width, height);
            // select the bitmap object
            IntPtr hOld = Gdi32.SelectObject(hdcDest, hBitmap);

            // bitblt over
            Gdi32.BitBlt(hdcDest, 0, 0, width, height, hdcSrc, 0, 0, Gdi32.SRCCOPY);
            // restore selection
            Gdi32.SelectObject(hdcDest, hOld);
            // clean up
            Gdi32.DeleteDC(hdcDest);
            User32.ReleaseDC(handle, hdcSrc);
            // get a .NET image object for it
            Image img = Image.FromHbitmap(hBitmap);

            // free up the Bitmap object
            Gdi32.DeleteObject(hBitmap);
            return(img);
        }
Exemple #28
0
        /// <summary>
        /// Creates an Image object containing a screen shot of a specific window
        /// </summary>
        /// <param name="handle">A <see cref="IntPtr"/> to the window to capture.
        /// (In windows forms, this is obtained by the Handle property)</param>
        /// <returns>An <see cref="Image"/> with the captured window if successfull,
        /// otherwise null.</returns>
        /// <remarks>This method uses the GDI32.BitBlt()
        /// method, so the window has to be visible and should not be
        /// minimized or hidden for example. In this cases use
        /// <see cref="GetWindowImage(IntPtr,Size)"/> which uses
        /// User32.PrintWindow().
        /// </remarks>
        public static Image CaptureWindow(IntPtr handle)
        {
            IntPtr hdcSrc  = IntPtr.Zero;
            IntPtr hdcDest = IntPtr.Zero;
            IntPtr bitmap  = IntPtr.Zero;
            Image  img;

            try
            {
                // get te hDC of the target window
                hdcSrc = User32.GetWindowDC(handle);

                // get the size
                User32.RECT windowRect = new User32.RECT();
                User32.GetWindowRect(handle, ref windowRect);
                int width  = windowRect.Right - windowRect.Left;
                int height = windowRect.Bottom - windowRect.Top;

                // create a device context we can copy to
                hdcDest = Gdi32.CreateCompatibleDC(hdcSrc);

                // create a bitmap we can copy it to,
                // using GetDeviceCaps to get the width/height
                bitmap = Gdi32.CreateCompatibleBitmap(hdcSrc, width, height);

                // select the bitmap object
                IntPtr old = Gdi32.SelectObject(hdcDest, bitmap);

                // bitblt over
                Gdi32.BitBlt(hdcDest, 0, 0, width, height, hdcSrc, 0, 0, Gdi32.TernaryRasterOperations.SRCCOPY);

                // restore selection
                Gdi32.SelectObject(hdcDest, old);

                // get a .NET image object for it
                img = Image.FromHbitmap(bitmap);
            }
            catch (Exception ex)
            {
                VGExceptionMethods.HandleException(ex);

                return(null);
            }
            finally
            {
                // clean up
                Gdi32.DeleteDC(hdcDest);
                User32.ReleaseDC(handle, hdcSrc);

                // free up the Bitmap object
                Gdi32.DeleteObject(bitmap);
            }

            return(img);
        }
Exemple #29
0
        // capture a region of a the screen, defined by the hWnd
        public static BitmapSource CaptureRegion(
            IntPtr hWnd, int x, int y, int width, int height, bool addToClipboard)
        {
            IntPtr       sourceDC = IntPtr.Zero;
            IntPtr       targetDC = IntPtr.Zero;
            IntPtr       compatibleBitmapHandle = IntPtr.Zero;
            BitmapSource bitmap = null;

            try
            {
                // gets the main desktop and all open windows
                sourceDC = User32.GetDC(User32.GetDesktopWindow());
                //sourceDC = User32.GetDC(hWnd);
                targetDC = Gdi32.CreateCompatibleDC(sourceDC);

                // create a bitmap compatible with our target DC
                compatibleBitmapHandle = Gdi32.CreateCompatibleBitmap(sourceDC, width, height);

                // gets the bitmap into the target device context
                Gdi32.SelectObject(targetDC, compatibleBitmapHandle);

                // copy from source to destination
                Gdi32.BitBlt(targetDC, 0, 0, width, height, sourceDC, x, y, Gdi32.SRCCOPY);

                // Here's the WPF glue to make it all work. It converts from an
                // hBitmap to a BitmapSource. Love the WPF interop functions
                bitmap = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
                    compatibleBitmapHandle, IntPtr.Zero, Int32Rect.Empty,
                    BitmapSizeOptions.FromEmptyOptions());

                if (addToClipboard)
                {
                    //Clipboard.SetImage(bitmap); // high memory usage for large images
                    IDataObject data = new DataObject();
                    data.SetData(DataFormats.Dib, bitmap, false);
                    Clipboard.SetDataObject(data, false);
                }
            }
            catch (Exception ex)
            {
                throw new ScreenCaptureException(string.Format("Error capturing region {0},{1},{2},{3}", x, y, width, height), ex);
            }
            finally
            {
                Gdi32.DeleteObject(compatibleBitmapHandle);

                User32.ReleaseDC(IntPtr.Zero, sourceDC);
                User32.ReleaseDC(IntPtr.Zero, targetDC);
            }

            return(bitmap);
        }
Exemple #30
0
        /*
         * InitBackBuffer
         */

        /// <summary>
        /// Creates the offscreen DC and associated bitmap.
        /// </summary>
        /// <param name="dc">Specifies drawing context for this <see cref="T:Genetibase.UI.NuGenPushGraphBar"/>.</param>
        /// <returns></returns>
        protected virtual IntPtr InitBackBuffer(IntPtr dc)
        {
            this.dcBack = Gdi32.CreateCompatibleDC(dc);
            Rectangle clientRectangle = this.ClientRectangle;

            this.bmBack = Gdi32.CreateCompatibleBitmap(
                dc,
                this.ClientRectangle.Width,
                this.ClientRectangle.Height
                );

            Gdi32.SelectObject(this.dcBack, this.bmBack);
            return(dcBack);
        }