Autore Topic: Impiego dei "Metodi nascosti"  (Letto 3317 volte)

Offline milio

  • Senatore Gambero
  • ******
  • Post: 1.273
  • Chi parla poco dice tanto...
    • Mostra profilo
Re: Impiego dei "Metodi nascosti"
« Risposta #15 il: 19 Settembre 2010, 23:49:41 »
Ma nella classe del Form3 hai fatto richiesta di passargli dei dati nel metodo speciale _new:

Codice: gambas [Seleziona]
PUBLIC SUB _new(Parametri AS String[])


END


?

Offline Picavbg

  • Senatore Gambero
  • ******
  • Post: 1.620
    • Mostra profilo
Re: Impiego dei "Metodi nascosti"
« Risposta #16 il: 20 Settembre 2010, 00:04:54 »
Si hai ragione; avevo dimenricato ad inserire l'array nella procedura -new della Form3 chiamata; però dopo la correzione il messaggio di errore non é scomparso, é solamente cambiato nel seguente:
Citazione
Not enough arguments
Ecco la riga di dichiarazione della procedura _new:
Codice: [Seleziona]
PUBLIC SUB _new(TbParF3 AS String[])
:ciao:

Offline md9327

  • Moderatore
  • Senatore Gambero
  • *****
  • Post: 2.840
    • Mostra profilo
Re: Impiego dei "Metodi nascosti"
« Risposta #17 il: 20 Settembre 2010, 00:50:09 »
Il problema è legato al fatto che Form accetta già un parametro, che è il riferimento (se esiste) di un altro contenitore, che gli fà da parent.
In questo caso, prova a passargli il tuo parametro, seguito da un bel NULL (es. Form(parm, NULL)).

Inoltre, ma potrebbe anche non essere (devo provarlo), prova ad eliminare l'underscore davanti al nome della variabile. Non sò come si comporta gambas in questo caso, ma l'underscore davanti ad un metodo lo rende privato e non visibile all'esterno. Questa è una caratteristica usata per la creazione dei componenti (e milio la conosce bene...  :P ).

Come ultimo, nel forum ho pubblicato alcuni esempi fatti appunto per capire le funzionalità di gambas, e uno di questi è praticamente il tuo programma, su cui ho giocato un poco, aggiungendo alcune cose per dimostrare come funzionano le classi, gli oggetti e l'uso di _new().


Offline Ceskho

  • Amministratore
  • Senatore Gambero
  • *****
  • Post: 3.778
  • Vi Veri Veniversum Vivus Vici
    • Mostra profilo
    • Pagina Personale
Re: Impiego dei "Metodi nascosti"
« Risposta #18 il: 20 Settembre 2010, 00:54:38 »
Il problema è legato al fatto che Form accetta già un parametro, che è il riferimento (se esiste) di un altro contenitore, che gli fà da parent.
In questo caso, prova a passargli il tuo parametro, seguito da un bel NULL (es. Form(parm, NULL)).

Scusa, ma non è il contrario? Non accetta PRIMA il contenitore e poi tutti i parametri creati dal programmatore?

Offline milio

  • Senatore Gambero
  • ******
  • Post: 1.273
  • Chi parla poco dice tanto...
    • Mostra profilo
Re: Impiego dei "Metodi nascosti"
« Risposta #19 il: 20 Settembre 2010, 06:08:27 »
L'errore secondo me nasce  invece da questo:

  Frm3 = NEW Form3($_FrmParam)
  i_SwReturn = Form3.Showmodal()


Tu dichiari un nuovo Form3 nella variabile Frm3
Poi pero' cerchi di aprire Form3, che ovviamente vuole i parametri del metodo _new(), quindi e' giusto che scateni l'errore...
Devi dare:

  Frm3 = NEW Form3($_FrmParam)
  i_SwReturn = Frm3.Showmodal()


Offline Picavbg

  • Senatore Gambero
  • ******
  • Post: 1.620
    • Mostra profilo
Re: Impiego dei "Metodi nascosti"
« Risposta #20 il: 20 Settembre 2010, 09:58:17 »
Si, effettivamente é stata una mia svista. Ho corretto l'istruzione errata e con
Codice: [Seleziona]
Frm3 = NEW Form3($_FrmParam)
i_SwReturn = Frm3.ShowModal()
ha funzionato tutto benissimo e finalmente ho potuto gestire nella Form chiamante il ritorno alla FMain.  :2birre:

Resta da chiarire il concetto già espresso nel mio post n.12. Se poteste spiegarmi in maniera elementare come si combinano le due istruzioni, può darsi che riesca a capire l'uso applicativo del metodo _New.  :D
Ciao
:ciao:

