# Komma igång: Programguiden

Arbete med att utveckla programvara i &kdevelop; organiseras i projekt. Ett sådant projekt håller samman allt som hör till en fullständig programmeringsuppgift: källkodsfiler, ytterligare datafiler, alla hanteringsfunktioner som behövs som byggsystemet samt åtkomst till alla komponenter och ytterligare verktyg som behövs för att få programmet klart att köras.

Att organisera utvecklingsarbetet i projekt låter dig enkelt byta mellan befintliga övergripande uppgifter. Det här riktigt bekvämt om du till exempel arbetar med flera program samtidigt, vilket ofta är fallet. Tala om för &kdevelop; att öppna projektet du vill arbeta med, och du kan fortsätta i miljön precis där du tidigare lämnade den.

## Nya projekt

Så fort du vill starta ett nytt programmeringsprojekt, behöver en hel del formella inställningsprocedurer göras. En startstruktur för kataloger måste skapas, nya deklarationsfiler och källkodsfiler måste skapas, byggsystemet måste initieras, etc.

&kdevelop; tillhandahåller ett enkelt sätt att starta ett nytt programmeringsprojekt: programguiden. Du hittar programguiden via menyalternativet Projekt Nytt projekt.

Det behövs bara ett fåtal steg för att skapa ett nytt programmeringsprojekt med programguiden:

1. Välj programspråk du vill använda, och typ av program som du vill skapa från en uppsättning fördefinierade mallar.

2. Tillhandahåll en del allmän information som programnamn, katalog där programmet ska byggas, etc.

3. Bestäm om du vill använda ett versionskontrollsystem, som t.ex. CVS, och tillhandahåll nödvändig information som behövs.

4. Ställ in några mallar för ursprunglig deklarationsfil och källkodsfil (om nödvändigt).

5. Tala till sist om för programguiden att skapa alla nya saker, katalogstruktur, startmallar för deklarationsfiler och källkodsfiler, och hanteringsverktyg som ett startskelett för att bygga programmet, etc.

Voilà, det är allt. Programguiden har nu gett dig en första fungerade uppsättning programfiler, där du enkelt kan börja arbeta.

Låt oss nu ta en mer detaljerad titt på allt detta...

### Inledande steg

För att skapa ett nytt projekt i &kdevelop;, välj Nytt projekt i menyn Projekt. Du ska då se guiden för att skapa nytt projekt, som visas nedan:

Inledande dialogruta för att skapa ett nytt projekt

Som du kan se, är dialogrutan uppdelad i en övre och undre del. I den övre delen kan du bestämma dig för programspråk och programtyp. Den under delen innehåller en del allmän information.

#### Välj programspråk och programtyp

Du gör dina val på vänstersidan längst upp i dialogrutan. När den visas finns en lista med kataloger, var och en med namnet på ett programspråk, som till exempel:

- Ada

- C

- C++

- Databas (SQL-projekt)

- Fortran

- Haskell

- Java

- Pascal

- Perl

- PHP

- Python

- Ruby

- Skal (Skript för skalet Bash)

För att precisera, innehåller katalogerna i själva verket inte riktiga programmeringsverktyg. De leder till fördefinierade mallar som du kan använda som utgångspunkt för utveckling i ett språk. För att få en idé om vad som erbjuds, öppna bara en katalog i taget. Det finns en följd underkataloger i vissa, men bara en eller flera enkla beteckningar i andra. Underkatalogerna du ser organiserar de tillgängliga mallarna enligt vissa uppgifter, de enkla beteckningarna namnger mallar som du kan välja.

Här kan vi inte i detalj gå in på vilka uppgifter varje mall tillhandahåller, men det är enkelt att ta reda på. Så fort du markerar en mallbeteckning, visas viss information i fälten till höger. I det nedre fältet ser du en kort beskrivning om vad mallen är avsedd att göra. I fältet ovanför visas en bild, om tillgänglig, med hur programmet som mallen producerar ser ut om du kompilerar och kör det utan ändring. Oftast är det en skärmbild av huvudfönstret som programmet visar.

Välj mallen som bäst passar målen för ditt program som startpunkt. Skriv därefter in information om allmänna egenskaper i de nedre fälten, som visas i nästa kapitel.

#### Välja ett projekthanteringssystem

Varje mall är kopplad till ett särskilt projekthanteringssystem. För närvarande finns det inget direkt sätt att helt fritt välja ett sådant projekthanteringssystem. Du måste hitta en mall som passar dina behov, eller ändra projektet på motsvarande sätt efter det har skapats.

#### Ange allmän information

Den undre delen av sidan Allmänt i dialogrutan Skapa nytt projekt är ett inramat fält som heter Egenskaper. Du måste tillhandahålla en del allmän information om projektet här, så att programguiden vet hur den ursprungliga strukturen ska byggas.

#### Programnamn

Ditt program behöver förstås ett namn. Skriv in det i det övre fältet under Egenskaper, som heter Programnamn. Vi använder Mitt_program som exempel.

När du gör det, märker du att programguiden vägrar att acceptera specialtecken av något slag. De enda tecken som accepteras är:

- små och stora bokstäver

- siffror

- tecknet understreck

En framträdande orsak till begränsningen är att programguiden kommer att använda programnamnet som bas för vissa klassnamn som den skapar när den bygger upp projektet från början. Alltså måste projektets namn följa reglerna för programspråket som används.

