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

<chapter id="applicationwizard">

<chapterinfo>
  <authorgroup>
    <author
><firstname
>Bernd</firstname
><surname
>Pol</surname
></author>
    <!-- ROLES_OF_TRANSLATORS -->
  </authorgroup>
</chapterinfo>

<title
>Primi passi &mdash; la procedura guidata per le applicazioni</title>
<!-- FIXME (bp, 2006-06-18) This is a misnomer. It should be something like -->
<!-- Working With Projects -->
<!-- featuring the application manager as part of the New Projects section. -->

<indexterm zone="applicationwizard">
  <primary
>procedura guidata per le applicazioni</primary
></indexterm>

<para
>In &tdevelop; lo sviluppo di software è organizzato in <emphasis
>progetti</emphasis
>. Un progetto include tutto il necessario per programmare: i file sorgente, i file di dati, le necessarie funzioni di gestione come il sistema make, l'accesso ai componenti e agli strumenti necessari per rendere l'applicazione funzionante. </para>
<para
>L'organizzazione del lavoro di sviluppo in progetti permette di gestire facilmente tutte le attività e risulta molto pratico se si lavora su diverse applicazioni contemporaneamente. Si indica a &tdevelop; il progetto a cui si vuole lavorare e si procede dal punto dove è stato lasciato. </para>

<sect1 id="new-projects">
<title
>Nuovi progetti</title>

<!-- TODO (bp, 2006-06-18) This whole section must be completely rewritten. -->
<!-- There is no need for a tutorial habit anymore. -->

<indexterm zone="new-projects">
  <primary
>progetto</primary>
  <secondary
>nuovo</secondary
></indexterm>

<para
>Quando si vuole iniziare un nuovo progetto di programmazione, vengono svolte parecchie procedure di setup: l'impostazione di una struttura di directory, la creazione dei file sorgente e header, l'inizializzazione del sistema make, ecc. </para>
<para
>&tdevelop; fornisce un sistema semplice per iniziare un nuovo progetto di programmazione &mdash; la <emphasis
>procedura guidata per le applicazioni</emphasis
>. La si può trovare al menu <menuchoice
><guimenu
>Progetto</guimenu
> <guimenuitem
>Nuovo Progetto</guimenuitem
></menuchoice
>. </para>
<para
>Usando la procedura guidata sono necessarie solo poche fasi per iniziare un nuovo progetto: </para>
<orderedlist>
  <listitem
><para
><link linkend="new-projects-start-type"
>Selezionare il linguaggio di programmazione</link
> che si vuole usare e il tipo di applicazione da costruire scegliendo da una serie di modelli predefiniti. </para
></listitem>
  <listitem
><para
><link linkend="new-projects-start-general"
>Fornire alcune informazioni generali</link
> come il nome dell'applicazione, la directory dove essa deve essere costruita, ecc. </para
></listitem>
  <listitem
><para
>Decidere se si vuole usare un <link linkend="new-projects-start-cvs"
>version control system</link
>, come ad esempio CVS e se necessario fornire gli eventuali dati necessari. </para
></listitem>
  <listitem
><para
>Impostare i modelli per <link linkend="new-projects-start-templates"
>i file sorgente e header</link
> (se possibile). </para
></listitem>
  <listitem
><para
>Infine la procedura guidata <link linkend="new-projects-start-build"
>preparerà tutto il necessario</link
>, come la struttura della directory, i modelli dei file sorgente/header, gli strumenti di gestione come make, &etc; </para
></listitem>
</orderedlist>
<para
>Voil&agrave; &mdash; è tutto. La procedura guidata creerà un insieme di file, con i quali si potrà facilmente iniziare a lavorare. </para>
<para
>Adesso si scenderà maggiormente nei dettagli... </para>

<sect2 id="new-projects-start">
<title
>Fasi preliminari</title>

<indexterm zone="new-projects-start">
  <primary
>finestra di dialogo</primary>
  <secondary
>Creare un nuovo progetto</secondary
></indexterm>
<indexterm zone="new-projects-start">
  <primary
>progetto</primary>
  <secondary
>Creare un nuovo progetto</secondary>
  <tertiary
>finestra di dialogo</tertiary
></indexterm>
<indexterm zone="new-projects-start">
  <primary
>progetto</primary>
  <secondary
>modelli</secondary
></indexterm>
<indexterm zone="new-projects-start">
  <primary
>modelli</primary>
  <secondary
>progetto</secondary
></indexterm>

<para
>Per creare un nuovo progetto con &tdevelop;, selezionare <guimenuitem
>Nuovo Progetto...</guimenuitem
> dal menu <guimenu
>Progetto</guimenu
>. Apparirà la finestra di dialogo <guilabel
>Crea nuovo progetto</guilabel
> mostrando la pagina <guilabel
>Generale</guilabel
>: </para>

<screenshot id="screenshot-newprojectwizard">
  <mediaobject>
    <imageobject>
      <imagedata fileref="create-new-project.png" format="PNG"/>
    </imageobject>
    <caption
><para
>Finestra di dialogo per creare un nuovo progetto </para
></caption>
  </mediaobject>
</screenshot>

<para
>Come si può vedere, la finestra di dialogo è divisa in una parte superiore e una inferiore. In quella superiore si può decidere il linguaggio di programmazione e il tipo di applicazione, mentre in quella inferiore sono presenti alcune informazioni generali. </para>

<sect3 id="new-projects-start-type">
<title
>Selezionare il linguaggio di programmazione e il tipo di applicazione</title>

<indexterm zone="new-projects-start-type">
  <primary
>progetto</primary>
  <secondary
>tipo di applicazione</secondary
></indexterm>
<indexterm zone="new-projects-start-type">
  <primary
>progetto</primary>
  <secondary
