Discussion :

[mathmathou]

Bonjour à tous,

Afin de rendre mon application plus réactive et moins gourmande, seule ma Main Form et mon Datamodule sont créés au lancement de l'application, toutes les autres Forms sont créées dynamiquement et libérées quand plus utilisées.
Je procède de la manière suivante :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
procedure TfrmKeywords.BtNewKwClick(Sender: TObject);
var
  F_Kw_Mod : TfrmKwMod;
begin
  F_Kw_Mod := TfrmKwMod.Create(nil);
    try
      F_Kw_Mod.ShowModal;
    finally
      F_Kw_Mod.Free;
    end;
end;

Ici, une From F_Kw_Mod est créée (et libérée à sa fermeture) depuis une autre Form (F_Keywords) elle même précédement créée dynamiquement.

Cette Form (F_Kw_Mod) contient un TEdit et un Tbutton, pour la saisie de nouveaux enregistrements. Le click du bouton déclenche une série de vérifications (champ vide, doublon...) avant validation, enregistrement en base de données et fermeture de la Form.

Mon problème est le suivant : après un enregistrement réussi, je veux forcer le recalcule du nombre d'enregistrements dans un footer de ma DBGrid sur la Form précédente. Bien sur, je pourrais ajouter

Code :

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

DBGridEh1.SumList.RecalcAll;

juste avant l'appel de

Code :

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

 F_Kw_Mod.Free;

