problème avec Visual C#

Bonjour,

je me retrouve face à un problème plus ou moins bizard, et devant lequel je suis devenu totalement impuissant.

mon problème se résume dans le fait que dans une application logicielle que je developpe en C#, j'ai un traitement à éxecuter et dont l'algorithme somble très correct.

mais quand je lance le programme ça donne pas le résultat escompté, mais bizarrement quand je lance l'application en mode Debug ça passe.

j'espère que quelqu'un connait une solution à ce problème

merci d'avance
bien cordialement

vu le peu d'éléments que tu donnes, je vois pas très bien comment on pourrait t'aider... :roll:
Tu pourrais peut-être nous montrer le bout de code incriminé pour commencer ?

Citation:

Envoyé par tomlev

vu le peu d'éléments que tu donnes, je vois pas très bien comment on pourrait t'aider... :roll:
Tu pourrais peut-être nous montrer le bout de code incriminé pour commencer ?

salut,

merci pour ta réponse,
c'est trop difficile de vous montrer un bout de code, puise que l'application contient une trentaine de classes et plus de 20000 lignes de code.

je vais essayer de vous expliquer la où le problème se pose exactement :
j'ai un composant graphique (que j'ai créé en héritant de la classe UserControl) et pour lequel j'ai sur-défini les évènements KeyPress et ProccessCmdKey

l'event ProcessCmdKey est utilisé pour capter l'utilisation de touches comme : Home, Fin, touches de direction, ...
l'event KeyPress pour les caractères de la table ASCII

Exemple :

si je tape -> : ProcessCmdKey doit s'activer
si je tape Z : KeyPress doit s'activer

voici une situation qui a posé problème : dans mon controle j'entre "0" et après je tape "<-", jusque là, tout est bon, mais quand j'entre un autre caractère Keypress ne s'active pas et ça provoque un traitement indésirable.

quand je refais la même procédure en debug (je met un break point dans la méthode ProcessCmdKey) tout marche à merveille.

voilà
Bien cordialement

Tu pourrais montrer le code de ta méthode ProcessCmdKey ?

Citation:

Envoyé par reeda

quand je refais la même procédure en debug (je met un break point dans la méthode ProcessCmdKey) tout marche à merveille

Et quand tu mets pas de breakpoint ça donne quoi ?

Citation:

Envoyé par tomlev

Tu pourrais montrer le code de ta méthode ProcessCmdKey ?

Et quand tu mets pas de breakpoint ça donne quoi ?