#### Projektkatalogen

Den andra utmärkande orsaken för begränsningen ser du på nedersta raden i området Egenskaper. Den heter Slutgiltig plats, och visar katalogen där programguiden skapar programmet.

När du skriver in programmets namn märker du att programguiden repeterar det du skriver in längst ner på raden Slutgiltig plats, men bara med små bokstäver.

Alltså måste du välja namn på det nya programmet med försiktighet. Om du slutar med en katalog som redan används, låter inte programguiden dig fortsätta till nästa steg, genom att behålla knappen Nästa > inaktiv (grå). Den varnar dig också genom att lägga till (fil eller katalog finns redan) sist på raden Slutgiltig plats.

#### Startsökväg

Det finns två sätt att välja en annan sökväg till det nya programmet. En är att använda ett annat namn. Det är dock inte alltid möjligt (t.ex. skapar du kanske en ny version av ett befintligt program). Som ett alternativ kan du välja en annan sökväg till programkatalogen.

Det görs i den andra radens inmatningsfält under Egenskaper, som heter Plats. Det du skriver in här är överliggande sökväg för det nya programmets utvecklingskatalog. Programguiden lägger till programnamnet sist i sökvägen när det nya projektet skapas. Resultatet visas på raden Slutgiltig plats för att bättre visa vad som händer.

Programguiden kopierar ett startvärde till fältet Plats från början. Det hämtas från det du har valt under fältet Standardprojektkatalog under den allmänna inställningen. I vårt fall har vi ställt in &kdevelop; att använda `/home/utveckling/projekt/` som ursprunglig sökväg för nya projekt.

Ändra innehållet i fältet Plats, så att utvecklingskatalogen för programmet som visas på raden Slutgiltig plats är unik.

Försäkra dig om att sökvägen du skriver in i fältet Plats redan finns. Annars kommer du inte att kunna fortsätta till nästa steg. Programguiden varnar dig om sökvägar som inte finns, genom att lägga till (ogiltig) sist på raden Slutgiltig plats.

#### Personlig information

Fälten som följer är inte så kritiska. Ange bara ditt namn (dvs. namnet på personen som är ansvarig för programmet) i fältet Upphovsman, och en giltig e-postadress i fältet E-post, så att användare kan ge dig återmatning om programmet.

1. Programguiden fyller i fälten med vissa förvalda värden, som tas från e-postinställningarna i KDE:s inställningscentral. Om de förvalda värdena i fälten Upphovsman och E-post under Skapa nytt projekt inte passar, bör du kontrollera e-postinställningarna i KDE:s inställningscentral.

2. Programguiden sammanställer informationen till startprogrammallar om de finns. För KDE C++ program, hittar du den till exempel i början av källkodsfilen `main.cpp`.

3. Fältet E-post är det valfria bland fälten, vilket beror på att alla utvecklare kanske inte har tillgång till Internet. Du kan lämna fältet tomt om du vill, och ändå fortsätta.

#### Versions- och licensinformation

Skriv till sist in startversion för det nya programmet i fältet Version, och välj licensen du vill ska gälla för ditt program i kombinationsrutan Licens.

Om du väljer en programtyp där programguiden tillhandahåller gemensamma källkodstextmallar (t.ex. C/C++), bör du titta på licensinformationstexten på tredje sidan i dialogrutan Skapa nytt projekt (se kapitlet Ange mallar för deklarationer och källkod nedan).

Om du valde Egen i kombinationsrutan Licens måste du själv tillhandahålla en licenstext.

Både version och licensinformation kommer också att infogas i startmallarna på ett lämpligt format som passar programtypen du väljer.

När du har skrivit in all den här informationen på ett riktigt sätt, tryck på knappen Nästa > för att fortsätta, som visas i följande kapitel.

### Ange information om versionssystem

I det andra steget, leder programguiden dig till sidan Versionskontrollsystem, där du kan bestämma vilket versionskontrollsystem du vill använda.

Den här beskrivningen koncentreras endast på behoven för att skapa projekt. För mer information om CVS, se kapitlet Använda CVS nedan.

### Inget versionskontrollsystem önskas

Från början är Inget valt i kombinationsrutan Versionskontrollsystem, och sidan är för övrigt tom. Om du inte vill använda ett versionskontrollsystem, klicka bara på knappen Nästa för att fortsätta.

### Använda CVS

Annars måste du välja versionskontrollsystemet som du vill använda i kombinationsrutan Versionskontrollsystem. Vi använder &cvs; i vårt exempel. Om du väljer det, visar programguiden sidan igen, men nu innehåller den ett antal fält som du måste fylla i.

Ställa in ett nytt projekt för CVS

Ett versionskontrollsystem som &CVS; (vilket betyder Concurrent Versions System) lagrar kopior av valda projektfiler i någon sorts databas. Om du använder &CVS;, kan du bland annat ladda upp (arkivera) filerna eller ladda ner dem till din projektkatalog (checka ut, eller uppdatera). Det särskilda med detta är att filerna i versionsdatabasen lagras på ett strukturerat sätt, vilket gör att du alltid kan återgå till ett tidigare utvecklingssteg om du behöver. &CVS; tillåter också flera utvecklare att ganska enkelt samarbeta i ett stort projekt (som &kdevelop;), utan att störa varandras arbete.

