Versione delle 15:00, 19 mag 2021

Come è noto, un Componente di Gambas viene di norma attivato dall'IDE seguendo la seguente procedura:

Progetto-->Proprietà-->Componenti

e quindi nell'apposita finestra si attiva il Componente prescelto cliccando sul suo riferimento.

E' possibile, però, attivare un Componente anche successivamente, in modo dinamico, da codice. Per poter fare ciò, si dovrà fare uso del metodo .Load() della Classe statica "Component":

  Component.Load("gb.nome_del_componente")

Esempio

Si faccia, infatti, questo esempio, nel quale si dovrà far aprire un file con il suo programma di default mediante il Metodo ".Open()" della Classe Desktop. L'applicativo nell'esempio non ha attivato il componente gb.desktop, indispensabile per poter utilizzare il predetto comando:

Desktop.Open("/percorso/del/file/da/aprire")

previsto dall'applicativo medesimo.
Si proverà a verificare cosa succede cliccando prima sul tasto Button1, e successivamente sul tasto Button2:

Public Sub Form_Open()

End


Public Sub Button1_Click()

' Si effettua il tentativo di apertura di un file qualsiasi senza alcun tipo di attivazione del Componente "gb.desktop":
   Desktop.Open("/percorso/del/file/da/aprire")

End


Public Sub Button2_Click()

' Si procede ad attivare il Componente Gambas "gb.desktop", per poter utilizzare la funzione "Desktop.Open()".
' Inoltre si verificherà il suo nome, e se esso è stato effettivamente caricato:
   Print "Componente \""; Component.Load("gb.desktop").Name; "\" caricato: "; Component.IsLoaded("gb.desktop")

' Quindi si effettua il tentativo di apertura di un file qualsiasi:
   Desktop.Open("/percorso/del/file/da/aprire")

End

Gestione dei Metodi e delle Proprietà posseduti da una Classe di un Componente attivato da codice

I Metodi e le Proprietà di una Classe appartenente ad un Componente, attivato da codice, possono essere gestiti direttamente attraverso i Metodi nativi della Classe.
Vediamo appresso un esempio (è necessario attivare i Componenti "gb.gui.qt", o altro Componente grafico, e "gb.image"):

Public Sub Main()
 
' Le Classi, appartenenti a Componenti attivati da codice, essendo "creabili", devono essere "istanziate" come tipo "Object":
 Dim fin, mappa, mp As Object
 
 Component.Load("gb.net")
 Component.Load("gb.net.curl")
 Component.Load("gb.map")
 
 With fin = Class.Load("Window").New(Null)
   .Center
   .Y = 100
   .W = 500
   .H = 500
   .Show()
 End With
 
 mp = Class.Load("MapPoint").New([41.89018, 12.49230])
 
 With mappa = Class.Load("MapView").New([fin])
   .X = 0
   .Y = 0
   .W = fin.W
   .H = fin.H
   .Map.AddTile("GoogleMap", "https://mt0.google.com/vt/lyrs=s&hl=&x={x}&y={y}&z={z}")
   .Map.Zoom = 15
   .Map.Center = mp
 End With
 
End

Inoltre, Metodi e Proprietà di una Classe, appartenente a un Componente attivato da codice, potranno essere pure richiamati mediante il Metodo "Object.Call()".

Gestione dei Metodi di una Classe mediante il Metodo "Object.Call()"

Come detto, la gestione dei Metodi di una Classe di un Componente, attivato da codice, può avvenire utilizzando il Metodo "Object.Call()".

Mostriamo un esempio, nel quale, dopo aver attivato un Componente, sarà richiamata una sua specifica Classe, della quale vengono utilizzati due Metodi:

Public Sub Main()
 
 Dim cl As Class
 Dim symb As String
 Dim ob As Object
 
' Viene attivato, ad esempio, il Componente "gb.sdl2.audio":
  Component.Load("gb.sdl2.audio")
 
' Viene presa in considerazione la Classe "Sound" del Componente "gb.sdl2.audio":
  cl = Class.Load("Sound")
  
' Pro memoria vengono mostrate tutte le risorse appartenenti alla Classe "Sound" del Componente "gb.sdl2.audio":   
  For Each symb In cl.Symbols
    Print symb
  Next
  
' Viene richiamato il metodo ".Load()" della Classe "Sound" per caricare un file audio di formato WAV:
  ob = Object.Call(cl, cl.Symbols[0], ["/percorso/del/file.wav"])
   
' Si usa la varibile di tipo "Oggetto", restituita dal precedente metodo "Object.Call()",
' per richiamare il metodo ".Play()" della Classe "Sound", al fine di eseguire il file audio WAV caricato:
  ob.play()
  
End

oppure anche così (in questo caso usiamo la Classe "Music" del Componente "gb.sdl2.audio"):

Public Sub Main()
 
 Dim cl As Class
 Dim symb As String
   