et cela fonctionnerait (je l'ai testé).

Ce que je voudrais savoir c'est comment accéder depuis ma seconde Form (créée dynamiquement) à un composant de la Form précédent (elle aussi créée dynamiquement) ?
Quand je tente d'y faire référence directement, j'ai droit à une belle "Application Exception" parce que je fais référence à "nil".
Alors savez-vous comment "partager" un composant et lui envoyer une commande depuis une autre Form en gardant à l'esprit (je sais que je me répète) qu'elles ont toutes les deux été créées dynamiquement (le simple ajout de l'unité à la use clause n'y change rien) ?

Merci d'avance


Math

[Lung]

Quand je tente d'y faire référence directement, j'ai droit à une belle "Application Exception" parce que je fais référence à "nil".

Tu t'y prends de quelle façon ?

[mathmathou]

Bonjour Lung et merci de t'être intéressé à ma question.

Je vais tenter d'être clair : j'ai donc deux Forms : frmKeywords et frmkwmod qui sont respectivement déclarées comme suit :
F_Keywords := TfrmKeywords depuis un ButtonClick de ma main Form
et
F_Kw_Mod := TfrmKwMod depuis un ButtonClick de frmKeywords
et créées dynamiquement comme exposé dans mon premier post.

Elles ne sont pas créées directement en frmKeywords ou frmKwmod pour éviter d'utiliser les variables globales que Delphi génère automatiquement entre Type et Implementation (que je pourrais effacer), et qui, semble t'il, sont le mal absolu .

Le problème est que si je les efface, je ne sais plus accéder à frmKeywords.dbgrideh1 depuis frmKwMod.

Et si je réactive ces variables, que ce soit F_Keywords ou frmKeywords, quand je tente un
FrmKeywords.dbgrideh1.sumlist.recalcall depuis frmKwMod, j'ai une AE.

Ces Forms sont créées avec Create(nil) car elles sont modales mais je n'arrive pas à interagir de la seconde sur un composant de la première.

Je me relis et ne suis pas certain d'avoir été très clair

[retwas]

Pour le Create(nil), le nil est simplement le Owner.

Tu pourrais utiliser les property ?

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
type
  TForm2 = class(TForm)
    procedure FormCreate(Sender: TObject);
    procedure FormShow(Sender: TObject);
  private
    FDBGrid: TDBGrid;
    function GetDBGrid: TDBGrid;
  public
    property DBGrid: TDBGrid read GetDBGrid;
  end;
 
var
  Form2: TForm2;
 
implementation
 
{$R *.dfm}
 
{ TForm2 }
 
procedure TForm2.FormCreate(Sender: TObject);
begin
   // initialisation de la variable
   FDBGrid := nil;
end;
 
procedure TForm2.FormShow(Sender: TObject);
begin
   // création de la grille
   FDBGrid := TDBGrid.Create(nil);
end;
 
function TForm2.GetDBGrid: TDBGrid;
begin
   // récupération de la grille
   Result := FDBGrid;
end;

Du coup depuis une autre fenêtre si tu crées une Form de type TForm2 tu auras accès à la grille.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
procedure TForm3.Button1Click(Sender: TObject);
var
   CurrentForm: TForm2;
begin
   CurrentForm := TForm2.Create(nil);
 
   try
      CurrentForm.ShowModal;
      CurrentForm.DBGrid; // <-- accès à la grille
   finally
      FreeAndNil(CurrentForm);
   end;
end;

[Paul TOTH]

Bonjour,

Je viens de rédiger un petit article sur la question

[mathmathou]

Bonjour à tous,

@Paul
Un article très instructif et intéressant en vérité, c'est toujours une satisfaction de faire, non plus parce que l'on vous a dit que c'était comme cela, mais parce qu'on a compris pourquoi.
Malheureusement, j'ai eu beau tourner et retourner cela dans tous les sens, je n'ai pas abouti à ce que je souhaitais. Le manque d'expérience à n'en pas douter

@retwas
malheureusement, même constat, je ne saisis pas encore tout parfaitement, et donc de là à l'appliquer...

Je vais tenter de m’expliquer de manière plus claire

Merci pour votre participation

Math

[mathmathou]

Alors, en essayant d'être plus précis, voici un petit schéma :



La Form 1 est la main Form, elle est créée automatiquement
La Form suivante (frmkeywords) est créée dynamiquement au click du bouton Keywods (1)
La dernière Form (frmKwMod la plus petite) est également créée dynamiquement au click du bouton "Add New Keyword" (2).

La Form frmkeyword et frmKwMod sont créées respectivement suivant la procédure suivante :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
procedure TfrmWelcome.BtKeywordsClick(Sender: TObject);
var
  F_Keywords : TfrmKeywords;
begin
  F_Keywords := Tfrmkeywords.Create(nil);
    try
      F_Keywords.ShowModal;
    finally
      F_Keywords.Free;
    end;
end;

et

Code :

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

1
2
3
4
5
6
7
8
9
10
11
procedure TfrmKeywords.BtNewKwClick(Sender: TObject);
var
  F_Kw_Mod : TfrmKwMod;
begin
  F_Kw_Mod := TfrmKwMod.Create(nil);
    try
      F_Kw_Mod.ShowModal;
    finally
      F_Kw_Mod.Free;
    end;
end;

Mais comme elles sont toutes les deux créées avec Owner nil, il n'y a pas de variable globale pour y accéder.

En fermant la Form frmKwMod, avant le "Close", je tente de déclencher un rafraichissement de la DBGrid de la fenêtre frmkeywords.
Mais impossible d'accéder à ce DBGrid, elle est sur une autre Form (frmKeywords) avec laquelle je suis incapable de créer une "passerelle".


Je continue à me creuser les méninges

Math

[Lung]

Si j'ai bien compris, voici un exemple qui marche :

Une form1 crée et affiche une form2 :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
procedure TForm1.Button1Click(Sender: TObject);
var
   MaForm2: TForm2;
begin
   MaForm2 := TForm2.Create(nil);
   try
      MaForm2.ShowModal;
   finally
      MaForm2.Free;
   end;
end;

Une form2 crée une form3, lui donne un pointeur d'elle-même, et l'affiche :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
procedure TForm2.Button1Click(Sender: TObject);
var
   MaForm3: TForm3;
begin
   MaForm3 := TForm3.Create(nil);
   try
      MaForm3.LaForm2 := Self;    // <-- Je lui donne un pointeur sur moi-même.
      MaForm3.ShowModal;
   finally
      MaForm3.Free;
   end;
end;

La form3 accède à la Form2 par le pointeur, et se ferme :

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
uses ... Unit2 ...
 
type
  TForm3 = class(TForm)
    Button1: TButton;
 
    procedure Button1Click(Sender: TObject);
 
  private
 
  public
    LaForm2: TForm2;      // Un pointeur sur la Form2.
  end;
 
...
 
procedure TForm3.Button1Click(Sender: TObject);
begin
   LaForm2.DBGrid.Refresh;     // <-- Je peux accéder à la Form2.
   Close;
end;

Bon, c'est juste pour te donner une idée, et t'aider à comprendre la solution de retwas.

[anapurna]

salut

vous vous compliquez la vie
il suffit de redéfinir la méthode de fermeture et dedans relancer le calcul

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
 
procedure TForm1.Button1Click(Sender: TObject);
var
   MaForm2: TForm2;
begin
   MaForm2 := TForm2.Create(nil);
   try
      MaForm2.Onclose := OnMyClose;
      MaForm2.ShowModal;
   finally
      MaForm2.Free;
   end;
end;
 
Procedure TForm1.OnMyClose(...);
begin
  // Ici je relance mon calcul 
end;

[tourlourou]

La solution d'anapurna respecte bien l'indépendance entre fiches : chacune s'occupe de ce qui la regarde !

[Hermite]

Bonjour,
pour le cas qui t'intéresse, je ferais comme ceci :

Sur le clic du bouton "BtNewKw" :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
procedure TfrmKeywords.BtNewKwClick(Sender: TObject);
begin
	// AddKeyWord est définie en tant que fonction autonome de "frmKwMod"
	if AddKeyWord(GridKeyWord.Datasource.Dataset) then
	begin
		// Traitement à exécuter après enregistrement effectif
		// en l’occurrence le recalcul du footer de la grille
	end;
 
end;

Dans l'unité "UfrmKwMod" :

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
 
// On définit la fonction AddKeyWord entre le bloc Type et le bloc Var au dessus de Implementation
 
function AddKeyWord(ADataSet:TDataset);
 
// Dans la partie implémentation
 
function AddKeyWord(ADataSet:TDataset);
begin
	Result := False;
	with TfrmKwMod.Create(nil) do  
	try
		Showmodal;
 
		if ModalResult = mrOk then
		begin
			// traitement à faire à la fermeture si l'utilisateur à cliqué sur le bouton Save
			// la propriété ModalResult du bouton save étant elle-même sur mrOk
			// on peut accéder au DataSet de la grille KeyWord puisqu'il est passé en paramètre de la fonction
			// Par exemple :
			ADataSet.Insert;
			ADataSet.FieldByname('KEY_WORD').AsString := EditKw.Text;
			ADataSet.Post;			
		end;
 
	finally
		Free;
	end;
end;

Il y a de nombreuses solutions à ton problème en fait.
Tu peux modifier l'exemple ci-dessus pour passer en paramètre de la fonction la form frmKeywords. En ajoutant l'unité UFrmKeyWords dans les uses après la partie implémentation de l'unité frmKwMod tu auras ainsi accès à tous les composants. Cependant cela risque de rendre ton code plus compliqué à suivre.

[Paul TOTH]

La solution d'anapurna respecte bien l'indépendance entre fiches : chacune s'occupe de ce qui la regarde !

elle présente juste un défaut...si quelqu'un décide d'utiliser l’événement Onclose de la fiche depuis la fiche elle même, ce code ne sera plus invoqué.

pour être strict, il faudrait alors dériver TForm2 pour surcharger sa méthode close...ce qui rend la solution tout de suite moins immédiate

[tourlourou]

C'est juste ; ce que je voulais signaler comme pertinent dans ce schéma est d'utiliser une CallBack : la fiche appelée déclenche quand on appuie sur son bouton "save" un traitement réalisé par la fiche appelante, dont elle n'a pas à connaître la mécanique.

[anapurna]

salut

j'ai pris le onclose comme exemple de callback
mais il est préférable de faire c'est propre événement

[mathmathou]

Tout d'abord, un grand merci à tous, mon problème est solutionné grâce à vos exemples et vos conseils, et j'ai "presque" l'impression de comprendre pourquoi
Ensuite mes excuses pour le décalage dans mes réponse. Je vis en Nouvelle Calédonie : je bosse quand vous dormez et vice-versa.

La solution retenu est celle de Lung avec ses pointeurs. Pourquoi ?

Parce que la solution proposée par anapurna, qui est la plus courte, est aussi celle à laquelle j'étais parvenu seul en faisant :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
procedure TfrmKeywords.BtNewKwClick(Sender: TObject);
var
  F_Kw_Mod : TfrmKwMod;
begin
  F_Kw_Mod := TfrmKwMod.Create(nil);
    try
      F_Kw_Mod.ShowModal;
    finally
      DBGridEh1.SumList.RecalcAll;
      F_Kw_Mod.Free;
    end;
end

C'est assez élégant et surtout simple, mais je voulais comprendre pourquoi l'autre approche ne fonctionnait pas (j'aurai par la suite besoin d'accéder à d'autres composants).

L'approche d'Hermite ressemble à celle de anapurna en plus complète et un peu plus difficile à digérer à cause de mon niveau "grand débutant".
L'approche de Retwas ressemble à celle de Lung, mais fait appel au properties avec lesquelles je suis loin d'être à l'aise.

Quant à Paul, je vais creuser son article à propos des helpers et des Interfaces.

En tous cas, merci à tous pour votre participation et votre patience. Il y a de grosses chances pour que je revienne vous "enquiquiner"

Math