>linguaggio di programmazione</secondary
></indexterm>
<indexterm zone="new-projects-start-type">
  <primary
>progetto</primary>
  <secondary
>linguaggio</secondary
></indexterm>
<indexterm zone="new-projects-start-type">
  <primary
>linguaggio</primary
></indexterm>
<indexterm zone="new-projects-start-type">
  <primary
>linguaggio di programmazione</primary
></indexterm>
<indexterm zone="new-projects-start-type">
  <primary
>applicazione</primary>
  <secondary
>tipo</secondary
></indexterm>

<para
>La selezione viene effettuata nella parte sinistra della zona superiore, dove è presente una lista di cartelle corrispondenti a vari linguaggi di programmazione, per esempio:  </para>

<itemizedlist>
  <listitem
><para
>Ada <indexterm>
      <primary
>Ada</primary>
      <secondary
>nuovo progetto</secondary
></indexterm>
  </para
></listitem>
  <listitem
><para
>C <indexterm>
      <primary
>C</primary>
      <secondary
>nuovo progetto</secondary
></indexterm>
  </para
></listitem>
  <listitem
><para
>C++ <indexterm>
      <primary
>C++</primary>
      <secondary
>nuovo progetto</secondary
></indexterm>
  </para
></listitem>
  <listitem
><para
>Database (Progetti SQL) <indexterm>
      <primary
>SQL</primary>
      <secondary
>nuovo progetto</secondary
></indexterm>
    <indexterm>
      <primary
>Database</primary>
      <secondary
>nuovo progetto</secondary
></indexterm>
  </para
></listitem>
  <listitem
><para
>Fortran <indexterm>
      <primary
>Fortran</primary>
      <secondary
>nuovo progetto</secondary
></indexterm>
  </para
></listitem>
  <listitem
><para
>Haskell <indexterm>
      <primary
>Haskell</primary>
      <secondary
>nuovo progetto</secondary
></indexterm>
  </para
></listitem>
  <listitem
><para
>Java <indexterm>
      <primary
>Java</primary>
      <secondary
>nuovo progetto</secondary
></indexterm>
  </para
></listitem>
  <listitem
><para
>PHP <indexterm>
      <primary
>PHP</primary>
      <secondary
>nuovo progetto</secondary
></indexterm>
  </para
></listitem>
  <listitem
><para
>Pascal <indexterm>
      <primary
>Pascal</primary>
      <secondary
>nuovo progetto</secondary
></indexterm>
  </para
></listitem>
  <listitem
><para
>Perl <indexterm>
      <primary
>Perl</primary>
      <secondary
>nuovo progetto</secondary
></indexterm>
  </para
></listitem>
  <listitem
><para
>Python <indexterm>
      <primary
>Python</primary>
      <secondary
>nuovo progetto</secondary
></indexterm>
  </para
></listitem>
  <listitem
><para
>Ruby <indexterm>
      <primary
>Ruby</primary>
      <secondary
>nuovo progetto</secondary
></indexterm>
  </para
></listitem>
  <listitem
><para
>Shell (Script per la shell Bash) <indexterm>
      <primary
>Bash</primary>
      <secondary
>nuovo progetto</secondary
></indexterm>
    <indexterm>
      <primary
>shell</primary>
      <secondary
>nuovo progetto</secondary
></indexterm>
  </para
></listitem>
</itemizedlist>

<para
>Più precisamente queste cartelle non contengono i veri strumenti di programmazione, ma dei <emphasis
>modelli</emphasis
> predefiniti che possono essere usati come punto di partenza per la programmazione in quel particolare linguaggio. Per avere un'idea di quello che viene fornito, aprire le varie cartelle. In alcune di esse saranno presenti una serie di sottocartelle, mentre in altre ci saranno alcuni semplici elementi. Le sottocartelle organizzano i modelli disponibili a seconda dei vari compiti, mentre gli elementi rappresentano dei modelli che possono essere selezionati. </para>
<para
>Non si scenderà ulteriormente nei dettagli su quale compito viene svolto dai vari modelli, ma è semplice scoprirlo. Quando si seleziona un elemento vengono fornite alcune informazioni nei campi a destra. Più in basso si troverà una <emphasis
>breve descrizione</emphasis
> di cosa dovrebbe fare il modello. In alto, se disponibile, verrà mostrata un'immagine dell'applicazione che verrà prodotta dal modello una volta compilata e avviata senza modifiche. Normalmente questa immagine è uno <emphasis
>screenshot</emphasis
> della finestra principale dell'applicazione. </para>
<para
>Per prima cosa, selezionare il modello che si adatta meglio agli scopi della propria applicazione. Poi inserire le proprietà generali nei campi in basso come mostrato in seguito. </para>

<formalpara>
<title
>Selezionare un sistema di gestione dei progetti</title>
<para
>Ogni modello è legato ad uno specifico <link linkend="makesystems"
>Sistema di gestione dei progetti</link
>, che attualmente non può essere scelto liberamente. Si deve trovare un modello che corrisponda alle proprie necessità oppure modificare il progetto dopo la sua creazione. </para>
</formalpara>

</sect3
> <!-- new-projects-start-type -->

<sect3 id="new-projects-start-general">
<title
>Fornire le informazioni generali</title>

<indexterm zone="new-projects-start-general">
  <primary
>progetto</primary>
  <secondary
>proprietà</secondary
></indexterm>
<indexterm zone="new-projects-start-general">
  <primary
>proprietà</primary
></indexterm>
<indexterm zone="new-projects-start-general">
  <primary
>applicazione</primary>
  <secondary
>nome</secondary
></indexterm>
<indexterm zone="new-projects-start-general">
  <primary
>nome</primary>
  <secondary
