Comment mettre un TEdit dans un PopupMenu

Version imprimable

Voir 40 message(s) de cette discussion en une page

05/02/2007, 17h11
bandit boy

Comment mettre un TEdit dans un PopupMenu

Tout est dans le titre, j'aimerais donner la possibilité à l'utilisateur de saisir un texte dans un PopupMenu.

J'ai tenté de modifier la propriété Parent d'un TEdit, mais le TPopupMenu et le TMenuItem ne sont pas des composants permettant de contenir d'autres composants.

Est ce que quelqun connait un moyen de contourner ce problème ou d'obtenir une zone de saisie dans un pop up.

Merci
05/02/2007, 19h39
kmaniche

Bonsoir,

j'avais tenté la même chôse un jour, mais pas avec un TPopUpMenu, j'ai dû construir un nouveau composant.

J'ai créé un nouvelle form, j'ai ajouter des TLabels et j'ai fais ceci.

Citation:

Envoyé par bandit boy

Est ce que quelqun connait un moyen de contourner ce problème ou d'obtenir une zone de saisie dans un pop up.

Bonsoir,

J'ai essayé, pour 'jouer', de contourner avec un Hook afin de capter la saisie de l'utilisateur tout en gardant le PopupMenu 'deroulé' ... ce n'est pas encore tout a fait au point :?
La saisie s'affiche dans le caption du PopupMenu mais a chaque lettre saisie, il me quadruple (au moins) le caractère saisi.
De plus, il faudrait stopper le Hook clavier dès que le Popup est fermé, ce qui n'est pas encore le cas la.
Je poste tout de même le code, même si c'est loin d'être parfait. Ca permettra peut être d'avancer ...
. côté hook:

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
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
 
//---------------------------------------------------------------------------
 
#include <vcl.h>
#include <windows.h>
#pragma hdrstop
//---------------------------------------------------------------------------
 
//---------------------------------------------------------------------------
//struct pour le hook
typedef struct _TDataHook
{
	 HHOOK KeyHookHandle;   // Handle du hook clavier
	 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'
 
// Déclaration des fonctions de la DLL
LRESULT CALLBACK KeyboardProc(int nCode,WPARAM wParam,LPARAM lParam);
 
//fonction a appeller depuis les fiches
extern "C" __declspec(dllexport) __stdcall int InitHook(HWND hDest, TPopupMenu* aMenu);
extern "C" __declspec(dllexport) __stdcall int EndHook();
 
//var
TPopupMenu* baseMenu;
String nCaption;
int PosX, PosY;
 
#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
										"HookPopup"); // 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;
}
//---------------------------------------------------------------------------
LRESULT CALLBACK KeyboardProc(int nCode,WPARAM wParam,LPARAM lParam)
{
String S;
	switch (wParam)
	{
	case VK_ESCAPE:
 
	break;
	case VK_RETURN:
		//baseMenu->Popup(PosX, PosY);
		//baseMenu->Items->Items[0]->Caption = nCaption;
	break;
	default:
		switch (wParam)
		{
		case 'A':
			S = "a";
		break;
		case 'B':
			S = "b";
		break;
		case 'C':
			S = "c";
		break;
		case 'D':
			S = "d";
		break;
		case 'E':
			S = "e";
		break;
		case 'F':
			S = "f";
		break;
		case 'G':
			S = "g";
		break;
		case 'H':
			S = "h";
		break;
		case 'I':
			S = "i";
		break;
		case 'J':
			S = "j";
		break;
		case 'K':
			S = "k";
		break;
		case 'L':
			S = "l";
		break;
		case 'M':
			S = "m";
		break;
		case 'N':
			S = "n";
		break;
		case 'O':
			S = "o";
		break;
		case 'P':
			S = "p";
		break;
		case 'Q':
			S = "q";
		break;
		case 'R':
			S = "r";
		break;
		case 'S':
			S = "s";
		break;
		case 'T':
			S = "t";
		break;
		case 'U':
			S = "u";
		break;
		case 'V':
			S = "v";
		break;
		case 'W':
			S = "w";
		break;
		case 'X':
			S = "x";
		break;
		case 'Y':
			S = "y";
		break;
		case 'Z':
			S = "z";
		break;
		default:
			;
		}
		if (nCaption != NULL)
		{
			nCaption = nCaption + S;
		}
		else
		{
			nCaption = S;
		}
		baseMenu->Items->Items[0]->Caption = nCaption;
	break;
	}
return CallNextHookEx(VueDonnees->KeyHookHandle,nCode,wParam,lParam);
}
//---------------------------------------------------------------------------
int __stdcall InitHook(HWND hDest, TPopupMenu* aMenu)
{
int Result;
try
{
baseMenu = aMenu;
PosX = baseMenu->PopupPoint.x;
PosY = baseMenu->PopupPoint.y;
 
ThId = GetCurrentThreadId();
	 VueDonnees->KeyHookHandle = SetWindowsHookEx(WH_KEYBOARD,
											 (HOOKPROC)KeyboardProc,
												 NULL,
											 ThId);
	 VueDonnees->hDestWindow = hDest;
	 Result = 0;
}
catch(...)
{
	Result = 1;
}
return Result;
}
//---------------------------------------------------------------------------
int __stdcall EndHook()
{
	nCaption = "";
	UnhookWindowsHookEx(VueDonnees->KeyHookHandle);
return 0;
}
//---------------------------------------------------------------------------

