Introduzione all'interfaccia grafica: X Window System

X Window System

E' possibile operare su un sistema Linux in due modi: tramite una shell, con interfaccia testuale a caratteri, particolarmente comoda su server, o tramite un più accessibile ambiente grafico, con un mondo di finestre e icone gestite via mouse.

Il sistema grafico di Linux viene comunemente chiamato X (X Window System) che nel tempo è diventato lo standard GUI (graphic user interface) di Unix e Linux.
A differenza di Microsoft Windows in cui l'interfaccia a finestre è parte integrante del kernel, in Unix è un normale processo e viene trattato come tale, con i vantaggi (maggiore stabilità del sistema nel momento in cui si dovesse bloccare) e gli svantaggi (prestazioni penalizzate) del caso.

L'ambiente grafico X è composto essenzialmente da questi componenti:
Server X
E' il processo che si occupa di gestire il display, ovvero si occupa di far interagire l'utente con la GUI. Esistono molteplici server X, ma su Linux sono diffusi Xorg e XFree86.
Alternative commerciali sono Accelerated-X e Metro-X.

Windows manager
Sono i software che si occupano di gestire le finestre e l'interazione con l'utente, ne esistono numerosi e possono essere alla base di sistemi desktop più complessi e completi. Fra i nomi più noti KDE (è un sistema Dekstop con un proprio Window Manager), Enlightenment, Sawfish, AfterStep, FVWM, Blackbox, Fluxbox, Metacity..

Desktop Manager
Insieme di programmi, che offrono una interfaccia unificata, coerente ed integrata. I Desktop Manager più conosciuti e utilizzati  sono Gnome e KDE, dotati di tutto il software necessario per un ambiente desktop moderno, con XFCE terzo incomodo, sicuramente più "leggero".

Client X
Sono tutti i programmi eseguiti sotto X, con cui l'utente interagisce (ad esempio un browser, un word processor ecc.).

Il fatto di avere un'architettura client-server permette di utilizzare facilmente un server X locale (che mostra l'ambiente grafico sul nostro schermo) con un client in esecuzione su una macchina remota (potrebbe essere un server di applicazioni, particolarmente dotato in termini di hardware, dove di fatto vengono eseguiti i programmi che si usano).
Un'applicazione possimile di questa struttura prevede dei terminali con poche risorse hardware (thin client), a volte senza harddisk e giusto una scheda video e di rete, che caricano il sistema operativo via network, ospitano localmente un server X ed eseguono programmi (client X) su un server centrale.

