C/Visual C - Ayuda con capturar ventana con C++/CLI

#ifndef MANEJOPROCESOS_H

#define MANEJOPROCESOS_H

#include "Estructuras.h"

#include "ManejoDirectorios.h"

using namespace System;

using namespace System::Diagnostics;

using namespace System::ComponentModel;

using namespace System::Drawing;

[DllImport("user32.dll")]

static bool GetClientRect(IntPtr^ hWnd, Rectangle^ lpRect);

ref class ManejoProcesos

{

private:

	List<Servidores^>^ listaServidores;

	Servidores^ structServidor;

	array<Process^>^ listaProcesosBuscados;

	Process^ process;

	Process^ proServidor;

	ProcessStartInfo^ psi;

	String^ msgError;

	String^ servidor;

	// Ejemplo parametros servidor "-b 2000 -s 640x480 -f 30 -p 9006 \"Proyecto_Arduinio_I Game Preview Standalone(64 - bit / PCD3D_SM5)\""

	String^ parametrosServidor;

	int servidores = 0;

	// Esto sirve para que mientras se ejecuta el proceso no vaya a buscar un proceso que todavía no existe

	int dormir = 7000;

public:

	ManejoProcesos()

	{

		listaServidores = gcnew List<Servidores^>;

		servidor = ManejoDirectorios::rutaPrograma + "/jsmpeg-vnc-v0.2/jsmpeg-vnc.exe ";

		parametrosServidor = "-b 2000 -s 640x480 -f 30 -p 9006 ";

	}

	inline String^ obtenerError() { return msgError; }

	bool lanzarEjecutableConServidor(String^ nombreRuta, int indiceLista)

	{

		try

		{

			process = gcnew Process();

			psi = gcnew ProcessStartInfo(nombreRuta);

			process->StartInfo = psi;

			process->Start();

			// Se detiene un rato el proceso en lo que el proceso de render inicia

			System::Threading::Thread::Sleep(dormir);

			//*************** Lanzar servidor

			this->iniciarServidor(indiceLista, process, psi);

			//*******************************

			msgError = "";

			return true;

		}

		catch (Exception ^ ex)

		{

			msgError = ex->Message;

			return false;

		}

	}

	// Inicia un servidor y lo almacena para luego ser terminado cuando se desea

	bool iniciarServidor(int indiceLista, Process^ procesoRender, ProcessStartInfo^ infoRender)

	{

		try

		{

			proServidor = gcnew Process();

			String^ rutaServidor = servidor;

			psi = gcnew ProcessStartInfo(rutaServidor);

			psi->Arguments = parametrosServidor + "\"" + procesoRender->ProcessName + "\"";

			structServidor = gcnew Servidores();

			proServidor->StartInfo = psi;

			proServidor->Start();

			structServidor->estadoProceso = EN_STREAMING;

			structServidor->procesoServidor = proServidor;

			structServidor->procesoRender = procesoRender;

			structServidor->indiceLista = indiceLista;

			structServidor->indice = servidores;

			structServidor->infoRender = infoRender;

			structServidor->infoServidor = psi;

			listaServidores->Add(structServidor);

			msgError = "";

			servidores++;

			return true;

		}

		catch (Exception ^ ex)

		{

			msgError = ex->Message;

			return false;

		}

	}

	bool detenerServidor(int indiceLista)

	{

		for each (Servidores ^ server in listaServidores)

		{

			if (server->indiceLista == indiceLista)

			{

				try

				{

					server->estadoProceso = APAGADO;

					server->procesoServidor->Kill();

					server->procesoRender->Kill();

					listaServidores->Remove(server);

					msgError = "";

					return true;

				}

				catch (Exception ^ ex)

				{

					msgError = ex->Message;

					return false;

				}

			}

		}

		msgError = "Servidor no encontrado...";

		return false;

	}

};

#endif // MANEJOPROCESOS_H

using System;

using System.Threading.Tasks;

using CaptureSampleCore;

using Composition.WindowsRuntimeHelpers;

using Windows.Graphics.Capture;

class ACapturador

{

    private string msgError = "";

    private SProcesos proc;

    private IntPtr hwnd;

    private BasicSampleApplication sample;

    public ACapturador()

    {

    }