.côté fiche:

Code:

1
2
3
 
extern "C" __declspec(dllimport) __stdcall int InitHook(HWND hDest, TPopupMenu* aMenu);
extern "C" __declspec(dllimport) __stdcall int EndHook();

Code:

1
2
3
4
5
6
7
8
9
10
11
 
void __fastcall TForm2::PopupMenuPopup(TObject *Sender)
{
InitHook(Form2->Handle, Form2->PopupMenu);
}
//---------------------------------------------------------------------------
 
void __fastcall TForm2::FormClose(TObject *Sender, TCloseAction &Action)
{
EndHook();	
}

Pour l'aspect 'extérieur' du TMenuItem, on peut imaginer travailler dans le OnDrawItem de l'élément (avec, pourquoi pas DrawEdge(...)).
Je verrais ça plus tard,

En espérant t'aider,
@+;)

06/02/2007, 09h13
bandit boy

Bonjour et merci à tous les deux. J'ai testé vos solutions.

Pour la solution de kmaniche c'est une idée de détourner le problème qui est sympa mais par contre, elle nécessite pas mal de travail pour retrouver la convivialité d'un vrai Popup avec les items en surbrillance et les sous-menu, mais l'idée est bonne.

Pour la solution de Sunchaser, j'ai des problèmes d'exceptions générés lors de l'exécution et la pose du try/catch ne me permet pas de voir le fonctionnement en pas à pas. En fait, lorsque je clic droit sur ma Form2, mon Popup apparaît mais dès que je saisie une lettre, j'ai une exception et le systême se bloque. L'idée me permetterai de garder le Popup et avec un peu de mise en forme ferait croire à un TEdit.

Les deux idées sont à développez, par contre je ne voit pas où le hook génère l'erreur, si tu as une idée Sunchaser.
06/02/2007, 14h41
Sunchaser

Salut,

Non, a priori, je ne sais pas cela peut bloquer.
Néanmoins, vu que j'ai fait tourner chez moi, je n'ai pas d'erreur ...
Je ne pourrais regarder sereinement que chez moi ce soir, désolé.
(puisque je n'ai pas la joie de pouvoir m'occuper de programmation durant mon activité salariée ...)

@ + ;)
06/02/2007, 23h54
Sunchaser

Bonsoir,

J'ai fait qq changements, le 'truc' est plus stable en quelquesorte.
Le problème est que, en travaillant sur la valeur retournée par LRESULT CALLBACK KeyboardProc, j'ai un réduit le 'bug' lors de la saisie ... mais pas totalement : les lettres sont doublées.
:koi:

Surement mon manque de connaissances théoriques, qui me fait passer a côté de quelquechose.
Encore un p'tit effort a faire quoi.