le code de cette méthode est hyper grand (environs 200 lignes) :

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
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
 
        protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
        {
            // tester si la zone de texte est visible, si oui valider l'ancienne valeur et cacher la zone de texte
            TextBox zone = getTextBox();
 
            int keyCode = (int)keyData;
            ctrl_.console("Key = " + keyCode);
            if ((keyCode & (int)Keys.Shift) != 0 && mdl_.CacheCount != 0)//ame\\
            { // Shift
 
                if ((keyCode & (int)Keys.Control) != 0)
                {
                    keyCode &= 0xffff;
                    if ((Keys)keyCode == Keys.Home)
                    {
                        #region Key Crtl + Shift + Home
                        if (mdl_.Select.End > 0)
                        {
                            // déplacer la cellule sélectionnée vers la cellule du début
                            mdl_.StartNb = ctrl_.requestJustInTime(0);
 
                            // Sélection de la cellule
                            mdl_.Select.End = 0;
                            ctrl_.selectionMultiple(mdl_.Select.Begin, mdl_.Select.End);
 
                            // Infos dans le pied de page
                            this.colonne_ = (int)getPosition(mdl_.Select.End)[0];
                            this.position_ = mdl_.Select.End;
                            ctrl_.piedPage(this);
                        }
                        return true;
                        #endregion
                    }
                    else if ((Keys)keyCode == Keys.End)
                    {
                        #region Key Ctrl + Shift + End
                        if (mdl_.Select.End < (ctrl_.getLastOffSet() - 1))
                        {
                            // calcul du nouveau StartNb
                            Int64 newStartNb = ctrl_.getLastStartNb();
                            // test si la fin du fichier se situe dans la page d'affichage
                            if (0 <= newStartNb && newStartNb < ctrl_.getLastOffSet() - 1)
                                mdl_.StartNb = ctrl_.requestJustInTime(newStartNb);
 
                            // déplacer la cellule sélectionnée vers la cellule de fin
                            mdl_.Select.End = ctrl_.getLastOffSet() - mdl_.MinCache - 1;
 
                            // Sélection des cellules
                            ctrl_.selectionMultiple(mdl_.Select.Begin, mdl_.Select.End);
 
                            // Infos dans le pied de page
                            this.colonne_ = (int)getPosition(mdl_.Select.End)[0];
                            this.position_ = mdl_.Select.End;
                            ctrl_.piedPage(this);
                        }
                        return true;
                        #endregion
                    }
                }
                else
                {
                    keyCode &= 0xffff; // Effacer les bits des états
 
                    switch ((Keys)keyCode)
                    {
                        case Keys.Right:
                            //si on dépasse la fin du fichier on ne fait rien
                            if ((mdl_.Select.End + 1) < ctrl_.getLastOffSet() - mdl_.MinCache)
                                mouvementKeys(1, true, 1);
                            return true;
 
                        case Keys.Left:
                            if (mdl_.Select.End != -1)
                            {
                                //si on dépasse le début du fichier on ne fait rien
                                if ((mdl_.AbsoluteEnd - 1) >= 0)
                                    mouvementKeys(-1, true, 1);
                            }
                            return true;
 
                        case Keys.Up:
                            if (mdl_.Select.End >= 0)
                            {
                                Int64 index = mdl_.Select.End - nbColonne_;
                                //si on dépasse le début du fichier on ne fait rien
                                if (index >= 0)
                                    mouvementKeys(-nbColonne_, true, 1);
                            }
                            return true;
 
                        case Keys.Down:
                            if (mdl_.Select.End != -1)
                            {
                                Int64 index = mdl_.Select.End + nbColonne_;
                                //si on dépasse la fin du fichier on ne fait rien
                                if (index < ctrl_.getLastOffSet())
                                    mouvementKeys(nbColonne_, true, 1);
                            }
                            return true;
 
                        case Keys.Home:
                            if (mdl_.Select.End != -1)
                            {
                                if (this.colonne_ != 0)
                                    mouvementKeys((int)(-((mdl_.AbsoluteEnd) % nbColonne_)), true, 0);
                            }
                            return true;
 
                        case Keys.End:
                            if (mdl_.Select.End != -1)
                            {
                                if (this.colonne_ != (nbColonne_ - 1))
                                {
                                    Int64 index = mdl_.AbsoluteEnd + nbColonne_ - ((mdl_.AbsoluteEnd) % nbColonne_) - 1;
                                    if (index < ctrl_.getLastOffSet()) // test sur le cas limite : si la dernière ligne n'est pas complétement remplie
                                        mouvementKeys((int)(nbColonne_ - ((mdl_.AbsoluteEnd) % nbColonne_) - 1), true, 0);
                                    else
                                        mouvementKeys((int)((ctrl_.getLastOffSet() % nbColonne_) - ((mdl_.AbsoluteEnd) % nbColonne_) - 1), true, 0);
                                }
                            }
                            return true;
 
                        case Keys.PageUp:
                            #region Shift + PageUp
                            if (mdl_.Select.End != -1)
                            {
                                Int64 index = mdl_.AbsoluteEnd - nbLine_ * nbColonne_;
 
                                // tester la position de la cellule sélectionnée par rapport au début du fichier
                                if (index < 0 && mdl_.ParamStartNb == 1)
                                {
                                    // se positionner dans la première ligne du fichier
                                    mdl_.Select.End = colonne_;//mdl_.Select.End - mdl_.MinCache - (nbColonne_ * (mdl_.Select.End / nbColonne_));//BUG2 : 481
 
                                    // position le StartNb dans la première position du fichier
                                    mdl_.StartNb = ctrl_.requestJustInTime(0);
                                }
                                else
                                {
                                    if (mdl_.StartNb <= mdl_.Select.End && mdl_.Select.End <= (mdl_.StartNb + (nbColonne_ * nbLine_)))
                                        mouvementKeys(-(nbLine_ * nbColonne_), true, nbLine_);
                                    else
                                    {
                                        Int64 newStartNb = mdl_.StartNb + mdl_.MinCache - (nbLine_ * nbColonne_);
                                        mdl_.Select.End = Math.Max(colonne_, newStartNb + colonne_ - mdl_.MinCache);
                                        mdl_.StartNb = ctrl_.requestJustInTime(newStartNb);
                                    }
                                }
                            }
                            return true;
                        #endregion
 
                        case Keys.PageDown:
                            #region Shift + PageDown
                            if (mdl_.Select.End != -1)
                            {
                                // tester la position de la cellule sélectionnée par rapport à la fin du fichier
                                Int64 index = mdl_.AbsoluteEnd + nbLine_ * nbColonne_;
                                if (index > (ctrl_.getLastOffSet() - 1))
                                {
                                    //calcul de l'emplacement où devrait atterir le dernier point
                                    Int64 last = mdl_.Select.End + (nbColonne_ * (mdl_.Select.End % nbColonne_));
                                    Int64 numColonneFin = (ctrl_.getLastOffSet() - 1 - mdl_.MinCache) % nbColonne_;
                                    Int64 numColonneLast = last % nbColonne_;
 
                                    if ((numColonneLast - numColonneFin) > 0)
                                        mdl_.Select.End = ctrl_.getLastOffSet() - 1 - mdl_.MinCache;
                                    else
                                        mdl_.Select.End = ctrl_.getLastOffSet() - 1 - mdl_.MinCache - Math.Abs(numColonneLast - numColonneFin);
 
                                    Int64 newStartNb = mdl_.Select.End - (nbColonne_ * (nbLine_ - 1)) - getPosition(mdl_.Select.End)[0];
                                    mdl_.StartNb = ctrl_.requestJustInTime(newStartNb + mdl_.MinCache);
                                }
                                else
                                {
                                    if (mdl_.StartNb <= mdl_.Select.End && mdl_.Select.End <= (mdl_.StartNb + (nbColonne_ * nbLine_)))
                                        mouvementKeys((nbLine_ * nbColonne_), true, nbLine_);
                                    else
                                    {
                                        Int64 newStartNb = mdl_.StartNb + mdl_.MinCache + (nbLine_ * nbColonne_);
                                        mdl_.Select.End = Math.Min(newStartNb + colonne_, ctrl_.getLastOffSet() - 1) - mdl_.MinCache;
                                        //mdl_.StartNb = ctrl_.requestJustInTime(Math.Min((ctrl_.getVSB().Maximum - 9) * nbColonne_, newStartNb));
                                        mdl_.StartNb = ctrl_.requestJustInTime((((Int64)ctrl_.getVSB().Maximum) - 9) * nbColonne_);//BUG2 : 502
                                    }
                                }
                            }
                            return true;
                            #endregion
 
                        default: return base.ProcessCmdKey(ref msg, keyData);
                    }
                }
            }
            else if ((keyCode & (int)Keys.Control) != 0 && mdl_.CacheCount != 0)
            { // Ctrl
                mdl_.IsPersiste = false;
                keyCode &= 0xffff; // Effacer les bits des états
                switch ((Keys)keyCode)
                {
                    case Keys.Home:
                        #region Key Crtl + Home
                        if (mdl_.Select.End > 0)
                        {
                            //-\\ : tester si la zone de texte est visible, si oui valider l'ancienne valeur et cacher la zone de texte
                            if (zone.Visible == true)
                                validateValue();
 
                            // déplacer la cellule sélectionnée vers la cellule du début
                            mdl_.StartNb = ctrl_.requestJustInTime(0);
 
                            // Sélection de la cellule
                            mdl_.Select.Begin = mdl_.Select.End = 0;
                            liste_cell[getPosition(mdl_.Select.End)[1], getPosition(mdl_.Select.End)[0]].Selected = true;
                            ctrl_.selection(mdl_.Select.End);
 
                            // Infos dans le pied de page
                            this.colonne_ = (int)getPosition(mdl_.Select.End)[0];
                            this.position_ = mdl_.Select.End;
                            ctrl_.piedPage(this);
                        }
                        return true;
                        #endregion
 
                    case Keys.End:
                        #region Key Ctrl + End
                        if (mdl_.Select.End < (ctrl_.getLastOffSet() - 1))
                        {
                            //-\\ : tester si la zone de texte est visible, si oui valider l'ancienne valeur et cacher la zone de texte
                            if (zone.Visible == true)
                                validateValue();
 
                            // tester si la cellule sélectionnée est bien affichée
                            if (mdl_.Select.End < mdl_.StartNb || mdl_.Select.End > mdl_.StartNb + (nbColonne_ * nbLine_))
                                mdl_.StartNb = ctrl_.requestJustInTime(mdl_.AbsoluteEnd - this.colonne_);
 
                            // dé-sélectionner l'ancienne cellule 
                            liste_cell[getPosition(mdl_.Select.End)[1], getPosition(mdl_.Select.End)[0]].Selected = false;
 
                            // calcul du nouveau StartNb
                            Int64 newStartNb = ctrl_.getLastStartNb();
                            // test si la fin du fichier se situe dans la page d'affichage
                            if (0 <= newStartNb && newStartNb < ctrl_.getLastOffSet() - 1)
                                mdl_.StartNb = ctrl_.requestJustInTime(newStartNb);
 
                            // déplacer la cellule sélectionnée vers la cellule de fin
                            mdl_.Select.Begin = mdl_.Select.End = ctrl_.getLastOffSet() - mdl_.MinCache - 1;
 
                            // Sélection de la cellule
                            liste_cell[getPosition(mdl_.Select.End)[1], getPosition(mdl_.Select.End)[0]].Selected = true;
                            ctrl_.selection(mdl_.Select.End);
 
                            // Infos dans le pied de page
                            this.colonne_ = (int)getPosition(mdl_.Select.End)[0];
                            this.position_ = mdl_.Select.End;
                            ctrl_.piedPage(this);
                        }
                        return true;
                        #endregion
 
                    case Keys.A://*\\
                        selectAll();
                        return true;
 
                    default: return base.ProcessCmdKey(ref msg, keyData);
                }
            }
            else if (mdl_.Cache.Count != 0)//ame\\
            {
                mdl_.IsPersiste = false;
                //On vérifie quelle touche a été appuyée pour reproduire le déplacement d'un CacheGridView
                switch (keyData)
                {
                    case Keys.Right:
                        if (mdl_.Select.End != -1)
                        {
                            //si on dépasse la fin du fichier on ne fait rien
                            if ((mdl_.Select.End + 1) < ctrl_.getLastOffSet() - mdl_.MinCache)
                                mouvementKeys(1, false, 1);
                        }
                        return true;
 
                    case Keys.Left:
                        if (mdl_.Select.End != -1)
                        {
                            //si on dépasse le début du fichier on ne fait rien
                            if ((mdl_.AbsoluteEnd - 1) >= 0)
                                mouvementKeys(-1, false, 1);
                        }
                        return true;
 
                    case Keys.Up:
                        if (mdl_.Select.End != -1)
                        {
                            SuspendLayout();
                            Int64 index = mdl_.AbsoluteEnd - nbColonne_ + 1;
                            //si on dépasse le début du fichier on ne fait rien
                            if (index > 0)
                                mouvementKeys(-nbColonne_, false, 1);
                            ResumeLayout();
                        }
                        return true;
 
                    case Keys.Down:
                        if (mdl_.Select.End != -1)
                        {
                            Int64 index = mdl_.Select.End + nbColonne_ + 1;
                            Int64 a = ctrl_.getLastOffSet();
                            //si on dépasse la fin du fichier on ne fait rien
                            if (index <= ctrl_.getLastOffSet() - mdl_.MinCache)
                                mouvementKeys(nbColonne_, false, 1);
                        }
                        return true;
 
                    case Keys.PageUp:
                        #region Key PageUp
                        if (mdl_.Select.End != -1)
                        {
                            Int64 index = mdl_.AbsoluteEnd - (nbLine_ * nbColonne_);
 
                            // tester la position de la cellule sélectionnée par rapport au début du fichier
                            if (index < 0 && mdl_.ParamStartNb == 1)
                            {
                                // se positionner dans la première ligne du fichier
                                mdl_.Select.Begin = mdl_.Select.End = colonne_;//mdl_.Select.End - mdl_.MinCache - (nbColonne_ * (mdl_.Select.End / nbColonne_));//BUG2 : 481
 
                                // position le StartNb dans la première position du fichier
                                mdl_.StartNb = ctrl_.requestJustInTime(0);
                            }
                            else
                            {
                                if (mdl_.StartNb <= mdl_.Select.End && mdl_.Select.End <= (mdl_.StartNb + (nbColonne_ * nbLine_)))
                                    mouvementKeys(-(mdl_.NbLine * mdl_.NbColonne), false, mdl_.NbLine);
                                else
                                {
                                    Int64 newStartNb = mdl_.StartNb + mdl_.MinCache - (nbLine_ * nbColonne_);
                                    mdl_.Select.Begin = mdl_.Select.End = Math.Max(colonne_, newStartNb + colonne_ - mdl_.MinCache);
                                    mdl_.StartNb = ctrl_.requestJustInTime(newStartNb);
                                }
                            }
                        }
                        return true;
                        #endregion
 
                    case Keys.PageDown:
                        #region Key PageDown
                        if (mdl_.Select.End != -1)
                        {
                            // tester la position de la cellule sélectionnée par rapport à la fin du fichier
                            Int64 index = mdl_.AbsoluteEnd + nbLine_ * nbColonne_;
                            if (index > (ctrl_.getLastOffSet() - 1))
                            {
                                //calcul de l'emplacement où devrait atterir le dernier point
                                Int64 last = mdl_.Select.End + (nbColonne_ * (mdl_.Select.End % nbColonne_));
                                Int64 numColonneFin = (ctrl_.getLastOffSet() - 1 - mdl_.MinCache) % nbColonne_;
                                Int64 numColonneLast = last % nbColonne_;
 
                                if ((numColonneLast - numColonneFin) > 0)
                                    mdl_.Select.Begin = mdl_.Select.End = ctrl_.getLastOffSet() - 1 - mdl_.MinCache;
                                else
                                    mdl_.Select.Begin = mdl_.Select.End = ctrl_.getLastOffSet() - 1 - mdl_.MinCache - Math.Abs(numColonneLast - numColonneFin);
 
                                Int64 newStartNb = ctrl_.getLastStartNb();
                                mdl_.StartNb = ctrl_.requestJustInTime(newStartNb);
                            }
                            else
                            {
                                if (mdl_.StartNb <= mdl_.Select.End && mdl_.Select.End <= (mdl_.StartNb + (nbColonne_ * nbLine_)))
                                    mouvementKeys((mdl_.NbLine * mdl_.NbColonne), false, mdl_.NbLine);
                                else
                                {
                                    Int64 newStartNb = mdl_.StartNb + mdl_.MinCache + (nbLine_ * nbColonne_);
                                    mdl_.Select.Begin = mdl_.Select.End = Math.Min(newStartNb + colonne_, ctrl_.getLastOffSet() - 1) - mdl_.MinCache;
                                    mdl_.StartNb = ctrl_.requestJustInTime(((Int64)(ctrl_.getVSB().Maximum) - 9) * nbColonne_);//BUG2 : 502
                                }
                            }
                            ctrl_.piedPage(this);
                        }
                        return true;
                        #endregion
 
                    case Keys.Home:
                        if (mdl_.Select.End != -1)
                        {
                            if (this.colonne_ != 0)
                                mouvementKeys((int)(-((mdl_.AbsoluteEnd) % nbColonne_)), false, 0);
                        }
                        return true;
 
                    case Keys.End:
                        if (mdl_.Select.End != -1)
                        {
                            if (this.colonne_ != (nbColonne_ - 1))
                            {
                                Int64 index = mdl_.AbsoluteEnd + nbColonne_ - ((mdl_.AbsoluteEnd) % nbColonne_) - 1;
                                if (index < ctrl_.getLastOffSet()) // test sur le cas limite : si la dernière ligne n'est pas complétement remplie
                                    mouvementKeys((int)(nbColonne_ - ((mdl_.AbsoluteEnd) % nbColonne_) - 1), false, 0);
                                else
                                    mouvementKeys((int)((ctrl_.getLastOffSet() % nbColonne_) - ((mdl_.AbsoluteEnd) % nbColonne_) - 1), false, 0);
                            }
                        }
                        return true;
 
                    case Keys.Delete:
                        // Test si la taille des données n'est pas trop grande (superieure à maxDataSize)
                        if (mdl_.Select.Count < maxDataSize_)
                            deleteCell();
                        else
                            MessageBox.Show("Taille de données très grande.\r\nAction annulée.", "Attention", MessageBoxButtons.OK, MessageBoxIcon.Hand);
                        return true;
 
                    case Keys.Insert://*\\
                        insert_ = !insert_; //change la valeur du boolean insert
                        ctrl_.setInsert(insert_);
                        return true;
 
                    default:
                        return false;//base.ProcessCmdKey(ref msg, keyData);
                }
            }
 
            mdl_.IsPersiste = true;
 
            return false;
        }

