Comment simuler les clics et les pressions de la souris en F #

Question

Je suis en train de créer un programme censé déplacer la souris et appuyer automatiquement sur les endroits que je spécifie dans le code. En ce moment j'ai réussi à déplacer le curseur à l'aide de cette ligne: Cursor.Position < - System.Drawing.Point (x, y)

Ce que je ne l'ai pas encore découvert comment simuler ou clics de souris pressions sur les touches . La seule chose que j'ai trouvé à ce sujet est la classe SendKeys de MSDN (http://msdn.microsoft.com/en-us/library/system.windows.forms.sendkeys.aspx). J'ai essayé de simuler une touche avec cette classe, mais j'ai un message d'erreur d'exécution.

La ligne que j'utilise est: SendKeys.Send ("{ENTRER}")

Le message d'erreur que je reçois. « SendKeys ne peuvent pas fonctionner dans cette application, car l'application ne gère pas les messages Windows changement soit l'application pour gérer les messages ou utiliser la méthode SendKeys.SendWait. "

Donc je l'ai remplacé par la méthode SendWait, mais il ne semble toujours pas envoyer la touche. Comment puis-je faire cela? Ce que je veux vraiment que le programme fini soit en mesure de faire, c'est d'envoyer des clés et des clics de souris à un autre programme qui est déjà ouvert en arrière-plan. Par exemple, peindre une image dans Paint automatiquement.

Answer 1

Vous recherchez l'appel API Win32 SendInput.

Answer 2

Si vous voulez éviter l'interopérabilité natif de Win32, Windows Input Simulator est un wrapper géré prometteur autour de SendInput. Mais la dernière version ne supporte pas la simulation de souris. Cependant, le tronc actif a un correctif pour la simulation de la souris (voir la discussion this). Le projet utilise VS2010 C#, et vous pouvez exporter et construire vous-même à partir du référentiel subversion here.

Si vous êtes intéressé par l'interopérabilité natif de Win32, j'ai rassemblé une démonstration de l'utilisation de l'API SendInput avec F #. Cette application simule un clic droit.

open System 
open System.Runtime.InteropServices 

type MOUSEINPUT = struct 
    val dx:int 
    val dy:int 
    val mouseData:int 
    val dwFlags:int 
    val time:int 
    val dwExtraInfo:int 
    new(_dx, _dy, _mouseData, _dwFlags, _time, _dwExtraInfo) = {dx=_dx; dy=_dy; mouseData=_mouseData; dwFlags=_dwFlags; time=_time; dwExtraInfo=_dwExtraInfo} 
end 

type INPUT = struct 
    //need to escape traditional INPUT identifier here since "type" is a reserved word 
    //though could use any other identifier name if so desired 
    val ``type``:int //0 is mouse 
    val mi:MOUSEINPUT 
    new(_type, _mi) = {``type``=_type; mi=_mi} 
end 

let MOUSEEVENTF_RIGHTDOWN = 0x0008 
let MOUSEEVENTF_RIGHTUP = 0x0010 

[<DllImport("user32.dll", SetLastError=true)>] 
extern uint32 SendInput(uint32 nInputs, INPUT* pInputs, int cbSize) 

let mutable inputRightDown = INPUT(0, MOUSEINPUT(0, 0, 0, MOUSEEVENTF_RIGHTDOWN, 0, 0)) 
let mutable inputRightUp = INPUT(0, MOUSEINPUT(0, 0, 0, MOUSEEVENTF_RIGHTUP, 0, 0)) 

SendInput(uint32 1, &&inputRightDown, Marshal.SizeOf(inputRightDown)) 
SendInput(uint32 1, &&inputRightUp, Marshal.SizeOf(inputRightUp)) 

En deuxième lecture de votre question, je vois que finalement vous voulez envoyer souris simulées et des événements clavier à une application en cours d'exécution en arrière-plan, auquel cas SendMessage/PostMessage peut être API plus appropriées. Cela nécessitera toujours l'interopérabilité native, et j'espère que mon exemple utilisant SendInput sera utile. Here est une question connexe.

Answer 3

open System.Runtime.InteropServices 

module InteropWithNative = 
    [<DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)>] 
    extern void mouse_event(System.Int64, System.Int64, System.Int64, System.Int64, System.Int64) 

    let MOUSEEVENTF_LEFTDOWN = 0x02L 
    let MOUSEEVENTF_LEFTUP  = 0x04L 
    let MOUSEEVENTF_RIGHTDOWN = 0x08L 
    let MOUSEEVENTF_RIGHTUP  = 0x10L 

    let MouseLeftClick() = 
     mouse_event(MOUSEEVENTF_LEFTDOWN, 0L, 0L, 0L, 0L) 
     mouse_event(MOUSEEVENTF_LEFTUP, 0L, 0L, 0L, 0L) 

ensuite à utiliser:

InteropWithNative.MouseLeftClick()