@ + ;)
07/02/2007, 08h48
bandit boy

J'ai mis le code du hook dans mon .cpp, la déclaration dans le .h et déclaré les évènements comme il faut pour lancer le InitHook, mais j'ai une erreur lorsque j'appuie sur une touche.

Lorsque je fais clic droit, le popup apparaît bien avec mes Items, mais quand j'appuie sur une touche, le popup affiché, j'ai une exception "Lecture à l'adresse 0".
07/02/2007, 12h38
Sunchaser
Bonjour,

J'avais placé le hook dans un .dll (pur hasard en fait, car j'ai repris un projet que j'avais) et dans ce cas, il semble qu'il y ait une différence sur l'appel d'une fonction, par rapport a ce que j'avais trouvé sur le tuto des hooks; néanmoins pas sur que cela provienne de la ...
->
J'avais rajouté un paramètre au lancement du hook:
Code:

1 2 3 ThId = GetCurrentThreadId(); VueDonnees->KeyHookHandle = SetWindowsHookEx(WH_KEYBOARD,(HOOKPROC)KeyboardProc,NULL,ThId);
alors que selon le tuto, il aurait suffit de:
Code:

1 2 VueDonnees->KeyHookHandle = SetWindowsHookEx(WH_KEYBOARD,(HOOKPROC)KeyboardProc,NULL,0);
J'espère pouvoir bosser plus la dessus ce soir,
a plus tard,
@ + ;)
08/02/2007, 08h37
bandit boy

Alors en fait y'a du mieux. Je n'ai plus d'erreur en lancant l'exe, plus d'exception. Par contre, je n'ai rien qui se passe lorsque j'appuie sur une touche, pas réaction 8O donc je vais creuser voir d'où ca peut venir.

Coucou, me revoilou ...

J'ai testé avec qq modifs, que je vais poster même si - malgré tout - je n'ai pas solutionné mon problème du doublon des caractères saisis (pour être plus clair, lorsque je tape 'a', le gentil code me renvoi 'AA' dans le caption de l'élément de menu).
.Pour le Hook:
(le code me semble un peu plus clean comme ça, tout de même)

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
 
#include <vcl.h>
#include <windows.h>
#pragma hdrstop
//---------------------------------------------------------------------------
 
//---------------------------------------------------------------------------
//struct pour le hook
typedef struct _TDataHook
{
	 HHOOK KeyHookHandle;   // Handle du hook clavier
	 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'
 
// Déclaration des fonctions de la DLL
LRESULT CALLBACK KeyboardProc(int nCode,WPARAM wParam,LPARAM lParam);
 
//fonction a appeller depuis les fiches
extern "C" __declspec(dllexport) __stdcall int InitHook(HWND hDest);
extern "C" __declspec(dllexport) __stdcall int EndHook();
 
#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
										"HookPopup"); // 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;
}
//---------------------------------------------------------------------------
#define WMAP_INITHOOKMSG WM_APP + 1
#define WMAP_SENDSMSG WM_APP + 2
LRESULT CALLBACK KeyboardProc(int nCode,WPARAM wParam,LPARAM lParam)
{
	switch (wParam)
	{
	case VK_ESCAPE:
	case VK_RETURN:
	PostMessage(VueDonnees->hDestWindow, WMAP_INITHOOKMSG, 0, 0);
	EndHook();
	break;
	default:
		PostMessage(VueDonnees->hDestWindow, WMAP_SENDSMSG, wParam, 0);
	   //	return 1;
	break;
	}
}
//---------------------------------------------------------------------------
int __stdcall InitHook(HWND hDest)
{
int Result;
try
{
ThId = GetCurrentThreadId();
	 VueDonnees->KeyHookHandle = SetWindowsHookEx(WH_KEYBOARD,
											 (HOOKPROC)KeyboardProc,
											  NULL,
											  ThId);
	 VueDonnees->hDestWindow = hDest;
	 PostMessage(VueDonnees->hDestWindow, WMAP_INITHOOKMSG, 0, 0);
	 Result = 0;
}
catch(...)
{
	Result = 1;
}
return Result;
}
//---------------------------------------------------------------------------
int __stdcall EndHook()
{
	UnhookWindowsHookEx(VueDonnees->KeyHookHandle);
return 0;
}
//---------------------------------------------------------------------------