Comunemente, quando si utilizza Linux sul proprio computer, il server e i client coesistono e vengono eseguiti sulla stessa macchina, ma prima di poter lanciare i client (i programmi, in ambiente grafico, che l'utente normalmente esegue), bisogna avere il server X funzionante.

Gnome, KDE e altri ambienti Desktop

L'interfaccia grafica su Linux può basarsi su diversi ambienti desktop (Desktop Environment o Desktop Manager), che mirano alla definizione di un interfaccia a finestre omogenea, coerente, semplice da usare ed integrata: Gnome e KDE sono i più conosciuti e generalmente usati nelle distribuzioni Linux, ma esistono alternative come XFCE e il vecchio CDE.

Gnome e KDE hanno le caratteristiche tipiche di un ambiente desktop evoluto: un file manager integrato e coerente, un layer di librerie tramite il quale è possible realizzare programmi con un look&feel comune, degli ambienti di sviluppo IDE che semplificano lo sviluppo di applicazioni native, canali omogenei di comunicazione fra programmi ecc.

Kde (K Desktop Environment)
Comprende, oltre ad un Windows Manager autonomo, un'intero ambiente desktop molto user friendly. Fornisce vari sistemi integrati per la gestione e configurazione del sistema oltre a vari programmi come una suite office completa (KOffice) e un IDE - Ambiente di sviluppo integrato (Kdevelop).
Si basa sulle librerie Qt ed utilizza un proprio metodo di comunicazione fra processi: DCOP.

Gnome (GNU Network Object Model Environment)
E' scritto e sviluppato dal Gnome Developer's project e fa parte del progetto GNU. A differenza di KDE Gnome è solo l'ambiente desktop per cui ha bisogno di un windows manager come FVWM (Fantastic Virtual Windows Manager). Anche Gnome offre dei propri sistemi integrati per la gestione della macchina. La sua architettura è completamente basata su CORBA.
Si basa sulle librerie GTK ed utilizza Corba per la comunicazione fra processi con l'implementazione OBRit.

Molte distribuzioni Linux prevedono la possibilità di installare ed utilizzare sia Gnome che KDE, è poi possibile modificarli e aggiornarli secondo le proprie necessità.
E' possibile lanciare programmi per KDE sotto Gnome e viceversa (sono tutti client X), l'interoperabilità reciproca migliora ma resta l'onere di caricare in memoria le librerie di base di entrambi e quindi appesantire sistemi non ben dimensionati.

XFCE
E' un ambiente desktop che sta crescendo molto perchè mantiene la caratteristica di essere leggero, e quindi permettere un agevole uso anche su hardware non potente.

Utilizzare XWindow da remoto

XWindow è un sistema client server in cui il server si occupa della visualizzazione del display e il client è il singolo programma eseguito.
Normalmente client e server coesistono sulla stessa macchina e all'utente questa natura non appare in tutte le sue potenzialità.
E' possibile infatti eseguire programmi su macchine remote e visualizzarli sulla propria macchina.

Per farlo, in modo rapido, si possono seguire 2 vie:

Sistema normale
Consideriamo un sistema in cui la nostra macchina ha IP 10.0.0.90 e vogliamo visualizzare sul nostro schermo comandi sulla macchina 10.0.0.20.
Per farlo sulla macchina locale va impostato (con non pochi potenziali problemi di sicurezza), solitamente come root, su alcuni sistemi anche come utente normale:
xhost + Apre a tutti gli IP la possibilità di collegarsi all'X server locale o
xhost + inet:10.0.0.90 Limita l'accesso solo all'IP 10.0.0.90
Mentre sulla macchina remota, basta collegarsi in telnet e impostare come Xserver il proprio IP:
export DISPLAY=10.0.0.20:0
A questo punto qualsiasi programma che richiede l'ambiente grafico lanciato dalla shell aperta in remoto viene visualizzato sullo schermo del PC locale.

Sistema criptato tramite SSH
Se è abilitata l'opzione X11forwarding sia sul client che sul server SSH, si possono lanciare programmi remoti e visualizzarli sul Xserver locale in modo molto più semplice e sicuro.
Per farlo basta collegarsi via SSH con l'opzione -X. Per esempio:
ssh -X 10.0.0.20
A questo punto qualsiasi programma grafico lanciato sulla macchina remota viene visualizzato automaticamente sul proprio schermo, senza bisogno di ulteriori configurazioni.

Se c'e' un firewall fra client X remoto e server X locale, ricordarsi di aprire la porta 6000 TCP, utilizzata dall'X Window System

rdesktop: Un client di Terminal Services per Unix

Rdesktop è un RDP client per Unix: in pratica l'anello mancante per accedere a sistemi Windows remoti dal proprio Linux tramite la funzionalità di accesso remoto e condivisione desktop chiamata Terminal Services su Windows 2000 Server e Remote Desktop su WindowsXP.
Di fatto con una comoda riga di comando rdesktop permette di aprire una sessione su un Windows 2000 Server remoto o un WindowsXP e visualizzarne il contenuto in una finestra all'interno del proprio ambiente X Window.
Terminal Services funziona molto meglio di VNC (ha protocollo più ottimizzato che supporta meglio limiti di banda) e il client per Unix / Linux permette quello che promette: la gestione e l'uso di server Windows remoti dalla propria postazione Linux.

La sintassi è semplice e si rimanda alla documentazione ufficiale per maggiori informazioni.
Per esempio:
rdesktop -P 98% -k it -u al 10.0.0.100 &
apre una sessione sul server Windows 10.0.0.100, con nome utente al, con dimensioni della finestra al 98% del proprio schermo e usando il layout di tastiera italiana.

Dalla versione 1.3, minima raccomandata, è migliorata la compatibilità con tastiere internazionali (tra cui l'italiana) e la possibilità di fare un copia e incolla dalla macchina locale Linxu alla finestra del Windows remoto.

Download e installazione sono semplicissimi:
make Nella directory scompattata, per compilare (senza particolari configurazioni).
./rdesktop nomeserver Per collegarsi al server remoto.
./rdesktop ? Per un elenco delle opzioni disponibili.

Internet Protocol Version 6 su WinXP SP2

Il seguente tutorial spiega come ri-attivare ipv6 con il service pack 2 su Windows Xp.

    +------------------------------------------+
        | Tips, scritto per i disperati in cerca   |
        | del loro ipv6, che avendo messo il       |
        | Service PAKKO 2 su Windows XP non va più!|
        |                           |
        +------------------------------------------+


+---------------------------------------------------------------------------------------------+
|                                                                                             |
|                                                      |
|   1) Pannello di controllo                                           |
|   2) Centro sicurezza PC                                      |
|   3) Impostazioni di Windows Firewall "DISATTIVARLO"                          |
|   4) A sinistra c'è scritto "Cambiare la modalità con cui il Centro sicurezza PC avisa      |
|      l'utente". Apritelo e disabilitate l'avviso firewall.                      |
|   5) Adesso chiudete il Centro Sicurezza PC e sempre dal pannello di controllo andate a     |
|      "Strumenti di amministrazione" e poi "Servizi".                          |
|   6) Fate doppio click sul servizio Centro sicurezza PC e impostate tipo di avvio MANUALE   |
|      invece di automatico e premete sul pulsante Arresta. Poi fate ok.                  |
|   7) Ripetete lo stesso procedimento per il servizio Windows Firewall / Condivisione        |
|      connessione Internet (ICS).                                  |
|   8) A questo punto, riavviate winzozzo e siete appost :)                                   |
|                                                      |
+---------------------------------------------------------------------------------------------+

