para - ¿Cómo capturar la pantalla seleccionada de otra aplicación usando java?

como tomar captura de pantalla en computadora

Question

Estamos tratando de desarrollar una utilidad de captura de pantalla.

¿Cómo capturamos la pantalla seleccionada de otra aplicación usando Java? ¿Y cómo agregamos una llamada a la pantalla capturada?

Answer 1

Si desea tomar una captura de pantalla de una ventana específica de otro código de aplicación que no es Java, creo que tendrá que escribir un código nativo (es decir, no Java). La interacción entre aplicaciones Java y aplicaciones que no son Java a ese nivel es difícil.

Answer 2

Tal vez la clase java.awt.Robot ayude con las capturas de pantalla, aunque no creo que sea capaz de localizar ventanas individuales. En cuanto a estas "llamadas", la clase Robot también puede invocar clics del mouse y presionar teclas, si eso es lo que quiere decir.

Answer 3

Tendrá que proporcionar información más específica para recibir ayuda significativa. Para empezar, ¿en qué sistemas operativos se debe trabajar? ¿Necesita capturar el contenido de ventanas individuales o pantallas enteras completas (utilizó el término ambiguo "pantalla seleccionada de otra aplicación" en su publicación original). ¿Qué desea ver específicamente cuando "agrega texto destacado a la pantalla capturada"?

Answer 4

Robot r = new Robot();
Toolkit t = Toolkit.getDefaultToolkit();
Dimension d = t.getScreenSize();
Image i = r.createScreenCapture( 0, 0, d.width, d.height );

debería obtener una imagen completa de toda la pantalla. Sin embargo, no estoy seguro de si eso le da todo si tiene múltiples monitores ...

Answer 5

Probablemente puede solucionar el problema Robot falta de capacidad para conocer los bordes de la ventana, al permitir que el usuario seleccione el área que desea captura de pantalla.

Tiene dos enfoques, si la opción es a pantalla completa no necesita preocuparse, siga el enfoque de Robot descrito anteriormente.

Si la aplicación es para el área deseada:

1. Comience la aplicación deseada.

2. Tome una pantalla completa del escritorio.

3. Cree una aplicación de pantalla completa usando la captura de pantalla como fondo, SÓLO para permitirle al usuario seleccionar el área donde capturar la imagen (comienza con un cuadrado pequeño y deja que el usuario arrastre hasta que cree la captura de pantalla deseada)

4. Pase esta información a Robot y tome capturas de pantalla de esa área.

Algo como esto:

texto alternativo http://img136.imageshack.us/img136/8622/screencapturebb3.png

Si no le gusta la opción de utilizar una captura de pantalla completa como fondo, puede usar una ventana transparente .

Y haz lo mismo: -)

La segunda opción de Aaahhh es tratar de identificar las fronteras analizando las imágenes, pero sinceramente, no creo que valga la pena.

Hay una tercera opción, pero es un secreto.

Answer 6

Código para capturar capturas de pantalla en Java,

http://www.codinguide.com/2010/04/capture-screen-shot-from-java.html

Answer 7

Basado en la descripción del proyecto de Prajakta , creo que es necesaria cierta explicación para manipular una captura de pantalla (creo que John hizo un excelente trabajo explicando cómo capturar la captura de pantalla usando la clase java.awt.Robot ). Recuerde, como dijo Steve McLeod , es posible que Java no pueda ubicar automáticamente la ubicación de la ventana que desea capturar en la pantalla. Esto es importante, porque la clase Robot necesita conocer esta ubicación, ya sea automática o manualmente.

Las llamadas, el texto, las imágenes, etc. se pueden agregar a la captura de pantalla a través del objeto Graphics2D que recibe cuando llama al método createGraphics () de la Imagen Buffered de la captura de pantalla. Le recomiendo que consulte la API de Graphics2D para comprender mejor de lo que es capaz. También recomiendo encontrar algunos tutoriales, quizás comenzando con el Tutorial de gráficos en 2D de Sun. El libro titulado " Filthy Rich Clients " también puede ser útil.

Cuando finalmente quiera guardar esta captura de pantalla modificada, puede usar uno de los métodos de "escritura" de la clase ImageIO .

Aquí hay un ejemplo muy simple, de principio a fin. Depende de usted completar los detalles necesarios.

¡Espero que esto ayude un poco!

Robot robot = new Robot();

// The hard part is knowing WHERE to capture the screen shot from
BufferedImage screenShot = robot.createScreenCapture(x, y, width, height);
Graphics2D graphics = screenShot.createGraphics();

// Add a label to the screen shot
Color textColor = Color.RED;
graphics.setColor(textColor);
graphics.drawString("Some text", textX, textY);

