Hola,

No sé exactamente si este post va aquí, pero no he encontrado nada parecido.

Veréis, estoy intentando mandarle a una ventana el evento click un una posición X,Y de tal ventana. Lo quiero hacer de forma que me de igual que tenga el foco o no, o esté delante del resto de ventanas u ocutal.

He estado buscando información y he encontrado esto:
http://msdn.microsoft.com/en-us/library/ms644950(v=vs.85).aspx
He seguido buscando y he encontrado algunos ejemplos, pero por más que lo he intentado no consigo mandarle el evento a la otra ventana. Aquí dejo lo que tengo en código

Previamente a esto he recibido el Handle de la ventana correctamente.

He puesto 200,200 hardcodeado como las coordenadas del client pero aun así me sigue sin funcionar. He probado metiendo el wParam y el lParam como IntPtr pero tampoco me hace nada. Tampoco creo que sea problema de las coordenadas que sean de ventana en vez de cliente, porque utilizo un notepad que ocupa toda la pantalla y con 200,200 en algún sitio me debería de clicar.

Alguna idea?

Una vez hice esta clase en C# 2010 para ello y tambien para enviar pulsaciones de teclas y envio de texto a ventanas externas es justamente lo que necesitas:

using System;
using System.Runtime.InteropServices;
using System.Threading;
 
namespace Sender
{
 
    public sealed class WinApi
    {
 
        [DllImport("Kernel32.dll")]
        public extern static int CloseHandle(IntPtr hObject);
 
        [DllImport("kernel32.dll")]
        public static extern IntPtr OpenProcess(Consts.ProcessAccess dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, int dwProcessId);
 
        [DllImport("kernel32.dll")]
        public static extern bool VirtualProtectEx(IntPtr hProcess, IntPtr lpAddress,
           UIntPtr dwSize, Consts.Protection flNewProtect, out Consts.Protection lpflOldProtect);
 
        [DllImport("user32.dll")]
        public static extern IntPtr SendMessage(IntPtr hWnd, Consts.WindowMessage Msg, int wParam, int lParam);
 
        [DllImport("user32.dll")]
        public static extern bool SetForegroundWindow(IntPtr hWnd);
 
        [DllImport("user32.dll")]
        public static extern bool ShowWindow(IntPtr hWnd, Consts.ShowWindowCommand Cmd);
 
        public class Consts
        {
 
            public enum ProcessAccess : int
            {
                AllAccess = CreateThread | DuplicateHandle | QueryInformation | SetInformation | Terminate | VMOperation | VMRead | VMWrite | Synchronize,
                CreateThread = 0x2,
                DuplicateHandle = 0x40,
                QueryInformation = 0x400,
                SetInformation = 0x200,
                Terminate = 0x1,
                VMOperation = 0x8,
                VMRead = 0x10,
                VMWrite = 0x20,
                Synchronize = 0x100000
            }
 
            public enum ShowWindowCommand : int
            {
                Hide = 0,
                Normal = 1,
                ShowMinimized = 2,
                Maximize = 3,     
                ShowNoActivate = 4,
                Show = 5,
                Minimize = 6,
                ShowMinNoActive = 7,
                ShowNA = 8,
                Restore = 9,
                ShowDefault = 10,
                ForceMinimize = 11
            }
 
            public enum Protection : int
            {
                PAGE_NOACCESS = 0x01,
                PAGE_READONLY = 0x02,
                PAGE_READWRITE = 0x04,
                PAGE_WRITECOPY = 0x08,
                PAGE_EXECUTE = 0x10,
                PAGE_EXECUTE_READ = 0x20,
                PAGE_EXECUTE_READWRITE = 0x40,
                PAGE_EXECUTE_WRITECOPY = 0x80,
                PAGE_GUARD = 0x100,
                PAGE_NOCACHE = 0x200,
                PAGE_WRITECOMBINE = 0x400,
                PAGE_UNKNOW = 0x0
            }
 
            public enum WindowMessage : int
            {
                WM_KEYDOWN = 0x0100,
                WM_KEYUP = 0x0101,
                WM_CHAR = 0x0102,
                WM_LBUTTONDOWN = 0x201,
                WM_LBUTTONUP = 0x202
            }
        }
    }
 
    public sealed class Input
 
    {
 
        public static WinApi.Consts.Protection SetProcessMemoryAccess(IntPtr ProcesshWnd,IntPtr Address, UIntPtr Size, WinApi.Consts.Protection Protection)
        {
            WinApi.Consts.Protection x = WinApi.Consts.Protection.PAGE_UNKNOW;
            IntPtr y = WinApi.OpenProcess(WinApi.Consts.ProcessAccess.VMOperation, false, (int)ProcesshWnd);
 
            WinApi.VirtualProtectEx(y, Address, Size, Protection, out x);
 
            WinApi.CloseHandle(y);
 
            return x;
        }
 
        public static void SendKey(IntPtr WindowhWnd, Int32 key)
        {
            WinApi.SendMessage(WindowhWnd, WinApi.Consts.WindowMessage.WM_KEYDOWN, (int)key, 0);
            WinApi.SendMessage(WindowhWnd, WinApi.Consts.WindowMessage.WM_CHAR, (int)key, 0);
            WinApi.SendMessage(WindowhWnd, WinApi.Consts.WindowMessage.WM_KEYUP, (int)key, 0);
        }
 
        public static void SendClick(IntPtr WindowhWnd, int X, int Y)
        {
            WinApi.SendMessage(WindowhWnd, WinApi.Consts.WindowMessage.WM_LBUTTONUP, 0, 0);
            int lpara = MakeLParam(X, Y);
            WinApi.SendMessage(WindowhWnd, WinApi.Consts.WindowMessage.WM_LBUTTONDOWN, 0, lpara);
            WinApi.SendMessage(WindowhWnd, WinApi.Consts.WindowMessage.WM_LBUTTONUP, 0, lpara);
            Thread.Sleep(25);
        }
 
        public static void SendString(IntPtr WindowhWnd, string String)
        {
            foreach (var x in String)
                SendKey(WindowhWnd, Convert.ToInt32(x));
            Thread.Sleep(3);
        }
 
        public static void SetAsForeground(IntPtr WindowhWnd)
        {
            WinApi.ShowWindow(WindowhWnd, WinApi.Consts.ShowWindowCommand.Maximize);
            WinApi.SetForegroundWindow(WindowhWnd);
        }
 
        private static int MakeLParam(int LoWord, int HiWord) { return ((HiWord << 16) | (LoWord & 0xffff)); }
    }
}

Correcto, debes usar el handle del child "edit", usa algún window spy para obtener la información que necesitas.