Offline Picavbg

  • Senatore Gambero
  • ******
  • Post: 1.620
    • Mostra profilo
Re: Impiego dei "Metodi nascosti"
« Risposta #21 il: 20 Settembre 2010, 10:03:24 »
..., nel forum ho pubblicato alcuni esempi fatti appunto per capire le funzionalità di gambas, e uno di questi è praticamente il tuo programma, su cui ho giocato un poco, aggiungendo alcune cose per dimostrare come funzionano le classi, gli oggetti e l'uso di _new().

Potresti, se non ti secca, facilitarmi la ricerca comunicandomi il link?
Scusami, se ti posso sembrare pigro, ma ... forse lo sono proprio. ;D
Ciao.
:ciao:

Offline md9327

  • Moderatore
  • Senatore Gambero
  • *****
  • Post: 2.840
    • Mostra profilo
Re: Impiego dei "Metodi nascosti"
« Risposta #22 il: 20 Settembre 2010, 10:48:55 »
In effetti mi era sfuggita l'istruzione errata... per fortuna milio ci vede meglio di me...   8)

Citazione
Scusa, ma non è il contrario? Non accetta PRIMA il contenitore e poi tutti i parametri creati dal programmatore?
No, è il contrario, i parametri si accodano partendo dall'oggetto parent più in alto...

Riguardo al link, devo guardare, ma credo che Cesko abbia in qualche modo spostato il tutto da qualche parte... forse ha creato un'altro contenitore... devo controllare...

Offline md9327

  • Moderatore
  • Senatore Gambero
  • *****
  • Post: 2.840
    • Mostra profilo
Re: Impiego dei "Metodi nascosti"
« Risposta #23 il: 20 Settembre 2010, 10:50:22 »

Offline Picavbg

  • Senatore Gambero
  • ******
  • Post: 1.620
    • Mostra profilo
Re: Impiego dei "Metodi nascosti"
« Risposta #24 il: 20 Settembre 2010, 12:46:21 »
Prova qui...
http://www.gambas-it.org/smf/index.php?topic=1353.0

Grazie per l'indicazione. Solo che dopo avere fatto il download di tutti gli esempi ed averli guardati, non ho capito quale di essi potesse contenere, come hai citato qualche post fa, il mio programmino di prova
Citazione
uno di questi è praticamente il tuo programma, su cui ho giocato un poco, aggiungendo alcune cose per dimostrare come funzionano le classi, gli oggetti e l'uso di _new()
L'unico che potrebbe aiutarmi mi sembrerebbe TestEvent.tar.gz, ma non vi ho trovato le istruzioni che cercavo e quindi non l'ho capito.
Mi dispiace,  :-\, occorre che scenda al mio modesto livello comunicativo.
Ciao.
:ciao:

Offline md9327

  • Moderatore
  • Senatore Gambero
  • *****
  • Post: 2.840
    • Mostra profilo
Re: Impiego dei "Metodi nascosti"
« Risposta #25 il: 20 Settembre 2010, 14:31:12 »
Ma che te possino!  :bad:

In effetti scherzavo un pochino sul "praticamente il tuo programma"...  :P

Perchè dici che non può esserti utile?
Nell'esempio ci sono parametri e gestione eventi, un pò di tutto insomma...

Altrimenti puoi vedere gli altri. Nei miei programmi, solitamente, io faccio esclusivamente uso del costruttore, se necessario.

Ad ogni modo, quello che non capisco, a parte alcune piccole particolarità, come ad esempio la posizione dei parametri, oppure alla piccola svista sulla chiamata della form, non capisco dove ti sei incagliato. Il numero di post non lo calcolo...  :'(

Tu hai una form... di norma le form di dialogo ritornano solo un valore intero, con cui è possibile stabilire cosa è successo, o cosa fare, alla chiusura della finestra.
Dato che non hai, e non puoi avere altri tipi di ritorno, l'unco modo che hai per poter modificare dei dati dalla finestra di dialogo, dati che appartangono ad altra procedura, è quello di passarli sottoforma di oggetto alla form di dialogo (il perchè un oggetto te lavevo chiarito).
Detto questo, nel metodo _new della form di dialogo, dichiari l'oggetto che riceve questi dati e, nella funzione chiamante, crei la form di dialogo passandogli appunti i dati da modificare, opportunamente codificati in un oggetto (es. String[], Object, ecc.).
Nella finestra di dialogo, devi poter capire se, un'eventuale chiusura, deve ritornare un particolare codice, in modo che la funzione chiamante possa stabile cosa fare quando la dialog si chiude. Ammettiamo per il caso di avere un bottone Chiudi, la pressione di questo pulsante genera un evento Click, e all'interno di questo evento fai un bel "ME.Close(1)". Il valore 1 è un valore di esempio, ma sicuramente valido per uno scopo preciso, ovvero far in modo di avvertire la funzione chiamante che la dialog è stata chiusa dal pulsante, e non per altre cause.