### CVS-rot

&cvs; måste hantera versionsdatabasen som det har med dina projektfiler. För att åstadkomma det har det en del speciell databasinformation i en egen katalog, som kallas &cvs;-roten. Det första steget för att ställa in &cvs; för det nya projektet, är alltså att tala om för &kdevelop; var roten finns.

Lokal &cvs;-rot. Det finns två grundläggande möjligheter. Antingen vill du använda en lokal CVS-databas, eller använder du en databas som finns på en fjärrserver. Om du utvecklar på egen hand, kan du vilja använda &cvs;-databasen som ett sorts säkerhetskopieringssystem på din egen dator. Oftast skapas den i din hemkatalog och ges namnet `cvsroot`. Det kan se ut på följande sätt:

``/home/utveckling/cvsroot`` (där `devel` helt enkelt anger användaren utveckling, bara som ett exempel)

I själva verket är det här en förkortad form. Mer fullständigt ska den lokala &cvs;-roten adresseras med prefixet `:local:`. Den förkortade formen tillåts bara i fallen då filnamnet börjar med ett snedstreck (`/`). Det fullständiga namnet på vår lokala &cvs;-rot i exemplet skulle exakt se ut som: `:local:/home/utveckling/cvsroot`.

Skriv in namnet på &cvs;-rotkatalogen som systemet har ställts in för i fältet CVS-rot. I princip kan du välja vilket namn som helst, och till och med använda flera &cvs;-databaser, men det är lämpligt att behålla &cvs;-roten när den väl har ställts in.

Initiera en ny &cvs;-rot. Om det inte finns en&cvs;-root, ännu kan &kdevelop; ställa in &CVS;-systemet att skapa ett åt dig i den givna katalogen. Markera bara kryssrutan Initiera rot under fältet CVS-rot.

Som sagt, beordrar bara &kdevelop; &CVS;-systemet att initiera en ny &cvs;-rot. Det gör ingenting själv med katalogen. Som tur är, är &cvs; smart nog att kontrollera om &cvs;-rotkatalogen redan finns. Därför gör det ingen skada om du skulle ha markerat Initiera rot för en befintlig &cvs;-rotkatalog.

Fjärr &cvs;-rot. Det finns tillfällen då &cvs;-databasen ska finnas på en fjärrserver, särskilt när flera utvecklare arbetar med samma projekt. Då måste du skriva in &cvs;-rotens webbadress till servern i fältet CVS-rot. Om du till exempel vill komma åt &kde;:s &cvs;-server:

``:pserver:min_inloggning@cvs.kde.org:/home/kde`` (där `min_inloggning` anger inloggningsnamnet som är inställt i ditt &kde; &cvs;-konto)

### Servertyper för fjärr-&cvs;

Det finns i huvudsak två fjärrservertyper för &cvs; med bred användning: pserver som använder ett lösenordssäkrat okrypterat protokoll, och ext-servern som använder krypterad dataöverföring via rsh eller ssh. De skiljs åt av webbadressprefixet de använder:

`:pserver:`

för den okrypterade typen lösenordsskyddad server, och

`:ext:`

för en servertyp krypterad med rsh eller ssh. Till exempel

``:ext:mylogin@cvs.sourceforge.net:/cvsroot/cervisia``

kommer åt &cvs;-roten för det brett använda &cvs;-hanteringsverktyget Cervisia på servern SourceForge.

Om du vill använda en krypterad server via rsh eller ssh för att komma åt &cvs;, måste du tala om för &kdevelop; vilket krypteringsprotokoll som ska användas. Skriv bara in `rsh` eller `ssh` i fältet CVS_RSH på sidan Versionskontrollsystem i Skapa nytt projekt.

Det finns ett problem om du använder en krypterad server för &cvs; inne i &kdevelop;. Se kapitlet Använda CVS för detaljinformation.

### &cvs;-arkivet

Hittills har du talat om för &kdevelop; var &cvs;-roten finns, som hanterar versionsdatabasen och hur den ska kommas åt. Nu måste du tala om för &kdevelop; vilket namn du vill att &CVS; ska använda för att spara dina projektfiler i databasen. Ett sådan ställe där projektfilerna lagras i &cvs;, kallas ett arkiv.

I princip kan du använda vilket namn som helst för projektfilernas &cvs;-arkiv, så länge det uppfyller specifikationerna för att namnge en fil. Oftast använder ändå de flesta utvecklare själva programmets namn. &CVS; bygger en katalog med namnet under &cvs;-roten, därför hittas det enklare om du behåller programnamnet för det.

Skriv bara in arkivnamnet som du vill använda i fältet CVS-arkiv på sidan Versionskontrollsystem under Skapa nytt projekt. I vårt exempel är det `Mitt_program`.

Försäkra dig om att inte använda ett arkiv som redan finns!. &CVS;-systemet varnar inte för duplicerade filer, utan skyfflar in allting som inte producerar en formell konflikt. Du ställer till allting!

### Återstående fält

Det återstår inte mycket arbete. Programguiden har redan ställt in återstående fält åt dig. Mer detaljerat:

Fältet Leverantörstagg används endast av kompatibilitetsskäl. Du kan behålla standardvärdet leverantör som programguiden skrivit in här.