>applicazione</secondary
></indexterm>
<indexterm zone="new-projects-start-general">
  <primary
>progetto</primary>
  <secondary
>directory</secondary
></indexterm>
<indexterm zone="new-projects-start-general">
  <primary
>directory</primary>
  <secondary
>progetto</secondary
></indexterm>
<indexterm zone="new-projects-start-general">
  <primary
>percorso</primary>
  <secondary
>nuovo progetto</secondary
></indexterm>
<indexterm zone="new-projects-start-general">
  <primary
>progetto</primary>
  <secondary
>autore</secondary
></indexterm>
<indexterm zone="new-projects-start-general">
  <primary
>progetto</primary>
  <secondary
>email</secondary
></indexterm>
<indexterm zone="new-projects-start-general">
  <primary
>autore</primary
></indexterm>
<indexterm zone="new-projects-start-general">
  <primary
>email</primary
></indexterm>
<indexterm zone="new-projects-start-general">
  <primary
>progetto</primary>
  <secondary
>main.cpp</secondary
></indexterm>
<indexterm zone="new-projects-start-general">
  <primary
>main.cpp</primary
></indexterm>
<indexterm zone="new-projects-start-general">
  <primary
>progetto</primary>
  <secondary
>licenza</secondary
></indexterm>
<indexterm zone="new-projects-start-general">
  <primary
>licenza</primary
></indexterm>

<para
>La parte più in basso della pagina <guilabel
>Generale</guilabel
> della finestra di dialogo <guilabel
>Crea nuovo progetto</guilabel
> contiene un gruppo di campi chiamati <guilabel
>Proprietà</guilabel
> che devono essere compilati in modo che la procedura guidata sappia come costruire la struttura iniziale del progetto. </para>
<formalpara>
<title
>Nome dell'applicazione</title>
<para
>Ovviamente l'applicazione deve avere un nome. Inserirlo nel campo più in alto del riquadro <guilabel
>Proprietà</guilabel
> chiamato <guilabel
>Nome Applicazione</guilabel
>. Nell'esempio è stato usato il nome <quote
>NuovaApplicazione</quote
>. </para>
</formalpara>
<para
>I caratteri speciali vengono rifiutati; gli unici caratteri ammessi sono: <itemizedlist>
  <listitem
><para
>caratteri maiuscoli e minuscoli</para
></listitem>
  <listitem
><para
>numeri</para
></listitem>
  <listitem
><para
>il carattere underline</para
></listitem>
</itemizedlist>
</para>
<para
>Questa restrizione è necessaria poiché la procedura guidata usa il nome dell'applicazione per costruire <emphasis
>i nomi di alcune classi</emphasis
>, quindi questo nome dovrà attenersi alle regole del linguaggio di programmazione usato. </para>
<formalpara>
<title
>Directory del progetto</title>
<para
>Nella linea inferiore dell'area <guilabel
>Proprietà</guilabel
> è presente il campo <guilabel
>Posizione Finale</guilabel
> e visualizza la directory dove verrà creata l'applicazione. </para>
</formalpara>
<para
>Mentre si scrive il nome si noterà che la procedura guidata ripete il proprio input alla fine della linea <guilabel
>Posizione Finale</guilabel
>, usando solo i caratteri minuscoli. </para>
<para
>Per questo deve essere selezionato con cura. Se si usa il nome di una directory già usata la procedura guidata non permetterà di continuare con la prossima fase tenendo disattivato il pulsante <guibutton
>Successivo &gt;</guibutton
> (rendendolo grigio). Tuttavia la procedura guidata <emphasis
>segnalerà</emphasis
> il problema aggiungendo la scritta <quote
>(dir./file già esistente)</quote
> nella linea <guilabel
>Posizione finale</guilabel
>. </para>

<formalpara>
<title
>Il percorso di partenza</title>
<para
>Ci sono due modi per scegliere un altro percorso per la propria applicazione: si può selezionare un altro nome, ma non è sempre attuabile. In alternativa si può selezionare un altro percorso della directory dell'applicazione. </para>
</formalpara>
<para
>Questo viene fatto nella seconda riga del gruppo <guilabel
>Proprietà</guilabel
>, chiamata <guilabel
>Posizione</guilabel
>, dove si inserisce il <emphasis
>percorso di partenza</emphasis
> dell'applicazione. Quando il progetto è inizializzato la procedura guidata aggiunge a questo percorso il nome dell'applicazione. Il percorso completo viene visualizzato nella linea <guilabel
>Posizione finale</guilabel
>. </para>
<para
>La procedura guidata copierà un <emphasis
>valore iniziale</emphasis
> nel campo <guilabel
>Posizione</guilabel
> ricavato dall'opzione <guilabel
>Directory progetti predefinita</guilabel
> durante la <link linkend="setup-general"
>configurazione generale</link
>. In questo caso il percorso iniziale per i nuovi progetti è <filename class="directory"
>/home/devel/</filename
>. </para>
<para
>Cambiare il contenuto del campo <guilabel
>Posizione</guilabel
> in modo che la directory di sviluppo dell'applicazione mostrata nella <guilabel
>Posizione finale</guilabel
> sia univoca. </para>
<!--TODO add tab description Project Options -->
<note
><para
>Accertarsi che il percorso che si inserisce nel campo <guilabel
>Posizione</guilabel
> sia esistente. In caso contrario non si potrà continuare con la prossima fase. Nel caso in cui il percorso non esistesse la procedura guidata <emphasis
>segnalerà</emphasis
> il problema aggiungendo il testo <quote
>(non valido)</quote
> nella linea <guilabel
>Posizione finale</guilabel
>. </para
></note>

<screenshot id="screenshot-createnewprojectoptions">
  <mediaobject>
    <imageobject>
      <imagedata fileref="createnewprojectoptions.png" format="PNG"/>
    </imageobject>
    <caption
