none
Débutant besoin d'éxécuter cette méthode. RRS feed

  • Question

  • Bonjour je suis débutant dans visual studio and aussi en csharp.

    J'ai trouvé cette méthode sur internet, mon besoin est de faire un screenshot d'une application et le résultat final devrait etre capable de passer par une méthode qui tient compte du statut d'une fenêtre en mode minimisé ou invisible, pour l'instant ce n'est pas important, je recherche surtout comment utiliser la méthode dans le lien pour l'intégrer dans un projet vide et que ca tourne.

    https://www.daniweb.com/programming/software-development/threads/260393/get-bitmap-of-hidden-window

    Merci parce-que je n'arrive à rien reconnaitre et réaliser une exécution, les importations ne fonctionnent déjà pas.

    edit:même fonction plus ou moins détaillée ici http://www.sohua.xyz/questions-full/3153850/c-sharp-printwindow-returns-a-black-image

    edit2: on peut faire passer un handle comme ceci avec une fenêtre de test

    string prcname="notepad.exe";

    var proc = Process.GetProcessesByName(prcname)[0];

    IntPtr hwnd = proc.MainWindowHandle;

    puis appeler CaptureWindow(hwnd)

    mardi 2 février 2016 17:06

Réponses

  • Bonjour, pardon j'ai tenté de l'éxecuter mais finalement tout va bien, il manquait pas mal de référence puis j'ai du cast des int en intptr, le soucis étant que je n'arrive pas à obtenir une image de la fenêtre si le code ne l'a ramène pas au premier plan ou tout du moins d'après mon expérience passée que ce soit dans ce lange ou un autre au moins une fenêtre restaurée mais moi je souhaite faire un screenshot d'une fenêtre minimisée et qu'elle le reste sans changer son état.

    Voici le code qui fonctionne bien en trouvant le handle d'un pid, le handle est préremplis car je ne connais pas encore comment passer d'un titre de fenêtre à un pid vers un handle de fenêtre.

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Drawing;
    using System.Threading;
    using System.Runtime.InteropServices;
    using System.Windows.Forms;
    using System.Device;
    
    
    namespace ScreenAppByHandler
    {
        class Program
        {
            public static void Main(string[] args)
            {
                IntPtr aptr = (IntPtr)0x0008290C;
                Orwellophile.TakeScreenShotOfWindow("C:/Users/Colorado/Documents/MMEDIA/window.jpg", aptr);
                //Orwellophile.
            }
        }
            [StructLayout(LayoutKind.Sequential)]
    public struct RECT
    {
        private int _Left;
        private int _Top;
        private int _Right;
        private int _Bottom;
    
        public RECT(System.Drawing.Rectangle Rectangle)
            : this(Rectangle.Left, Rectangle.Top, Rectangle.Right, Rectangle.Bottom)
        {
        }
        public RECT(int Left, int Top, int Right, int Bottom)
        {
            _Left = Left;
            _Top = Top;
            _Right = Right;
            _Bottom = Bottom;
        }
    
        public int X
        {
            get { return _Left; }
            set { _Left = value; }
        }
        public int Y
        {
            get { return _Top; }
            set { _Top = value; }
        }
        public int Left
        {
            get { return _Left; }
            set { _Left = value; }
        }
        public int Top
        {
            get { return _Top; }
            set { _Top = value; }
        }
        public int Right
        {
            get { return _Right; }
            set { _Right = value; }
        }
        public int Bottom
        {
            get { return _Bottom; }
            set { _Bottom = value; }
        }
        public int Height
        {
            get { return _Bottom - _Top; }
            set { _Bottom = value - _Top; }
        }
        public int Width
        {
            get { return _Right - _Left; }
            set { _Right = value + _Left; }
        }
        public Point Location
        {
            get { return new Point(Left, Top); }
            set
            {
                _Left = value.X;
                _Top = value.Y;
            }
        }
        public Size Size
        {
            get { return new Size(Width, Height); }
            set
            {
                _Right = value.Height + _Left;
                _Bottom = value.Height + _Top;
            }
        }
    
        public Rectangle ToRectangle()
        {
            return new Rectangle(this.Left, this.Top, this.Width, this.Height);
        }
        static public Rectangle ToRectangle(RECT Rectangle)
        {
            return Rectangle.ToRectangle();
        }
        static public RECT FromRectangle(Rectangle Rectangle)
        {
            return new RECT(Rectangle.Left, Rectangle.Top, Rectangle.Right, Rectangle.Bottom);
        }
    
        static public implicit operator Rectangle(RECT Rectangle)
        {
            return Rectangle.ToRectangle();
        }
        static public implicit operator RECT(Rectangle Rectangle)
        {
            return new RECT(Rectangle);
        }
        static public bool operator ==(RECT Rectangle1, RECT Rectangle2)
        {
            return Rectangle1.Equals(Rectangle2);
        }
        static public bool operator !=(RECT Rectangle1, RECT Rectangle2)
        {
            return !Rectangle1.Equals(Rectangle2);
        }
    
        public override string ToString()
        {
            return "{Left: " + _Left + "; " + "Top: " + _Top + "; Right: " + _Right + "; Bottom: " + _Bottom + "}";
        }
    
        public bool Equals(RECT Rectangle)
        {
            return Rectangle.Left == _Left && Rectangle.Top == _Top && Rectangle.Right == _Right && Rectangle.Bottom == _Bottom;
        }
        public override bool Equals(object Object)
        {
            if (Object is RECT)
            {
                return Equals((RECT)Object);
            }
            else if (Object is Rectangle)
            {
                return Equals(new RECT((Rectangle)Object));
            }
    
            return false;
        }
    
        public override int GetHashCode()
        {
            return Left.GetHashCode() ^ Right.GetHashCode() ^ Top.GetHashCode() ^ Bottom.GetHashCode();
        }
    }
    
        public class Orwellophile
        {
            [DllImport("gdi32.dll", SetLastError = true)]
            static extern IntPtr CreateCompatibleDC(IntPtr hdc);
            [DllImport("user32.dll")]
            static extern IntPtr GetWindowDC(IntPtr hWnd);
            [DllImport("gdi32.dll")]
            static extern IntPtr CreateCompatibleBitmap(IntPtr hdc, int nWidth, int nHeight);
            [DllImport("gdi32.dll", ExactSpelling = true, PreserveSig = true, SetLastError = true)]
            static extern IntPtr SelectObject(IntPtr hdc, IntPtr hgdiobj);
            [DllImport("User32.dll", SetLastError = true)]
            [return: MarshalAs(UnmanagedType.Bool)]
            static extern bool PrintWindow(IntPtr hwnd, IntPtr hDC, uint nFlags); // To capture only the client area of window, use PW_CLIENTONLY = 0x1 as nFlags
            [DllImport("gdi32.dll")]
            static extern bool DeleteObject(IntPtr hObject);
            [DllImport("user32.dll")]
            static extern bool ReleaseDC(IntPtr hWnd, IntPtr hDC);
    
            [DllImport("user32.dll", EntryPoint = "SetWindowPos")]
            static extern bool SetWindowPos(
             int hWnd,           // window handle
             int hWndInsertAfter,    // placement-order handle
             int X,          // horizontal position
             int Y,          // vertical position
             int cx,         // width
             int cy,         // height
             uint uFlags);       // window positioning flags
            [DllImport("user32.dll")]
            static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
            [DllImport("user32.dll")]
            [return: MarshalAs(UnmanagedType.Bool)]
            public static extern bool GetWindowRect(IntPtr hwnd, out RECT lpRect);
            [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
            static public extern IntPtr GetForegroundWindow();
            private const int SW_SHOWNOACTIVATE = 4;
            private const int HWND_TOPMOST = -1;
            private const uint SWP_NOACTIVATE = 0x0010;
            private const int SRCCOPY = 0xcc0020;
            [DllImport("User32.dll", EntryPoint = "GetDC")]
            public static extern IntPtr GetDC(IntPtr hwnd);
            [DllImport("gdi32.dll", EntryPoint = "BitBlt")]
            public static extern int BitBlt(IntPtr hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, IntPtr hdcSrc, int nXSrc, int nYSrc, uint dwRop);
            //public static void TakeScreenshotOfWindow(String strFilename, IntPtr hTargetWindow);
    
            private static void TakeScreenshotPrivate(string strFilename, Rectangle objRectangle)
            {
    
            Bitmap objBitmap = new Bitmap(objRectangle.Width, objRectangle.Height);
                Graphics objGraphics = default(Graphics);
                IntPtr hdcDest = default(IntPtr);
                IntPtr hdcSrc = (IntPtr)0;
    
                objGraphics = Graphics.FromImage(objBitmap);
    
    
                hdcSrc = GetDC((IntPtr)0);                  // Get a device context to the windows desktop and our destination  bitmaps
                hdcDest = objGraphics.GetHdc();     // Copy what is on the desktop to the bitmap
                BitBlt((IntPtr)hdcDest, 0, 0, objRectangle.Width, objRectangle.Height, hdcSrc, objRectangle.X, objRectangle.Y, SRCCOPY);
                //.ToInt32()
                objGraphics.ReleaseHdc(hdcDest);    // Release DC
                ReleaseDC((IntPtr)0, hdcSrc);
    
                objBitmap.Save(strFilename);
            }
    
            internal static void TakeScreenShotOfWindow(string strFilename, IntPtr hTargetWindow)
            {
                Rectangle objRectangle;
                RECT r;
                IntPtr hForegroundWindow = GetForegroundWindow();
    
                GetWindowRect(hTargetWindow, out r);
                objRectangle = r.ToRectangle();
                //Ne fonctionne pas si je commente tout jusqu'à la fin sauf le dernier appel.
                if (hTargetWindow != hForegroundWindow)
                {
                    ShowWindow(hTargetWindow, SW_SHOWNOACTIVATE);
                    SetWindowPos(hTargetWindow.ToInt32(), HWND_TOPMOST, r.X, r.Y, r.Width, r.Height, SWP_NOACTIVATE);
                    Thread.Sleep(500);
                }
    
                TakeScreenshotPrivate(strFilename, objRectangle);
            }
        }
       
           
        
    
    }
    

    mercredi 3 février 2016 19:43

Toutes les réponses

  • Bonjour, bonjour101,

    les importations ne fonctionnent déjà pas.

    Avez vous ajouté cette ligne ?

    using System.Runtime.InteropServices;

    La classe DllImportAttribute se trouve dans cet espace de nom.

    Cordialement,
    Dimitar

    mercredi 3 février 2016 15:32
    Modérateur
  • Bonjour, pardon j'ai tenté de l'éxecuter mais finalement tout va bien, il manquait pas mal de référence puis j'ai du cast des int en intptr, le soucis étant que je n'arrive pas à obtenir une image de la fenêtre si le code ne l'a ramène pas au premier plan ou tout du moins d'après mon expérience passée que ce soit dans ce lange ou un autre au moins une fenêtre restaurée mais moi je souhaite faire un screenshot d'une fenêtre minimisée et qu'elle le reste sans changer son état.

    Voici le code qui fonctionne bien en trouvant le handle d'un pid, le handle est préremplis car je ne connais pas encore comment passer d'un titre de fenêtre à un pid vers un handle de fenêtre.

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Drawing;
    using System.Threading;
    using System.Runtime.InteropServices;
    using System.Windows.Forms;
    using System.Device;
    
    
    namespace ScreenAppByHandler
    {
        class Program
        {
            public static void Main(string[] args)
            {
                IntPtr aptr = (IntPtr)0x0008290C;
                Orwellophile.TakeScreenShotOfWindow("C:/Users/Colorado/Documents/MMEDIA/window.jpg", aptr);
                //Orwellophile.
            }
        }
            [StructLayout(LayoutKind.Sequential)]
    public struct RECT
    {
        private int _Left;
        private int _Top;
        private int _Right;
        private int _Bottom;
    
        public RECT(System.Drawing.Rectangle Rectangle)
            : this(Rectangle.Left, Rectangle.Top, Rectangle.Right, Rectangle.Bottom)
        {
        }
        public RECT(int Left, int Top, int Right, int Bottom)
        {
            _Left = Left;
            _Top = Top;
            _Right = Right;
            _Bottom = Bottom;
        }
    
        public int X
        {
            get { return _Left; }
            set { _Left = value; }
        }
        public int Y
        {
            get { return _Top; }
            set { _Top = value; }
        }
        public int Left
        {
            get { return _Left; }
            set { _Left = value; }
        }
        public int Top
        {
            get { return _Top; }
            set { _Top = value; }
        }
        public int Right
        {
            get { return _Right; }
            set { _Right = value; }
        }
        public int Bottom
        {
            get { return _Bottom; }
            set { _Bottom = value; }
        }
        public int Height
        {
            get { return _Bottom - _Top; }
            set { _Bottom = value - _Top; }
        }
        public int Width
        {
            get { return _Right - _Left; }
            set { _Right = value + _Left; }
        }
        public Point Location
        {
            get { return new Point(Left, Top); }
            set
            {
                _Left = value.X;
                _Top = value.Y;
            }
        }
        public Size Size
        {
            get { return new Size(Width, Height); }
            set
            {
                _Right = value.Height + _Left;
                _Bottom = value.Height + _Top;
            }
        }
    
        public Rectangle ToRectangle()
        {
            return new Rectangle(this.Left, this.Top, this.Width, this.Height);
        }
        static public Rectangle ToRectangle(RECT Rectangle)
        {
            return Rectangle.ToRectangle();
        }
        static public RECT FromRectangle(Rectangle Rectangle)
        {
            return new RECT(Rectangle.Left, Rectangle.Top, Rectangle.Right, Rectangle.Bottom);
        }
    
        static public implicit operator Rectangle(RECT Rectangle)
        {
            return Rectangle.ToRectangle();
        }
        static public implicit operator RECT(Rectangle Rectangle)
        {
            return new RECT(Rectangle);
        }
        static public bool operator ==(RECT Rectangle1, RECT Rectangle2)
        {
            return Rectangle1.Equals(Rectangle2);
        }
        static public bool operator !=(RECT Rectangle1, RECT Rectangle2)
        {
            return !Rectangle1.Equals(Rectangle2);
        }
    
        public override string ToString()
        {
            return "{Left: " + _Left + "; " + "Top: " + _Top + "; Right: " + _Right + "; Bottom: " + _Bottom + "}";
        }
    
        public bool Equals(RECT Rectangle)
        {
            return Rectangle.Left == _Left && Rectangle.Top == _Top && Rectangle.Right == _Right && Rectangle.Bottom == _Bottom;
        }
        public override bool Equals(object Object)
        {
            if (Object is RECT)
            {
                return Equals((RECT)Object);
            }
            else if (Object is Rectangle)
            {
                return Equals(new RECT((Rectangle)Object));
            }
    
            return false;
        }
    
        public override int GetHashCode()
        {
            return Left.GetHashCode() ^ Right.GetHashCode() ^ Top.GetHashCode() ^ Bottom.GetHashCode();
        }
    }
    
        public class Orwellophile
        {
            [DllImport("gdi32.dll", SetLastError = true)]
            static extern IntPtr CreateCompatibleDC(IntPtr hdc);
            [DllImport("user32.dll")]
            static extern IntPtr GetWindowDC(IntPtr hWnd);
            [DllImport("gdi32.dll")]
            static extern IntPtr CreateCompatibleBitmap(IntPtr hdc, int nWidth, int nHeight);
            [DllImport("gdi32.dll", ExactSpelling = true, PreserveSig = true, SetLastError = true)]
            static extern IntPtr SelectObject(IntPtr hdc, IntPtr hgdiobj);
            [DllImport("User32.dll", SetLastError = true)]
            [return: MarshalAs(UnmanagedType.Bool)]
            static extern bool PrintWindow(IntPtr hwnd, IntPtr hDC, uint nFlags); // To capture only the client area of window, use PW_CLIENTONLY = 0x1 as nFlags
            [DllImport("gdi32.dll")]
            static extern bool DeleteObject(IntPtr hObject);
            [DllImport("user32.dll")]
            static extern bool ReleaseDC(IntPtr hWnd, IntPtr hDC);
    
            [DllImport("user32.dll", EntryPoint = "SetWindowPos")]
            static extern bool SetWindowPos(
             int hWnd,           // window handle
             int hWndInsertAfter,    // placement-order handle
             int X,          // horizontal position
             int Y,          // vertical position
             int cx,         // width
             int cy,         // height
             uint uFlags);       // window positioning flags
            [DllImport("user32.dll")]
            static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
            [DllImport("user32.dll")]
            [return: MarshalAs(UnmanagedType.Bool)]
            public static extern bool GetWindowRect(IntPtr hwnd, out RECT lpRect);
            [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
            static public extern IntPtr GetForegroundWindow();
            private const int SW_SHOWNOACTIVATE = 4;
            private const int HWND_TOPMOST = -1;
            private const uint SWP_NOACTIVATE = 0x0010;
            private const int SRCCOPY = 0xcc0020;
            [DllImport("User32.dll", EntryPoint = "GetDC")]
            public static extern IntPtr GetDC(IntPtr hwnd);
            [DllImport("gdi32.dll", EntryPoint = "BitBlt")]
            public static extern int BitBlt(IntPtr hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, IntPtr hdcSrc, int nXSrc, int nYSrc, uint dwRop);
            //public static void TakeScreenshotOfWindow(String strFilename, IntPtr hTargetWindow);
    
            private static void TakeScreenshotPrivate(string strFilename, Rectangle objRectangle)
            {
    
            Bitmap objBitmap = new Bitmap(objRectangle.Width, objRectangle.Height);
                Graphics objGraphics = default(Graphics);
                IntPtr hdcDest = default(IntPtr);
                IntPtr hdcSrc = (IntPtr)0;
    
                objGraphics = Graphics.FromImage(objBitmap);
    
    
                hdcSrc = GetDC((IntPtr)0);                  // Get a device context to the windows desktop and our destination  bitmaps
                hdcDest = objGraphics.GetHdc();     // Copy what is on the desktop to the bitmap
                BitBlt((IntPtr)hdcDest, 0, 0, objRectangle.Width, objRectangle.Height, hdcSrc, objRectangle.X, objRectangle.Y, SRCCOPY);
                //.ToInt32()
                objGraphics.ReleaseHdc(hdcDest);    // Release DC
                ReleaseDC((IntPtr)0, hdcSrc);
    
                objBitmap.Save(strFilename);
            }
    
            internal static void TakeScreenShotOfWindow(string strFilename, IntPtr hTargetWindow)
            {
                Rectangle objRectangle;
                RECT r;
                IntPtr hForegroundWindow = GetForegroundWindow();
    
                GetWindowRect(hTargetWindow, out r);
                objRectangle = r.ToRectangle();
                //Ne fonctionne pas si je commente tout jusqu'à la fin sauf le dernier appel.
                if (hTargetWindow != hForegroundWindow)
                {
                    ShowWindow(hTargetWindow, SW_SHOWNOACTIVATE);
                    SetWindowPos(hTargetWindow.ToInt32(), HWND_TOPMOST, r.X, r.Y, r.Width, r.Height, SWP_NOACTIVATE);
                    Thread.Sleep(500);
                }
    
                TakeScreenshotPrivate(strFilename, objRectangle);
            }
        }
       
           
        
    
    }
    

    mercredi 3 février 2016 19:43