Fältet Meddelande gör det möjligt att skriva in en kommentar om innehållet i &cvs; från början. Använd vilken text du vill, eller behåll bara standardvärdet nytt projekt som programguiden skrivit in.

Utgåvetagg innehåller namnet som används som tagg för det ursprungliga tillståndet för projektet. En sådan tagg namnger ett visst tillstånd i &CVS;-arkivet, som du senare kan använda för att komma åt det tillståndet för utvecklingen. (Se vidare i kapitlet Använda CVS.)

Programguiden har skrivit in standardtaggen start här, som är ett värdigt förslag. Behåll det bara.

Om någon information om versionskontroll är fel, märker &kdevelop; det oftast inte förrän projektet skapas. Det är &CVS;-systemet som hittar felen när det försöker skapa arkivet. Därför måste du hålla ett öga på fönstret Meddelanden i &kdevelop; när projektet skapas under det sista inställningssteget. Om det var något fel med &CVS;, ser du oftast ett felmeddelande som det här:

    * cd '/home/utveckling/test' && cvs -d '/home/utveckling/min_cvsrot' \
      import -m 'nytt projekt' '' 'leverantör' 'start' &&\
      sh /opt/kde3/share/apps/kdevcvs/buildcvs.sh . '' \
      '/home/utveckling/min_cvsrot'
    * cvs [import aborted]: /home/utveckling/min_cvsrot/CVSROOT: No such file or
      directory
    * *** Exited with status: 1 ***

Om det här händer, måste du antingen ställa in &cvs; för hand (&kdevelop; ska ha lyckats initiera dina projektfiler vid detta tillfälle) eller ta bort projektkatalogen och börja om igen med Nytt projekt i menyn Projekt.

Efter du har skrivit in all informationrelaterad till &CVS;, klicka på knappen Nästa > för att fortsätta.

Om du vill rätta ett fel på föregående sida i Skapa nytt projekt, tryck bara på knappen < Tillbaka. Programguiden kommer ihåg dina inställningar på nuvarande sida, så du kan enkelt fortsätta när du kommer tillbaka.

### Ange mallar för deklarationer och källkod

Nästa steg tar dig till en serie sidor, där du kan ställa in vanlig information som du vill inkludera i dina källkods- och deklarationsfiler, om uppgiften i fråga tillåter.

Både deklarationsmallar och källkodsmallar tillhandahålls för C och C++ program, var och en på sin egen sida. För andra språk kanske det bara finns källkodsmallar. I vissa fall ser du till och med att mallsidan är tom.

Om sidan används, fyller programguiden i några vanliga kommentarer i sidhuvudet, som kan se ut så här för ett C++ baserat program:

    /***************************************************************************
     *   Copyright (C) 2003 by Ditt namn                                       *
     *   du@du.se                                                           *
     *                                                                         *
     *   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.             *
     ***************************************************************************/

Andra mallar tillhandahåller liknande information på ett format enligt definitionen av programspråket du vill använda.

Som du kanske märkt, har programhanteringen redan fyllt i viss information som du angav på den fösta sidan Allmänt i dialogrutan Skapa nytt projekt, närmare bestämt innehållet i fälten Upphovsman och E-post. Riktig licensinformation har också infogats, enligt ditt val i kombinationsrutan Licens.

#### Hur mallarna kan redigeras

Mallarna som du ställer in i dialogrutan Skapa nytt projekt behandlas varje gång du talar om för &kdevelop; att skapa en ny källkodsfil och/eller deklarationsfil. Informationen som du anger här, inkluderas längst upp i ett dokumentationshuvud, innan koden börjar.

Du är dock inte begränsad till ren text. &kdevelop; känner till flera variabler, som låter dig inkludera riktig information i filen. Programguiden använda i själva verket just några sådana variabler för att inkludera information om Upphovsman, E-post och Licens i den ursprungliga malltexten.

#### Infoga filinformation från &doxygen;

Om du till exempel vill att dokumentationen av programvarugränssnittet som &doxygen; skapar, ska visa ytterligare information om filens innehåll i listan med filnamn, kan du lägga till följande rader i källkodsfilens mall:

    /**
     * \file $MODULE$.cpp
     * \brief (skriv en kort beskrivning här).
     **/

Så fort du skapar en ny källkodsfil, ersätter &kdevelop; variabeln `$MODULE$` med namnet på den nyskapade filen. Om du till exempel skapar en ny C++ klass som heter `EnEnkelTest`, ser du följande rader i filen `enenkeltest.cpp`:

    /**
     * \file enenkeltest.cpp
     * \brief (skriv en kort beskrivning här).
     **/

Du måste fortfarande tillhandahålla den korta beskrivningen efter nyckelordet \brief, men en del av jobbet har redan gjorts automatiskt åt dig.

#### Textfilen med licensen

Som ett annat exempel skulle du kunna inkludera en explicit referens till licenstexten som du vill använda i mallen. Använd variabeln `$LICENSEFILE$` för detta, och lägg till exempel till följande rad:

    //   Se $LICENSEFILE$ för den fullständiga licenstexten.

Programguiden ersätter `$LICENSEFILE$` med namnet på filen där den fullständiga licenstexten finns, nämligen:

    //   Se COPYING för den fullständiga licenstexten.