(il est toujours dans une .dll, ce qui doit être une obscession chez moi ... dois je me faire psychanaliser d'après vous ?)
.Pour la fiche:
.h:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
//Avant la déclaration de la TForm:
#define WMAP_INITHOOKMSG WM_APP + 1
#define WMAP_SENDSMSG WM_APP + 2
 
//Puis en private:
void __fastcall DefHook(TWMNoParams &p);
void __fastcall RecepS(TMessage &msg);
 
 
BEGIN_MESSAGE_MAP				
MESSAGE_HANDLER(WMAP_INITHOOKMSG, TWMNoParams, DefHook)
MESSAGE_HANDLER(WMAP_SENDSMSG, TMessage, RecepS)
END_MESSAGE_MAP(TForm)
 
bool HookLance;

.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
 
//Déclaration des fonctions de la dll
extern "C" __declspec(dllimport) __stdcall int InitHook(HWND hDest);
extern "C" __declspec(dllimport) __stdcall int EndHook();
//
void __fastcall TForm2::PopupHookPopup(TObject *Sender)
{
if (HookLance != true) 
{
InitHook(Form2->Handle);
}
}
//---------------------------------------------------------------------------
 
void __fastcall TForm2::FormClose(TObject *Sender, TCloseAction &Action)
{
EndHook();
}
//---------------------------------------------------------------------------
void __fastcall TForm2::DefHook(TWMNoParams &p)
{
if (HookLance)
{
	HookLance = false;
}
else
{
	HookLance = true;
}
}
//---------------------------------------------------------------------------
void __fastcall TForm2::RecepS(TMessage &msg)
{
char c = static_cast<const char>(msg.WParam);
String S = PopupHook->Items->Items[0]->Caption.operator +(c) ;
PopupHook->Items->Items[0]->Caption = S;
}
//---------------------------------------------------------------------------

Dans ce cas, il me reste :
. a comprendre pourquoi les lettres sont doublées
. capter l'évènement lors que le PopupMenu se referme afin de lancer EndHook()...

@ +
;)

08/02/2007, 20h14
bandit boy

Je pars aussi en parallèle de ces deux solution sur la création d'un composant (voir le poste suivant), mais toutes ces solutions ont leurs avantages et inconvénients.

Toutefois, c'est très intéressant de toutes les développer.

Merci à tous.

Je teste ca dès que possible.

Bonsoir,

J'ai ajouter une petite chose dans le hook, afin d'intercepter la fermeture du popup et de lancer EndHook() ...ça donnerais ceci:

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
 
#include <vcl.h>
#include <windows.h>
#pragma hdrstop
//---------------------------------------------------------------------------
 
