path: root/tde-i18n-it/docs/kdevelop/kdevelop/getting-started.docbook

<!--
Please keep the formatting simple.
Do not indent XML constructs.
Keep lines at 80 characters length maximum.
-->

<chapter id="getting-started">

<chapterinfo>
<authorgroup>
<author
><firstname
>Bernd</firstname
><surname
>Pol</surname
></author>
<othercredit role="translator"
><firstname
>Alessio</firstname
> <surname
>Rolleri</surname
> <affiliation
><address
><email
>aroller@libero.it</email
></address
> </affiliation
><contrib
>Traduzione del documento</contrib
></othercredit
> 
</authorgroup>
</chapterinfo>

<title
>Iniziare ad usare &kdevelop;</title>

<para
>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.</para>

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

<simplelist>
<member
><link linkend="gettingstarted-overview"
>Un primo sguardo &mdash; gli elementi dell'interfaccia utente dell'IDE &kdevelop;.</link
></member>
<member
><link linkend="gettingstarted-configure"
>Alcune configurazioni iniziali</link
></member>
<member
><link linkend="gettingstarted-new"
>Come creare un nuovo progetto</link>
</member>
<member
><link linkend="gettingstarted-edit"
>Alcuni consigli sui documenti</link
></member>
<member
><link linkend="gettingstarted-compile"
>Come compilare l'applicazione del progetto.</link
></member>
<member
><link linkend="gettingstarted-extend"
>Come aggiungere le classi e altri dettagli al proprio progetto.</link
></member>
<member
><link linkend="gettingstarted-debug"
>Come effettuare il debug dell'applicazione.</link
></member>
<member
><link linkend="gettingstarted-doc"
>Alcuni strumenti di base per costruire il programma o la documentazione utente.</link
></member>
<member
><link linkend="gettingstarted-keys"
>Per ultimo, ma non ultimo, le scorciatoie da tastiera</link
></member>
</simplelist>

<para
>Prima di iniziare deve essere chiarito un concetto importante.</para>

<formalpara>
<title
>Cosa attendersi?</title>
<para
>Come detto precedentemente, &kdevelop; è un <emphasis
>Ambiente di sviluppo integrato</emphasis
>, 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.</para>
</formalpara>

<para
>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.</para>

<para
>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 <link linkend="unixdev"
>Sviluppo su &UNIX;</link
> che contiene una panoramica storica e in particolare il capitolo <link linkend="unixdev-ide"
>Integrare concetti e strumenti</link
>.</para>

<note>
<para
>In seguito si tratterà il caso generale in cui &kdevelop; viene avviato nella <guilabel
>Modalità IDEAl semplificata</guilabel
>. 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 <menuchoice
><guimenu
>Impostazioni</guimenu
><guimenuitem
>Configura KDevelop...</guimenuitem
><guimenuitem
>Interfaccia Utente</guimenuitem
></menuchoice
>.</para>
</note>

<sect1 id="gettingstarted-overview">
<title
>Un primo sguardo a &kdevelop;</title>

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

<simplelist>
<member
><link linkend="gettingstarted-overview-basic"
>Come si presenta l'IDE &kdevelop;.</link
></member>
<member
><link linkend="gettingstarted-overview-help"
>Come ricevere aiuto</link
></member>
<member
><link linkend="gettingstarted-overview-menu"
>Cosa è presente nei menu?</link
></member>
<member
><link linkend="gettingstarted-overview-tools"
>A cosa servono le viste strumenti?</link
></member>
</simplelist>

<sect2 id="gettingstarted-overview-basic">
<title
>In superficie</title>

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

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="empty-ide.png" format="PNG"/>
</imageobject>
<caption>
<para
>Aspetto iniziale di &kdevelop;</para>
<para
>(In realtà la finestra iniziale di &kdevelop; sarà più grande, ma gli elementi presenti sono gli stessi).</para>
</caption>
</mediaobject>
</screenshot>

<formalpara>
<title
>Area di lavoro e linguette degli strumenti</title>
<para
>Inizialmente &kdevelop; userà la cosiddetta <link linkend="uimodes-survey"
>interfaccia utente IDEAl</link
>, 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 <emphasis
>vista strumenti</emphasis
> che permette di svolgere un particolare compito.</para>
</formalpara>

<formalpara>
<title
>Menu e barre degli strumenti</title>
<para
>In alto è presente la normale barra dei menu e diverse barre degli strumenti, alcune inizialmente vuote. Verranno riempite quando si aprirà un progetto.</para>
</formalpara>

<formalpara>
<title
>Barra di stato</title>
<para
>Infine è presente nella parte bassa della finestra una barra di stato che fornisce brevi informazioni su vari compiti.</para>
</formalpara>
</sect2>

<sect2 id="gettingstarted-overview-help">
<title
>Come ricevere aiuto</title>

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

<formalpara>
<title
>Cosa fa questa voce di menu?</title>
<para
>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.</para>
</formalpara>

<formalpara>
<title
>Qual è il nome di questo elemento?</title>
<para
>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.</para>
</formalpara>

<formalpara>
<title
>Cosa fa questo elemento?</title>
<para
>Per molti elementi dell'&IDE; sono disponibili ulteriori informazioni attraverso gli aiuti estesi. Selezionare <menuchoice
><guimenu
>Aiuto</guimenu
><guimenuitem
>Che cos'è?</guimenuitem
></menuchoice
> o premere <keycombo
><keycap
>&Shift;</keycap
><keycap
>F1</keycap
></keycombo
> 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.</para>
</formalpara>
</sect2>

<sect2 id="gettingstarted-overview-menu">
<title
>Cosa è presente nei menu?</title>

<para
>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.</para>

<note>
<para
>Questa è solo una breve panoramica. Vedere il capitolo relativo alla <link linkend="commands"
>Descrizione dei comandi</link
> per un elenco dettagliato.</para>
</note>

<variablelist>
<varlistentry>
<term
><guimenu
>File</guimenu
></term>
<listitem>
<formalpara>
<title
>Azioni comuni</title>
<para
>Queste azioni sono molto standard. Permettono di creare, aprire, salvare, stampare, chiudere i file e uscire dall'applicazione &kdevelop;.</para>
</formalpara>

<formalpara>
<title
>Annulla tutto</title>
<para
>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.</para>
</formalpara>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Modifica</guimenu
></term>
<listitem>
<para
>Questo menu è utile solo se è presente un documento aperto.</para>

<formalpara>
<title
>Azioni comuni</title>
<para
>Fornisce le normali azioni annulla/rifai e taglia/copia/incolla, oltre a permettere di selezionare blocchi di testo in vari modi.</para>
</formalpara>

<formalpara>
<title
>Trova e Sostituisci</title>
<para
>Sono presenti due potenti strumenti per le ricerche: <menuchoice
><guimenu
>Modifica</guimenu
><guimenuitem
>Trova nei file...</guimenuitem
></menuchoice
> e <menuchoice
><guimenu
>Modifica</guimenu
><guimenuitem
>Trova, seleziona e sostituisci...</guimenuitem
></menuchoice
>. In aggiunta alle normali azioni di ricerca e sostituzione limitate al documento aperto permettono di effettuare ricerche e sostituzioni globali in un solo colpo.</para>
</formalpara>

<formalpara>
<title
>Modifica avanzata del testo</title>
<para
>In futuro sarà possibile riformattare il documento e completare automaticamente le parti di testo incomplete in vari modi.</para>
</formalpara>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Visualizza</guimenu
></term>
<listitem>
<para
>Come il menu <guimenu
>Modifica</guimenu
>, questo menu è utile solo quando è presente un documento aperto: saranno disponibili (assieme ad altre) le seguenti azioni:</para>

<formalpara>
<title
>Cronologia</title>
<para
>Permette di muoversi avanti e indietro attraverso i vari documenti visitati</para>
</formalpara>

<formalpara>
<title
>Traccia degli errori</title>
<para
>Naviga tra le linee di codice che contengono errori rilevati durante l'ultimo processo di compilazione.</para>
</formalpara>

<formalpara>
<title
>Azioni relative all'editor</title>
<para
>Alcune voci del menu <guimenu
>Visualizza</guimenu
> controllano l'aspetto dell'editor in uso. Nel caso del componente &kate; (editor avanzato incorporato) saranno disponibili i seguenti comandi:</para>
</formalpara>

<itemizedlist>
<listitem>
<para
>Controllo del ritorno a capo automatico nella finestra del documento.</para>
</listitem>
<listitem>
<para
>Mostrare o nascondere diversi bordi della finestra del documento: numeri di linea, icone e contrassegni.</para>
</listitem>
<listitem>
<para
>Controllo della visualizzazione delle sezioni annidate (temporaneamente nascoste) nel codice sorgente.</para>
</listitem>
</itemizedlist>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Progetto</guimenu
></term>
<listitem>
<para
>Tutto il lavoro in &kdevelop; si basa sui <emphasis
>progetti</emphasis
>, 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:</para>

<formalpara>
<title
>Apri Progetto</title>
<para
>Permette di creare nuovi progetti, aprirne di nuovi e importare progetti di altri ambienti.</para>
</formalpara>

<formalpara>
<title
>Opzioni progetto</title>
<para
>Permette di definire un insieme di varie proprietà del progetto</para>
</formalpara>

<formalpara>
<title
>Gestione delle classi</title>
<para
>Aggiunge nuove classi al progetto e permette di attraversare l'albero di ereditarietà di una classe.</para>
</formalpara>

<formalpara>
<title
>Distribuzione del progetto</title>
<para
>Aiuta a costruire pacchetti di distribuzione del progetto.</para>
</formalpara>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Compila</guimenu
></term>
<listitem>
<para
>Questo menu è dedicato alla compilazione e alla documentazione del progetto. Si può quindi usare quando è presente un progetto aperto. Fornisce le seguenti azioni:</para>

<formalpara>
<title
>Compilare, effettuare il link, eseguire</title>
<para
>Permette di compilare ed effettuare il link dell'intero progetto o parti di esso ed eseguire l'applicazione dall'interno dell'&IDE;.</para>
</formalpara>

<formalpara>
<title
>Preparazione alla compilazione</title>
<para
>Queste operazioni dipendono dal sistema make usato per il progetto. Nel caso di progetti automake, esse permettono di eseguire <filename
>Makefile.cvs</filename
> e <filename
>configure</filename
>. </para>
</formalpara>

<formalpara>
<title
>Installare l'applicazione</title>
<para
>Permette di installare l'applicazione sia nelle directory locali che nelle directory di sistema accessibili solo all'utente root.</para>
</formalpara>