+---------------------------------------------------------------------------------------------+
| - Per suggerimenti o delucidazioni <[email protected]> ciao! ;)                          |
+---------------------------------------------------------------------------------------------+

ddcprobe

Script in python utilizzato anche da tools come redhat-config-xfree86 o firstboot per diagnosticare tutte le info possibili riguardanti scheda video e monitor.

Comando utile per diagnosticare la configurazione corretta del proprio hardware, relativa alla scheda video e monitor. Richiede:
- Python installato
- Deve essere lanciato come superuser

Esempio:
[root@giraffa root]# ddcprobe
Videocard DDC probe results
Description:  NVidia Corporation NV10 Reference Board
Memory (MB):  32

Monitor DDC probe results
ID: PZC4343
Width (mm): 670
Height(mm): 670

Usare i Font di Windows su Linux con Fontconfig

Fontconfig è il nuovo font subsystem utilizzato da XFree86 per gestire in maniera più semplice i caratteri sotto Linux. Grazie ad esso è possibile utilizzare i font Windows in Linux in pochi passi.

Il processo per aggiungiere i font a Fontconfig e renderli quindi disponibili al sistema consta di soli due passi:
- E' necessario copiare i nuovi font nella directory /usr/share/fonts/local/ (in caso si voglia aggiungere dei font solo ad un determinato utente si devono copiare nella cartella nascosta .fonts/ nella rispettiva home directory;
- Successivamente da una shell si deve lanciare il comando fc-cache indicando come parametro la directory in cui risiedono i font (Es. fc-cache /usr/share/fonts/local/);

