FAQ C++ BuilderConsultez toutes les FAQ

Nombre d'auteurs : 60, nombre de questions : 670, dernière mise à jour : 21 novembre 2010  Ajouter une question

 

Cette F.A.Q. a été réalisée à partir des questions fréquemment posées sur le forum C++ Builder de developpez.com et de l'expérience personnelle des auteurs.

Nous tenons à souligner que cette F.A.Q. ne garantit en aucun cas que les informations qu'elle propose soient correctes. Les auteurs font le maximum, mais l'erreur est humaine. Cette F.A.Q. ne prétend pas non plus être complète. Si vous trouvez une erreur, ou que vous souhaitez devenir rédacteur, contactez pottiez

Nous espérons que cette F.A.Q. saura répondre à un maximum de vos questions. Nous vous souhaitons une bonne lecture.

L'équipe C++ Builder de Developpez.

Commentez cette FAQ : Commentez


SommaireSystèmeClavier et souris (7)
précédent sommaire suivant
 

Pour permettre à une fiche de récupérer les évènements du clavier se produisant dans l'un de ses contrôles enfants, vous devez positionner la propriété KeyPreview à true, la fiche recevra tous les évènements du clavier avant que les contrôles ne les reçoivent.

Vous pouvez définir cette propriété dans l'inspecteur d'objet ou à tout moment par le code suivant :

Code c++ : Sélectionner tout
KeyPreview = true;

Mis à jour le 1er septembre 2004 Geronimo

Prenons l'exemple de la surveillance de l'écriture dans un TEdit et intéressons nous à l'évènement OnKeyDown :

Code c++ : Sélectionner tout
void __fastcall Edit1KeyDown(TObject *Sender, WORD &Key, TShiftState Shift);
Nous allons utiliser la fonction GetKeyState qui permet non seulement de savoir si une touche est enfoncée, mais également de savoir si celle-ci est bloquée.
Pour cela, il faut examiner de plus près la valeur renvoyée par cette fonction : elle renvoie un SHORT. Le bit de poids le plus fort est à 1 si la touche est enfoncée et le bit de poids le plus faible est à 1 si la touche est verrouillée.
Le code suivant permet donc de tester le verrouillage ou non du NumLock :

Code c++ : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
void __fastcall TForm1::Edit1KeyDown(TObject *Sender, WORD &Key, TShiftState Shift) 
{ 
   if(Key == VK_NUMLOCK) 
   { 
      if((GetKeyState(VK_NUMLOCK) & 1) == 1) 
      { 
         ShowMessage("NumLock vient d'être verrouillé !"); 
      } 
   } 
}

Mis à jour le 1er septembre 2004 Geronimo Ricky81

Utilisez pour cela la fonction GetCursorPos qui initialise un objet avec les coordonnées actuelles du pointeur de la souris.
Pour cela, on lui passe en paramètre un pointeur sur une instance d'un objet de type TPoint, lequel type permet d'identifier un point de l'espace en deux dimensions par une abscisse et une ordonnée.

Code c++ : Sélectionner tout
1
2
3
4
5
TPoint *Position = new TPoint; 
GetCursorPos(Position); 
int x = Position->x; 
int y = Position->y; 
delete Position;

Mis à jour le 1er septembre 2004 Geronimo

Il suffit de déplacer la souris, faire croire à Windows que le bouton est appuyé, puis relâcher et remettre (ou pas) le curseur en place. Voici comment faire :

Code c++ : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
void __fastcall TForm1::Button1Click(TObject *Sender) 
{ 
   TPoint MyPoint; 
   // Récupère la position du curseur 
   GetCursorPos(&MyPoint); 
   // Positionne le curseur sur l'écran 
   SetCursorPos(200, 200); 
   // Simule l'action de clic du bouton gauche de la souris 
   mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0); 
   // Simule l'action de relâcher du bouton gauche de la souris 
   mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0); 
   // Repositionne le curseur à sa position d'origine 
   SetCursorPos(MyPoint.x, MyPoint.y); 
}
Il existe aussi les constantes :

  • MOUSEEVENTF_RIGHTDOWN et MOUSEEVENTF_RIGHTUP pour provoquer des clics droits
  • MOUSEEVENTF_MIDDLEDOWN et MOUSEEVENTF_MIDDLEUP pour provoquer un clic du bouton du milieu
  • MOUSEEVENTF_MOVE pour faire croire que la souris a bougé sans la faire bouger
  • MOUSEEVENTF_WHEEL pour faire croire que la molette a bougé (sans indication de sens)

Mis à jour le 31 janvier 2005 Al-Yazdi Ricky81

Il est possible de tester à tout moment l'état d'une touche du clavier ou d'un bouton de la souris grâce à la fonction API :

Code c++ : Sélectionner tout
short GetAsyncKeyState(int vKey)
Cette fonction retourne l'état de la touche, le bit 15 du résultat est à 1 si la touche (ou le bouton) est actuellement enfoncée. Le test fonctionne aussi même si l'application n'est pas active. Le numéro de touche passé en paramètre doit être le code de touche virtuelle. C++ Builder définit les constantes VK_xxxx pour chaque touche du clavier. A noter que pour les touches de type lettre, on peut également utiliser le code ASCII de la lettre majuscule, ou le charactère correspondant (ce qui revient au même).

Pour obtenir la liste des codes de touche virtuelle, recherchez dans l'aide de BCB la rubrique Codes de touche virtuelle

Par exemple pour tester l'état du bouton gauche de la souris :

Code c++ : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
void __fastcall TForm1::Timer1Timer(TObject *Sender) 
{ 
   if((GetAsyncKeyState(VK_LBUTTON) & 0x8000) != 0) 
   { 
      Label1->Caption = "Enfoncé"; 
   } 
   else 
   { 
      Label1->Caption = "Relâché"; 
   } 
}

Mis à jour le 31 janvier 2005 Nono40 Ricky81

Cette fonction repète une action tant que le bouton gauche de la souris reste enfoncé.
Attention : ne pas utiliser dans le code les variables X et Y qui sont les coordonnées de la souris.

Code c++ : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void __fastcall TForm1::Button1MouseDown(TObject *Sender, 
      TMouseButton Button, TShiftState Shift, int X, int Y) 
{ 
// dans la boucle ne pas utiliser X et Y qui sont les coordonnées de 
// la souris renvoyées par Button1MouseDown 
unsigned int time; 
int a = 0; // utiliser pour tester 
// on boucle tant que le bouton gauche de la souris est enfoncé 
while ((GetAsyncKeyState(VK_LBUTTON) & 0x8000) != 0) 
        { 
        a = a + 1; 
        Label1->Caption = a; 
        Application->ProcessMessages(); 
        time = GetTickCount(); 
        while (GetTickCount() < time + 150)  // 150 ms 
                { 
        // 150 ms temporisation utilisée pour un appui bref 
        // sinon le déplacement est de plusieurs pixels si le délai est trop court 
                } 
        } 
}

La boucle while ((GetAsyncKeyState(VK_LBUTTON) & 0x8000) != 0) répète l'action tant que le bouton gauche reste enfoncé, dès que celui-ci est relaché l'action cesse.
La boucle while (GetTickCount() < time + 150) assure une temporisation qui ralentit le test sur l'état du bouton afin de ne prendre en compte que l'incrément de 1 lors d'un appui bref.

Mis à jour le 10 décembre 2007 blondelle henderson pottiez

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2020 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.