Probleme de repetition lors de l'appuie sur un Button

Version imprimable

31/08/2007, 19h53
blondelle

Probleme de repetition lors de l'appuie sur un Button

Bonsoir.
J'ai une Form que je deplace pixel par pixel grace a l'appuie sur un Button, j'aimerais que le deplacement se realise tant que le Button reste appuye, les recherches que j'ai effectuees ne m'on pas permis de trouver une solution
31/08/2007, 20h00
rtg57

Bonsoir,

pourquoi ne pas lancer le déplacement en boucle, avec la mise à 1 d'un drapeau, et capter le message OnMouseUp qui éteindrait ce drapeau, ce qui aurait pour conséquence d'arrêter la boucle de déplacement ?
31/08/2007, 22h22
Crayon

Je suis d'accord avec toi rtg57! blondelle, si tu veux tu peux mettre ton code dans un thread avec une pause entre chaque déplacement.
05/09/2007, 21h45
blondelle

Je vous remercie pour vos reponses mais cela ne fonctionne pas si le programme entre dans une boucle apres appuis sur le bouton il n'y a plus detection du relachement de ce bouton, je n'ai toujours rien trouve :?
05/09/2007, 22h01
Sunchaser

Bonsoir,

J'ai essayé un hook sur les messages de la souris.
(dans une .dll)
L'idée étant de capter les clicks de souris, de vérifier si il s'agit d'un click sur le bouton gauche, si oui de balancer un message a l'application.
Dans l'application, lorsque le message est capté: on vérifie si le bouton gauche est toujours enfoncé, et si a souris est 'au dessus' du bouton.
Et alors, on fait qqchose ... déplacer un objet dans ton cas.

Bon, ben, tout cela était bien beau sauf que lorsque je clique sur le bouton j'obtiens un méga freeeezze de l'appli.
On dirait que j'ai foiré qqchose ... :mrgreen:
05/09/2007, 22h09
blondelle

Alors on est deux a avoir le probleme, mon idee c'est que l'on ne detecte pas le bon message de Window mais je ne vois pas lequel, un message du bouton ou de la souris ou les deux ?, a moins que l'on utilise pas la bonne methode de lecture des messages :?
05/09/2007, 22h18
Sunchaser

A mon sens, et a ce que j'ai testé, (ce qui ne veut pas dire que j'ai forcement raison) le message capté est le bon mais la facon dont on le traite provoque l'erreur.
Un brin de mémoire lointaine me rappelle avoir vu qqpart sur le net un soucis évoqué avec ce genre de Hooks, mais quoi précisement ... je ne sais plus et de plus j'ai pommé tout mes marques-pages sur mon 'vieux' PC.
(je suis fou de rage :evilred:)

Bon courage blondelle, je continuerais a chercher aussi de mon côté
;)
05/09/2007, 22h45
blondelle

J'ai peut etre trouve quelque chose dans les trucs et astuces
Le titre " Déplacement d'une fenêtre sans barre de titre : "
Le lien

Citation:

http://chgi.developpez.com/tips2/

Je testerais cela demain apres une bonne nuit et un sommeil reparateur :P

Bonsoir,

Revoici le Sunchaser nocture ....

Bon, ben, j'ai fini par craquer pour l'idée du Timer, sauf que celui est dans la dll.
Je ne sais pas si on peut capter si le bouton d'une souris est toujours pressé a un instant 'T', un peu a la manière de GetKeyState et autres pour le clavier ... donc...

.DLL

Code:

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
 
//---------------------------------------------------------------------------
 
#include <vcl.h>
#include <windows.h>
#include <stdio.h>
 
 
#pragma hdrstop
//---------------------------------------------------------------------------
 
//---------------------------------------------------------------------------
//struct pour le hook
typedef struct _TDataHook
{
	 HHOOK MouseHookHandle; // Handle du hook souris
	 HWND hDestWindow;    // Handle de la fenêtre
} TDataHook;
 