Al momento alcuni software, come per esempio OpenOffice.Org e AbiWord non sono ancora progettati per utilizzare Fontconfig e necessitano di procedure personalizzate per utilizzare i font di sistema.

X su Windows

Come è possibile eseguire dei programmi che richiedono X su una macchina remota e visualizzarli in locale tramite macchine *nix e' possibile eseguire le stesse operazioni anche con un client windows.

Semplicemente installando un software che simula un Xserver sulla macchina windows (per lo piu' sono shareware o freeware) e' possibile far interagire la macchina UNIX con quella Windows.

Anche qui vale cio' che e' stato detto nell'infobox "Utilizzare XWindows remoto" connettendosi via ssh tramite secureCRT o simili bisogna abilitare X11 forwarding altrimenti bisogna configurare il proprio Xserver locale per accettare le connessioni dall'IP della macchina remota la quale dovra' eseguire l'export del display.

Come usare i font di Windows su Linux

Per avere sul proprio Linux anche i font Windows (utili per visualizzare coerentemente vari siti web):
- Chiudere X e andare in modalità testo.
- Copiare i font da Windows (es: c:\windows\font ) ad una directory sul proprio Linux (es: /usr/local/lib/X11/ fonts/TrueType/ )
- Generare la nuova lista di font: spostarsi nella directory in cui sono stati copiati e scrivere:
ttmkfdir -d /usr/local/lib/X11/fonts/TrueType/ -o fonts.dir
- Aggiungere il nuovo path al font server:
chkfontpath --add /usr/local/lib/X11/fonts/TrueType/
- Ristartare il font server:
/etc/rc.d/init.d/xfs restart

Le funzioni in C

Il seguente tutorial spiega le funzioni con il linguaggio di programmazione C.

+--------------------------------+
|                                |
| # SOMMARIO #                     |
|                             |
| c1 - Definizione         |
| c2 - Dichiarazione         |
| c3 - Funzioni vs. puntatori    |
| c4 - Passaggio di parametri    |
| c5 - Ringraziamenti            |
|                 |
+--------------------------------+

+---------------------------------------------------------------------------------------------+
| c1 # DEFINZIONE #                                          |
|                                                  |
| La definizione di una funzione basata sulla specifica iniziale della sintassi del           |
| linguaggio, si presenta nella seguente forma:                              |
|                                                  |
| tiporitornato nomefunzione(lista_parametri_formali)                          |
|                  dichiarazione_parametri_formali                          |
|    {                                                  |
|    definizioni/dichiarazioni                                          |
|                                                  |    
|    lista_statement                                          |
|    }                                                  |
|                                                      |
|                                                  |
| Se il tiporitornato non viene specificato, per default viene assunto di tipo int.           |
| Se la funzione non ritorna alcun risultato. allora tiporitornato deve essere specificato    |
| di tipo void.                                              |
|                                                  |
| Esempio di definizione:                                      |
|                                                  |
|  int fattoriale(n)                                          |
|        int n;                                              |
|    {                                                  |
|    if (n > 1)                                              |
|      return n*fattoriale(n-1);                                  |
|    else                                              |
|      return 1;                                          |
|    }                                                  |
|                                                      |
|                                                  |
| La definizione della funzione effettuata in base alle specifiche della versione ANSI del    |
| linguaggio C, assume la forma:                                  |
|                                                                                             |
|  tiporitornato nomefunzione(dichiarazione_parametri_formali)                      |
|    {                                                  |
|    definizioni/dichiarazioni                                      |
|                                                  |
|    lista_statement                                          |
|    }                                                  |
|                                                      |
|                                                  |
| Se la funzione non accetta parametri, la dichiarazione_parametri_formali deve essere        |
| specificata di tipo void.                                      |
| Esempio:                                              |
|                                                  |
|    int funzione_senza_parametri(void)                               |
|                                                                      |
| Esempio di definizione:                                      |
|                                                  |
|  int fattoriale(int n)                                      |
|    {                                                  |
|    if (n > 1)                                              |
|      return n*fattoriale(n-1);                                  |
|    else                                              |
|      return 1;                                              |
|    }                                                  |
|                                                      |
|                                                  |
| Indipendentemente dai 2 modi di definizione della funzione, essa ha termine al           |
| verificarsi di una delle condizioni:                                       |
| o     viene esguita l'istruzione return                                                     |
| o     l'ultima istruzione del corpo della funzione e' stata eseguita                        |
| Quando la funzione termina, il controllo torna al chiamante.                          |
|                                                  |
| Una funzione puo' essere invocata tramite il codice:                                  |
|                                                  |
| nomefunzione(lista_parametri_attuali)                                |
|                                                      |
|                                                  |
| N.B. - Il C non specifica l'ordine di valutazione dei parametri attuali, pertanto bisogna   |
| prestare attenzione affinche' gli effetti collaterali non intervengano su variabili         |
| utilizzate anche per altri parametri.                                  |
| Esempio di chiamata ERRATA:                                      |
|                                                  |
|  int j=0;                                              |
|  ...                                                  |
|  funzione(j=5, j+1);           /* ERRATA */                                  |
|                                /* Puo' venire eseguita la valutazione di              |
|                                 * j+1, prima dell'assegnamento j=5 !!!                      |
|                                 * (dipende dalla implementazione del                        |
|                                 * compilatore) */                                           |
|                                                  |
+---------------------------------------------------------------------------------------------+


+---------------------------------------------------------------------------------------------+
|                                                                                             |
| c2 # DICHIARAZIONE #                                                                        |
|                                                                                             |
|                                                                                             |
| Nella versione originale del linguaggio la dichiarazione si presenta con la sintassi        |
| seguente:                                              |
| tiporisultato nomefunzione();                                                  |
|                                                      |
|                                                  |
| mentre nella versione ANSI, appare il concetto di prototype della funzione, attraverso il   |
| quale viene effettuato il controllo del tipo dei parametri passati durante la chiamata      |
| della funzione.                                              |
| Il controllo e' effettuato al tempo di compilazione e questo costituisce, senza dubbio,     |
| un notevole vantaggio.                                      |
| Il prototype presenta la sintassi seguente:                              |
|                                                  |
| tiporisultato nomefunzione(dichiarazione_parametri_formali);                      |
|                                                      |
|                                                  |
| Qualora la funzione non accetti parametri, la dichiarazione_parametri_formali deve essere   |
| definita come void.                                              |
|                                                  |
| In entrambe le situazioni, la dichiarazione della funzione e' necessaria se viene invocata  |
| prima della sua definizione, oppure se e' definita in altro file e compilata separatamente. |
|                                                                                             |
+---------------------------------------------------------------------------------------------+


+---------------------------------------------------------------------------------------------+
|                                                                                             |
|  c3 # FUNZIONI vs. PUNTATORI #                                                              |
|                                                                                             |
| Il linguaggio C consente di dichiarare e/o definire, oltre alle funzioni, anche i           |
| puntatori alle funzioni.                                      |
| Ad essi possono essere assegnati gli indirizzi di altre funzioni, poiche' il tipo della     |
| funzione abbia lo stesso tipo della funzione puntata, cioe' che il puntatore punti ad un    |
| tipo di funzione con gli stessi parametri formali (per numero, posizione e tipo)            |
| e abbia lo stesso tipo di risultato, rispetto alla funzione di cui si vuole assegnare       |
| l'indirizzo.Inoltre i puntatori a funzione possono essere dereferenziati allo scopo di      |
| eseguire il codice della funzione a cui puntano.                          |
|                                                  |
| Inoltre il C considera il nome della funzione come il puntatore al suo codice, per cui non  |
| occorre applicare gli operatori indirizzo & e indirezione *, sebbene il linguaggio ne       |
| permetta anche il loro impiego.                                  |
| Esempio:                                              |
|                                                  |
|  int funz(int a);              /* prototype funzione */                      |
|                                                  |
|  int (*pf)(int);               /* pf e' puntatore ad una funzione, avente un                |
|                                 * parametro di tipo int e ritorna un int, cioe'             |
|                                * int f(int) */                                              |
|                                                  |
|  ...                                                  |
|                                                  |
|  pf = &funz;                   /* oppure pf = funz; */                      |
|  (*pf)(5);                         /* oppure pf(5); */                                      |
|                                                      |
|                                                  |
| Facendo uso di puntatori, anche le funzioni possono far parte dei parametri di una funzione |
| e possono essere restituite come risultato di una funzione.                      |
| Data l'equivalenza tra il puntatore della funzione ed il suo nome, anche per questi casi è  |
| possibile impiegare semplicemente il nome della funzione, senza far                   |
| uno dell'operando indirizzo.                                                                |
|                                                                                             |
+---------------------------------------------------------------------------------------------+

+---------------------------------------------------------------------------------------------+
|                                                                                             |
|  c4 # PASSAGGIO DI PARAMETRI #                                                              |
|                                                                                             |
|   Nel C il passaggio dei paramteri ad una funzione, avviene sempre per valore, per cui non  |
|   e' possibile che una funzione abbia degli effetti collaterali sui parametri passati.      |
|   Esempio: #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt;                    |
|            void funz(int a); int main(int argc, char *argv) { int a=10;               |
|            printf("a = %d\n\n", a); /* stampa "a = 10" */ funz(a); printf("a = %d\n\n", a); |
|            /* stampa ancora "a = 10" */ return 0; } void funz(int a) { a/=2;                |
|            printf("a = %d\n\n", a); /* stampa "a = 5" */ }                       |
|                                                  |
| Qualora, invece, sia proprio necessario che la chiamata di una funzione produca degli       |
| effetti collaterali, allora diventa indispensabile passare alla funzione gli indirizzi di   |
| memoria di dove si devono ottenere gli effetti collaterali. In altri termini vengono        |
| passati alla funzione gli indirizzi degli argomenti per i quali siano richiesti gli effetti |
| collaterali.                                                  |
|                                                  |
| In questo modo, i puntatori sono ancora passati per valore, e pertanto non possono essere   |
| modificati dalla funzione, mentre puo' venire modificato il contenuto a cui essi puntano.   |
| Esempio: ... int main(int argc, char *argv[]) { int a1, b1, c1; ...                         |
| inizializza(&amp;a1, &amp;b1, &amp;c1); /* chiamata alla funzione */ ... }                  |
| void inizializza(int *a, int *b, int *c) { *a = 5; *b = 7; *c = 20; }                       |
|                                                                                             |
+---------------------------------------------------------------------------------------------+


+---------------------------------------------------------------------------------------------+
|                                                   |
| c5 # RINGRAZIAMENTI #                                                                       |
|                                                                                             |
|                                                                                             |
|  Ringraziamenti:  Mio Prof. di Matematica. :***                           |
|                   (Se non fosse per lui, oggi questo tutorial non sarebbe qui)              |                
|                   zbs e gli amici di #el8                                                   |
|                   Rhapsody  ed il Team di Sideralis                           |
|                                                      |
|  [ skorpion@IRCnet: #giardini - #el8 - #sideralis - #linux-cafe - #odio - #void ]           |
|                                                  |
|  Commento: Non sono un granchè come programmatore in C, anche io sto imparando pian piano.  |
|                                                                                             |
|                                                         |
|                                                                                             |
|  Per suggerimenti o delucidazioni <[email protected]> ciao! ;)                     |
|                                                                                             |
|                                                      |
+---------------------------------------------------------------------------------------------+