# Scoprire il funzionamento di &kde;

Nicolas
Goutte
goutte@kde.org

## Modifica manuale dei file di configurazione

### Introduzione

In &kde; i file di configurazione sono facili da modificare con un semplice editor di testi come &kate;, dato che sono file di testo.

Un esempio di un file di testo:

    [General]
    AutoSave=1
    LastFile=/var/tmp/test.txt

I file della configurazione specifica dell'utente sono memorizzati in `.kde/share/config` (cambia `.kde` con la tua variabile $`KDEHOME`) e quelli globali nelle sottocartelle del percorso di installazione di &kde; `share/config`. (Puoi trovare questo percorso eseguendo il comando `kde4-config --prefix`). I nomi dei loro file solitamente finiscono in rc (senza il punto iniziale), per esempio `kopeterc`.

Modificare a mano i file di configurazione può rovinare la stabilità della tua installazione &kde;. Le applicazioni solitamente non controllano quello che leggono dai file di configurazione. Questo significa che possono essere disturbate da quello che prendono come configurazione e potrebbero andare in crash.

### Copia di riserva

Così la prima regola è di fare una copia di riserva del tuo file prima di modificarlo. La copia di riserva è migliore se memorizzata fuori da qualsiasi sottocartella di `.kde` (o la corrispondente cartella $`KDEHOME`). Le copie di riserva sono comunque una buona idea in caso di un grave danno di &kde; che distruggerebbe importanti file di configurazione (per esempio le tue impostazioni di &kmail;, che sono nel file `kmailrc`). (Un danno così grave non dovrebbe avvenire ma può comunque succedere.)

### Modificare

Allora, perché toccare i file di configurazione? Bene, per prima cosa ne hai bisogno quando vuoi forzare la modalità KIOSK. Forse uno sviluppatore ti ha chiesto di aggiungere una voce per aiutarlo a risolvere un problema con l'applicazione. Forse vuoi risolvere un problema senza dover rimuovere tutta la cartella `.kde`. Forse vuoi imparare di più sulla complessità di &kde;.

Comunque, qualunque sia la ragione, vuoi modificare a mano un file di configurazione.

Quando pianifichi di modificare questo tipo di file, assicurati che l'applicazione che stai usando non è in esecuzione. Se è uno dei file di configurazione base, prendi in considerazione di modificare il file mentre &kde; non è proprio in esecuzione.