//variables pour le hook
HANDLE MemPartagee;      // Handle de la zone de mémoire partagée
TDataHook * VueDonnees; // Pointeur vers la zone de mémoire
HINSTANCE HInst;       // Handle d'intance de la DLL
DWORD ThId;           //  Recupération de l'ID du thread 'appellant'
bool Decal;
HWND ahwnd;
// Déclaration des fonctions de la DLL
LRESULT CALLBACK MouseProc(int nCode,WPARAM wParam,LPARAM lParam);
INT CALLBACK ATimerProc();
 
//fonction a appeller depuis les fiches
extern "C" __declspec(dllexport) __stdcall int InitHookMH(HWND hDest);
extern "C" __declspec(dllexport) __stdcall int EndHookMH();
 
#pragma argsused
int WINAPI DllEntryPoint(HINSTANCE hinst, unsigned long reason, void* lpReserved)
{
     HInst = hinst;
     switch (reason)
     {
          case DLL_PROCESS_ATTACH : // à la création de l'instance de la DLL
		  // Attachement d'une zone de mémoire partagée (notez le cast)
			   MemPartagee = CreateFileMapping((HANDLE)0xFFFFFFFF, // On map un espace mémoire
                                        NULL, // Pas d'informations de sécurité
										PAGE_READWRITE, // Partage en lecture/écriture
										0, // Taille de la zone réservée sur 64 bits (32 bits de poid fort)
										sizeof(TDataHook), // 32 bits de poids faible
										"HookMouseHelp"); // Nom de la zone réservée
 
               // Création d'une vue pour pouvoir accéder à la zone de mémoire partagée (notez le cast)
			   VueDonnees = (TDataHook *)(MapViewOfFile((HANDLE)MemPartagee, // Zone sur laquelle créer la vue
                                        FILE_MAP_WRITE, // Mode d'accès en lecture/écriture
                                        0, 0, // Offset de début de la vue sur 64 bits
										0)); // Taille de la vue (0 = tout)
		  break;
		  case DLL_PROCESS_DETACH :
			   UnmapViewOfFile((LPVOID)VueDonnees);
			   CloseHandle(MemPartagee);
		  break;
		  default :
		  break;
	 }
 
	return 1;
}
//---------------------------------------------------------------------------
int __stdcall InitHookMH(HWND hDest)
{
int Result;
try
{
ThId = GetCurrentThreadId();
	 VueDonnees->MouseHookHandle = SetWindowsHookEx(WH_MOUSE,
											 (HOOKPROC)MouseProc,
											  NULL,
											  ThId);
	 VueDonnees->hDestWindow = hDest;
	 SetTimer(hDest, 1, 5, ATimerProc);
	 ahwnd = hDest;
	 Result = 0;
}
catch(...)
{
	Result = 1;
}
return Result;
}
//---------------------------------------------------------------------------
int __stdcall EndHookMH()
{
	KillTimer(ahwnd, 1);
	UnhookWindowsHookEx(VueDonnees->MouseHookHandle);
return 0;
}
//---------------------------------------------------------------------------
#define WMAP_SENDSMSGMH WM_APP + 3
LRESULT CALLBACK MouseProc(int nCode, WPARAM wParam, LPARAM lParam)
{
if (nCode == HC_ACTION)
{
	if (wParam == WM_LBUTTONDOWN)
	{
		PostMessage(VueDonnees->hDestWindow, WMAP_SENDSMSGMH, MK_LBUTTON, lParam);
		Decal = true;
	}
	else
	{
		Decal = false;
    }
}
return CallNextHookEx(VueDonnees->MouseHookHandle, nCode, wParam, lParam);
}
//----------------------------------------------------------------------------
INT CALLBACK ATimerProc()
{
int Result;
try
{
	if (Decal == true)
	{
		PostMessage(VueDonnees->hDestWindow, WMAP_SENDSMSGMH, MK_LBUTTON, 0);
	}
	Result = 0;
}
catch(...)
{
	Result = 1;
}
return Result;
}
//----------------------------------------------------------------------------

. h de la TForm

Code:

1
2
3
4
5
6
7
8
9
10
11
 
//En amont de la déclaration de la TForm:
#define WMAP_SENDSMSGMH WM_APP + 3
 
