Newsgroup: it.comp.lang.delphi
Titolo: Controllo rientro form chiamato

Salve
normalmente nelle mie applicazioni
dal menu apro le form con i seguenti:
   GestioneXXXForm:=TGestioneXXXForm.Create(Self);
   GestioneXXXForm.ShowModal;
   GestioneXXXForm.Free;
   GestioneXXXForm:=nil;
e fin qui tutto beneo almeno sembra   :-)
Volevo sapere se e come è possibile "sapere" in maniera
centrallizzata QUANDO rientro nel menu, quindi
quando termina in questo caso GestioneXXXForm
per poter effettuare delle attività di tipo centralizzato.
Grazie
C. 

 per poter effettuare delle attivit` di tipo centralizzato.
Che cosa intendi per "QUANDO rientro nel menu"?
Dopo a ShowModal sei sicuro che l'utente abbia chiuso la form, per cui
puoi, ad esempio, richiamare una funzione "centralizzata" che deve
gestire il tuo codice.
-- 
Vuoi distribuire il tuo sito web su CD/DVD?
Prova 
http://www.dwebpro.com/
Vuoi diventare un esperto analista PHP/MySQL?
Vieni a fare uno stage con noi: 
http://www.creativepark.it/stage/

 gestire il tuo codice.
Grazie Filippo
cercherň di spiegarmi meglio.
Al rientro da una chiamata ad una form ho bisogno di fare certe cose dolpo 
la Free
Vorrei evitare di inserire OGNI VOLTA le stesse istruzioni o inserire uba 
chiamata
tipo  FunctionFaiquesto(xxx)
Sarebbe utile che la MainForm avesse un evento per il "rientro" ma credo non 
esista
almenonon in maniera evidente perchč le ho provate tutte e non l'ho trovata.
Quindi forse la domanda corretta era:
esite un evento per il rientro al programma chiamato ?
Uso D7
Grazie
C.

>>
Col .Free dovrebbe attivarsi l'evento OnDestroy della tua GestioneXXXForm.
In alternativa puoi usare anche l'OnClose, giorgio 

 ha scritto nel messaggio 
news:48639360$0$17935$5fc...@news.tiscali.it...

Ciao
Il Free scatena l'evento sulla SubForm e non sulla MainForm e quindi non lo 
"acchiappo"
da Main; idem per OnClose;
C. 

 non lo "acchiappo" da Main; idem per OnClose;
Crei nella Main un evento e lo richiami dall'OnClose/OnDestroy della
SubForm.


 -- 
E' la stessa cosa che scrivere dentro Main
la chiamata ad una funzione dopo ogni Free.
Servirebbe un evento Main:.OnBeforeShowModal
e uno OnAfterShowModal
Grazie cmq.
C. 

 la chiamata ad una funzione dopo ogni Free.
No, non e la stessa.


camperos ha scritto:


No, non e' la stessa cosa.
PS: se hai certe necessità stai sbagliando qualcosa nella progettazione
della tua applicazione, legandoti troppo all'interfaccia utente.
Ciao
ACSH
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 ACSH
e perchè ??? che ne sai della mia applicazione che fa.... e PERCHE cercavo
(ormai ho capito che non cè) una soluzione diversa a ripetere decine di 
volte la stessa istruzione ?
La domanda non era retorica ma pratica...
Grazie cmq per aver risposto
C.

 decine di volte la stessa istruzione ?
La soluzione proposta NON richiede di ripetere decine di volte la
stessa istruzione.
-- 
Vuoi distribuire il tuo sito web su CD/DVD?
Prova 
http://www.dwebpro.com/
Vuoi diventare un esperto analista Delphi?


e perchč ??? che ne sai della mia applicazione che fa....
Certi sbagli architetturali si deducono dalle domande di alcuni
(molti) su come risolvere certi problemi. Uno chiede in un ng come far
ruotare su sé stesso un appartamento; gli si chiede di rimando perché
vuol farlo; obiezione di rito: a che ti serve sapere perché lo voglio
fare?. 
Probabilmente non ha mai pensato che per avvitare una lampadina basta
lasciar ferma la stanza e ruotare la mano.
Se vuoi una risposta concreta e fattiva, descrivi il problema di base
che stai cercando di risolvere, non chiedere come realizzare la tua
particolare (probabilmente errata) soluzione.

 volte la stessa istruzione ?
ma la soluzione di Filippo non è proprio ciò che ti occorre?
prevede di scrivere una funzione (una sola volta) che viene richiamata ogni 
qualvolta è necessario...non vedo altre strade + ottimizzate
ma forse quello che intendi tu è se esiste un metodo per non scrivere *la 
chiamata* alla funzione da ogni form?
V

 non scrivere *la chiamata* alla funzione da ogni form?
Se la implementi tramite ereditarieta', non seve nemmeno scriverla in
ogni form. Basta implementarla nel metodo DoDestroy()/DoClose() della
form base e le form figlie richiameranno l'evento/metodo
automaticamente senza dover aggiungere una sola riga di codice.
-- 
Vuoi distribuire il tuo sito web su CD/DVD?
Prova 
http://www.dwebpro.com/
Vuoi diventare un esperto programmatore Delphi?



Esatto.
L'applicazione è costituita (ormai) da una main form che chiama 
(crea-esegue-distrugge) MOLTE form
in modalità Showmodal.
OGNI volta che le crea deve  fare delle cose e ogni volte che l'utente le 
chiude deve fare altre cose.
Il  perchè non ha nessuna importanza; è ovvio che è un requisto 
dell'applicazione.
Sarà stupido, ma per me il modo più immediato è subito PRIMA e subito DOPO 
la creazione-distruzione della form
nel MAIN inserire o le istruzioni o la chiamata di una procedura che fa 
quello che deve fare.
Se queste istruzioni, supponiamo siano 40 form, le scrivo nel main ogni 
volta che chiamo la form o le scrivo
dentro la form il mio sforzo è lo stesso: fare 40+40 volte la stessa noiosa 
operazione di copia incolla.
Se le metto nel Mainform il tutto è più leggibile e concentrato in un punto 
e quindo lo preferisco
al modiifcare l'entrata e l'uscita di ogni form gestendo i due eventi 
iniziale e finale. Mi risulta più facile la
manutenzione tra qualche mese quando magari dovrò aggiungere altre funzioni.
Se fosse esistito un evento del tipo "OnBeforeModal..."  le istruzioni le 
scrivevo una volta sola nel main.
Purtorppo non cè;  l'unico modo è farlo io a mano implementando una nuova 
form main che abbia
queste caratteristiche.
Spero di essere stato chiaro.
Grazie a tutti per il contributo
C. 

 
Guarda che tu vuoi fare quello che ti ha suggerito Filippo:
"Se la implementi tramite ereditarieta', non seve nemmeno scriverla in
ogni form. Basta implementarla nel metodo DoDestroy()/DoClose() della
form base e le form figlie richiameranno l'evento/metodo
automaticamente senza dover aggiungere una sola riga di codice."
Non solo gli eventuali eventi che vorresti "OnBeforeModal..." potrebbero 
essere implementati nella childform che vuoi chiamare e non nella 
MainForm come tu vorresti. Solo così avrebbero un senso.
Ciao.

 iniziale e finale.
Vedi un pò se non ho mal interpretato la tua esigenza e se adattandolo, non 
dimenticarti i try che altrimenti ci linciano  :-) , è quello che serve a te
************************************************
unit Unit1;
interface
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;
type
  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    Label1: TLabel;
    procedure FormShow(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  private
    { Private declarations }
    procedure OpenModal(Sender: TObject);
    procedure CloseModal(Sender: TObject);
  public
    { Public declarations }
  end;
var
  Form1: TForm1;
implementation
uses Unit2, Unit3;
{$R *.dfm}
procedure TForm1.OpenModal(Sender: TObject);
begin
  label1.Caption := 'Apro una form qualsiasi in modale';
  // tutte le operazioni che voglio ma uguali ad ogni
  // apertura di qualsiasi form in modale
end;
 procedure TForm1.CloseModal(Sender: TObject);
begin
  label1.Caption := 'Chiudo la form modale';
  // come sopra alla chiusura di ogni form modale
end;
procedure TForm1.Button1Click(Sender: TObject);
begin
  label1.Caption := '';
  form2.ShowModal;
end;
procedure TForm1.Button2Click(Sender: TObject);
begin
  label1.Caption := '';
  form3.ShowModal;
end;
procedure TForm1.FormShow(Sender: TObject);
begin
  application.OnModalBegin := form1.OpenModal;
  application.OnModalEnd := form1.CloseModal;
end;
end.
********************************************* 


Se il tuo scopo č quello di scrivere meno righe possibili puoi provare 
se ti va bene questo:
unit Unit1;
interface
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, 
Forms,
  Dialogs, StdCtrls;
type
  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  private
    { Private declarations }
    Function ShowModalForm(NewFormClass: TformClass): Integer;
    Procedure EsecuzioniPrima;
    Procedure EsecuzioniDopo;
  public
    { Public declarations }
  end;
var
  Form1: TForm1;
implementation
Uses Unit2, Unit3;
{$R *.dfm}
Procedure TForm1.EsecuzioniPrima;
Begin
  MessageBeep(0);
End;
Procedure TForm1.EsecuzioniDopo;
Begin
  MessageBeep(0);
End;
Function TForm1.ShowModalForm(NewFormClass: TFormClass): Integer;
var
  FM: TForm;
Begin
  Try
    FM:= NewFormClass.Create(Self);
    EsecuzioniPrima;
    Result:= FM.ShowModal;
    EsecuzioniDopo;
  Finally
    FreeAndNil(FM);
  End;
End;
procedure TForm1.Button1Click(Sender: TObject);
begin
  ShowModalForm(TForm2);
end;
procedure TForm1.Button2Click(Sender: TObject);
begin
  ShowModalForm(TForm3);
end;
end.
--- posted by geoForum on 
http://www.delphiedintorni.it

Grazie a Zaleuco e Valter per la generosa disponibilità
Prenderò spunto dai vostri utili suggerimenti.
Grazie anche a Filippo per i suggerimento sull'ereditarietà.
Mò mi tocca lavorare, non ho più scuse !
ciao
C

 dell'applicazione.
Ti sbagli. Il perché ha SEMPRE un'importanza fondamentale. Hai la strana
presunzione che il tuo approccio alla soluzione sia in assoluto il
migliore. 
Allora che chiedi a fare? 
Se chiedi aiuto, devi anche essere disposto a mettere in discussione i
motivi di base di certe scelte.


 ha scritto nel messaggio 
news:xIM8k.105595$FR.3...@twister1.libero.it...

Se l'evento richiama una procedura della MainForm mi sembra che ottieni 
quello che ti serve.. se non ho capito male, Giorgio