# Manuale di programmazione di &kdevelop;

2002-12-05
2.0
Ralf
Nolden

    Ralf.Nolden@post.rwth-aachen.de

Caleb
Tennis

    caleb@aei-tech.com

1999
Ralf Nolden
2002
Caleb Tennis
&FDLNotice;

Il manuale utente per lo sviluppo di applicazioni C++ in ambiente KDE con &kdevelop; IDE

KDE
KDevelop
IDE
development
programming

## Introduzione

Mentre i sistemi Unix statnno diventando molto e molto popolari TODO

### Cosa dovresti già conoscere

Per usare al meglio questo manuale di programmazione, si assume che tu abbia già la conoscenza della programmazione con il linguaggio C/C++, se così non fosse dovresti acuisire prima un po' di familiarità con questo linguaggio. Informazioni del linguaggio C++ sono disponibili grazie a vari sorgenti o in forma stampata nel localmente al tuo sistema nel tutorial che puoi trovare in Internet. Non è indispensabile conoscere come è stata progettato l'Interfaccia Grafica Utente TODO

### Informazioni su questo manuale

Questo manuale è stato scritto per dare agli sviluppatori una introduzione alla progettazione di applicazioni KDE utilizzando l'ambiente di sviluppo integrato KDevelop.

I capitoli seguenti tuttavia danno una introduzione a come creare i propri progetti, spiegando il codice sorgente già generato e mostrando come arricchiere questi sorgenti con altri oggetti come barre degli strumenti, barre dei menu e aree di vista.

Inoltre è discusso in dettaglio l'editor dei dialoghi, spiegando come sono creati i widget ed impostare in dettaglio tutte le loro proprietà.

Infine imparerai come molti soggetti TODO

#### Nel prossimo capitolo

Daremo un'occhiata alle librerie Qt e KDE, analizzando i concetti base e il perchè alcune cose vadano fatte in quella maniera.&kdevelop;'s best features.TODO

#### Nei capitoli seguenti

Imparerai come:

- create una applicazione con KappWizard

- Quale progetto scheletro già prevede

- Il significato del codice già creato

- Come creare le tue viste

- Come espandere le funzionalità delle tue applicazioni con dialoghi, barre di menu, e barre degli strumenti

- Come rendere la tua applicazione amichevoli per l'utente introducendo le funzioni di help

- Come scrivere la documentazione in linea

### Ulteriori informazioni

Ulteriori informazioni sulla programmazione con Qt/KDE sono disponibili con diversi sorgenti:

- Programmando con Qt di Matthias Kalle Dalheimer

- Il manuale utente in KDevelop, provvisto con l'IDE KDevelop

- La documentazione di riferimento delle librerie Qt

- Il sito dello sviluppatore KDE

Inoltre puoi ricercare aiuto sottoscrivendoti alle varie mailing list, i quali indirizzi sono disponibili sul sito menzionato, sui newsgroup Usenet degli utenti KDE e sistemi Unix così come riguardo il llinguaggio di programmazione C e C++. TODO

Per ottenere aiuto sull'uso dell'ambiente integrato KDevelop dovresti inviare una richiesta alla nostra mailing list a kdevelop@kdevelop.org. Ricorda che il gruppo di KDevelop è dedicato a provvedere il significato per abilitarti alla programmazione di applicazioni e tuttavia non intende dare un supporto tecnico nel caso in cui le tue applicazioni non funzionino a causa di errori di implementazione o configurazioni errate del tuo sistema. Per questo chiediamo a tutti gli utenti di prendere vantaggio dalla mailinglist in ogni caso ci siano dei problemi di esecuzione dell'ambiente integrato così come per comunicare errori o suggerimenti per aumentare la funzionalità dell'ambiente di sviluppo.

## Le librerie KDE e Qt