sinon quand je met pas de break point le programme n'appelle pas l'event KeyPress

Merci

Bien cordialement

Citation:

Envoyé par reeda

sinon quand je met pas de break point le programme n'appelle pas l'event KeyPress

OK, donc a priori je pense que c'est lié au fait que ton appli perd le focus quand le breakpoint est atteint... ça nous aide pas beaucoup, mais c'est un début :aie:

Sinon, je pense que dans ton ProcessCmdKey tu renvoies true dans un cas où tu devrais pas... mais j'avoue que le code est un peu indigeste pour que je le vérifie en détail, surtout qu'il y a des trucs spécifiques à ton appli que je ne comprends pas...

Citation:

Envoyé par tomlev

OK, donc a priori je pense que c'est lié au fait que ton appli perd le focus quand le breakpoint est atteint... ça nous aide pas beaucoup, mais c'est un début :aie:

Sinon, je pense que dans ton ProcessCmdKey tu renvoies true dans un cas où tu devrais pas... mais j'avoue que le code est un peu indigeste pour que je le vérifie en détail, surtout qu'il y a des trucs spécifiques à ton appli que je ne comprends pas...

coté focus, j'ai vérifié, avec quelques tests que tout est bon,
est ce que ce ne serait pas lié au fait que j'implémente ProcessCmdKey et KeyPress en même temps ?

