Discussion :

[eric1701]

Bonjour,
Je suis handicapé et je cherche à faire une application qui puisse controler des jeux parce que j'en ai assez de ne pas pouvoir me distraire.
Je signale que je suis débutant en C++. J'étudie Qt pour faire l'interface de mon appli.
Mais avant cela, je vais faire un test:
J'ai fait une fenetre et dedans j'ai mis 3 boutons(j'aurais pu mettre des QLabel à la place)
Je voudrais faire les choses suivantes:

le bouton 1: je veux que quand la souris le survole, cela simule une touche du clavier qui sera envoyée en continu à un jeu( ou au notepad pour tester)
et ce, tant que la souris est dessus.

le bouton 2: meme chose mais cette fois avec 2 touches en meme temps et en continu. Pour comprendre, cela me servira, pour
un jeu de course automobile, à accelérer et tourner en meme temps(en diagonale).

le bouton 3: meme chose mais avec un délai entre chaque pression simulée.

et aussi, quand je clique dessus, cela simule un clic de souris qui sera envoyée au jeu(pour le clic gauche par exemple).

J'ai déjà regardé le forum, mais rien ne correspond vraiment à ce que je cherche.

Pouvez-vous me donner des conseils sur la marche à suivre ? Sur les méthodes à employer ?
Comme je suis débutant, si vous aviez des exemples de lignes de code à me montrer, ça m'aiderai.
J'espère vraiment que vous pourrez m'aider, c'est important.

Merci.

[Troudhyl]

Bonjour,

C'est un projet intéressant, je vais pouvoir t'aider étant donné que j'ai développé un clavier virtuel il y a peu donc j'ai pas mal étudié la question.

D'abord, Qt ne permet pas de faire tout cela, il faut passer par l'API Windows (tu es bien sous Windows ?).

Ensuite, je n'ai pas mon code donc si personne ne le fait avant, je t'aiderai demain soir pour la partie API Windows. Ce qu'on peut déjà faire c'est faire une classe héritant de QPushButton (ou QLabel ou autre) pour ajouter le support du "mouseover", à savoir émettre des signaux lorsque la souris survole et sort. Voici ma proposition d'implémentation :

mouseoverbutton.h

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#ifndef MOUSEOVERBUTTON_H
#define MOUSEOVERBUTTON_H
 
#include <QPushButton>
 
class MouseOverButton : public QPushButton
{
    Q_OBJECT
 
public:
    explicit MouseOverButton(QWidget *parent = 0);
    ~MouseOverButton();
 
    inline const bool isMouseOver();
 
signals:
    void entered();
    void leaved();
    void mouseIsOver(bool over);
 
private:
    bool mouseOver;
 
    void enterEvent(QEvent *);
    void leaveEvent(QEvent *);
 
private slots:
    void setMouseOver(bool over);
};
 
inline const bool MouseOverButton::isMouseOver() {
    return mouseOver;
}
 
#endif // MOUSEOVERBUTTON_H

mouseoverbutton.cpp

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include "mouseoverbutton.h"
 
MouseOverButton::MouseOverButton(QWidget *parent) :
    QPushButton(parent)
{
    connect(this, SIGNAL(mouseIsOver(bool)), SLOT(setMouseOver(bool)));
}
 
MouseOverButton::~MouseOverButton()
{
}
 
void MouseOverButton::enterEvent(QEvent *) {
    emit mouseIsOver(true);
}
 
void MouseOverButton::leaveEvent(QEvent *) {
    emit mouseIsOver(false);
}
 
void MouseOverButton::setMouseOver(bool over) {
    mouseOver = over;
    if (mouseOver)
        emit entered();
    else
        emit leaved();
}

[eric1701]

Merci pour ton aide.
Je suis bien sous windows (le 7).

[Troudhyl]

Bonsoir,

Voici ci-joint un projet, tu peux t'appuyer dessus. Il n'est quasi pas commenté alors si tu ne comprends pas quelque chose n'hésite pas.

Attention à l'exécution ! Vu qu'il tape des choses juste en passant la souris dessus ^^

Il y a les 3 boutons demandés, avec pour chacun une checkbox "auto" pour répéter le fait de le survoler. Je ne sais pas comment fonctionnent les jeux, s'ils surveillent les down/up de touche alors il n'y a pas besoin de répéter : survole = down et sortir = up (sinon en auto actuellement ça répète les down). A tester avec un éditeur de texte (il tape des C et des V).

Si tu cliques sur un bouton, ça envoie le curseur un peu plus en haut à gauche, clique, et revient. Ce n'est pas du tout fonctionnel, mais envoyer un événement clic se fait à une certaine position à spécifier, donc pas sûr que tu puisses faire quelque chose de cette idée. A tester avec Paint par exemple.

La fenêtre peut être déplacée, et elle est toujours devant mais jamais active, sinon tu perdrais focus de la fenêtre où tu essaies de l'utiliser. Elle s'ouvre en bas de l'écran au milieu de sa largeur.

Avec ça tu devrais avoir toutes les briques pour bien avancer dans ton projet.

Bon courage !

PS : Lien dans les téléchargements

[eric1701]

Merci pour ton aide, c'est ce que je cherchais.
J'ai essayé et ça marche sur le notepad.
Avec les jeux, c'est plus difficile car je crois que la touche en continu
est trop rapide pour eux. Avec une pause très brève entre la touche, ça pourrait marcher.
Si j'ai d'autres problèmes, je te demanderai.
Encore merci.

[Troudhyl]

De rien Après c'est juste un exemple, faut reprendre pas mal de choses. La vitesse de l'automatique est à 40ms, cf mouseoverbutton.cpp . Il me semble que c'est à peu près la vitesse réglée à mon clavier.
Dans un programme pour observer les événements clavier, je me suis aperçu que l'auto-repeat réel alterne les press/release ce qui semble plus logique en fait que ce que j'ai fait.

Code de l'observateur, tout basique, en console :

Widget.h

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#ifndef WIDGET_H
#define WIDGET_H
 
#include <QtGui/QWidget>
 
class Widget : public QWidget
{
    Q_OBJECT
 
public:
    Widget(QWidget *parent = 0);
    ~Widget();
 
    void keyPressEvent(QKeyEvent *e);
    void keyReleaseEvent(QKeyEvent *e);
};
 
#endif // WIDGET_H

Widget.cpp

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include "widget.h"
#include <QDebug>
#include <QKeyEvent>
 
Widget::Widget(QWidget *parent)
    : QWidget(parent)
{
    resize(500,400);
}
 
Widget::~Widget()
{
 
}
 
void Widget::keyPressEvent(QKeyEvent *e)
{
    qDebug() << e->key() << e->text() << "pressed";
}
 
void Widget::keyReleaseEvent(QKeyEvent *e)
{
    qDebug() << e->key() << e->text() << "released";
}

main.cpp

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
#include <QtGui/QApplication>
#include "widget.h"
 
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Widget w;
    w.show();
 
    return a.exec();
}

Je pense qu'ajouter un Up dans Widget::auto1() avant le Down traduira mieux un vrai comportement (même si le tout premier up est en trop, ce qui est sans conséquence).

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
void Widget::auto1()
{
    sendKeyboardInputUp(  0, QChar('C').unicode(), KEYEVENTF_UNICODE);
    sendKeyboardInputDown(0, QChar('C').unicode(), KEYEVENTF_UNICODE);
}

Ce que je n'arrive pas à faire c'est :
"C" pressed
"V" pressed
"V" released
"C" released
(combinaison de touche), du coup c'est juste alterné très rapidement. Bizarre, car ce comportement est possible en vrai... Il doit y avoir une question de pile quelque part.

Je maj la page de téléchargement.