    public string MsgError { get { return msgError; } }

    public bool InicializarCapturador()

    {

        if (!Windows.Graphics.Capture.GraphicsCaptureSession.IsSupported())

        {

            this.msgError = "Error Windows.Graphics.Capture no soportado.";

            return false;

        }

        else

        {

            this.msgError = "";

            return true;

        }

    }

    public SProcesos SProceso

    {

        get { return this.proc; }

        set { this.proc = value; }

    }

    public async Task StartPickerCaptureAsync(SProcesos sProc)

    {

        hwnd = sProc.proRender.MainWindowHandle;

        var picker = new GraphicsCapturePicker();

        picker.SetWindow(hwnd);

        GraphicsCaptureItem item = await picker.PickSingleItemAsync();

        if (item != null)

        {

            sample.StartCaptureFromItem(item);

        }

    }

    private void StartHwndCapture(IntPtr hwnd)

    {

        GraphicsCaptureItem item = CaptureHelper.CreateItemForWindow(hwnd);

        if (item != null)

        {

            sample.StartCaptureFromItem(item);

        }

    }

}

#ifndef PROCESOS_H

#define PROCESOS_H

#include <Windows.h>

#include <iostream>

#include "AList.h"

#include "AString.h"

class Procesos

{

private:

	// Estructura que guarda un proceso hijo

	struct Proceso

	{

		// Handle Process

		HANDLE hProcess = 0;

		// Handle Thread

		HANDLE hThread = 0;

		// Startup Information

		STARTUPINFO si;

		// Process Information

		PROCESS_INFORMATION pi;

		// Process ID

		DWORD dwProcessId;

		// Process ID Hilo

		DWORD dwThreadId;

		// Boolean Process

		BOOL bProcess;

	};

	AList<Proceso> listaProcs;

	AString msgError;

public:

	// Constructor

	Procesos();

	// Añade un nuevo proceso a la lista y lo ejecuta

	bool nuevoProceso(LPCWSTR rutaEjecutable);

	void cerrarProceso(int pos);

	HANDLE obtenerHandleProceso(int pos);

	DWORD obtenerIdProceso(int pos);

};

#endif // PROCESOS_H

#include "Procesos.h"

Procesos::Procesos()

{

	listaProcs.borrar_todosElementos();

}

bool Procesos::nuevoProceso(LPCWSTR rutaEjecutable)

{

	Proceso proc;

	// Lleno los espacios de zeros para ocupar ese espacio de memoria despues

	// Paso 1

	ZeroMemory(&proc.si, sizeof(proc.si));

	ZeroMemory(&proc.pi, sizeof(proc.pi));

	// Paso 2

	proc.bProcess = CreateProcess(

		rutaEjecutable,	// Nombre de la aplicacion

		NULL,							// Linea de comandos

		NULL,							// Atributos del proceso

		NULL,							// Hilo de atributos

		FALSE,							// Inherit handle

		0,								// Creacion de bandera

		NULL,							// Enviroment variable

		NULL,							// Directorio actual

		&proc.si,						// Start info

		&proc.pi						// Process Information

	);

	// Paso 3

	if (proc.bProcess == FALSE)

	{

		msgError.setAString("Error al crear proceso: CREATE_PROCESS");

		return false;

	}

	else

	{

		// Paso 4

		//WaitForSingleObject(proc.pi.hProcess, 0);

		listaProcs.insertar(proc);

		return true;

	}

}

void Procesos::cerrarProceso(int pos)

{

	// Paso 5

	// Cerrar los handles que iniciaron el proceso

	Proceso proc = listaProcs.obtener_at(pos);

	CloseHandle(proc.hProcess);

	CloseHandle(proc.hThread);

	TerminateProcess(proc.hProcess, 0);

}

HANDLE Procesos::obtenerHandleProceso(int pos)

{

	Proceso proc = listaProcs.obtener_at(pos);

	return proc.pi.hProcess;

}

DWORD Procesos::obtenerIdProceso(int pos)

{

	Proceso proc = listaProcs.obtener_at(pos);

	return GetProcessId(proc.pi.hProcess);

}

#include "ACapturador.h"

#include <atlimage.h>

#include <gdiplusimaging.h>

#include <Windows.h>