<formalpara>
<title
>Documentazione API</title>
<para
>Costruisce o rimuove la documentazione API del progetto basata su doxygen in base alle opzioni del progetto</para>
</formalpara>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Debug</guimenu
></term>
<listitem>
<para
>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 <menuchoice
><guimenu
>Progetto</guimenu
> <guimenuitem
>Opzioni progetto...</guimenuitem
></menuchoice
>. Sono presenti le seguenti azioni:</para>

<formalpara>
<title
>Azioni normali del debugger</title>
<para
>La prima parte del menu <guimenu
>Debug</guimenu
> 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.</para>
</formalpara>

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

<formalpara>
<title
>Debug avanzato</title>
<para
>Le altre voci del menu <guimenu
>Debug</guimenu
> compiono analisi più sofisticate. Usare <keycombo
><keycap
>&Shift;</keycap
><keycap
>F1</keycap
></keycombo
> per ottenere ulteriori informazioni sul loro funzionamento.</para>
</formalpara>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Script</guimenu
></term>
<listitem>
<para
>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. </para>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Finestra</guimenu
></term>
<listitem>
<para
>È 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.</para>

<para
>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.</para>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Strumenti</guimenu
></term>
<listitem>
<para
>&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 <guimenu
>Strumenti</guimenu
> controlla tutte queste impostazioni.</para>

<formalpara>
<title
>Editing avanzato</title>
<para
>La parte alta del menu <guimenu
>Strumenti</guimenu
> viene fornita del plugin dell'editor in uso. Si può selezionare l'editor preferito in <menuchoice
><guimenu
>Impostazioni</guimenu
> <guimenuitem
>Configura KDevelop</guimenuitem
> <guilabel
>Editor</guilabel
></menuchoice
>. Quando è stato selezionato un documento, questa porzione del menu visualizzerà i comandi di editing specifici del componente editor usato.</para>
</formalpara>

<formalpara>
<title
>Gestione pagine web</title>
<para
>Se la finestra del documento attivo contiene una pagina HTML (&eg; visualizzata selezionando la <guilabel
>Documentazione</guilabel
>), il menu <guimenu
>Strumenti</guimenu
> visualizzerà ulteriori voci per la gestione delle pagine Web.</para>
</formalpara>

<formalpara>
<title
>Altri strumenti</title>
<para
>Normalmente saranno presenti molte altre voci a seconda degli strumenti disponibili. Usare <keycombo
><keycap
>&Shift;</keycap
><keycap
>F1</keycap
></keycombo
> per ottenere ulteriori informazioni.</para>
</formalpara>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Impostazioni</guimenu
></term>
<listitem>
<para
>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;.</para>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Aiuto</guimenu
></term>
<listitem>
<para
>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.</para>
</listitem>
</varlistentry>
</variablelist>
</sect2>

<sect2 id="gettingstarted-overview-tools">
<title
>A cosa servono le viste strumenti?</title>

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

<itemizedlist>
<listitem>
<formalpara>
<title
>Parte sinistra</title>
<para
>Fornisce accesso agli strumenti di navigazione e selezione</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Basso</title>
<para
>Queste viste mostrano i messaggi generati dai vari strumenti.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Parte destra</title>
<para
>Fornisce accesso alla documentazione e agli strumenti di gestione dei sorgenti.</para>
</formalpara>
</listitem>
</itemizedlist>

<para
>Quando un progetto è stato aperto, aumenterà il numero delle schede disponibili per lavorare. L'effettivo insieme delle viste strumenti dipende dai <link linkend="plugin-tools"
>Moduli</link
> disponibili al momento in &kdevelop;. Ulteriori informazioni sono presenti nel capitolo <link linkend="setup"
>Configurare KDevelop</link
>.</para>

<para
>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.</para>

<variablelist>
<varlistentry>
<term
>Navigazione e selezione</term>
<listitem>
<formalpara>
<title
>Selettore file</title>
<para
>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.</para>
</formalpara>

<formalpara>
<title
>Lista file</title>
<para
>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 <emphasis
>sessioni</emphasis
>. 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.</para>
</formalpara>
</listitem>
</varlistentry>

<varlistentry>
<term
>Visualizzatori di messaggi</term>
<listitem>
<formalpara>
<title
>Applicazione</title>
<para
>Visualizza l'output di una applicazione che è stata avviata all'interno di &kdevelop;.</para>
</formalpara>

<formalpara>
<title
>Diff</title>
<para
>Usato per visualizzare i contenuti delle patch. Mostra l'output dello strumento di visualizzazione delle differenze che può essere avviato menu <menuchoice
><guimenu
>Strumenti</guimenu
><guimenuitem
>Visualizzatore differenze...</guimenuitem
></menuchoice
>.</para>
</formalpara>

<formalpara>
<title
>Messaggi</title>
<para
>Visualizza i messaggi generati dagli strumenti di compilazione eseguiti da &kdevelop; attraverso il menu <guimenu
>Compila</guimenu
>.</para>
</formalpara>

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

<formalpara>
<title
>Sostituisci</title>
<para
>Elenca i risultati della ricerca e sostituzione globale avviata dal menu <menuchoice
><guimenu
>Modifica</guimenu
><guimenuitem
>Trova, seleziona e sostituisci...</guimenuitem
></menuchoice
>. In questa vista si può decidere se sostituire effettivamente ogni elemento che è stato trovato.</para>
</formalpara>
<note>
<para
>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 <menuchoice
><guimenu
>Modifica</guimenu
><guimenuitem
>Trova, seleziona e sostituisci...</guimenuitem
></menuchoice
> sarà disabilitato.</para>
</note>

<formalpara>
<title
>Konsole</title>
<para
>Apre <application
>Konsole</application
> di &kde;, un emulatore di terminale dove si possono inserire comandi da tastiera attraverso una tradizionale interfaccia a linea di comando &UNIX;.</para>
</formalpara>
</listitem>
</varlistentry>

<varlistentry>
<term
>Gestione documentazione e sorgenti</term>
<listitem>
<formalpara>
<title
>Documentazione</title>
<para
>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;.</para>
</formalpara>

<para
>Per ulteriori dettagli, consultare i capitoli <link linkend="documentation"
>Documentazione</link
> e <link linkend="setup-docu"
>Configurazione della documentazione</link
>.</para>

<formalpara>
<title
>Frammenti di codice</title>
<para
>Questo strumento consente di memorizzare permanentemente frammenti di testo da utilizzare in seguito durante l'editing. &Egrave; molto flessibile, infatti il testo memorizzato può contenere un insieme di variabili che vengono sostituite dal relativo testo quando si inserisce il frammento.</para>
</formalpara>
<para
>Ulteriori informazioni sono disponibili nei capitoli <link linkend="editing-snippets"
>Frammenti di codice</link
> e <link linkend="setup-snippets"
>Impostazione dello strumento frammenti di codice</link
>.</para>
</listitem>
</varlistentry>
</variablelist>
</sect2>
</sect1>

<sect1 id="gettingstarted-configure">
<title
>Un po' di configurazione</title>

<para
>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.</para>

<note>
<para
>Se si vuole conoscere la configurazione di &kdevelop; in dettaglio, consultare il capitolo <link linkend="setup"
>Configurazione di KDevelop</link
>.</para>
</note>

<sect2 id="gettingstarted-configure-general">
<title
>Alcune impostazioni generali</title>

<para
>Per configurare &kdevelop; fare clic nel menu <menuchoice
><guimenu
>Impostazioni</guimenu
></menuchoice
> e selezionare <menuchoice
><guimenuitem
>Configura KDevelop...</guimenuitem
></menuchoice
>. Verrà aperta la finestra di dialogo <guilabel
>Configura KDevelop</guilabel
> che contiene a destra la pagina seguente <guilabel
>Generale</guilabel
>.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="configure-general.png" format="PNG"/>
</imageobject>
<caption>
<para
>Finestra di dialogo generale</para>
</caption>
</mediaobject>
</screenshot>

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

<formalpara>
<title
>Directory progetti predefinita</title>
<para
>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 <guilabel
>Apri finestra file</guilabel
> etichettato con l'icona della cartella.</para>
</formalpara>

<para
>In questi esempi si utilizzerà un utente chiamato <filename class="directory"
>devel</filename
>. Quindi si deve sempre sostituire <quote
>devel</quote
> con il proprio nome utente. L'utente devel utilizzerà la cartella <filename class="directory"
>/home/devel/projects</filename
> per lo sviluppo del software. Nuovamente, si deve sostituire <filename class="directory"
>projects</filename
> con il nome della propria cartella scelta. </para>

<para
>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 <quote
>Hello</quote
> verrebbero inseriti nella cartella <filename class="directory"
>/home/devel/projects/hello</filename
>.</para>

<para
>Ovviamente si possono scavalcare queste impostazioni in caso di necessità. Per maggiori informazioni vedere il capitolo <link linkend="applicationwizard"
>Procedura guidata per le applicazioni</link
>.</para>

<formalpara>
<title
>Output del compilatore</title>
<para
>Quando &kdevelop; effettua la compilazione dei sorgenti, verranno visualizzati i messaggi degli strumenti di compilazione come <application
>make</application
> nella vista <guilabel
>Messaggi</guilabel
> 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.</para>
</formalpara>

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

<caution>
<para
>&Egrave; necessario prestare attenzione sul fatto che nella finestra <guilabel
>Messaggi</guilabel
> saranno visualizzate <emphasis
>solo le informazioni di base</emphasis
>. 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 <guilabel
>Messaggi</guilabel
> e selezionare &eg; <quote
>Output completo del compilatore</quote
> dal menu contestuale.</para>
</caution>
</sect2>

<sect2 id="gettingstarted-configure-search">
<title
>Inizializzazione degli indici di ricerca della documentazione</title>

<para
>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.</para>

<para
>Aprire la vista strumenti <guilabel
>Documentazione</guilabel
> nella parte destra della finestra principale e selezionare <guilabel
>Cerca</guilabel
>.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="documents-search.png" format="PNG"/>
</imageobject>
<caption
><para
>Dove generare gli indici di ricerca</para
></caption>
</mediaobject>
</screenshot>

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

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

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="configure-docu-indexgen.png" format="PNG"/>
</imageobject>
<caption
><para
>&kdevelop; sta generando gli indici di ricerca della documentazione.</para
></caption>
</mediaobject>
</screenshot>

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