för GPL-licensen, eller

    //   Se LICENSE.BSD för den fullständiga licenstexten.

om du bestämmer dig för att använda BSD-license för programmet.

Det finns förstås fler variabler som &kdevelop; känner till. Se avsnittet Redigera mallarna i kapitlet Redigeringsverktyg för att hitta vad som är möjligt.

Mallarna som du definierar här får ingen effekt förrän programguiden skapar det nya projektet. Du hittar informationen längst upp i filerna som du själv skapar under utvecklingsprocessen. När de ursprungliga filerna skapas, använder programguiden några fördefinierade standardmallar. Du måste anpassa de ursprungliga filerna till dina behov för hand.

### Bygg de ursprungliga projektfilerna

Nu är nästan allt klart. På den sista sidan i mallen, har knappen Nästa > ändrats så att den nu lyder Slutför.

Tänk efter innan du klickar på den! Du har fortfarande möjlighet att granska allting genom att använda knappen < Tillbaka upprepade gånger. Eftersom programguiden kommer ihåg all information du hittills matat in, kan det vara lämpligt att ta dig tid att titta tillbaka en gång till. Om du använder lokal CVS, glöm inte att kontrollera namnet på CVS-arkivet igen (det ska inte redan finnas någon underkatalog med det namnet i CVS-rotkatalogen. Om det gör det, försök med ett annat arkivnamn).

Om du någon gång inte vill att det nya projektet ska byggas, avbryt dialogrutan Skapa nytt projekt med knappen Avbryt. Klicka annars på Slutför, och se i fönstret Meddelanden hur programguiden skapar projektet.

Om du vill använda ett versionshanteringssystem (&CVS;), sker det i själva verket två genomgångar. Programguiden bygger först projektkatalogerna och anropar sedan &CVS;-programmet som återstartar fönstret Meddelanden med sitt eget innehåll. Om något fel uppstår i någon av genomgångarna, stannar processen och visar dig motsvarande felmeddelande i fönstret.

I många fall, när det nya projektet har skapats på det här sättet, laddar &kdevelop; automatiskt källkodsfilen eller filerna för en eller fler av de grundläggande viktiga modulerna, så att du kan enkelt börja arbeta. (Vilka källkodsmoduler som visas, om några alls, beror dock på mallen som från början valdes i programguiden.)

Glöm inte att kontrollera vad programguiden tillhandahåller från början. Du kanske till exempel vill ändra ursprunglig information i filhuvuden enligt dina egna mallar. Oftast hittar du dem i underkatalogen `templates` i projektkatalogen. Några enkla kopieringsåtgärder räcker oftast.

Därefter är det lämpligt att du kompilerar det ursprungliga projektet innan du försöker ändra någon kod. I de flesta fall ska den här första kompileringen vara möjlig. På så sätt kan du avgöra om projektet verkligen skapades enligt dina behov. Om det inte gjorde det, ta helt enkelt bort projektkatalogen (i den lokala &CVS;-roten också, om du använder en) och börja om.

Innan du kompilerar det nya projektet för första gången, ta en titt på Projekt Bygginställning. Om det finns tre alternativ som visas: default, optimized och debug, med debug markerat, behåll det för all del, eller använd optimized istället.

På grund av vissa begränsningar i den nuvarande inställningen av autoconf och automake, ska du under inga omständigheter bygga med inställningen default. Det förstör vissa interna kataloginställningar, och gör att `configure` klagar när du senare försöker använda det med bygginställningarna optimized eller debug.

(Det här gäller bara för dessa flervalsmöjligheter. Om programtypen du valde bara tillhandahåller bygginställningen default, ska du förstås använda den.)

## Bakom ridån

Det är alltid lämpligt att titta på utskrivna meddelanden och försöka förstå vad som har hänt. Åtminstone i princip bör du veta vad som ska göras när programguiden skapar det nya projektet. Vi kan inte gå in på detaljer, men ger en översikt över dessa meddelanden för att få en idé om vad som pågick bakom ridån.

Om projektet ställdes in för lokal &CVS;, fick du två uppsättningar med meddelanden, där den första uppsättningen försvann innan du kunde läsa den ordentligt, eftersom &CVS; använde fönstret Meddelanden för sitt eget syfte. Så vi sparade båda följderna i separata körningar: skapade programmet två gånger, en gång utan &CVS;, tog bort katalogen och började om, den här gången med inställning av programmet med &CVS;.

Du bör följa samma procedur om något konstigt hände, och du bara inte kunde fånga meddelanden från det första inställningssteget.

Vi tar en titt i utmatningen under Meddelanden för båda stegen:

- Ställa in programmet samt

- Ställa in &CVS;.

### Ställa in programmet

Om du ställt in Mitt_program som i föregående exempel, ska programguiden ha skrivit ut följande meddelanden (vi arrangerade om utmatningen en del för ökad läsbarhet, och du kan klicka på vilken rad som helst för att gå till beskrivningen av den):

    * perl /opt/kde3/share/apps/kdevappwizard/template-kapp/script \
      --author='Ditt namn' \
      --email='du@du.se' \
      --version='0.1' \
      --appname='Mitt_program' \
      --dest='/home/utveckling/projekt/mitt_program' \
      --source='/opt/kde3/share/apps/kdevappwizard' \
      --license='GPL' \
      --licensefile='COPYING' \
      --filetemplates='h,/tmp/kde-devel/kdevelopcDE5Ja.tmp,\
                       cpp,/tmp/kde-devel/kdevelopsRrLab.tmp'
    * Making destination directory
    * Installing file templates
    * Installing license file
    * Installing admin directory
    * Installing &GNU; coding standard files
    * Installing Docbook template
    * Installing project file
    * Installing application framework
    * Installing application sources
    * Finished
    * *** Success ***