Pronto? Allora, fai una copia di riserva del file (Te l'ho già detto?), avvia il tuo editor preferito (prendiamo per esempio &kate;), carica il file (Stai attento a caricarlo come UTF-8, &kate; lo mostra come utf8).

Adesso hai un file simile a questo:

    [Group]
    Key1=Value1
    Key2=Value2
    Key3=Value3

Adesso lo puoi modificare (con attenzione!) e quindi salvarlo (Stai attento che sia nuovamente UTF-8).

Adesso puoi provare l'applicazione e se non sia avvia più correttamente, chiudila e ripristina la copia di riserva del file di configurazione.

#### Informazioni correlate

- ha più informazioni sulla struttura delle cartelle di &kde;, per aiutarti a trovare il file che hai bisogno di modificare.

## Scrivere uno script per il desktop

&kde; fornisce un potente sistema di comunicazione interprocesso in &DCOP;, il protocollo di comunicazione del desktop (Desktop COmmmunication Protocol). Usando &DCOP;, puoi controllare un'ampia varietà di funzioni in &kde; dalla riga di comando o da uno script scritto nella tua lingua preferita. Puoi anche ottenere informazioni da applicazioni &kde;: per esempio, molti player multimediali di &kde; forniscono metodi di richiesta al player per avere informazioni sulla traccia in riproduzione.

Generalmente parlando, ogni applicazione &kde; fornisce una o più interfacce &DCOP; che a loro volta forniscono metodi (o, se preferisci, funzioni) che un'altra applicazione può chiamare. Quindi, il primo passo per usare &DCOP;, è di trovare il metodo appropriato per il compito. La strada più veloce per fare ciò è usare l'interfaccia utente kdcop per i metodi di &DCOP; disponibili.

Avvia kdcop da una &konsole; o dalla mini-CLI (la finestra che appare premendo &Alt;F2 ). La finestra kdcop mostra le applicazioni correntemente in esecuzione che forniscono interfacce &DCOP;, usando una vista ad albero. In generale, per trovare il metodo corretto occorre una piccola ricerca attraverso la vista ad albero, ma un consiglio utile è che l'interfaccia marcata (predefinita) solitamente contiene le funzioni usate più frequentemente.

Per verificare che la funzione faccia ciò che ci aspettiamo, fai doppio clic sulla voce impostaColore. Per impostare il colore `c`, fai clic sul pulsante del selettore colore, e scegli un colore. Se il colore deve essere il colore A con la casella, configura l'impostazione. Fai clic su OK e il colore di sfondo è impostato.

Per accedere al metodo &DCOP; dal tuo linguaggio di scripting preferito, puoi usare sia la connessione &DCOP;, se disponibile nel modulo kdebindings, o chiamare l'applicazione a riga di coamando `dcop`. Per un uso semplice, chiamare l'applicazione a riga di comando `dcop` è sufficiente.

Specifichiamo l'applicazione, interfaccia e metodo in quel modo, seguiti dagli argomenti nello stesso ordine nel quale sono mostrati in kdcop. `dcop` ha una grande varietà di opzioni: guarda l'output di ``dcop` `--help``.

Abbiamo visto abbastanza teoria: è ora di fare un esempio:

### Uno script per cambiare il colore di sfondo con &DCOP;

Con l'applicazione a riga di comando `dcop` e un po' di Perl, faremo un semplice script che cambi ciclicamente lo sfondo del desktop attraverso lo spettro.

Per prima cosa, cerchiamo il metodo appropriato con kdcop. Per questo esempio, taglieremo corto: il metodo che vogliamo è kdesktop KBackgroundIface setColor . I tipi degli argomenti e dei parametri restituiti della funzione vengono mostrati nello stile del linguaggio C++. Per `setColor`, gli argomenti sono un colore, `c`, che specifica il nuovo colore dello sfondo, e un valore booleano (vero o falso), `isColorA`, che specifica se il colore è il primo o il secondo (questo è utile per impostare i gradienti eccetera).

Per usare il nostro metodo`setColor` nella riga di comando, scriviamo ciò che segue:

    % dcop kdesktop KBackgroundIface setColor '#ffffff' false

Per specificare il colore, usiamo il valore esadecimale RGB, come usato in &HTML;. Nota che è chiuso in apici singole per proteggere il # dalla shell.

Per trovare il valore esadecimale RGB di un colore, apri una qualsiasi finestra di scelta colore in un'applicazione &kde; (per esempio, in &kcontrolcenter;, Aspetto & Temi Colori ), seleziona il colore che desideri e usa il valore dato nella casella di testo HTML.

Ecco, è tutto quello di cui abbiamo bisogno da &DCOP;; adesso è necessario solamente scriverci uno script. È una implementazione (molto!) grezza:

    $min=49;  # Minimum value of R, G, or B colour
    $max=174; # Maximum value of R, G, or B colour
    $step=5;  # Amount to step colour by on each step
    $sleeptime=15; # Interval in seconds between each step

    @start = ($max, $min, $min);
    @colour = @start;

    while (1) {
            foreach (0..5) {
                    my $which = $_ % 3; # Which colour (R, G or B) to change
                    my $updown = $_ % 2; # Whether to increase or decrease the colour value
                    do {
                            if ($updown == 0) { $colour[$which]+=$step; }
                            if ($updown == 1) { $colour[$which]-=$step; }
                            my $dcopcall=sprintf "dcop kdesktop KBackgroundIface setColor '#%x%x%x' true\n", @colour;
                            system($dcopcall);
                            sleep $sleeptime;
                            } while (($colour[$which]
    >= $min) and ($colour[$which] <= $max));
                    }
    }

Avvia semplicemente lo script senza nessun argomento, e cambierà ciclicamente il colore di sfondo attraverso uno spettro leggermente mutato finché non viene ucciso. Voilà!

Naturalmente, Perl non è l'unico linguaggio che puoi usare per scrivere script con &DCOP;—se preferisci lo scripting shell, è disponibile anch'esso:

### Impostare uno sfondo da internet

Lo script seguente prende l'immagine principale dal fumetto User friendly e lo imposta come uno sfondo desktop, usando gli strumenti comunemente disponibili e un po' di &DCOP;:

    #!/bin/sh
    COMICURL=`wget -qO - http://www.userfriendly.org/static/index.html | \
              grep Latest | sed -e "s,.*SRC=\",," -e "s,\"
    >.*,,"`
    TMPFILE=`mktemp /tmp/$0.XXXXXX` || exit 1
    wget -q -O $TMPFILE $COMICURL
    dcop kdesktop KBackgroundIface setWallpaper $TMPFILE 1

La prima riga dopo #!/bin/sh usa `wget` e qualche espressione regolare per estrarre la posizione dell'immagine dalla risorsa &HTML; della pagina principale. La seconda e terza riga scaricano l'immagine, e infine, `dcop` imposta l'immagine scaricata come sfondo.

## Aggiungere combinazioni di tasti extra a &kde;

Molte tastiere moderne contengono tasti extra che non sono assegnati come impostazione predefinita a nessuna azione.

I tasti Multimedia generano spesso un segnale, e può essere scelto semplicemente come combinazione di tasto con un'applicazione a piacere scegliendo qualsiasi altro tasto. Qualche tasto tuttavia, non è individuato e premendolo in una Configura scorciatoie non ha alcun effetto.

Alcuni laptop IBM, d'altra parte, hanno tasti extra vicini alle frecce di sinistra e di destra, che appaiono come pagina sinistra e pagina destra.

1. Usa `xev` per trovare il codice dei tasti. In questo caso sono 233 e 234

2. Scegli i simboli dei tasti. Qua c'è una varietà abbastanza grande di quelli che non sono usati come predefiniti, così molti sono liberi. Puoi trovare la lista in `/usr/X11R6/include/X11/keysymdef.h` (o il suo equivalente nel sistema).

3. Crea un file nella tua cartella home chiamata `.Xmodmap`, e aggiungilo al seguente:

       keycode 233 = Next_Virtual_Screen
       keycode 234 = Prev_Virtual_Screen

4. Avvia il comando ``xmodmap` `~/.Xmodmap``

A questo punto, dovresti essere in grado di avviare `xev` nuovamente e vedere che i tasti generano ora il simbolotasto che hai assegnato. Puoi semplicemente assegnarli a qualsiasi azione normale.

### Informazioni correlate

- Puoi vedere il manuale di `xev` scrivendo `man:/xev` in una finestra di &konqueror; o scrivendo ``man` xev` in un terminale.

## Aggiungere combinazioni di tasti per nuove azioni

La maggior parte delle azioni sia nel desktop che nelle applicazioni sono subito disponibili per essere assegnate a una combinazione di tasti. Se l'azione per cui vuoi una scorciatoia è qualcosa che hai scritto da te, o è comunque non disponibile, puoi ancora assegnarle una scorciatoia.

Per unire le due sezioni precedenti, forse vuoi assegnare un tasto altrimenti inutilizzato della tua tastiera in uno script o comando dcop. Il nostro esempio qua sarebbe di assegnare i due tasti che abbiamo aggiunto nel per andare al precedente o al prossimo desktop virtuale, due funzioni per le quali avrai bisogno di DCOP (come discusso nel).

Questo può essere realizzato facilmente usando il metodo seguente:

1. Apri &kcontrol;, e nella sezione Regionali e Accesso facilitato &, seleziona Azioni di immissione

2. Scegli Nuova azione

3. Dai il nome alla nuova azione, &eg; `Prossimo schermo virtuale`

4. Seleziona Scorciatoia tastiera ->Comando/URL (semplice) per Action type:

5. Nella scheda Scorciatoia da tastiera, fai clic sul pulsante che vorresti usare per dare l'avvio al comando. Per questo esempio, vorresti premere quello con l'immagine Prossima Pagina. Prossimo_schermo_virtuale apparirà nell'immagine del tasto.

6. Nella scheda Impostazioni comando/URL, scrivi il comando per avviare nel campo: ``dcop kwin default nextDesktop``

Ripeti il precedente con il tasto Prev_Virtual_Screen e ``dcop kwin default previousDesktop``.

Adesso scrivendo Prev_Virtual_Screen o Next_Virtual_Screen ti porterà al desktop virtuale rispettivamente precedente o successivo.

Naturalmente puoi assegnare qualsiasi tasto libero a qualsiasi azione.

### Informazioni correlate

- Vedi la documentazione KHotKeys guardandola in &khelpcenter; o scrivendo `help:/khotkeys` in una finestra &konqueror;.

Adriaan
de Groot
groot@kde.org

## &kdebugdialog; - Controllare l'output di debug di &kde;

### Uso di base

&kdebugdialog; non è presente di defalut nel &kmenu;. Avrai bisogno di avviarlo dalla shell o da mini-CLI col comando ``kdebugdialog``. &kdebugdialog; mostra una finestra con una lunga lista di aree di debug. Ogni area ha una casella che puoi spuntare o alla quale puoi togliere il segno di spunta per abilitare o disabilitare l'output di debug per quella parte di &kde;.

La lista delle aree di debug è ordinata numericamente, non alfabeticamente, quindi kio (127) viene prima di artskde (400). I numeri vanno avanti fino a 200000 circa, ma in realtà ci sono solo 400 aree. Quindi non devi scorrere tutta la lista per trovare l'area di cui hai bisogno. C'è una casella di testo in alto nella finestra di dialogo dove puoi scrivere una parte del nome dell'area che desideri. La lista delle voci che vengono mostrate è filtrata per includere solo quelle aree di debug che contengono il testo che hai immesso. &eg; scrivendo `k` non viene filtrato molto, ma scrivendo `kont` verranno mostrate solamente le aree di debug di &kontact;. Come scorciatoia per attivare/disattivare l'output delle aree di debug , ci sono anche i pulsanti seleziona tutto e deseleziona tutto che fanno produrre a &kde; una montagna di output di debug, o una quantità minima.

### KDebugDialog in modalità completa

Nella modalità completa, quella che ottieni avviando kdebugdialog con``kdebugdialog` `--fullmode``, la stessa lista delle aree di debug sono disponibili come nella modalità semplice, ma puoi selezionare uno per volta dalla casella a cascata. Potresti anche impostare indipendentemente l'output per vari tipi di messaggi: informazioni, avvertimenti, errori e errori fatali. Per ognuno di questo tipo, puoi scegliere i messaggi da inviare. Le scelte sono:

File, in quel caso puoi scrivere il nome del file. Questo file è scritto nella tua cartella $`HOME`.

Casella di testo. Ogni messaggio di debug è mostrato in una finestra di informazioni, nella quale devi premere OK per continuare a usare l'applicazione.

Shell, la voce predefinita. I messaggi sono mostrati su stderr, e apparirà sia nelle finestra shell dove viene avviata l'applicazione, o in `.xsession-errors`.

Syslog. Questo invia ogni messaggio di debug al syslog del sistema, che può eseguire il suo proprio processo del messaggio.

Niente. Questo elimina l'output di questo tipo di messaggio.

Per i messaggi generati da errori fatali, è generalmente una cattiva idea scegliere Niente o Syslog, dato che in entrambi i casi probabilmente non vedrai il messaggio e l'applicazione che si sono imbattuti in un errore fatale, non lasciando così una traccia dell'errore che si è verificato. Per decidere se mostrare o no gli errori fatali si può controllare con la casella di testo termina se si verificano errori fatali che è spuntata di default — ma comunque dovresti aspettarti che un'applicazione che si è imbattuta in un errore fatale vada in crash comunque.