<note>
<itemizedlist>
<listitem>
<para
>In alcuni casi l'applicazione <application
>htdig</application
> utilizzata da &kdevelop; per le ricerche potrebbe non essere configurata correttamente. Per ulteriori informazioni, fare riferimento al capitolo <link linkend="setup-docu-textsearch"
>Impostazione degli indici di ricerca</link
>.</para>
</listitem>
<listitem>
<para
>Per poter consultare la documentazione API specifica di &kde; e &Qt;, è necessario che siano presenti le <emphasis
>KDELibs Apidocs</emphasis
> durante l'installazione di &kdevelop;. Se si riscontrano problemi durante la generazione degli indici o la ricerca degli identificatori, come negli <link linkend="gettingstarted-edit-defs"
>esempi seguenti</link
>, assicurarsi che questa documentazione esista e che sia accessibile. Vedere <link linkend="kdevelop-install"
>Installare KDevelop</link
> per ulteriori dettagli.</para>
</listitem>
</itemizedlist>
</note>
</sect2>
</sect1>


<sect1 id="gettingstarted-new">
<title
>Iniziare un nuovo progetto</title>

<para
>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 <emphasis
>progetti</emphasis
>. Quindi, in generale, la prima cosa da fare per iniziare a sviluppare è creare un nuovo progetto.</para>

<para
>Fortunatamente, &kdevelop; fornisce uno strumento chiamato Procedura guidata per le applicazioni, che permette di creare un nuovo progetto in modo semplice. (Vedere il capitolo <link linkend="applicationwizard"
>Primi passi &mdash;la procedura guidata per le applicazioni</link
> per ulteriori informazioni).</para>

<para
>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:</para>

<simplelist>
<member
><link linkend="gettingstarted-new-setup"
>Come iniziare un nuovo progetto con l'aiuto della procedura guidata per le applicazioni</link
></member>
<member
><link linkend="gettingstarted-new-files"
>Quali file vengono inizialmente impostati dalla procedura guidata</link
></member>
<member
><link linkend="gettingstarted-new-toolviews"
>Viste strumenti aggiuntive visualizzate con il progetto</link
></member>
</simplelist>

<sect2 id="gettingstarted-new-setup">
<title
>Come creare un nuovo progetto</title>

<para
>Ora si creerà un semplice progetto &kde; <quote
>Hello World</quote
>, seguendo i seguenti passi.</para>

<procedure>
<step>
<para
>Per avviare la procedura guidata per le applicazioni, fare clic sul menu <menuchoice
><guimenu
>Progetto</guimenu
><guimenuitem
>Nuovo Progetto...</guimenuitem
></menuchoice
>.</para>
</step>

<step>
<para
>Verrà visualizzata la finestra di dialogo <guilabel
>Crea nuovo progetto</guilabel
>. In alto a sinistra, in <guilabel
>Tutti i progetti</guilabel
> saranno elencati diversi linguaggi di programmazione.</para>

<substeps>
<step>
<para
>Si vuole costruire una applicazione per &kde; in C++, quindi fare clic sul <guilabel
>+</guilabel
> a fianco dell'etichetta <guilabel
>C++</guilabel
> per espandere quella sezione.</para>
</step>

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

<step>
<para
>Saranno elencati una serie di <emphasis
>modelli di progetto</emphasis
>. Fare clic su <guilabel
>Una semplice applicazioni KDE</guilabel
>.</para>

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

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="tutorial-new-project.png" format="PNG"/>
</imageobject>
<caption>
<para
>Selezionare un modello di progetto <quote
>Hello World</quote
></para>
</caption>
</mediaobject
></screenshot>
</step>

<step>
<para
>L'applicazione necessita di un nome. Inserire nell'area <guilabel
>Proprietà</guilabel
> in basso un nome adatto nel campo <guilabel
>Nome applicazione</guilabel
>.</para>

<para
>In questo esempio si è usato il nome <quote
>Hello</quote
>, 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.</para>
</step>

<step>
<para
>Assicurarsi che la casella <guilabel
>Posizione</guilabel
> visualizzi il nome della cartella padre dedicata ai progetti impostata nel capitolo precedente <link linkend="gettingstarted-configure"
>Un po' di configurazione</link
>. 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.</para>

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

<step>
<para
>Fare clic sul pulsante <guibutton
>Avanti</guibutton
> in basso nella finestra per procedere.</para>
</step>
</substeps>
</step>

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

<screenshot id="gettingstarted-new-setup-options">
<mediaobject>
<imageobject>
<imagedata fileref="tutorial-hello-options.png" format="PNG"/>
</imageobject>
<caption>
<para
>Fornire il nome e l'indirizzo email (opzionale)</para>
</caption>
</mediaobject>
</screenshot>

<note>
<para
>Si deve inserire almeno il nome dell'<guilabel
>Autore</guilabel
>: esso è obbligatorio per l'impostazione dei file dell'applicazione.</para>
</note>

<para
>Quando tutto è corretto, verrà abilitato il pulsante <guibutton
>Avanti</guibutton
>. Fare clic per procedere.</para>
</step>

<step>
<para
>Per il momento possono essere saltate le pagine <guilabel
>Sistema di controllo versione (VCS)</guilabel
>, <guilabel
>Template per i file .h</guilabel
> e <guilabel
>Template per i file .cpp</guilabel
>. Saltarle facendo clic sul pulsante <guibutton
>Avanti</guibutton
> ed infine sul pulsante <guibutton
>Fine</guibutton
>.</para>
</step>
</procedure>

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

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

<sect2 id="gettingstarted-new-files">
<title
>File iniziali del progetto</title>

<para
>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 <guilabel
>Albero file</guilabel
> in basso a sinistra. In questo modo verrà visualizzato un elenco di file simile al seguente.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="tutorial-hello-new.png" format="PNG"/>
</imageobject>
<caption>
<para
>File iniziale del progetto <quote
>Hello World</quote
></para>
</caption>
</mediaobject>
</screenshot>

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

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

<sect3 id="gettingstarted-new-files-copyright">
<title
>Problemi di copyright</title>

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

<formalpara>
<title
>Copyright nei singoli file sorgente</title>
<para
>Ci si rammenta della pagina <link linkend="gettingstarted-new-setup-options"
><guilabel
>Opzioni del progetto</guilabel
></link
> 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 <guilabel
>hello.cpp</guilabel
> 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.</para>
</formalpara>

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

<para
>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 <filename class="directory"
>templates</filename
>.</para>

<formalpara>
<title
>Copyright dell'applicazione</title>
<para
>Una volta avviata l'applicazione &kde;, l'utente può visualizzare i dati relativi al menu <guilabel
>Aiuto</guilabel
> alla voce <guimenu
>Informazioni su</guimenu
>. Dando un'occhiata al file <filename
>main.cpp</filename
> si può trovare una linea simile alla seguente, anch'essa inserita dalla procedura guidata.</para>
</formalpara>

<programlisting
>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" );
</programlisting>

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

<important>
<para
>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.</para>
</important>
</sect3>

<sect3 id="gettingstarted-new-files-source">
<title
>File sorgenti iniziali</title>

<para
>La procedura guidata inserirà i file sorgente nella sottocartella <filename class="directory"
>src</filename
> del progetto, dove saranno presenti i file <filename
>main.cpp</filename
>, <filename
>hello.h</filename
> e <filename
>hello.cpp</filename
>.</para>

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

<itemizedlist>
<listitem>
<para
><filename
>hello.desktop</filename
> contiene alcuni metadati usati da &kdevelop; per la manutenzione e l'avvio dell'applicazione.</para>
</listitem>

<listitem>
<para
><filename
>hi16-app-hello.png</filename
> e <filename
>hi32-app-hello.png</filename
> contengono alcune icone predefinite, utilizzate nella visualizzazione dell'applicazione.</para>
</listitem>

<listitem>
<para
>Infine, il file <filename
>helloui.rc</filename
> contiene una descrizione dell'interfaccia utente, di fatto i menu forniti dall'applicazione.</para>
</listitem>
</itemizedlist>
</sect3>

<sect3 id="gettingstarted-new-files-doc">
<title
>Documentazione iniziale dell'applicazione</title>

<para
>Nella sottocartella <filename class="directory"
>doc/en</filename
> si può trovare il file <filename
>index.docbook</filename
>. Si tratta di un modello predefinito che si può utilizzare per iniziare a scrivere la documentazione utente.</para>
</sect3>

<sect3 id="gettingstarted-new-files-project">
<title
>File del progetto e ausiliari</title>

<para
>Nella vista strumenti <guilabel
>Albero file</guilabel
>, 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 <emphasis
>file di progetto</emphasis
>.</para>

<para
>Anche nella finestra <guilabel
>Gestore automake</guilabel
> 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.</para>

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

<itemizedlist>
<listitem>
<formalpara>
<title
>Controllo di compilazione del progetto</title>
<para
>Questi file controllano i processi di compilazione, l'installazione, la costruzione della compilazione, &etc;. Se il progetto usa gli strumenti <application
>autotools</application
> di &GNU;, si troverà un file chiamato <application
>Makefile.am</application
> 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 <filename
>configure</filename
> durante le fasi della compilazione. Tale processo genera un file <filename
>Makefile</filename
> in ogni cartella. A loro volta, da questi ultimi, l'utility <application
>make</application
> effettuerà la compilazione dell'applicazione.</para>
</formalpara>

<para
>I file <filename
>Makefile.am</filename
> 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 <filename
>Makefile.am</filename
>.</para>

<para
>Gli altri file di controllo attualmente elencati sono <filename
>configure.in.in</filename
> e <filename
>subdirs</filename
> nella cartella root del progetto. Essi saranno elaborati da alcuni file nella cartella di amministrazione di &kde; <filename class="directory"
>admin</filename
> per produrre altri tipi di file <filename
>configure</filename
> e <filename
>Makefile</filename
> ed infine i binari dell'applicazione.</para>
</listitem>

<listitem>
<formalpara>
<title
>File di controllo di &kdevelop;</title>
<para
>&kdevelop; necessita di alcuni file di controllo e dati di amministrazione, che si trovano nella cartella root del progetto. In questo esempio essi sono <filename
>hello.kdevelop</filename
>, <filename
>hello.kdevelop.pcs</filename
> e <filename
>hello.kdevses</filename
>.</para>
</formalpara>

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

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

<listitem>
<formalpara>
<title
>File di descrizione GNU del progetto</title>
<para
>Alcuni file della cartella root del progetto sono obbligatori per ogni applicazione conforme agli standard &GNU;. Essi sono: <filename
>AUTHORS</filename
>, <filename
>ChangeLog</filename
>, <filename
>INSTALL</filename
>, <filename
>COPYING</filename
> (che contiene la GNU GENERAL PUBLIC LICENSE), <filename
>INSTALL</filename
>, <filename
>NEWS</filename
>, <filename
>README</filename
> e <filename
>TODO</filename
>.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Altri file</title>
<para
>Altri file, non ancora menzionati, sono:</para>
</formalpara>

<itemizedlist>
<listitem>
<para
><filename
>Doxyfile</filename
> controlla la creazione della documentazione sulle &API; interne dell'interfaccia di programmazione specifiche del progetto.</para>
</listitem>

