Comment mettre un TEdit dans un PopupMenu [Sources]

**Sunchaser** · 16/04/2007, 18h49

Bonjour,

Oui effectivement, merci bandit boy, j'ai déja honteusement plagié cette idée dans ton code pour le déplacement ...
Reste que j'ai toujours du mal a positionner le curseur, en tout cas dans la situation dans laquelle je me trouve; ça serait plus clair si je postais je code ... je sais.
Mais la ça ressemble a un champs de bataille, alors je vais attendre d'avoir fait un peu le ménage

@ +

**Sunchaser** · 18/04/2007, 00h51

Envoyé par pottiez

T'es le roi Sunchaser

Bonsoir,
Merci bien pottiez ... c'est trop gentil ...

mais je crois qu'en ce moment je suis plutôt le roi des galériens : impossible de positionner le 'caret maison' tout a fait correctement.
En plus de ça, la méthode que j'ai adopté me provoque un scintillement plus ou moins prononcé.

Je croyais pouvoir régler cela d'ailleurs.
J'ai la désagréable sensation d'être tout proche du résultat cherché, sans jamais pouvoir l'obtenir.
Un bout de code malgré tout :
La Fiche
.h:

Code :

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
//---------------------------------------------------------------------------
 
#ifndef UnitMFormH
#define UnitMFormH
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <Menus.hpp>
#include <ComCtrls.hpp>
#include <ExtCtrls.hpp>
//---------------------------------------------------------------------------
#define WMAP_INITHOOKMSG WM_APP + 1
#define WMAP_SENDSMSG WM_APP + 2
//---------------------------------------------------------------------------
class TMForm : public TForm
{
__published:	// Composants gérés par l'EDI
	TPopupMenu *PopupHook;
	TMenuItem *MMenuItem;
	TStaticText *StaticText1;
	TStatusBar *StatusBar1;
	TEdit *Edit1;
	TStaticText *StaticText2;
	void __fastcall FormCreate(TObject *Sender);
	void __fastcall MMenuItemClick(TObject *Sender);
	void __fastcall MMenuItemAdvancedDrawItem(TObject *Sender, TCanvas *ACanvas,
          TRect &ARect, TOwnerDrawState State);
	void __fastcall MMenuItemMeasureItem(TObject *Sender, TCanvas *ACanvas,
          int &Width, int &Height);
	void __fastcall PopupHookPopup(TObject *Sender);
	void __fastcall FormKeyDown(TObject *Sender, WORD &Key, TShiftState Shift);
private:	// Déclarations de l'utilisateur
		void __fastcall LanceHook(TWMNoParams &p);
		void __fastcall RecepMessHook(TMessage &msg);
		void __fastcall SwichCaption(TMenuItem *AMenuItem);
		int __fastcall CalculPos(TCanvas *Canva, int Index);
 
 
 
		BEGIN_MESSAGE_MAP
				MESSAGE_HANDLER(WMAP_INITHOOKMSG, TWMNoParams, LanceHook)
				MESSAGE_HANDLER(WMAP_SENDSMSG, TMessage, RecepMessHook)
		END_MESSAGE_MAP(TForm)
 