' Viene attivato, ad esempio, il Componente "gb.sdl2.audio":
  Component.Load("gb.sdl2.audio")
 
' Viene presa in considerazione la Classe "Music" del Componente "gb.sdl2.audio":
  cl = Class.Load("Music")
  
' Pro memoria vengono mostrate tutte le risorse appartenenti alla Classe "Music" del Componente "gb.sdl2.audio":   
  For Each symb In cl.Symbols
    Print symb
  Next
  
' Viene richiamato il metodo ".Load()" della Classe "Music" per caricare un file audio di formato WAV:
  Object.Call(cl, cl.Symbols[1], ["/percorso/del/file.wav"])
   
' Viene ora invocato il Metodo ".Play()" per l'esecuzione del file audio WAV caricato:
  Object.Call(cl, cl.Symbols[2], Null)
  
  Do
    Sleep 0.01
  Loop
  
End

Gestione delle Proprietà possedute da una Classe di un Componente attivato da codice

La gestione delle Proprietà può avvenire utilizzando i Metodi ".GetProperty()" e ".SetProperty()" della Classe "Object", assegnando al primo argomento di tale Metodo la variabile che si riferisce alla Classe prescelta del Componente richiamato.

Mostriamo un semplice esempio:

Public Sub Main()
 
' Viene attivato il Componente "gb.sdl2.audio":
 Component.Load("gb.sdl2.audio")
 
' Viene presa in considerazione la Classe "Music" del Componente "gb.sdl2.audio":
 cl = Class.Load("Music")
 
' Viene richiamato il metodo ".Load()" della Classe "Music" per caricare un file audio o Midi:
 Object.Call(cl, cl.Symbols[1], ["/percorso/del/file"])
 
' Viene ora invocato il Metodo ".Play()" per l'esecuzione del file audio o Midi caricato
 Object.Call(cl, cl.Symbols[2], Null)
 
' Per utilizzare alcune "Proprietà" della Classe "Music", viene usato il Metodo "Object.GetProperty()",
' assegnando al suo primo argomento direttamente la variabile che si riferisce alla Classe "Music":
 While Object.GetProperty(cl, "State") == Object.GetProperty(cl, "Playing")
' Mostra il tempo trascorso dall'inizio dell'esecuzione:
   Write CStr(Time(0, 0, 0, Object.GetProperty(cl, "Pos") * 1000)) & "\r"
 Wend
 
 Print "Esecuzione terminata !"
 
End

Differenza fra l'uso di Classi "Statiche" e l'uso di Classi "Creabili"

Negli esempi precedenti abbiamo visto come operare attivando da codice un Componente e utilizzando una o più sue Classi "Statiche".
Nel presente paragrafo, invece, vedremo come operare volendo utilizzare anche Classi "Creabili" di un Componente attivato da codice.

Va detto che nel caso di uso di Classi "Creabili", sarà necessario creare appunto una "Istanza", un "Oggetto" di tali Classi, altrimenti verrà sollevato un errore proprio attinente all'impossibilità di utilizzare una risorsa della Classe "Creabile", direttamente passando come argomento la correlata variabile di tipo "Class".
Tali Istanze delle Classi "creabili" vanno create, come variabili di tipo "Object", mediante il Metodo ".New()" della Classe "Class".

Mostriamo un esempio, nel quale verranno richiamate alcune Classi "creabili" e una Classe "statica" del Componente "gb.media":

Public Sub Main()
 
 Dim clMP, clMD, clMC As Class
 Dim obPL, obMC As Object
 Dim s As String
 
 Component.Load("gb.media")
 
 clMP = Class.Load("MediaPipeline")   ' Classe "Creabile"
 clMC = Class.Load("MediaControl")    ' Classe "Creabile"
 clMD = Class.Load("Media")           ' Classe "Statica"
 
' Poiché la Classe "MediaPipeline" è creabile, non può essere utilizzata in modalità "Statica"; e pertanto dovrà essere creata una sua istanza. In tale caso si dovrà usare il Metodo ".New()" della Classe "Class" e non il Metodo "Object.New()", altrimenti non sarà possibile.
 obPL = clMP.New(Null)
' Identico discorso anche per la Classe "MediaControl". In questo caso si dovranno impostare il "Genitore" e il "Tipo".
 obMC = clMC.New([obPL, "playbin"])
 
' Richiama il Metodo "Url()" della Classe "Media". Qui è possibile usare direttamente la variabile di tipo "Class", poiché la Classe "Media" è "Statica".
 obmc["uri"] = Object.Call(clMD, "Url", ["/percorso/del/file/multimediale"])
 
 Object.Call(obPL, "Play", Null)
 
' Consente l'esecuzione del file audio sino a quando, aprendo la Console/terminale, si premerà il tasto "Invio" sulla tastiera:
 Input s
 
 Object.Call(obPL, "Stop", Null)
 Object.Call(obPL, "Close", Null)
 
End