<listitem>
<para
>La cartella <filename class="directory"
>templates</filename
> 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.</para>

<para
>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 <filename
>cpp</filename
> e <filename
>h</filename
>, in modo da migliorarne l'aspetto.</para>
</listitem>

<listitem>
<para
>La  cartella <filename class="directory"
>po</filename
> sarà usata per la localizzazione. &Egrave; una parte essenziale dei file di progetto (contiene infatti un file <filename
>Makefile.am</filename
>), ma verrà utilizzata per le traduzioni. Non è di grande interesse per gli sviluppatori software.</para>
</listitem>

<listitem>
<para
>Infine la cartella<filename class="directory"
>admin</filename
> è 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;</para>
</listitem>
</itemizedlist>

</listitem>
</itemizedlist>
</sect3>
</sect2>

<sect2 id="gettingstarted-new-toolviews">
<title
>Ulteriori viste strumenti</title>

<para
>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à.</para>

<note>
<para
>Le viste strumenti effettivamente disponibili dipendono dai moduli caricati in &kdevelop;. Per controllare quali moduli sono presenti vedere il capitolo <link linkend="setup-plugins"
>Moduli</link
> per ottenere informazioni.</para>
</note>

<sect3 id="gettingstarted-new-toolviews-left">
<title
>Strumenti di navigazione e selezioni (parte sinistra)</title>

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

<listitem>
<formalpara>
<title
>Classi</title>
<para
>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.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Gruppi di file</title>
<para
>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.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Variabili</title>
<para
>Questa vista è usata dallo strumento di debug per visualizzare, valutare e controllare le variabili durante le sessioni di debug.</para>
</formalpara>
</listitem>
</itemizedlist>
</sect3>

<sect3 id="gettingstarted-new-toolviews-bottom">
<title
>Messaggi (in basso)</title>

<itemizedlist>
<listitem>
<formalpara>
<title
>Valgrind</title>
<para
><application
>Valgrind</application
> è 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).</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Problemi di sicurezza</title>
<para
>Il modulo di &kdevelop; <guilabel
>Controllo di sicurezza</guilabel
> 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.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Breakpoint</title>
<para
>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.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>CTags</title>
<para
>Permette di creare un database di identificatori utilizzando la applicazione <application
>CTags</application
>. 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.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Problemi</title>
<para
>&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.</para>
</formalpara>
</listitem>
</itemizedlist>
</sect3>
  
<sect3 id="gettingstarted-new-toolviews-right">
<title
>Gestione sorgenti (parte destra)</title>
      
<itemizedlist>
<listitem>
<formalpara>
<title
>Gestore automake</title>
<para
>Il gestore automake è principalmente un front end grafico per la gestione dei contenuti dei file <filename
>Makefile.am</filename
> 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 <emphasis
>file del progetto</emphasis
>. Ogni sottocartella di questo tipo deve contenere un file <filename
>Makefile.am</filename
> e in questo contesto viene chiamata <filename
>sottoprogetto</filename
>.</para>
</formalpara>

<para
>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.</para>

<para
>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 <link linkend="gettingstarted-extend-automake"
>più avanti</link
>, mentre per una descrizione più completa si può consultare il capitolo <link linkend="project-management"
>Compilazione e gestione del progetto</link
>.</para>
</listitem>
</itemizedlist>
</sect3>
</sect2>
</sect1>


<sect1 id="gettingstarted-edit">
<title
>Alcuni consigli sui documenti</title>

<para
>In questo progetto di esempio, la procedura guidata aprirà il file <filename
>hello.cpp</filename
> 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:</para>

<simplelist>
<member
><link linkend="gettingstarted-edit-headers"
>Come passare velocemente tra il file header e il file di implementazione</link
></member>
<member
><link linkend="gettingstarted-edit-defs"
>Come accedere velocemente alle dichiarazioni e alle definizioni</link
></member>
<member
><link linkend="gettingstarted-edit-arrange"
>Come adattare le finestre dell'editor alle proprie necessità</link
></member>
<member
><link linkend="gettingstarted-edit-problems"
>Come tenere sott'occhio i problemi comuni</link
></member>
</simplelist>

<sect2 id="gettingstarted-edit-headers">
<title
>Passare dal file header al file di implementazione</title>

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

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="editor-switch-header.png" format="PNG"/>
</imageobject>
<caption
><para
>Come passare da un file di implementazione a un file header</para
></caption>
</mediaobject>
</screenshot>

<para
>Trovare la voce <guimenuitem
>Commuta tra intestazione e implementazione</guimenuitem
> 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 <filename
>hello.cpp</filename
> verrà visualizzato il file <filename
>hello.h</filename
>.</para>

<para
>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.</para>

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

<sect2 id="gettingstarted-edit-defs">
<title
>Come accedere alle dichiarazioni e alle definizioni</title>

<para
>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.</para>

<para
>Tuttavia esistono due situazioni da considerare, ovvero:</para>
<simplelist>
<member
><link linkend="gettingstarted-edit-defs-external"
>Accedere agli identificatori definiti esternamente</link
>, e</member>
<member
><link linkend="gettingstarted-edit-defs-project"
>gestire gli identificatori interni</link
></member>
</simplelist>

<sect3 id="gettingstarted-edit-defs-external">
<title
>Dichiarazioni e definizioni esterne</title>

<para
>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.</para>

<para
>Ad esempio, nella finestra dell'editor del file <filename
>hello.cpp</filename
> si trovano le seguenti linee.</para>