### Ett anropat &perl;-skript

Som du ser på första raden, skapade programguiden ett anrop till ett &perl;-program från inställningarna som du gjorde i dialogrutan Skapa nytt projekt. Det anropade skriptet `script` finns i en katalog som bestäms av typen av programmall du valde i övre delen på sidan Allmänt i dialogrutan Skapa nytt projekt.

I vårt fall finns filen `script` i katalogen `/opt/kde3/share/apps/kdevappwizard/template-kapp/`. Ersätt bara `/opt/kde3/` med &kde;-katalogen på ditt system.

Det här &perl;-skriptet `script` anropas med en följd kommandoradsväljare, alla markerade med prefixet `--`, där programguiden placerar information från de övriga valen du gjorde i dialogrutan Skapa nytt projekt.

Den exakta följden av initieringssteg beror på vilket &perl;-skript som anropades. Om du vill kontrollera det, titta bara i filen `script` som anropades av kommandot `perl` på första raden i fönstret Meddelanden.

Inställningsskripten använder ett antal subrutiner i &perl; samlade i filen `kdevelop.pm`, som du hittar i underkatalogen `share/apps/kdevwizard/template-common/` i din &kde;-installation.

### Programmets baskatalog

När &perl;-skriptet körs, får du en följd meddelanden om vad som ska göras i nästa installationssteg. Först skapas en `målkatalog`. Det är programmets baskatalog, precis det som visades på raden Slutgiltig plats på sidan Allmänt i dialogrutan Skapa nytt projekt. Skriptet använder värdet på väljaren `--dest` i &perl;-kommandot ovan.

### Filmallarna

I nästa steg kopieras filmallarna du ställde in i dialogrutan Skapa nytt projekt till underkatalogen `templates` i denna målkatalog. Som du kan se från väljaren `--filetemplates` anges mallarna i par: Suffixet de används för först, följt av namnet på den tillfälliga fil dit projektguiden har kopierat innehållet i dialogrutans mallsidor. Suffixen används som filnamn där malltexterna lagras.

I vårt exempel, installerades två sådana mallfiler, nämligen `templates/h` för C++ deklarationsfiler och `templates/cpp` för C++ källkodsfiler.

### Licensfilen

På sidan Allmänt i dialogrutan Skapa nytt projekt, valde du licensen som du vill ska gälla för programmet. Programguiden utför två åtgärder baserat på detta. En är licensinformationen som den skrev i mallarna. Den andra åtgärden gör att motsvarande licensfil kopieras till programmets baskatalog.

Väljaren `--licensefile` talar om för &perl;-skriptet `script` vilken licenstextfil som ska kopieras. I vårt exempel kommer filen `/home/utveckling/projekt/mitt_program/COPYING` att ha installerats.

### Administrationskatalogen

&kdevelop; behöver en uppsättning filer för att administrera projektet. De läggs i underkatalogen `admin` i ditt programs baskatalog.

Programguiden skapar underkatalogen `admin` i det här steget, och extraherar standarduppsättningen filer som behövs från det komprimerade arkivet `share/apps/kdevappwizard/template-common/admin.tar.gz` allt från &kde;-katalogen.

&kdevelop; använder alltid samma uppsättning standardfiler för administrativa ändamål. Därför behövs ingen parameter i anropet till &perl;-skriptet `script` för att skapa underkatalogen `admin`.

### Filer i &GNU;:s kodningsstandard

Det finns flera standardfiler som ska distribueras med alla program som följer &GNU; kodningsstandard. &perl;-skriptet `script` hämtar dessa filer från det komprimerade arkivet `share/apps/kdevappwizard/template-common/gnu.tar.gz` i &kde;:s installationskatalog, och anpassar dem enligt informationen som du angav i dialogrutan Skapa nytt projekt.

Efter det här steget hittar du följande filer i programmets baskatalog:

- `AUTHORS`, som från början innehåller information från väljarna `--author` och `--email`.

- `COPYING`, det här är den allmänna &GNU;-licensen, som alla program som följer &GNU; måste innehålla, även om du bestämmer att ditt program ska ha en annan licens.

- `ChangeLog`, från början tom. Du bör protokollföra alla större ändringar här.

- `INSTALL` innehåller generella installationsinstruktioner. Ändra detta om särskild försiktighet eller särskilda procedurer kan behövas för att installera programmet.

- `README`, från början tom. Skriv in all information som användaren bör känna till innan programmet installeras.

- `TODO`, från början tom. Skriv in information om vad som måste göras för att utveckla programmet ytterligare här. Du kan använda detta som ett anteckningsblock för eget syfte, men det är dessutom till stor hjälp när programmet är publicerat för allmänheten.

### Den ursprungliga programdokumentationen