><para
>Impostare un nuovo progetto con il CVS </para
></caption>
  </mediaobject>
</screenshot>

<formalpara>
<title
>Informazioni personali</title>
<para
>I campi seguenti non sono fondamentali come quelli precedenti. Inserire il proprio nome (cioè il nome del responsabile) nel campo <guilabel
>Autore</guilabel
>, e un indirizzo di email valido nel campo <guilabel
>Posta elettronica</guilabel
>, in modo che gli utenti possano fornire un eventuale feedback per l'applicazione. </para>
</formalpara>

<note>
<orderedlist>
  <listitem
><para
>La procedura guidata riempie questi campi con alcuni valori di default, ricavati dalle impostazioni presenti nel centro di controllo KDE. Se i valori di default dei campi <guilabel
>Autore</guilabel
> e <guilabel
>Posta elettronica</guilabel
> non sono appropriati si dovrebbe controllare la propria configurazione di posta nel &kcontrolcenter;. </para
></listitem>
  <listitem
><para
>Se questa informazione è disponibile, verrà integrata dalla procedura guidata nel modello dell'applicazione. Ad esempio nei programmi &kde; in C++ la si troverà vicino all'inizio del file <filename
>main.cpp</filename
>. </para
></listitem>
  <listitem
><para
><guilabel
>Posta elettronica</guilabel
> è un campo <emphasis
>opzionale</emphasis
>, poiché non tutti gli sviluppatori hanno accesso a Internet. Se si desidera si può lasciare il campo vuoto e procedere. </para
></listitem>
</orderedlist>
</note>

<formalpara>
<title
>Informazioni sulla versione e sulle licenze</title>
<para
>Infine inserire un numero di versione nel campo <guilabel
>Versione</guilabel
> e selezionare la licenza con la quale rilasciare l'applicazione nel menu <guilabel
>Licenza</guilabel
>. </para>
</formalpara>

<para
>Se si seleziona un tipo di applicazione per la quale vengono forniti i modelli dei sorgenti dalla procedura guidata (&eg; C/C++), si potrà vedere il testo di notifica della licenza nella terza pagina della finestra di dialogo <guilabel
>Crea nuovo progetto</guilabel
> (vedere il capitolo <link linkend="new-projects-start-templates"
>Fornire i modelli dei file header/sorgente</link
>). </para>
<para
>Se si seleziona <quote
>Personalizzato</quote
> nel menu <guilabel
>Licenza</guilabel
> si dovrà inserire il testo della licenza. </para>

<note
><para
>Sia la versione che le informazioni sulla licenza saranno integrati nei modelli in un formato appropriato per il tipo di applicazione selezionata. </para
></note>

<para
>Quando sono state inserite correttamente tutte le informazioni, premere il pulsante <guibutton
>Successivo &gt;</guibutton
> per procedere. </para>
</sect3
> <!-- new-projects-start-general -->

</sect2
> <!-- new-projects-start -->

<sect2 id="new-projects-start-cvs">
<title
>Fornire le informazioni del Version System</title>

<indexterm zone="new-projects-start-cvs">
  <primary
>CVS</primary>
  <secondary
>nuovo progetto</secondary
></indexterm>
<indexterm zone="new-projects-start-cvs">
  <primary
>progetto</primary>
  <secondary
>CVS</secondary
></indexterm>
<indexterm zone="new-projects-start-cvs">
  <primary
>database</primary>
  <secondary
>CVS</secondary
></indexterm>
<indexterm zone="new-projects-start-cvs">
  <primary
>versione</primary>
  <secondary
>database</secondary
></indexterm>
<indexterm zone="new-projects-start-cvs">
  <primary
>versione</primary>
  <secondary
>CVS</secondary
></indexterm>

<para
>Nella seconda fase la procedura guidata mostrerà la pagina <guilabel
>Version Control System</guilabel
> dove si può decidere quale version control system si vuole usare. </para>

<note
><para
>Questo capitolo si limita a fornire le informazioni necessarie per la creazione di progetti. Per ulteriori informazioni su &CVS; vedere il capitolo <link linkend="cvs"
>Usare &CVS;</link
> </para
></note>

<formalpara>
<title
>Nessun Version Control System</title>
<para
>Inizialmente è selezionato <quote
>Nessuno</quote
> nel menu <guilabel
>Sistema di controllo versione</guilabel
> e la pagina è vuota. Se non si vuole usare un version control system, fare clic sul pulsante <guibutton
>Successivo &gt;</guibutton
> e proseguire. </para>
</formalpara>

<formalpara>
<title
>Usare &CVS;</title>
<para
>In caso contrario si deve selezionare il version control system che si vuole usare dal menu <guilabel
>Sistema di controllo versione</guilabel
>. In questo esempio si userà <quote
>&cvs;</quote
>. Se lo si seleziona, la procedura guidata ridisegnerà la pagina, visualizzando una serie di campi da riempire. </para>
</formalpara>

<screenshot id="screenshot-newproject-cvs">
  <mediaobject>
    <imageobject>
      <imagedata fileref="create-new-project-cvs.png" format="PNG"/>
    </imageobject>
    <caption
><para
>Impostare un nuovo progetto con il CVS </para
></caption>
  </mediaobject>
</screenshot>

<para
>Un version control system come &CVS; (che significa <quote
>Concurrent Versions System</quote
>) conserva copie dei file del progetto in una sorta di database. Se si usa &CVS; si possono caricare (<quote
>commit</quote
>) o scaricare questi file nella propria directory del progetto (<quote
>checkout</quote
>, o <quote
>update</quote
>). La particolarità consiste nella struttura in cui sono immagazzinati i file che permette di ripristinare un precedente stato di sviluppo. Con &CVS; diversi progettisti possono collaborare facilmente ad un grande progetto senza disturbarsi a vicenda. </para>