A questo punto, come hai pure fatto, la funzione chiamante riceve il valore di 1, che vuol dire che devi fare qualcosa, e nel tuo caso cosa lo sai tu... :D

Ora è chiaro il discorso?

Offline Picavbg

  • Senatore Gambero
  • ******
  • Post: 1.620
    • Mostra profilo
Re: Impiego dei "Metodi nascosti"
« Risposta #26 il: 20 Settembre 2010, 18:15:40 »
Perchè dici che non può esserti utile?
Nell'esempio ci sono parametri e gestione eventi, un pò di tutto insomma...

Premetto, come ho detto nel mio ultimo post, che ho assunto praticamente il codice che mi hai suggerito, sia dentro la Form chiamante, sia in quella chiamata, cercando di capire, per quello che ho potuto. Il valore di ritorno inserito nell'istruzione me.close(x) della form chiamata mi é stato molto utile perhé mi ha permesso di testarlo subito dopo il rientro alla Form chiamante ed ho potuto riconoscerlo per ritornare da quel punto alla Form Fmain per l'ulteriore scelta.
Perciò, quello che ho potuito fare col tuo suggerimeneto é proprio quello che volevo, quindi meriti un  :-*
Penso che sia anche chiaro il concetto sul passaggio dei parametri tramite l'array che viene intercettato dentro la procedura _New della Form chiamata; ritengo però non essere cresciuto in esperienza e conoscenza logica relativamente alle istruzioni di chiamata tramite metodo _new nella Form chiamante:
Codice: gambas [Seleziona]

DIM Frm3 AS Form3
DIM ret AS Integer
DIM $Param AS NEW String[]
Frm3 As Form3           --> somiglia molto alla dichiarazione di una classe o contenitore(come lo chiami tu);
Frm3 = NEW Form3($Param)   --> somiglia molto alla chiamata di una nuova ricorrenza della classe dichiarata sopra;
iRet = Frm3.ShowModal()  --> sembrerebbe inutile, in quanto dà l'impressione di essere una seconda chiamata della stessa classe della riga superiore.

É codesto il concetto che non ho capito e cercavo una spiegazione nella lettura diretta del codice in uno dei tuoi esempi, ma non sono riescito a farlo perché non ho trovato un codice simile.

Sto cercando di impossessarmi del concetto e per questo parto da i seguenti capisaldi, almeno credo:
- La Form é una classe statica e va chiamata con l'istruzione show o showmodal (quest'ultima obbligatoria per potere utilizzare il metodo -new);
- L'oggetto Frm3(nell'esempio) dovrebbe costituire il contenitore dell'indirizzo della Form3 a cui viene agganciata la lista dei parametri contenuta nell'array $Param.
- La variabile iRet(nell'esempio) é destinataria del valore di ritorno fornito dalla Form chiamata a fine lavoro.

Se é così come ho descritto qui sopra, penso di averne capito a grosse spanne il meccanismo; se invece non é così posso partecipare ad un corso di "Caccia al Metodo nascosto" che potresti tenere in occasione del prossimo Natale a Roma con offerta di panettone per tutti i partecipanti.   :rotfl:

A parte gli scherzi, quello che ho scritto relativamente ai capisaldi, é scivolato così come lo leggi mentre scrivevo; non esisteva assolutamente all'inizio del post.
Ciao.
:ciao:

Offline md9327

  • Moderatore
  • Senatore Gambero
  • *****
  • Post: 2.840
    • Mostra profilo
Re: Impiego dei "Metodi nascosti"
« Risposta #27 il: 21 Settembre 2010, 15:34:48 »
A parte il bacio, che accetto idealmente, ma mi fà anche un pò schifo...  ;D

Ti dico che:

1) la Form non è un oggetto statico, leggi bene la doc, ma un oggetto che non può essere usato come padre di un'altro (il concetto di INHERITS).
2) il codice che hai incorniciato ha un errore: la DIM dichiara un tipo, e l'istruzione "Frm3 AS Form3" è errata e dà sicuramente errore in compilazione
3) l'istruzione _new viene sempre eseguita, sia negli oggetti statici, che negli altri, solo che verrà eseguita solo alla prima chiamata di un qualsiasi suo metodo
4) Frm3 è a tutti gli effetti il riferimento, o puntatore, all'oggetto appena creato. Ed è per questo che deve essere dichiarato come stesso tipo (ma qui il discorso può ampliarsi, lasciamolo per il futuro)
5) Quello che affermi sulla variabile iRet è corretto