// Save your screen shot with its label
ImageIO.save(screenShot, "png", new File("myScreenShot.png"));

Answer 8

Con este código podría hacer pantallas de ciertas ventanas en windows10, no olvides la dependencia.

Los créditos van a: Windows: ¿cómo obtener una lista de todas las ventanas visibles?

<dependency>
    <groupId>net.java.dev.jna</groupId>
    <artifactId>jna</artifactId>
    <version>4.5.0</version>
</dependency>

Código:

import java.awt.AWTException;
import java.awt.Rectangle;
import java.awt.Robot;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import javax.imageio.ImageIO;

import com.sun.jna.Native;
import com.sun.jna.Structure;
import com.sun.jna.win32.StdCallLibrary;

public class Main {
    public static void main(String[] args) throws AWTException, IOException {

        int hWnd = User32.instance.FindWindowA(null, "Minesweeper X");
        WindowInfo w = getWindowInfo(hWnd);
        User32.instance.SetForegroundWindow(w.hwnd);
        BufferedImage createScreenCapture = new Robot().createScreenCapture(new Rectangle(w.rect.left, w.rect.top, w.rect.right - w.rect.left, w.rect.bottom - w.rect.top));
        ImageIO.write(createScreenCapture, "png", new File("screen.png"));

        // listAllWindows();
    }

    private static void listAllWindows() throws AWTException, IOException {
        final List<WindowInfo> inflList = new ArrayList<WindowInfo>();
        final List<Integer> order = new ArrayList<Integer>();
        int top = User32.instance.GetTopWindow(0);
        while (top != 0) {
            order.add(top);
            top = User32.instance.GetWindow(top, User32.GW_HWNDNEXT);
        }

        User32.instance.EnumWindows(new WndEnumProc() {
            public boolean callback(int hWnd, int lParam) {
                WindowInfo info = getWindowInfo(hWnd);
                inflList.add(info);
                return true;
            }

        }, 0);
        Collections.sort(inflList, new Comparator<WindowInfo>() {
            public int compare(WindowInfo o1, WindowInfo o2) {
                return order.indexOf(o1.hwnd) - order.indexOf(o2.hwnd);
            }
        });
        for (WindowInfo w : inflList) {
            System.out.println(w);
        }
    }

    public static  WindowInfo getWindowInfo(int hWnd) {
        RECT r = new RECT();
        User32.instance.GetWindowRect(hWnd, r);
        byte[] buffer = new byte[1024];
        User32.instance.GetWindowTextA(hWnd, buffer, buffer.length);
        String title = Native.toString(buffer);
        WindowInfo info = new WindowInfo(hWnd, r, title);
        return info;
    }

    public static interface WndEnumProc extends StdCallLibrary.StdCallCallback {
        boolean callback(int hWnd, int lParam);
    }

    public static interface User32 extends StdCallLibrary {
        public static final String SHELL_TRAY_WND = "Shell_TrayWnd";
        public static final int WM_COMMAND = 0x111;
        public static final int MIN_ALL = 0x1a3;
        public static final int MIN_ALL_UNDO = 0x1a0;

        final User32 instance = (User32) Native.loadLibrary("user32", User32.class);

        boolean EnumWindows(WndEnumProc wndenumproc, int lParam);

        boolean IsWindowVisible(int hWnd);

        int GetWindowRect(int hWnd, RECT r);

        void GetWindowTextA(int hWnd, byte[] buffer, int buflen);

        int GetTopWindow(int hWnd);

        int GetWindow(int hWnd, int flag);

        boolean ShowWindow(int hWnd);

        boolean BringWindowToTop(int hWnd);

        int GetActiveWindow();

        boolean SetForegroundWindow(int hWnd);

        int FindWindowA(String winClass, String title);

        long SendMessageA(int hWnd, int msg, int num1, int num2);

        final int GW_HWNDNEXT = 2;
    }

    public static class RECT extends Structure {
        public int left, top, right, bottom;

        @Override
        protected List<String> getFieldOrder() {
            List<String> order = new ArrayList<>();
            order.add("left");
            order.add("top");
            order.add("right");
            order.add("bottom");
            return order;
        }
    }

    public static class WindowInfo {
        int hwnd;
        RECT rect;
        String title;

        public WindowInfo(int hwnd, RECT rect, String title) {
            this.hwnd = hwnd;
            this.rect = rect;
            this.title = title;
        }

        public String toString() {
            return String.format("(%d,%d)-(%d,%d) : /"%s/"", rect.left, rect.top, rect.right, rect.bottom, title);
        }
    }
}