<indexterm zone="new-projects-start-cvs-root">
  <primary
>CVS</primary>
  <secondary
>radice</secondary
></indexterm>
<indexterm zone="new-projects-start-cvs-root">
  <primary
>radice</primary>
  <secondary
>CVS</secondary
></indexterm>
<indexterm zone="new-projects-start-cvs-root">
  <primary
>CVS</primary>
  <secondary
>locale</secondary
></indexterm>
<indexterm zone="new-projects-start-cvs-root">
  <primary
>CVS</primary>
  <secondary
>remoto</secondary
></indexterm>
<indexterm zone="new-projects-start-cvs-root">
  <primary
>CVS locale</primary
></indexterm>
<indexterm zone="new-projects-start-cvs-root">
  <primary
>:local:</primary
></indexterm>
<indexterm zone="new-projects-start-cvs-root">
  <primary
>CVS</primary>
  <secondary
>:local:</secondary
></indexterm>

<formalpara id="new-projects-start-cvs-root">
<title
>Radice &CVS;</title>
<para
>&CVS; deve <emphasis
>amministrare</emphasis
> il database costituito dai file del progetto, conservando alcune informazioni speciali in una directory chiamata <emphasis
>radice &CVS;</emphasis
>. Quindi per prima cosa si deve indicare a &tdevelop; dove è situata questa directory radice. </para>
</formalpara>

<para
><emphasis
>Radice &CVS; locale</emphasis
>. Ci sono due possibilità: usare un database &CVS; <emphasis
>locale</emphasis
> o uno che è mantenuto su un <emphasis
>server remoto</emphasis
>. Se si sviluppa in proprio, si potrebbe usare il database &CVS; come una sorta di sistema di backup sul proprio computer. Normalmente questo è impostato sulla propria directory home e ha come nome <filename
>cvsroot</filename
>. Potrebbe essere simile a questo: </para>
<para
><userinput
><filename class="directory"
>/home/devel/cvsroot</filename
></userinput
> (dove <filename
>devel</filename
> indica semplicemente l'utente <quote
>sviluppatore</quote
>, ad esempio) </para>

<note
><para
>Di fatto, questa è la forma abbreviata. Esattamente, la radice locale del &CVS; dovrebbe essere indirizzata usando il prefisso <computeroutput
>:local:</computeroutput
>. La forma breve è permessa solo nei casi in cui il nome del file inizia con una barra (<computeroutput
>/</computeroutput
>). Il nome completo per l'esempio sarebbe esattamente così:<filename class="directory"
>:local:/home/devel/cvsroot</filename
> </para
></note>

<para
>Inserire il nome della directory radice del &CVS; del proprio sistema nel campo <guilabel
>Radice CVS</guilabel
>. In principio si può selezionare ogni nome, anche database &CVS; multipli, ma è consigliabile attenersi alla radice &CVS; impostata. </para>
<para
><emphasis
>Inizializzare una nuova radice &CVS;</emphasis
>. Se non esiste ancora una radice &CVS;, &tdevelop; può comandare a &CVS; di crearne una nella directory indicata. Selezionare la casella <guilabel
>Init root</guilabel
> sotto al campo <guilabel
>Radice CVS</guilabel
>. </para>
<note
><para
>Come detto in precedenza, &tdevelop; invia al sistema &CVS; i comandi per inizializzare una nuova radice &CVS;. Fortunatamente, &CVS; è abbastanza saggio da controllare se esiste già una directory radice. Perciò non succede nulla di male se si seleziona inavvertitamente la casella <guilabel
>Init root</guilabel
> in una directory radice già esistente.  </para
></note>

<para
><emphasis
>Radice &CVS; remota</emphasis
>. Ci sono situazioni dove il database &CVS; deve essere mantenuto su un server remoto, specialmente quando diversi sviluppatori lavorano allo stesso progetto. In questo caso si deve inserire l'&URL; della radice &CVS; di questo server nel campo <guilabel
>Radice CVS</guilabel
>. Per esempio, se si vuole accedere al server &CVS; di &kde;: </para>
<para
><userinput
><filename class="directory"
>:pserver:<replaceable
>mylogin</replaceable
>@cvs.kde.org:/home/kde</filename
></userinput
> dove <replaceable
>mylogin</replaceable
> indica il nome che è stato impostato nell'account &CVS; di &kde;) </para>

<indexterm zone="new-projects-start-cvs-remote">
  <primary
>CVS remoto</primary
></indexterm>
<indexterm zone="new-projects-start-cvs-remote">
  <primary
>:pserver:</primary
></indexterm>
<indexterm zone="new-projects-start-cvs-remote">
  <primary
>:ext:</primary
></indexterm>
<indexterm zone="new-projects-start-cvs-remote">
  <primary
>CVS</primary>
  <secondary
>:local:</secondary
></indexterm>
<indexterm zone="new-projects-start-cvs-remote">
  <primary
>CVS</primary>
  <secondary
>:pserver:</secondary
></indexterm>
<indexterm zone="new-projects-start-cvs-remote">
  <primary
>CVS</primary>
  <secondary
>:ext:</secondary
></indexterm>

<formalpara id="new-projects-start-cvs-remote">
<title
>Tipi di server &CVS; remoti</title>
<para
>Principalmente ci sono due tipi largamente usati di server &CVS; remoti, il <emphasis
>pserver</emphasis
> che usa un protocollo non cifrato protetto da password e il server <emphasis
>ext</emphasis
> che usa il trasferimento dati cifrato rsh o ssh. Si distinguono dal prefisso dell'&URL;: </para>
</formalpara>
<para>
<filename
>:pserver:</filename>
</para>
<para
>per un <quote
>server protetto da password</quote
> non cifrato, e </para>
<para>
<filename
>:ext:</filename>
</para>
<para
>per un server cifrato di tipo rsh o ssh. Per esempio </para>
<para>
<userinput
><filename class="directory"
>:ext:<replaceable
>mylogin</replaceable
>@cvs.cervisia.sourceforge.net:/cvsroot/cervisia</filename
></userinput>
</para>
<para
>accede alla radice &CVS; del famoso strumento di gestione di &CVS; <application
>Cervisia</application
> sul server SourceForge. </para>
<para
>Se si vuole usare un server cifrato rsh o ssh per l'accesso &CVS; si deve indicare a &tdevelop; il protocollo di cifratura da usare. Inserire <userinput
>rsh</userinput
> o <userinput
>ssh</userinput
> nel campo <guilabel
>CVS_RSH</guilabel
> della pagina <guilabel
>Version Control System</guilabel
> della finestra <guilabel
>Crea nuovo progetto</guilabel
>. </para>

<note
><para
>Bisogna fare attenzione se si usa un server &CVS; cifrato con &tdevelop;. Vedere il capitolo <link linkend="cvs"
>Usare &CVS;</link
> per i dettagli. </para
></note>

<indexterm zone="new-projects-start-cvs-repository">
  <primary
>CVS</primary>
  <secondary
>deposito</secondary
></indexterm>
<indexterm zone="new-projects-start-cvs-repository">
  <primary
>deposito</primary>
  <secondary
>CVS</secondary
></indexterm>

<formalpara id="new-projects-start-cvs-repository">
<title
>Il deposito &CVS;</title>
<para
>Fin qui è stato indicato a &tdevelop; dove risiede la radice &CVS; che gestisce il database e come accedervi. Adesso si deve inserire sotto quale nome si vogliono salvare i file del progetto nel database. La posizione dove i file di progetto vengono memorizzati è detta <emphasis
>deposito (repository)</emphasis
>. </para>
</formalpara>
<para
>In principio si può usare qualunque nome per il deposito &CVS;, purché aderisca alle specifiche per i nomi dei file, tuttavia molti sviluppatori usano semplicemente il nome stesso dell'applicazione. Siccome &CVS; costruirà una directory con questo nome nella radice &CVS;, se si usa il nome dell'applicazione sarà più facile trovarla. </para>
<para
>Inserire il nome del deposito che si vuole usare nel campo <guilabel
>CVS repository</guilabel
> della pagina <guilabel
>Version Control System</guilabel
> della finestra <guilabel
>Crea nuovo progetto</guilabel
>. Nell'esempio è: <userinput
>NuovaApplicazione</userinput
> </para>

<warning
><para
><emphasis
>Si eviti di usare un deposito già esistente!</emphasis
> Il sistema &CVS; non avverte in caso di file duplicati ed elimina tutto quello che non produce un conflitto formale. Si rovinerà tutto! </para
></warning>

<formalpara>
<title
>Campi restanti</title>
<para
>Non c'è molto altro lavoro da fare: la procedura guidata ha impostato i campi rimanenti. Nel dettaglio: </para>
</formalpara>
<para
>Il campo <guilabel
>Tag del Vendor</guilabel
> è usato solo per ragioni di compatibilità. Si può mantenere il valore di default <quote
>vendor</quote
> che viene inserito dalla procedura guidata. </para>
<para
>Il campo <guilabel
>Messaggio</guilabel
> permette di commentare i contenuti iniziali di &CVS;. Usare qualunque testo desiderato oppure lasciare il valore di default <quote
>nuovo progetto</quote
> che viene inserito dalla procedura guidata. </para>
<para
>Il <guilabel
>Tag di release</guilabel
> contiene il nome che etichetta lo stato iniziale del progetto. Una tale <emphasis
>etichetta</emphasis
> definisce all'interno del deposito &CVS; un certo punto dal quale si può in seguito accedere a quello stadio di sviluppo. (Ulteriori informazioni nel capitolo <link linkend="cvs"
>Usare &CVS;</link
>) </para>
<para
>La procedura guidata mette un valore di default <quote
>avvia</quote
> che è una buona proposta. Si può lasciare questa. </para>

<note>
<para
>Fino al momento della costruzione del progetto, &tdevelop; non saprà se c'è qualche informazione sbagliata: sarà il sistema &CVS; a individuare questi errori quando costruirà il deposito. Quindi si deve controllare la finestra <guilabel
>Messaggi</guilabel
> di &tdevelop; quando viene creato il progetto. Se c'è stato qualche errore nelle impostazioni del &CVS; nella maggior parte dei casi si vedranno messaggi di errore come questi: </para>

<screen
><computeroutput>
* cd '/home/devel/test' &amp;&amp; cvs -d '/home/devel/mycvsroot' \
  import -m 'nuovo progetto' '' 'vendor' 'avvia' &amp;&amp;\
  sh /opt/kde3/share/apps/kdevcvs/buildcvs.sh . '' \
  '/home/devel/mycvsroot'
* cvs [import aborted]: /home/devel/mycvsroot/CVSROOT: No such file or
  directory
* *** Exited with status: 1 ***
</computeroutput
></screen>

<para
>In questo caso si deve impostare manualmente &CVS; (a questo punto &tdevelop; dovrebbe aver inizializzato con successo i file del progetto) o cancellare la directory del progetto e ricominciare da capo con il comando <guimenuitem
>Nuovo Progetto...</guimenuitem
> dal menu <guimenu
>Progetto</guimenu
>. </para>
</note>

<para
>Dopo aver inserito tutte le informazioni relative a &CVS;, fare clic sul pulsante <guibutton
>Successivo &gt;</guibutton
> per procedere. </para>

<note
><para
>Se si vuole correggere un errore nella pagina precedente, premere il pulsante <guibutton
>&lt; Precedente</guibutton
>. La procedura guidata ricorderà le impostazioni della pagina attuale, in modo da poter procedere facilmente quando si ritornerà a questa pagina. </para
></note>

</sect2
> <!-- new-projects-start-cvs -->

<sect2 id="new-projects-start-templates">
<title
>Fornire i modelli dei file header/sorgente</title>

<para
>Nella prossima fase saranno impostate alcune informazioni da includere nei file sorgente e header. </para>
<para
>Nelle rispettive pagine vengono forniti i modelli dei file header e sorgente per le applicazioni C/C++. Per gli altri linguaggi potrebbe essere disponibile solo il modello per il file sorgente, e in alcuni casi si troveranno le pagine dei modelli vuote. </para>
<para
>Se la pagina viene usata, sarà riempita dalla procedura guidata con alcuni commenti, che nel caso di applicazioni C++ appariranno così: </para>

<screen
><computeroutput
><literal>
/***************************************************************************
 *   Copyright (C) 2003 by Nome                                            *
 *   io@io.it                                                              *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
</literal
></computeroutput
></screen>

<para
>Gli altri modelli forniranno informazioni simili in un formato adatto al linguaggio di programmazione usato. </para>
<para
>Il gestore delle applicazioni usa le informazioni che sono state fornite nella pagina <guilabel
>Generale</guilabel
> della finestra di dialogo <guilabel
>Crea nuovo progetto</guilabel
>, cioè i contenuti dei campi <guilabel
>Autore</guilabel
> e <guilabel
>Posta elettronica</guilabel
>. Anche le informazioni sulla licenza vengono inserite in base alla selezione effettuata nel menu <guilabel
>Licenza</guilabel
>. </para>

<sect3 id="new-projects-start-templates-edit">
<title
>Come modificare i modelli</title>

<indexterm zone="new-projects-start-templates-edit">
  <primary
>modelli</primary>
  <secondary
>progetto</secondary>
  <tertiary
>modificare</tertiary
></indexterm>
<indexterm zone="new-projects-start-templates-edit">
  <primary
>progetto</primary>
  <secondary
>modelli</secondary>
  <tertiary
>modificare</tertiary
></indexterm>

<para
>Quando &tdevelop; creerà un nuovo file sorgente e/o header, verranno elaborati i modelli presenti nella finestra di dialogo <guilabel
>Crea nuovo progetto</guilabel
>. Le informazioni fornite nei modelli saranno incluse nell'intestazione dei file che precede il codice. </para>
<para
>Oltre al semplice testo, &tdevelop; riconosce diverse variabili che permettono di includere informazioni nel file. La procedura guidata usa alcune di queste varibili per inserire le informazioni <guilabel
>Autore</guilabel
>, <guilabel
>Posta elettronica</guilabel
> e <guilabel
>Licenza</guilabel
>. </para>

<variablelist>
<varlistentry>
<term
>Includere informazioni di &doxygen;</term>
<listitem>
<para
>Se, ad esempio, si vuole che la documentazione &API; di &doxygen; visualizzi alcune informazioni sul contenuto del file si potrebbero includere le seguenti linee nel modello di file sorgente. </para>
<screen
><computeroutput>
/**
 * \file $MODULE$.cpp
 * \brief (inserire-qui-una-breve-descrizione).
 **/
</computeroutput
></screen>
<para
>Quando verrà creato un nuovo file sorgente, &tdevelop; sostituirà la variabile <varname
>$MODULE$</varname
> con il nome del file creato. Per esempio, se si crea una nuova classe C++ chiamata <classname
>ASimpleTest</classname
> il file <filename
>asimpletest.cpp</filename
> conterrà le linee seguenti: </para>
<screen
><computeroutput>
/**
 * \file asimpletest.cpp
 * \brief (inserire-qui-una-breve-descrizione).
 **/
</computeroutput
></screen>
<para
>Si dovrà fornire una breve descrizione dopo la parola chiave <quote
>\brief</quote
>, ma parte del lavoro è stato fatto automaticamente. </para>
</listitem>
</varlistentry>

<varlistentry>
<term
>Il file della licenza</term>
<listitem>
<para
>Si potrebbe, ad esempio, includere nel modello un accenno al testo di licenza usato. A questo scopo di usa la variabile <varname
>$LICENSEFILE$</varname
>, aggiungendo una linea come questa: </para>

<screen
><computeroutput>
//   Vedere $LICENSEFILE$ per il testo completo della licenza.
</computeroutput
></screen>
<para
>La procedura guidata sostituirà <varname
>$LICENSEFILE$</varname
> con il nome del file dove si trova il testo completo della licenza, cioè: </para>
<screen
><computeroutput>
//   Vedere COPYING per il testo completo della licenza.
</computeroutput
></screen>
<para
>per la licenza <acronym
>GPL</acronym
>, o  </para>
<screen
><computeroutput>
//   Vedere LICENSE.BSD per il testo completo della licenza.
</computeroutput
></screen>
<para
>se si decide di rilasciare l'applicazione sotto licenza <acronym
>BSD</acronym
>. </para>
<para
>Ovviamente esistono molte altre variabili riconosciute da &tdevelop;. Vedere la sezione <link linkend="newfiles-edittemplates"
>Modificare i modelli</link
> del capitolo <link linkend="editing"
>Strumenti di Editing</link
> per ulteriori informazioni. </para>
</listitem>
</varlistentry>
</variablelist>