Alla projekt du skapar, kommer att innehålla en ursprunglig DocBook-mall, som du kan använda när du börjar skriva programdokumentationen. I det här steget har &perl;-skriptet `script` skapat underkatalogerna `doc` och `doc/en` i programmets baskatalog med den ursprungliga mallen `doc/en/index.docbook` och några &automake; `Makefile.am` filer, som &kdevelop; senare kan använda för att bygga hjälpsystemfiler.

### Projektfilen

Hittills har det mesta av det allmänna sakerna skapats, det som mer eller mindre finns i alla &kdevelop;-projekt. Med det här steget börjar den mer programspecifika inställningsprocessen. Den kan variera beroende på programtyp du valt. Ta en titt på det verkliga &perl;-skriptet `script` som programguiden anropade åt dig för att skapa det nya programmet, om du vill titta på detaljerna. Vi fortsätter att följa stegen i exemplet som listas ovan.

I det första av dessa steg, kopieras projekthanteringsfilen i &kdevelop; från mallkatalogen, där &perl;-skriptet `script` finns. I vårt fall kopierades filen `share/apps/kdevappwizard/template-kapp/app.kdevelop` till programmets baskatalog och anpassades enligt de val som gjorts i dialogrutan Skapa nytt projekt.

Du kanske vill ta en titt på den resulterande projektfilen, som i vårt fall sparades som `/home/utveckling/projekt/mitt_program.kdevelop`. Den är skriven på XML-format, och kan enkelt visas med Kate eller någon annan texteditor. Men var försiktig så att ingenting ändras, eftersom &kdevelop; är beroende av innehållet.

### Programramverket

Nu är det hög tid att katalogstrukturen och andra underhållsfiler skapas, att lägga det nya programmet i och göra det möjligt att underhålla det. Ett så kallat programramverk skapas i detta steg. Dess struktur beror i grunden på programtyp som du valde i dialogrutan Skapa nytt projekt, men delar av det är nog vanliga för att också hittas i andra projekt.

I vårt fall har följande katalogstruktur skapats i programmets baskatalog `/home/utveckling/projekt/mitt_program/`.

- Underkatalogen `src` är avsedd att innehålla programmets källkodsfiler.

- Underkatalogen `debug` innehåller den kompilerade utmatningen från bygginställningen för avlusning. (Se kapitlet Bygginställningar för att lära dig mer om detta.) Som namnet anger, ska du använda den här katalogen för avlusningssyfte.

- Underkatalogen `optimized` innehåller den kompilerade utmatningen från den optimerade bygginställningen. Du bör testa en optimerad version av programmet därifrån.

- Underkatalogen `po` är avsett för översättningssyften. Det kommer att innehålla filer som kallas Portable Object (`.po`-filer) och mallar (`.pot`-filer), som behandlas av ett översättningsprogram, som t.ex. Kbabel.

Alla dessa kataloger förblir inte tomma, utan fylls med en följ av `Makefile` och andra filer som &kdevelop; använder för att behandla programmets källkod. Några ursprungliga ikoner för det nya programmet har också placerats i underkatalogen `src`, om nödvändigt. I vårt fall hittar du två stycken: `src/hi16-app-mitt_program.png` och `src/hi32-app-mitt_program.png` som båda innehåller vanliga &kde;-programikoner.

### Installerad programkällkod

Ramverket kommer till sist användas för att lägga till ursprungliga källkodsfiler för det nya projektet i katalogen `src`. De verkliga filerna beror helt och hållet på programtypen du valde i dialogrutan Skapa nytt projekt. Du ser snart själv, eftersom det här är vad du verkligen måste arbeta med.

### Ställa in &CVS;

Låt oss nu ta en titt på vad fönstret Meddelanden innehåller när programguiden fortsätter att bygga vårt projektexempel. Om inget fel uppstod under första genomgången, återställs innehållet i Meddelanden för att skapa det lokala &cvs;-arkivet.

Som tidigare formaterade vi om de utskrivna raderna lite grant för ökad läsbarhet. Vi tog också bort några onödiga rader (där punkterna . . . finns).

    * cd '/home/utveckling/mitt_program' \
      && cvs -d '/home/utveckling/cvsroot' \
             import -m 'nytt projekt' \
                    'Mitt_program' \
                    'leverantör' \
                    'start' \
      && sh /opt/kde3/share/apps/kdevcvs/buildcvs.sh . \
                                                     'Mitt_program' \
                                                     '/home/utveckling/cvsroot'
      . . .
    * N Mitt_program/NEWS
    * N Mitt_program/TODO
    * N Mitt_program/README
      . . .
    * N Mitt_program/admin/configure.in.bot.end
    * N Mitt_program/templates/h
    * N Mitt_program/templates/cpp
    *
    * No conflicts created by this import
    *
    * *** Success ***

Som du ser från den första meddelanderaden, skapade programguiden en ny skalkommandorad som styr arbetet som &cvs; ska göra. Först går skalet till den nyskapade baskatalogen för programmet, för att använda det som standardkatalog för följande steg.

### Bygga &CVS;-arkivet

På den andra delen av kommandoraden, anropas &CVS;-programmet för att importera det ursprungliga projektinnehållet till det önskade arkivet. Återigen styrs arbetet i detalj av ett antal kommandoradsväljare i anropet till &CVS;-programmet.

