Pillole di GNOME

Spread the love

Ho dovuto fabbricarmi un allarme visivo per una attività che devo svolgere a intervalli regolari durante la giornata.

Ho realizzato questo compito utilizzando

  • Gnome
  • cron

Gnome

Gnome open source free spftware linux desktop environment
Gnome open source free software linux desktop environment

Gnome è uno degli ambienti grafici desktop utiizzati da molte distribuzioni Linux (RedHat, Ubuntu, Fedora e altri) per gestire il sistema grafico a finestre. Esso si basa sul server X (come gli altri sistemi, ad esempio KDE). Non ho sviluppato molto in questo ambiente tipicamente desktop, essendomi occupato più di web.

In ogni caso lo trovo molto divertente; in pratica si programma in Javascript e si usa uno speciale interprete che utilizza le API del server, gjs.

Ho preso spunto dal questo tutorial (Gnome developer) ed l’ho personalizzato. In sostanza si tratta di aprire una finestra di X da linea di comando: essa contiene una semplice immagine e un messaggio, l’aspetto è questo:

Finestra che si apre eseguendo il programma Gnome listato qui sotto

Il codice Javascript è questo di seguito, lo descrivo sommariamente, per i dettagli si veda il tutorial di Gnome:

#!/usr/bin/gjs

imports.gi.versions.Gtk = '3.0';
const Gtk = imports.gi.Gtk;

class MyGrid {
    // Crea l'applicazione
    constructor() {
        this.application = new Gtk.Application();

        // Collega i segnali 'activate' e 'startup' alle funzioni di callback
        this.application.connect('activate', this._onActivate.bind(this));
        this.application.connect('startup', this._onStartup.bind(this));
    }

    // La funzione di callback per il segnale 'activate' presenta la finestra quando attiva
    _onActivate() {
        this._window.present();
    }

    // La funzione di callback per il segnale 'startup' costruisce la UI
    _onStartup() {
        this._buildUI ();
    }

    // Costruisci la UI dell'applicazione
    _buildUI() {

        // Crea la finestra applicativa
        this._window = new Gtk.ApplicationWindow({
            application: this.application,
            window_position: Gtk.WindowPosition.CENTER,
            border_width: 10,
            title: "Ora di bere!"});

        // Crea una immagine
        this.path = '/home/marcob/gnome';
        this._image = new Gtk.Image ({ file: this.path + '/bottiglia.png' });

        // Crea una etichetta
        this._label = new Gtk.Label ({ label: "Questo per ricordarti di bere!" });

        // Crea la griglia
        this._grid = new Gtk.Grid ();

        // Posiziona immagine ed etichetta nella griglia
        this._grid.attach (this._image, 0, 0, 1, 1);
        this._grid.attach (this._label, 0, 1, 1, 1);

        // Aggiungi la griglia alla finestra
        this._window.add (this._grid);

        // Mostra la finestra e tutti gli oggetti figli
        this._window.show_all();
    }

};

// Lancia l'applicazione
let app = new MyGrid ();
app.application.run (ARGV);

Leggiamo brevemente il sorgente: con il preambolo importiamo le funzioni dello Gnome Toolkit (GTK+) e definiamo la classe MyGrid che ci consente di progettare la finestra come una griglia.

Si collegano (bind) gli eventi a dei metodi che definiamo subito dopo (present() e _buildUI()).

Il core del programma è il metodo this._buildUI() che costruisce la User Interface utilizzano i metodi della libreria GTK+:

  • si definisce una nuova finestra GTK: new Gtk.ApplicationWindow();
  • si definiscono varie proprietà come posizione e titolo;
  • si definiscono una immagine caricata da file system e un titolo della finestra più altre proprietà geometriche;
  • si definisce la griglia all’interno della quale collocare gli oggetti (new Gtk.Grid ());
  • e si posizionano gli oggetti (this._grid.attach());
  • Finalmente si istanzia questa nuova classe e si lancia il metodo application.run();

Se si vogliono maggiori dettagli si veda il tutorial di Gnome

Ora questo programmino si può semplicemente lanciare da shell

$ gjs native.js

Il passo successivo è eseguirlo in automatico con periodicità (ad esempio ogni 20 minuti). Per fare questo utilizzo cron.

Modifico il mio cron personale tramite il comando

$ crontab -e

Il contenuto del file è il seguente (mi limito alla riga che definisce il comando):

# 
# m h  dom mon dow   command
0,20,40 /usr/bin/gjs /home/marcob/gnome/native.js

Questa impostazione provoca il ripetersi del comando ogni venti minuti.

Tuttavia incappo in un problema: in realtà il programma non parte e viene generato un errore nel syslog

Unable to init server: Impossibile connettersi: Connessione rifiutata

(gjs:25833): Gtk-WARNING **: 16:00:01.480: cannot open display: 

Questo è perché il processo cron esegue i comandi in uno spazio “virtuale” che non ha display. Quindi occorre indicare a cron quale display usare:

# 
# m h  dom mon dow   command
0,20,40 export DISPLAY=:0 && /usr/bin/gjs /home/marcob/gnome/native.js

L’indicazione della direttiva export DISPLAY=:0 serve per poter agganciare il server X. Il risultato è quello voluto ed io sono forzato a bere un po’ d’acqua ogni venti minuti per evitare la ritenzione idrica! 🙂

Lascia un commento

Your email address will not be published.

Questo sito usa Akismet per ridurre lo spam. Scopri come i tuoi dati vengono elaborati.