Newsgroup: it.comp.lang.visual-basic
Titolo: unload ?

E sono ancora io a chiedere aiuto.
Quello che devo fare č questo:
nel caso in cui ci siano piů form aperti chiuderli tutti fino ad arrivare al
form "principale" cioč quello del menu.
Perň se faccio questo usando l'istruzione Unload, non viene rieffettuato
l'activate del form "sottostante" cosa che invece mi necessita. Come posso
risolvere questo problema?
Grazie ancora.
Elisa.

 wrote in message
LWaj6.17816$LM4.2...@twister1.tin.it...

La cosa piů normale sarebbe aprire tutti i sottoform in modo modale
    frmPippo.show vbModal
in questo modo lo fa in automatico.
Diversamente, č un macello, perchč dovresti sapere qual'e' il form che
dovrebbe stare avanti a tutti col fuoco.
Per portare un form avanti a tutti:
    frmPippo.zorder
Per dare il fuoco ad un form
    frmFiammifero.show
    o
    frmFiammifero.setocus
Ciao
Ettore Maronese
il Mes
http://www.maronese.com/mes

 wrote in message
q1bj6.17650$7U4.3...@news.infostrada.it...


 Ho sbagliato qualcosa vero?
Bhe, se vuoi chiudere tutti i forms tranne uno in particolare, + o - č
corretto.
Ovviamente quel loop non č corretto. Dovresti scandirti tutti i forms
aperti, tipo
dim nr as integer
nr=0
do
    if nr >= forms.count then exit do
    if forms(nr).name = "formmenu" then
        unload forms(nr)
        nr=0
    else
        nr=nr+1
    end if
loop
Io perň seguirei altre vie + strutturate (se fosse possibile).
Vediamo se ho capito quello di cui hai bisogno:
Tu hai una finestra madre frmMenu che richiama una finestra frmUno che a sua
volta chiama la finestra frmDue.
Se in frmDue l'utente pigia il tasto Annulla si deve chiudere sia la frmUno
che la frmDue.
Se č questo io ti consigli di fare in questo modo (anche se non č dei +
puliti e ce ne sarebbero di + puliti ma + comlessi da realizzare)
    - crei una variabile globale in un modulo chiamata EsitoForms as boolean
    - quando frmMain apre frmUno fai:
            EsitoForms = true
            frmUno.show vbModal
    - quando frmUno chiama frmDue fai:
            frmDue.show vbModal
            if EsitoForms=false then unload me: exit function
    - quando in frmDue l'utente preme Annulla fai:
            EsitoForms = false
            unload me
In questo modo rimane ben strutturato.


 ha scritto nel messaggio
news:LWaj6.17816$LM4.2...@twister1.tin.it...


     - crei una variabile globale in un modulo chiamata EsitoForms as boolean
Ipotesi: frmMaster -> frmUno -> frmDue
Prima di tutto: i form sono chiamati in maniera modale o no?
Nel primo caso, l'attivazione di frmDue (fatta con frmDue.Show vbModal) congela
tutto il mondo al suo esterno, e quando frmDue viene scaricata (al suo interno
viene eseguito un Unload Me) l'esecuzione riprende dall'istruzione successiva a
Show vbModal. A questo punto, posso mettere in frmDue una Property Get
(leggibile anche quando e' scaricata), che dice se il chiamante deve essere
scaricato a sua volta.
Nel secondo caso, visto che dopo l'attivazione di frmDue (fatta con frmDue.Show,
senza il vbModal) tutto prosegue come prima, forse la variabile globale e' piu'
indicata. Tieni conto pero' che, essendo frmUno e frmDue non 'vincolate', posso
buttar giu' frmUno, mentre frmDue vive ormai di vita propria. E' mio compito
controllare, prima di eseguire l'Unload Me di frmuno, che frmDue sia ancora
viva, scorrendo la collection delle Forms.
Bye by Massimo 8-]

 loop
Ciao


Prima di tutto: i form sono chiamati in maniera modale o no?
Allora, il modo corretto sarebbe questo (Delphi docet, direbbe qualcuno :))
in frmDue ho
    Public ModalResult As Long
nei bottoni "Ok" e "Annulla" (o dove vuoi) metti:
Sub cmdOk_Click()
    ModalResult = vbOk
    Me.Hide
End Sub
Sub cmdAnnulla_Click()
    ModalResult = vbCancel
    Me.Hide
End Sub
--
In frmUno
    frmDue.Show vbModal
    if (frmDue.ModalResult = vbOk) then
        'Risposto Ok
    Else
        'Risposto annulla
    End if
    Unload frmDue
    Set frmDue = Nothing ' questo non fa mai male...
Ciao

 wrote in message
2xbj6.13439$Uj1.2...@twister2.tin.it...


Zanna wrote:

Al posto del  'Me.Hide......if (frmDue.ModalResult = vbOk) then' non ci
starebbe meglio un 'Unoad Me.......if frmDue.GetModalResult.....', definendo in
frmDue
Public Property Get GetModalResult() as Long
  GetModalResult = ModalResult
End Property
Bye by Massimo 8-]

End Property
No.
(1) perchè fare una property quando una var è più che sufficiente?
(2) tu ben sai che accedendo a un metodo di un form ne provochi il suo
caricamento.
    Poi, se fai l'unload come fai poi ad accedere alla GetModalResult?
    Ti troveresti un ModalResult errato (presumibilmente = 0), e il form