private:
 
void __fastcall RecepMH(TMessage &msg);
 
BEGIN_MESSAGE_MAP
     MESSAGE_HANDLER(WMAP_SENDSMSGMH, TMessage, RecepMH)
END_MESSAGE_MAP(TForm)

.cpp de la TForm

Code:

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
 
//{$R WinXP.res}
TForm2 *Form2;
//
extern "C" __declspec(dllimport) __stdcall int InitHookMH(HWND hDest);
extern "C" __declspec(dllimport) __stdcall int EndHookMH();
 
//---------------------------------------------------------------------------
void __fastcall TForm2::FormActivate(TObject *Sender)
{
InitHookMH(Handle);
}
//---------------------------------------------------------------------------
void __fastcall TForm2::RecepMH(TMessage &msg)
{
	if ( (msg.WParam == MK_LBUTTON) && WindowFromPoint(Mouse->CursorPos) == Button35->Handle )
	{
		SPBT->Left ++;  //SPBT est le nom de l'objet a déplacer
	}
DefaultHandler(&msg);
}
//---------------------------------------------------------------------------
void __fastcall TForm2::FormDeactivate(TObject *Sender)
{
EndHookMH();
}
//---------------------------------------------------------------------------

Bon, il est tard, donc il se peut que je rate un truc dans le code mais cela a l'air de fonctionner.
Tout ceci est donc très certainement perfectible (largement même).

@+ ;)

J'ai trouve une solution simple pour boucler sur une fonction temps que le bouton gauche de la souris est enfonce.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 void __fastcall TForm1::Button1MouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y) { int a = 0; // utiliser pour tester // on boucle temps que le bouton gauche de la souris est enfonce while ((GetAsyncKeyState(VK_LBUTTON) & 0x8000) != 0) { a = a + 1; Label1->Caption = a; Sleep(150); // temporisation utilise pour un appui bref } }
Il suffit juste de tester l'etat du bouton dans la boucle, la temporisation sert juste pour un appui bref afin d'avoir un deplacement d'un seul pixel sinon le programme boucle trop vite

Bonjour,

j'ai repri le code de Blondelle, et j'ai ajouter une autre instruction :

Code:

1
2
3
4
5
6
7
8
9
 
int a = 0; 
while ((GetAsyncKeyState(VK_LBUTTON) & 0x8000) != 0)
        {
                a = a + 1;
                Label1->Caption = a;
                Application -> ProcessMessages() ;
                Sleep(50); 
        }

Merci Blondelle.

09/09/2007, 10h32
blondelle

Salut kmaniche:
Ta modification a apporte une amelioration au code, par contre j'ai du laisser le " Sleep a 150 " (mon micro est equipe d'un AMD 64 3000+), sinon je n'ai jamais le chiffre 1.
Apparament cette temporisation est dependante de la vitesse du microprosseur, ce point meriterait d'etre ameliore pour rendre le code portable sur n'importe quelle micro :P

Bonjour,

pour une temporisation indépendante de la machine, il y a GetTickCount() qui donne le temps écoulé depuis le démarrage en millisecondes.

Ex:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 int tempo; Bla bla le code... tempo = GetTickCount(); Bla... bla exécution de mon code soumis à temporisation... do { Application->ProcessMessages(); } while( GetTickCount() - tempo < 15 )
Ce système a l'avantage de garantir une tempo de 15 ms.
Si le code met plus de temps, la boucle de temporisation n'a pas lieu.
A l'avenir, avec la montée en puissance des machines, la boucle sera toujours à 15 ms.

Salut !

J'ai utilisé un panel (Panel1) au lieu d'un bouton.
Ici, c'est la fenêtre du bouton qui se déplace.
C'est pour aller dans le sens de la proposition de rtg57

Code:

1
2
 
bool Flag = false;

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
void __fastcall TForm1::Panel1MouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
//Rem : Panel1->BevelWidth = 2 (par exemple...)
 
