1) Nell'uso di funzioni da richiamare fra Classi e Moduli è opportuno attribuire un nome privo di trattino in basso.
Pertanto nella Classe Form2.class bisognerà modificare la funzione passdati() come segue:
Private Sub passdati(string1 As String, string2 As String)
Form1.PassaDati(string1, string2)
End
così, nella Classe Form1.class la funzione passa_dati() assumerà il nome: PassaDati()
2) nella funzione PassaDati() della Classe Form1.class il Form1 va richiamato attraverso la sua variabile di tipo Form1, dichiarata e creata nella Classe principale. La proprietà .Text del TextBox va utilizzata ripercorrendo l'intera gerarchia.
Pertanto questa funzione sarà così modificata:
Public Sub PassaDati(dato1 As String, dato2 As String)
FMain.Frm1.TextBox1.Text = dato1
FMain.Frm1.TextBox2.Text = dato2
End
3) La dichiarazione della variabile di tipo Form1 va posta come Globale e Pubblica:
Ciao Tornu,
guardando un po al passato ho constatato che non è la prima volta che ti “picchi” con questi concetti. Questo mi ha permesso di comprendere che anche io non capivo. :)
Ho fatto un paio di esperimenti che sottopongo a te e a tutti gli uomini e donne di buona volontà per avere dei pareri così se vorrete potrete evitarci delle brutte figure con la stesura del libro.
Sembra proprio che le finestre siano delle classi speciali, infatti puoi aggiungere delle proprietà senza il bisogno di ereditarle. Anzi pare proprio che non si debbano ereditare.
Posto e allego due esempi, il secondo prende spunto da quanto suggerito da vuott, il primo ricorre come detto alle proprietà.
In tutti e due gli esempi occorre creare due finestre la FMain con due label riquadrate e testo centrale rinominate rispettivamente lblNome e lblCognome e un pulsante non rinominato (Button1).
La seconda finestra rinominata Form2 con due TextBox (1 e 2) e un Pulsante (Button1).
Questo il codice del primo esempio (per i principianti rammento che non bisogna cancellare questa scritta dal modulo di classe: ' Gambas class file):
Codice Finestra Fmain:
' Esponendo queste proprietà consentiamo alle altre finestre
' di inviarci dei dati che possiamo controllare prima di esporli.
' NB: In qualunque modo noi cambieremo in futuro il controllo
' interno dei dati questo non inciderà sul passaggio stesso.
Property sNome As String
Property sCognome As String
Private $sNome As String
Private $sCognome As String
Public Sub _new()
End
Public Sub Form_Open()
Me.Center
End
Private Function sNome_Read() As String
' Restituisce il valore controllato da Write.
Return $sNome
End
Private Sub sNome_Write(Value As String)
' Legge il valore, lo controlla (!?) per poterlo restituire corretto
If Value <> "" Then
$sNome = Value
Else
$sNome = "#Dato mancante"
Endif
End
Private Function sCognome_Read() As String
Return $sCognome
End
Private Sub sCognome_Write(Value As String)
If Value <> "" Then
$sCognome = Value
Else
$sCognome = "#Dato mancante"
Endif
End
Public Sub Button1_Click()
' La finestra in modalità dialogo (ShowDialog) o modale (ShowModal) stessa cosa significa che fino a quando non l'abbiamo chiusa
' non permetterà al programma di andare avanti. Questo metodo termina solo quando la finestra è chiusa, e il valore intero
' passato al metodo Close viene restituito.
Form2.ShowDialog
'' NB: Se noi passiamo una finestra non modale queste istruzioni
'' non verranno eseguite.
lblNome.Text = Me.sNome
lblCognome.Text = Me.sCognome
End
Codice Finestra Form2:
Public Sub Form_Open()
Me.Center
End
Public Sub Button1_Click()
Me.Close
End
Public Sub Form_Close()
' Usiamo il metodo Close per passare i dati comunque,
' anche in caso di chiusura della finestra.
With FMain
.sNome = TextBox1.Text
.sCognome = TextBox2.Text
End With
End
E questo il secondo esempio:
Codice finestra Fmain:
Public Sub Form_Open()
Me.Center
End
Public Sub Passameli(sNome As String, sCognome As String)
lblNome.Text = sNome
lblCognome.Text = sCognome
End
Public Sub Button1_Click()
' La finestra in modalità dialogo (ShowDialog) o modale (ShowModal) stessa cosa significa che fintanto che non l'abbiamo chiusa
' non permetterà al programma di andare avanti. Questo metodo termina solo quando la finestra è chiusa, e il valore intero
' passato al metodo Close viene restituito..
' La finestra in modalità normale (Show) è senza priorità.
' NB: Se la finestra già aperta è modale, allora la finestra verrà
' visualizzata comunque in modalità modale anche se chiamata con Show.
'Form2.ShowDialog
Form2.Show
End
Questo il codice della finestra Form2:
Private $sNome As String
Private $sCognome As String
Public Sub Form_Open()
Me.Center
End
Private Sub Nome()
' Legge il valore della textbox, lo controlla (!?) per poterlo restituire corretto
If TextBox1.Text <> "" Then
$sNome = TextBox1.Text
Else
$sNome = "#Dato mancante"
Endif
End
Private Sub Cognome()
If TextBox2.Text <> "" Then
$sCognome = TextBox2.Text
Else
$sCognome = "#Dato mancante"
Endif
End
Public Sub Button1_Click()
Me.Close
End
Public Sub Form_Close()
' Usiamo il metodo Close per passare i dati comunque
' anche in caso di chiusura della finestra.
' Chiamiamo i metodi che controllano le textbox e
' restituiscono il valore alle variabili private
Nome()
Cognome()
' Passiamo direttamente il valore alle label
' della FMain attraverso il metodo pubblico.
FMain.Passameli($sNome, $sCognome)
End
Lo so è un post molto lungo e visto gli allegati lo potevo risparmiare ma credo ci siano gamberetti timidi che prima di iscriversi vogliono capire un po quindi...
Ora però vado ad ubriacarmi e ad ingozzarmi... Buona Vigilia a Tutti.
:ciao:
PS: Mi sono scordato di precisare che tu questo lo sai già fare, era che volevo metterlo giù per il libro. Se torno sobrio poi studio il tuo caso con quello che qui è stato già detto.
Ciao ragazzi,
essendo stato moderato col vino (neanche 4 quartini) vi posso aggiornare sul codice precedente per ottenere il passaggio di dati fra tre form (In effetti come giustamente dice il titolo il passaggio è fra 2 con coinvolta la FMain) cambiando leggermente i progetti PassaggioFraFinestre_1 e 2 :
L'attuale FMain diventa Form1
Aggiungiamo una form al programma rinominandola Fmain facendola diventare Classe di avvio. Quindi scriviamo al suo interno questo codice:
Public Frm1 As Form1
Public Sub Form_Open()
Frm1 = New Form1(FMain) As "Frm1"
FMain.Title = "Form1"
Me.Center
End
Poi solo in PassaggioFraFinestre_1 occorre:
La Form1 ex Fmain rimane invariata e nella Form2 andiamo a inserire nel metodo di chiusura
With Fmain.Frm1 'al posto del solo With FMain
lasciando invariato il resto del codice.
Invece per PassaggioFraFinestre_2 occorre:
La Form1 ex Fmain rimane sempre invariata e nella Form2 andiamo a inserire sempre nel metodo di chiusura il riferimento Frm1 fra FMain e Passameli così:
FMain.Frm1.Passameli($sNome, $sCognome)
Bene ora che mi sono svegliato vado a dormire. :sleepy:
:ciao:
PS: Malgrado lo credessi non ero poi così sobrio :).
Ti vorrei chiedere se mi puoi spiegare il motivo che ti spinge a “camuffare” una form per un'altra.
Mi pare che ancora, pur essendo andati avanti coi ragionamenti e lo studio del materiale citato, non sia chiaro come costringere la form chiamata a restituire dati alla Form chiamante e come recepire detti dati quando la Form chiamante riprenderà il controllo del ciclo elaborativo.
Diciamo subito che il Form chiamante non deve essere necessariamente il FMain, ma può essere anche uno successivo, dipendente o meno dalla FMain. Il trucco per ottenere lo scambio dati sta nel tipo dati della variabile da passare al Form chiamato. Se i dati da passare e da ricevere indietro sono più di uno conviene costituire un array di un numero imprecisato di elementi. Essi saranno valorizzati al momento della chiamata e probabilmente non saranno di natura omogenea, percò:
Dim vDati As New Variant[]
Dim iSwReturn as integer
Il secondo passo importante è quello di richiamare il costruttore della nuova classe FormX da chiamare:
seguito dalla classica istruzione di chiamata della Form, rispettando il seguente formato:
iSwReturn = Frm7.showmodal()
In quest'ultima istruzione risiede la chiave risolutiva del meccanismo di andata e ritorno dei dati, perchè, al ritorno dal Form chiamato, l'array di partenza, vDati, conterrà non più i valori ceduti al programma chiamato, bensì quelli che quest'ultimo avrà modificato o anche aggiunto a quelli iniziali.
Supponiamo perciò di avere fornito due campi coi seguenti valori
$Strimia = "andata"
iNum = 111
vDati.add($Strimia)
vDati.add(iNum)
Supponiamo ancora che il Form chiamato, nel corso della sua esecuzione, abbia modificato il contenuto di vDat[0] ed abbia aggiunto un valore booleano come terzo campo. Al rientro dalla chiamata del FormX l'array sarà così costituito:
vDati[0] = "ritorno"
vDati[1] = 111
vDati[2] = 0 'False
La prima istruzione dopo quella di chiamata della FormX sarà:
Select Case iSwReturn
Case 0
print vDati[0]
Case 1
print vDati[1]
Case 2
print vDati[2]
End Select
Spero di avere dato il giusto aiuto per un corretto uso del metodo che ho imparato a suo tempo ed assimilato grazie alla paziente guida di md9327.
:ciao:
Non ho capito l'utilità della variabile iSwReturn puoi essere più dettagliato.
La Form chiamata riceverà i dati dell'array con il metodo _new, ho capito bene?
L'array valorizzato nella Form chiamante (da questo momento FormX1) coi dati da passare alla Form chiamata (da questo momento FormX2) viene acquisito dal costruttore della FormX2, cioe dalla classe _new di quest'ultima. Una volta costruita la FormX2, l'esecuzione del contatore di istruzioni ritorna sulla FormX1 che esegue la chiamata in modalità Showmodal. Tuttavia è necessario indicare come destinataria del valore numerico di ritorno una variabile di tipo integer, esattamente come si fa quando si richiama una funzione:
iSwReturn = FrmX2.showmodal()
Come succeda che al rientro dalla FormX2, l'array valorizzato nella FormX1 risulti modificato non è dato saperlo perchè nessuna guida di Gambas lo chiarisce, però ciò succede solo utilizzando il metodo di chiamata in showmodal descritto sopra. Se si prova ad eseguirlo nella maniera tradizionale, anche dopo avere richiamato il costruttore (_new), l'array conterrà sempre i valori di partenza, senza le modifiche apportate nella FormX2.
Spero che abbia chiarito tutti i tuoi dubbi. ;D
Grazie Picavbg, concetto esposto con molta chiarezza ed applicato con successo. :ok:
Ora mi viene in mente un'altra domanda (l'appetito vien mangiando...) sempre inerente il concetto di passaggio dati.
Poniamo che il nostro progetto sia un gestionale, abbiamo una Form "Ricerca Anagrafica Clienti" che come puoi ben
capire sarà richiamata da vari punti del programma Emmissione Fatture, DDT, Ordini, ect... e quindi dovrà passare
uno o più dati alla Form chiamante, con i concetti da te espressi posso passare al costruttore _new un dato
tramite variabile o più dati con un array, ma come faccio a scindere quale è la Form chiamante e passargli i dati?
La prima cosa che mi è venuta al volo è quella di aggiungere un'altra variabile in caso di passaggio tramite variabili
o un'altro dato all'interno dell'eventuale array da usare come flag di identificazione della Form chiamante, è la strada
corretta o ci sono altri metodi?
La chiamate di un Form tramite il parametro showmodal pone il Form chiamato in stato di dipendenza rispetto al Form chiamante. Ciò significa che mentre è attivo, il Form chiamante resta in stand-by, in attesa che il Form chiamato gli restituisca il controllo delle operazioni di elaborazione. Te lo dimostra il fatto che se tu clicchi sul Form chiamante, visibile sotto quello attivo (il chiamato ), non ottieni alcun effetto. Quindi il Form chiamante potrà ritornare attivo solamente dopo che il Form chiamato avrà eseguito la sua brava Close e nel caso specifico della chiamata eseguita nella modalità su cui stiamo ragionando dovrà restituire anche un valore. Riporto, anche se ridondante, la chiamata fatta dal Form chiamante:
FrmX = New FormX(vDati)
iSwReturn = FrmX2.showmodal()
Nel Form chiamato all'esecuzione della:
Me.Close(x) ' dove x costituisce i valore destinato a iSwReturn
Non vedo perciò alcuna necessità di passare dati dal chiamato al chiamante in maniera diversa da quella appena descritta più dettagliatamente.
Se ci rifletti con lo showmodal hai realizzato un pseudo-incapsulamento. Non è proprio un incapsulamento perchè non è completamente automatico, ma si avvale della chiamata preliminare del costruttore _new.
;D
@ GianLuigi
Scusami, ma non capisco cosa vuoi dire.
Per quanta riguarda la chiamata di un Form con showmodal il Form chiamato non è un Form esterno. Esso è direttamente dipendente del Form chiamante e mentre il chiamato è attivo il Form chiamante va sicuramente in stand-by.
:ciao:
Quando Tornu ha aperto la discussione ha postato due esempi il primo funzionante come dimostrazione di quanto voleva ottenere e il secondo quello vero che non faceva quanto da lui sperato.
Vuott ha trovato subito la soluzione, però a mio modestissimo parere in modo diciamo così non conforme ai canoni teologici della programmazione orientata agli oggetti. :)
Quanto da Tornu richiesto era lo scambio di informazioni fra una finestra Fmain, una finestra Form1 incorporata in Fmain e una Form2.
Se noi ci atteniamo a questo e insieme usiamo il metodo da te indicato “ereditato” da md9327, metodo che se non erro dovrà essere così applicato (almeno io l'ho provato in questo modo e funziona):
Frm1 = New Form1(vParametri, Fmain)
a questo punto anche se mostriamo la Frm1 in modalità modale (dialogo) non otterremo quanto otterremmo dal tuo codice se non incorporassimo la Frm1 e la chiamassimo con ShowModal().
Volevo dire questo quando mi sono riferito a “Form esterno” rispetto al Form incorporato.
Intendiamoci io non sono lo sciamano addetto alla reliquia della Prima Proprietà, il mio intento è solo comprendere bene per poter bene indirizzare giovani gamberetti.
Pertanto non posso che ringraziarti del tuo cortesissimo interessamento.
Sai come in tante altre cose la programmazione ci offre molte vie alla meta ma io credo che alcune siano migliori di altre, non intendo più dirette o con minore occupazione di memoria, intendo complessivamente più consone.
:ciao:
@ Gianluigi
Benissimo, allora, a parte le disquisizioni di carattere tecnico, volendo tornare all'oggetto dell'argomento corrente, tu dici:
Quando Tornu ha aperto la discussione ha postato due esempi il primo funzionante come dimostrazione di quanto voleva ottenere e il secondo quello vero che non faceva quanto da lui sperato.
Vuott ha trovato subito la soluzione
Secondo me, sebbene sia una soluzione pratica, quello non è un passaggio di dati ma è semplicemente una valorizzazione di una variabile appartenente ad un altro Form.
Ho riguardato il tuo esempio:
Frm1 = New Form1(vParametri, Fmain)
:ciao:
Ti allego una piccolissima dimostrazione che credo sia più esplicativa, così mi dici come avresti fatto tu e ci capiamo meglio.
Ho guardato il pochissimo codice che contiene il programmino d'esempio che hai allegato al tuo ultimo post, codice che avevo già letto in un tuo post precedente. Ho provato ad eseguirlo ma pare che sia stato scritto con una versione di Gambas più recente della mia, quindi non l'ho potuto provare. Guardando però il codice, In esso ho riscontrato due cose:
- Mi pare di capire che vuoi incorporare la FMain nella Form1, visto che passi alla Form1 la FMain come parametro, ma la FMain comprende la FMain.class e la FMain.Form. Non so se puoi passare col parametro Fmain sia l'una che l'altro. Non conosco Gambas così a fondo.
- La tua chiamata di Form1
Frm1 = New Form1(sParametri, FMain)
Frm1.Show
è eseguita in maniera che la Form1 sia perfettamente indipendente dalla FMain e ciò significa che tu puoi spostarti dall'una all'altra sia col Mouse che dai tasti scorciatoia senza dovere obbligatoriamente chiudere la Form1. Quindi mi pare che non riesci ad ottenere quell'inglobamento che vorresti. Inoltre, anche se richiami il costruttore della Form1, la successiva Form1.show non potrà mai e poi mai ricevere alcun effetto prodotto all'interno della Form1, sia perchè hai usato un metodo diverso da quello modale, sia perchè non hai indicato la variabile numerica dove fare pervenire il valore di ritorno a carico dell'istruzione di chiusura della Form1.
L'unica modalità per subordinare la Form1 alla FMain è quella di eseguire una chiamata di tipo modale. In questo modo il Form1, seppur non incorpori FMain, risulta dipendente da esso e FMain non è più disponibile per un suo utilizzo fino a quando la Form1 non sarà chiusa. Per ottenere poi il ritorno di un valore numerico occore fare la chiamata, come ho già detto più volte, esclusivamente con la seguente modalità:
Frm1 = New Form1(sParametri) 'dove includerai tutte le variabili che vorrai passare a Form1 per manipolarle
iNum = Frm1.Show
la Form 1 di contro utilizzarà il contenuto della sParametri ed al momento cella chiusura restituirà un valore, anche formale, ma soprattutto restituira l'array modificato coi nuovi valori che avrà determinato durante l'elaborazione di sua competenza:
Private vParam As New String[]
Public Sub _new(vParamInp As Variant[])
vParam = vParamInp
End
Public Sub PulsMod_Click()
vParam[1] = "fine prova"
End
Public Sub PulsEsci_Click()
'-----------------------------------------
Me.Close(0) 'Questo è il momento in cui il Form1 finisce il suo lavoro e si chiude la relativa finestra. A FMain viene restituito il valore 0, ma l'array sParametri risulta pure modificato nel suo 2° elemento.
End
Ora ho indicatoi chiaramente anche le istruzioni salienti da inserire nella Form1.class.
Insisto col dire che è l'unica modalità per passare in andata e ritorno dei parametri fra due Form, di cui il Form chiamato deve essere in dipendenza modale rispetto al chiamante.
;)
@Vuott
Come ho già scritto, ribadisco che anch'io credo che il programmatore è padronissimo di scrivere il codice come meglio gli aggrada. Ciò non toglie che si possa discutere di cosa è meglio per ognuno di noi.
@Picavbg
Sostieni che avevo già postato questo codice? Posso chiederti dove?
E poi scusa ma fermarsi davanti all'incompatibilità di versione e non provare un codice così breve che poteva far capire cosa intendevo dire/dimostrare...
Ricordo a me stesso che basta fare doppio click sulla cartella del progetto con spuntata l'opzione di Visualizza > Mostra file nascosti e fare doppio click sul file .src e poi visualizzare i file .class (quelli con icona la tazzina del caffè) col tasto destro del mouse per aprirli con l'editor di testo.
Basta copiare e fare le semplicissime form et voilà.
Comunque tranquillo non ti sei perso niente.
@Tornu
Come puoi ben comprendere è quasi impossibile o è molto difficile capire cosa sia che esattamente un altra persona voglia ottenere dal proprio codice.
Uno può offrire uno spunto dal proprio punto di vista per quel poco che ha compreso.
Qui si trattava comunque di cosa già risolta ne ho voluto parlare proprio perché ne dobbiamo poi scrivere nel libro.
E' quindi nata questa disquisizione con Picavbg che ha dato il suo suggerimento dicendo che se si parla di dati scambiati fra finestre non si può prescindere da quanto insegnato da md9327.
Ora siccome sembra che io non sappia di cosa stiamo parlando esemplifico in modo minimale quanto io ho compreso del suddetto insegnamento:
Per provare questo codice occorre creare un progetto grafico QT avente la Fmain con un button1 e una Form1 con una textlabel1 e un button1.
Questo il codice della Fmain:
Public Sub Form_Open()
Me.Center
End
Public Sub Button1_Click()
Dim iRitorno, i As Integer
Dim sParametri As New String[]
Dim Frm1 As Form1
' Inserisco un paio di voci da inviare a form1
sParametri.Add("Voce 1 da FMain")
sParametri.Add("Voce 2 da FMain")
' Passo i parametri attraverso il costruttore di classe.
' NB: Per passare e ottenere valori da altre form devo utilizzare
' degli oggetti le array string[] sono oggetti (classi).
' Quindi potrei utilizzare altri tipi di classi array.
Frm1 = New Form1(sParametri)
' Ottengo l'integer dalla form1
' Apro la form1 come dialogo o modale (stessa cosa)
' altrimenti non posso ottenere i valori di ritorno.
iRitorno = Frm1.ShowDialog()
' Ottengo i valori di ritorno
Print iRitorno
For i = 0 To sParametri.Max
Print sParametri[i]
Next
End
Questo il codice della Form1
Private $bOk As Boolean = False
Private $iRitorno As Integer
Private $sParametriForm1 As String[]
Public Sub _new(sParametri As String[])
Dim i As Integer
Dim s As String
' Ottengo i parametri copiandoli in una nuova array
$sParametriForm1 = sParametri
For i = 0 To $sParametriForm1.Max
s &= $sParametriForm1[i] & "<BR>"
Next
' Mostro i parametri nella textlabel
TextLabel1.Text = s
End
Public Sub Button1_Click()
' Abilito la chiusura della finestra solo da
' button1 per poter passare il valore alla FMain
$bOk = True
' Cambio la seconda voce e aggiungo una voce
$sParametriForm1.Remove(1)
$sParametriForm1.Add("Voce Cambiata da Form 1", 1)
' Aggiungo una nuova voce.
$sParametriForm1.Add("Nuova voce da Form 1", 2)
' Valore integer di ritorno a FMain.
Me.Close(10)
End
Public Sub Form_Close()
' Per impedire di non avere il valore integer di ritorno (in questo caso 10).
' Se invece vogliamo sapere se la finestra è stata chiusa non da pulsante
' (a parte che non avremmo variazioni di dati, ritorno degli stessi alla FMain ecc.)
' commentate o cancellate questo codice e se la finestra viene chiusa dalla
' X riceverete indietro l'intero Zero.
If $bOk = False Then
Message("Occorre agire sul pulsante <B>Sostituisco Aggiungo Chiudo</B> per chiudere la finestra regolarmente.")
Stop Event
Endif
End
Mi sono accorto che nel codice di “Array_di_passaggio” questa parte non è spiegata bene, penso che ora confrontando i due codici tu possa meglio comprendere.
Public Sub Form_Open()
Dim iRitorno As Integer
Dim sParametri As New String[]
Dim Frm1 As Form1
' Aggiungo una voce
sParametri.Add("FM")
Frm1 = New Form1(sParametri, FMain)
' Questa voce comunque tu la scrivi (o no) non serve a nulla!
Frm1.ShowModal()
' Show o ShowModal non servono in quanto se incorpori il form1 in FMain
' non si avrà il ritorno del codice alla chiusura
' se invece non si incorpora form1 in fmain allora
' occorre aprire in modale per avere il ritorno.
Print "Eseguito fino a qui"
End
Io credo che il passaggio di dati fra finestre attraverso il costruttore (_New) non faccia al caso tuo, come del resto neanche gli altri modi qui trattati, a meno che non trovi un compromesso all'idea di partenza.
Se devi per forza chiudere una finestra quando ne apri un altra e quella che deve ricevere i dati deve essere incorporata o ti sei fatto bastare il suggerimento di vuott altrimenti puoi prendere in considerazione la classe Application e fare come si faceva una volta in Access (un ritorno alle variabili pubbliche comunque, che poi non è che sono il diavolo e a volte...).
PS: Il codice con “gambas code” non funziona bene l'ho cambiato sperando in meglio col vecchio sistema.
:ciao: