Bernd
Pol
Alessio
Rolleri

    aroller@libero.it

Traduzione del documento

# Iniziare ad usare &kdevelop;

Come iniziare ad usare l'&IDE; &kdevelop; dopo averlo installato? Siccome è una applicazione complessa, se l'utente non ha mai usato questo tipo di ambiente di sviluppo integrato, la curva di apprendimento potrebbe risultare piuttosto drastica.

Si cercherà di ammorbidirla analizzando una semplice applicazione C++ per KDE. Si effettuerà una (rapida) panoramica su:

- Un primo sguardo — gli elementi dell'interfaccia utente dell'IDE &kdevelop;.
- Alcune configurazioni iniziali
- Come creare un nuovo progetto
- Alcuni consigli sui documenti
- Come compilare l'applicazione del progetto.
- Come aggiungere le classi e altri dettagli al proprio progetto.
- Come effettuare il debug dell'applicazione.
- Alcuni strumenti di base per costruire il programma o la documentazione utente.
- Per ultimo, ma non ultimo, le scorciatoie da tastiera

Prima di iniziare deve essere chiarito un concetto importante.

## Cosa attendersi?

Come detto precedentemente, &kdevelop; è un Ambiente di sviluppo integrato, quindi non è uno strumento di sviluppo di per se, ma piuttosto un front end grafico per accedere facilmente ad una grande quantità di strumenti di sviluppo, molti dei quali richiedono complessi comandi da inserire in una console testuale.

Mentre &kdevelop; facilita molte attività legate alla programmazione, questo insieme di strumenti mantiene una certa complessità. Quindi per imparare a fondo l'uso dell'&IDE; è necessario comprende l'utilizzo di questi strumenti che vengono eseguiti in sottofondo.

Dunque non verrà insegnato come scrivere software, ma piuttosto verrà effettuata una introduzione su come &kdevelop; è stato progettato per facilitare la programmazione. Se si vuole conoscere maggiormente lo scopo di un Integrated Development Environmente, si veda il capitolo Sviluppo su &UNIX; che contiene una panoramica storica e in particolare il capitolo Integrare concetti e strumenti.

In seguito si tratterà il caso generale in cui &kdevelop; viene avviato nella Modalità IDEAl semplificata. Se è già stata selezionata un'altra interfaccia utente alcuni elementi potrebbero non essere presenti oppure mostrare comportamenti leggermente diversi da quelli descritti. Per verificare quale interfaccia utente viene attualmente usata, controllare nella finestra di dialogo Impostazioni Configura KDevelop...Interfaccia Utente.

## Un primo sguardo a &kdevelop;

Questo è quello che verrà visualizzato la prima volta che viene avviato &kdevelop;. Si troveranno informazioni preliminari su:

- Come si presenta l'IDE &kdevelop;.
- Come ricevere aiuto
- Cosa è presente nei menu?
- A cosa servono le viste strumenti?

### In superficie

Quando si avvia &kdevelop; per la prima volta, verrà visualizzata una schermata simile a questa:

Aspetto iniziale di &kdevelop;

(In realtà la finestra iniziale di &kdevelop; sarà più grande, ma gli elementi presenti sono gli stessi).

#### Area di lavoro e linguette degli strumenti

Inizialmente &kdevelop; userà la cosiddetta interfaccia utente IDEAl, dove l'area di lavoro ha la massima dimensione possibile ed è circondata a sinistra, destra e in basso da vari pulsanti simili a linguette. Facendo clic su una di queste linguette verrà aperta una cosiddetta vista strumenti che permette di svolgere un particolare compito.

#### Menu e barre degli strumenti

In alto è presente la normale barra dei menu e diverse barre degli strumenti, alcune inizialmente vuote. Verranno riempite quando si aprirà un progetto.

#### Barra di stato

Infine è presente nella parte bassa della finestra una barra di stato che fornisce brevi informazioni su vari compiti.

### Come ricevere aiuto

Oltre al menu Aiuto, che fornisce supporto per questioni specifiche, si possono ottenere alcune brevi informazioni dalla barra di stato e da due tipi di aiuto.

#### Cosa fa questa voce di menu?

Quando si posiziona il cursore sopra una voce di menu verrà generalmente visualizzata una breve informazione nella barra di stato. In molti casi ripeterà il nome della selezione, mentre in alcuni altri saranno fornite ulteriori informazioni sullo scopo del comando del menu.

#### Qual è il nome di questo elemento?

Quando si posiziona il cursore su un elemento, verrà visualizzato per qualche secondo un aiuto contenente il suo nome. É utile per orientarsi velocemente nella barra degli strumenti o nelle viste strumenti della modalità IDEAl quando è stata impostata la sola visualizzazione delle icone.

#### Cosa fa questo elemento?

Per molti elementi dell'&IDE; sono disponibili ulteriori informazioni attraverso gli aiuti estesi. Selezionare Aiuto Che cos'è? o premere &Shift;F1 e selezionare l'elemento con il cursore, che verrà visualizzato con un punto interrogativo. Con questo metodo si possono anche aprire i menu e fare clic su una voce specifica (sia attiva che disattivata) per visualizzare le eventuali informazioni aggiuntive.

### Cosa è presente nei menu?

Ci sono dieci menu selezionabili nella barra dei menu. La maggior parte di essi viene riempita quando è stato caricato un progetto, mentre altri quando viene aperto almeno un documento. In breve, essi permettono i seguenti tipi di azioni.

Questa è solo una breve panoramica. Vedere il capitolo relativo alla Descrizione dei comandi per un elenco dettagliato.

File

  #### Azioni comuni

  Queste azioni sono molto standard. Permettono di creare, aprire, salvare, stampare, chiudere i file e uscire dall'applicazione &kdevelop;.

  #### Annulla tutto

  Questo comando permette di annullare tutte le modifiche recenti ma non salvate ricaricando il file dal disco. Funziona su tutti i file aperti, non solo quelli che fanno parte di un progetto.

Modifica

  Questo menu è utile solo se è presente un documento aperto.

  #### Azioni comuni

  Fornisce le normali azioni annulla/rifai e taglia/copia/incolla, oltre a permettere di selezionare blocchi di testo in vari modi.

  #### Trova e Sostituisci

  Sono presenti due potenti strumenti per le ricerche: Modifica Trova nei file... e Modifica Trova, seleziona e sostituisci.... In aggiunta alle normali azioni di ricerca e sostituzione limitate al documento aperto permettono di effettuare ricerche e sostituzioni globali in un solo colpo.

  #### Modifica avanzata del testo

  In futuro sarà possibile riformattare il documento e completare automaticamente le parti di testo incomplete in vari modi.

Visualizza

  Come il menu Modifica, questo menu è utile solo quando è presente un documento aperto: saranno disponibili (assieme ad altre) le seguenti azioni:

  #### Cronologia

  Permette di muoversi avanti e indietro attraverso i vari documenti visitati

  #### Traccia degli errori

  Naviga tra le linee di codice che contengono errori rilevati durante l'ultimo processo di compilazione.

  #### Azioni relative all'editor

  Alcune voci del menu Visualizza controllano l'aspetto dell'editor in uso. Nel caso del componente &kate; (editor avanzato incorporato) saranno disponibili i seguenti comandi:

  - Controllo del ritorno a capo automatico nella finestra del documento.

  - Mostrare o nascondere diversi bordi della finestra del documento: numeri di linea, icone e contrassegni.

  - Controllo della visualizzazione delle sezioni annidate (temporaneamente nascoste) nel codice sorgente.

Progetto

  Tutto il lavoro in &kdevelop; si basa sui progetti, che raccolgono file di codice sorgente, file per la gestione della compilazione e altre informazioni in una directory . In questo menu si può controllare quale progetto usare, le sue proprietà e altre azioni relative alla sua gestione. In particolare:

  #### Apri Progetto

  Permette di creare nuovi progetti, aprirne di nuovi e importare progetti di altri ambienti.

  #### Opzioni progetto

  Permette di definire un insieme di varie proprietà del progetto

  #### Gestione delle classi

  Aggiunge nuove classi al progetto e permette di attraversare l'albero di ereditarietà di una classe.

  #### Distribuzione del progetto

  Aiuta a costruire pacchetti di distribuzione del progetto.

Compila

  Questo menu è dedicato alla compilazione e alla documentazione del progetto. Si può quindi usare quando è presente un progetto aperto. Fornisce le seguenti azioni:

  #### Compilare, effettuare il link, eseguire

  Permette di compilare ed effettuare il link dell'intero progetto o parti di esso ed eseguire l'applicazione dall'interno dell'&IDE;.

  #### Preparazione alla compilazione

  Queste operazioni dipendono dal sistema make usato per il progetto. Nel caso di progetti automake, esse permettono di eseguire `Makefile.cvs` e `configure`.

  #### Installare l'applicazione

  Permette di installare l'applicazione sia nelle directory locali che nelle directory di sistema accessibili solo all'utente root.

  #### Documentazione API

  Costruisce o rimuove la documentazione API del progetto basata su doxygen in base alle opzioni del progetto