- `-d '/home/utveckling/cvsroot'`: väljaren `-d` talar om för &CVS; vilken rotkatalog som ska användas. I vårt fall är det den lokala &cvs;-roten som finns i `/home/utveckling/cvsroot`.

- `import`: Talar om för &CVS;-programmet vilken åtgärd som ska utföras med roten. Vi vill importera filer till &cvs;-databasen. För att åstadkomma det, måste kommandot `import` ha några egna väljare:

  - `-m 'nytt projekt'`; Väljaren `-m` ger en meddelandetext till import för åtgärden. Den kommer att lagras i databasen, och kan senare hämtas för att identifiera data som lagrades i det här steget. I vårt fall anger `nytt projekt` att vi lagrar våra första filer i databasen.

  - `'Mitt_program'`: Den andra väljaren talar om för &CVS; vilket arkiv som ska användas. Om det inte finns, skapas det innan filimportåtgärderna. i det här fallet skapas arkivet `Mitt_program`.

  - `'leveratör'`: Den följande väljaren är en tagg, ett symboliskt namn som markerar en följd av filer i katalogen. Det finns flera betydelser en sådan tagg kan ha (se Använda CVS för mer information). Den här markerar i princip hela gruppen med filer som någonsin lagras i det här arkivet i framtiden. Den är inte av någon särskild nytta för oss, så `leveratör` är ett lika bra namn som något annat.

  - `'start'` är en annan tagg. Den markerar utgåvan, med enkla ord en följd av senare sparade filer som hör ihop. Vi använder `start` här, en beskrivning som passar in på användningen av den här ursprungliga följden.

### De importerade filerna

&CVS;-programmet skapar arkivet, och börjar sedan importera alla filer från katalogen `/home/utveckling/projekt/mitt_program`. Det rapporterar därefter alla filer som laddas. Det är innehållet i en hel mängd rader med `N` som följer i fönstret Meddelanden. Bokstaven `N` anger att filen är ny och importerades till arkivet.

Beroende på det nya programmets typ finns det en hel del av raderna med `N`. Vi avkortade utmatningen, för att bara visa den första och de tre sista raderna som ett exempel.

### Meddelande att &CVS; lyckades

&CVS; rapporterar alltid när en åtgärd utförts med lyckat resultat. I vårt fall skrevs meddelandet `No conflicts created by this import` ut, följt av den allmänna raden `*** Success ***` eftersom ingen ytterligare åtgärd behövde utföras.

Det skulle kunnat finnas några felmeddelanden om filer med konflikter om arkivet redan fanns, eftersom &CVS; kontrollerar filinnehållet enligt vissa formella kriterier, och rapporterar alla konflikter som det möjligen hittar.

### Bygga &cvs; administrativa poster

&CVS;-importåtgärden är avslutat i detta ögonblick. Arkivet har skapats, och alla filer vi vill behålla har lagrats i databasen. Ändå så återstår mer arbete, eftersom &CVS;-programmet behöver ha viss administrativ information i varje katalog under programmet. Det använder informationen senare, för att kommunicera med CVS-roten och arkivet.

Om vi arbetade enbart med &CVS;, skulle vi behöva ge en möjlighet för &CVS; att lagra informationen i arbetskatalogen. Vi skulle till exempel kunna checka ut filerna igen i en tom baskatalog, då &CVS; automatiskt skulle utföra alla administrativa åtgärderna tillsammans med de utcheckade filerna.

Det finns ett enklare sätt i &kdevelop;, som tur är. Det tillhandahåller skalskriptet `buildcvs.sh` i katalogen `/opt/kde3/share/apps/kdevcvs/` (igen, ersätt `/opt/kde3` med &kde;:s installationskatalog), som programguiden anropar efter &CVS;-programmet har utfört sitt arbete med lyckat resultat.

Skriptet `buildcvs.sh` skapar i huvudsak en `CVS`-underkatalog i varje katalog i programmets stomme. Var och en av dessa `CVS`-underkataloger innehåller följande tre filer:

- `Root` innehåller namnet på servern där &cvs;-roten finns. I vårt fall är det den lokala roten `/home/utveckling/cvsroot`. Orsaken till detta är att alltid samma arkiv ska användas för filerna, eftersom &CVS; inte lagrar hela filerna, utan bara skillnaderna för följande delar. Det sparar mycket diskutrymme, men gör det nödvändigt att all följande information hålls samman under alla omständigheter.

- `Repository` tjänar samma syfte. &CVS; har namnet på arkivet som ska användas här, i vårt fall `Mitt_program`.

- `Entries` innehåller namnen och en del annan information om filerna som &CVS; tar hand om i katalogen. Det beror på att &CVS; inte nödvändigtvis lägger alla programfiler i arkivet. Du kan tala om vilka filer som ska lagras, och vilka som ska ignoreras. Denna information finns i filen `Entries`.

All denna möda är nödvändig eftersom &CVS; arbete är katalogbaserat. Eftersom &CVS; tidigare lagrade alla filer i ramverket `Mitt_program`, söker skriptet `buildcvs.sh` helt enkelt igenom alla kataloger och lägger till namnen på alla programfiler som det hittar i motsvarande fil `CVS/Entries`.

Skriptet kör utan utmatning, och avslutas bara utan några fler rader i fönstret Meddelanden, när arbetet är klart.