		bool HookLance;
		bool Dessin;
		int CurPos;
		int Index;
 
public:		// Déclarations de l'utilisateur
	__fastcall TMForm(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TMForm *MForm;
//---------------------------------------------------------------------------
#endif

.cpp:

Code :

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
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
 
//---------------------------------------------------------------------------
 
#include <vcl.h>
#pragma hdrstop
 
#include "UnitMForm.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TMForm *MForm;
extern "C" __declspec(dllimport) __stdcall int InitHook(HWND hDest);
extern "C" __declspec(dllimport) __stdcall int EndHook();
//---------------------------------------------------------------------------
__fastcall TMForm::TMForm(TComponent* Owner)
	: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TMForm::LanceHook(TWMNoParams &p)
{
if (HookLance)
{
	HookLance = false;
}
else
{
	HookLance = true;
}
}
//---------------------------------------------------------------------------
void __fastcall TMForm::RecepMessHook(TMessage &msg)
{
switch (msg.LParam)
{
	case 0: //ajout en minuscule
		MMenuItem->Caption = MMenuItem->Caption.Insert(LowerCase((char)msg.WParam), Index + 1);
		Index ++;
	break;
	case 1: //ajout en majuscule
		MMenuItem->Caption = MMenuItem->Caption.Insert((char)msg.WParam, Index + 1);
		Index ++;
	break;
	case 2: //retrait d'une lettre
		MMenuItem->Caption = MMenuItem->Caption.Delete(Index, 1);
		Index --;
	break;
	case 3: //supp ou delete
		Index = 0;
		MMenuItem->Caption = "";
	break;
	case 4: //VK_LefT
		if (Index > 0)
		{
			Index --;
			SwichCaption(MMenuItem);
		}
	break;
	case 5: //VK_RIGHT
		if (Index < MMenuItem->Caption.Length())
		{
			Index ++;
			SwichCaption(MMenuItem);
		}
	break;
	case 6:
		MMenuItem->Click();
	break;
	case 1000:
		Dessin = true;
		SwichCaption(MMenuItem);
	break;
	case 1001:
		Dessin = false;
		SwichCaption(MMenuItem);
	break;
	default:
	break;
}
StatusBar1->Panels->Items[0]->Text = (char)msg.WParam;
}
//---------------------------------------------------------------------------
void __fastcall TMForm::SwichCaption(TMenuItem *AMenuItem)
{
String temp;
		temp = MMenuItem->Caption;
		MMenuItem->Caption = "";
		MMenuItem->Caption = temp;
}
//---------------------------------------------------------------------------
void __fastcall TMForm::FormCreate(TObject *Sender)
{
HookLance = false;
DoubleBuffered = true;
}
//---------------------------------------------------------------------------
void __fastcall TMForm::MMenuItemClick(TObject *Sender)
{
Edit1->Text = MMenuItem->Caption;
}
//---------------------------------------------------------------------------
void __fastcall TMForm::MMenuItemAdvancedDrawItem(TObject *Sender,
	  TCanvas *ACanvas, TRect &ARect, TOwnerDrawState State)
{
CurPos = ARect.Left + CalculPos(ACanvas, Index);
 
ACanvas->Font->Style = TFontStyles() << fsBold;
ACanvas->TextRect(ARect, 2, 2, ((TMenuItem*)Sender)->Caption);
 
	if (Dessin == true)
	{
		ACanvas->MoveTo(CurPos, ARect.Top + 1);
		ACanvas->LineTo(CurPos, ARect.Bottom - 1);
	}
}
//---------------------------------------------------------------------------
void __fastcall TMForm::MMenuItemMeasureItem(TObject *Sender, TCanvas *ACanvas,
      int &Width, int &Height)
{
if (   ACanvas->TextExtent(((TMenuItem*)Sender)->Caption).cx < 50   )
{
	Width = 50;
}
else
{
	Width = ACanvas->TextExtent(((TMenuItem*)Sender)->Caption).cx * 1.15;
}
}
//---------------------------------------------------------------------------
void __fastcall TMForm::PopupHookPopup(TObject *Sender)
{
if (HookLance != true)
{
	InitHook(MForm->Handle);
	MMenuItem->Caption = "";
	CurPos = 0;
}
}
//---------------------------------------------------------------------------
int __fastcall TMForm::CalculPos(TCanvas *Canva, int Index)
{
int Result = 0;
int wPos;
	if (Index > 0)
	{
		for (int i = 1; i < (Index + 1) ; i ++)
		{
			wPos = wPos + (Canva->TextExtent(MMenuItem->Caption.SubString(i, 1)).cx * 1.28);
		}
		Result = wPos;
	}
StatusBar1->Panels->Items[1]->Text = Result;
return Result;
}
//---------------------------------------------------------------------------
 
void __fastcall TMForm::FormKeyDown(TObject *Sender, WORD &Key,
	  TShiftState Shift)
{
if (Key == VK_ESCAPE)
{
	Close();
}
}
//---------------------------------------------------------------------------

Le Hook:

Code :

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
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
208
209
210
211
212
213
214
 
//---------------------------------------------------------------------------
 
#include <vcl.h>
#include <windows.h>
#include <stdio.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'
//variable Timer
bool Dessin;
HWND ahwnd;
// 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 CALLBACK ATimerProc();
//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:
	PostMessage(VueDonnees->hDestWindow, WMAP_INITHOOKMSG, 0, 0);
	EndHook();
	break;
	case VK_BACK:
	if (GetKeyState(wParam) == 0)
		PostMessage(VueDonnees->hDestWindow, WMAP_SENDSMSG, wParam, 2);
	break;
	case VK_DELETE:
	case VK_CLEAR:
	if (GetKeyState(wParam) == 0)
		PostMessage(VueDonnees->hDestWindow, WMAP_SENDSMSG, wParam, 3);
	break;
	case VK_LEFT:
	if (GetKeyState(wParam) == 0)
		PostMessage(VueDonnees->hDestWindow, WMAP_SENDSMSG, wParam, 4);
	break;
	case VK_RIGHT:
	if (GetKeyState(wParam) == 0)
		PostMessage(VueDonnees->hDestWindow, WMAP_SENDSMSG, wParam, 5);
	break;
	case VK_RETURN:
		PostMessage(VueDonnees->hDestWindow, WMAP_SENDSMSG, wParam, 6);
	break;
	case 'A':
	case 'B':
	case 'C':
	case 'D':
	case 'E':
	case 'F':
	case 'G':
	case 'H':
	case 'I':
	case 'J':
	case 'K':
	case 'L':
	case 'M':
	case 'N':
	case 'O':
	case 'P':
	case 'Q':
	case 'R':
	case 'S':
	case 'T':
	case 'U':
	case 'V':
	case 'W':
	case 'X':
	case 'Y':
	case 'Z':
	if (GetKeyState(wParam) == 0 && wParam != VK_SHIFT)
	{
		if (GetAsyncKeyState(VK_SHIFT) || GetAsyncKeyState(VK_CAPITAL))
		{
			PostMessage(VueDonnees->hDestWindow, WMAP_SENDSMSG, wParam, 1);
		}
		else
		{
			PostMessage(VueDonnees->hDestWindow, WMAP_SENDSMSG, wParam, 0);
		}
	}
	break;
	default:
	break;
	}
return CallNextHookEx(VueDonnees->KeyHookHandle,nCode, wParam, lParam);
}
//---------------------------------------------------------------------------
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 CALLBACK ATimerProc()
{
int Result;
try
{
Dessin ^= true;
	switch (Dessin)
	{
		case true:
			PostMessage(VueDonnees->hDestWindow, WMAP_SENDSMSG, 0, 1000);
		break;
		case false:
			PostMessage(VueDonnees->hDestWindow, WMAP_SENDSMSG, 0, 1001);
		break;
		default:
		;
	}
	Result = 0;
}
catch(...)
{
	Result = 1;
}
return Result;
}
//---------------------------------------------------------------------------
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;
 
	 SetTimer(hDest, 1, 500, ATimerProc);
	 ahwnd = hDest;
	 PostMessage(VueDonnees->hDestWindow, WMAP_INITHOOKMSG, 0, 0);
	 Result = 0;
}
catch(...)
{
	Result = 1;
}
return Result;
}
//---------------------------------------------------------------------------
int __stdcall EndHook()
{
	KillTimer(ahwnd, 1);
	UnhookWindowsHookEx(VueDonnees->KeyHookHandle);
	UnhookWindowsHookEx(VueDonnees->CBTHookHandle);
return 0;
}
//---------------------------------------------------------------------------