//**********************************************************************************************

// Estas funciones no son posibles compilarlas en un archivo .h

//**********************************************************************************************

typedef struct {

	char* prefix;

	HWND window;

} window_with_prefix_data_t;

BOOL CALLBACK window_with_prefix_callback(HWND window, LPARAM lParam) {

	window_with_prefix_data_t* find = (window_with_prefix_data_t*)lParam;

	char title[80];

	GetWindowTextA(window, title, sizeof(title));

	if (!find->window && strncmp(find->prefix, title, strlen(find->prefix)) == 0) {

		find->window = window;

	}

	return TRUE;

}

HWND window_with_prefix(char* title_prefix) {

	window_with_prefix_data_t find = { title_prefix, NULL };

	EnumWindows(window_with_prefix_callback, (LPARAM)&find);

	return find.window;

}

// Structure used to communicate data from and to enumeration procedure

struct EnumData {

	DWORD dwProcessId;

	HWND hWnd;

};

// Application-defined callback for EnumWindows

BOOL CALLBACK EnumProc(HWND hWnd, LPARAM lParam) {

	// Retrieve storage location for communication data

	EnumData& ed = *(EnumData*)lParam;

	DWORD dwProcessId = 0x0;

	// Query process ID for hWnd

	GetWindowThreadProcessId(hWnd, &dwProcessId);

	// Apply filter - if you want to implement additional restrictions,

	// this is the place to do so.

	if (ed.dwProcessId == dwProcessId) {

		// Found a window matching the process ID

		ed.hWnd = hWnd;

		// Report success

		SetLastError(ERROR_SUCCESS);

		// Stop enumeration

		return FALSE;

	}

	// Continue enumeration

	return TRUE;

}

// Main entry

HWND FindWindowFromProcessId(DWORD dwProcessId) {

	EnumData ed = { dwProcessId };

	if (!EnumWindows(EnumProc, (LPARAM)&ed) &&

		(GetLastError() == ERROR_SUCCESS)) {

		return ed.hWnd;

	}

	return NULL;

}

// Helper method for convenience

HWND FindWindowFromProcess(HANDLE hProcess) {

	return FindWindowFromProcessId(GetProcessId(hProcess));

}

//**********************************************************************************************

// Estas funciones no son posibles compilarlas en un archivo .h

//**********************************************************************************************

ACapturador::ACapturador()

{

}

ACapturador::~ACapturador()

{

	delete img;

}

CImage ACapturador::capturarImagen(HANDLE hProcess)

{

	RECT rect;

	HWND ventana = NULL;

	// Obtengo el proceso

	/*do

	{

		ventana = FindWindowEx(NULL,ventana, NULL, NULL);

		GetWindowThreadProcessId(ventana, &idProc);

		if (idProc == procId)

		{

			break;

		}

	} while (ventana != NULL);*/

	// Dibujo el cuadro

	//char* window_title = (char*)"PruebasIA";

	//ventana = window_with_prefix(window_title);

	//ventana = FindWindowEx(0,0, TEXT("PruebasIA"),0);

	ventana = FindWindowFromProcess(hProcess);

	//GetWindowThreadProcessId(ventana, &procId);

	GetClientRect(ventana, &rect);

	HDC ventanaDC = GetDC(ventana);

	HDC memoriaDC = CreateCompatibleDC(ventanaDC);

	HBITMAP bmp = CreateCompatibleBitmap(ventanaDC, rect.right - rect.left, rect.bottom - rect.top);

	img.Attach(bmp);

	CLSID pngClsid;

	img.Save(L"archivo.jpeg", Gdiplus::ImageFormatJPEG); //Esta linea solo es para hacer una comprobacion que si obtengo una captura del proceso

	return img;

}

Bitmap CapPantalla(String filename, ImageFormat format)

{

    Rectangle bounds = Screen.GetBounds(Point.Empty);

    Bitmap bitmap = new Bitmap(bounds.Width, bounds.Height);

    using (Graphics g = Graphics.FromImage(bitmap))

    {

        g.CopyFromScreen(Point.Empty, Point.Empty, bounds.Size);

    }

     if (filename != null) bitmap.Save(filename, format);

    return bitmap;

}