<note
><para
>I modelli che sono stati definiti saranno utilizzati solo dopo che la procedura guidata ha creato il nuovo progetto. Le informazioni che contengono si trovano informazioni all'inizio dei file che vengono creati. Quando verranno creati i file iniziali la procedura guidata userà alcuni modelli standard predefiniti, che dovranno essere modificati manualmente. </para
></note>

</sect3
> <!-- new-projects-start-templates-edit -->
</sect2
> <!-- new-projects-start-templates -->

<sect2 id="new-projects-start-build">
<title
>Compilare i file iniziali</title>

<indexterm zone="new-projects-start-build">
  <primary
>progetto</primary>
  <secondary
>nuovo</secondary>
  <tertiary
>compilare</tertiary
></indexterm>
<indexterm zone="new-projects-start-build">
  <primary
>progetto</primary>
  <secondary
>prima compilazione</secondary
></indexterm>

<para
>È stato fatto quasi tutto. Nell'ultima pagina il testo del pulsante <guibutton
>Successivo &gt; </guibutton
> cambierà diventando <guibutton
>Fine</guibutton
>. </para>
<para
><emphasis
>Pensarci due volte prima di fare clic!</emphasis
> Si può ancora rivedere ogni cosa premendo ripetutamente il pulsante <guibutton
>&lt; Precedente</guibutton
>. Siccome la procedura guidata ricorda tutte le informazioni che sono state inserite, potrebbe essere consigliabile prendersi il tempo per rivederle ancora una volta. Nel caso si usi un &CVS; locale, non dimenticare di controllare il nome del <emphasis
>deposito &CVS;</emphasis
> (non dovrebbero esistere sottodirectory con quel nome nella directory radice &CVS; &mdash; se esistono provare un altro nome per il deposito). </para>
<para
>Se non si vuole costruire il nuovo progetto, fare clic sul pulsante <guibutton
>Annulla</guibutton
> in modo da chiudere la finestra di dialogo <guilabel
>Crea nuovo progetto</guilabel
>. In caso contrario premere il pulsante <guibutton
>Fine</guibutton
> e controllare nella finestra <guilabel
>Messaggi</guilabel
> l'inizializzazione del progetto. </para>
<para
>Se si vuole usare un sistema di versioning (&CVS;) ci sono effettivamente due percorsi. La procedura guidata costruirà prima le directory del progetto e i file, in seguito chiamerà il programma &CVS; che inserirà nella finestra <guilabel
>Messaggi</guilabel
> il proprio output. Se capita qualche errore in queste fasi si fermerà il processo, mostrando il messaggio di errore opportuno nella finestra. </para>

<note
><para
>Nella maggior parte dei casi, quando il progetto è stato impostato, &tdevelop; caricherà automaticamente il/i file sorgente di uno o più moduli principali in modo da poter iniziare facilmente a lavorare. (Tuttavia, quale modulo sorgente verrà visualizzato dipende dal modello inizialmente selezionato nella procedura guidata). </para
></note>

<para
>Non dimenticarsi di fare un controllo preliminare del lavoro svolto dalla procedura guidata. Per esempio si potrebbe voler modificare le informazioni di intestazione in base ai propri modelli, che normalmente si trovano nella sottodirectory <filename class="directory"
>templates</filename
> della directory del progetto. Saranno sufficienti alcune semplici operazioni di copia. </para>
<para
>In seguito è consigliabile <emphasis
>compilare il progetto</emphasis
> prima di iniziare a cambiare il codice. Nella maggior parte dei casi sarà possibile effettuare la compilazione. In questo modo si può capire se il progetto è stato impostato in modo opportuno. In caso contrario, rimuovere semplicemente la directory del progetto (anche nella radice &CVS; se è stata usata) e ripartire nuovamente. </para>

<warning id="defaultbuild-warning"
> <!-- ### remove this when "default" works again -->

  <indexterm zone="defaultbuild-warning">
    <primary
>configurazione di compilazione di default</primary>
    <secondary
>avvertimento</secondary
></indexterm>
  <indexterm zone="defaultbuild-warning">
    <primary
>configurazioni di compilazione</primary>
    <secondary
>avvertimento per compilazione di default</secondary
></indexterm>
  <indexterm zone="defaultbuild-warning">
    <primary
>avvertimento</primary>
    <secondary
>configurazione compilazione default</secondary
></indexterm>

  <para
>Prima di compilare il nuovo progetto, controllare in <menuchoice
><guimenu
>Progetto</guimenu
> <guimenuitem
>Configurazione compilazione</guimenuitem
></menuchoice
>. Se sono visualizzate tre selezioni: <guimenuitem
>default</guimenuitem
>, <guimenuitem
>optimized</guimenuitem
>, e <guimenuitem
>debug</guimenuitem
> e quest'ultima è selezionata si deve mantenere questa configurazione oppure selezionare <guimenuitem
>optimized</guimenuitem
>. </para>
  <para
>A causa di alcune limitazioni nell'impostazione attuale di autoconf/automake non si dovrebbe <emphasis
>per nessun motivo</emphasis
> compilare nella configurazione <guimenuitem
>default</guimenuitem
>. Questo corromperà alcune impostazioni interne della directory, quindi <command
>configure</command
> si lamenterà quando si tenterà di usarlo in seguito nella configurazione <guimenuitem
>optimized</guimenuitem
> o <guimenuitem
>debug</guimenuitem
>. </para>
  <para
>(Questo si applica solo con queste capacità di multiselezione. Se il tipo della propria applicazione fornisce solo la configurazione <guimenuitem
>default</guimenuitem
>, si deve ovviamente usare quest'ultima).  </para>
</warning>

</sect2
> <!-- new-projects-start-build -->

</sect1
> <!-- new-projects -->

<sect1 id="projects-configure">
<title
>Configurazione dei progetti</title>

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

</sect1>

</chapter
> <!-- applicationwizard -->