Ca va finir par me rendre dingue ce truc ...

@ +

**bandit boy** · 18/04/2007, 14h17

Je ne sais pas si ca peux t'aider, mais moi j'ai ce code dans le dessin du popup:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
    ACanvas->Brush->Color = clWhite;
    ACanvas->Rectangle(ARect.Left+2,ARect.Top+2,ARect.Right-2,ARect.Bottom-2);
    ACanvas->TextOutA(ARect.Left+4,ARect.Top+3,N11->Caption);
 
    int length;
    AnsiString text = PopupHook->Items->Items[0]->Caption.SubString(1,PosCurseur);
    length = ACanvas->TextWidth(text);
    PopupHook->Items->Items[2]->Caption = text;
    PopupHook->Items->Items[3]->Caption = IntToStr(length);
 
    ACanvas->Pen->Color = clBlack;
    ACanvas->MoveTo(ARect.Left+3+length,ARect.Top+5);
    ACanvas->LineTo(ARect.Left+3+length,ARect.Bottom-5);

Et je n'ai pas de problème de positionnement du curseur...

Pour le scintillement, il vient surement du fait que tu dois redessiner le carré puis le carret maison alors qu'ils ne devrai rien faire.( c'est juste une hypothèse)

**Sunchaser** · 20/04/2007, 00h13