Panel1->BevelOuter = bvLowered;
Flag = true;
int start = GetTickCount();
int time;
int interval;
while(Flag)
    {
    time = GetTickCount();
    interval = time - start;
    if(interval > 10) //10 ms ... donc à tester 
        {
        start = time;
        SetBounds(Left + 1, Top + 1, Width, Height);
        }
    Application->ProcessMessages();
    }
}

Code:

1
2
3
4
5
6
7
 
void __fastcall TForm1::Panel1MouseUp(TObject *Sender, TMouseButton Button,
      TShiftState Shift, int X, int Y)
{
Panel1->BevelOuter = bvRaised;
Flag = false;
}

C'est une solution comme une autre !

A plus !

09/09/2007, 16h25
ero-sennin

Bonjour,

Je suivais ce post de près, et je viens de tester la solution d'Henderson !
Ca fonctionne très bien!

Je mets celà de coté ;)

Merci rtg57 merci henderson:
J'ai adapte a mes besoins la fonction GetTickCount(), elle me permet de recuperer la valeur 1 lors d'un appui bref et un d'avoir un deplacement pas trop rapide.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
void __fastcall TForm1::Button1MouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
unsigned int time;
int a = 0; // utiliser pour tester
// on boucle temps que le bouton gauche de la souris est enfonce
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 utilise pour un appui bref
                }
        }
}

henderson ton code est parfait si l'on veut avoir un bouton personalise.
En tout cas cette fonction est une belle reussite collective. :king:

Voici un bout du programme utilisant la repetition sur un bouton de souris enfonce, ce code ajuste un viseur dans une Form transparante.
Le .cpp

Code:

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
 
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
Form1->Color = clWhite;
Form1->BorderStyle = bsDialog;
Form1->TransparentColor = true;
Form1->TransparentColorValue = clWhite;
Form1->Visible = false;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1MouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
unsigned int time;
// on boucle temps que le bouton gauche de la souris est enfonce
while ((GetAsyncKeyState(VK_LBUTTON) & 0x8000) != 0)
        {
  aX = aX + 1;
// on efface avant de tracer
  Canvas->Pen->Color = clWhite;
  Canvas->Pen->Width = 5;
// ligne horizontale gauche
  Canvas->MoveTo(171 + aX, 262);
  Canvas->LineTo(271 + aX, 262);
// ligne horizontale droite
  Canvas->MoveTo(371 - aX, 262);
  Canvas->LineTo(471 - aX, 262);
// ligne verticale haute
  Canvas->MoveTo(322, 112 + aX);
  Canvas->LineTo(322, 212 + aX);
// ligne verticale basse
  Canvas->MoveTo(322, 312 - aX);
  Canvas->LineTo(322, 412 - aX);
  Canvas->Pen->Width = 5;
// on affiche les petits enbouts
// bout gauche
  Canvas->MoveTo(271 + aX, 252);
  Canvas->LineTo(271 + aX, 272);
// bout droit
  Canvas->MoveTo(371 - aX, 252);
  Canvas->LineTo(371 - aX, 272);
// bout haut
  Canvas->MoveTo(312, 212 + aX);
  Canvas->LineTo(332, 212 + aX);
// bout bas
  Canvas->MoveTo(312, 312 - aX);
  Canvas->LineTo(332, 312 - aX);
// on trace
// parametres du trait
  Canvas->Pen->Color = clBlack;
  Canvas->Pen->Width = 1;
// on affiche la croix
// ligne horizontale gauche
  Canvas->MoveTo(171 + aX, 262);
  Canvas->LineTo(271 + aX, 262);
// ligne horizontale droite
  Canvas->MoveTo(371 - aX, 262);
  Canvas->LineTo(471 - aX, 262);
// ligne verticale haute
  Canvas->MoveTo(322, 112 + aX);
  Canvas->LineTo(322, 212 + aX);
// ligne verticale basse
  Canvas->MoveTo(322, 312 - aX);
  Canvas->LineTo(322, 412 - aX);
  Canvas->Pen->Width = 1;
// on affiche les petits enbouts
// bout gauche
  Canvas->MoveTo(271 + aX, 252);
  Canvas->LineTo(271 + aX, 272);
// bout droit
  Canvas->MoveTo(371 - aX, 252);
  Canvas->LineTo(371 - aX, 272);
// bout haut
  Canvas->MoveTo(312, 212 + aX);
  Canvas->LineTo(332, 212 + aX);
// bout bas
  Canvas->MoveTo(312, 312 - aX);
  Canvas->LineTo(332, 312 - aX);
  Application->ProcessMessages();
  time = GetTickCount();
        while (GetTickCount() <= time + 150) // 150 ms
                {
        // 150 ms temporisation utilise pour un appui bref
                }
        }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2MouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