Merci
bien cordialement

Citation:

Envoyé par reeda

coté focus, j'ai vérifié, avec quelques tests que tout est bon

Quel genre de tests ? Ce que je veux dire, c'est que quand le breakpoint est atteint, c'est Visual Studio qui prend le focus, donc ton appli le perd...

Citation:

Envoyé par reeda

est ce que ce ne serait pas lié au fait que j'implémente ProcessCmdKey et KeyPress en même temps ?

ça ne devrait pas poser de problème en principe...

Voilà en gros ce qui se passe quand tu appuies sur une touche (en très simplifié bien sûr) :

> Windows envoie un message WM_KEYDOWN
> ProcessCmdKey est appelé avec ce message en paramètre
> Si ProcessCmdKey renvoie false :
--> OnKeyDown traite le message WM_KEYDOWN
--> Si le KeyDown n'est pas Handled :
----> Windows renvoie un message WM_CHAR
----> Le message est traité par OnKeyPress
> Si ProcessCmdKey renvoie true : OnKeyDown n'est pas appelé, Windows n'envoie pas de WM_CHAR, et donc OnKeyPress n'est pas appelé
> Windows envoie un message WM_KEYUP
> OnKeyUp traite le message WM_KEYUP

Je sais pas si ça pourra t'aider à résoudre le problème, mais ça montre au moins que si ProcessCmdKey renvoie true pour une touche, OnKeyPress ne sera pas appelé...

Bonjour,

Citation:

Envoyé par tomlev

Quel genre de tests ? Ce que je veux dire, c'est que quand le breakpoint est atteint, c'est Visual Studio qui prend le focus, donc ton appli le perd...

j'ai fait d'autres tests sur d'autres composants pour lesquels le focus passe de l'un vers l'autre. Mais j'ai tout vérifié, de ce coté il n'y a aucun problème.
en ce qui concerne le point que t'as évoqué je pense que c'est aussi une piste à voir, mais je sais pas comment l'entamer :aie:

Citation:

Envoyé par tomlev

Je sais pas si ça pourra t'aider à résoudre le problème, mais ça montre au moins que si ProcessCmdKey renvoie true pour une touche, OnKeyPress ne sera pas appelé...

j'ai retourné false dans tous les cas qui présentent des situations non traitées par ProcessCmdKey, et rien n'a changé.

Merci
Bien cordialement