Versione delle 15:39, 16 mag 2023

Per terminare un programma esterno aperto è possibile usare:

• le funzioni Kill o Killall (a seconda delle situazioni). Va distinto però il ".Kill()", quale Metodo di Process, dal Kill, quale comando da utilizzare con Shell (o Exec);
• un algoritmo capace di chiudere la sua finestra.

Uso dei comandi Kill e killall

Caso in cui un programma esterno sia stato aperto dalla nostra applicazione.gambas, sia gestito mediante "process", e si intenda chiuderlo con il Metodo ".Kill()" di Process

Private pro As Process


Public Sub Form_Open()

' Avviamo un programma esterno e lo gestiamo come processo:
 pro = Exec["nome_programma_esterno"]

End


Public Sub Button1_Click()

' Chiudiamo il programma esterno mediante il Metodo ".Kill()" di "Process":
 pro.Kill

 pro.Close

End

Per questo caso vedere anche la nota ^{[nota 1]}.

Caso in cui un programma esterno non sia stato aperto dalla nostra applicazione.gambas, e non sia gestito mediante Process

In questo caso potremo utilizzare due soluzioni.

1) Possiamo chiudere il programma esterno con il comando Killall, lanciato con Shell (o Exec), al quale passiamo il nome del programma:

Public Sub Button1_Click()

 Shell "Killall nome_programma_esterno"

End

2) Possiamo chiudere il programma esterno con il comando Kill, lanciato con Shell (o Exec), al quale passiamo il numero del PID del programma. ^{[nota 2]}

Public Sub Button1_Click()

   Shell "Kill numero_PID_del_programma_esterno"

End

L'utilità di quest'ultima modalità può vedersi nel caso in cui si hanno più programmi .gambas aperti e si intende chiuderne uno solo. Poiché il nome del processo (visibile nel file /proc/numero_pid/comm) è identico a tutti i programmi .gambas (ossia: gbr3), se si adottasse il comando precedente killall gbr3, si chiuderebbero tutti i programmi .gambas aperti. Se, invece, si usasse quel comando inserendo il nome del programma, ossia così: killall nome_programma, si otterrebbe questo errore: nome_programma: nessun processo trovato, in quanto il comando bash killall vuole il nome del processo del programma, e non quello del programma visibile nel file esecutivo.
Allora, potremo inserire il nome del programma Gambas, ed individuare il suo PID.
In tal caso sarà possibile utilizzare il comando bash kill:

Public Sub Button1_Click()

 Dim s1, s2, pid As String
   
 s1 = InputBox("Inserire il nome del programma Gambas (con l'estensione .gambas):")

 For Each pid In Dir("/proc", Null, gb.Directory)
   If Exist("/proc" &/ pid &/ "cmdline") Then
     s2 = File.Load("/proc" &/ pid &/ "cmdline")
     If s2 Like "*" & s1 & "\x00" Then Shell "kill " & pid
   Endif
 Next

End

oppure la funzione esterna "kill()" di C, alla quale bisognerà passare il PID del programma esterno. Tale funzione esterna invierà un segnale SIGKILL connesso al programma esterno da chiudere:

Private Const SIGKILL As Integer = 9
Private Extern kill_C(pid As Integer, signal As Integer) As Integer In "libc:6" Exec "kill"

Public Sub Main()

 Dim s, d, t As String
  
 t = "programma_esterno" 
 
 For Each s In Dir("/proc", Null, gb.Directory)
   If Exist("/proc" &/ s &/ "cmdline") Then 
     d = File.Load("/proc" &/ s &/ "cmdline")
     If d Like "*" & t & "\x00" Then kill_C(Val(s), SIGKILL)
   Endif
 Next

End

Caso in cui il programma esterno sia stato aperto dalla nostra applicazione.gambas, e si intenda chiuderlo con il comando bash Kill

Possiamo avere due sotto-casi.

1) Se il programma è gestito tramite Process, possiamo passare al comando bash Kill il numero del PID ottenuto mediante la Proprietà ".Id" di Process nel modo spiegato in questa pagina.

2) Se il programma non è gestito mediante Process, allora si dovrà scegliere un altro algoritmo per individuare e raccogliere il numero del PID del prgramma esterno da chiudere.