unsigned int time;
// on boucle temps que le bouton gauche de la souris est enfonce
while ((GetAsyncKeyState(VK_LBUTTON) & 0x8000) != 0)
        {
  aX = aX - 1;
  Canvas->Pen->Color = clWhite;
  Canvas->Pen->Width = 5;
// ligne horizontale gauche
  Canvas->MoveTo(171 + aX, 262);
  Canvas->LineTo(271 + aX, 262);
// ligne horizontale droite
  Canvas->MoveTo(371 - aX, 262);
  Canvas->LineTo(471 - aX, 262);
// ligne verticale haute
  Canvas->MoveTo(322, 112 + aX);
  Canvas->LineTo(322, 212 + aX);
// ligne verticale basse
  Canvas->MoveTo(322, 312 - aX);
  Canvas->LineTo(322, 412 - aX);
  Canvas->Pen->Width = 5;
// on affiche les petits enbouts
// bout gauche
  Canvas->MoveTo(271 + aX, 252);
  Canvas->LineTo(271 + aX, 272);
// bout droit
  Canvas->MoveTo(371 - aX, 252);
  Canvas->LineTo(371 - aX, 272);
// bout haut
  Canvas->MoveTo(312, 212 + aX);
  Canvas->LineTo(332, 212 + aX);
// bout bas
  Canvas->MoveTo(312, 312 - aX);
  Canvas->LineTo(332, 312 - aX);
// on trace
// parametres du trait
  Canvas->Pen->Color = clBlack;
  Canvas->Pen->Width = 1;
// on affiche la croix
// ligne horizontale gauche
  Canvas->MoveTo(171 + aX, 262);
  Canvas->LineTo(271 + aX, 262);
// ligne horizontale droite
  Canvas->MoveTo(371 - aX, 262);
  Canvas->LineTo(471 - aX, 262);
// ligne verticale haute
  Canvas->MoveTo(322, 112 + aX);
  Canvas->LineTo(322, 212 + aX);
// ligne verticale basse
  Canvas->MoveTo(322, 312 - aX);
  Canvas->LineTo(322, 412 - aX);
  Canvas->Pen->Width = 1;
// on affiche les petits enbouts
// bout gauche
  Canvas->MoveTo(271 + aX, 252);
  Canvas->LineTo(271 + aX, 272);
// bout droit
  Canvas->MoveTo(371 - aX, 252);
  Canvas->LineTo(371 - aX, 272);
// bout haut
  Canvas->MoveTo(312, 212 + aX);
  Canvas->LineTo(332, 212 + aX);
// bout bas
  Canvas->MoveTo(312, 312 - aX);
  Canvas->LineTo(332, 312 - aX);
  Application->ProcessMessages();
  time = GetTickCount();
        while (GetTickCount() <= time + 150) // 150 ms
                {
        // 150 ms temporisation utilise pour un appui bref
                }
        }
}
//---------------------------------------------------------------------------

Le .h

Code:

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
 
//---------------------------------------------------------------------------
#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published: // IDE-managed Components
        TButton *Button1;
        TButton *Button2;
        TLabel *Label1;
        void __fastcall Button1MouseDown(TObject *Sender,
          TMouseButton Button, TShiftState Shift, int X, int Y);
        void __fastcall Button2MouseDown(TObject *Sender,
          TMouseButton Button, TShiftState Shift, int X, int Y);
private: // User declarations
public:  // User declarations
        __fastcall TForm1(TComponent* Owner);
int aX;
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

La Form a une Largeur de 643, et une Hauteur de 523