void MandarBitmap(Socket soc, Bitmap bitmap)

{

    NetworkStream stream = new NetworkStream(soc);

    MemoryStream ms = new MemoryStream();

    bitmap.Save(ms, System.Drawing.Imaging.ImageFormat.Bmp);

    byte[] imageBuffer = ms.GetBuffer();

    stream.Write(imageBuffer, 0, imageBuffer.Length);

    stream.Flush();

    stream.Close();

}

public ref class Form1 : Form

    {

        bool termino = false;

        Process^ _proc;

        ProcessStartInfo^ psi;

        Thread hilo;

        public: Form1()

        {

            InitializeComponent();

            ThreadStart^ threadStart = gcnew ThreadStart(capturar);

            hilo = gcnew Thread(threadStart);

        }

        private: void btnCapturar_Click(object^ sender, EventArgs^ e)

        {

            termino = false;

            _proc = gcnew Process();

            psi = gcnew ProcessStartInfo("C:/Users/usuario/source/repos/E-Cloud v1.2/E-Cloud v1.2/Aplicaciones/PruebasIA/PruebasIA.exe");

            _proc->StartInfo = psi;

            _proc->Start();

            hilo->Start();

        }

        private: void capturar()

        {

            while(!termino)

            {

                Rectangle^ bounds = Screen::FromHandle(_proc.MainWindowHandle).Bounds;

                Bitmap^ bitmap = gcnew Bitmap(bounds.Width, bounds.Height);

                Graphics^ g = Graphics.FromHwnd(_proc.MainWindowHandle);

                    g->DrawImage(bitmap, bounds);

                    //g->CopyFromScreen(Point.Empty, Point.Empty, bounds.Size);

                System::Threading::Thread::Sleep(100);

                picImg->Image = bitmap;

            }

        }

        private: void btnDetener_Click(object^ sender, EventArgs^ e)

        {

            termino = false;

        }

    }

CImage ACapturador::capturarImagen(HWND ventana)

{

	RECT rect;

	HWND otra = FindWindow(0, TEXT("Nombre de la ventana"));

	ventana = otra;

	if (ventana== NULL)

	{

		// Capturo el error

		this->msgError.setAString("Error al encontrar ventana...");

		return img;

	}

	//Obtengo el cuadro

	GetClientRect(ventana, &rect);

	// Preparo el capturador

	HDC ventanaDC = GetDC(NULL);

	HDC memoriaDC = CreateCompatibleDC(ventanaDC);

	HBITMAP bmp = CreateCompatibleBitmap(ventanaDC, rect.right - rect.left, rect.bottom - rect.top);

	// Selecciono los objetos y los capturo

	SelectObject(memoriaDC, bmp);

	PrintWindow(otra, memoriaDC, PW_CLIENTONLY);

	// Ingreso la imagen a un CImage

	img.Attach(bmp);

	CLSID pngClsid;

	img.Save(L"archivo.jpeg", Gdiplus::ImageFormatJPEG);

	//Libero memoria

	DeleteDC(memoriaDC);

	DeleteObject(bmp);

	ReleaseDC(NULL, ventanaDC);

	//Retorno la imagen

	return img;

}

// Buscar la ventana

HWND h = ::GetTopWindow(0);

while (h)

{

    DWORD pid;

    DWORD dwTheardId = ::GetWindowThreadProcessId(h, &pid);

    if (pid == proc.pi.dwProcessId)

    {

        break;

    }

    h = ::GetNextWindow(h, GW_HWNDNEXT);

}

Proceso proc;

	// Lleno los espacios de zeros para ocupar ese espacio de memoria despues

	// Paso 1

	ZeroMemory(&proc.si, sizeof(proc.si));

	ZeroMemory(&proc.pi, sizeof(proc.pi));

	// Paso 2

	proc.bProcess = CreateProcess(

		rutaEjecutable.AString2wchar_t(),	// Nombre de la aplicacion

		NULL,								// Linea de comandos

		NULL,								// Atributos del proceso

		NULL,								// Hilo de atributos

		FALSE,								// Inherit handle

		0,									// Creacion de bandera

		NULL,								// Enviroment variable

		NULL,								// Directorio actual

		&proc.si,							// Start info

		&proc.pi							// Process Information

	);