Normalement non, la ^mémoire peut être lue et écrite en même temps.

Bonsoir,

C'est normal car dans le Hook on récupère le code virtuel de touche et non pas le caractère. Il faut tenir compte de l'état de Shift, Ctrl et Alt pour en déduire la touche exacte (Ces états sont aussi donnés dans le hook)

=> Tigris1.
Ton approche est bonne mais la solution imparfaite.
Le (1) est inutile voire dangereux, car le TEdit que tu crées ne sera pas celui que tu vas détruire. Vu que ta variable Edit va contenir le dernier TEdit sélectionné par ta ligne Edit := TEdit(FindComponent('Edit' + IntToStr(nCount)));
Edit n'a nullement besoin d'être instancié avant l'appel de FindComponent. Il suffit juste de vérifier (comme tu le soulignes) le <> de nil avant de l'utiliser.

Pas grand intéret. Surtout si le Dataset est important. Pas de mise à jour automatique en fonction des données ( cas de plusieurs PC/applications ).

Ne déplace pas l'enregistrement courant, et donc ne facilite pas les modifs sur la ligne en cours.

Dans tous les avantages que tu donnes dans ton commentaire, tout peut se faire dans le DBGrid et sans que ce soit plus compliqué.

Trois remarques.
- Le case avec les 101 cas, ce n'est pas top. Utilise plutôt un tableau constant
- Le code n'est pas indenté correctement
- Le code peut se simplifier énormément avec un méthode récursive tout en gardant ta logique :

function Centaine (i: integer) : String; { NOM DES CHIFFRES }
begin
  case i of
   1..100: Result:=chif(i);
   101..199: Result:=' cent ' + Chif(i mod 100);
   200..999: case (i mod 100) of
              0:  Result:=Chif(i div 100) + ' cent';
              1..99:  Result:=Chif(i div 100) + ' cent ' + Chif(i mod 100);
             end;
   1000..999999: case (i div 1000) of
                1: Result:=' mille '+ Centaine(i mod 1000);
                2..999:Result:=Centaine(i div 1000)+' milles '+ Centaine(i mod 1000);
                end;
   1000000..999999999:  Result:= Centaine(i div 1000000)+' millions '+ Centaine(i mod 1000000);
  end;
end;

procedure TForm1.Button1Click(Sender: TObject);
var i:Int64;
begin
  i:=StrToInt64(edit1.Text);
  if (i <= 999999999) then
    edit2.Text:= Centaine(i)
  else
    edit2.Text:= Centaine(i div 1000000000)+' milliards '+ Centaine(i mod 1000000000);
end;

Tout sauf optimisé ton code :wink:

Il ne faut pas utiliser Power(xxx,0.5) mais SQRT()
Il ne faut calculer le SQRT qu'une seule fois au début de boucle car il ne change pas.
Il ne faut pas faire trop de processMessages, ça perd un temps fou.
Il ne faut pas mettre à jour la liste à chaque fois, mais seulement une fois sur N  ou sur demande ( touche ou sortie ). La mise à jour de la liste est énormement plus longue que le calcul d'un nombre.

--> Delphiprog
Je ne proposait cette méthode que pour la faire coonnaitre. J'utilise régulièrement la création dynamique et quand ce n'est que pour quelques objets j'utilise bien sur le transtypage et les objet existants ( TComponent.Components, TWinControl.Controls ).

Mais dans le cas d'un grand nombre avec des besoin particulier un héritage est bien mieux adapté.

PS : je viens te voir ici vu que l'on ne te vois pas beaucoup là ba. :wink:

Merci je sais la différence entre un Whiol et un repeat....

Regarde ma solution de près et tu veras que le code Repeat Until n'est appelé que si le If est vrai. Le traitement ne seront donc bien effectué que sur le premier élément.

Pour ta solution
procedure SetList(List : TStrings);
var TMPLIST : TStringList;
begin
  try
    TMPLIST := TStringList.Create;
    ...
    TMPLIST.Add(...);
    ...
    List.Assign(TMPLIST);
  finally
    TMPLIST.Free;
  end;
end;

La création est inutile ici.
procedure SetList(List : TStrings);
begin
  list.Clear
  List.Add(...);
end;

Pour répondre à un point au dessus aussi, tu dis que le résultat est libéré car c'est une variable locale. C'est FAUX. Seules les chaines et les tableaux dynamiques sont dans ce cas, dans tous les autres c'est à toi de le gérer.

"la création dynamique de compos est toujours d'actualité?"
Imagine une visionneuse de diapos miniatures, par exemple...

Exactement, et il y a des tas d'autres cas... Je rejoints DelphiProg sur les TObjectList. Tu dérives une classe descendante de TObjectList ou même un TComponentList et tu n'as plus rien à transtyper non plus.

Deux trucs. FindFirst et FindNext ça s'utilise avec un repeat until, le findclose ne doit être fait que si le FindFirst réussi.
If FindFirst()=0 Then
Begin
  Repeat
    // Le code de gestion d'une occurence ici et seulement ici
  Until FindNext()<>0;
  FindClose()
End;

Le deuxième truc encore plus moche c'est le GetSelection:TStringList. Une grosse fuite de mémoire en perpective car il faut détruire la liste retournée par la fonction ce que personne ne fera... Regarde dans le code de la VCL pour voir comment sont gérées les propriétés de type TStrings. Ta méthode ne gère pas non plus les éventuelles erreur de durant le code entre la création de la liste et sa destruction.

Si vraiment tu veux faire une fonction que retourne un TStrings il faut faire comme suit :
Proceudre GetSelection(Selection:TStrings);
Begin
  // Pas de create ici
End;
L'appel :
MaListe := TStringList.Create;
Try
  GetSelection(MaListe);
  // Traitement de la liste
Finally
  MaListe.Free;
End;