Indirizzare dati da un programma ad un altro e ad un Terminale
Il caso in questione è quello in cui si inviano dati da un programma Gambas ad un altro programma Gambas e ad un Terminale.
Indice
Invio dei dati da un programma Gambas ad un altro
In questo caso, abbiamo due progetti Gambas, che per comodità chiameremo A e B. Il progetto "B" invia dati al progetto "A". Per inviare i dati dal programma "B" al programma "A" si potranno utilizzare alcune modalità.
Uso della risorsa Pipe di Gambas
Paragrafo in costruzione
Uso del file speciale /dev/pts/... e del file descriptor 1 associati al processo del programma ricevente
Sarà possibile inviare i dati anche utilizzando il file speciale (/dev/pts/...) associato al programma "A" ricevente, oppure il file descriptor n. 1 (/proc/PID_del_processo_di_A/fd/1) associato al processo del programma "A" ricevente. In questo caso si potranno avere due effetti a seconda del codice scritto nei due programmi.
Caso in cui i dati ricevuti in console/Terminale possono essere soltanto visualizzati
Inviando i dati semplicemente con le funzioni Write o Print al file-descriptor associato al programma ricevente o al file speciale pts del programma ricevente, i dati potranno essere soltanto visualizzati in console/Terminale, ma non recuperati per essere eventualmente gestiti.
Uso dei file speciali /dev/pts/...
Nel progetto "A", che riceve i dati inviati dal programma "B", avremo il seguente codice:
Public Sub Main()
Dim pts As String
' Ricaviamo e mostriamo in console/Terminale il file speciale che rappresenta il progetto "A" (il nome del file "pts" servirà per il programma "B" inviante):
pts = Dir("/dev/pts", "*", gb.Device)[0]
Print pts
' Restiamo in attesa dei dati inviati:
While True
Wait 0.01
Wend
End
Nel progetto "B", che invia i dati al programma "A", avremo il seguente codice:
Private fl As File
Public Sub Main()
Dim pts As String
' Qui va inserito il nome numerico del file speciale (pts) che rappresenta il progetto "A":
pts = ....
' Viene aperto il file speciale che rappresenta il progetto "A":
fl = Open "/dev/pts/..." For Write
' Viene inviata la stringa di caratteri al file speciale che rappresenta il progetto "A":
While True
Print #fl, "Testo qualsiasi"
Wait 0.3
Wend
End
Uso del file descriptor n. 1
In quest'altro esempio il programma "B" invia di continuo il valore progressivamente incrementato di una variabile. La stringa dei dati inviata è formattata in modo tale che nella console del programma "A" ricevente (se esso è aperto come progetto nell'IDE) ovvero nel Terminale (se il programma "A" è stato lanciato da Terminale) i dati verranno di volta in volta visualizzati sovrascritti.
Nel progamma "A", che riceve i dati, avremo il seguente codice:
Public Sub Main()
' Ricaviamo e mostriamo in console o in Terminale il PID del programma "A" ricevente (il PID servirà per il programma "B" inviante):
Print Application.Id
' Restiamo in attesa dei dati inviati:
While True
Wait 0.01
Wend
End
Il codice del programma "B", che invia i dati, in questo esempio sarà il seguente:
Private fl As File
Public Sub Main()
Dim fl As File
Dim i As Integer
Dim nome_processo, PID As String
' Qui va assegnato il PID del programma "A" ricevente i dati:
PID = .....
' Apriamo il "file-descriptor" n. 1 del processo del programma "A" in scrittura:
fl = Open "/proc" &/ PID &/ "fd/1" For Write
' Ciclo per l'invio continuo - ogni 500 millisecondi - del valore progressivamente incrementato della variabile di tipi Intero:
While True
' Formattiamo la stringa in modo tale che i dati, di volta in volta inviati, si sovrascrivano ai precedenti:
Write #fl, "\r" & i
Wait 0.5
Inc i
Wend
End
Caso in cui i dati ricevuti in console/Terminale possono essere anche recuperati dal programma ricevente
Affinché i dati ricevuti possano essere anche gestiti, è necessario nel programma ricevente aprire in lettura e porre in Osservazione con la parola chiave Watch il file speciale pts del programma che invia i dati, ed il programma inviante deve aprire in scrittura il file speciale pts del programma ricevente. Inoltre il codice del programma inviante dovrà prevedere l'invio dei dati mediante la funzione Shell ed i relativi comandi bash.
Mostriamo di seguito un semplice esempio pratico:
Paragrafo in costruzione
Uso della Classe Clipboard
Si potranno trasmettere dati anche sfruttando gli "Appunti" di sistema con una sorta di copia-incolla, da effettuarsi mediante la Classe Clipboard di Gambas. In particolare utilizzeremo le funzioni .Copy() e .Paste() della Classe Clipboard.
Durante il trasferimento dei dati da un programma all'altro bisogna prestare attenzione a non effettuare alcun'altra copia di caratteri (per esempio con il mouse), o comunque di altri dati, altrimenti verrà trasmesso il contenuto della nuova copia di dati appena effettuata.
Ovviamente, trattandosi di "Appunti" di sistema, i dati potranno essere raccolti pure da altri programmi, anche non-Gambas.
Facciamo un esempio pratico. Avendo due programmi, A che deve trasferire dei dati al programma B, nel programma A avremo il seguente codice, capace di copiare dati negli appunti:
Public Sub Button1_Click() Dim s As String s = "Prova trasferimento dati stringa" Clipboard.Copy(s) End
mentre nel programma B avremo il seguente codice, capace di raccogliere quanto precedentemente copiato negli appunti dal programma A:
Public Sub Button1_Click() Dim s As String s = Clipboard.Paste() Print s End
Scrivere nella finestra del Terminale
Se viene aperto un Terminale virtuale distinto dal programma Gambas, e si intende scrivere al suo interno, si potranno utilizzare o il file speciale associato al Terminale aperto: il suo percorso è /dev/pts/n; oppure si potrà usare il file descriptor num. 1 associato al processo del Terminale.
Uso del file speciale della cartella pts
Volendo utilizzare il comando Shell per conoscere il nome del file speciale associato ad un certo terminale virtuale è sufficiente dare allo shell di quel terminale il comando tty:
Shell tty
Se, invece, si vuole fare a meno del comando Shell per conoscere il nome del file speciale associato, bisogna tenere in considerazione che la console dell'IDE di Gambas si comporta come un Terminale virtuale; e pertanto anche ad essa sarà associato un file speciale nella directory /dev/pts/N. Se non sarà già aperto un Terminale virtuale, il numero del file associato alla Console dell'IDE di Gambas, sarà 0, altrimenti sarà il primo numero successivo a quello dell'ultimo Terminale aperto. Identico discorso vale per i terminale virtuali aperti successivamente all'apertura dell'IDE di Gambas.
Mostriamo un codice esemplificativo, con il quale scriveremo all'interno di una finestra Terminale mediante le sole funzioni di Gambas.
E' necessario aver impostato nel progetto anche il componente "gb.desktop" e "gb.desktop.x11":
Public Sub Form_Open()
' Apre un Terminale:
Desktop.OpenTerminal
End
Public Sub Button1_Click()
Dim fl As File
' Apre in scrittura il file "speciale" associato al Terminale virtuale appena lanciato.
' Esso può essere individuato in questo modo:
fl = Open "/dev/pts" &/ Dir("/dev/pts", "*")[0]" For Write ' ...o anche “For Output”
' Se si intende scrivere nel terminale ogni stringa appresso alla precedente, allora si userà “Write”:
Write #fl, "stringa da scrivere nel terminale"
' Se si intende scrivere ogni stringa l'una sotto l'altra, allora si utilizzerà “Print”:
Print #fl, "stringa da scrivere nel terminale"
' Oppure semplicemente solo "Print":
Print #fl, "stringa da scrivere nel terminale"
fl.Close
End
N.B. Seppure sia possibile - come abbiamo visto - scrivere all'interno della finestra del terminale, non è però possibile utilizzare tale possibilità per lanciare dalla finestra del Terminale dei comandi, magari in combinazione con l'istruzione "Desktop.Sendkeys(Chr(10))", se non in quest'altra modalità.
Uso del file descriptor associato al processo del Terminale ed utile alla scrittura dei dati
In tal caso si tratta di individuare preliminarmente il numero del PID del processo del Terminale, e quindi il file descriptor utile per la scrittura nel Terminale dei dati desiderati.
Il codice può essere il seguente:
Private fl As File
Public Sub Form_Open()
Dim pr, s As String
pr = "/proc" &/ PID_del_processo &/ "fd"
For Each s In Dir(pr, "*")
If Stat(pr &/ s).Link Like "/dev/pts/*" Then Exit
Next
fl = Open pr &/ s For Output
End
Public Sub Button1_Click()
' Se si vuole far scrivere nel terminale una riga "sotto" l'altra
' ogni volta che si preme il tasto, allora si utilizzerà "Print":
Print #fl, "testo qualsiasi"
' Se si vuole far scrivere nel terminale una riga "dopo" l'altra
' ogni volta che si preme il tasto, allora si utilizzerà "Write":
Write #fl, "testo qualsiasi"
fl.Close
End