<programlisting
>Hello::Hello()
    : KMainWindow( 0, "Hello" )
{
</programlisting>

<para
>Facendo clic con il tasto destro su <classname
>KMainWindow</classname
> verrà visualizzato un menu. Selezionando la voce <guimenuitem
>Ricerca nella documentazione: KMainWindow</guimenuitem
> si aprirà la vista strumenti <guilabel
>Documentazione</guilabel
>, dove sarà stata inserita la voce <classname
>KMainWindow</classname
> nella sottopagina <guilabel
>Cerca</guilabel
>. 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 <classname
>KMainWindow</classname
>.</para>

<para
>Questa sarà visualizzato come segue (&Egrave; stata deliberatamente aperta la pagina <guilabel
>Documentazione</guilabel
>, <guilabel
>Cerca</guilabel
> per illustrare il risultato della selezione).</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="editor-search-doc.png" format="PNG"/>
</imageobject>
<caption
><para
>Come cercare un identificatore documentato esternamente</para
></caption>
</mediaobject>
</screenshot>

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

<note>
<para
>Nel caso il procedimento non funzionasse, allora potrebbe non essere stato ancora creato un indice della documentazione. Per crearlo, seguire le istruzioni <link linkend="gettingstarted-configure-search"
>fornite precedentemente</link
> e riprovare.</para>
</note>
</sect3>

<sect3 id="gettingstarted-edit-defs-project">
<title
>Dichiarazioni e definizioni interne al progetto</title>

<para
>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 <application
>CTags</application
> per effettuare ricerche all'interno dei sorgenti del proprio progetto.</para>

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

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

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="editor-ctags-regenerate.png" format="PNG"/>
</imageobject>
<caption
><para
>Costruzione dell'indice CTags con il pulsante <guibutton
>Rigenerare</guibutton
></para
></caption>
</mediaobject>
</screenshot>

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

<tip>
<para
>La data presente a fianco del pulsante <guilabel
>Rigenerare</guilabel
> 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.</para>
</tip>

<para
>La ricerca di un identificatore può essere svolta tramite diversi mezzi.</para>

<itemizedlist>
<listitem>
<formalpara>
<title
>Utilizzo della vista strumenti CTags</title>
<para
>&Egrave; un metodo semplice. Inserire il nome dell'identificatore nel campo di input <guilabel
>Ricerca</guilabel
> 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.</para>
</formalpara>

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

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="editor-ctags-lookup.png" format="PNG"/>
</imageobject>
<caption
><para
>Come cercare un identificare nella vista strumenti <guilabel
>CTags</guilabel
></para
></caption>
</mediaobject>
</screenshot>

<para
>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.</para>
</listitem>

<listitem>
<formalpara>
<title
>Utilizzo di un menu contestuale in un file sorgente</title>
<para
>&Egrave; un metodo pratico quando si sta lavorando su un certo file sorgente. Supponendo di lavorare sul file <filename
>main.cpp</filename
>. Incontrando la linea seguente</para>
</formalpara>
<programlisting
>Hello *mainWin = 0;
</programlisting>
<para
>si vuole sapere dove è stato utilizzato l'identificatore <quote
>Hello</quote
> nella applicazione. Per trovarlo, fare clic con il tasto destro sull'identificatore e sarà visualizzato un menu, che mostrerà le seguenti linee</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="editor-ctags-menu.png" format="PNG"/>
</imageobject>
<caption
><para
>Ottenere informazioni di <application
>CTags</application
> su un identificatore interno del progetto</para
></caption>
</mediaobject>
</screenshot>

<para
>Facendo clic sulla voce di interesse, ad esempio <guilabel
>Ctags - Vai alla definizione: Hello</guilabel
>, verrà aperta immediatamente la finestra dell'editor relativa al file <filename
>hello.cpp</filename
> e verrà posizionato il cursore proprio sulla definizione della classe:</para>
<programlisting
>Hello::Hello()
    : KMainWindow( 0, "Hello" )
{
</programlisting>
</listitem>

<listitem>
<formalpara>
<title
>Effettuare una ricerca globale</title>
<para
>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:</para>
</formalpara>
<itemizedlist>
<listitem>
<para
>Si può avviare una ricerca globale attraverso il menu <menuchoice
><guimenu
>Modifica</guimenu
> <guimenuitem
>Trova nei file...</guimenuitem
></menuchoice
>, oppure</para>
</listitem>
<listitem>
<para
>si può usare direttamente il menu contestuale attraverso un clic destro nella finestra dell'editor.</para>
</listitem>
</itemizedlist>

<para
>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 <filename
>hello.cpp</filename
> e il cursore sia posizionato sul primo identificare Hello. Ora si vuole sapere dove la parola <quote
>Hello</quote
> è stata utilizzata nei sorgenti del progetto e quante volte essa compare. Questo è un tipico esempio di uso delle funzioni di ricerca globale di &kdevelop;.</para>

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

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="editor-find-menu.png" format="PNG"/>
</imageobject>
<caption
><para
>Avviare una ricerca globale all'interno di una finestra dell'editor</para
></caption>
</mediaobject>
</screenshot>

<para
>Verrà visualizzata la seguente finestra <guilabel
>Trova nei file</guilabel
> (esattamente la stessa che compare selezionando il menu <menuchoice
><guimenu
>Modifica</guimenu
> <guimenuitem
>Trova nei file...</guimenuitem
></menuchoice
>).</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="find-in-files.png" format="PNG"/>
</imageobject>
<caption
><para
>Un front end grafico e versatile per effettuare ricerche globali all'interno del progetto</para
></caption>
</mediaobject>
</screenshot>

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

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

<para
>Esistono due linee di particolare interesse nella finestra della vista strumenti.</para>
<itemizedlist>
<listitem>
<para
>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.</para>
</listitem>

<listitem>
<para
>In basso verrà visualizzato il numero di voci trovate durante la ricerca. In questo esempio si dovrebbe leggere <quote
>*** 11 corrispondenze trovate ***</quote
>.</para>
</listitem>
</itemizedlist>

<para
>&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 <guilabel
>Trova nei file</guilabel
>.</para>
</listitem>
</itemizedlist>
</sect3>
</sect2>

<sect2 id="gettingstarted-edit-arrange">
<title
>Adattare le finestre dell'editor</title>

<para
>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. </para>
<simplelist>
<member
><link linkend="gettingstarted-edit-arrange-clean"
>Come rimuovere schede non necessarie</link
></member>
<member
><link linkend="gettingstarted-edit-arrange-tabs"
>Come riorganizzare le schede</link
></member>
<member
><link linkend="gettingstarted-edit-arrange-split"
>Come visualizzare diversi file nell'area di lavoro contemporaneamente</link
></member>
<member
><link
linkend="gettingstarted-edit-arrange-sourceheader"
>Come modificare contemporaneamente i file header e sorgente C++</link
></member>
<member
><link linkend="gettingstarted-edit-arrange-group"
>Come raggruppare i file sorgente in sessioni di sviluppo</link
></member>
</simplelist>

<sect3 id="gettingstarted-edit-arrange-clean">
<title
>Ripulire la barra delle schede</title>

<para
>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.</para>

<formalpara>
<title
>Chiusura di varie schede alla volta</title>
<para
>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 <guimenu
>Finestra</guimenu
> oppure fare clic con il tasto destro su una scheda per</para>
</formalpara>
<itemizedlist>
<listitem>
<para
>chiudere la finestra dell'editor attualmente selezionata,</para>
</listitem>
<listitem>
<para
>chiudere tutte le altre finestre dell'editor aperte, oppure</para>
</listitem>
<listitem>
<para
>chiudere tutte le finestre in un solo colpo (disponibile solo nel menu <guimenu
>Finestra</guimenu
>).</para>
</listitem>
</itemizedlist>

<formalpara>
<title
>Chiusura delle schede selezionate</title>
<para
>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.</para>
</formalpara>

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

<procedure>
<step>
<para
>Aprire <guilabel
>Lista file</guilabel
> e, tenendo premuto il tasto <keycap
>Ctrl</keycap
> fare clic nella lista sui file che si vuole chiudere.</para>
</step>
<step>
<para
>Mantenendo il puntatore dei mouse sul nome di un file della lista, fare clic con il tasto destro del mouse.</para>
</step>
<step>
<para
>Dal menu contestuale <guimenu
>Lista file</guimenu
> selezionare <guimenuitem
>Chiudi selezionato</guimenuitem
>.</para>
</step>
</procedure>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="file-list-close-selected.png" format="PNG"/>
</imageobject>
<caption
><para
>Come chiudere le finestre selezionate in una sola operazione.</para
></caption>
</mediaobject>
</screenshot>
<para
>&kdevelop; chiuderà tutte le finestre dell'editor desiderate e si può procedere con una barra di schede nuovamente pulita.</para>
</sect3>

<sect3 id="gettingstarted-edit-arrange-tabs">
<title
>Come riorganizzare le schede</title>

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

<formalpara>
<title
>Impostazione di base &mdash; dove posizionare le nuove schede</title>

<para
>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.</para>
</formalpara>
<para
>Per attivare questo comportamento è necessario modificare le impostazioni dell'interfaccia utente di &kdevelop;</para>
<procedure>
<step>
<para
>Selezionare <menuchoice
><guimenu
>Impostazioni</guimenu
> <guimenuitem
>Configura KDevelop...</guimenuitem
></menuchoice
></para>
</step>
<step>
<para
>Nella parte destra della finestra di dialogo fare clic sull'icona <guilabel
>Interfaccia utente</guilabel
>. Verrà visualizzata la pagina <guilabel
>Interfaccia Utente</guilabel
>.</para>
</step>
<step>
<para
>Nell'angolo in basso si trova la sezione intitolata <guilabel
>Navigazione con schede</guilabel
>. Rimuovere la marcatura della casella <guilabel
>Apri nuova scheda dopo la corrente</guilabel
>.</para>
</step>
<step>
<para
>Chiudere &kdevelop; e riavviarlo. Ora le schede delle nuove finestre aperte saranno posizionate all'estremità destra nella barra delle schede.</para>
</step>
</procedure>

<para
>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;.</para>

<formalpara>
<title
>Come riorganizzare le schede</title>
<para
>Data la varietà dei compiti svolti durante lo sviluppo, prima o poi sorge la necessità di riorganizzare le schede delle finestre.</para>
</formalpara>
<para
>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.</para>
</sect3>

<sect3 id="gettingstarted-edit-arrange-split">
<title
>Visualizzare diversi file contemporaneamente</title>

<para
>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.</para>

<para
>Sono presenti due comandi raggiungibili attraverso il menu <guimenu
>Finestra</guimenu
> 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.</para>

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

<para
>Fare clic con il tasto destro sulla linguetta del file <filename
>hello.h</filename
>. Verrà aperto il seguente menu.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="split-workspace.png" format="PNG"/>
</imageobject>
<caption
><para
>Come suddividere l'area di lavoro attuale in due parti.</para
></caption>
</mediaobject>
</screenshot>

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

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="split-windows.png"/>
</imageobject>
<caption
><para
>L'area di lavoro è stata divisa orizzontalmente</para
></caption>
</mediaobject>
</screenshot>

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

<para
>Ci sono alcune considerazioni</para>
<itemizedlist>
<listitem>
<para
>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.</para>
</listitem>

<listitem>
<para
>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.</para>
</listitem>

<listitem>
<para
>Inoltre, non esiste un metodo diretto per chiudere esplicitamente una sottoarea. Essa verrà chiusa automaticamente alla chiusura dell'ultima scheda contenuta in essa.</para>
</listitem>
</itemizedlist>
</sect3>

<sect3 id="gettingstarted-edit-arrange-sourceheader">
<title
>Modificare contemporaneamente i file sorgenti e header C++</title>

<para
>La capacità di suddividere l'area di lavoro in &kdevelop; ha una simpatica applicazione: permette di aprire automaticamente una sorgente <filename
>.cpp</filename
> e il corrispondente file header <filename
>.h</filename
>. 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.</para>

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

<para
>Selezionare <menuchoice
><guibutton
>Progetto</guibutton
> <guimenuitem
>Opzioni progetto</guimenuitem
></menuchoice
>. Verrà visualizzata la finestra di dialogo <guilabel
>Opzioni Progetto</guilabel
>, dove deve essere selezionata l'icona <guiicon
>Gestione C++</guiicon
> e in seguito la scheda <guilabel
>Funzioni navigazione</guilabel
> nella pagina visualizzata a destra.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="split-source-header.png" format="PNG"/>
</imageobject>
<caption
><para
>Avere i file header e sorgente affiancati</para
></caption>
</mediaobject>
</screenshot>

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

<para
>Ora chiudere nel progetto di esempio Hello sia il file <filename
>hello.cpp</filename
> che <filename
>hello.h</filename
>, poi selezionare nuovamente <filename
>hello.cpp</filename
> dalla sottocartella <filename class="directory"
>src</filename
> del progetto. Si aprirà normalmente una finestra dell'editor; tuttavia, aprendo il file <filename
>hello.h</filename
> 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 <filename
>hello.cpp</filename
>.</para>

<para
>Inoltre, cercando nella finestra del file <filename
>hello.cpp</filename
> la linea di definizione del costruttore:</para>
<programlisting
>Hello::Hello()
</programlisting>
<para
>e posizionando il cursore su questa linea, si può notare che nella finestra inferiore, relativa al file <filename
>hello.h</filename
>, il cursore si sarà posizionato nella linea corrispondente di dichiarazione del costruttore.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="split-source-header-navigate.png" format="PNG"/>
</imageobject>
<caption
><para
>&kdevelop; ha navigato automaticamente alla dichiarazione del costruttore</para
></caption>
</mediaobject>
</screenshot>

<para
>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.</para>
</sect3>

<sect3 id="gettingstarted-edit-arrange-group">
<title
>Raggruppamento dei file sorgente in sessioni di sviluppo</title>

<para
>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 <guilabel
>Lista file</guilabel
> ha questa funzionalità.</para>

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

<para
>Nel progetto di esempio, si desidera di voler sempre aprire i file <filename
>hello.cpp</filename
>, <filename
>hello.h</filename
> e <filename
>main.cpp</filename
> 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, <filename
>sources</filename
>.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="file-list-session-create.png" format="PNG"/>
</imageobject>
<caption
><para
>Utilizzo delle sessioni di sviluppo per memorizzare i gruppi di file</para
></caption>
</mediaobject>
</screenshot>

<para
>Questo può essere svolto attraverso le seguenti fasi:</para>
<procedure>
<step>
<para
>Creazione di una nuova sessione</para>
<substeps>
<step>
<para
>Fare clic sull'icona <guiicon
>New Session</guiicon
> in alto a sinistra nella vista strumenti <guilabel
>Elenco file</guilabel
>.</para>
</step>
<step>
<para
>Verrà visualizzata una finestra di dialogo. Nel campo <guilabel
>Inserisci il nome della sessione</guilabel
> fornire il nome alla nuova sessione, &eg; <quote
>sources</quote
>.</para>
</step>
<step>
<para
>Chiudere la finestra di dialogo facendo clic su <guibutton
>OK</guibutton
>. La nuova sessione verrà elencata nella casella a discesa sulla barra degli strumenti.</para>
</step>
</substeps>
</step>
<step>
<para
>La nuova sessione sarà inizialmente vuota, e dovrà essere popolata con i file che dovrà contenere.</para>
<substeps>
<step>
<para
>Aprire tutti i file che si vuole raggruppare nella sessione. In questo esempio è stato deciso di inserire i file <filename
>hello.cpp</filename
>, <filename
>hello.h</filename
> e <filename
>main.cpp</filename
>.</para>
</step>
<step>
<para
>Una volta che è stata completato l'elenco, fare clic sull'icona <guiicon
>Salva Sessione</guiicon
>. Non si deve saltare questo passo, altrimenti saranno persi i file elencati.</para>
</step>
</substeps>
</step>
</procedure>

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

<para
>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 <guiicon
>Salva sessione</guiicon
>. Se ci si vuole sbarazzare di una sessione, selezionarla nella casella a discesa e fare clic sull'icona <guiicon
>Elimina sessione</guiicon
> sulla barra degli strumenti.</para>

<para
>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 <menuchoice
><guimenu
>Progetto</guimenu
> <guimenuitem
>Opzioni progetto</guimenuitem
> <guimenuitem
>Lista file</guimenuitem
></menuchoice
>.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="file-list-session-default.png" format="PNG"/>
</imageobject>
<caption
><para
>Aprire una sessione specifica quando il progetto è stato caricato.</para
></caption>
</mediaobject>
</screenshot>
</sect3>
</sect2>

<sect2 id="gettingstarted-edit-problems">
<title
>Tenere d'occhio i problemi comuni</title>

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

<para
>Verrà illustrata questa funzionalità nel progetto Hello di esempio.</para>

<itemizedlist>
<listitem>
<para
>Aprire il file sorgente <filename
>main.cpp</filename
>.</para>
</listitem>

<listitem>
<para
>Assicurarsi che contenga la seguente linea</para>
<programlisting
>/// @todo do something with the command line args here
</programlisting>
<para
>Essa è stata inserita dalla procedura guidata quando è stato creato il progetto Hello nel capitolo <link linkend="gettingstarted-new"
>Iniziare un nuovo progetto</link
> precedente.</para>
</listitem>

<listitem>
<para
>Ora aprire la vista strumenti <guilabel
>Problemi</guilabel
> in basso. Se tutto va bene, apparirà questo avviso:</para>
<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="problem-report-todo.png"/>
</imageobject>
<caption
><para
>&kdevelop; avverte che una linea di codice sorgente contiene un contrassegno.</para
></caption>
</mediaobject>
</screenshot>
</listitem>
</itemizedlist>

<para
>Il formato del comando <computeroutput
>/// @todo</computeroutput
> deriva dal documentatore di codice <application
>Doxygen</application
>, il quale verrà descritto velocemente nella sezione <link linkend="gettingstarted-doc"
>Documentazione</link
>. Non è obbligatorio usare questo formato, e saranno riconosciuti anche i marcatori <computeroutput
>TODO</computeroutput
> e <computeroutput
>FIXME</computeroutput
>.</para>

<para
>Se si vogliono inserire &eg; i seguenti commenti contenenti i marcatori <computeroutput
>TODO</computeroutput
> e <computeroutput
>FIXME</computeroutput
> nel file di esempio <filename
>hello.cpp</filename
></para>
<programlisting
>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" );
}
</programlisting>
<para
>allora essi saranno elencati nella vista strumenti <guilabel
>Problemi</guilabel
></para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="problem-report-marks.png" format="PNG"/>
</imageobject>
<caption
><para
>Il reporter di problema elencherà le linee del file attuale che richiedono attenzione.</para
></caption>
</mediaobject>
</screenshot>

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

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="problem-report-all-todos.png" format="PNG"/>
</imageobject>
<caption
><para
>Il reporter di problema ha raccolto gli avvisi contrassegnati con <computeroutput
>TODO</computeroutput
>.</para
></caption>
</mediaobject>
</screenshot>

<para
>La scheda <guilabel
>Errori</guilabel
> 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.</para>

<para
>Il reporter di problema di &kdevelop; è un valido strumento, quindi è consigliabile di controllare regolarmente la vista strumenti <guilabel
>Problemi</guilabel
> durante il lavoro.</para>
</sect2>
</sect1>

<sect1 id="gettingstarted-compile">
<title
>Come compilare un nuovo progetto</title>

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

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="build-menu.png" format="PNG"/>
</imageobject>
<caption
><para
>La compilazione di un progetto viene effettuata in diverse fasi</para
></caption>
</mediaobject>
</screenshot>

<para
>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 <guimenuitem
>Compila progetto</guimenuitem
>. 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.</para>

<para
>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:</para>

<simplelist>
<member
><link linkend="gettingstarted-compile-basic"
>Il ciclo di sviluppo</link
></member>
<member
><link linkend="gettingstarted-compile-setup"
>I metodi principali per configurare un progetto</link
></member>
</simplelist>

<sect2 id="gettingstarted-compile-basic">
<title
>Il ciclo di sviluppo</title>

<para
>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:</para>
<simplelist>
<member
><link linkend="gettingstarted-compile-basic-init"
>Come inizializzare un progetto per la prima compilazione</link
></member>
<member
><link linkend="gettingstarted-compile-basic-config"
>Come effettuare la configurazione iniziale</link
></member>
<member
><link linkend="gettingstarted-compile-basic-build"
>Come creare il progetto</link
></member>
<member
><link linkend="gettingstarted-compile-basic-run"
>Come avviare l'applicazione da &kdevelop;</link
></member>
</simplelist>

<note>
<para
>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 <application
>QMake</application
>, basato su &Qt;, saranno presenti altre funzionalità nei menu oppure potrebbero risultare assenti. &Egrave; necessario in questi casi consultare la documentazione del fornitore relativa alla gestione del progetto e alla compilazione dell'applicazione.</para>
</note>

<sect3 id="gettingstarted-compile-basic-init">
<title
>Inizializzare il progetto per la compilazione</title>

<para
>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 <menuchoice
><guimenu
>Compila</guimenu
> <guimenuitem
>Compila progetto</guimenuitem
></menuchoice
> o premendo il tasto <keycap
>F8</keycap
>, si otterrà il seguente messaggio di avvertimento:</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="raw-project-warning.png" format="PNG"/>
</imageobject>
<caption
><para
>Tentativo di compilare un progetto basato su Automake non inizializzato </para
></caption>
</mediaobject>
</screenshot>

<para
>Premendo il pulsante <guibutton
>Eseguili</guibutton
>, &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 <guibutton
>Non eseguire</guibutton
>. </para>

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

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="build-menu-automake.png" format="PNG"/>
</imageobject>
<caption
><para
>Avviare una inizializzazione</para
></caption>
</mediaobject>
</screenshot>

<para
>&kdevelop; aprirà la vista strumenti <guilabel
>Messaggi</guilabel
> in basso ed elencherà una serie di messaggi prodotti dagli strumenti. Se tutto è andato bene, la linea finale sarà <quote
><computeroutput
>*** successo ***</computeroutput
></quote
>.</para>

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

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

<para
>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 <application
>autoconf</application
> e <application
>automake</application
> utilizzare. Infine ha comandato lo strumento make (in questo caso &GNU; <application
>gmake</application
>) di elaborare il makefile <filename
>Makefile.cvs</filename
>.</para>

<para
>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 <filename
>configure</filename
>, necessari per effettuare la fase successiva.</para>
</sect3>

<sect3 id="gettingstarted-compile-basic-config">
<title
>Configurazione iniziale</title>

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

<para
>La sequenza di configurazione sarà disponibile solo dopo una corretta inizializzazione di automake, poiché solo dopo questa saranno disponibili i file <filename
>configure</filename
>. Fatto questo, selezionare la voce del menu <menuchoice
><guimenu
>Compila</guimenu
> <guimenuitem
>Esegui configure</guimenuitem
></menuchoice
> per iniziare la sequenza di configurazione.</para>

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

<para id="gettingstarted-compile-basic-config-cmd"
>La prima linea nella vista strumenti <guilabel
>Messaggi</guilabel
> conterrà anche in questo caso il comando usato da &kdevelop; per avviare la configurazione:</para>

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

<para
>Da questi messaggi si possono ricavare dettagli interessanti.</para>

<informaltable frame="none">
<tgroup cols="2"
><tbody
><row>
<entry>
<mediaobject>
<imageobject>
<imagedata fileref="tutorial-debug-tree.png"/>
</imageobject>
</mediaobject>
</entry>
<entry>
<itemizedlist>
<listitem>
<para
>Per prima cosa, &kdevelop; ha utilizzato una sottocartella dedicata per il processo di compilazione. Questa cartella, <filename class="directory"
>debug</filename
> (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 <filename
>configure</filename
> e un <filename
>Makefile</filename
>.</para>
</listitem>
<listitem>
<para
>Nella sezione <link linkend="gettingstarted-compile-setup"
>Configurazione del progetto</link
> 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 <filename class="directory"
>debug</filename
> prima della configurazione e che lo script <filename
>configure</filename
> ha creato la sotto struttura e i <filename
>Makefile</filename
> al suo interno.</para>
</listitem>
<listitem>
<para
>In seguito, dall'interno della cartella <filename class="directory"
>debug</filename
>, &kdevelop; ha chiamato lo script <filename
>configure</filename
> nella cartella radice del progetto utilizzando un ambiente dedicato, dove le opzioni <computeroutput
>CXXFLAGS="-O0 -g3"</computeroutput
> indicheranno in seguito che il compilatore &gcc; non deve ottimizzare i binari e che deve includere in essi tutte le informazioni di debug.</para>
</listitem>
<listitem>
<para
>Infine è stato avviato lo script <filename
>configure</filename
> con l'opzione <computeroutput
>--enable-debug=full</computeroutput
> che gli indica di creare ogni <filename
>Makefile</filename
>  in modo tale che le successivi fasi di compilazione e di linking possano avere tutte le informazioni di debug.</para>
</listitem>
</itemizedlist>
</entry>
</row
></tbody
></tgroup>
</informaltable>

<para
>Tutte queste impostazioni sono configurabili per ogni progetto. Sono disponibili ulteriori informazioni su questo argomento nel capitolo <link linkend="project-management"
>Gestione del progetto</link
>.</para>
</sect3>

<sect3 id="gettingstarted-compile-basic-build">
<title
>Compilazione del progetto</title>

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

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="build-commands.png" format="PNG"/>
</imageobject>
<caption
><para
>Comandi per costruire i file binari</para
></caption>
</mediaobject>
</screenshot>

<para
>Procedendo dal basso verso l'alto, essi sono:</para>
<itemizedlist>
<listitem>
<para
><guimenuitem
>Compila file</guimenuitem
> &mdash; questo comando compila il file sorgente attualmente aperto nella finestra dell'editor. Viene usato per controllare velocemente eventuali errori.</para>
</listitem>
<listitem>
<para
><guimenuitem
>Compila target attivo</guimenuitem
> &mdash; questo comando viene usato principalmente assieme al <link linkend="gettingstarted-extend-automake"
>Gestore automake</link
> che verrà descritto in seguito.</para>
</listitem>
<listitem>
<para
><guimenuitem
>Compila progetto</guimenuitem
> &mdash; questo è il comando che, procedendo per tutto il progetto, compilerà ed effettuerà il link di tutti file.</para>
</listitem>
</itemizedlist>

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

<para id="gettingstarted-compile-basic-build-cmd"
>Siccome nel progetto di esempio non sono presenti molti file sorgente, la vista <guilabel
>Messaggi</guilabel
> conterrà poche linee. In alto si troverà nuovamente il comando inviato da &kdevelop; alla shell sttostante.</para>

<programlisting
>cd '/home/devel/projects/hello/debug' &amp;&amp; \
WANT_AUTOCONF_2_5="1" WANT_AUTOMAKE_1_6="1" gmake -k 
</programlisting>

<para
>&kdevelop; è passato nella cartella <filename class="directory"
>Debug</filename
> per eseguire il <filename
>Makefile</filename
>. &Egrave; stato impostato, come durante la <link linkend="gettingstarted-compile-basic-init"
>fase di inizializzazione</link
>, un sotto ambiente dedicato dove è stato eseguito successivamente lo strumento <application
>gmake</application
>.</para>

<para
>Notare l'opzione <computeroutput
>-k</computeroutput
> di <application
>gmake</application
>: 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 <guilabel
>Messaggi</guilabel
>. 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.</para>

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

<sect3 id="gettingstarted-compile-basic-run">
<title
>Esecuzione dell'applicazione</title>

<para
>Per eseguire la nuova applicazione Hello non è necessario compiere altre operazioni: si può selezionare <menuchoice
><guimenu
>Compila</guimenu
> <guimenuitem
>Esegui programma</guimenuitem
></menuchoice
> o premere <keycombo
><keycap
>Shift</keycap
> <keycap
>F9</keycap
></keycombo
> o utilizzare il pulsante <guibutton
>Esegue programma</guibutton
> nella <guilabel
>Barra strumenti compilazione</guilabel
> visualizzata sotto.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="run-button.png"/>
</imageobject>
<caption
><para
>Esecuzione dell'applicazione dalla <guilabel
>Barra strumenti compilazione</guilabel
>.</para>
</caption>
</mediaobject>
</screenshot>

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

<programlisting
>./hello
</programlisting>

<para
>questo dimostra che l'&IDE; conosce dove si trova l'eseguibile che deve avviare. Anche questo può essere configurato, per ulteriori informazioni nel capitolo <link linkend="project-management"
>Gestione del progetto</link
>.</para>

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

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="hello-world-app.png" format="PNG"/>
</imageobject>
<caption>
<para
>L'applicazione <application
>Hello</application
></para>
</caption>
</mediaobject>
</screenshot>

<para
>Chiudere la finestra dell'applicazione <application
>Hello</application
> normalmente. Se non è avvenuto nessun errore, &kdevelop; riporterà il messaggio <quote
><computeroutput
>*** Uscito normalmente ***</computeroutput
></quote
> nella vista strumenti <guilabel
>Applicazione</guilabel
>.</para>
</sect3>
</sect2>

<sect2 id="gettingstarted-compile-setup">
<title
>Configurazione del progetto</title>

<para
>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. </para>

<simplelist>
<member
><link linkend="gettingstarted-compile-setup-build"
>A cosa servono le configurazioni di compilazione?</link
></member>

<member
><link linkend="gettingstarted-compile-setup-config"
>Dove si può definire il comportamento dello script <filename
>configure</filename
></link
></member>

<member
><link linkend="gettingstarted-compile-setup-make"
>Alcune considerazioni su come dovrebbe essere avviato <application
>make</application
></link
></member>

<member
><link linkend="gettingstarted-compile-setup-run"
>Dove dovrebbe essere l'eseguibile e come può essere chiamato?</link
></member>
</simplelist>

<sect3 id="gettingstarted-compile-setup-build">
<title
>Configurazioni di compilazione</title>

<para
>Nella sezione <link linkend="gettingstarted-compile-basic-config"
>Configurazione iniziale</link
> è stato avviato per la prima volta lo script <filename
>configure</filename
> e si è notato che &kdevelop; ha impostato una sottocartella dedicata di nome <filename class="directory"
>debug</filename
>. In questa sezione verranno discusse brevemente alcune conseguenze di questo comportamento.</para>

<para
>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.</para>

<para
>Per sapere quale configurazione di compilazione è disponibile attualmente, andare nel menu <menuchoice
><guimenu
>Progetto</guimenu
> <guisubmenu
>Configurazione compilazione</guisubmenu
></menuchoice
>.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="build-configurations.png" format="PNG"/>
</imageobject>
<caption
><para
>Nel progetto sono disponibili diverse configurazione di compilazione</para
></caption>
</mediaobject>
</screenshot>

<para
>In questo caso, nel progetto Hello di esempio, sono disponibili tre diverse configurazioni di compilazione. In altri casi potrebbe &mdash; inizialmente &mdash; essere presente solo una configurazione di nome <guimenuitem
>default</guimenuitem
>.</para>

<para
>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.</para>

<para
>Segue una breve descrizione delle configurazioni di compilazione.</para>

<variablelist id="gettingstarted-compile-setup-build-configs">
<varlistentry>
<term
><guimenuitem
>debug</guimenuitem
></term>
<listitem>
<para
>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 <filename class="directory"
>debug</filename
>, &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 <filename
>configure</filename
> avrà le opzioni <computeroutput
>--enable-debug=full</computeroutput
> e <computeroutput
>CXXFLAGS="-O0 -g3"</computeroutput
>: quest'ultima indica a &gcc; di non ottimizzare il codice e di inserire le informazioni di debug nei file binari.</para>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenuitem
>optimized</guimenuitem
></term>
<listitem>
<para
>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 <filename class="directory"
>optimized</filename
>. In questa configurazione non vengono definite delle opzioni per lo script <filename
>configure</filename
>, ma solo le seguenti per il compilatore &gcc;: <computeroutput
>CXXFLAGS="-O2 -g0"</computeroutput
>. In questo modo il compilatore ottimizzerà il codice e non inserirà le informazioni di debug nei binari.</para>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenuitem
>default</guimenuitem
></term>
<listitem>
<para
>Il termine <quote
>default</quote
> indica l'impostazione standard quando si compila una applicazione dalla console utilizzando &eg; gli strumenti a linea di comando &GNU; <application
>configure</application
>, <application
>make</application
> e <application
>gmake</application
>. A differenza delle configurazioni <guimenuitem
>debug</guimenuitem
> e <guimenuitem
>optimized</guimenuitem
>, 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).</para>

<warning>
<para
>Si consiglia di valutare attentamente l'uso dell'impostazione di compilazione <guimenuitem
>default</guimenuitem
>!</para>

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

<para
>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.</para>

<para
>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.</para>

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

<para
>Nota finale &mdash; 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.</para>
</sect3>

<sect3 id="gettingstarted-compile-setup-config">
<title
>Opzioni di configurazione del progetto</title>

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

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

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="configure-project-configure.png" format="PNG"/>
</imageobject>
<caption
><para
>La maggior parte delle configurazioni può essere definita qui</para
></caption>
</mediaobject>
</screenshot>

<para
>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 <link linkend="projects-configure"
>Configurazione dei Progetti</link
>. Se si desidera conoscere il significato di tutte le opzioni che possono essere impostate, inserire in una console <command
>info make</command
> (oppure <command
>info:make</command
> dall'interno di &konqueror;) e consultare le sezioni <menuchoice
><guimenu
>Implicit Rules</guimenu
> <guimenuitem
>Implicit Variables</guimenuitem
></menuchoice
>.</para>

<para
>Sono presenti diverse schede per le impostazioni. La scheda <guilabel
>Generale</guilabel
> 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.</para>

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

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="configure-project-buildconfig.png" format="PNG"/>
</imageobject>
<caption
><para
>Selezione della configurazione di compilazione da definire.</para
></caption>
</mediaobject>
</screenshot>

<para
>Ora, selezionando un'altra configurazione di compilazione della casella, si può notare che &eg; le caselle di testo <guilabel
>Argomenti per configure</guilabel
> e <guilabel
>Compila Directory</guilabel
> sono state modificate in base alle impostazioni citate nell'<link linkend="gettingstarted-compile-setup-build-configs"
>elenco delle configurazioni di compilazione</link
> precedentemente.</para>

<sect4 id="gettingstarted-compile-setup-config-general">
<title
>Configurazione generale</title>

<para
>Nella scheda <guilabel
>Generale</guilabel
> della finestra di dialogo, possono essere impostate le seguenti opzioni:</para>

<itemizedlist>
<listitem>
<formalpara>
<title
>Argomenti per configure</title>
<para
>Queste sono le opzioni che &kdevelop; assegnerà alla chiamata dello script <filename
>configure</filename
> durante la compilazione. Vedere l' <link linkend="gettingstarted-compile-basic-config-cmd"
>esempio</link
> nella sezione <quote
>Configurazione iniziale</quote
>.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Compila directory</title>
<para
>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.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Directory sorgente superiore</title>
<para
>Questa opzione non servirà spesso. &Egrave; impostata sulla cartella radice del progetto, e deve essere modificata solo se i sorgenti sono posizionati da un'altra parte.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Flag preprocessore C/C++ (CPPFLAGS)</title>
<para
>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'<link linkend="gettingstarted-compile-basic-config-cmd"
>esempio</link
> nella sezione <quote
>Configurazione iniziale</quote
>.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Flag linker (LDFLAGS)</title>
<para
>Queste sono configurazioni extra per il linker <application
>ld</application
> che indicano la posizione di eventuali librerie aggiuntive. Vengono usate anche per costruire l'ambiente di compilazione temporaneo.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Variabili d'ambiente</title>
<para
>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.</para>
</formalpara>
</listitem>
</itemizedlist>
</sect4>

<sect4 id="gettingstarted-compile-setup-config-spec">
<title
>Impostazioni specifiche del compilatore</title>

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

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="configure-project-cpp.png" format="PNG"/>
</imageobject>
<caption
><para
>Selezionare qui il compilatore e il suo ambiente di lavoro che dovrà essere usato da &kdevelop;.</para
></caption>
</mediaobject>
</screenshot>

<para
>Queste sono le impostazioni che si possono modificare:</para>

<itemizedlist>
<listitem>
<formalpara>
<title
>Compilatore C++</title>
<para
>Da questa casella a discesa si può selezionare il compilatore C++ usato da &kdevelop;. Essa elenca tuttavia solo i compilatori noti a &kdevelop;.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Comando compilatore (CXX)</title>
<para
>Opzione consigliata per utenti esperti: è necessaria solo se il compilatore C++ usato non è standard. Contiene il nome con cui viene chiamato.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Flag compilatore (CXXFLAGS)</title>
<para
>Qui si possono inserire ulteriori opzioni che verranno passate da &kdevelop; (attraverso il <filename
>Makefile</filename
>) al compilatore. Alcuni valori saranno preimpostati in base alla configurazione di compilazione selezionata nella casella <guilabel
>Configurazione</guilabel
>.</para>
</formalpara>

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

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="configure-project-cppoptions.png" format="PNG"/>
</imageobject>
<caption
><para
>Usare questa finestra di dialogo per definire il comportamento del compilatore C++ &GNU;</para
></caption>
</mediaobject>
</screenshot>

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

<para
>Sfortunatamente da questa finestra di dialogo non possono essere selezionate tutte le opzioni. &eg; l'opzione <computeroutput
>-g3</computeroutput
> usata dalla configurazione <computeroutput
>debug</computeroutput
> deve, se necessario, essere modificata manualmente.</para>
</listitem>
</itemizedlist>
</sect4>
</sect3>

<sect3 id="gettingstarted-compile-setup-make">
<title
>Come viene compilato il programma da parte di Make</title>

<para
>Si può anche configurare il modo con cui &kdevelop; chiamerà lo strumento <application
>make</application
> nella compilazione del progetto. Selezionare <menuchoice
><guimenu
>Progetto</guimenu
> <guimenuitem
>Opzioni progetto</guimenuitem
></menuchoice
> e in seguito l'icona <guiicon
>Opzioni di make</guiicon
> a sinistra. Apparirà la pagina <guilabel
>Opzioni di make</guilabel
>.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="configure-project-make.png" format="PNG"/>
</imageobject>
<caption
><para
>Definizioni di come &kdevelop; chiamerà lo strumento <application
>make</application
></para
></caption>
</mediaobject>
</screenshot>

<para
>Per il momento non c'è molto da fare: nella maggior parte dei casi l'unica impostazione interessante sarà <guilabel
>Interrompi al primo errore</guilabel
>, che sarà disattivata in molti progetti. Corrisponde all'opzione <computeroutput
>-k</computeroutput
> nella chiamata a <application
>gmake</application
> vista precedentemente nella <link linkend="gettingstarted-compile-basic-build-cmd"
>compilazione iniziale</link
> del progetto di esempio.</para>

<para
>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 <guilabel
>Messaggi</guilabel
>, attraverso il menu <menuchoice
><guimenu
>Visualizza</guimenu
> <guimenuitem
>Errore successivo</guimenuitem
></menuchoice
> e <menuchoice
><guimenu
>Visualizza</guimenu
> <guimenuitem
>Errore precedente</guimenuitem
></menuchoice
> oppure con la i tasti <keycap
>F4</keycap
> e <keycombo
><keycap
>Shift</keycap
> <keycap
>F4</keycap
></keycombo
>. &kdevelop; attiverà automaticamente la finestra dell'editor relativa al file sorgente in questione e posizionerà il cursore nella linea dove è presente l'errore.</para>

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

<sect3 id="gettingstarted-compile-setup-run">
<title
>Come avviare l'eseguibile</title>

<para
>Una volta completata la compilazione, è possibile eseguire facilmente l'applicazione all'interno di &kdevelop;. Si può usare il menu <menuchoice
><guimenu
>Compila</guimenu
> <guimenuitem
>Esegui programma</guimenuitem
></menuchoice
>, i tasti <keycombo
><keycap
>Shift</keycap
><keycap
>F9</keycap
></keycombo
> o il pulsante <guibutton
>Esegue programma</guibutton
> nella <guilabel
>Barra strumenti compilazione</guilabel
> si &kdevelop;.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="run-button.png" format="PNG"/>
</imageobject>
<caption
><para
>Si può eseguire il programma da qui.</para
></caption>
</mediaobject>
</screenshot>

<para
>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?</para>

<para
>Tutti questi interrogativi possono essere risolti configurando alcune opzioni di esecuzione di &kdevelop;. Selezionare <menuchoice
><guimenu
>Progetto</guimenu
> <guimenuitem
>Opzioni progetto</guimenuitem
></menuchoice
> e in seguito l'icona <guiicon
>Opzioni di esecuzione</guiicon
>. Verrà visualizzata la pagina <guilabel
>Opzioni di esecuzione</guilabel
> a destra.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="configure-project-run.png" format="PNG"/>
</imageobject>
<caption
><para
>Definizioni di dove e come eseguire il programma</para
></caption>
</mediaobject>
</screenshot>

<para
>Sono presenti molte opzioni da impostare, raccolte principalmente in quattro gruppi.</para>

<itemizedlist>
<listitem>
<formalpara>
<title
>Cartella</title>
<para
>Queste opzioni indicano dove si trova l'eseguibile da chiamare. Esistono tre possibilità da scegliere.</para>
</formalpara>

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

<itemizedlist>
<listitem>
<para
>Esegui dalla cartella dov'è l'eseguibile. Questa è l'opzione predefinita e per il momento può essere lasciata selezionata.</para>
</listitem>

<listitem>
<para
>Esegui dalla cartella BUILD in base alla <link linkend="gettingstarted-compile-setup-build"
>configurazione di compilazione</link
> attualmente selezionata. Il nome di questa cartella è stato impostato nella pagina <link linkend="gettingstarted-compile-setup-config-general"
>Configurazione Generale</link
>.</para>

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

<para
>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 <guimenu
>Progetto</guimenu
>.</para>
</listitem>

<listitem>
<para
>Cartella personalizzata. Anche in questo caso questa opzione specifica solo la cartella radice dalla quale deve essere cercato l'eseguibile.</para>

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

<listitem>
<formalpara>
<title
>Programma</title>
<para
>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.</para>
</formalpara>

<note>
<para
>Se si lascia la casella di testo <guilabel
>Programma principale</guilabel
> vuota, verrà usata l'impostazione <emphasis
>Target attivo</emphasis
> 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.</para>
</note>
</listitem>

<listitem>
<formalpara>
<title
>Variabili d'ambiente</title>
<para
>Verrà impostato un ambiente shell dedicato per avviare il programma. In questo gruppo di configurazione si possono definire delle variabili d'ambiente.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Varie</title>
<para
>In fondo alla pagina sono presenti due caselle.</para>
</formalpara>

<itemizedlist>
<listitem>
<para
><guilabel
>Compila automaticamente prima di eseguire</guilabel
> è 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.</para>

<para
>Non marcare la casella nel caso si vuole avviare la versione del programma precedente alle ultime modifiche.</para>
</listitem>

<listitem>
<para
><guilabel
>Avvia in un terminale esterno</guilabel
> è 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.</para>
</listitem>
</itemizedlist>
</listitem>
</itemizedlist>
</sect3>
</sect2
> 
</sect1>

<sect1 id="gettingstarted-extend">
<title
>Come estendere un progetto &mdash; il gestore automake</title>

<para
>(... da scrivere ...)</para>

<sect2 id="gettingstarted-extend-automake">
<title
>Un breve sguardo al meccanismo Automake</title>

<para
>(... da scrivere ...)</para>
</sect2
> 

<sect2 id="gettingstarted-extend-pics">
<title
>Come posizionare le icone in una cartella separata</title>

<para
>(... da scrivere ...)</para>
</sect2
> 

<sect2 id="gettingstarted-extend-class">
<title
>Come aggiungere nuove classi</title>

<para
>(... da scrivere ...)</para>

<caution
><para
>Prestare attenzione quando si seleziona il nome di una classe: è molto difficile modificarlo in seguito.</para
></caution>
</sect2
> 

<sect2 id="gettingstarted-extend-subproject">
<title
>Cosa è presente in un sottoprogetto?</title>

<para
>(... da scrivere ...)</para>

<sect3 id="gettingstarted-extend-subproject-active">
<title
>Concentrare il lavoro &mdash; il target attivo</title>

<para
>(... da scrivere ...)</para>
</sect3
> 
</sect2
> 

<sect2 id="gettingstarted-extend-restructure">
<title
>Alcune operazioni per ristrutturare un progetto</title>

<para
>(... da scrivere ...)</para>
</sect2
> 
</sect1>


<sect1 id="gettingstarted-debug">
<title
>Come effettuare il debug</title>

<para
>(... da scrivere ...)</para>
</sect1
> 


<sect1 id="gettingstarted-doc">
<title
>Nota sulla documentazione del progetto</title>

<para
>Il progetto &kde; utilizza <ulink url="http://www.docbook.org/tdg5/en/html/docbook.html"
>docbook</ulink
> per generare il manuale del progetto (&ie; il manuale utente). Il manuale è disponibile attraverso la barra dei menu dell'applicazione selezionando la voce <menuchoice
><guimenu
>Aiuto</guimenu
> <guimenuitem
>Manuale di <replaceable
>NomeApplicazione</replaceable
></guimenuitem
></menuchoice
>, 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. </para>
<para
>Tutti i template basati su &kde; possiedono una sottocartella doc che contiene il modello <filename
>index.docbook</filename
> 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.</para>
<note
><para
>Si deve installare il progetto con <menuchoice
><guimenu
>Compila</guimenu
> <guimenuitem
>Installa</guimenuitem
></menuchoice
> o <guimenuitem
>Installa (come amministratore)</guimenuitem
> per vedere il manuale utente nel &khelpcenter;.</para
></note>
<para
>Si possono trovare ulteriori informazioni sulla sintassi docbook nel sito della <ulink url="http://l10n.kde.org/docs/markup/index.html"
>documentazione di &kde;</ulink
>.</para>
</sect1>

<sect1 id="gettingstarted-keys">
<title
>Per ultimo ma non ultimo, le scorciatoie da tastiera</title>

<para
>(... da scrivere ...)</para>
</sect1>

<sect1 id="gettingstarted-whereto">
<title
>Dove proseguire</title>

<para
>(... da scrivere ...)</para>

<sect2 id="gettingstarted-whereto-faq">
<title
>Problemi incontrati frequentemente</title>

<simplelist>
<member
>Capitolo nutshell</member>
<member
>Domande frequenti</member>
<member
>Forum</member>
<member
>Mailing list</member>
</simplelist>
</sect2>

<sect2 id="gettingstarted-whereto-projects">
<title
>Lavorare con i progetti</title>

<para
>(... da scrivere ...)</para>

<sect3 id="gettingstarted-whereto-projects-open">
<title
>Usare progetti di &kdevelop; esistenti</title>

<para
>(... da scrivere ...)</para>
</sect3>

<sect3 id="gettingstarted-whereto-projects-import">
<title
>Importare progetti esterni</title>

<para
>(... da scrivere ...)</para>
</sect3>
</sect2>
</sect1>

</chapter>