Rimane il fatto che secondo logica in un modulo non si dovrebbero scatenare gli eventi, guisto? e invece:
Poniamo questo nella classe del form:
Public Sub Form_Open()
Mporca.Miseria
End
Quindi creiamo un modulo nominandolo "Mporca" e inseriamo questo codice:
Private hMappaPesi As GridView
Public Sub Miseria()
Dim i, e As Integer
hMappaPesi = New GridView(FMain) As "MappaPesi"
With hMappaPesi
.Header = 3
.W = 410
.h = 200
.X = (FMain.W - .W) / 2
.Y = (FMain.H - .H) / 3
.Rows.Count = 10
.Columns.Count = 3
.Columns.Width = 120
.Columns[0].Text = "Primo Dato"
.Columns[1].Text = "Secondo Dato"
.Columns[2].Text = "Terzo Dato"
For i = 0 To 9
For e = 0 To 2
hMappaPesi[i, e].Text = "Dato in R" & CStr(i + 1) & "C" & CStr(e + 1)
Next
Next
End With
End
Public Sub MappaPesi_Arrange()
Message("Cosa succede. Sono in un modulo e sto funzionando come in una classe!?")
End
:ciao:
Se non scateno un putiferio non sono contento. :D :D
Devo dire che sulla questione relativa alla presunta incapacità di un Modulo di avere propri Oggetti, rappresentati da rispettive variabili, io devo fare marcia indietro. :-[
Parto da questa esatta precisazione di Gianluigi:
Gambas ti sta dicendo che cerca un contenitore e invece riceve una classe.
In effetti, Gambas non dice che la parola Me non è applicabile ad un Modulo, bensì che hai tentato - scrivendo all'interno di Modulo - di impostare come "Parent " della GridView un Me che non è e non si riferisce ad un Contenitore: ma che è il Modulo medesimo.
Dunque va ricordato e sottilineato che la parola Me può riferirsi comunque anche ad un Modulo.
Questione degli Oggetti di Modulo:
ho dovuto elimare le righe ove affermavano che un Modulo è incapace di istanziarsi come Oggetto, rappresentato da una propria variabile.
Infatti propongo l'esempio che segue.
Nel Modulo secondario, chiamato Module1, scriviamo questo codice:
Public Function Prova_1(n As Integer) As Integer
Dim a As Integer
a = Me.Prova_2(n) ' Utilizzo anche la parola chiave "Me" ! ...che si riferisce dunque al Modulo secondario "Module1"
Return a + 100
End
Public Function Prova_2(c As Integer) As Integer
Return c * 10
End
In un Modulo (si può ovviamente utilizzare anche un'apposita Classe) principale poniamo questo codice:
Public Sub Main()
Dim mn1 As New Module1 ' Creiamo un "Oggetto" del Modulo chiamato "Module1" '
Dim i As Integer
i = mn1.Prova_1(10)
Print i
End
Funziona tutto.
Sapete cosa vi dico? Che non ci capisco più niente, credevo che... e invece...
Public Sub Main()
Dim hclasse As New Class1("Ma come!")
End
Create Static
Public Sub _new(sPippo As String)
Print sPippo
End
A static class cannot be instantiated: it would create an object with no dynamic variable, which is useless.
Caro Vuott potresti essere così cortese di ripartire con le spiegazioni filosofiche e farci capire cosa qui si intende per variabile dinamica?
:ciao: :ciao:
La questione fondamentale risiede nella differenza in tale contesto fra "Statico" e "Dinamico".
Data l'importanza dell'argomento Boege avrebbe dovuto spendere qualche parola in più per specificare e chiarire il significato di quelle due accezioni in Gambas.
Ad ogni modo mi pare che il nucleo del suo ragionamento sia il seguente:
" Now, a module is a normal class in which every symbol is implicitly madestatic by the compiler.
You can still create objects from a module but thatisn't useful because you don't have dynamic symbols
in a module. You will just end up with multiple objects that all reference the same data. "
combinato con queste righe del suo esempio:
Dim x As New Mod
......
Mod.A = 12
x.Func()
Mod.Func()
Si ha dunque che è possibile creare regolarmente Istanze individuali, singoli Oggetti di un Modulo mediante la parola-chiave "New"; ma i Simboli delle Istanze di un Modulo non sono suscettibili di diretta lettura né di assegnazione diretta di valori, restando questa caratteristica una prerogativa del Modulo, del quale quegli Oggetti sono Istanze.
In ciò si sostanzia l'affermazione di Boege per cui la creazione di Istanze individuali di un Modulo "that isn't useful", ossia non possiede alcuna utilità pratica.
Provate infatti ad aggiungere e provare queste righe:
......
x.A = 1990
Print x.A
Mod.Func()
......
Tutto giusto quello che dici, ma io personalmente, avendo sempre usato normalmente i moduli per routine di appoggio non avevo mai notato sostanziali differenze con le classi.
Invece grazie a Tobias ora è chiaro che le differenze ci sono e come, basta cambiare il modulo con una classe e provare lo stesso codice per rendersi conto di quello che invece io non riuscivo a capire.
Per essere più chiari copiate in Class1 il codice del modulo e cambiate così:
Public Sub Main()
Dim cl As New Class1
Dim x As New Class1
' Show that Mod and x share the same (static) variable A:
cl.A = 10
x.Func()
cl.A = 12
x.Func()
cl.Func()
' Dump all symbols (they show up as static)
DumpSymbols(x)
End