Debug

  Anche se questo menu viene riempito una volta che un progetto è aperto, è ovviamente utile solo se il progetto è stato precedentemente compilato con le informazioni di debug (può essere impostato in Progetto Opzioni progetto.... Sono presenti le seguenti azioni:

  #### Azioni normali del debugger

  La prima parte del menu Debug costituisce una interfaccia grafica al debugger &GNU; GDB. Permette di avviare e interrompere l'applicazione nel debugger e procedere in diverse modalità passo-per-passo.

  #### Breakpoint

  &kdevelop; permette di impostare i breakpoint (punti di interruzione) in diversi modi nei sorgenti dell'applicazione. Uno viene effettuato usando la voce Attiva/disattiva breakpoint.

  #### Debug avanzato

  Le altre voci del menu Debug compiono analisi più sofisticate. Usare &Shift;F1 per ottenere ulteriori informazioni sul loro funzionamento.

Script

  Attraverso questo menu si possono chiamare diversi script per compiere facilmente compiti noiosi sul testo presente nella finestra dell'editor selezionata. Tuttavia le azioni disponibili dipendono dallo script selezionato.

Finestra

  È un menu piuttosto standard. Si possono selezionare varie finestre aperte e chiudere una o più finestre contenenti documenti. Si può anche selezionare un gruppo di finestre da chiudere in un colpo solo.

  A seconda del modulo usato nell'editor potrebbero essere presenti altre voci nel menu. Quindi il modulo di default dell'editor Kate permette di suddividere la finestra orizzontalmente o verticalmente.

Strumenti

  &kdevelop; è altamente configurabile. Si può selezionare il proprio editor preferito per i documenti e fornire strumenti modulari esterni per estendere le capacità di base dell'&IDE;. Il menu Strumenti controlla tutte queste impostazioni.

  #### Editing avanzato

  La parte alta del menu Strumenti viene fornita del plugin dell'editor in uso. Si può selezionare l'editor preferito in Impostazioni Configura KDevelop Editor. Quando è stato selezionato un documento, questa porzione del menu visualizzerà i comandi di editing specifici del componente editor usato.

  #### Gestione pagine web

  Se la finestra del documento attivo contiene una pagina HTML (&eg; visualizzata selezionando la Documentazione), il menu Strumenti visualizzerà ulteriori voci per la gestione delle pagine Web.

  #### Altri strumenti

  Normalmente saranno presenti molte altre voci a seconda degli strumenti disponibili. Usare &Shift;F1 per ottenere ulteriori informazioni.

Impostazioni

  Questo menu permette di mostrare e nascondere la barra dei menu, le barre degli strumenti e la barra di stato. Inoltre si possono configurare le scorciatoie, le barre degli strumenti, le notifiche, l'editor e il comportamento generale di &kdevelop;.

Aiuto

  Si può aprire questo manuale, leggere la documentazione Qt, aprire le pagine man (il tradizionale formato UNIX per i manuali) e le pagine info (il formato GNU per i manuali). Inoltre si possono segnalare i bug e ottenere varie informazioni sulla versione e sugli autori di KDevelop.

### A cosa servono le viste strumenti?

Nella modalità IDEAl l'area di lavoro sarà circondata da tre aree di pulsanti, chiamati etichette della vista strumenti. Esse forniscono l'accesso alle schede della vista strumenti, che permettono di eseguire molti compiti durante il processo di sviluppo del software. Ognuna delle seguenti tre schede è dedicata ad un diverso scopo.

- #### Parte sinistra

  Fornisce accesso agli strumenti di navigazione e selezione

- #### Basso

  Queste viste mostrano i messaggi generati dai vari strumenti.

- #### Parte destra

  Fornisce accesso alla documentazione e agli strumenti di gestione dei sorgenti.

Quando un progetto è stato aperto, aumenterà il numero delle schede disponibili per lavorare. L'effettivo insieme delle viste strumenti dipende dai Moduli disponibili al momento in &kdevelop;. Ulteriori informazioni sono presenti nel capitolo Configurare KDevelop.

Attualmente, quando non è aperto alcun progetto e sono stati caricati i moduli di default, si troveranno le seguenti viste. Le schede possono essere aperte e chiuse facendo clic sulla rispettiva linguetta.

Navigazione e selezione

  #### Selettore file

  Fornisce un pannello per navigare nell'albero delle cartelle e selezionare i file proprio come si farebbe in &konqueror;. Facendo clic su un file esso verrà aperto in una apposita finestra dell'editor nell'area di lavoro. Facendo clic con il tasto destro si aprirà un menu contestuale di navigazione e di gestione dei file.

  #### Lista file

  Elenca i file attualmente aperti. Facendo clic su un file verrà selezionata la finestra dell'editor nell'area di lavoro. Si può usare per navigare velocemente attraverso un grande numero di file aperti. Inoltre questa vista fornisce dei mezzi per organizzare i file aperti in differenti sessioni. Questi sono particolarmente utili nei progetti molto grandi e complessi, aiutando lo sviluppatore nel concentrarsi nei diversi compiti. Facendo clic con il tasto destro del mouse verrà aperto un menu contestuale per la gestione del file.

Visualizzatori di messaggi

  #### Applicazione

  Visualizza l'output di una applicazione che è stata avviata all'interno di &kdevelop;.

  #### Diff

  Usato per visualizzare i contenuti delle patch. Mostra l'output dello strumento di visualizzazione delle differenze che può essere avviato menu Strumenti Visualizzatore differenze....

  #### Messaggi

  Visualizza i messaggi generati dagli strumenti di compilazione eseguiti da &kdevelop; attraverso il menu Compila.

  #### Trova nei file

  Visualizza un elenco di elementi trovati nella operazione di ricerca globale avviata dal menu Modifica Trova nei file.... Facendo clic su una linea farà automaticamente aprire il file corrispondente alla linea specificata in una finestra dell'editor.

  #### Sostituisci

  Elenca i risultati della ricerca e sostituzione globale avviata dal menu Modifica Trova, seleziona e sostituisci.... In questa vista si può decidere se sostituire effettivamente ogni elemento che è stato trovato.

  Questo strumento di ricerca e sostituzione globale è disponibile sono quando un progetto è stato caricato. In caso contrario lo strumento di sostituzione globale nel del menu Modifica Trova, seleziona e sostituisci... sarà disabilitato.

  #### Konsole

  Apre Konsole di &kde;, un emulatore di terminale dove si possono inserire comandi da tastiera attraverso una tradizionale interfaccia a linea di comando &UNIX;.

Gestione documentazione e sorgenti

  #### Documentazione

  Attraverso questo strumento è possibile accedere all'insieme completo della documentazione. Si può accedere ai file di documentazione, generalmente online da remoto, in maniera strutturata. Sono presenti diversi metodi per consultare direttamente le informazioni utili contenute nei manuali &kde; o &Qt;.

  Per ulteriori dettagli, consultare i capitoli Documentazione e Configurazione della documentazione.

  #### Frammenti di codice

  Questo strumento consente di memorizzare permanentemente frammenti di testo da utilizzare in seguito durante l'editing. È molto flessibile, infatti il testo memorizzato può contenere un insieme di variabili che vengono sostituite dal relativo testo quando si inserisce il frammento.

  Ulteriori informazioni sono disponibili nei capitoli Frammenti di codice e Impostazione dello strumento frammenti di codice.

## Un po' di configurazione

Prima di iniziare veramente con un primo progetto di esempio, si dovrebbe adattare il comportamento di &kdevelop; alle proprie necessità. Anche se per il momento la maggior parte delle impostazioni sono adeguate, alcune dovrebbero essere modificate.

Se si vuole conoscere la configurazione di &kdevelop; in dettaglio, consultare il capitolo Configurazione di KDevelop.

### Alcune impostazioni generali

Per configurare &kdevelop; fare clic nel menu Impostazioni e selezionare Configura KDevelop.... Verrà aperta la finestra di dialogo Configura KDevelop che contiene a destra la pagina seguente Generale.

Finestra di dialogo generale

La maggior parte delle impostazioni predefinite saranno adeguate, ma probabilmente si potrebbe voler modificare due impostazioni.

#### Directory progetti predefinita

Al primo avvio di &kdevelop;, questa impostazione conterrà probabilmente la propria directory home. Tuttavia la maggior parte degli utenti desidera avere una directory dedicata per lo sviluppo del software. Se lo si desidera, modificare la casella di testo inserendo la cartella preferita per lo sviluppo. Essa potrà essere selezionata dall'albero delle cartelle premendo il pulsante a sinistra Apri finestra file etichettato con l'icona della cartella.

In questi esempi si utilizzerà un utente chiamato `devel`. Quindi si deve sempre sostituire devel con il proprio nome utente. L'utente devel utilizzerà la cartella `/home/devel/projects` per lo sviluppo del software. Nuovamente, si deve sostituire `projects` con il nome della propria cartella scelta.

Per impostazione predefinita, &kdevelop; creerà una sottocartella all'interno di questa cartella genitore per ogni progetto creato. Quindi &eg; tutti i file di un progetto di nome Hello verrebbero inseriti nella cartella `/home/devel/projects/hello`.

Ovviamente si possono scavalcare queste impostazioni in caso di necessità. Per maggiori informazioni vedere il capitolo Procedura guidata per le applicazioni.

#### Output del compilatore

Quando &kdevelop; effettua la compilazione dei sorgenti, verranno visualizzati i messaggi degli strumenti di compilazione come make nella vista Messaggi nella parte bassa dell'area di lavoro. Normalmente questi messaggi saranno oltremodo prolissi. Per avere una migliore percezione di quello che accade, &kdevelop; permette di accorciarli.

A seconda della versione utilizzata, l'impostazione Output del compilatore può essere impostata su Completo, che comporterà la visualizzazione completa dei contenuti dei messaggi. Si potrebbe voler modificare questa impostazione su un valore molto più conveniente, come Molto breve.

È necessario prestare attenzione sul fatto che nella finestra Messaggi saranno visualizzate solo le informazioni di base. Probabilmente in caso di errori si vorranno esaminare una quantità maggiore (se non tutti) di messaggi. Comunque, non sono perduti: facendo clic con il tasto destro sulla vista Messaggi e selezionare &eg; Output completo del compilatore dal menu contestuale.

### Inizializzazione degli indici di ricerca della documentazione

Prima di iniziare lo sviluppo vero e proprio, sarebbe preferibile inizializzare un altro elemento. Se si vuole effettuare ricerche nella documentazione in modo regolare, è necessario creare gli indici di ricerca prima di compiere queste ricerche. Quindi prima di iniziare a lavorare con &kdevelop;, si dovrebbero inizializzare gli indici di ricerca.

Aprire la vista strumenti Documentazione nella parte destra della finestra principale e selezionare Cerca.

Dove generare gli indici di ricerca

Premere il pulsante Aggiorna configurazione per assicurarsi che siano stati impostati gli strumenti principali di ricerca. Verrà visualizzata una finestra di dialogo, indicando File di configurazione aggiornato. Fare clic su OK.

Dopo aver compiuto questo passaggio, &kdevelop; sarà pronto ad analizzare la documentazione e potrà costruire gli indici. Premere il pulsante a destra Aggiorna indice. Apparirà la finestra di dialogo Generazione indici di ricerca visualizzando i progressi dell'operazione.

&kdevelop; sta generando gli indici di ricerca della documentazione.

Questa operazione potrebbe richiedere tempo, a seconda della dimensione della documentazione e della velocità del proprio computer. Infine il pulsante Annulla sarà sostituito dal pulsante OK. Premerlo per procedere.

- In alcuni casi l'applicazione htdig utilizzata da &kdevelop; per le ricerche potrebbe non essere configurata correttamente. Per ulteriori informazioni, fare riferimento al capitolo Impostazione degli indici di ricerca.

- Per poter consultare la documentazione API specifica di &kde; e &Qt;, è necessario che siano presenti le KDELibs Apidocs durante l'installazione di &kdevelop;. Se si riscontrano problemi durante la generazione degli indici o la ricerca degli identificatori, come negli esempi seguenti, assicurarsi che questa documentazione esista e che sia accessibile. Vedere Installare KDevelop per ulteriori dettagli.

## Iniziare un nuovo progetto

Molte applicazioni consistono di dozzine, centinaia e a volte anche migliaia di file, che devono essere organizzati in modo strutturato e gestibile. Per questo motivo, &kdevelop; organizza i compiti di sviluppo software in progetti. Quindi, in generale, la prima cosa da fare per iniziare a sviluppare è creare un nuovo progetto.

Fortunatamente, &kdevelop; fornisce uno strumento chiamato Procedura guidata per le applicazioni, che permette di creare un nuovo progetto in modo semplice. (Vedere il capitolo Primi passi —la procedura guidata per le applicazioni per ulteriori informazioni).

Ora si creerà una semplice applicazione &kde; per illustrare come viene facilmente creato un nuovo progetto e quali file e strumenti saranno utilizzati. Si fornirà un breve sguardo a:

- Come iniziare un nuovo progetto con l'aiuto della procedura guidata per le applicazioni
- Quali file vengono inizialmente impostati dalla procedura guidata
- Viste strumenti aggiuntive visualizzate con il progetto

### Come creare un nuovo progetto

Ora si creerà un semplice progetto &kde; Hello World, seguendo i seguenti passi.

1. Per avviare la procedura guidata per le applicazioni, fare clic sul menu Progetto Nuovo Progetto....

2. Verrà visualizzata la finestra di dialogo Crea nuovo progetto. In alto a sinistra, in Tutti i progetti saranno elencati diversi linguaggi di programmazione.

   1. Si vuole costruire una applicazione per &kde; in C++, quindi fare clic sul + a fianco dell'etichetta C++ per espandere quella sezione.

   2. Verranno visualizzate diverse sottosezioni. Siccome si vuole creare una applicazione &kde;, aprire l'ulteriore sottosezione facendo clic sul + vicino all'etichetta KDE.

   3. Saranno elencati una serie di modelli di progetto. Fare clic su Una semplice applicazioni KDE.

      Nelle due finestre a destra appariranno un'anteprima dell'applicazione relativa al modello del progetto selezionato e una breve descrizione.

      Selezionare un modello di progetto Hello World

   4. L'applicazione necessita di un nome. Inserire nell'area Proprietà in basso un nome adatto nel campo Nome applicazione.

      In questo esempio si è usato il nome Hello, ma si può inserire un qualunque nome di proprio gradimento che contenga lettere, numeri e il simbolo di underline. La procedura guidata rifiuterà ogni altro carattere.

   5. Assicurarsi che la casella Posizione visualizzi il nome della cartella padre dedicata ai progetti impostata nel capitolo precedente Un po' di configurazione. In caso contrario, inserire un nome di cartella adatto o selezionarne una dall'elenco di cartelle visualizzate facendo clic sul pulsante a destra con l'icona della cartella.

      Se tutto andrà bene, la linea intitolata Posizione finale in basso mostrerà il percorso completo che sarà usato dal nuovo progetto. Nel caso appaia la scritta (non valido, allora provare un nuovo nome per il progetto e assicurarsi che la cartella padre per i progetti nella casella Posizione esista e sia accessibile in scrittura.

   6. Fare clic sul pulsante Avanti in basso nella finestra per procedere.

3. Si aprirà la pagina Opzioni progetto della finestra di dialogo. Assicurarsi che i dati nelle caselle Autore e Posta elettronica siano corretti. Generalmente saranno generati a partire dalle impostazioni utente di &kde; fornite nella finestra Password e account utente del Centro di controllo di &kde;. Se non fossero corretti, inserire i valori desiderati per l'applicazione.

   Fornire il nome e l'indirizzo email (opzionale)

   Si deve inserire almeno il nome dell'Autore: esso è obbligatorio per l'impostazione dei file dell'applicazione.

   Quando tutto è corretto, verrà abilitato il pulsante Avanti. Fare clic per procedere.

4. Per il momento possono essere saltate le pagine Sistema di controllo versione (VCS), Template per i file .h e Template per i file .cpp. Saltarle facendo clic sul pulsante Avanti ed infine sul pulsante Fine.

La procedura guidata creerà un insieme di file iniziali nella cartella specificata nel campo Posizione finale nel passo 2c.

Una volta che è finita la fase di creazione, &kdevelop; aprirà una finestra dell'editor per il file di implementazione della finestra principale dell'applicazione (che in questo esempio è `hello.cpp`), in modo da poter procedere subito.

### File iniziali del progetto

Anche se il progetto Hello dell'esempio è piuttosto semplice, la procedura guidata ha creato un numeroso gruppo di file sorgenti e di gestione del progetto. Essi possono essere visualizzati facilmente facendo clic nella vista strumenti Albero file in basso a sinistra. In questo modo verrà visualizzato un elenco di file simile al seguente.

File iniziale del progetto Hello World

Per verificare l'insieme dei file prodotti dalla procedura guidata, si possono aprire le sottocartelle nella vista strumenti di sinistra Albero file. Si possono aprire le sottosezioni dell'albero per osservarne la struttura.

Solo per dimostrazione, sono state espanse tutte le sezioni della vista strumenti Gestore Automake a destra dove sono elencati alcuni dei sorgenti del progetto.

#### Problemi di copyright

Tutte le applicazioni conformi a &GNU; devono possedere un copyright. Le note di copyright devono essere inserite in due livelli: nei singoli file dell'applicazione e a livello globale dell'applicazione. La procedura guidata inserirà le appropriate informazioni di copyright e di licenza nei file del progetto.

##### Copyright nei singoli file sorgente

Ci si rammenta della pagina Opzioni del progetto nella finestra di dialogo durante la creazione di un nuovo progetto? In essa era necessario indicare il nome dell'autore e, facoltativamente, un indirizzo di posta elettronica. Controllando in alto nella finestra dell'editor del file hello.cpp attualmente visualizzata nell'area di lavoro si può notare che la procedura guidata ha inserito queste informazioni nell'intestazione dedicata alla licenza di ogni file sorgente creato.

    /***************************************************************************
     *   Copyright (C) 2006 by Joe User   *
     *   joe@user.com   *
     *                                                                         *
     *   This program is free software; you can redistribute it and/or modify  *

Si potrà trovare lo stesso testo nell'intestazione di ogni file sorgente creato all'interno di &kdevelop; (utilizzando gli strumenti appropriati per la creazione dei file). Queste impostazioni sono memorizzate in alcuni modelli di file che possono essere trovati nella cartella `templates`.

##### Copyright dell'applicazione

Una volta avviata l'applicazione &kde;, l'utente può visualizzare i dati relativi al menu Aiuto alla voce Informazioni su. Dando un'occhiata al file `main.cpp` si può trovare una linea simile alla seguente, anch'essa inserita dalla procedura guidata.

    int main(int argc, char **argv)
    {
        KAboutData about("hello", I18N_NOOP("Hello"), version, description,
                         KAboutData::License_GPL, "(C) 2006 Joe User", 0, 0,
                         "joe@user.com");
        about.addAuthor( "Joe User", 0, "joe@user.com" );

In questo modo sono state inserite le informazioni sul nome dello sviluppatore (in questo caso Joe User) e l'indirizzo di posta elettronica nelle pagine Accordo di licenza e Autori nella finestra Informazioni su.

Quando si effettuano modifiche sostanziali ad un progetto esistente, assicurarsi di inserire il proprio nome e il proprio indirizzo di posta elettronica nelle informazioni di copyright su ogni file modificato e nelle informazioni visualizzate nella finestra. Non si deve essere timidi: in questo modo si aiuterà considerevolmente la comunità open source.

#### File sorgenti iniziali

La procedura guidata inserirà i file sorgente nella sottocartella `src` del progetto, dove saranno presenti i file `main.cpp`, `hello.h` e `hello.cpp`.

Saranno presenti alcuni file aggiuntivi che possono essere trovati in una tipica applicazione &kde;

- `hello.desktop` contiene alcuni metadati usati da &kdevelop; per la manutenzione e l'avvio dell'applicazione.

- `hi16-app-hello.png` e `hi32-app-hello.png` contengono alcune icone predefinite, utilizzate nella visualizzazione dell'applicazione.

- Infine, il file `helloui.rc` contiene una descrizione dell'interfaccia utente, di fatto i menu forniti dall'applicazione.

#### Documentazione iniziale dell'applicazione

Nella sottocartella `doc/en` si può trovare il file `index.docbook`. Si tratta di un modello predefinito che si può utilizzare per iniziare a scrivere la documentazione utente.

#### File del progetto e ausiliari

Nella vista strumenti Albero file, i file introdotti precedentemente sono visualizzati in grassetto, mentre altri non lo sono. Questa visualizzazione riflette il diverso compito per cui vengono utilizzati questi file. Quelli visualizzati in grassetto influenzano direttamente l'applicazione; i file sorgenti produrranno il codice che può essere eseguito, mentre gli altri forniranno i dati e la documentazione necessaria. Questi ultimi devono essere gestiti ed elaborati ordinatamente nelle fasi di compilazione del progetto, e sono chiamati file di progetto.

Anche nella finestra Gestore automake in basso a destra dell'area di lavoro si troverà un elenco dei file di progetto. Queste informazioni sono utilizzate dal gestore per occuparsi del controllo della compilazione, come verrà illustrato in seguito.

I file visualizzati non in grassetto sono di natura più ausiliaria. Essi appartengono a diverse classi:

- ##### Controllo di compilazione del progetto

  Questi file controllano i processi di compilazione, l'installazione, la costruzione della compilazione, &etc;. Se il progetto usa gli strumenti autotools di &GNU;, si troverà un file chiamato Makefile.am in tutte le cartelle del progetto. Sono un tipo di file make che contengono dei comandi per la compilazione che verranno eseguiti assieme ai vari file `configure` durante le fasi della compilazione. Tale processo genera un file `Makefile` in ogni cartella. A loro volta, da questi ultimi, l'utility make effettuerà la compilazione dell'applicazione.

  I file `Makefile.am` devono essere gestiti attraverso il processo di sviluppo. Fortunatamente, &kdevelop; esonera lo sviluppatore da questo peso attraverso il gestore automake, che in sostanza è un front end grafico per la gestione dei contenuti dei `Makefile.am`.

  Gli altri file di controllo attualmente elencati sono `configure.in.in` e `subdirs` nella cartella root del progetto. Essi saranno elaborati da alcuni file nella cartella di amministrazione di &kde; `admin` per produrre altri tipi di file `configure` e `Makefile` ed infine i binari dell'applicazione.

- ##### File di controllo di &kdevelop;

  &kdevelop; necessita di alcuni file di controllo e dati di amministrazione, che si trovano nella cartella root del progetto. In questo esempio essi sono `hello.kdevelop`, `hello.kdevelop.pcs` e `hello.kdevses`.

  Il file `xxx.kdevelop` (dove xxx indica il nome del progetto) è particolarmente importante: infatti è il file di progetto di KDevelop 3 ed è necessario se si vuole in seguito caricare il progetto in questo &IDE;.

  Non si dovrebbe mai modificare, rinominare o cancellare questi file di controllo! Probabilmente l'&IDE; non funzionerebbe correttamente con il progetto.

- ##### File di descrizione GNU del progetto

  Alcuni file della cartella root del progetto sono obbligatori per ogni applicazione conforme agli standard &GNU;. Essi sono: `AUTHORS`, `ChangeLog`, `INSTALL`, `COPYING` (che contiene la GNU GENERAL PUBLIC LICENSE), `INSTALL`, `NEWS`, `README` e `TODO`.

- ##### Altri file

  Altri file, non ancora menzionati, sono:

  - `Doxyfile` controlla la creazione della documentazione sulle &API; interne dell'interfaccia di programmazione specifiche del progetto.

  - La cartella `templates` contiene i modelli di file che l'&IDE; utilizza come base per creare i nuovi file sorgenti. Questi file possono essere modificati in qualunque momento e le modifiche si rifletteranno nei rispettivi file sorgenti che si generano successivamente.

    Si potrebbe voler &eg; riallineare gli asterischi nelle linee relative alle note di copyright che sono stati inseriti dalla procedura guidata nei modelli dei file `cpp` e `h`, in modo da migliorarne l'aspetto.

  - La cartella `po` sarà usata per la localizzazione. È una parte essenziale dei file di progetto (contiene infatti un file `Makefile.am`), ma verrà utilizzata per le traduzioni. Non è di grande interesse per gli sviluppatori software.

  - Infine la cartella`admin` è necessaria principalmente alle applicazioni &kde;. Contiene un insieme di file necessari per la gestione dei sorgenti e dei file binari dell'applicazione, in modo che possano essere integrati correttamente nell'ambiente &kde;

### Ulteriori viste strumenti

Si può notare come non appena la procedura guidata ha terminato la creazione del progetto, sono apparse diverse viste strumenti aggiuntive. Esse infatti sono utili solo durante lo sviluppo di un progetto e forniscono le seguenti funzionalità.

Le viste strumenti effettivamente disponibili dipendono dai moduli caricati in &kdevelop;. Per controllare quali moduli sono presenti vedere il capitolo Moduli per ottenere informazioni.

#### Strumenti di navigazione e selezioni (parte sinistra)

- ##### Segnalibri

  Permette di contrassegnare qualunque linea in un file di testo in modo da ritornare velocemente in quella posizione. &kdevelop; memorizzerà questi segnalibri, anche se si chiude la finestra dell'editor. Questa vista strumenti elenca tutti i segnalibri per nome del file e per numero di linea. È sufficiente fare clic su un segnalibro per aprire la finestra delle editor corrispondente con il cursore posizionato sulla relativa linea.

- ##### Classi

  Elenca le classi, i metodi, &etc; del progetto. Facendo clic su una voce verrà aperto il file header o sorgente relativo in una finestra dell'editor e il cursore sarà posizionato sulla corrispondente dichiarazione o definizione.

- ##### Gruppi di file

  Elenca i file del progetto in raggruppamenti &ie; Sorgenti, Interfaccia utente, icone, traduzioni e altro. Facendo clic su una voce verrà aperto il file corrispondente in una finestra dell'editor.

- ##### Variabili

  Questa vista è usata dallo strumento di debug per visualizzare, valutare e controllare le variabili durante le sessioni di debug.

#### Messaggi (in basso)

- ##### Valgrind

  Valgrind è un analizzatore run-time di applicazioni. Questa vista strumenti visualizza i risultati delle analisi effettuate da questo strumento, che viene usato &eg; per trovare le perdite di memoria (memory leaks).

- ##### Problemi di sicurezza

  Il modulo di &kdevelop; Controllo di sicurezza analizza i file sorgente attualmente modificati per cercare diversi problemi di sicurezza comuni che possono essere inseriti nelle applicazioni e avverte l'utente in questa vista strumenti.

- ##### Breakpoint

  Questa vista permette di impostare, cancellare e gestire esplicitamente i punti di interruzione di debug nei file sorgente dell'applicazione. Viene usata assieme al debugger.

- ##### CTags

  Permette di creare un database di identificatori utilizzando la applicazione CTags. Questo database di tag può quindi essere usato al di fuori di questa vista strumenti per cercare nei sorgenti gli identificatori desiderati. Facendo clic sulla linea di un oggetto trovato verrà aperta una finestra dell'editor e verrà posizionato il cursore sull'identificatore corrispondente.

- ##### Problemi

  &kdevelop; mantiene una traccia di tutti i problemi di programmazione comuni nel file attualmente aperto nell'editor e li notifica all'utente in questa vista strumenti.

#### Gestione sorgenti (parte destra)

- ##### Gestore automake

  Il gestore automake è principalmente un front end grafico per la gestione dei contenuti dei file `Makefile.am` posizionati nelle cartelle del progetto. Questa vista strumenti utilizza due finestre: quella superiore visualizza parte delle sottocartelle del progetto, ovvero quelle che contengono esplicitamente dei file del progetto. Ogni sottocartella di questo tipo deve contenere un file `Makefile.am` e in questo contesto viene chiamata `sottoprogetto`.

  Facendo clic su una voce verranno visualizzati nella finestra inferiore i file contenuti nel relativo sottoprogetto. I file elencati saranno raggruppati a seconda della loro funzionalità nel sottoprogetto.

  Il gestore automake è un potente strumento per gestire il progetto e i relativi sottoprogetti, oltre ai vari compiti svolti dai vari file di progetto. Saranno illustrati brevemente gli aspetti principali più avanti, mentre per una descrizione più completa si può consultare il capitolo Compilazione e gestione del progetto.

## Alcuni consigli sui documenti

In questo progetto di esempio, la procedura guidata aprirà il file `hello.cpp` in una finestra dell'editor, in modo da poter iniziare a lavorare immediatamente. Si presume che il lettore abbia una conoscenza sufficiente per utilizzare un editor, tuttavia ci sono alcune caratteristiche pratiche che sono peculiari di &kdevelop; come le finestre dell'editor a schede. Si effettuerà una breve panoramica ad alcune caratteristiche, tra cui:

- Come passare velocemente tra il file header e il file di implementazione
- Come accedere velocemente alle dichiarazioni e alle definizioni
- Come adattare le finestre dell'editor alle proprie necessità
- Come tenere sott'occhio i problemi comuni

### Passare dal file header al file di implementazione

&kdevelop; fornisce un metodo veloce e facile per passare da un file di implementazione (`.cpp`) ad un file header (`.h`) e viceversa. Fare clic con il tasto destro nella finestra dell'editor, e apparirà il seguente menu

Come passare da un file di implementazione a un file header

Trovare la voce Commuta tra intestazione e implementazione e selezionarla. &kdevelop; cercherà il file di header o di implementazione e lo aprirà in un'altra finestra dell'editor. In questo esempio, facendo clic con il tasto destro nel file sorgente `hello.cpp` verrà visualizzato il file `hello.h`.

Inoltre, se si fa clic con il tasto destro all'interno del codice di implementazione di una classe, &kdevelop; posizionerà il cursore nella relativa linea di dichiarazione nel file header. Viceversa, con il clic destro su una linea di dichiarazione si passerà alla implementazione corrispondente.

Se è già presente la finestra dell'editor contente il file, &kdevelop; la attiverà ed eventualmente riposizionerà il cursore.

### Come accedere alle dichiarazioni e alle definizioni

Cosa fare se si sta lavorando su un file sorgente e si vuole controllare la dichiarazione o la definizione di un identificatore? Si può effettuare facilmente questa operazione facendo clic con il tasto destro sull'identificatore desiderato.

Tuttavia esistono due situazioni da considerare, ovvero:

- Accedere agli identificatori definiti esternamente, e
- gestire gli identificatori interni

#### Dichiarazioni e definizioni esterne

Nella maggior parte dei casi si vorrà cercare un identificatore che è stato definito esternamente al proprio progetto. Nei progetti &kde; tali identificatori sono tipicamente documentati nelle varie librerie &kde; o &Qt;. Se &kde; e &kdevelop; sono stati installati correttamente, allora &kdevelop; sarà in grado di accedere alla cosiddetta documentazione API e di cercare all'interno di essa l'identificatore.

Ad esempio, nella finestra dell'editor del file `hello.cpp` si trovano le seguenti linee.

    Hello::Hello()
        : KMainWindow( 0, "Hello" )
    {

Facendo clic con il tasto destro su `KMainWindow` verrà visualizzato un menu. Selezionando la voce Ricerca nella documentazione: KMainWindow si aprirà la vista strumenti Documentazione, dove sarà stata inserita la voce `KMainWindow` nella sottopagina Cerca. Dopo poco tempo verrà aperta una finestra dell'editor nell'area di lavoro principale dove sarà visualizzata la pagina di riferimento della documentazione API di KDE relativa alla classe `KMainWindow`.

Questa sarà visualizzato come segue (È stata deliberatamente aperta la pagina Documentazione, Cerca per illustrare il risultato della selezione).

Come cercare un identificatore documentato esternamente

Si può selezinare la voce Cerca documentazione su: KMainWindow. In questo caso verrà aperta la vista strumenti Documentazione, mostrando tipicamente una selezione di pagine che contengono il termine cercato (nel nostro caso i termini saranno probabilmente i nomi delle classi `KMainWindow` e `KMainWindowInterface`). Selezionare la voce di interesse e verrà visualizzata in una finestra del'editor la documentazione relativa.

Nel caso il procedimento non funzionasse, allora potrebbe non essere stato ancora creato un indice della documentazione. Per crearlo, seguire le istruzioni fornite precedentemente e riprovare.

#### Dichiarazioni e definizioni interne al progetto

Le funzioni di ricerca nella documentazione esterna presentano tuttavia delle limitazioni. Non si può ovviamente cercare un identificatore esterno se è stato definito e usato solo all'interno del progetto. &kdevelop; può invece utilizzare gli indici costruiti dall'applicazione CTags per effettuare ricerche all'interno dei sorgenti del proprio progetto.

Prima di poterlo usare nel progetto di esempio Hello, è necessario generare un indice. Questo può essere effettuato tramite la vista strumenti CTags nella parte inferiore dell'area di lavoro.

Quando si fa clic sulla linguetta CTags verrà visualizzata una finestra di dialogo dove si troverà il seguente pulsante nell'angolo inferiore destro.

Costruzione dell'indice CTags con il pulsante Rigenerare

Premere il pulsante Rigenerare e attendere qualche secondo. In seguito il messaggio Nessun database CTags trovato sarà sostituito con l'indicazione della data attuale. Ora si è pronti per effettuare le ricerche di identificatori all'interno dei sorgenti del progetto.

La data presente a fianco del pulsante Rigenerare permette di ricordarsi dell'eventualità di indici non aggiornati. Quando non si riesce a trovare un identificatore nel progetto, si consideri la possibilità di dover rigenerare l'indice. Nei grandi progetti questo potrebbe occupare un lasso di tempo considerevole, ma si dovrebbe prendere l'abitudine di rigenerare l'indice regolarmente dopo aver effettuato modifiche significative ai file sorgente.

La ricerca di un identificatore può essere svolta tramite diversi mezzi.

- ##### Utilizzo della vista strumenti CTags

  È un metodo semplice. Inserire il nome dell'identificatore nel campo di input Ricerca in basso a sinistra. &kdevelop; cercherà di completare la parola che si sta inserendo mostrando tutte le posizioni occupate dagli identificatori il cui nome inizia con la sequenza di caratteri che si sta inserendo.

  Se ad esempio si vuole sapere se è stato utilizzato l'identificatore Hello si può inserire la lettera "H" nel campo Ricerca. &kdevelop; inzierà immediatamente la ricerca, visualizzando questi risultati:

  Come cercare un identificare nella vista strumenti CTags

  Facendo clic su un elemento della lista, verrà aperto una finestra dell'editor che visualizzerà il file relativo e verrà spostato il cursore nella posizione appropriata.

- ##### Utilizzo di un menu contestuale in un file sorgente

  È un metodo pratico quando si sta lavorando su un certo file sorgente. Supponendo di lavorare sul file `main.cpp`. Incontrando la linea seguente

      Hello *mainWin = 0;

  si vuole sapere dove è stato utilizzato l'identificatore Hello nella applicazione. Per trovarlo, fare clic con il tasto destro sull'identificatore e sarà visualizzato un menu, che mostrerà le seguenti linee

  Ottenere informazioni di CTags su un identificatore interno del progetto

  Facendo clic sulla voce di interesse, ad esempio Ctags - Vai alla definizione: Hello, verrà aperta immediatamente la finestra dell'editor relativa al file `hello.cpp` e verrà posizionato il cursore proprio sulla definizione della classe:

      Hello::Hello()
          : KMainWindow( 0, "Hello" )
      {

- ##### Effettuare una ricerca globale

  Questo tipo di ricerca è utile se si vuole trovare un testo arbitrario nei sorgenti del progetto. Una ricerca globale può essere effettuata in due modi:

  - Si può avviare una ricerca globale attraverso il menu Modifica Trova nei file..., oppure

  - si può usare direttamente il menu contestuale attraverso un clic destro nella finestra dell'editor.

  Verrà illustrato il secondo metodo nel progetto di esempio Hello, ma i risultati saranno simili al primo metodo. Si ipotizzerà che si stia lavorando sul file `hello.cpp` e il cursore sia posizionato sul primo identificare Hello. Ora si vuole sapere dove la parola Hello è stata utilizzata nei sorgenti del progetto e quante volte essa compare. Questo è un tipico esempio di uso delle funzioni di ricerca globale di &kdevelop;.

  Mantenendo il cursore sopra a Hello, fare clic con il tasto destro del mouse. Apparirà il menu contestuale dove si deve selezionare la voce Grep: Hello.

  Avviare una ricerca globale all'interno di una finestra dell'editor

  Verrà visualizzata la seguente finestra Trova nei file (esattamente la stessa che compare selezionando il menu Modifica Trova nei file...).

  Un front end grafico e versatile per effettuare ricerche globali all'interno del progetto

  Si può osservare che è uno strumento molto versatile per avviare ricerche con le applicazioni find e grep . Non si effettueranno approfondimenti dettagliati, ma si possono tentare degli esperimenti. Al momento dovrebbe essere preselezionato nel campo Schema la parola Hello. In caso contrario, inserirla e premere il pulsante Cerca in basso a destra.

  Verrà aperta la vista strumenti Trova nei file in basso, visualizzando i nomi dei file e le linee relative a tutte le parole Hello presenti nel progetto. Come sempre, facendo clic su una voce &kdevelop; visualizzerà esattamente il file e la posizione relativa in una finestra dell'editor.

  Esistono due linee di particolare interesse nella finestra della vista strumenti.

  - In alto a destra si troveranno le sequenze di comandi utilizzate effettivamente da &kdevelop; per effettuare la ricerca. Sono utili per controllare con maggiore precisione la ricerca.

  - In basso verrà visualizzato il numero di voci trovate durante la ricerca. In questo esempio si dovrebbe leggere *** 11 corrispondenze trovate ***.

  &kdevelop; memorizza i risultati della ricerca attraverso la sessione corrente. Se si avvia una nuova ricerca globale, i risultati verranno elencati in una nuova scheda della vista strumenti Trova nei file.

### Adattare le finestre dell'editor

Quando si deve lavorare con progetti estesi e complessi, ci si potrebbe trovare nella situazione di avere molte schede inserite nella barra delle schede. &kdevelop; fornisce delle funzionalità per ripulire, riordinare e raggruppare queste schede.

- Come rimuovere schede non necessarie
- Come riorganizzare le schede
- Come visualizzare diversi file nell'area di lavoro contemporaneamente
- Come modificare contemporaneamente i file header e sorgente C++
- Come raggruppare i file sorgente in sessioni di sviluppo

#### Ripulire la barra delle schede

Se l'insieme delle schede inizia a diventare disorganizzato, si potrebbe voler chiudere tutte le schede che non sono più necessarie. Con &kdevelop; è possibile effettuare questa operazione attraverso la chiusura in blocco delle finestre dell'editor aperte oppure specificando quali finestre devono essere chiuse e quali devono restare aperte.

##### Chiusura di varie schede alla volta

Questo è un metodo che permette di chiudere tutte le schede non necessarie che si può trovare anche in altre applicazioni &kde;. Si può usare il menu Finestra oppure fare clic con il tasto destro su una scheda per

- chiudere la finestra dell'editor attualmente selezionata,

- chiudere tutte le altre finestre dell'editor aperte, oppure

- chiudere tutte le finestre in un solo colpo (disponibile solo nel menu Finestra).

##### Chiusura delle schede selezionate

Il metodo passo per passo della chiusura delle schede può diventare scomodo quando è presente un grande numero di schede tra le quali se ne vogliono mantenere diverse aperte.Invece che cercare e chiudere una scheda dopo l'altra, si possono selezionare le schede da un elenco e chiuderle con un solo clic del mouse.

Si suppone di avere, nel progetto Hello di esempio, diversi file aperti: `hello.cpp`, `hello.h`, `helloui.rc`, `hello.desktop` e `main.cpp`. Si vuole chiudere tutte le finestre tranne `hello.cpp` e `hello.h`. Nella vista strumenti Lista file saranno elencati alfabeticamente tutti i file aperti, in modo da individuare facilmente quelli che devono essere chiusi. Procedere come segue:

1. Aprire Lista file e, tenendo premuto il tasto Ctrl fare clic nella lista sui file che si vuole chiudere.

2. Mantenendo il puntatore dei mouse sul nome di un file della lista, fare clic con il tasto destro del mouse.

3. Dal menu contestuale Lista file selezionare Chiudi selezionato.

Come chiudere le finestre selezionate in una sola operazione.

&kdevelop; chiuderà tutte le finestre dell'editor desiderate e si può procedere con una barra di schede nuovamente pulita.

#### Come riorganizzare le schede

Anche se sono aperte solo le finestre necessarie, si potrebbe desiderare di organizzare le schede in modo logico. &kdevelop; fornisce alcuni metodi per farlo:

##### Impostazione di base — dove posizionare le nuove schede

Per impostazione predefinita, quando si apre una nuova finestra, verrà posizionata la relativa scheda a destra della scheda attualmente aperta.Questa impostazione può essere modificata in modo che la nuova scheda sia posizionata all'estrema destra nella barra delle schede.

Per attivare questo comportamento è necessario modificare le impostazioni dell'interfaccia utente di &kdevelop;

1. Selezionare Impostazioni Configura KDevelop...

2. Nella parte destra della finestra di dialogo fare clic sull'icona Interfaccia utente. Verrà visualizzata la pagina Interfaccia Utente.

3. Nell'angolo in basso si trova la sezione intitolata Navigazione con schede. Rimuovere la marcatura della casella Apri nuova scheda dopo la corrente.

4. Chiudere &kdevelop; e riavviarlo. Ora le schede delle nuove finestre aperte saranno posizionate all'estremità destra nella barra delle schede.

Sfortunatamente, questa impostazione non può essere cambiata al volo durante una sessione di lavoro. Si dovrebbe decidere quale comportamento si desidera, almeno fino al prossimo avvio di &kdevelop;.

##### Come riorganizzare le schede

Data la varietà dei compiti svolti durante lo sviluppo, prima o poi sorge la necessità di riorganizzare le schede delle finestre.

Fare clic sulla scheda che si vuole spostare con il tasto centrale del mouse e spostare leggermente il mouse: il cursore assumerà l'aspetto di due frecce incrociate. Ora è possibile trascinare la scheda, mantenendo il tasto centrale premuto, fino alla posizione desiderata.

#### Visualizzare diversi file contemporaneamente

A prima vista è presente sempre una singola finestra dell'editor aperta per lavorare su un file sorgente. Anche se si può cambiare velocemente scheda, a volte si desidera avere diversi file aperti contemporaneamente, &eg; per avere un maggior controllo durante i compiti più difficili. &kdevelop; permette di suddividere l'area di lavoro in diverse sezioni, che possiedono una propria serie di schede.

Sono presenti due comandi raggiungibili attraverso il menu Finestra o facendo clic con il tasto destro in una una scheda o in una linguetta. Verrà illustrata la procedura di suddivisione nuovamente nell'esempio del progetto Hello.

Si ipotizzerà che siano aperti nella barra delle schede i seguenti file: `hello.cpp` e `hello.h`. Mentre si sta lavorando sul file `hello.cpp`, si ha spesso la necessità di fare riferimento alle dichiarazioni contenute nel file header `hello.h`, quindi è utile poter mantenere i due file aperti simultaneamente.

Fare clic con il tasto destro sulla linguetta del file `hello.h`. Verrà aperto il seguente menu.

Come suddividere l'area di lavoro attuale in due parti.

Selezionare la voce Dividi orizzontalmente. L'area di lavoro attuale verrà suddivisa a metà e la finestra dell'editor relativa al file `hello.h` sarà spostata nella parte inferiore.

L'area di lavoro è stata divisa orizzontalmente

La linea di separazione tratteggiata tra le finestre può essere trascinata con il mouse in modo da poter adattare le altezze delle finestre.

Ci sono alcune considerazioni

- Le aree divise sono completamente funzionali: le nuove schede saranno aperte nell'area di lavoro che contiene la finestra dell'editor attualmente attiva. Si può suddividere ulteriormente una sottoarea a proprio piacimento, aprendo così tutti i file necessari contemporaneamente.

- Ogni suddivisione sposterà la finestra dell'editor attualmente attiva nella nuova sottoarea di lavoro, in basso o a destra. Le altre schede rimarranno nelle loro posizioni. Non si possono spostare direttamente le finestre attraverso le sottoaree: per fare questo è necessario chiudere esplicitamente la finestra in una area e riaprirla nell'altra.

- Inoltre, non esiste un metodo diretto per chiudere esplicitamente una sottoarea. Essa verrà chiusa automaticamente alla chiusura dell'ultima scheda contenuta in essa.

#### Modificare contemporaneamente i file sorgenti e header C++

La capacità di suddividere l'area di lavoro in &kdevelop; ha una simpatica applicazione: permette di aprire automaticamente una sorgente `.cpp` e il corrispondente file header `.h`. Come opzione, si può lavorare sui due file in modo sincrono, in modo tale che quando si seleziona una dichiarazione nel file header, &kdevelop; navigherà nella corrispondente definizione nel file sorgente e viceversa.

Tuttavia questa funzionalità è disattivata come impostazione predefinita: per utilizzarla deve essere attivata.

Selezionare Progetto Opzioni progetto. Verrà visualizzata la finestra di dialogo Opzioni Progetto, dove deve essere selezionata l'icona Gestione C++ e in seguito la scheda Funzioni navigazione nella pagina visualizzata a destra.

Avere i file header e sorgente affiancati

Ora, marcare la casella Enable split of Header/Source files, che abilita per impostazione predefinita Sincronizzazione automatica e Verticale. Per il momento mantenere queste opzioni e fare clic su OK.

Ora chiudere nel progetto di esempio Hello sia il file `hello.cpp` che `hello.h`, poi selezionare nuovamente `hello.cpp` dalla sottocartella `src` del progetto. Si aprirà normalmente una finestra dell'editor; tuttavia, aprendo il file `hello.h` verrà effettuata automaticamente la divisione dell'area di lavoro e sarà aperto il file header in una finestra dell'editor proprio sotto alla finestra relativa al file `hello.cpp`.

Inoltre, cercando nella finestra del file `hello.cpp` la linea di definizione del costruttore:

    Hello::Hello()

e posizionando il cursore su questa linea, si può notare che nella finestra inferiore, relativa al file `hello.h`, il cursore si sarà posizionato nella linea corrispondente di dichiarazione del costruttore.

&kdevelop; ha navigato automaticamente alla dichiarazione del costruttore

Funziona anche al contrario: se si posiziona il cursore in qualche punto in una finestra dove è presente un costrutto, &kdevelop; navigherà al costrutto corrispondente nell'altra finestra.

#### Raggruppamento dei file sorgente in sessioni di sviluppo

Quando il progetto cresce e lo sviluppo diventa sempre più complesso e obbliga a passare spesso attraverso insiemi diversi di file, allora è il momento di organizzare il lavoro in diverse sessioni. La vista strumenti Lista file ha questa funzionalità.

Nella parte alto della vista strumenti Lista file è presente una barra degli strumenti con la quale si possono creare, salvare, selezionare e rimuovere sessioni. Alternativamente si può usare il sottomenu Visualizza Vista sessioni.

Nel progetto di esempio, si desidera di voler sempre aprire i file `hello.cpp`, `hello.h` e `main.cpp` in una sola volta, indipendentemente da quale compito si stia svolgendo in quel progetto. Si deve per prima cosa creare una nuova sessione di sviluppo chiamata, ad esempio, `sources`.

Utilizzo delle sessioni di sviluppo per memorizzare i gruppi di file

Questo può essere svolto attraverso le seguenti fasi:

1. Creazione di una nuova sessione

   1. Fare clic sull'icona New Session in alto a sinistra nella vista strumenti Elenco file.

   2. Verrà visualizzata una finestra di dialogo. Nel campo Inserisci il nome della sessione fornire il nome alla nuova sessione, &eg; sources.

   3. Chiudere la finestra di dialogo facendo clic su OK. La nuova sessione verrà elencata nella casella a discesa sulla barra degli strumenti.

2. La nuova sessione sarà inizialmente vuota, e dovrà essere popolata con i file che dovrà contenere.

   1. Aprire tutti i file che si vuole raggruppare nella sessione. In questo esempio è stato deciso di inserire i file `hello.cpp`, `hello.h` e `main.cpp`.

   2. Una volta che è stata completato l'elenco, fare clic sull'icona Salva Sessione. Non si deve saltare questo passo, altrimenti saranno persi i file elencati.

Quando si seleziona la sessione sources dalla casella a discesa Apri sessione, &kdevelop; chiuderà tutte le finestre attualmente aperte e aprirà quelle relative ai file della lista (in questo caso `hello.cpp`, `hello.h` e `main.cpp`).

Nel contesto del progetto si possono definire tutte le sessioni che si desiderano. Se si vuole modificare i contenuti della sessione, si può aggiornare l'elenco dei file facendo clic su Salva sessione. Se ci si vuole sbarazzare di una sessione, selezionarla nella casella a discesa e fare clic sull'icona Elimina sessione sulla barra degli strumenti.

Si può impostare l'apertura di una data sessione in modo predefinito quando viene caricato il progetto. Per fare questo, selezionare la sessione nella casella a discesa nella pagina di configurazione del progetto in Progetto Opzioni progetto Lista file.

Aprire una sessione specifica quando il progetto è stato caricato.

### Tenere d'occhio i problemi comuni

Quando si apre un file, &kdevelop; analizzerà suo contenuto, in modo che il reporter di problema possa scansionare il testo per trovare alcuni errori comuni. L'utente può essere avvertito di alcune posizioni che sono state contrassegnate.

Verrà illustrata questa funzionalità nel progetto Hello di esempio.

- Aprire il file sorgente `main.cpp`.

- Assicurarsi che contenga la seguente linea

      /// @todo do something with the command line args here

  Essa è stata inserita dalla procedura guidata quando è stato creato il progetto Hello nel capitolo Iniziare un nuovo progetto precedente.

- Ora aprire la vista strumenti Problemi in basso. Se tutto va bene, apparirà questo avviso:

  &kdevelop; avverte che una linea di codice sorgente contiene un contrassegno.

Il formato del comando `/// @todo` deriva dal documentatore di codice Doxygen, il quale verrà descritto velocemente nella sezione Documentazione. Non è obbligatorio usare questo formato, e saranno riconosciuti anche i marcatori `TODO` e `FIXME`.

Se si vogliono inserire &eg; i seguenti commenti contenenti i marcatori `TODO` e `FIXME` nel file di esempio `hello.cpp`

    Hello::Hello()
        : KMainWindow( 0, "Hello" )
    {
        // set the shell's ui resource file
        // TODO check the user interface
        setXMLFile("helloui.rc");

        // FIXME change to a better suited greeting
        new QLabel( "Hello World", this, "hello label" );
    }

allora essi saranno elencati nella vista strumenti Problemi

Il reporter di problema elencherà le linee del file attuale che richiedono attenzione.

Notare le schede presenti nella vista strumenti Problemi, in particolare Da sistemare e Da fare. Selezionandole, si troveranno le linee contrassegnate con i marcatori `FIXME` e `TODO`. Ad esempio, gli avvisi contrassegnati con `TODO` saranno visualizzati così:

Il reporter di problema ha raccolto gli avvisi contrassegnati con `TODO`.

La scheda Errori non conterrà gli errori di programmazione effettuati: essi saranno rilevati da altri strumenti &eg; durante la compilazione. Si troveranno invece gli avvisi relativi ad alcuni problemi che sarebbero probabilmente passati inosservati e probabilmente sarebbero stati scoperti con difficoltà durante complesse sessioni di debug.

Il reporter di problema di &kdevelop; è un valido strumento, quindi è consigliabile di controllare regolarmente la vista strumenti Problemi durante il lavoro.

## Come compilare un nuovo progetto

La compilazione di un progetto richiede diverse fasi di setup che precedono la compilazione dell'applicazione. Esse sono disponibili attraverso il menu Compila.

La compilazione di un progetto viene effettuata in diverse fasi

Per il momento si considera solo la parte superiore di questo menu, le cui voci sono elencate in ordine di importanza. Il comando che si utilizza più frequentemente è in alto, alla voce Compila progetto. Il comando effettua l'inizializzazione del progetto, la compilazione e il linking.Le altre voci sono relative alla compilazione di parti del progetto o un singolo file, all'inizializzazione o l'installazione dei binari dell'applicazione.

Per ora si considereranno le funzionalità di &kdevelop; relative all'impostazione del progetto, l'inizializzazione, la compilazione e l'esecuzione di una applicazione. Generalmente esse comprendono:

- Il ciclo di sviluppo
- I metodi principali per configurare un progetto

### Il ciclo di sviluppo

Quando si è creato un nuovo progetto, generalmente si vuole verificare che tutto sia stato impostato correttamente. Questa verifica implica una prima compilazione del progetto e l'esecuzione dell'applicazione. Per compilare un progetto si devono effettuare diverse fasi:

- Come inizializzare un progetto per la prima compilazione
- Come effettuare la configurazione iniziale
- Come creare il progetto
- Come avviare l'applicazione da &kdevelop;

Queste istruzioni prevedono che il progetto sia basato sugli autotools &GNU;, che attivano il gestore automake in &kdevelop;, come nel progetto di esempio Hello. Se si crea un altro tipo di progetto, &eg; per il gestore di progetti QMake, basato su &Qt;, saranno presenti altre funzionalità nei menu oppure potrebbero risultare assenti. È necessario in questi casi consultare la documentazione del fornitore relativa alla gestione del progetto e alla compilazione dell'applicazione.

#### Inizializzare il progetto per la compilazione

Quando la procedura guidata, dopo la creazione del progetto di esempio Hello, lo ha lasciato in uno stato preliminare. Gli autotools &GNU; richiedono una serie di fasi di inizializzazioni da compiere prima che l'applicazione possa essere effettivamente compilata. Se si cerca di compilare il progetto senza le inizializzazioni, selezionando Compila Compila progetto o premendo il tasto F8, si otterrà il seguente messaggio di avvertimento:

Tentativo di compilare un progetto basato su Automake non inizializzato

Premendo il pulsante Eseguili, &kdevelop; tenterà di effettuare queste inizializzazioni automaticamente prima della compilazione e il linking. Si analizzeranno queste fasi in dettaglio, quindi chiudere la finestra di dialogo premendo il tasto Non eseguire.

Come detto in precedenza, la compilazione e il linking dell'applicazione viene effettuato tramite il menu Compila. Aprirlo e selezionare la voce Esegui autotools.

Avviare una inizializzazione

&kdevelop; aprirà la vista strumenti Messaggi in basso ed elencherà una serie di messaggi prodotti dagli strumenti. Se tutto è andato bene, la linea finale sarà `*** successo ***`.

Risalendo fino alla prima linea, si troverà il comando inviato da &kdevelop; agli strumenti:

    cd '/home/devel/projects/hello' && \
    WANT_AUTOCONF_2_5="1" WANT_AUTOMAKE_1_6="1" gmake -f Makefile.cvs

Questo comando indica in pratica che &kdevelop; è entrato prima nella directory radice del progetto, poi ha impostato un ambiente dedicato, indicando al sistema make quali versioni degli strumenti autoconf e automake utilizzare. Infine ha comandato lo strumento make (in questo caso &GNU; gmake) di elaborare il makefile `Makefile.cvs`.

Questo makefile è stato impostato automaticamente alla creazione del progetto e contiene tutti i comandi necessari per una corretta inizializzazione in modo che l'applicazione venga eseguita in &kde;. In particolare esso crea gli script `configure`, necessari per effettuare la fase successiva.

#### Configurazione iniziale

La configurazione consiste nell'adattare la compilazione alle peculiarità hardware e software del proprio sistema. È un requisito fondamentale nei processi di compilazione basati sullo schema degli autotools &GNU;.

La sequenza di configurazione sarà disponibile solo dopo una corretta inizializzazione di automake, poiché solo dopo questa saranno disponibili i file `configure`. Fatto questo, selezionare la voce del menu Compila Esegui configure per iniziare la sequenza di configurazione.

&kdevelop; aprirà la vista strumenti Messaggi nuovamente ed elencherà i messaggi prodotti dalla configurazione. Se tutto va bene, il messaggio finale sarà `Good - your configure finished. Start make now` (inviato da configure) seguito dal messaggio di &kdevelop; `*** Successo ***`.

La prima linea nella vista strumenti Messaggi conterrà anche in questo caso il comando usato da &kdevelop; per avviare la configurazione:

    mkdir '/home/devel/projects/hello/debug' && \
    cd '/home/devel/projects/hello/debug' && \
    CXXFLAGS="-O0 -g3" "/home/devel/projects/hello/configure" --enable-debug=full

Da questi messaggi si possono ricavare dettagli interessanti.

- Per prima cosa, &kdevelop; ha utilizzato una sottocartella dedicata per il processo di compilazione. Questa cartella, `debug` (mostrata a sinistra) rispecchia la struttura principale del progetto e contiene in ogni sottocartella un insieme di file relativi alla compilazione, come vari file basati su `configure` e un `Makefile`.

- Nella sezione Configurazione del progetto si darà uno sguardo al motivo per cui &kdevelop; usa cartelle diverse per la compilazione. Al momento è sufficiente sapere che &kdevelop; ha creato la cartella `debug` prima della configurazione e che lo script `configure` ha creato la sotto struttura e i `Makefile` al suo interno.

- In seguito, dall'interno della cartella `debug`, &kdevelop; ha chiamato lo script `configure` nella cartella radice del progetto utilizzando un ambiente dedicato, dove le opzioni `CXXFLAGS="-O0 -g3"` indicheranno in seguito che il compilatore &gcc; non deve ottimizzare i binari e che deve includere in essi tutte le informazioni di debug.

- Infine è stato avviato lo script `configure` con l'opzione `--enable-debug=full` che gli indica di creare ogni `Makefile` in modo tale che le successivi fasi di compilazione e di linking possano avere tutte le informazioni di debug.

Tutte queste impostazioni sono configurabili per ogni progetto. Sono disponibili ulteriori informazioni su questo argomento nel capitolo Gestione del progetto.

#### Compilazione del progetto

Ora si è pronti alla compilazione vera e propria &ie; compilare ed effettuare il link dell'applicazione. Osservando il menu Compila si può notare che sono presenti tre voci dedicate alla compilazione da poter selezionare.

Comandi per costruire i file binari

Procedendo dal basso verso l'alto, essi sono:

- Compila file — questo comando compila il file sorgente attualmente aperto nella finestra dell'editor. Viene usato per controllare velocemente eventuali errori.

- Compila target attivo — questo comando viene usato principalmente assieme al Gestore automake che verrà descritto in seguito.

- Compila progetto — questo è il comando che, procedendo per tutto il progetto, compilerà ed effettuerà il link di tutti file.

Potrebbe essere interessante osservare cosa accade nella cartella `Debug` creata dalla precedente esecuzione di `configure`. Per fare questo è meglio lasciarla aperta con tutte le sottocartelle, come mostrato sopra. Selezionare Compila Compila progetto (oppure premere il tasto F8) per avviare la sequenza di compilazione. Come in precedenza, verrà aperta la vista strumenti Messaggi e conterrà l'output del processo. Alcuni file aggiuntivi appariranno nelle sottocartelle di `Debug`.

Siccome nel progetto di esempio non sono presenti molti file sorgente, la vista Messaggi conterrà poche linee. In alto si troverà nuovamente il comando inviato da &kdevelop; alla shell sttostante.

    cd '/home/devel/projects/hello/debug' && \
    WANT_AUTOCONF_2_5="1" WANT_AUTOMAKE_1_6="1" gmake -k

&kdevelop; è passato nella cartella `Debug` per eseguire il `Makefile`. È stato impostato, come durante la fase di inizializzazione, un sotto ambiente dedicato dove è stato eseguito successivamente lo strumento gmake.

Notare l'opzione `-k` di gmake: essa forza il processo di compilazione in modo che esso continui fino al suo termine, anche in presenza di errori. Questa opzione ha senso poiché &kdevelop; elenca tutti gli errori nella finestra Messaggi. Se compaiono errori, si possono utilizzare le funzioni dell'&IDE;, facendo clic sul messaggio di errore: &kdevelop; si posizionerà esattamente nel file sorgente dove si è verificato l'errore.

Cosa è successo all'interno delle sottocartelle di `Debug`? Non molto: sono comparsi alcuni file nei rami `doc/en` e `src`, tra cui il file `hello` nella cartella `/home/devel/projects/hello/debug/src/`. Questo è il file binario dell'applicazione, e per effettuare un controllo del progetto è sufficiente eseguirlo.

#### Esecuzione dell'applicazione

Per eseguire la nuova applicazione Hello non è necessario compiere altre operazioni: si può selezionare Compila Esegui programma o premere Shift F9 o utilizzare il pulsante Esegue programma nella Barra strumenti compilazione visualizzata sotto.

Esecuzione dell'applicazione dalla Barra strumenti compilazione.

&kdevelop; avvierà l'applicazione in una console dedicata che si apre nella vista strumenti Applicazione. Il comando di esecuzione inviato da &kdevelop; verrà visualizzato sulla prima linea:

    ./hello

questo dimostra che l'&IDE; conosce dove si trova l'eseguibile che deve avviare. Anche questo può essere configurato, per ulteriori informazioni nel capitolo Gestione del progetto.

La linea `./hello` sarà molto probabilmente seguita da un messaggio di avvertimento che per il momento può essere ignorato: esso non impedisce a Hello si essere avviato.

L'applicazione Hello

Chiudere la finestra dell'applicazione Hello normalmente. Se non è avvenuto nessun errore, &kdevelop; riporterà il messaggio `*** Uscito normalmente ***` nella vista strumenti Applicazione.

### Configurazione del progetto

In &kdevelop; esistono molti modi per gestire un progetto: questo comportamento è configurabile da progetto a progetto ed è particolarmente interessante per gli sviluppatori più esperti. Tuttavia sono presenti alcune impostazioni specifiche per il progetto che si dovrebbero conoscere da subito.

- A cosa servono le configurazioni di compilazione?
- Dove si può definire il comportamento dello script `configure`
- Alcune considerazioni su come dovrebbe essere avviato make
- Dove dovrebbe essere l'eseguibile e come può essere chiamato?

#### Configurazioni di compilazione

Nella sezione Configurazione iniziale è stato avviato per la prima volta lo script `configure` e si è notato che &kdevelop; ha impostato una sottocartella dedicata di nome `debug`. In questa sezione verranno discusse brevemente alcune conseguenze di questo comportamento.

Prima di tutti, &kdevelop; non usa necessariamente delle cartelle dedicate: la configurazione di compilazione dedicata viene effettuata tramite dei template usati dalla procedura guidata per le applicazioni quando viene creato un nuovo progetto.

Per sapere quale configurazione di compilazione è disponibile attualmente, andare nel menu Progetto Configurazione compilazione.

Nel progetto sono disponibili diverse configurazione di compilazione

In questo caso, nel progetto Hello di esempio, sono disponibili tre diverse configurazioni di compilazione. In altri casi potrebbe — inizialmente — essere presente solo una configurazione di nome default.

La configurazione di compilazione attualmente usata ha un segno di marcatura a sinistra. Per passare ad un'altra configurazione selezionare semplicemente la relativa voce del menu.

Segue una breve descrizione delle configurazioni di compilazione.

debug

  Durante il processo di sviluppo dovrebbe essere usata questa configurazione di compilazione. La compilazione avviene separatamente dalle cartelle che contengono i sorgenti: viene utilizzata la sottocartella `debug`, &ie; tutti i file oggetto, i file ausiliari e gli eseguibili saranno inseriti in questa sottocartella al contrario delle loro controparti nella cartella root del progetto. Lo script `configure` avrà le opzioni `--enable-debug=full` e `CXXFLAGS="-O0 -g3"`: quest'ultima indica a &gcc; di non ottimizzare il codice e di inserire le informazioni di debug nei file binari.

optimized

  Questa configurazione viene usata per l'applicazione C++ definitiva. La compilazione avviene in una sottocartella dedicata e separata delle cartelle che contengono i sorgenti, chiamata `optimized`. In questa configurazione non vengono definite delle opzioni per lo script `configure`, ma solo le seguenti per il compilatore &gcc;: `CXXFLAGS="-O2 -g0"`. In questo modo il compilatore ottimizzerà il codice e non inserirà le informazioni di debug nei binari.

default

  Il termine default indica l'impostazione standard quando si compila una applicazione dalla console utilizzando &eg; gli strumenti a linea di comando &GNU; configure, make e gmake. A differenza delle configurazioni debug e optimized, non viene usata una cartella dedicata e l'applicazione verrà compilata nella stessa cartella dei sorgenti. Non sono previste opzioni particolari e la compilazione utilizzerà le impostazioni predefinite degli strumenti (ad es. &gcc;, ecc).

  Si consiglia di valutare attentamente l'uso dell'impostazione di compilazione default!

  Essa non può essere utilizzata in parallelo alle configurazioni debug e optimized: qualunque operazione di compilazione effettuata con la configurazione default renderà le altre configurazioni non utilizzabili. Questo è causato da alcune caratteristiche dei processi di compilazione degli strumenti automake/autoconf, che non possono essere facilmente evitate.

Perché utilizzare diverse configurazioni di compilazione, che non sono neppure compatibili tra loro? Esse semplificano i cicli di codifica-compilazione-debug. Le informazioni extra di debug inserite nei file binari, come le piccole modifiche effettuate al codice durante le ottimizzazioni, hanno effetto sul comportamento a runtime dell'applicazione. Quindi nella maggior parte dei casi, quando la struttura logica delle routine sembra essere corretta, si potrebbe voler controllare se essere si comportano correttamente anche in situazioni più pratiche.

In questi casi le configurazioni di compilazione entrano in azione: poiché i file oggetto, i file eseguibili e i comandi di compilazione sono mantenuti separati nelle rispettive sottocartelle, devono essere gestite solo le modifiche ai sorgenti quando si passa tra una configurazione e l'altra.

Quindi, invece di ripulire e ricompilare tutto da zero con opzioni diverse, è sufficiente passare dalla configurazione debug a optimize per ottenere i sorgenti compilati e pronti per verificare il comportamento dell'applicazione. Se non accade nulla di inappropriato, si può tornare alla configurazione debug e continuare immediatamente il proprio lavoro.

Nota finale — molte configurazione di compilazione sono configurabili. Si possono anche definire le proprie configurazioni, se è necessario per il proprio progetto. Verrà illustrata questa possibilità nella prossima sezione.

#### Opzioni di configurazione del progetto

Per la catena degli strumenti &GNU; autotools è vitale una configurazione appropriata dell'applicazione. Questa viene effettuata attraverso le definizioni presenti nello script `configure` e/o le opzioni dell'ambiente presenti precedentemente all'avvio di `configure`, come &eg; `CXXFLAGS`.

La maggior parte delle opzioni di configurazione di un progetto possono essere impostate dall'interno della &GUI; di &kdevelop;. Selezionando Progetto Opzioni progetto e l'icona Opzioni di configurazione presente a sinistra nella finestra di dialogo, apparirà la pagina delle opzioni che mostrerà diverse schede.

La maggior parte delle configurazioni può essere definita qui

Come si può vedere, sono presenti molte opzioni. Per ora si darà un breve sguardo ad alcune di esse all'interno del progetto di esempio. Per informazioni dettagliate consultare il capitolo Configurazione dei Progetti. Se si desidera conoscere il significato di tutte le opzioni che possono essere impostate, inserire in una console `info make` (oppure `info:make` dall'interno di &konqueror;) e consultare le sezioni Implicit Rules Implicit Variables.

Sono presenti diverse schede per le impostazioni. La scheda Generale contiene le impostazioni più comuni, mentre le altre sono dedicate alle impostazioni più specifiche. Comunque, in ogni caso, i contenuti di queste schede dipenderanno dalla data configurazione di compilazione.

La compilazione selezionata è quella la cui configurazione è stata definita nella casella Configurazione in alto nella finestra di dialogo Opzioni di configurazione.

Selezione della configurazione di compilazione da definire.

Ora, selezionando un'altra configurazione di compilazione della casella, si può notare che &eg; le caselle di testo Argomenti per configure e Compila Directory sono state modificate in base alle impostazioni citate nell'elenco delle configurazioni di compilazione precedentemente.

##### Configurazione generale

Nella scheda Generale della finestra di dialogo, possono essere impostate le seguenti opzioni:

- ###### Argomenti per configure

  Queste sono le opzioni che &kdevelop; assegnerà alla chiamata dello script `configure` durante la compilazione. Vedere l' esempio nella sezione Configurazione iniziale.

- ###### Compila directory

  Questa è la sottocartella della cartella radice del progetto, dove &kdevelop; inserirà tutti i file che verranno creati durante la compilazione. Idealmente il nome della cartella dovrebbe corrispondere al nome della configurazione di compilazione utilizzata, ma si può scegliere qualunque nome diverso dalle cartelle dedicate alle altre configurazioni.

- ###### Directory sorgente superiore

  Questa opzione non servirà spesso. È impostata sulla cartella radice del progetto, e deve essere modificata solo se i sorgenti sono posizionati da un'altra parte.

- ###### Flag preprocessore C/C++ (CPPFLAGS)

  Qui sono presenti le istruzioni specifiche per il preprocessore. Saranno utilizzate da &kdevelop; per impostare un ambiente temporaneo prima di eseguire gli strumenti di compilazione. Vedere l'esempio nella sezione Configurazione iniziale.

- ###### Flag linker (LDFLAGS)

  Queste sono configurazioni extra per il linker ld che indicano la posizione di eventuali librerie aggiuntive. Vengono usate anche per costruire l'ambiente di compilazione temporaneo.

- ###### Variabili d'ambiente

  Qui possono essere definite diverse variabili per l'ambiente di compilazione temporaneo. &kdevelop; imposterà queste variabili prima di eseguire lo strumento di compilazione. Anche in questo caso, le variabili devono essere definite per ogni configurazione di compilazione usata.

##### Impostazioni specifiche del compilatore

Le altre schede della pagina Opzioni di configurazione sono dedicate alle impostazioni specifiche per il compilatore. Queste opzioni sono strutturate in modo simile, quindi è sufficiente dare un'occhiata alla pagina C++.

Selezionare qui il compilatore e il suo ambiente di lavoro che dovrà essere usato da &kdevelop;.

Queste sono le impostazioni che si possono modificare:

- ###### Compilatore C++

  Da questa casella a discesa si può selezionare il compilatore C++ usato da &kdevelop;. Essa elenca tuttavia solo i compilatori noti a &kdevelop;.

- ###### Comando compilatore (CXX)

  Opzione consigliata per utenti esperti: è necessaria solo se il compilatore C++ usato non è standard. Contiene il nome con cui viene chiamato.

- ###### Flag compilatore (CXXFLAGS)

  Qui si possono inserire ulteriori opzioni che verranno passate da &kdevelop; (attraverso il `Makefile`) al compilatore. Alcuni valori saranno preimpostati in base alla configurazione di compilazione selezionata nella casella Configurazione.

  Notare che si possono selezionare molte opzioni comuni del compilatore dalla finestra di dialogo che apparirà premendo il pulsante ... alla destra della casella di testo.

  Usare questa finestra di dialogo per definire il comportamento del compilatore C++ &GNU;

  Qui è stata scelta intenzionalmente la scheda Ottimizzazione Notare che è stata impostata l'opzione Nessuna ottimizzazione (relativa alla opzione `-O0` preimpostata nella configurazione di compilazione `debug`).

  Sfortunatamente da questa finestra di dialogo non possono essere selezionate tutte le opzioni. &eg; l'opzione `-g3` usata dalla configurazione `debug` deve, se necessario, essere modificata manualmente.

#### Come viene compilato il programma da parte di Make

Si può anche configurare il modo con cui &kdevelop; chiamerà lo strumento make nella compilazione del progetto. Selezionare Progetto Opzioni progetto e in seguito l'icona Opzioni di make a sinistra. Apparirà la pagina Opzioni di make.

Definizioni di come &kdevelop; chiamerà lo strumento make

Per il momento non c'è molto da fare: nella maggior parte dei casi l'unica impostazione interessante sarà Interrompi al primo errore, che sarà disattivata in molti progetti. Corrisponde all'opzione `-k` nella chiamata a gmake vista precedentemente nella compilazione iniziale del progetto di esempio.

Questa opzione ha senso in un &IDE; come &kdevelop;, che visualizza ogni messaggio di errore generato durante la compilazione. Dopo la compilazione infatti possono essere facilmente consultati nella vista strumenti Messaggi, attraverso il menu Visualizza Errore successivo e Visualizza Errore precedente oppure con la i tasti F4 e Shift F4. &kdevelop; attiverà automaticamente la finestra dell'editor relativa al file sorgente in questione e posizionerà il cursore nella linea dove è presente l'errore.

Se invece si vuole che la compilazione venga interrotta quando viene rilevato un errore, allora marcare la casella Interrompi al primo errore nella finestra di dialogo. In questo caso &kdevelop; eseguirà gmake senza l'opzione `-k`.

#### Come avviare l'eseguibile

Una volta completata la compilazione, è possibile eseguire facilmente l'applicazione all'interno di &kdevelop;. Si può usare il menu Compila Esegui programma, i tasti Shift F9 o il pulsante Esegue programma nella Barra strumenti compilazione si &kdevelop;.

Si può eseguire il programma da qui.

Dove si trova l'eseguibile che deve essere avviato? Come si possono impostare le opzioni di chiamata? Come si può avviare l'esecuzione in un terminale separato per verificare il comportamento da console?

Tutti questi interrogativi possono essere risolti configurando alcune opzioni di esecuzione di &kdevelop;. Selezionare Progetto Opzioni progetto e in seguito l'icona Opzioni di esecuzione. Verrà visualizzata la pagina Opzioni di esecuzione a destra.

Definizioni di dove e come eseguire il programma

Sono presenti molte opzioni da impostare, raccolte principalmente in quattro gruppi.

- ##### Cartella

  Queste opzioni indicano dove si trova l'eseguibile da chiamare. Esistono tre possibilità da scegliere.

  Tuttavia è necessario osservare che si possono definire solo cartelle radice. &kdevelop; cercherà l'eseguibile in alcune sottocartelle definite nel prossimo gruppo di opzioni.

  - Esegui dalla cartella dov'è l'eseguibile. Questa è l'opzione predefinita e per il momento può essere lasciata selezionata.

  - Esegui dalla cartella BUILD in base alla configurazione di compilazione attualmente selezionata. Il nome di questa cartella è stato impostato nella pagina Configurazione Generale.

    Questa è la cartella radice dove verrà cercato l'eseguibile e verrà automaticamente modificata a seconda della sezione che si effettua nel menu Progetto Configurazione compilazione.

    Invece che eseguire sempre l'eseguibile compilato più recentemente, come nell'impostazione sopra, questo permette di cambiare il programma da avviare semplicemente selezionando un'altra configurazione di compilazione dal menu Progetto.

  - Cartella personalizzata. Anche in questo caso questa opzione specifica solo la cartella radice dalla quale deve essere cercato l'eseguibile.

    Utilizzare questa opzione se &eg; si vuole avviare il programma effettivamente installato invece della versione che si trova nelle cartelle del progetto.

- ##### Programma

  Questa opzione indica la posizione relativa e il nome del programma da chiamare. Questo è relativo alla cartella radice definita nel gruppo di opzioni precedente. Si possono anche indicare gli argomenti da passare al programma.

  Se si lascia la casella di testo Programma principale vuota, verrà usata l'impostazione Target attivo del gestore automake. Quando si lascia la casella vuota, anche se è una opzione per utenti esperti, essa può rappresentare una fonte di problemi; nel caso non venga avviato l'eseguibile desiderato, controllare questa impostazione.

- ##### Variabili d'ambiente

  Verrà impostato un ambiente shell dedicato per avviare il programma. In questo gruppo di configurazione si possono definire delle variabili d'ambiente.

- ##### Varie

  In fondo alla pagina sono presenti due caselle.

  - Compila automaticamente prima di eseguire è pratica opzione in molti casi. &kdevelop; controllerà i cambiamenti del progetto ed effettuerà le fasi di configurazione e di compilazione ogni volta che viene indicato di eseguire il programma.

    Non marcare la casella nel caso si vuole avviare la versione del programma precedente alle ultime modifiche.

  - Avvia in un terminale esterno è una opzione interessante se si vuole testare il comportamento di input/output dei programmi che non usano una &GUI; in una console. L'imposizione predefinita di questa casella è di avviare il programma di una finestra di &kdevelop;, senza le funzionalità I/O di una console.

## Come estendere un progetto — il gestore automake

(... da scrivere ...)

### Un breve sguardo al meccanismo Automake

(... da scrivere ...)

### Come posizionare le icone in una cartella separata

(... da scrivere ...)

### Come aggiungere nuove classi

(... da scrivere ...)

Prestare attenzione quando si seleziona il nome di una classe: è molto difficile modificarlo in seguito.

### Cosa è presente in un sottoprogetto?

(... da scrivere ...)

#### Concentrare il lavoro — il target attivo

(... da scrivere ...)

### Alcune operazioni per ristrutturare un progetto

(... da scrivere ...)

## Come effettuare il debug

(... da scrivere ...)

## Nota sulla documentazione del progetto

Il progetto &kde; utilizza docbook per generare il manuale del progetto (&ie; il manuale utente). Il manuale è disponibile attraverso la barra dei menu dell'applicazione selezionando la voce Aiuto Manuale di NomeApplicazione, quando l'applicazione viene eseguita. Quando il progetto è stato costruito, il manuale utente è visualizzato nel &khelpcenter; di &kde;. Esso dovrebbe illustrare all'utente il funzionamento dell'applicazione, quali sono le caratteristiche principali e come configurarla. Dovrebbero essere descritte anche eventuali funzionalità avanzate.

Tutti i template basati su &kde; possiedono una sottocartella doc che contiene il modello `index.docbook` nella cartella en per poter iniziare a scrivere il manuale utente. Si dovrebbe modificare questo file in &kdevelop; e iniziare ad inserire i dettagli personali come il nome, l'indirizzo di posta elettronica, &etc;. Osservare i commenti presenti cercando di seguire queste indicazioni per iniziare a scrivere la documentazione. Per vedere le modifiche in &khelpcenter; si deve ricostruire il progetto.

Si deve installare il progetto con Compila Installa o Installa (come amministratore) per vedere il manuale utente nel &khelpcenter;.

Si possono trovare ulteriori informazioni sulla sintassi docbook nel sito della documentazione di &kde;.

## Per ultimo ma non ultimo, le scorciatoie da tastiera

(... da scrivere ...)

## Dove proseguire

(... da scrivere ...)

### Problemi incontrati frequentemente

- Capitolo nutshell
- Domande frequenti
- Forum
- Mailing list

### Lavorare con i progetti

(... da scrivere ...)

#### Usare progetti di &kdevelop; esistenti

(... da scrivere ...)

#### Importare progetti esterni

(... da scrivere ...)