Newsgroup: it.comp.lang.delphi
Titolo: Visibilità variabili in diverse unit

Ciao a tutti,
Vorrei accedere ad una variabile settata in una form da un'altra form
creata dalla prima.
E' forse contorto... mi spiego con un esempio banale...
In un applicazione SDI visualizzo il form con un campo edit, scrivo
qualcosa e schiaccio il bottone.
Il bottone crea una nuova form a cui viene passata quello che c'è
scritto in edit.text (che magari ho salvato in una variabile _nome_) e
nella form viene scritto il contenuto della variabile _nome_
ShowMessage lo conosco :) è solo per capire come posso fare a passare
delle varibili tra le varie form
Grazie a tutti

Beh di metodi ne esistono vari....
mettiamo che hai:
Unit1.pas che contiene
Oggetto1 = Class
end;
e Unit2.pas che contiene
Oggetto2 = Class
end;
e vuoi da Oggetto2 vedere delle variabili poste in Unit1 (o Oggetto1) - 
mettiamo per esempio che vuoi vedere la variabili Stringa1 di tipo String
quindi vediamo alcuni metodi:
1) Creazione di una unit chiamata, ad esempio, tipi.pas che contiene le 
variabili che ti servono. Questa unit dovrà essere inclusa nella clausola.
Unit Tipi.pas
Interface
Var
   Stringa1 : String;
Implementation
End;
2) La variabile la dichiari direttamente in Unit2 prima della 
dichiarazione dell'oggetto ed includi Unit1 in Unit2
Unit Unit1;
Interface
Var
   Stringa1 : String;
Type
   Oggetto1 = Class
   End;
....
3) La variabile Stringa1 è dichiarata nella sezione public di oggetto1 
(ovviamente Unit1 dovrà essere inclusa in Unit2)
Unit Unit1;
Interface
Type
   Oggetto1 = Class
   public
      Stringa1 : String;
   End;
....
4) La variabile Stringa1 è dichiarata nella sezione private di oggetto1 
ed è dichiarata una proprietà di lettura/scrittura di questa variabile 
(ovviamente Unit1 dovrà essere inclusa in Unit2)
Unit Unit1;
Interface
Type
   Oggetto1 = Class
   private
      Stringa1 : String;
   puplished
      MiaStringa : String Read Stringa1 Write Stringa1;
   End;
....
Con gli oggetti il quarto metodo è il migliore in quanto puoi chiamare 
delle procedure per la lettura/scrittura controllando gli 
input/output... mi spiego meglio con un esempio:
Oggetto1 ha al suo interno un oggetto TEdit. Si vuole avere la 
possibilità di esportare, in un altro oggetto, il campo Text di questo 
edit e, si vuole avere la possibilità di riempire tale campo basta che 
il valore non sia una stringa vuota.
Quindi avremo
Type
   Oggetto1 = Class
   Edit1 : TEdit
   private
      function  Leggi_Stringa : String;
      procedure Scrivi_Stringa(Valore : String);
   puplished
      MiaStringa : String Read Leggi_Stringa Write Scrivi_Stringa;
   End;
implementation
   function Oggetto1.Leggi_Stringa : String;
   Begin
     Result := Edit1.Text;
   End;
   procedure Scrivi_Stringa(Valore : String);
   begin
     If Valore <> '' Then Edit1.Text := Valore;
   end;
Ora basta che includi Unit1 in Unit2 e chiami il metodo con 
Oggetto.MiaStringa.
Spero di essere stato abbastanza chiaro.
Ciao,
David
Simpz ha scritto:


> Vorrei accedere ad una variabile settata in una form da un'altra form
Devi usare _uses_ dove vuoi, nelle dichiarazioni della unit.
Ciao
Mario
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

Grazie a tutti
Ciao
c'è anche un altro modo; dichiarare la stessa variabile nella sezione Public della Unit figlia
e inizializzarla DOPO la creazione della Unit e PRIMA della sua esecuzione.
Ad esempio ha una vairabile  UTENTE di tipo string definita
sia nel pas "padre" che nel pas "figlio"
Nel figlio:
Public   // deve essere dichiarata nell'area public
  UTENTE: string;
ecc..
Dal padre farai qualcosa del genere
figlio:=Tfiglio.Create(self);
figlio.UTENTE:=UTENTE;   //qui passi la variabile
figlio.showmodal;
figlio.free;
ecc..
Questo sistema ha il duplice vantaggio di non avere le Uses incrociate e di autodocumentarsi.
Ciao
C. 

 creata dalla prima. [...]
Credo che la soluzione più efficace e meno dispersiva sia inserire un 
metodo nel Form secondario che accetti come parametro la stringa passata 
dal primo Form, qualcosa di simile a questo:
    procedure TForm2.ShowWithParam(AParam: string);
    begin
      // Fai qualcosa con il parametro...
      // ...
      // Visualizza il Form
      Self.Show();
    end;
Il codice del primo Form, cioè il Form chiamante, potrebbe essere simile 
al seguente:
    procedure TForm1.Form2ButtonClick(Sender: TObject);
    var
      Frm: TForm2;
    begin
      Frm := TForm2.Create(nil);
      try
        Frm.ShowWithParam(Edit1.Text);
      finally
        Frm.Free;
      end;
    end;
In breve, introduci nel Form secondario un metodo aggiuntivo e 
personalizzato che accetti come parametro il valore stringa da 
utilizzare a piacimento e che visualizzi in seguito lo stesso Form 
usando i metodi Show() oppure ShowModal().
Il Form primario si limita, alla pressione di un pulsante, o alla 
generazione dell'evento che ritieni opportuno, a creare il Form 
secondario e ad invocare il metodo personalizzato di cui sopra, passando 
il valore che il Form secondario deve utilizzare prima di visualizzarsi.
Il concetto può essere all'occorrenza modificato a seconda dei casi e 
delle necessità.
Ciao,
   Marco.
-- 
MARCO BREVEGLIERI
  (
http://www.marco.breveglieri.name
)