//---------------------------------------------------------------------------
//struct pour le hook
typedef struct _TDataHook
{
	 HHOOK KeyHookHandle;   // Handle du hook clavier
	 HHOOK CBTHookHandle;   // handle du hook CBT
	 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'
 
// Déclaration des fonctions de la DLL
LRESULT CALLBACK KeyboardProc(int nCode,WPARAM wParam,LPARAM lParam);
LRESULT CALLBACK CBTProc(int nCode,WPARAM wParam,LPARAM lParam);
//fonction a appeller depuis les fiches
extern "C" __declspec(dllexport) __stdcall int InitHook(HWND hDest);
extern "C" __declspec(dllexport) __stdcall int EndHook();
 
#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
										"HookPopup"); // 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;
}
//---------------------------------------------------------------------------
#define WMAP_INITHOOKMSG WM_APP + 1
#define WMAP_SENDSMSG WM_APP + 2
LRESULT CALLBACK KeyboardProc(int nCode,WPARAM wParam,LPARAM lParam)
{
	switch (wParam)
	{
	case VK_ESCAPE:
	case VK_RETURN:
	PostMessage(VueDonnees->hDestWindow, WMAP_INITHOOKMSG, 0, 0);
	EndHook();
	break;
	default:
		PostMessage(VueDonnees->hDestWindow, WMAP_SENDSMSG, wParam, 0);
	   //	return 1;
	break;
	}
}
//---------------------------------------------------------------------------
LRESULT CALLBACK CBTProc(int nCode,WPARAM wParam,LPARAM lParam)
{
	if (nCode == HCBT_DESTROYWND)
	{
		PostMessage(VueDonnees->hDestWindow, WMAP_INITHOOKMSG, 0, 0);
		EndHook();
	}
return CallNextHookEx(VueDonnees->CBTHookHandle, nCode, wParam, lParam);
}
//---------------------------------------------------------------------------
int __stdcall InitHook(HWND hDest)
{
int Result;
try
{
ThId = GetCurrentThreadId();
VueDonnees->KeyHookHandle = SetWindowsHookEx(WH_KEYBOARD,		(HOOKPROC)KeyboardProc,
NULL,
ThId);
VueDonnees->CBTHookHandle = SetWindowsHookEx(WH_CBT,				(HOOKPROC)CBTProc,
NULL,
ThId);
	 VueDonnees->hDestWindow = hDest;
	 PostMessage(VueDonnees->hDestWindow, WMAP_INITHOOKMSG, 0, 0);
	 Result = 0;
}
catch(...)
{
	Result = 1;
}
return Result;
}
//---------------------------------------------------------------------------
int __stdcall EndHook()
{
	UnhookWindowsHookEx(VueDonnees->KeyHookHandle);
	UnhookWindowsHookEx(VueDonnees->CBTHookHandle);
return 0;
}
//---------------------------------------------------------------------------

Et pour le dessin, on pourrais penser a:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
void __fastcall TForm2::Essaifrappe1AdvancedDrawItem(TObject *Sender,
	  TCanvas *ACanvas, TRect &ARect, TOwnerDrawState State)
{
DrawEdge(ACanvas->Handle, &ARect, EDGE_SUNKEN, BF_RECT	);
TRect pRect;
pRect.top = ARect.top + 4;
pRect.left = ARect.left;
pRect.bottom = ARect.bottom;
pRect.right = ARect.right;
DrawText(ACanvas->Handle, ((TMenuItem*)Sender)->Caption.c_str(), ((TMenuItem*)Sender)->Caption.Length(), &pRect, DT_CENTER | DT_VCENTER);
}
//---------------------------------------------------------------------------

dans le OnAdvancedDrawItem de l'objet, avec la propriété OwnerDraw a true.
(a améliorer et retravailler bien évidemment, au niveau 'esthétique').

Néanmoins ... dois-je l'avouer ... ben je n'ai pas encore reglé le problème du bégaiement de mon code :oops:

Et pis, ça, ça m'enerve ... :evilred:
J'ai toujours deux lettres quand j'en tape une !

Bon, comme on dis dans un jeu célèbre : je fais appel au vote du public.
Ceux qui savent, zavez le droit de m'aider ...:mrgreen:

@ + ;)

09/02/2007, 09h35
bandit boy

Il y a des choses que je ne piges pas dans ton code. Je l'ai copié/collé dans ma fiche, mais j'ai des erreurs sur des fonctions non déclarés ou des des objets non déclarés 8O .

PopupHookPopup() et PopupHook.

Et je dois avouer que du coup, j'ai plein de code dans tous les sens et j'ai du mal à m'y retrouver :oops: .
09/02/2007, 11h49
Sunchaser

Bonjour,

Effectivement ...PopupHook est le nom (peut être pas tres bien choisi) du TPopupMenu sur lequel je travaille.
Et vu que je travaille sur l'évènement OnPopup du TPopupMenu, on a donc une 'fonction' qui s'appelle :
PopupHookPopup

...
Il faut comprendre que je suis dans un projet incroyablement bordelique ( :mrgreen: , il faut le voir pour le croire), puisque c'est la ou je 'travaille' sur tout les sujets que je trouve sur dvp.
Un fourre-tout de code, d'essai divers et variés; et maintenant, avec le BDS, j'ai la même avec Delphi
Donc j'évite de laisser PopupMenu1 par exemple en nom d'objet.