La società norvegese TrollTech (http://www.trolltech.com) fornisce uno strumento per la programmazione di GUI chiamate Qt. GUI sta per "Graphical User Interface", quindi le applicazioni Qt appaiono con pulsanti, finestre, ecc, permettendo all'utente l'inserimento e la visualizzazione dei dati inseriti. Questo strumento è necessario agli sviluppatori di applicazioni con interfaccia grafica per l'interfaccia X-Window dei sistemi Unix, in quanto X non contiene una sua interfaccia utente predefinita. Anche se sono disponibili altri strumenti per la creazione di interfaccie grafiche, Qt offre alcune tecniche vantaggiose per rendere semplice la loro progettazione. Inoltre Qt è disponibile anche per la piattaforma Windows, permettendo quindi agli sviluppatori di rendere disponibili le loro applicazioni per entrambe le piattaforme.

Il gruppo KDE (http://www.kde.org), unito insieme con l'obiettivo di facilitare l'uso dei sistemi Unix, ha deciso di utilizzare gli strumenti Qt per sviluppare su piattaforma X-Windows, oltre che una varietà di strumenti inclusi nei pacchetti KDE. L'ambiente di sviluppo KDevelop contiene il gestore di finestre kwm, il gestore dei file kfm ed il pannello di esecuzione kpanel come componenti principali, oltre che una varietà di utilità e applicazioni. Dopo l'uscita di KDE molti sviluppatori posero i loro occhi sopra questo nuovo ambiente e su cosa questo offriva. Le librerie KDE fornivano i metodi e le classi essenziali per la creazione e la progettazione di applicazioni con aspetto simile e coerente in modo che l'utente avesse un grande vantaggio in quanto doveva solo abituarsi con una sola modalità specifica di uso dell'applicazione, non con la gestione di dialoghi o pulsanti. Inoltre i programmi KDE interagiscono tra loro nel desktop e sono capaci di interagire con il gestore dei file con il trascinamento, offre gestori di sessione e molto altro se tutte le funzionalità offerte dale librerie KDE vengono usate. Sia Qt che le librerie KDE sono implementate in C++. Nel prossimo capitolo faremo un piccolo viaggio attraverso le librerie per vedere cosa è già fornito e come le applicazioni Qt e KDE sono in generate create. TODO

Entrambe, le librerie Qt e KDE, sono implementate con il linguaggio di programmazione C++, quindi le applicazioni che fanno uso di queste librerie sono principalmente scritte in C++. Nel seguente capitolo faremo un piccolo viaggio attraverso le librerie, per vedere cosa è previsto e come le applicazioni Qt e KDE sono generalmente create.

### Gli strumenti Qt GUI

Come detto la libreria Qt è un insieme di strumenti che offrono tutti gli elementi grafici che sono usati per creare le GUI delle applicazioni e sono necessarie per la programmazione su X-Window. Inoltre gli strumenti offrono:

- Un completo insieme di classi e metodi già pronti per l'uso anche per la programmazione di applicazioni non grafiche

- Una buona soluzione verso l'interazione con l'utente tramite metodi virtuali e tramite il meccanismo dei signale e degli slot

- Un insieme di elementi GUI predefiniti chiamati "widget" che possono essere facilmente usati per creare elementi visibili

- Inoltre dialoghi completamente predefiniti che sono spesso usati nelle applicazioni come barre di progressione e dialoghi di file

Tuttavia la conoscenza delle classi Qt è molto importante, anche se vuoi solamente programmare applicazioni KDE. Per renderti conto sui concetti base di come sono costruite e compilate le applicazioni GUI dovresti prima dare una occhiata ad un semplice programma Qt e quindi estenderlo ad un programma KDE.

#### La prima applicazione Qt

Normalmente i programmi in C++ devono contenere una funzione `main()`, che è il punto di partenza della loro esecuzione. Dato che vogliamo che questi abbiano un aspetto grafico a finestre e vogliamo che integiscano con l'utente, prima di tutto dobbiamo capire come presentarli all'utente. Per un esempio dovremmo cercare nel primo tutorial incluso nella documentazione di riferimento in linea di Qt e spiegare i passi base di esecuzione, anche per capire perché e come l'applicazione basata su finestre appare.

    #include <qapplication.h>
    #include <qpushbutton.h>

    int main( int argc, char **argv )
    {
    QApplication a( argc, argv );

    QPushButton hello( "Hello world!" );
    hello.resize( 100, 30 );

    a.setMainWidget( &hello );
    hello.show();
    return a.exec();
    }

Questa applicazione disegna soltanto una finestra contenente un pulsante che ha per testo "Hello world!". Come per tutte le applicazioni basate su Qt è necessario creare prima una istanza della classe `QApplication`, rappresentata dalla variabile a.

Successivamente il programma crea una istanza della classe `QPushButton` chiamata hello, questa rappresenta il pulsante. Il costruttore di hello riceve una stringa come parametro, la quale è il contenuto del widget visibile come pulsante con testo.

Quindi viene chiamato il metodo `resize()` sul pulsante hello. Esso cambia la grandezza predefinita del widget (che in questo caso è il `QPushButton`) che è stato creato, impostandolo con lunghezza di 100 pixel ed altezza di 30 pixel. Infine viene chiamato il metodo setMainWidget() per a e il metodo show() per hello. La QApplication è infine eseguita con `a.exec()` che fa entrare l'applicazione nel ciclo principale fino a quando un intero non verrà ritornato al sistema operativo segnalando che l'applicazione è terminata.

#### La documentazione di riferimento per Qt

Ora diamo una veloce occhiata alla documentazione di riferimento delle librerie Qt. Per fare questo avvia &kdevelop; e seleziona "Qt" dall'albero nella linghuetta della documentazione. Il browser della documentazione di apre e mostra la pagina iniziale del riferimento Qt. Questo sarà il primo posto in cui ricercare informazioni su Qt, esso mostra le classi disponibili. Inoltre il programma qui sopra è il primo incluso della sezione delle istruzioni. Per avere informazioni riguardo una classe che vogliamo usare dobbiamo cercare `QApplication`, selezionare "Lista delle classi in ordine alfabetico" e cercare il suo nome. Seguire una di queste per avere una visione della documentazione della classe.

Alternativamente puoi usare la documentazione in linea di Trolltech Documentazione Qt

Per `QApplication` potrai vedere il costruttore e tutti gli altri metodi che supporta questa classe. Se segui il collegamento ti verranno mostrate ulteriori informazioni riguardo l'uso ed il significato del metodo, il quale è molto utile quando qualche volta non conosci il corretto utilizzo o vuoi vedere un esempio. Questo conta anche come documentazione delle librerie KDE che usano un tipo di documentazione simile, tuttavia questo è quanto tu devi almeno sapere riguardo l'utilizzo del browser della documentazione di riferimento per le classi.

##### Capire l'esempio

Iniziando con `QApplication` troverai tutti i metodi utilizzati in questo primo esempio:

- il costruttore `QApplication()`

- il metodo `setMainWidget()`

- il metodo `exec()`

Capire perché utilizziamo questi metodi è molto semplice:

1. Creare una istanza della classe `QApplication` con il costruttore, così possiamo far uso degli elementi della GUI forniti da Qt

2. Creare un widget che sarà il contenuto delle nostro programma a finestre

3. Impostare il widget come widget grafico principale per a

4. Eseguire l'istanza di a di `QApplication`

Il secondo oggetto del nostro programma è il pulsante una istanza della classe `QPushButton`. Dai due costruttori dati a creare una istanza del pulsante qui c'è la stringa "Hello World!". Quindi chiamiamo il metodo `resize` per cambiare la dimensione del pulsante concordemente al suo contenuto - il pulsante deve essere più lango per fare in modo che la stringa sia completamente visibile.

Ma lo scopo del metodo `show()`? Ora vedi che come molti altri widget `QPushButton` è basato su una singola gerarchia la documentazione dice derivato da `QButton`. Successivamente il collegamento alla classe `QButton`. Questo ti mostra una serie di altri elementi che sono ereditati da `QPushButton` che useremo successivamente per spiegare il meccanismo dei signal e degli slot. Comunque il metodo `show()` non è riportato tuttavia esso deve essere un metodo presente da una classe derivata. La classe dalla quale `QButton` deriva è `QWidget`. Seguendo questo collegamento TODO

1. Creare una istanza di `QPushButton` usa il secondo costruttore per impostare il testo del pulsante

2. Ridimensionare il widget in base al suo contenuto

3. Impostare il widget come il principale dell'istanza della classe `QApplication` a

4. Dire al widget di mostrarsi sul video chiamando il metodo `show()` un metodo derivato dalla classe `QWidget`

Dopo aver chiamato il metodo `exec` l'applicazione è visibile all'utente e mostra una finestra con il pulsante contente "Hello World!". Nota: I programmi GUI hanno un comportamento alle volte diverso rispetto le applicazioni procedurali. La caratteristica principale in questo caso è che l'applicazione entra in un così detto "main event loop". Questo significa che il programma deve attendere le azioni dell'utente e quindi rispondere a queste, questo anche per una applicazione Qt, il programma deve trovarsi nel ciclo principale degli eventi per iniziare a gestire gli eventi. La prossima sezione spiega in breve, ai programmatori, cosa significa e cosa offre Qt per la gestione degli eventi dell'utente.

Per gli utenti più esperti: Il pulsante non ha la dichiarazione del genitore nel costruttore tuttavia esso è un widget di livello superiore e avviato in un ciclo di evento locale il quale non ha bisogno di attendere il ciclo principale degli eventi. Vedere la documentazione della classe QWidget e la Guida di Riferimento della libreria KDE

#### Interazioni con l'utente

Dopo la lettura dell'ultima sezione dovresti conoscere:

- Cosa prevede la libreria Qt in termini di applicazioni GUI

- Come viene creato un programma che utilizza Qt e

- Dove e come trovare, tramite il browser della documentazione, le informazioni riguardo le classi che vuoi utilizzare

Ora passiamo a dare "vita" all'applicazione processando gli eventi utente. Generalmente l'utente ha due modi per interagire con un programma: il mouse e la tastiera. Per entrambi l'interfaccia grafica utente deve fornire metodi per intercettare le azioni e metodi che eseguono qualcosa come risposta a queste azioni.

Il sistema Windows invia quindi tutti gli eventi di interazione di una data applicazione. La classe `QApplication` invia questi alla finestra attiva come un `QEvent` e i widget dovranno devicede cosa farne. Un widget riceve l'evento e processa `QWidget::event(QEvent*)`, il quale decide quindi quale evento è stato eseguito e come reagire, `event()` è tuttavia il gestore principale di eventi. Quindi il metodo `event()` passa l'evento ai così chiamati filtri di evento che determinano cosa è successo e cosa fare con l'evento. Se non esiste un filtro assegnato come responsabile per l'evento, i gestori specializzati per quell'evento saranno chiamati. Quindi possiamo decidere tra:

- Eventi di tastiera -- tasti TAB e Shift-TAB:

  - `virtual void focusInEvent(QFocusEvent *)`

  - `virtual void focusOutEvent(QFocusEvent *)`

- Tutti gli input dagli altri tasti:

  - `virtual void keyPressEvent(QKeyEvent *)`

  - `virtual void keyReleaseEvent(QKeyEvent *)`

- Movimenti del mouse:

  - `virtual void mouseMoveEvent(QMouseEvent *)`

  - `virtual void enterEvent(QEvent *)`

  - `virtual void leaveEvent(QEvent *)`

- Azioni del pulsante del mouse

  - `virtual void mousePressEvent(QMouseEvent *)`

  - `virtual void mouseReleaseEvent(QMouseEvent *)`

  - `virtual void mouseDoubleClickEvent(QMouseEvent *)`

- Eventi della finestra contenente il widget

  - `virtual void moveEvent(QMoveEvent *)`

  - `virtual void resizeEvent(QResizeEvent *)`

  - `virtual void closeEvent(QCloseEvent *)`

Notare che tutte le funzioni degli eventi sono virtuali e protette; quindi puoi implementare nuovamente gli eventi di cui hai bisogno nei puoi propri widget e specificare come essi debbano rispondere. `QWidget` contiene inoltre qualche altro metodo virtuale che può essere utile nei tuoi programmi; in ogni modo è sufficiente capire molto bene la classe `QWidget`.

#### Interazione degli oggetti con segnali e slot

Siamo ora giunti al più ovvio vantaggio degli strumenti Qt: il meccanismo dei segnali e degli slot. Questi offrono una comoda soluzione all'interazione tra oggetti, che normalmente viene risolta con funzioni di callback per gli strumenti X-Windows. Dato che questa comunicazione richiede una programmazione rigorosa ed alcune volte una difficoltosa creazione delle interfaccie utente (come riportato della documentazione Qt e dimostrato nella Programmazione in Qt di K.Dalheimer), Troll Tech ha inventato un nuovo sistema, dove gli oggetti possono emettere segnali che possono essere connessi ai metodi dichiarati come slot. Dalla parte del programmatore C++ è necessario solamente conoscere alcune cose riguardo questo meccanismo:

- la dichiarazione di una classe che usa i segnali e gli slot deve contenere la macro Q_OBJECT all'inizio (senza il punto e virgola) e deve essere derivata dalla classe `QObject`

- un segnale può essere emesso tramite la parola chiave emit, es: emit signal(parametri); dall'interno di ogni membro di una classe che permette l'uso di segnali e slot

- tutti i segnali utilizzati dalle classi che non sono derivate, devono essere aggiungi alla dichiarazione di classe da un sezione di segnali

- tutti i metodi che possono essere connessi con un segnale sono dichiarati nelle sezioni con un parola chiave aggiuntiva slot, es: public slot: all'interno della dichiarazione di classe

- il compilatore per i meta oggetto moc deve essere eseguito sul file di intestazione per espandere le macro e per produrre l'implementazione (che non è necessaria conoscere). I file di output dal moc saranno quindi compilati dal compiltore C++.

Un'altra strada per utilizzare i segnali senza derivare da `QObject` è utilizzare la classe `QSignal`- vedere la documentazione di riferimento per ulteriori informazioni ed esempi di utilizzo. Nel seguito assumiamo che si debba derivare dalla classe `QObject`.

In questo modo la tua classe può inviare ovunque segnali ed avere degli slot a cui collegare tali segnali. Utilizzando i segnali non dovrai preoccuparti di chi li riceverà, devi solo emettere il segnale e connetere a questo qualunque slot, a tuo piacimento, che risponda all'evento. Inoltre gli slot possono essere utilizzati come normali metodi durante l'implementazione.

Ora per connettere un segnale ad uno slot devi utilizzare i metodi `connect()` messi a disposizione dalla classe `QObject` o, quando disponibile, metodi speciali che gli oggetti forniscono per impostare la connessione ad un determinato segnale.

##### Semplice utilizzo

Per spiegare il modo di come impostare l'interazione con l'oggetto prendiamo nuovamente il nostro primo esempio ed estendiamolo con una semplice connessione:

    #include <qapplication.h>
    #include <qpushbutton.h>

    int main( int argc, char **argv )
    {
    QApplication a( argc, argv );

    QPushButton hello( "Hello world!" );
    hello.resize( 100, 30 );

    a.setMainWidget( &hello );

    connect(&hello, SIGNAL( clicked() ), &a, SLOT( quit() ));

    hello.show();
    return a.exec();
    }

Vedi, la sola aggiunta per dare al pulsante maggiore interazione, è utilizzare il metodo `connect()`: `connect(&hello,SIGNAL( clicked() ), &a,SLOT( quit() ))`, è tutto quello che devi aggiungere. Qual'è il significato? La dichiarazione della classe di QObject riguardo il metodo `connect()` dice:

`bool connect ( const QObject * sender, const char * signal, const QObject * receiver, const char * member )`

Viene specificato un puntatore dell'istanza `QObject`, il trasmettitore del segnale, che significa che esso può emettere questo segnale come primo parametro; dovrai quindi specificare il segnale che vuoi connettere. Gli ultimi due parametri sono l'oggetto ricevitore che fornisce uno slot, seguito dalla funzione membro che attualmente è lo slot che sarà eseguito successivamente all'emissione del segnale.

Utilizzando i segnali e gli slot i tuoi oggetti di programma potranno interagire tra loro facilmente senza esplicitamente dipendere sul tipo dell'oggetto ricevente. In questo manuale imparerai molto su come utilizzare in maniera produttiva questo meccanismo. Ulteriori informazioni riguardo i segnali e gli slot possono essere trovati in Guida di riferimento della libreria KDE e Riferimento Qt in linea.

### Cosa fornisce KDE

#### Le librerie KDE 3.x

Le librerie principali di KDE che utilizzerai per la creazione delle tue applicazioni KDE sono:

- la libreria kdecore, contenente tutte le classi degli elementi non visibili che forniscono funzionalità all'applicazione

- la libreria kdeui, contenente elementi dell'interfaccia grafica come barre dei menu, barre degli strumenti, ecc.

- la libreria kfile, contenente i dialoghi di selezione file

Inoltre, per precifiche soluzioni, KDE offre le seguenti librerie:

- la libreria kdefx, contenente pixmaps, effetti grafici e KStyle, l'estensione di QStyle

- la libreria khtml, contenente il componente html di KDE

- la libreria kjs, contenente il supporto Javascript di KDE

- la libreria kio, contenente l'accesso a basso livello ai file di rete

- la libreria kparts, contenente il supporto per il riutilizzo delle applicazioni estendibili ed incapsulabili

Successivamente daremo una occhiata a cosa è necessario trasformare la prima applicazione Qt in una KDE.

#### Esempio di application KDE

Nel seguito vedrai che scrivere una applicazione KDE non è molto più difficile che scrivere una applicazione Qt. Per l'uso delle funzionalità di KDE dovresti usare alcune altre classi, e sei quasi pronto. Come esempio discuteremo la versiona modificata del precedente esempio Qt:

    #include <kapplication.h>
    #include <qpushbutton.h>

    int main( int argc, char **argv )
    {
    KApplication a( argc, argv );

    QPushButton hello( "Hello world!" );
    hello.resize( 100, 30 );

    a.setTopWidget( &hello );

    connect(&hello, SIGNAL( clicked() ), &a, SLOT( quit() ));

    hello.show();
    return a.exec();
    }

Vedi che abbiamo prima di tutto cambiato la classe `QApplication` con la classe `KApplication`. Inoltre abbiamo cambiato la funzione precedentemente usata `setMainWidget()` con `setTopWidget`, che `KApplication` usa per impostare il widget principale. Ecco qua! La tua prima applicazione KDE è pronta - tu ora devi solamente dire al compilatore il percorso di inclusione di KDE e al linker di processare la libreria kdecode con la direttiva -lkdecore.

Dato che ora conoscete almeno cosa fornisce generalmente la funzione `main()`, come rendere visibile l'applicazione e come gli oggetti interagiscono con l'utente, con il prossimo capitolo andremo a creare la nostra prima applicazione con &kdevelop;. Potremo quindi provare ogni cosa detta precedentemente e vederne gli effetti.

Quello che dovresti consultare oltre a ciò che è stato visto fino ad ora è la documentazione di riferimento per Qt, in particolare le classi `QApplication`, `QWidget` e `QObject` oltre che la documentazione della libreria kdecore per la classe `KApplication` . Inoltre KDE Library Reference handbook copre una completa descrizione di come invocare i costruttori di classe `QApplication` e `KApplication` inclusi gli argomenti della riga di comando.

## Creare una nuova applicazione

### Il wizard di applicazione

Il wizard di applicazione di &kdevelop; mira a permetterti di iniziare a lavorare su un nuovo progetto con &kdevelop;. Quindi ogni cosa dei tuoi progetti viene prima creata da un wizard, quindi potrai iniziare la compilazione e l'estensione di quello che già viene fornito dallo schema di sorgente. Potrai scegliere tra molti tipi di progetto in accordo con i tuoi obiettivi:

- Il framework di applicazione KDE include codice sorgente per una completa struttura di una applicazione KDE standard

- Il progetto QMake crea una framework di applicazione basata sul sistema di configurazione qmake di Trolltech

- Il semplice programma hello world: Crea un programma C++ basato sul terminale senza il supporto GUI

- Una moltitudine di altri schemi di programma

In questo capitolo vedremo come il wizard di applicazione può essere invocato e cosa deve essere fatto per generare un progetto di applicazione KDE. Questo sarà anche il primo passo nella nostra trattazione, dove creeremo una versione iniziale di un semplice progetto. Per tutti gli altri tipo di progetto il metodo è normalmente lo stesso, ma non potrete avere mai così tante opzioni disponibili.

### Invocare il wizard di applicazione e la generazione del progetto

#### Avviare il wizard di applicazione e la prima pagina

Per iniziare con la tua applicazione KDE, lancia &kdevelop;. Dal menu Progetto selezione Nuovo Progetto. Verrà avviato il wizard di applicazione e vedrai un albero di selezione nella prima pagina contenente i tipi di progetti disponibili che puoi creare. Scegli il sottoalbero C++, quindi KDE, quindi Framework dell'applicazione.

Per il nostro semplice progetto creeremo l'applicazione KScribble. Inserire questo come nome dell'applicazione e cambiare le altre informazioni nel fondo del video secondo le tue preferenze. Quindi seleziona Prossimo. Wizard di applicazione

#### Informazioni sul controllo versione

Su questa schermata tu hai la possibilità di decidere se il tuo progetto utilizzerà un sistema per il controllo delle versioni come CVS. Per il nostro progetto non utilizzeremo il controllo dei sorgenti, quindi fai attenzione che la selezione sia Nessuno e selezione Prossimo.

#### Prototipo di sorgente e di intestazione

Le due prossime pagine mostrano esempi di intestazione che andranno all'inizio di ognuno dei tuoi file di codice e di intestazione che creerai utilizzando &kdevelop;. Per ora lasciamo questi come predefiniti e seleziona Prossimo, quindi Finito. Se il pulsante Finito non è attivo significa che non hai selezionato correttamente tutte le opzioni. Usa il pulsante Precedente per tornare ai menu precedenti e correggere gli errori.

#### Terminando

Dopo aver terminato, il wizard di applicazione dovrebbe chiudersi e una finestra con dei messaggi dovrebbe comparire visualizzando alcune informazioni riguardo il lavoro che &kdevelop; sta facendo. Alla fine di tutte le procedure dovresti vedere il messaggio *** Successo ***. Questo significa che il framework dell'applicazione è stato correttamente caricato.

### La prima compilazione

Dopo che il nostro progetto è stato generato faremo prima un viaggio attraverso il codice sorgente per apprendere in generale come il framework di applicazione appare. Questo non solo dovrebbe aiutare a partire, ma, nei prossimi passi, andremo a capire dove e come cambiare.

Questo capitolo fa l'assunzione che tu capisca la navigazione base di &kdevelop;. Consulta il manuale utente di KDevelop per informazioni di cui hai bisogno.

Automake visualizza i file di progetto come segue: I file nel nostro progetto

Prima di immergerci all'interno dei sorgenti di &kdevelop; avviamo una compilazione ed eseguiamo la nostra nuova applicazione. Per fare questo selezionare Compila Progetto dal menu Compila o premi F8. Una finestra di output si aprirà e mostrerà tutti i messaggi durante la fase di compilazione.

    1 cd /home/caleb/kscribble && WANT_AUTOCONF_2_5=1 WANT_AUTOMAKE_1_6=1 gmake k
    2 gmake all-recursive
    3 gmake[1]: Entering directory `/home/caleb/kscribble'
    4 Making all in doc
    5 gmake[2]: Entering directory `/home/caleb/kscribble/doc'
    6 Making all in .
    7 gmake[3]: Entering directory `/home/caleb/kscribble/doc'
    8 gmake[3]: Nothing to be done for `all-am'.
    9 gmake[3]: Leaving directory `/home/caleb/kscribble/doc'
    10 Making all in en
    11 gmake[3]: Entering directory `/home/caleb/kscribble/doc/en'
    12 /usr/local/kde3/bin/meinproc --check --cache index.cache.bz2 /home/caleb/kscribble/doc/en/index.docbook
    13 gmake[3]: Leaving directory `/home/caleb/kscribble/doc/en'
    14 gmake[2]: Leaving directory `/home/caleb/kscribble/doc'
    15 Making all in po
    16 gmake[2]: Entering directory `/home/caleb/kscribble/po'
    17 gmake[2]: Nothing to be done for `all'.
    18 gmake[2]: Leaving directory `/home/caleb/kscribble/po'
    19 Making all in src
    20 gmake[2]: Entering directory `/home/caleb/kscribble/src'
    21 source='main.cpp' object='main.o' libtool=no \
    22 depfile='.deps/main.Po' tmpdepfile='.deps/main.TPo' \
    23 depmode=gcc3 /bin/sh /home/caleb/kscribble/admin/depcomp \
    24 g++ -DHAVE_CONFIG_H -I. -I/home/caleb/kscribble/src -I.. -I/usr/local/kde3/include
       -I/usr/lib/qt/include -I/usr/X11R6/include -DQT_THREAD_SUPPORT -D_REENTRANT -Wnon-virtual-dtor
       -Wno-long-long -Wundef -Wall -pedantic -W -Wpointer-arith -Wmissing-prototypes -Wwrite-strings
       -ansi -D_XOPEN_SOURCE=500 -D_BSD_SOURCE -Wcast-align -Wconversion -O2 -fno-exceptions -fno-check-new
       -c -o main.o `test -f 'main.cpp' || echo '/home/caleb/kscribble/src/'`main.cpp
    25 /usr/lib/qt/bin/moc /home/caleb/kscribble/src/kscribble.h -o kscribble.moc
    26 source='kscribble.cpp' object='kscribble.o' libtool=no \
    27 depfile='.deps/kscribble.Po' tmpdepfile='.deps/kscribble.TPo' \
    28 depmode=gcc3 /bin/sh /home/caleb/kscribble/admin/depcomp \
    29 g++ -DHAVE_CONFIG_H -I. -I/home/caleb/kscribble/src -I.. -I/usr/local/kde3/include
       -I/usr/lib/qt/include -I/usr/X11R6/include -DQT_THREAD_SUPPORT -D_REENTRANT -Wnon-virtual-dtor
       -Wno-long-long -Wundef -Wall -pedantic -W -Wpointer-arith -Wmissing-prototypes -Wwrite-strings
       -ansi -D_XOPEN_SOURCE=500 -D_BSD_SOURCE -Wcast-align -Wconversion -O2 -fno-exceptions -fno-check-new
       -c -o kscribble.o `test -f 'kscribble.cpp' || echo '/home/caleb/kscribble/src/'`kscribble.cpp
    30 kscribble.cpp: In member function `void KScribble::setupActions()'
    31 kscribble.cpp:107: warning: unused variable `KAction*custom'
    32 /usr/lib/qt/bin/moc /home/caleb/kscribble/src/kscribbleview.h -o kscribbleview.moc
    33 source='kscribbleview.cpp' object='kscribbleview.o' libtool=no \
    34 depfile='.deps/kscribbleview.Po' tmpdepfile='.deps/kscribbleview.TPo' \
    35 depmode=gcc3 /bin/sh /home/caleb/kscribble/admin/depcomp \
    36 g++ -DHAVE_CONFIG_H -I. -I/home/caleb/kscribble/src -I.. -I/usr/local/kde3/include
       -I/usr/lib/qt/include -I/usr/X11R6/include -DQT_THREAD_SUPPORT -D_REENTRANT -Wnon-virtual-dtor
       -Wno-long-long -Wundef -Wall -pedantic -W -Wpointer-arith -Wmissing-prototypes -Wwrite-strings -ansi
       -D_XOPEN_SOURCE=500 -D_BSD_SOURCE -Wcast-align -Wconversion -O2 -fno-exceptions -fno-check-new -c
       -o kscribbleview.o `test -f 'kscribbleview.cpp' || echo '/home/caleb/kscribble/src/'`kscribbleview.cpp
    37 kscribbleview.cpp: In member function `void KScribbleView::print(QPainter*,
    38  int, int)':
    39 kscribbleview.cpp:79: warning: unused parameter `QPainter*p'
    40 kscribbleview.cpp:79: warning: unused parameter `int height'
    41 kscribbleview.cpp:79: warning: unused parameter `int width'
    42 /usr/lib/qt/bin/moc /home/caleb/kscribble/src/pref.h -o pref.moc
    43 source='pref.cpp' object='pref.o' libtool=no \
    44 depfile='.deps/pref.Po' tmpdepfile='.deps/pref.TPo' \
    45 depmode=gcc3 /bin/sh /home/caleb/kscribble/admin/depcomp \
    46 g++ -DHAVE_CONFIG_H -I. -I/home/caleb/kscribble/src -I.. -I/usr/local/kde3/include
       -I/usr/lib/qt/include -I/usr/X11R6/include -DQT_THREAD_SUPPORT -D_REENTRANT -Wnon-virtual-dtor
       -Wno-long-long -Wundef -Wall -pedantic -W -Wpointer-arith -Wmissing-prototypes -Wwrite-strings
       -ansi -D_XOPEN_SOURCE=500 -D_BSD_SOURCE -Wcast-align -Wconversion -O2 -fno-exceptions -fno-check-new
       -c -o pref.o `test -f 'pref.cpp' || echo '/home/caleb/kscribble/src/'`pref.cpp
    47 /usr/local/kde3/bin/dcopidl /home/caleb/kscribble/src/kscribbleiface.h
    > kscribbleiface.kidl ||
       ( rm -f kscribbleiface.kidl ; /bin/false )
    48 /usr/local/kde3/bin/dcopidl2cpp --c++-suffix cpp --no-signals --no-stub kscribbleiface.kidl
    49 source='kscribbleiface_skel.cpp' object='kscribbleiface_skel.o' libtool=no \
    50 depfile='.deps/kscribbleiface_skel.Po' tmpdepfile='.deps/kscribbleiface_skel.TPo' \
    51 depmode=gcc3 /bin/sh /home/caleb/kscribble/admin/depcomp \
    52 g++ -DHAVE_CONFIG_H -I. -I/home/caleb/kscribble/src -I.. -I/usr/local/kde3/include
       -I/usr/lib/qt/include -I/usr/X11R6/include -DQT_THREAD_SUPPORT -D_REENTRANT -Wnon-virtual-dtor
       -Wno-long-long -Wundef -Wall -pedantic -W -Wpointer-arith -Wmissing-prototypes -Wwrite-strings
       -ansi -D_XOPEN_SOURCE=500 -D_BSD_SOURCE -Wcast-align -Wconversion -O2 -fno-exceptions -fno-check-new
       -c -o kscribbleiface_skel.o `test -f 'kscribbleiface_skel.cpp' ||
       echo '/home/caleb/kscribble/src/'`kscribbleiface_skel.cpp
    53 /bin/sh ../libtool --silent --mode=link --tag=CXX g++ -Wnon-virtual-dtor -Wno-long-long -Wundef -Wall
       -pedantic -W -Wpointer-arith -Wmissing-prototypes -Wwrite-strings -ansi -D_XOPEN_SOURCE=500
       -D_BSD_SOURCE -Wcast-align -Wconversion -O2 -fno-exceptions -fno-check-new -o kscribble -R
       /usr/local/kde3/lib -R /usr/lib/qt/lib -R /usr/X11R6/lib -L/usr/X11R6/lib -L/usr/lib/qt/lib
       -L/usr/local/kde3/lib main.o kscribble.o kscribbleview.o pref.o kscribbleiface_skel.o -lkio
    54 source='kscribble_client.cpp' object='kscribble_client.o' libtool=no \
    55 depfile='.deps/kscribble_client.Po' tmpdepfile='.deps/kscribble_client.TPo' \
    56 depmode=gcc3 /bin/sh /home/caleb/kscribble/admin/depcomp \
    57 g++ -DHAVE_CONFIG_H -I. -I/home/caleb/kscribble/src -I.. -I/usr/local/kde3/include
       -I/usr/lib/qt/include -I/usr/X11R6/include -DQT_THREAD_SUPPORT -D_REENTRANT -Wnon-virtual-dtor
       -Wno-long-long -Wundef -Wall -pedantic -W -Wpointer-arith -Wmissing-prototypes -Wwrite-strings
       -ansi -D_XOPEN_SOURCE=500 -D_BSD_SOURCE -Wcast-align -Wconversion -O2 -fno-exceptions -fno-check-new
       -c -o kscribble_client.o `test -f 'kscribble_client.cpp' || echo
       '/home/caleb/kscribble/src/'`kscribble_client.cpp
    58 /bin/sh ../libtool --silent --mode=link --tag=CXX g++ -Wnon-virtual-dtor -Wno-long-long -Wundef
       -Wall -pedantic -W -Wpointer-arith -Wmissing-prototypes -Wwrite-strings -ansi -D_XOPEN_SOURCE=500
       -D_BSD_SOURCE -Wcast-align -Wconversion -O2 -fno-exceptions -fno-check-new -o kscribble_client -R
       /usr/local/kde3/lib -R /usr/lib/qt/lib -R /usr/X11R6/lib -L/usr/X11R6/lib -L/usr/lib/qt/lib
       -L/usr/local/kde3/lib kscribble_client.o -lkdecore
    59 gmake[2]: Leaving directory `/home/caleb/kscribble/src'
    60 gmake[2]: Entering directory `/home/caleb/kscribble'
    61 gmake[2]: Nothing to be done for `all-am'.
    62 gmake[2]: Leaving directory `/home/caleb/kscribble'
    63 gmake[1]: Leaving directory `/home/caleb/kscribble'
    64 *** Success ***

Come puoi notare abbiamo messo il numero di riga su ogni riga, la quale non appare nella tua finestra di output, ma ci facilita nel descrivere cosa è successo durante la compilazione. Prima di tutto gmake funziona ricorsivamente. Questo significa che esso parte da una directory dalla quale è invocato e va all'interno di tutte le sue sottodirectory, una per volta, quindi ritorna alla directory di partenza, processandola, quindi termina.

La nostra prima linea di interesse è la 24. Notare su questa linea che g++, che è il nostro compilatore C++, viene chiamato da make per compilare il primo file di codice sorgente nel nostro progetto - in questo caso main.cpp. Ci sono molte altre opzioni della riga di comando utilizzate dal compilatore g++, alcune delle quali sono predefinite ed alcune altre posso essere configurate con &kdevelop;.

Prima che il prossima file (kscribble.cpp, linea 29) sia compilato, il moc (compilatore dei meta oggetti) viene invocato per kscribble.h (linea 25). Questo perchè le classi di KScribble utilizzano i segnali e gli slot, quindi la macro Q_OBJECT deve essere espansa e il moc deve fare questo per noi. Il file risultante, kscribble.moc, verrà utilizzato da kscribble.cpp tramite la direttiva #include dentro il file.

### Lo schema del sorgente

Per concettualizzare come funziona l'applicazione KDE, prima dovremmo guardare da vicino lo schema del sorgente appena creato dal wizard. Come avevamo già visto abbiamo un insieme di file di codice e di file di intestazione. che compongono il codice iniziale per l'applicazione e la fanno pronta a partire. Quindi il modo più facile per spiegare il codice è quello di seguire l'implementazione linea per linea come è stata processata durante l'esecuzione del proramma fino a quando entra nel cilco principale di gestione degli eventi e pronto ad accettare i comandi dell'utente. Quindi vedremo quali sono le funzionalità che abilitano le interazioni con l'utente e come certe cose lavorino. Questo è probabilmente il modo migliore per spiegare il framework, dato che è molto simile alle altre applicazioni KDE, ti abiliteremo alla lettura del codice sorgente da altri progetti così, inoltre, saprai dove cambiare quale parte del codice per far funzionare la tua applicazione nel modo in cui l'hai progettata.

#### La funzione main()

Dato che l'applicazione inizia la sua esecuzione entrando nella funzione `main()`, questo punto sarà l'inizio per la nostro esame del codice. La funzione `main()` di KScribble è implementata in main.cpp e può essere trovata utilizzando il Browser di Classe selezionando la scheda "Funzioni Globali".

    1  int main(int argc, char **argv)
    2  {
    3      KAboutData about("kscribble", I18N_NOOP("KScribble"), version, description,
    4                       KAboutData::License_GPL, "(C) 2002 Your Name", 0, 0, "you@you.com");
    5      about.addAuthor( "Your Name", 0, "you@you.com" );
    6      KCmdLineArgs::init(argc, argv, &about);
    7      KCmdLineArgs::addCmdLineOptions(options);
    8      KApplication app;
    9
    10    // register ourselves as a dcop client
    11    app.dcopClient()->registerAs(app.name(), false);
    12
    13    // see if we are starting with session management
    14    if (app.isRestored())
    15        RESTORE(KScribble)
    16    else
    17    {
    18        // no session.. just start up normally
    19        KCmdLineArgs *args = KCmdLineArgs::parsedArgs();
    20        if (args->count() == 0)
    21        {
    22            KScribble *widget = new KScribble;
    23            widget->show();
    24        }
    25        else
    26        {
    27            int i = 0;
    28            for (; i < args->count(); i++)
    29            {
    30                KScribble *widget = new KScribble;
    31                widget->show();
    32                widget->load(args->url(i));
    33            }
    34        }
    35        args->clear();
    36    }
    37
    38    return app.exec();
    39 }

Ora, quello che accade prima di tutto è la usale creazione di un oggetto `KApplication`, ma noi abbiamo aggiunto qualche metodo KDE che imposta il programma e le informazioni dell'autore per questa applicazione.

#### Avvio Applicazione Utente

... (non ancora scritto)

#### Il costruttore

Andiamo ora a vedere il costruttore e vediamo come questa istanza viene chiamata

    1  KScribble::KScribble()
    2      : KMainWindow( 0, "KScribble" ),
    3        m_view(new KScribbleView(this)),
    4        m_printer(0)
    5  {
    6      // accept dnd
    7      setAcceptDrops(true);
    8
    9      // tell the KMainWindow that this is indeed the main widget
    10     setCentralWidget(m_view);
    11
    12     // then, setup our actions
    13     setupActions();
    14
    15     // and a status bar
    16     statusBar()->show();
    17
    18     // allow the view to change the statusbar and caption
    19     connect(m_view, SIGNAL(signalChangeStatusbar(const QString&)),
    20             this,   SLOT(changeStatusbar(const QString&)));
    21     connect(m_view, SIGNAL(signalChangeCaption(const QString&)),
    22             this,   SLOT(changeCaption(const QString&)));
    23
    24  }

Notare che `KScribble` eredita la classe `KMainWindow` - un uso comune utilizzato dalla classe base per applicazioni KDE. Noi inizializziamo una classe chiamando `KScribbleViiew` come il nostro widget centrale, creare un `KStatusBar` tramite il metodo `statusBar` (linea 16) e connettiamo alcuni segnali e slot insieme.

## Disegnare la vista dell'applicazione

### Introduzione

Quando si sviluppa una applicazione con interfaccia grafica utente il lavoro più oneroso e provvedere alle così chiamate "viste" per le applicazioni. Una vista generalmente è un widget che mostra i dati del documento e fornisce metodi per manitopolare il contenuto del documento. Questo può esserefatto dall'utente per mezzo degli eventi che esgli emette tramite tastiera o tramite il mouse; molto più complesse le operazioni da processare dalle barre degli strumenti e dalle barre dei menu le quali interagiscono con le viste e con il documento. La barra di stato provvede a dare delle informazioni di stato del documento, della vista e dell'applicazione. Per esempio vediamo come un editor è costuito e dove noi possiamo trovare quale parte. TODO

Un editor generalmente è creato per fornire una insterazione alle viste e(o cambiare i contenuti di un documento di testo per l'utente. Se fai partire Kate vedrai l'interfaccia visualiale come segue:

- La barra dei menu fornisce operazioni complesse così come apertura, salvataggio e chiusura dei file ed uscita dalla applicazione.

- La barra degli strumenti offre icone che permettono un accesso veloce per molte funzioni necessarie,

- LA barra di stato: mostra lo stato della posizione del cursore visualizzando la riga e la colonna corrente,

- La vista in centro della finestra visualizza un documento e offre un cursore connesso alla tastiera ed al mouse per operare sui dati.

Ora è semplice capire che una vista è l'unica parte della'applicazione e il disegno di una vista decide riguardo l'usabilità e l'accettabilità dell'applicazione. Questo significa che ono dei primi passi nelo sviluppo è determinare lo scopo dell'applicazione e che tipo di vista disegnata potrebbe corriscpondere meglio alle necessità dell'utente al fine di operare con l'applicazione con uno sforzo minimo imparando come maneggiare l'interfaccia grafica.

Per alcuni scopi come la modifica di testo e la visualizzazione di file HTML, viste come fornite dalle librerie Qt e KDE, discuteremo certi aspetti di questi widget ad alto livello nella prossima sezione. Ma per moltissime applicazioni nuovi widget devono essere progettati ed implementati. Questo è ciò che fa un programmatore anche un archietetto e la sua abilità nella creatività è richiesta. Prima di tutto devi concentrarti sulla intuitività. Ricorda molti utenti non accettano una applicazione che non lo è.

- graficamente gradevole.

- offrendo molte funzionalità

- facile da manipolare

- veloce da imparare il suo utilizzo

Non c'è bisogno di dire che la stabilità è l'obiettivo principale. Nessuno può prevenire errori, ma un minimo può essere raggiunto almeno tramite gli obiettivi intelligenti di progettazione ed il vasto uso della progettazione orientata agli oggetti. C++ fa della programmazione un gioco se conosci come sfruttare le capacità - ereditarietà, incapsulamento e riusabilità di codice già esistente.

Quando crei un progetto KDE o Qt, tu dovrai sembre avere una vista che eredita QWidget o per ereditarietà diretta o perchè la libreria widget che vuoi usare deriva da QWidget. Quindi il wizard dell'applicazione prepara già una vista che è una istanza di una classe yourappView che deriva da QWidget.

Questo capitolo descrive quindi come usare la libreria widget per creare viste di applicazioni KDE o Qt che sono generate con &kdevelop;, quindi vedremo le librerie e che tipo di viste sono gia pronte.

### Usare la libreria delle viste

Quando il disegno della tua applicazione è stato fatto, tu prima di tutto cerca per codice esistente che rende la tua vita molto più semplice. Una parte di questa ricerca è guardare di widget che possono essere usati come viste o almeno come parte di esse, o direttamente per ereditando. Le librerie KDE e Qt contengono un insieme di widget che possono essere usate per questi scopi. Per usarle hai due opzioni:

1. Rimuovere la nuova classe di vista e creare una istanza di una libreria widget; quindi impostare questa come vista,

2. Cambiare la gerarchia della classa della vista fornita alla classe della libreria di widget in uso.

In entrambe le maniere, è importante sapere che se il framework di applicazione non è attualmente collegato tra la libreria che contiene il widget, il collegamento potrebbe fallire. Dopo che tu hai deciso di usare un certo widget, cerca la libreria a cui collegarlo, quindi apri "Progetto"->"Opzioni" dalla barra dei menu di &kdevelop;. Vai nella linguetta "Opzioni del linker" e cerca per il marcatore che indica le librerie che attualmente stai utilizzando. Se la libreria del tuo componente visuale è già selezionata, lascia inalterate le opzioni di progetto e inizia a fare i cambiamenti necessari al fine della tua scelta. Se così non è, e le opzioni del linker permettono di aggiungere attraverso una casella di selezione, selezionala e premi "OK" per lasciare il dialogo delle opzioni di progetti nuovamente. In tutti gli altri casi, aggiungi la libreria nella linea di edit sotto con l'opzione -l. Per librerie che le tue applicazioni devono cercare prima della preparazione dei Makefile attraverso lo script di configurazione sul sistema dell'utente finale, aggiungi le macro trovate al file di configurazione che si trova nella directory principale del tuo progetto e aggiungi la macro alla linea di edit. Ricorda che devi lanciare "Compila"->"Autoconf e automake" e "Compila"->"Configura" prima i Makefile contengono la corretta espansione per la libreria macro.

Inoltre, se i file di inclusione per la libreria da aggiungere non sono nel percorso corrente (che può essere sista tramite l'opzione -l della finesta di output di "Make"), devi aggiungere il percorso al Dialogo di Progetto - linguetta "Opzioni di Compilazione" con l'opzione -l o compatibilmente alla macro automake sulla linea di edit per "Informazioni Addizionali".

#### Viste Qt

Cercando sulla prima pagina della documentazione in linea di Qt, troverai un colleamento a "Schermate di Widget" dove potrai dare uno sguardo a come i widget di Qt appaiono. Questi sono già printi ad essere utilizzati e possono essere combinati insieme per formare una complessi widget per create viste di applicazioni o dialoghi. Nel seguito discuteremo alcune di queste le quali sono molto usabili per creare viste di applicazione, ma tiene a mente che le librerie KDE alcune volte contengono altri widget per gli stessi scopi, le quali saranno rivisitati nella prossima sezione.

Qui sono riportati una serie di suggerimenti per gli scopi che potresti usare per i componenti Qt:

1. Se la tua area di vista non è abbastanza grande per visualizzare tutti i dati, l'utente deve poter scrollare su documento con barre sul lato sinistro e basso della vista. Per questo Qt fornisce la classe `QScrollView` che offre un'area figlio scrollabile. Come spiegato tu puoi derivare il tuo widget dalla classe `QScrollView` o utilizzare una istanza per manipolare il tuo widget di vista del documento.

2. per creare da solo uno ScrollView, deriva il widget View da `QWidget` e aggiungi un barra di scorrimento orizzontale ed una verticale `QScrollBars`. (Questo è fatto dal widget KHTMLViews di KDE.)

3. Per processare teste usa la classe `QTextEdit`

4. Usa la classe `QTable` per visualizzare i dati che sono organizzati in una tabella. La classe `QTable` è gestita da barre di scorrimento così offre una buona soluzione per le applicazioni di calcolo tabellare.

5. Per visualizzare due widget diversi o due istanze di widget nello stesso momento, usa la classe `QSplitter`. Questo permette tagliare le viste in modo verticale oppure orizzontale. KMail è un buon esempio di come questo appare- la vista principale è separata da un divisore verticale, la finestra a destra è quindi nuovamente separata in orizzonale.

6. `QListView` visualizza informazioni in una lista e in un albero. Questo è utile per la creazione di alberi per selezione file o per altre informazioni gerarchiche con cui vuoi interagire.

Vedi che Qt da solo offre un intero insieme di widget che sono già pronti all'uso in modo che tu non debba inventare nuove delle soluzione se queste corrispondono ai tuoi bisogni. L'effetto indesiderato quando usi un widget standard è che l'utente già conosce come manipolarlo quindi ti devi concentrare solamente su come visualizzare i dati.

#### Viste KDE

Le librerie KDE sono state inventate per sviluppare facilmente applicazioni orientate all'ambiente K Desktop capace di molte funzionalità he è quello che Qt offre. La libreria kdeui offre:

1. KListView: una più potente versione di `QListView`

2. KIconView: una vista grafica di file ad icona

La libreria khtml, d'altro canto, offre un widget per la completa interpretazione del linguaggio HTML già pronto all'uso. Questo fornisce già lo scorrimento in modo che tu non ti debba preoccupare di screarlo. Un possibile utilizzo potrebbe essere l'integrazione ....

### Creare le tue viste

Non ancora scritto

## Configurare barre dei menu e barre degli strumenti

### Introduzione

Le barre dei menu e le barre degli strumenti sono una delle più importanti parti di una applicazione per fornire metodi per lavorare con una struttura di documento. Come regola generale dovresti rendere disponibili tutte le funzioni dalla barra dei menu. Questi metodi non sono disponibili nel passo corrente dell'applicazione dovrebbero essere disabilitati.

Tuttavia una applicazione può contenere una sola barra dei menu, ma molte barre degli strumenti. Le barre degli strumenti tuttavia dovrebbero contenere solamente le più frequenti comandi utente .... TODO

### Come funziona?

La nostra applicazione deriva la classe `KMainWindow`, che automaticamente crea una barra dei meni e una barra degli strumenti per noi. Nel metodo `KScribble::setupActions()` c'è una chiamata al metodo `KMainWindow::createGUI()`. Questo metodo carica un file di risorsa, in questo caso kscribbleui.rc, per inizializzare i menu alla partenza. Nota che kscribbleur.rc è elencato all'interno dei file di progetto nel Manager Automake. Aprendo questo file rivela questo:

    1 <!DOCTYPE kpartgui SYSTEM "kpartgui.dtd">
    2 <kpartgui name="kscribble" version="1">
    3 <MenuBar>
    4   <Menu name="custom"
    ><text
    >C&ustom</text>
    5     <Action name="custom_action" />
    6   </Menu>
    7 </MenuBar>
    8 </kpartgui
    >

Spiegazione...

Un altro modo i modificare i contenuti dei menu e delle barre degli strumenti è manipolare direttamente questi attraverso i metodi forniti dalle loro classi. Per esempio, il metodo `menuBar` ritorna il widget `KMenuBar` che rappresenta la barra dei menu del nostro programma. Guardando la documentazione della classe `KMenuBar` e della sua classe derivata `QMenuBar`, proverai un vasto numero di metodi `insertItem()` che ti permettono di aggiungere elementi alla barra dei menu.

I metodi `statusBar()` e `toolBar()` della classe `KMainWindow` ti forniranno TODO.

### Configurazione delle scorciatoie

Una cosa molto professionale che tu dovresti sempre aggiungere alle tue applicazioni sono le scorciatoie da tastiera. Queste sono prevalentemente utilizzate da utenti esperti che vogliono lavorare velocemente con le loro applicazioni e vogliono imparare le scorciatoie. Per questo le librerie KDE forniscono la classe `KAction`, la quale fornisce i tasti scorciatoia e l'accesso alla configurazione generale degli acceleratori da tastiera standard.

Normalmente le applicazioni generate da &kdevelop; utilizzano solamente gli acceleratori predefiniti di tastiera come F1 per accedere alla documentazione di help in linea, CRTL+N per Nuovo File, ecc.

Se la tua applicazione contiene molti acceleratori, dovresti farli configurabili da un menu di Opzioni; uno potrebbe essere unito con configurazione della applicazione in un QWidger o stare solo. La libreria KDE già pronta fornisce la classe `KKeyChooser` da usare nei dialoghi a linguetta, mentre la classe `KKeyDialog` fornisce dialogo di configurazione già pronto all'uso. TODO

## Funzioni di Help

### Introduzione

Una parte importante del processo di sviluppo è fornire la funzionalità di aiuto all'utente ogni volta che è possibile. Molti sviluppatori tendono ad attendere ciò, ma tu dovresti ricordare che un normale utente non è necessariamente un esperto di Unix. Egli potrebbe venire da un lato oscuro dell'uso del software fornendo tutti i dolci che un utente ha bisogno lavorando da solo nell'uso dell'applicazione anche senza toccare il mannuale. Tuttavia le librerie Qt e KDE forniscono tutto significa normalmente con TODO...

- Tool-Tips

- Aiuto barra di stato

- Cos'è questo...? pulsanti

Inoltre l'applicazione dovrebbe fornire i significati per accedere al manuale in linea HTML direttamente usando il tasto prefedinito F1. Questo aiuto ontestuale è fornito automaticamente tramite la classe `KMainWindow`, benchè come l'autore debba fornire il contenuto.

Dato che &kdevelop; offre anche tutti i tipi di aiuto così come il framework KDE generato dal wizard di applicazione già contiene il supporto per questo, questo capitolo ti aiuterà a trovare dove e come aggiungere le tue funzionalità di aiuto.

Durante lo sviluppo della tua applicazione dovresti provare ad essere consistente in ogni cosa che stai facendo, tuttavia ovresti fare i passi necessari mentre entendi il codice. Questo ti eviterà dal doverti immergere nuovamente dentro il codice e calcolare cosa la tua applicazione fa o cosa intendevi con alcune parti del tuo codice.

### Tool-Tips

Un molto semplice di fornire un aiuto sono i suggerimenti. Questi sono piccoli messaggi di aiuto che scendono mentre l'utente muove il mouse sopra ai widget che fornisce un suggerimento e scompare quando il mouse cambia posizione. L'uso più popolare dei suggerimenti è fatto nelle barre degli strumenti dove i suggerimenti dovrebbero essere presi così piccoli come possibile perché le barre degli strumenti possono essere configurate per visualizzare i loro contenuti in vario modo: uno visualizza il pulsante, pulsante con testo sulla destra, pulsante con testo sotto, solo testo. Questa possibilità dovrebbere essere fatta configurabile dall'utente, ma questo non è un obbligo. Il testo è visualizzato come un suggerimento sempre e una barra degli strumenti normalmente consiste di pulsanti e di altri widget come linee di edit e liste di inserimento. Per un completo riferimento guarda il riferimento alla classe `KToolBar` che si trova nella libreria kdeui.

Come esempio dobbiamo cercare sul pulsante "Nuovo File" in una generica applicazione:

Là la parte i18n("Nuovo File") fornisce un messaggio di suggerimento. Questo è chiuso dalla macro i18n() fornita da kapp.h per tradurre i suggerimento verso la lingua appena selezionata.

I suggerimenti possono essere aggiunti ad ogni widget creato utilizzando la classe `QToolTip` fornita da Qt. Un esempio di questo potrebbe essere :

### Estendere la barra di stato

Come le applicazioni che ereditano `KMainWindow` contengono una barra di stato così come, questo alche affre un insieme di messaggi per la barra di stato già pronti per tutti i menu e gli elementi delle barre dei menu. Un massaggio di aiuto nella barra di stato è un piccolo messaggio che estende il significato dei suggerimenti o può essere visto come una sostituzione per i suggerimento sopra gli elementi nelle barre dei menu ed è (come il nome suggerisce) visualizzato nella barra di stato quando l'utente inserisce un menu e sottolinea il menu selezionato.

### Il pulsante Cos'è questo...?

Il pulsante Cos'è questo...? fornisce una finestra di aiuto con l'intenzione che l'utente vuole essere aiutato circa l'uso di alcuni widget all'interno della vista di lavoro o negli elementi della barra dei menu. Questo è posizionato nella barra degli strumenti e viene attivato una volta che l'utente seleziona il pulsante. Il cursore cambia la forma della freccia con un punto di domanda come il pulsante stesso appare. L'utente può premere su un elemento widget visibile ed aprire la finestra di aiuto. Come un esercizio dovresti provare questo comportamento con il pulsante Cos'è questo...? all'interno di &kdevelop;.

Per aggiungere l'aiuto Cos'è questo...? su uno dei tuoi widget, usa il metodo statico `QWhatsThis::add(QWidget *widget, const QString &test)`

## Documentazione

### Introduzione

Dato che i progetti spesso mancano di un completo insieme di documentazione per l'utente, tutti i progetti &kdevelop; contengono un manuale precompilato che può essere facilmente adattato, quindi un altro obiettivo i KDE: fornire una sufficiente documentazione in linea per supportare l'utente che non ha familiarità con l'applicazione. Questo capitolo ti introuce quindi a come estendere il prototipo di documentazione fornito e cosa devi fare per renderla disponibile all'utente.

### Documentazione utente

La documentazione per il tuo progetto è in projectdir/doc/en, o forse in una altra directory se l'inglese non è la tua lingua nativa. Il file index.docbook contiene la tua documentazione. Il formato per editare questo file è spiegato su KDE's documentation website.

### Documentazione del programmatore

Un'altra parte importante della documentazione include un aiuto dexrittivo per le interfacce di classe. Questo permetterà a te e agli altri programmatori di utilizzare le tue classi leggendo la documentazione HTML della classe che può essere creata con KDoc. &kdevelop; supporta l'usodi KDoc completamente creando la documentazione della libreria KDE., anche il framework delle tue applicazioni sono documenti già pronti. Per lavorare da solo nel codice fornito, un buon punto di partenza potrebbe essere leggere la documentazione in linea inclusa. Il seguente descrive cosa fare per prendere la documentazione delle API, dove &kdevelop; ti aiuta ad aggiungerla e che tipo di marcatori speciali KDoc fornisce.

## Internazionalizzazione

### Introduzione

i18n è un sistema di internazionalizzazione utilizzato per offrire versioni internazionalizzate di una applicazione o di un progetto. La difficoltà nello scrivere applicazioni è che queste supportano solo la lingua originale con la quale è stata creata; visualmente questa può essere vista su etichette, menu e cose simili. L'obiettivo dell'internazionalizzazione è fornire applicazioni e funzioni di libreria nel linguaggio dell'utente; abilitando quindi gli utenti che non comprendono la lingua originale dell'applicazione per fare uso delle funzionalità fornite e sentirsi molto confortato. TODO

## Riconoscimenti

(... da scriversi...)

## Bibliografia

#### GNU Make Manual

Richard M.
Stallman
Roland
McGrath

#### GNU Automake

David
MacKenzie
Tom
Tromey

#### GNU Autoconf

David
MacKenzie
Ben
Elliston

#### Using the GNU Compiler Collection

Richard M.
Stallman

#### GNU Libtool

Gordon
Matzigkeit
Alexandre
Oliva
Thomas
Tanner
Gary V.
Vaughan

#### GNU Autoconf, Automake, and Libtool

1st edition
October 2000
Gary V.
Vaughan
Ben
Elliston
Tom
Tromey
Ian Lance
Taylor
New Riders Publishing
ISBN 1578701902

#### Advanced Programming in the UNIX(R) Environment

1st edition
June 1992
W. Richard
Stevens
Addison-Wesley Pub Co
ISBN 0201563177

#### Thinking in C++, Volume 1: Introduction to Standard C++

2nd Edition
April 15, 2000
Bruce
Eckel
Prentice Hall
ISBN 0139798099

#### Open Source Development with CVS

2nd Edition
October 12, 2001
Karl
Fogel
Moshe
Bar
The Coriolis Group
ISBN 158880173X

#### Programming PHP

1st edition
March 2002
Rasmus
Lerdorf
Kevin
Tatroe
O'Reilly & Associates
ISBN 1565926102

#### Programming Python

2nd Edition
March 2001
Mark
Lutz
O'Reilly & Associates
ISBN 0596000855

#### Gui Programming With Python : Using the Qt Toolkit

Bk&Cd-r edition
January 2002
Boudewijn
Rempt
Opendocs Llc
ISBN 0970033044

#### Programming Perl

The Camel book
3rd Edition
July 2000
Larry
Wall
Tom
Christiansen
Jon
Orwant
O'Reilly & Associates
ISBN 0596000278

#### Learning Perl

The Lama book
3rd Edition
July 15, 2001
Randal L.
Schwartz
Tom
Phoenix
O'Reilly & Associates
ISBN 0596001320

&underFDL;