Sono felice che, in qualche modo, sia riuscito a farti capire il sistema, e sono qui per rispondere alle, sicure, successive tue domande...  :P


Offline Picavbg

  • Senatore Gambero
  • ******
  • Post: 1.620
    • Mostra profilo
Re: Impiego dei "Metodi nascosti"
« Risposta #28 il: 22 Settembre 2010, 00:17:15 »
A parte il bacio, che accetto idealmente, ma mi fà anche un pò schifo...  ;D
Anche a me, ma soprattutto per via dei peli che mi sono rimasti attaccati alle labbra.  :rotfl:

Citazione
2) il codice che hai incorniciato ha un errore: la DIM dichiara un tipo, e l'istruzione "Frm3 AS Form3" è errata e dà sicuramente errore in compilazione
Fino ad ora non ho assolutamente proceduto con la compilazione. Forse il mio modo di procedere non é proprio profiquo, perché probabilmente bisognerebbe compilare il programma di tanto in tanto, magari al raggiungimento di un nuovo punto fermo dello stato dell'arte, secondo un modo di dire convenzionale.  ??

Citazione
Sono felice che, in qualche modo, sia riuscito a farti capire il sistema, e sono qui per rispondere alle, sicure, successive tue domande...  :P
Vedo che cominci a conoscermi. Però, visto che sai prevedere quello che farò, potresti almeno anticiparmi la risposta, così almeno potrei risparmiarmi la o le domande.  :D :D

Grazie ancora.
Ciao.


[/quote]
:ciao:

Offline md9327

  • Moderatore
  • Senatore Gambero
  • *****
  • Post: 2.840
    • Mostra profilo
Re: Impiego dei "Metodi nascosti"
« Risposta #29 il: 22 Settembre 2010, 00:44:07 »
No, spetta un momento, mica mi hai preso per Nostradamus ?  :rolleyes:

Scherzi a parte, ormai quello che vuoi ottenere sembra abbastanza chiaro, ma da qui al cosa farai domani ce ne passa...

La logica più o meno sembra tu l'abbia compresa, il codice che hai postato sembra corretto, a parte la nota che ti ho inserito (nota, non sei ancora stato bocciato...  ;D ).

Se quella è stata una svista, ok, altrimenti c'è ancora qualcosa che non hai digerito...

Molti linguaggi usano definire ad inizio metodo (o funzione, o classe) il tipo di variabile che andrà ad utilizzare. In gambas, come in VisualBasic, questo si fà con la parolina DIM. Questo, però, in effetti non fà ancora nulla, ma dice solo al compilatore che quel nome di variabile verrà utilizzato per puntare ad un particolare tipo di dato.
Una volta stabilito il tipo, la variabile deve essere istanziata, ovvero creata relamente in memoria. Questo, dipendentemente dal tipo di variabile, se è un oggetto si usa la sintassi NEW, mentre per le variabili normali l'assunzione in memoria avviene alla prima assegnazione o al primo utilizzo, sempre premesso che il linguaggio azzeri in qualche modo il dato ivi contenuto.

A questo punto, se si tratta d una semplice, ad esempio, String che di default viene inizializzata a "" (vuoto), basta utilizzarla che viene immediatamanete istanziata. Nel caso di oggetti, come sopra accennato, dato che contengono sia codice (metodi) che dati (proprietà), la cosa assume alcune differenze. La prima è che l'oggetto deve essere esplicitamente creato, ovvero fornita sufficiente memoria per contenerlo, poi chiamato il suo costruttore. In alcuni linguaggi come Gambas, questo è implicito con l'uso dell'istruzione NEW, che provoca prima la creazione in memoria dell'oggetto, poi esegue il suo costruttore, in tutti i casi il metodo _new(). In altri linguaggi questo assume diverse modalità, ad esempio in C/C++, o in Java, il costruttore è un metodo che ha lo stesso nome della classe, senza valori di ritorno.

Inoltre, ogni oggetto prevede anche un metodo distruttore, che in gambas viene assunto da un'altro metodo nascosto _free().

Ora, non voglio appesantire il discorso, per cui ometto di parlarti di free() e di delete(), anche perchè gambas ha un sistema che li chiama automaticamente quando l'oggetto non viene più usato. Semmai ne parleremo in seguito. Tieni conto che anche io lo uso molto poco, anche perchè, in alcuni, casi crea dei problemi che tocca tener ben presenti.