Quello che è da sottolineare, è che in entrambi i suddetti sotto-casi il numero del PID di un programma aperto dalla nostra applicazione.gambas mediante Shell (o Exec), affinché l'esecuzione del comando Kill abbia buon fine, deve essere passato a Kill incrementato di un'unità:

Public Sub Button1_Click()
 
 Dim pidIncrementato As Integer

 pidIncrementato = numero_PID_del_programma_esterno + 1

 Shell "Kill pidIncrementato"

End

Uso di altro codice capace di chiudere la finestra di un programma esterno

mediante le risorse della Classe DesktopWindow di Gambas

Possiamo chiudere il programma esterno anche attraverso la chiusura espressa della sua finestra ^{[nota 3]}. In questo caso, però, non utilizzeremo i comandi bash Kill e Killall, bensì con la classe DesktopWindow. In tal caso si dovrà attivare nel progetto anche il Componente "gb.desktop":

Public Sub Button1_Click()

  Dim ii As Integer[]
  Dim dw As DesktopWindow

' Viene individuato l'Handle del programma che ha generato la propria finestra:
  ii = Desktop.FindWindow("nome_programma o nome_della_finestra_del_programma")

' Viene individuata la finestra in base al suo handle, e viene quindi inserita in una variabile di tipo "DesktopWindow":
  dw = Desktop.Windows.FromHandle(ii[0])

' Viene infine chiusa la finestra del programma, e pertanto il programma medesimo:
  dw.Close()
 
End

mediante le risorse della Classe Signal di Gambas

In quest'altro caso si dovrà attivare il Componente "gb.signal" di Gambas ed inviare il segnale SIGKILL con la Classe statica Signal:

Public Sub Main()
 
 Signal.Send(numero_PID_del_programma_da_chiudere, Signal.SIGKILL)
  
End

mediante la funzione esterna "XDestroyWindow()" della libreria X11

Per distruggere la finestra di un programma esterno si potrà utilizzare anche la funzione "XDestroyWindow()" della libreria condivisa (nella sua attuale versione) libX11.so.6.3.0.

Tale funzione esterna richiede, fra l'altro, la specificazione del numero identificativo della finestra del programma da chiudere.

Mostriamo un esempio:

Library "libX11:6.3.0"

' Display *XOpenDisplay(display_name)
' Opens a connection to the X server that controls a display.
Private Extern XOpenDisplay(displayP As Pointer) As Pointer

' XDestroyWindow(display, w)
' Destroys the specified window as well as all of its subwindows.
Private Extern XDestroyWindow(displayP As Pointer, w As Integer)

' XCloseDisplay(display)
' Closes the connection to the X server for the display specified in the Display structure and destroys all windows.
Private Extern XCloseDisplay(displayP As Pointer)


Public Sub Main()

 Dim disp As Pointer

' Connessione al server X ed impostazione di default:
 disp = XOpenDisplay(0)

 XDestroyWindow(disp, num_ID_della_finestra)

' Chiude la libreria:
 XCloseDisplay(disp)

End

Note

[1] Vedere al riguardo anche questa pagina: Apertura e chiusura di un processo mediante Process.

[2] Come cercare ed estrarre il PID di un programma, è stato già trattato in questa pagina: Individuare ed estrarre il PID di un programma.
Potremmo utilizzare, per trovare e passare il PID di un programma aperto e non gestito mediante Process, anche questo algoritmo:

Public Sub Button1_Click()

 Dim riga As String
 Dim plus As String[]

 Shell "pgrep -f nome_programma_da_chiudere" To riga

 plus = Split(riga, "\n")

' Passa a Kill il primo elemento dell'array stringa, il quale, essendo parte della stringa generata dal comando "pgrep", contiene sempre il numero del PID del programma:
  Shell "kill " & plus[0]

End

oppure quest'altro che, però, procederà in modo un po' più... brutale alla chiusura del programma:

Public Sub Button1_Click()

 Dim riga As String
 Dim plus As String[]
 Dim b As Integer

 Shell "ps -aux | grep " & "nome_programma_da_chiudere" To riga

 plus = Split(riga, " ")

 For b = 0 To plus.Max
' Passa a Kill - "forzatamente" - ed in modo distinto ogni elemento dell'array stringa.
' Quando Kill riceverà l'elemento contenente la stringa con il numero del PID del programma, questo si chiuderà:
   Try Shell "kill " & plus[b]
 Next

End

[3] Vedere anche Agire sulla finestra di un qualunque programma.