@ + ;)
10/02/2007, 12h33
Sunchaser

Citation:

Envoyé par Sunchaser

J'ai toujours deux lettres quand j'en tape une !

Bonjour,

Ben, j'ai toujours pas résolu ce problème.
Le caractère récupéré est bien le bon, c.a.d que j'ai bien une lettre et une seule suite a la saisie au clavier.
Mais, c'est lors de l'ajout de ce caractère a la valeur du caption que la lettre est doublée !

J'ai vraimment essayé un paquet de truc (que je vais peut être pas poster ici tout de même), mais je suis surement passé a côté de l'essentiel (?).
:cfou:
Je sais plus trop quoi faire...

Quelqu'un pour me donner un petit cours ?

Merci d'avance,
@ + ;)
12/02/2007, 11h37
josse95

cf http://www.developpez.net/forums/sho...=1#post1750438
12/02/2007, 11h56
Sunchaser

Bonjour,
:D
Effectivement, tres heureux d'avoir une réponse sur ce sujet, je n'imaginais pas a priori qq chose comme cela ...
Je teste cela dès que possible.

Merci
@ + ;)
12/02/2007, 13h32
josse95

Une autre remarque, quand on installe un filtre clavier, on doit gérer soit même l'appui sur les touches SHIFT, ALT, CTRL, de manière par exemple, à retranscrire l'appui sur la touche '2' en '2, 'é' ou '~' selon les cas.
Tu peux mémoriser l'état enfoncé ou non de ces trois touches à chaque fois qu'elles sont sollicitées (dans ta fonction de hook) ou plus sûr, utiliser la fonction ::GetKeyState() de l'API Windows.
12/02/2007, 20h03
Sunchaser

Bonsoir,