Bonsoir,

Et ben ... je me demande ya pas une petite poupée avec des épingles piquées partout dedans, parceque j'ai essayé pleins de choses diverses et je ne trouve pas 'mieux' que la solution utilisée avec ma petite fonction 'CalculPos' et le coefficient 'mystérieux' ( *1.28 ).
J'ai juste modifié une tout petite chose dans le OnAdvancedDrawItem, afin de répondre au positionnement du texte lors du TextRect:

Code :

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

1
2
 
CurPos = CalculPos(ACanvas, Index) + 3;

C'est pas très glorieux finalement comme truc, j'ai trouvé cela plus a force de tests laborieux qu'autre chose.

Je ne sais pas pas pourquoi ton code ne fonctionne pas tout a fait sur mon pc, bandit boy

Eventuellement, si qqu'un est très patient et peut tester, histoire de ...

Merci,
@ +

**gandf** · 21/04/2008, 14h24

Bonjour,

Je sais que cela est un vieux post, mais ma question est en rapport direct avec le problème soulevé ici.

Je voudrais utiliser un popup menu avec des control à l'intérieur mais ne pas me limiter à un pseudo TEdit refait à la main.

J'ai alors utilisé la méthode PaintTo pour affiché mes controls à l'écran mais j'ai un problème au niveau du hook. Le programme récupère bien le hook mais rien ne se passe quand j'essaie de renvoyer le message au control. En affichant les messages réceptionné, j'ai vu que lParam est différent suivant que l'on scrute un popupmenu ou un TEdit.

Voici ce que j'obtient avec mon popup menu (le rafraichissement n'est pas encore codé).

Je n'ai pas utilisé de DLL et ce code est directement dans le fichier cpp de ma TForm. Je n'ai mis que la partie du code qui me semble utile car le code fait partie d'une application et n'est pas testé sur une fiche spécial.
Le HOOK:

Code :

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
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
//struct pour le hook
typedef struct _TDataHook
{
        HHOOK KeyHookHandle;   // handle du hook clavier
        HHOOK CBTHookHandle;   // handle du hook CBT
        HWND hDestWindow;
} 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'instance de la DLL
DWORD ThId;                    // récupération de l'ID du thread 'appellant'
 
//Déclaration des fonctions de la DLL
LRESULT CALLBACK KeyboardProc(int nCode, WPARAM wParam, LPARAM lParam); // fonction hook du clavier
LRESULT CALLBACK CBTProc(int nCode, WPARAM wParam, LPARAM lParam); // fonction hook de destruction de control
                 int __stdcall InitHook(HWND hDest); // fonction initialisant le hook
                 int __stdcall EndHook(); // fonction mettant fin au hook
 
#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)
{
PostMessage(VueDonnees->hDestWindow, WMAP_SENDSMSG, wParam, lParam); // envoie du message vers la fonction de réception de l'application
return CallNextHookEx(VueDonnees->KeyHookHandle,nCode, wParam, lParam); // envoie le message au prochain hook présent dans la chaine
}
//---------------------------------------------------------------------------
LRESULT CALLBACK CBTProc(int nCode,WPARAM wParam,LPARAM lParam)
{
if (nCode == HCBT_DESTROYWND) // si on change de control, on arrête le hook
   {
   PostMessage(VueDonnees->hDestWindow, WMAP_INITHOOKMSG, 0, 0); // on prévient l'application de la fin du hook
   EndHook(); // le hook est stoppé
   }
return CallNextHookEx(VueDonnees->CBTHookHandle, nCode, wParam, lParam);
}
//---------------------------------------------------------------------------
int __stdcall InitHook(HWND hDest)
{
if (VueDonnees == NULL) // si aucun hook n'existe
   {
   VueDonnees = new _TDataHook(); // on crée une nouvelle structure
   }
int Result;
try {
    ThId = GetCurrentThreadId(); // on garde une trace du thread responsable du hook
    VueDonnees->KeyHookHandle = SetWindowsHookEx(WH_KEYBOARD,(HOOKPROC)KeyboardProc,NULL, ThId); // on utilise le hook clavier pour récupérer les commandes
    VueDonnees->CBTHookHandle = SetWindowsHookEx(WH_CBT,(HOOKPROC)CBTProc,NULL, ThId); // on utilise le hook permettant de vérifier le changement de control actif
    VueDonnees->hDestWindow = hDest; // on stocke l'initiateur de la demande
    PostMessage(VueDonnees->hDestWindow, WMAP_INITHOOKMSG, 0, 0); // informe l'application que le hook est initialisé
    Result = 0;
    }
catch (...)
      {
      Result = 1;
      }
return Result;
}
//---------------------------------------------------------------------------
int __stdcall EndHook()
{
   UnhookWindowsHookEx(VueDonnees->KeyHookHandle); // on arrête les 2 hooks
   UnhookWindowsHookEx(VueDonnees->CBTHookHandle);
return 0;
}