caricato in memoria a tua insaputa.
Ciao

caricato in memoria a tua insaputa.
No. Il caricamento avviene se si accede ad una proprieta' intrinseca
del form o ad un suo controllo.
L' unload del form non resetta le variabili che possono essere ancora
lette. E' ovviamente tassativo non accedere a proprieta' tipo
Caption o a controlli contenuti nel form perche' allora si'
che verrebbe ricaricato.
Ciao
Aldo

lette.
Appunto, hai ancora del codice *non* scaricato!
Se si usasse il Set Form1 = Nothing (come sarebbe giusto fare) dopo
l'unload, questo sistema porterebbe a una cascata di comportamenti
imprevisti.
Ciao

 Ciao
Ciao
G.C.

Appunto, hai ancora del codice *non* scaricato!
Alt ! In un nuovo progetto metti due form senza niente.
Dentro ogni form copia questo codice:
---------------------
Option Explicit
Private Sub Form_Initialize()
  Debug.Print "Form1: Initialize"
End Sub
Private Sub Form_Load()
  Debug.Print "Form1: Load"
End Sub
Private Sub Form_Terminate()
  Debug.Print "Form1: Terminate"
End Sub
Private Sub Form_Unload(Cancel As Integer)
  Debug.Print "Form1: Unload"
End Sub
-----------------
Ovviamente la parola Form1 diventa Form2 nel Form2.
In un modulo metti questa sub main(), che va impostata come oggetto
di avvio del progetto:
----------
Option Explicit
Public Sub Main()
  Dim f As Form1
  Dim g As Form2
 
  Set f = New Form1
  Load f
  f.Show
  Unload f
  Set g = New Form2
  Load g
  g.Show
  Unload g
End Sub
----------------
Ho premuto F5 e questo e' quanto ho letto (con nt4) nell' output window:
Form1: Initialize
Form1: Load
Form1: Unload
Form2: Initialize
Form2: Load
Form2: Unload
Form1: Terminate
Form2: Terminate
Il Form1 non e' terminato con l' unload, ma quando e' uscito dallo scope.
Se fosse stata inserita 
Set f = Nothing
dopo l' unload allora l' output window avrebbe riportato questo:
Form1: Initialize
Form1: Load
Form1: Unload
Form1: Terminate
Form2: Initialize
Form2: Load
Form2: Unload
Form2: Terminate
Quindi non si tratta di codice non scaricato (non ce n'e' proprio), ma la 
dimostrazione che le variabili interne del form sono ancora belle vispe
anche dopo l' unload.
Ciao
Aldo

anche dopo l' unload.
Non voglio mettere in discussione le vostre conoscenze, comunque...
Fate un po' come credete.
Forse non avete mai usato codice del genere insieme a variabili statiche
(anche sull'uso di queste ci sarebbe da farci un comizio).
Personalmente trovo questo modo di programmare molto superficiale, contorto,
disordinato, indice di cattiva progettazione e soggetto a grandi casini.
Parlo per me: già è difficile star dietro alla logica di alcuni
programmatori, se poi ci si deve preoccupare anche di stare attenti a come
si comporta il compilatore...
L'equazione "funziona = va bene" è assolutamente falsa!
Nessuno vieta di fare come dite, è vero, ma chi è causa del suo mal...
(ultimamente io mi sto rompendo il c***o di farmi male per mi*****te del
genere, perlopiù scritte da altri).
Ciao

 genere, perlopiù scritte da altri).
E qui c'e' un'altra grande verità: Qui sul NG vengono dati consigli sempre
utili, ma sta a chi li legge capire quali sono quelli + validi e corretti.
ma:
   "  L'equazione "funziona = va bene" è assolutamente falsa!  "
è davvero bellissima!
--
/\/\/\/\/\/\/\/\/\/\/\/\/
|  Partecipa alla stesura di progetti VB sviluppati in team,
|  informati sul Sito Comune sezione Leonardo. Io
|  partecipo al progetto Data Raptor, alleati con noi.
\/\/\/\/\/\/\/\/\/\/\/\/\
Ciao
Ettore Maronese, il Mes
http://www.maronese.com/mes
Sito Comune di questo NG
http://www.murialdo.it/it_lang_vb

genere, perlopiù scritte da altri).
Le avranno fatte male. E' chiaro che se dopo l' unload fanno
accesso ad un controllo o ad una proprieta' intrinseca del form 
fanno certamente casino.
Ma, ripeto, se la proprieta' cui si accede legge il valore di una
variabile di tipo semplice (long, string o quello che vuoi)
_non_ viene provocato nessun load e nessun initialize.
Cio' si rivela molto utile nelle form di dialogo per raccogliere
input dall' utente ed elaborarlo successivamente, rendendo le
form stesse indipendenti dal contesto e riutilizzabili e senza
usare porcate tipo variabili globali (che con mia gioia con
vb7 non ci saranno piu').
Ciao
Aldo

Aggiungo un po' di letteratura:
Example 1: Return Values from a Modal Dialog Box
http://msdn.microsoft.com/library/books/advnvb5/CH05_7.htm
Ciao
Aldo