Heu .... ben ça ne change rien, malheureusement.
(je parle de l'indication donnée dans mon post dans le forum developpement windows)
Je vais poser une question con (désolé, va falloir t'y habituer de ma part :mouarf: ) : comment devais je effectuer le test sur les messages WM_KEYDOWN et WM_SYSKEYDOWN dans la fonction LRESULT CALLBACK KeyboardProc ?
Parceque la, cela ne rajoute rien, mais je suis un peu 'bouché' des fois ...

Reste tout de même que je ré-insiste sur un point:
le char récupéré est bien le bon, et n'est pas doublé.

L'insertion dans un String ou AnsiString (pour une propriété Text ou Caption, par ex) semble doubler ce caractère par contre. 8O

@ + ;)

Salut bandit boy,

J'ai modifié deux ou trois choses du code que tu m'as envoyé, et ainsi on a plus de message d'erreur ... juste la magnifique plantade du caractère doublé!
Pour la Form2 donc:
.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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
//---------------------------------------------------------------------------
 
#ifndef Unit2H
#define Unit2H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <Menus.hpp>
//---------------------------------------------------------------------------
#define WMAP_INITHOOKMSG WM_APP + 1
#define WMAP_SENDSMSG WM_APP + 2
 
class TForm2 : public TForm
{
__published:	// IDE-managed Components
	TPopupMenu *PopupHook;
        TMenuItem *N11;
        TMenuItem *N21;
        TMenuItem *N31;
        void __fastcall PopupHookPopup(TObject *Sender);
        void __fastcall FormClose(TObject *Sender, TCloseAction &Action);
private:	// User declarations
        void __fastcall DefHook(TWMNoParams &p);
		void __fastcall RecepS(TMessage &msg);
// Déclaration des fonctions de la DLL
	   BEGIN_MESSAGE_MAP
		 MESSAGE_HANDLER(WMAP_INITHOOKMSG, TWMNoParams, DefHook)
		 MESSAGE_HANDLER(WMAP_SENDSMSG, TMessage, RecepS)
	   END_MESSAGE_MAP(TForm)
 
bool HookLance;
 
public:		// User declarations
		__fastcall TForm2(TComponent* Owner);
 
 
 
};
//---------------------------------------------------------------------------
extern PACKAGE TForm2 *Form2;
//---------------------------------------------------------------------------
#endif

.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
 
//---------------------------------------------------------------------------
 
#include <vcl.h>
#pragma hdrstop
 
#include "Unit2.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
//struct pour le hook
typedef struct _TDataHook
{
	 HHOOK KeyHookHandle;   // Handle du hook clavier
	 HHOOK CBTHookHandle;   // handle du hook CBT
	 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'
 
// Déclaration des fonctions de la DLL
LRESULT CALLBACK KeyboardProc(int nCode,WPARAM wParam,LPARAM lParam);
LRESULT CALLBACK CBTProc(int nCode,WPARAM wParam,LPARAM lParam);
		int __stdcall InitHook(HWND hDest);
		int __stdcall EndHook();
 
#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
										"HookPopup"); // 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;
}
//---------------------------------------------------------------------------
LRESULT CALLBACK KeyboardProc(int nCode,WPARAM wParam,LPARAM lParam)
{
	switch (wParam)
	{
	case VK_ESCAPE:
	case VK_RETURN:
	PostMessage(VueDonnees->hDestWindow, WMAP_INITHOOKMSG, 0, 0);
	EndHook();
	break;
	default:
		PostMessage(VueDonnees->hDestWindow, WMAP_SENDSMSG, wParam, 0);
	break;
	}
}
//---------------------------------------------------------------------------
LRESULT CALLBACK CBTProc(int nCode,WPARAM wParam,LPARAM lParam)
{
	if (nCode == HCBT_DESTROYWND)
	{
		PostMessage(VueDonnees->hDestWindow, WMAP_INITHOOKMSG, 0, 0);
		EndHook();
	}
return CallNextHookEx(VueDonnees->CBTHookHandle, nCode, wParam, lParam);
}
//---------------------------------------------------------------------------
int __stdcall InitHook(HWND hDest)
{
if (VueDonnees == NULL)
{
VueDonnees = new _TDataHook();
}
int Result;
try
{
ThId = GetCurrentThreadId();
VueDonnees->KeyHookHandle = SetWindowsHookEx(WH_KEYBOARD,(HOOKPROC)KeyboardProc,
NULL, ThId);
VueDonnees->CBTHookHandle = SetWindowsHookEx(WH_CBT,(HOOKPROC)CBTProc,
NULL, ThId);
	 VueDonnees->hDestWindow = hDest;
	 PostMessage(VueDonnees->hDestWindow, WMAP_INITHOOKMSG, 0, 0);
	 Result = 0;
}
catch(...)
{
	Result = 1;
}
return Result;
}
//---------------------------------------------------------------------------
int __stdcall EndHook()
{
	UnhookWindowsHookEx(VueDonnees->KeyHookHandle);
	UnhookWindowsHookEx(VueDonnees->CBTHookHandle);
return 0;
}
//---------------------------------------------------------------------------
 
TForm2 *Form2;
//---------------------------------------------------------------------------
__fastcall TForm2::TForm2(TComponent* Owner)
		: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm2::FormClose(TObject *Sender, TCloseAction &Action)
{
EndHook();
}
//---------------------------------------------------------------------------
void __fastcall TForm2::DefHook(TWMNoParams &p)
{
if (HookLance)
{
	HookLance = false;
}
else
{
	HookLance = true;
}
}
//---------------------------------------------------------------------------
void __fastcall TForm2::RecepS(TMessage &msg)
{
char c = static_cast<const char>(msg.WParam);
String S = PopupHook->Items->Items[0]->Caption.operator +(c) ;
PopupHook->Items->Items[0]->Caption = S;
}
//---------------------------------------------------------------------------
 
void __fastcall TForm2::PopupHookPopup(TObject *Sender)
{
if (HookLance != true)
{
InitHook(Form2->Handle);
}
}
//---------------------------------------------------------------------------

Important : j'ai renommé le PopupMenu.
Ce n'est donc plus Popupmenu1 mais PopupHook ...

@ + ;)

Voir 40 message(s) de cette discussion en une page