Le .hpp

Code :

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
#define WMAP_INITHOOKMSG WM_APP + 1
#define WMAP_SENDSMSG WM_APP + 2
class TForm1 : public TForm
{
__published:	// Composants gérés par l'EDI
 
...
 
private:	// Déclarations de l'utilisateur
        void __fastcall LanceHook(TWMNoParams &p);
        void __fastcall RecepMessHook(TMessage &msg);
// Déclaration des fonctions de la DLL
        BEGIN_MESSAGE_MAP
                        MESSAGE_HANDLER(WMAP_INITHOOKMSG, TWMNoParams, LanceHook)
                        MESSAGE_HANDLER(WMAP_SENDSMSG, TMessage, RecepMessHook)
        END_MESSAGE_MAP(TForm)
 
        bool HookLance;
        TWinControl *ControlActif;
public:		// Déclarations de l'utilisateur
	__fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

Le .CPP

Code :

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
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
//---------------------------------------------------------------------------
void __fastcall TForm1::LanceHook(TWMNoParams &p)
{
if (HookLance) // permet de commuter l'état du hook
   {
   HookLance = false;
   }
else {
     HookLance = true;
     }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::RecepMessHook(TMessage &msg)
{
ControlActif->Perform(WM_KEYDOWN, msg.WParam, msg.LParam); // renvoie des messages clavier vers le control concerné
}
//---------------------------------------------------------------------------
void __fastcall TForm1::PopupMenu1Popup(TObject *Sender)
{
if (HookLance != true) // si le hook est arrêté
   {
   InitHook(Form1->Handle); // on l'initialise
   }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::N2MeasureItem(TObject *Sender, TCanvas *ACanvas,
      int &Width, int &Height)
{
TWinControl *tempcontrol = (TWinControl *)CompList->Items[((TMenuItem *)Sender)->Tag];
ControlActif = tempcontrol;
Width = tempcontrol->Width - 10; // on donne la taille du control dessiné au menuitem
Height = tempcontrol->Height;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::N2AdvancedDrawItem(TObject *Sender, TCanvas *ACanvas,
      TRect &ARect, TOwnerDrawState State)
{
if (HookLance != true) // si le hook est arrêté
   {
   InitHook(Form1->Handle); // on l'initialise
   }
TWinControl *tempcontrol = (TWinControl *)CompList->Items[((TMenuItem *)Sender)->Tag];
ControlActif = tempcontrol;
ACanvas->Lock();
tempcontrol->PaintTo(ACanvas, 0, 0);
ACanvas->Unlock();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::N2DrawItem(TObject *Sender, TCanvas *ACanvas,
      TRect &ARect, bool Selected)
{
if (HookLance != true) // si le hook est arrêté
   {
   InitHook(Form1->Handle); // on l'initialise
   }
TWinControl *tempcontrol = (TWinControl *)CompList->Items[((TMenuItem *)Sender)->Tag];
ControlActif = (TWinControl *)tempcontrol;
ACanvas->Lock();
tempcontrol->PaintTo(ACanvas, 0, 0);
ACanvas->Unlock();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)
{
if (HookLance == true)
   {
   EndHook(); // on arrête le hook si on ferme l'application
   }
delete CompList;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::PopupMenu1Popup(TObject *Sender)
{
if (HookLance != true) // si le hook est arrêté
   {
   InitHook(Form1->Handle); // on l'initialise
   }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormCreate(TObject *Sender)
{
CompList = new TList();
// initialisation des variables
HookLance = false; // le hook n'est pas encore actif
CompList->Add(NULL); // L'item 0 ne comporte pas de composant pour que tag = index
CompList->Add(CurrencyEdit1);  //1
CompList->Add(CurrencyEdit2);  //2
CompList->Add(Edit1);          //3
CompList->Add(CurrencyEdit3);  //4
CompList->Add(CurrencyEdit4);  //5
CompList->Add(CurrencyEdit5);  //6
CompList->Add(ColorBox1);      //7
CompList->Add(ColorBox2);      //8
CompList->Add(ColorBox3);      //9
CompList->Add(ColorBox4);      //10
CompList->Add(CurrencyEdit6);  //11
CompList->Add(CurrencyEdit7);  //12
CompList->Add(Edit2);          //13
CompList->Add(CurrencyEdit8);  //14
CompList->Add(CurrencyEdit9);  //15
CompList->Add(ComboBox1);      //16
CompList->Add(ColorBox5);      //17
CompList->Add(ColorBox6);      //18
CompList->Add(ComboBox2);      //19
CompList->Add(Edit3);          //20
CompList->Add(Edit4);          //21
CompList->Add(CurrencyEdit10); //22
CompList->Add(CurrencyEdit11); //23
CompList->Add(CurrencyEdit12); //24
CompList->Add(ColorBox7);      //25
CompList->Add(CurrencyEdit13); //26
CompList->Add(CurrencyEdit14); //27
CompList->Add(Edit5);          //28
CompList->Add(Edit6);          //29
CompList->Add(CurrencyEdit15); //30
CompList->Add(Edit7);          //31
CompList->Add(Edit8);          //32
CompList->Add(Edit9);          //33
CompList->Add(ComboBox3);      //34
CompList->Add(ComboBox4);      //35
CompList->Add(ComboBox5);      //36
CompList->Add(ComboBox6);      //37
CompList->Add(CurrencyEdit16); //38
CompList->Add(CurrencyEdit17); //39
CompList->Add(Edit10);         //40
CompList->Add(Edit11);         //41
}

Quelqu'un a une solution? Dans quels cours puis-je trouver une réponse?

Merci

**Sunchaser** · 21/04/2008, 23h11

Bonsoir,

Juste une petite question: au moment du "perform" ControlActif pointe bien vers le control en question ? ControlActif et/ou tempcontrol désigne bien le bon contrôle cible a tout moment ?

@+

**gandf** · 22/04/2008, 09h10

Bien sûr, le controle actif est celui qui est dessiné. Je le retrouve grace au Tag du TMenuItem qui est dessiné avec le code suivant :

Code :

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

(TWinControl *)CompList->Items[((TMenuItem *)Sender)->Tag];

J'ai essayé sur une feuille vierge avec juste un popupmenu et un TEdit et j'ai pu voir que les lParam des 2 controls sont totalement différents mais que le reste des messages est identique.

**Sunchaser** · 22/04/2008, 09h36

Bonjour,

Juste une idée, sans certitude: dans le 'RecepMessHook', tu peut 'décoder' le WParam afin donc de savoir quel caractère a été tapé au clavier et envoyer plutôt un message de type WM_SETTEXT, avec ce caractère en paramètre ... ?
Ca ferait qqchose comme:

Code :

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

1
2
3
4
5
 
void __fastcall TForm1::RecepMessHook(TMessage &msg)
{
this->PostMessage(ControlActif->Handle, WM_SETTEXT, NULL, (char)msg.WParam );
}

Donc 'this' ou 'TaForm->', et pour le dernier paramètre je ne sais pas si on peut imaginer qu'il passe ainsi, mais a essayer donc.

@+

**gandf** · 22/04/2008, 10h50

Je ne comprend pas comment tu fais ceci.
J'ai C++Builder 2006 et une TForm ne comporte pas cette fonction.
En recherchant dans l'aide, j'ai trouver une fonction indépendante PostMessage mais elle veut un handle de fenêtre et non pas un handle sur un control.

**Sunchaser** · 22/04/2008, 11h52

Bonjour,

Mille excuses -> je n'étais pas très réveillé, effectivement 'PostMessage' ne fait pas partie des méthodes de TForm ou autre, désolé.
De ce fait , je viens d'essayer rapidement et c'est 'SendMessage' qu'il faut utiliser:

Code :

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

1
2
 
SendMessage(Edit1->Handle, WM_SETTEXT, 0, (LPARAM)"essai");

fonctionne donc sur un TEdit, mais selon l'explication donnée dans la ref Win32, il semble donc que ce soit applicable a un TButton (j'ai essayé aussi), ou a un TCombobox.
Donc pas sur que cela corresponde a tout tes besoins en fonction des objets ciblés, mais ca vaut la peine peut être d'essayer.

@+

**gandf** · 22/04/2008, 12h08

Merci, ça fonctionne. Je vais pouvoir bidouiller avec ça.

**gandf** · 23/04/2008, 13h31

Alors, le "WM_SETTEXT" ne convient pas, on ne peut pas gérer correctement tout ce que réclame un control comme par exemple l'ajout d'un caractère au milieu du texte.

J'ai donc essayé "WM_CHAR" et la ça marche mieux mais on ne peut toujours pas utiliser les flèches du clavier.

Donc, j'en reviens à "WM_KEYDOWN" et la rien ne fonctionne. Je me suis dit que le control ne récupère pas cet évènement parce qu'il n'est pas le control actif. Mais même en rajoutant "ControlActif->SetFocus();" avant l'envoie du message, il ne le récupère pas.

Je n'ai pas encore fait le raffraichissement du control mais cela ne devrait pas poser de problème.

Une idée de la cause du problème? On a presque un popupmenu gérant les controls, il ne reste plus que l'envoie des messages clavier et souris.

**Sunchaser** · 23/04/2008, 23h26

Bonsoir,

Le fait:

l'ajout d'un caractère au milieu du texte

suppose, a mon humble avis, que l'on peut récupérer la position du curseur dans le contrôle.
Mon idée aurait été:
. de rester sur le WM_SETTEXT
. au moment de la frappe d'un caractère au clavier, récupérer l'état du 'Text' en cours et qqchose comme soit 'GetCaretPos' soit 'GetCursorPos'
. faire un 'Insert' du caractère a la position donnée par le curseur précédemment
. re-balancer le texte a l'objet 'cible' au moyen donc de WM_SETTEXT
Comme je suis une truffe, je n'arrive pas a utiliser correctement ni 'GetCaretPos' ni 'GetCursorPos', dsl ...

Mais je suis d'accord avec toi, le mieux serait de rester / gérer WM_KEYDOWN, je ne suis pas sur du tout que WM_SETTEXT puisse correspondre a tous les cas.

@+

**Sunchaser** · 25/04/2008, 09h55

Bonjour,

Question surement tout a fait stupide, j'en suis conscient, mais sait on jamais:
-> as tu tenté de faire un 'SendMessage' en lieu et place du 'Perform', avec donc en paramètres: le handle de l'objet (TEdit ou autre), WM_KEYDOWN, 0, puis le code du caractère ?

++

**gandf** · 25/04/2008, 10h26

Ceci :

Code :

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

SendMessage(ControlActif->Handle, WM_KEYDOWN, 0, msg.LParam);

ne fonctionne pas.
Mais cela :

Code :

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

ControlActif->Perform(WM_CHAR,(unsigned int)msg.WParam,msg.LParam);

fonctionne.

J'ai aussi un autre problème, je n'arrive pas a raffraichir le menuitem automatiquement. Il faut bouger la souris pour obtenir un raffraichissement. Je n'ai pas trouver comment déclencher un repaint du menuitem.

Le Canvas fourni par le DrawItem peut-il être réutilisé ailleurs? (je n'ai pas encore pu tester ceci)

**Sunchaser** · 25/04/2008, 13h33

Mais cela :
Code :

ControlActif->Perform(WM_CHAR,(unsigned int)msg.WParam,msg.LParam);

fonctionne.

Ben c'est chouette alors !, non? Bravo ...

Je ne me replace pas dans ta situation (je ne peut pas, dsl) mais je jettes un oeil dans la ref Win32, et il y a des choses telles que:

Code :

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

1
2
 
UpdateWindow(LeMenuItem->Handle);

Cela ne peut il pas convenir ?

@+

Comment mettre un TEdit dans un PopupMenu [Sources]

C++Builder

Discussions similaires

Partager

Partager