Копирование содержимого из скрытого или обрезанного окна в XP?

Ответ 1

Вам нужна функция PrintWindow, доступная в Win32 API с Windows XP. Если вам нужно работать со старыми версиями Windows, вы можете попробовать WM_PRINT, хотя я никогда не мог заставить его работать.

Здесь есть хорошая статья которая показывает, как использовать PrintWindow, и здесь соответствующий фрагмент кода из этой статьи:

// Takes a snapshot of the window hwnd, stored in the memory device context hdcMem
HDC hdc = GetWindowDC(hwnd);
if (hdc)
{
    HDC hdcMem = CreateCompatibleDC(hdc);
    if (hdcMem)
    {
        RECT rc;
        GetWindowRect(hwnd, &rc);

        HBITMAP hbitmap = CreateCompatibleBitmap(hdc, RECTWIDTH(rc), RECTHEIGHT(rc));
        if (hbitmap)
        {
            SelectObject(hdcMem, hbitmap);

            PrintWindow(hwnd, hdcMem, 0);

            DeleteObject(hbitmap);
        }
        DeleteObject(hdcMem);
    }
    ReleaseDC(hwnd, hdc);
}

У меня должен быть код Python, который использует wxPython для достижения того же. Поставьте мне записку, если хотите.

Ответ 2

Скопируйте исходную растровую карту в растровое изображение памяти перед закрытием/скрытием окна.

Ответ 3

Вы можете попробовать отправить сообщение WM_PRINT в окно. Для многих окон (включая все стандартные окна и общие элементы управления) это заставит его рисовать в поставляемый DC.

Кроме того, если вы передадите HDC в качестве wparam сообщения WM_PAINT, многие окна (например, общие элементы управления) будут рисовать в этом DC, а не на экране.

Ответ 4

Может быть, вы можете вызвать операцию перерисовывания в окне с InvalidateRect?

Ответ 5

К сожалению, я думаю, что у вас появятся реальные проблемы с надежностью работы. Вы не говорите точно, что делаете, но я предполагаю, что, учитывая дескриптор окна, вы захватываете контекст устройства, связанный с окном, вызывая GetWindowDC(), а затем используя результирующий контекст устройства.

Это будет работать нормально на XP, когда окно будет видимым. Однако, если Vista, если включена компоновка рабочего стола, она не будет работать нормально: вы вернетесь обратно из GetWindowDC(). По сути, захват контекстов оконных устройств не будет работать надежно.

Если окно, которое вы пытаетесь скопировать, является частью вашего собственного приложения, я бы предложил изменить код для поддержки сообщения WM___PRINT: это действует как WM_PAINT, но позволяет вам использовать контекст устройства для рисования.

Если окно не принадлежит вашему приложению, вам в основном не повезло: если окно скрыто, изображение того, что оно будет показывать, если оно было видимым, не существует нигде.

Ответ 6

Функция PrintWindow, похоже, не работает в скрытом окне, только на видимых.

Ответ 7

Приближаясь к вещам с другой точки зрения, вы уверены, что действительно то, что вы хотите делать? Например, вы не хотите использовать CreateCompatibleDC и CreateCompatibleBitmap для создания невидимой поверхности чертежа, используя это, а затем используя BitBlt?

Дополнительная информация о том, что вы делаете, может помочь кому-то придумать решение или какое-то боковое мышление...

Ответ 8

http://msdn.microsoft.com/en-us/library/dd144909.aspx (getPixel) может помочь...

Ответ 9

Я только что протестировал это в Windows 7, должен отлично работать с XP.

Он выводит окно на передний план, не придавая ему фокуса, прежде чем захватывать его. Это не совершенство, но это лучшее, что вы собираетесь делать, если не можете заставить PrintWindow() работать.

Это статический метод, поэтому вы просто можете просто называть его так:

Orwellophile.TakeScreenShotOfWindow("window.jpg", Form.Handle);

Нет беспорядка, нет суеты. Это из более крупного класса, поэтому, надеюсь, ничего не пропало. Оригиналы:

http://sfinktah.trac.cvsdude.com/vhddirector/browser/main/VHD%20Director/UnhandledExceptionManager.cs и http://sfinktah.trac.cvsdude.com/vhddirector/browser/main/CSharp.cc/Win32Messaging.cs, хотя они нигде не являются такими аккуратными, как пример, который я вставил ниже.

using System;
using System.Drawing;
using System.Threading;
using System.Runtime.InteropServices;
using System.Windows.Forms;

public class Orwellophile {
    public static void TakeScreenshotOfWindow(String strFilename, IntPtr hTargetWindow)
    {
        Rectangle objRectangle;
        RECT r;
        IntPtr hForegroundWindow = GetForegroundWindow();

        GetWindowRect(hTargetWindow, out r);
        objRectangle = r.ToRectangle();

        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);
    }

    private static void TakeScreenshotPrivate(string strFilename, Rectangle objRectangle)
    {
        Bitmap objBitmap = new Bitmap(objRectangle.Width, objRectangle.Height);
        Graphics objGraphics = default(Graphics);
        IntPtr hdcDest = default(IntPtr);
        int hdcSrc = 0;

        objGraphics = Graphics.FromImage(objBitmap);


        hdcSrc = GetDC(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(hdcDest.ToInt32(), 0, 0, objRectangle.Width, objRectangle.Height, hdcSrc, objRectangle.X, objRectangle.Y, SRCCOPY);
        objGraphics.ReleaseHdc(hdcDest);    // Release DC
        ReleaseDC(0, hdcSrc);

        objBitmap.Save(strFilename);
    }


    [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;
}

Обратите внимание, что вы можете реализовать свой собственный легкий класс RECT класса /struct, но это тот, который я использую. Я привязал его отдельно из-за его размера

[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();
    }
}

Ответ 10

Для окна, которое скрыто за другим окном, вы можете установить его прозрачным (с высокой альфа, чтобы он не выглядел прозрачным). Затем должно быть возможно захватить все окно с помощью BitBlt.