path: root/tde-i18n-sv/docs/tdevelop/tdevelop/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
>Stefan</firstname
> <surname
>Asserhäll</surname
> <affiliation
><address
><email
>stefan.asserhall@comhem.se</email
></address
></affiliation
> <contrib
>Översättare</contrib
></othercredit
> 
</authorgroup>
</chapterinfo>

<title
>Komma igång med &tdevelop;: En guidad tur</title>

<para
>När du nu har installerat &tdevelop;s integrerade utvecklingsmiljö, hur ska du använda den på ett bra sätt? Eftersom det här är ett komplext program, kan inlärningskurvan vara något brant, särskilt om du inte redan är van vid den här sortens integrerade utvecklingsmiljö.</para>

<para
>Vi försöker att göra inlärningskurvan mindre brant genom att stegvis gå igenom hur ett enkelt KDE C++ program skapas. Därigenom tar vi en (översiktlig) titt på:</para>

<simplelist>
<member
><link linkend="gettingstarted-overview"
>En första titt: Elementen i användargränssnittet hos den integrerade utvecklingsmiljön &tdevelop;.</link
></member>
<member
><link linkend="gettingstarted-configure"
>Utföra vissa inledande inställningar.</link
></member>
<member
><link linkend="gettingstarted-new"
>Hur man skapar ett nytt projekt.</link>
</member>
<member
><link linkend="gettingstarted-edit"
>Några tips om hur man hanterar dokument.</link
></member>
<member
><link linkend="gettingstarted-compile"
>Hur man kompilerar programmet i projektet.</link
></member>
<member
><link linkend="gettingstarted-extend"
>Hur man lägger till klasser och andra saker i projektet.</link
></member>
<member
><link linkend="gettingstarted-debug"
>Vad man ska göra för att avlusa programmet.</link
></member>
<member
><link linkend="gettingstarted-doc"
>Några grundläggande verktyg för att bygga program eller användardokumentation.</link
></member>
<member
><link linkend="gettingstarted-keys"
>Sist men inte minst, snabbtangenter</link
></member>
</simplelist>

<para
>Innan vi börjar, måste ett viktigt begrepp klargöras.</para>

<formalpara>
<title
>Vad kan man förvänta sig?</title>
<para
>Som sagt är &tdevelop; en <emphasis
>integrerad utvecklingsmiljö</emphasis
>. Det betyder väsentligen att &tdevelop; inte själv är ett utvecklingsverktyg, utan snarare ett grafiskt gränssnitt för att enkelt komma åt ett omfattande antal utvecklingsverktyg, där många i själva verket skulle kräva komplicerade tangentbordskommandon om de kördes i en textterminal.</para>
</formalpara>

<para
>Även om &tdevelop; förenklar många av dessa programmeringsuppgifter, återstår ändå mycket av komplexiteten i denna uppsättning verktyg, vilket betyder att för en fullständig förståelse av den integrerade utvecklingsmiljön &tdevelop; måste du ändå begripa dig på verktygen som verkligen körs i bakgrunden.</para>

<para
>Därför kan vi inte lära dig hur man skapar programvara, utan snarare introducera några av de sätt &tdevelop; konstruerats för att förenkla denna process. Om du vill lära dig mer om vad en integrerad utvecklingsmiljö är avsedd för, kan du ta en titt på den historiska översikten <link linkend="unixdev"
>Utveckling på &UNIX;</link
>, i synnerhet kapitlet <link linkend="unixdev-ide"
>Integration av koncept och verktyg</link
>.</para>

<note>
<para
>Följande beskrivning gäller normalfallet, där &tdevelop; startar med <guilabel
>Förenklat IDEA-fönsterläge</guilabel
>. Om du redan har bytt till ett annat användargränssnitt, kanske inte vissa objekt finns enligt beskrivningen, eller beter sig något annorlunda. Om du inte är säker på vilket användargränssnitt som &tdevelop; för närvarande använder, kontrollera i dialogrutan <menuchoice
><guimenu
>Inställningar</guimenu
> <guimenuitem
>Anpassa KDevelop...</guimenuitem
> <guimenuitem
>Användargränssnitt</guimenuitem
></menuchoice
>.</para>
</note>

<sect1 id="gettingstarted-overview">
<title
>Den allra första titten på &tdevelop;</title>

<para
>Här handlar det enbart om vad du ser när du först startar &tdevelop;. Du finner preliminär information om:</para>

<simplelist>
<member
><link linkend="gettingstarted-overview-basic"
>Vad är det som syns på ytan?</link
></member>
<member
><link linkend="gettingstarted-overview-help"
>Hur man får hjälp.</link
></member>
<member
><link linkend="gettingstarted-overview-menu"
>Vad finns i menyerna?</link
></member>
<member
><link linkend="gettingstarted-overview-tools"
>Vad är verktygsvyerna till för?</link
></member>
</simplelist>

<sect2 id="gettingstarted-overview-basic">
<title
>På ytan</title>

<para
>När du startar &tdevelop; allra första gången ser du en skärm som liknar den här:</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="empty-ide.png" format="PNG"/>
</imageobject>
<caption>
<para
>Ursprunglig layout i &tdevelop;</para>
<para
>(I själva verket är &tdevelop;s ursprungliga fönster större, men elementen du ser är samma.)</para>
</caption>
</mediaobject>
</screenshot>

<formalpara>
<title
>Arbetsområde och verktygsflikar</title>
<para
>I det här ursprungliga fallet använder &tdevelop; det så kallade <link linkend="uimodes-survey"
>IDEA-användargränssnittet</link
>. Ett maximalt stort arbetsområde omges till vänster, under, och till höger av en serie knappar som fungerar på liknande sätt som flikarna på en skärm med flikar. Om du klickar på en av flikarna visas ett så kallat <emphasis
>verktygsvyfönster</emphasis
>, som låter dig arbeta med en speciell aktivitet.</para>
</formalpara>

<formalpara>
<title
>Menyer och verktygsrader</title>
<para
>Längst upp finns den vanliga menyraden, följd av flera rader med verktygsrader, där vissa är tomma från början. De förses med knappar så fort ett projekt har öppnats för verkligt arbete.</para>
</formalpara>

<formalpara>
<title
>Statusrad</title>
<para
>Till sist finns en statusrad längst ner i fönstret, som visar kortfattad information om flera aktiviteter.</para>
</formalpara>
</sect2>

<sect2 id="gettingstarted-overview-help">
<title
>Hur man får hjälp</title>

<para
>Förutom menyn <guimenu
>Hjälp</guimenu
>, som erbjuder svar på specifika frågor, tillhandahåller statusraden och två olika sorters verktygstips en del snabbinformation.</para>

<formalpara>
<title
>Vad gör det här menyalternativet?</title>
<para
>När du placerar muspekaren över ett menyalternativ, visas oftast kortfattad information i statusraden. Även om det i de flesta fall bara upprepar alternativets namn, tillhandahålls ibland ytterligare information om menyalternativets syfte.</para>
</formalpara>

<formalpara>
<title
>Vad är det här objektets namn?</title>
<para
>För många objekt visas ett kort verktygstips med funktionsnamnet när du håller markören över det några sekunder. Det är användbart för snabb orientering i verktygsrader eller verktygsvyflikar i IDEA-läge, när den integrerade utvecklingsmiljön har ställts in att bara visa ikoner på dessa knappar.</para>
</formalpara>

<formalpara>
<title
>Vad gör det här objektet?</title>
<para
>Mer information är tillgänglig genom utökad hjälp med verktygstips för många objekt i den integrerade utvecklingsmiljön. Välj <menuchoice
><guimenu
>Hjälp</guimenu
> <guimenuitem
>Vad är det här?</guimenuitem
></menuchoice
> eller tryck på <keycombo
><keycap
>&Shift;</keycap
><keycap
>F1</keycap
></keycombo
>, välj därefter objektet som du vill veta mer om med markören i form av ett frågetecken. Du kan också visa vilken meny som helst på detta sätt, och klicka på ett visst menyalternativ (både aktiva och inaktiva) för att se om mer information finns tillgänglig.</para>
</formalpara>
</sect2>

<sect2 id="gettingstarted-overview-menu">
<title
>Vad finns i menyerna?</title>

<para
>Det finns tio menyer som kan väljas i menyraden. De flesta förses med alla alternativ när ett projekt väl har öppnats för verkligt arbete, medan andra kräver att att minst ett dokument är öppnat. I korthet tillåter de följande sorters åtgärder.</para>

<note>
<para
>Det här är bara en översikt. För en detaljerad beskrivning av menyerna, se <link linkend="commands"
>Kommandoreferensen</link
>.</para>
</note>

<variablelist>
<varlistentry>
<term
><guimenu
>Arkiv</guimenu
></term>
<listitem>
<formalpara>
<title
>Vanliga åtgärder</title>
<para
>Detta är ganska standardmässigt. Det tillåter att dokumentfiler skapas, öppnas, sparas, skrivs ut och stängs, samt att avsluta programmet &tdevelop; som vanligt.</para>
</formalpara>

<formalpara>
<title
>Återställ alla</title>
<para
>Låter dig återställa alla senaste ändringar som ännu inte sparats, genom att ladda filen igen från disk. Det fungerar för alla filer du redigerar, inte bara de som ingår i ett projekt.</para>
</formalpara>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Redigera</guimenu
></term>
<listitem>
<para
>Den här menyn är bara användbar om ett dokument är öppnat.</para>

<formalpara>
<title
>Vanliga åtgärder</title>
<para
>Tillhandahåller de vanliga åtgärderna för att ångra, göra om och klippa ut, kopiera eller klistra in. Dessutom tillåter den att markera textblock på olika sätt.</para>
</formalpara>

<formalpara>
<title
>Sök och ersätt</title>
<para
>Det finns två mycket kraftfull sökfunktioner tillgängliga, <menuchoice
><guimenu
>Redigera</guimenu
> <guimenuitem
>Sök i filer</guimenuitem
></menuchoice
> och <menuchoice
><guimenu
>Redigera</guimenu
> <guimenuitem
>Sök-välj-ersätt...</guimenuitem
></menuchoice
>. Förutom de vanliga sök- och ersättningsfunktionerna begränsade till det nuvarande dokumentet, kan du dessutom utföra globala sök- och ersättningsåtgärder på en gång.</para>
</formalpara>

<formalpara>
<title
>Avancerad textredigering</title>
<para
>Det finns möjlighet att formatera om nuvarande dokument och att automatiskt komplettera delvis inskriven text på olika sätt.</para>
</formalpara>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Visa</guimenu
></term>
<listitem>
<para
>Som menyn <guimenu
>Redigera</guimenu
>, är den här menyn bara användbar om ett projekt är öppet. I detta fall är (bland annat) följande alternativ tillgängliga:</para>

<formalpara>
<title
>Navigeringshistorik</title>
<para
>Byt fram och tillbaka mellan dokumenten du tittat på, etc.</para>
</formalpara>

<formalpara>
<title
>Felspårning</title>
<para
>Navigera till källkodsraderna för fel som stöttes på i den senaste kompilerings- eller byggprocessen.</para>
</formalpara>

<formalpara>
<title
>Åtgärder som hör ihop med editorn</title>
<para
>Visa alternativ i menyn <guimenu
>Visa</guimenu
> styr utseendet och vyn för editorn du använder. När det gäller &kate;-programdelen (den inbäddade avancerade texteditorn) finns följande alternativ tillgängliga:</para>
</formalpara>

<itemizedlist>
<listitem>
<para
>Styr radbrytningsbeteendet i dokumentfönstret.</para>
</listitem>
<listitem>
<para
>Visa eller dölj olika kolumner längs dokumentfönsterkanter: radnummer, ikoner och dessutom bokmärken i rullningslisten.</para>
</listitem>
<listitem>
<para
>Styr visning av ihopdragna (tillfälligt dolda) avsnitt i en källkodstext.</para>
</listitem>
</itemizedlist>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Projekt</guimenu
></term>
<listitem>
<para
>Allt arbete i &tdevelop; är baserat på <emphasis
>projekt</emphasis
>, som i grunden samlar källkodsfiler, bygghanteringsfiler och annan information i en projektkatalog. Med den här menyn bestämmer du vilket projekt som används, vilka egenskaper det har och några andra hanteringsalternativ. I synnerhet:</para>

<formalpara>
<title
>Öppna ett projekt</title>
<para
>Tillåter att nya projekt skapas, befintliga öppnas och import av projekt från andra miljöer.</para>
</formalpara>

<formalpara>
<title
>Projektalternativ</title>
<para
>Gör det möjligt att definiera en hel mängd olika projektegenskaper.</para>
</formalpara>

<formalpara>
<title
>Klasshantering</title>
<para
>Lägg till nya klasser i projektet och gå igenom arvträdet för en klass.</para>
</formalpara>

<formalpara>
<title
>Distribuera projekt</title>
<para
>Hjälper till att bygga paket för distribution av projektet.</para>
</formalpara>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Bygg</guimenu
></term>
<listitem>
<para
>Den här menyn handlar helt och hållet om att kompilera och dokumentera projektet. Sålunda är den bara användbar när ett projekt verkligen är öppet. I detta fall tillhandahåller den följande alternativ:</para>

<formalpara>
<title
>Kompilera, länka och köra</title>
<para
>Tillåter att hela projektet eller delar av det kompileras och länkas, samt kör programmet inifrån den integrerade utvecklingsmiljön.</para>
</formalpara>

<formalpara>
<title
>Förberedande byggåtgärder</title>
<para
>Det här beror i själva verket på byggsystemet som du använder för projektet. I fallet med automake-projekt tillåter de att köra <filename
>Makefile.cvs</filename
> och <filename
>configure</filename
> enskilt. Det finns också möjlighet att ta bort skapade filer från projektet, på olika nivåer.</para>
</formalpara>

<formalpara>
<title
>Installera programmet</title>
<para
>Tillåter att programmet installeras, både i lokala kataloger och i systemkataloger som bara är tillgängliga för systemadministratören.</para>
</formalpara>

<formalpara>
<title
>Dokumentation av programmeringsgränssnittet</title>
<para
>Bygg eller ta bort dokumentation av projektets programmeringsgränssnitt baserad på doxygen, enligt definitionen i projektalternativen.</para>
</formalpara>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Avlusa</guimenu
></term>
<listitem>
<para
>Även om menyn fylls i så fort ett projekt är aktivt, är den förstås bara användbar om själva projektet tidigare har kompilerats med avlusningsinformation (det ställs i huvudsak in under <menuchoice
><guimenu
>Projekt</guimenu
> <guimenuitem
>Projektinställningar...</guimenuitem
></menuchoice
>). I detta fall finns följande alternativ tillgängliga:</para>

<formalpara>
<title
>Vanliga avlusningsåtgärder</title>
<para
>Den första delen i menyn <guimenu
>Avlusa</guimenu
> tillhandahåller ett grafiskt gränssnitt till GDB, &GNU;:s symboliska avlusare. Den gör det möjligt att starta och stoppa programmet i avlusaren och stega igenom det på olika sätt.</para>
</formalpara>

<formalpara>
<title
>Brytpunkter</title>
<para
>&tdevelop; tillhandahåller flera möjligheter att ange brytpunkter i programmets källkod. Ett är genom användning av menyalternativet <guimenuitem
>Växla brytpunkt</guimenuitem
>.</para>
</formalpara>

<formalpara>
<title
>Avancerad avlusning</title>
<para
>Andra alternativ i menyn <guimenu
>Avlusa</guimenu
> tillåter mer avancerad analys av programmet. Använd <keycombo
>&Shift; <keycap
>F1</keycap
></keycombo
> för att få mer information om deras syfte.</para>
</formalpara>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Skript</guimenu
></term>
<listitem>
<para
>Du kan anropa diverse skript från menyn för att enklare åstadkomma långtråkiga ändringar av texten i editorfönstret som för närvarande används. Tillgängliga åtgärder beror dock på skriptet som väljes. </para>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Fönster</guimenu
></term>
<listitem>
<para
>Det här är ganska standardmässigt. Du kan välja alla öppna dokumentfönster samt stänga ett eller flera dokumentfönster här. Du kan till och med välja en uppsättning dokumentfönster som ska stängas på en gång.</para>

<para
>Beroende på editorinsticksprogrammet du använder, kanske det också finns andra menyalternativ. Kate, det förvalda editorinsticksprogrammet, tillåter exempelvis också att editorfönstret delas horisontellt eller vertikalt.</para>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Verktyg</guimenu
></term>
<listitem>
<para
>&tdevelop; är mycket anpassningsbart. Du kan välja din favoriteditor för dokument samt tillhandahålla externa och insticksverktyg för att utöka funktionerna i den grundläggande integrerade utvecklingsmiljön. Menyn <guimenu
>Verktyg</guimenu
> avspeglar de flesta av dessa inställningar.</para>

<formalpara>
<title
>Avancerad redigering</title>
<para
>Den övre delen av menyalternativ i <guimenu
>Verktyg</guimenu
> tillhandahålls av editorinsticksprogrammet som används. Du kan välja din favoriteditor via <menuchoice
><guimenu
>Inställningar</guimenu
> <guimenuitem
>Anpassa KDevelop...</guimenuitem
> <guilabel
>Editor</guilabel
></menuchoice
>. Så fort en redigerbar dokumentfil väljes, tillhandahåller den övre delen av menyn <guimenu
>Verktyg</guimenu
> avancerade redigeringskommandon, specifika för editorn som används.</para>
</formalpara>

<formalpara>
<title
>Hantering av webbsidor</title>
<para
>Om det aktiva dokumentfönstret innehåller en HTML-sida (som t.ex. visas från <guilabel
>Dokumentation</guilabel
>), visar <guimenu
>Verktyg</guimenu
> ytterligare menyalternativ som tillhandahåller olika sätt att hantera webbsidor.</para>
</formalpara>

<formalpara>
<title
>Övriga verktyg</title>
<para
>Oftast finns det en mängd andra alternativ enligt de verktyg som för närvarande är tillgängliga. Använd <keycombo
>&Shift;<keycap
>F1</keycap
></keycombo
> för att få mer information om deras syfte.</para>
</formalpara>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Inställningar</guimenu
></term>
<listitem>
<para
>Den här menyn låter dig visa och dölja menyraden, verktygsrader och statusraden. Dessutom kan du anpassa genvägar, verktygsrader, underrättelser, editorn och &tdevelop;s allmänna beteende.</para>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Hjälp</guimenu
></term>
<listitem>
<para
>Här kan du visa KDevelops handbok, slå upp begrepp i diverse dokumentationsfiler, visa manualsidor (det traditionella Unix manualformatet) och infosidor (GNU manualformatet). Dessutom kan du rapportera fel och få viss information om den nuvarande versionen av KDevelop och dess upphovsmän.</para>
</listitem>
</varlistentry>
</variablelist>
</sect2>

<sect2 id="gettingstarted-overview-tools">
<title
>Vad är verktygsvyerna till för?</title>

<para
>Med användargränssnittet IDEA-fönsterläge omges arbetsytan av tre rader med knappar, så kallade <emphasis
>verktygsvyflikar</emphasis
>. De gör att man kan komma åt <emphasis
>verktygsvyfönster</emphasis
> som åstadkommer viktiga uppgifter under programvaruutvecklingen. Var och en av dessa tre rader verktygsvyer tjänar olika huvudsyften.</para>

<itemizedlist>
<listitem>
<formalpara>
<title
>Vänster sida</title>
<para
>Ger möjlighet att komma åt verktyg för navigering och urval.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Underkanten</title>
<para
>Vyerna visar meddelanden som skapas av olika verktyg.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Höger sida</title>
<para
>Ger möjlighet att komma åt dokumentation och verktyg för källkodshantering.</para>
</formalpara>
</listitem>
</itemizedlist>

<para
>Antal verktygsvyflikar som visas kommer att ändras när ett projekt väl har öppnats att arbeta med. Fler verktyg för att arbeta med projektet kommer då att vara tillgängliga. Det verkliga antalet verktygsvyer beror på de <link linkend="plugin-tools"
>insticksverktyg</link
> som för närvarande är tillgängliga i &tdevelop;. Du hittar mer om detta ämne i kapitlet <link linkend="setup"
>Anpassa KDevelop</link
>.</para>

<para
>För närvarande, när inget projekt är öppet, och det normala antalet insticksverktyg är laddade, finns följande verktygsvyer. Genom att klicka på en flik öppnas eller stängs verktygsvyns fönster.</para>

<variablelist>
<varlistentry>
<term
>Navigering och urval</term>
<listitem>
<formalpara>
<title
>Filväljare</title>
<para
>Tillhandahåller en ruta för att navigera i katalogträdet och välja filer att arbeta med precis som du gör i &konqueror;. Att klicka på en fil öppnar den i ett lämpligt redigeringsfönster på arbetsytan. Ett högerklick i filväljarens område gör att en meny för navigering och filhantering visas.</para>
</formalpara>

<formalpara>
<title
>Fillista</title>
<para
>Listar filer som för närvarande är öppna. Att klicka på en fil väljer oftast dess redigeringsfönster på arbetsytan. Använd det för att snabbt navigera bland ett stort antal öppna filer. Dessutom ger vyn ett sätt att organisera öppna filer i olika <emphasis
>sessioner</emphasis
>. Det är särskilt användbart i mycket stora och komplexa projekt, för att hjälpa utvecklaren att koncentrera sig på olika uppgifter. Att högerklicka på en fil gör att en filhanteringsmeny dyker upp.</para>
</formalpara>
</listitem>
</varlistentry>

<varlistentry>
<term
>Visning av meddelanden</term>
<listitem>
<formalpara>
<title
>Program</title>
<para
>Visar utmatningen från ett program som startas inifrån &tdevelop;.</para>
</formalpara>

<formalpara>
<title
>Jämförelse</title>
<para
>Används för att visa innehållet i filer med programfixar. Visar utmatningen från verktyget för visning av skillnader, som startas från menyn <menuchoice
><guimenu
>Verktyg</guimenu
> <guimenuitem
>Visning av skillnader...</guimenuitem
></menuchoice
>.</para>
</formalpara>

<formalpara>
<title
>Meddelanden</title>
<para
>Visar meddelanden som skapas av byggverktygen som anropas inifrån &tdevelop;, oftast från menyn <guimenu
>Bygg</guimenu
>.</para>
</formalpara>

<formalpara>
<title
>Sök i filer</title>
<para
>Visar listan med objekt som hittas av den allmänna sökfunktionen som startas från menyn <menuchoice
><guimenu
>Redigera</guimenu
> <guimenuitem
>Sök i filer...</guimenuitem
></menuchoice
>. Genom att klicka på en rad här, öppnar automatiskt filen på angiven position i ett redigeringsfönster.</para>
</formalpara>

<formalpara>
<title
>Ersätt</title>
<para
>Listar resultat av den allmänna sök- och ersättningsfunktionen som startas från menyn <menuchoice
><guimenu
>Redigera</guimenu
> <guimenuitem
>Sök-välj-ersätt...</guimenuitem
></menuchoice
>. I den vyn kan du för varje hittat objekt bestämma dig för om du verkligen vill ersätta det eller inte.</para>
</formalpara>
<note>
<para
>Den allmänna sök- och ersättningsfunktionen är i själva verket bara tillgänglig efter ett projekt har laddats i &tdevelop;. Annars är verktyget i menyn <menuchoice
><guimenu
>Redigera</guimenu
> <guimenuitem
>Sök-välj-ersätt</guimenuitem
></menuchoice
> inte aktiverat.</para>
</note>

<formalpara>
<title
>Konsol</title>
<para
>Öppnar ett terminalemuleringsfönster som liknar <application
>Konsole</application
> i &kde; där du kan använda tangentbordskommandon med ett traditionellt &UNIX; kommandoradsgränssnitt.</para>
</formalpara>
</listitem>
</varlistentry>

<varlistentry>
<term
>Dokumentation och källkodshantering</term>
<listitem>
<formalpara>
<title
>Dokumentation</title>
<para
>&tdevelop; ger tillgång till en mängd dokumentation via det här verktyget. Här kan du komma åt dokumentfiler, oftast direkt från en annan dator, på ett strukturerat sätt. Det finns flera sätt att direkt komma åt värdefull information från handböcker om &kde; och &Qt;.</para>
</formalpara>

<para
>Se kapitlen <link linkend="documentation"
>Dokumentation</link
> och <link linkend="setup-docu"
>Anpassa dokumentationen</link
> för mer information.</para>

<formalpara>
<title
>Kodsnuttar</title>
<para
>Verktyget låter dig lagra utvald text permanent för senare användning vid andra redigeringsomgångar. Det är ett mycket flexibelt verktyg, eftersom alla textsnuttar som lagras här kan innehålla en uppsättning variabler, som får sina verkliga värden när en sådan textsnutt infogas i någon annan text.</para>
</formalpara>
<para
>Mer information om detta är tillgänglig i kapitlen <link linkend="editing-snippets"
>Kodsnuttar</link
> och <link linkend="setup-snippets"
>Ställa in verktyget för kodsnuttar</link
>.</para>
</listitem>
</varlistentry>
</variablelist>
</sect2>
</sect1>

<sect1 id="gettingstarted-configure">
<title
>Några inställningar</title>

<para
>Innan vi påbörjar det första exempelprojektet på riktigt, bör vi anpassa &tdevelop;s beteende efter våra behov. Även om de flesta standardinställningarna redan är lämpliga, finns det några ställen som det vore bra att ändra.</para>

<note>
<para
>Om du vill veta mer om inställning av &tdevelop;, ta en titt på kapitlet <link linkend="setup"
>Anpassa KDevelop</link
>.</para>
</note>

<sect2 id="gettingstarted-configure-general">
<title
>Några allmänna inställningar</title>

<para
>Klicka på menyn <menuchoice
><guimenu
>Inställningar</guimenu
> </menuchoice
> för att anpassa &tdevelop; och välj <menuchoice
><guimenuitem
>Anpassa KDevelop...</guimenuitem
></menuchoice
>. Dialogrutan <guilabel
>Anpassa KDevelop</guilabel
> dyker upp, och visar följande inställningssida, <guilabel
>Allmänt</guilabel
>, till höger.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="configure-general.png" format="PNG"/>
</imageobject>
<caption>
<para
>Den allmänna inställningsdialogrutan i &tdevelop;</para>
</caption>
</mediaobject>
</screenshot>

<para
>De flesta standardinställningarna är ok, men två av inställningarna kanske du vill ändra.</para>

<formalpara>
<title
>Standardprojektkatalog</title>
<para
>När &tdevelop; startas för första gången är den troligen förinställd till din hemkatalog. De flesta föredrar dock en särskild projektkatalog för programvaruutveckling. Ändra textrutan till huvudkatalogen för utveckling som du föredrar. Du kan välja det i katalogträdet om du klickar på knappen <guilabel
>Öppna fildialog</guilabel
> markerad med en katalogikon, till höger om textrutan.</para>
</formalpara>

<para
>I vårt exempel antar vi (i brist på bättre) en användare som kallas <filename class="directory"
>utvecklare</filename
>. Ersätt därför alltid <quote
>utvecklare</quote
> med ditt användarnamn. Vår utvecklare utnyttjar huvudkatalogen <filename class="directory"
>/home/utvecklare/projekt</filename
> för själva utvecklingen. Återigen, ersätt <filename class="directory"
>projekt</filename
> med namnet på din utvecklingskatalog. </para>

<para
>&tdevelop; skapar normalt en egen underkatalog under huvudkatalogen för varje nytt projekt du skapar. Alla filer i ett projekt som till exempel heter <quote
>Hello</quote
> kommer i vårt fall att placeras i katalogen <filename class="directory"
>/home/utvecklare/projekt/hello</filename
>.</para>

<para
>Du kan förstås tillfälligt överskrida dessa kataloginställningar om du behöver det. Se kapitlet <link linkend="applicationwizard"
>Programguide</link
> för mer information om det.</para>

<formalpara>
<title
>Kompilatorutmatning</title>
<para
>Så fort &tdevelop; kompilerar någon källkod, visas meddelanden från byggverktygen, som <application
>make</application
>, i fönstret <guilabel
>Meddelanden</guilabel
> längst ner på arbetsytan. Oftast är meddelandena överväldigande ordrika. För att få en bättre överblick av vad som händer, har &tdevelop; ett antal inbyggda sätt att förkorta meddelandena.</para>
</formalpara>

<para
>Beroende på vilken version av &tdevelop; du använder, kan inställningen <guilabel
>Kompilatorutmatning</guilabel
> vara förinställd till <quote
>fullständig</quote
>, vilket gör att allt innehåll i meddelanden visas i sin helhet. Du vill nog ändra det till den mycket mer praktiska inställningen <quote
>mycket kort</quote
>. Välj den helt enkelt i kombinationsrutan.</para>

<caution>
<para
>Var medveten om att bara <emphasis
>den mest grundläggande</emphasis
> informationen visas i fönstret <guilabel
>Meddelanden</guilabel
> med denna inställning. Om fel skulle uppstå när du bygger, behöver du troligen se mer av, om inte hela, meddelandetexten. Meddelandena är dock inte borta. Högerklicka bara i fönstret <guilabel
>Meddelanden</guilabel
> och välj t.ex. <quote
>Fullständig kompilatorutmatning</quote
> i den sammanhangsberoende menyn.</para>
</caution>
</sect2>

<sect2 id="gettingstarted-configure-search">
<title
>Initiera sökindex för dokumentation</title>

<para
>Det finns en annan, inte så uppenbar, inställning som helst ska göras innan själva utvecklingsarbetet påbörjas. Det beror på att du regelbundet kommer att vilja göra sökningar i dokumentationen under utvecklingen. &tdevelop; kräver att ett antal sökindex skapas innan en sådan sökåtgärd kan genomföras. Låt oss initiera dem innan vi utför de första stegen i det verkliga arbetet med &tdevelop;.</para>

<para
>Öppna verktygsvyn <guilabel
>Dokumentation</guilabel
> på höger sida i &tdevelop;s huvudfönster. Öppna där dialogsidan <guilabel
>Sök</guilabel
>.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="documents-search.png" format="PNG"/>
</imageobject>
<caption
><para
>Var sökindex ska skapas.</para
></caption>
</mediaobject>
</screenshot>

<para
>Klicka nu på knappen <guibutton
>Uppdatera inställning</guibutton
> för att försäkra dig om att de grundläggande sökverktygen är riktigt inställda. En dialogruta ska dyka upp, som säger <quote
>Configuration file updated</quote
>. Klicka på <guibutton
>Ok</guibutton
> för att stänga den.</para>

<para
>När det här är gjort, är &tdevelop; klar att tolka känd dokumentation och bygga några användbara sökindex från den. Klicka på knappen <guibutton
>Uppdatera index</guibutton
> till höger. Nu dyker dialogrutan <guilabel
>Skapar sökindex</guilabel
> upp, och visar förloppet när index skapas.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="configure-docu-indexgen.png" format="PNG"/>
</imageobject>
<caption
><para
>&tdevelop; skapar sökindex för dokumentation.</para
></caption>
</mediaobject>
</screenshot>

<para
>Det tar en viss tid beroende på dokumentationens storlek och datorns prestanda. Men till sist ändras knappen <guibutton
>Cancel</guibutton
> till <guibutton
>Ok</guibutton
>. Klicka bara på knappen för att fortsätta.</para>

<note>
<itemizedlist>
<listitem>
<para
>Det bör normalt fungera direkt, men i vissa fall kanske inte programmet <application
>htdig</application
> som &tdevelop; använder för att utföra fulltextsökning kanske inte är riktigt inställt. Titta i kapitlet <link linkend="setup-docu-textsearch"
>Inställning av index för textsökning</link
> för mer hjälp i detta fall.</para>
</listitem>
<listitem>
<para
>För att kunna slå upp specifik information om &kde;:s och &Qt;:s programmeringsgränssnitt, krävs att <emphasis
>KDELibs Apidocs</emphasis
> fanns när &tdevelop; installerades. Om du har problem med att skapa index eller utföra <link linkend="gettingstarted-edit-defs"
>exemplen med uppslagning av identifierare</link
> senare i kapitlet, försäkra dig om att dokumentationen finns och att &tdevelop; kan komma åt den. Se <link linkend="tdevelop-install"
>Installera KDevelop</link
> för mer information.</para>
</listitem>
</itemizedlist>
</note>
</sect2>
</sect1>


<sect1 id="gettingstarted-new">
<title
>Starta ett nytt projekt</title>

<para
>Nästan alla program består av dussintals, hundratals eller till och med tusentals filer som måste hållas strukturerade och möjliga att underhålla. För att åstadkomma det, organiserar &tdevelop; utveckling av programvara i <emphasis
>projekt</emphasis
>. Därför är det första praktiska steget för att utvecklar programvara i &tdevelop; oftast att skapa ett nytt projekt.</para>

<para
>Tursamt nog är det ganska lätt att åstadkomma det. &tdevelop; tillhandahåller verktyget Programguide för att göra det. (Se kapitlet <link linkend="applicationwizard"
>Komma igång: Programguiden</link
> för mer information.)</para>

<para
>Nu skapar vi ett enkelt &kde;-programprojekt för att åskådliggöra hur enkelt det kan åstadkommas, och vilka filer och verktyg som &tdevelop; tillhandahåller. Därigenom tar vi en snabbtitt på:</para>

<simplelist>
<member
><link linkend="gettingstarted-new-setup"
>Hur man skapar ett nytt projekt med hjälp av programguiden.</link
></member>
<member
><link linkend="gettingstarted-new-files"
>Vilka filer som programguiden skapade från början.</link
></member>
<member
><link linkend="gettingstarted-new-toolviews"
>Vad som gäller för de ytterligare verktygsvyer som visas ihop med projektet?</link
></member>
</simplelist>

<sect2 id="gettingstarted-new-setup">
<title
>Hur man skapar ett nytt projekt</title>

<para
>Låt oss skapa ett ganska enkelt &kde;-projekt, <quote
>Hello World</quote
>. Utför bara följande steg:</para>

<procedure>
<step>
<para
>Klicka på menyalternativet <menuchoice
><guimenu
>Projekt</guimenu
> <guimenuitem
>Nytt projekt...</guimenuitem
></menuchoice
> för att starta programguiden.</para>
</step>

<step>
<para
>Dialogrutan <guilabel
>Skapa nytt projekt</guilabel
> dyker upp. I fönstret längst upp till vänster, <guilabel
>Alla projekt</guilabel
>, finns ett antal programspråk listade.</para>

<substeps>
<step>
<para
>Vi vill bygga ett vanligt &kde;-program i C++. Klicka därför på knappen <guilabel
>+</guilabel
> till vänster om <guilabel
>C++</guilabel
> för att visa innehållet.</para>
</step>

<step>
<para
>En uppsättning möjliga programtyper visas. Vi ska bygga ett &kde;-program, och visa därför nästa undernivå via knappen <guilabel
>+</guilabel
> intill <guilabel
>KDE</guilabel
>.</para>
</step>

<step>
<para
>Nu erbjuds du ett antal möjliga <emphasis
>projektmallar</emphasis
>. Gå till början av listan och klicka på <guilabel
>Enkelt KDE-program</guilabel
>.</para>

<para
>En förhandsgranskning och kort beskrivning av programmet som projektmallen kommer att skapa dyker upp i de två fönstren till höger.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="tutorial-new-project.png" format="PNG"/>
</imageobject>
<caption>
<para
>Välja projektmallen <quote
>Hello World</quote
></para>
</caption>
</mediaobject
></screenshot>
</step>

<step>
<para
>Vårt program behöver ett namn. Hitta rutan <guilabel
>Egenskaper</guilabel
> längst ner i dialogrutan och skriv in ett lämpligt namn i inmatningsfältet <guilabel
>Programnamn</guilabel
>.</para>

<para
>Vi använder <quote
>Hello</quote
> i vårt exempel, men du kan använda vad du vill, under förutsättning att namnet bara består av bokstäver, siffror och understreck. Du kommer att märka att programguiden inte accepterar några andra tecken.</para>
</step>

<step>
<para
>Försäkra dig om att textrutan <guilabel
>Plats</guilabel
> under inmatningsfältet visar namnet på huvudkatalogen för projekt, som vi ställde in i kapitlet <link linkend="gettingstarted-configure"
>Några inställningar</link
> ovan. Om den inte gör det, skriv in ett lämpligt katalognamn eller välj ett i kataloglistan som tillhandahålls av knappen med katalogikonen till höger.</para>

<para
>Om allt gick bra, visar raden <guilabel
>Slutgiltig plats</guilabel
> katalogsökvägen som det nya projektet kommer att använda. Om suffixet <quote
>(ogiltig)</quote
> är tillagt, prova med ett annat namn på projektet och/eller försäkra dig om att huvudkatalogen för projekt i textrutan <guilabel
>Plats</guilabel
> verkligen finns och är skrivbar.</para>
</step>

<step>
<para
>När allting väl är riktigt, aktiveras knappen <guibutton
>Nästa</guibutton
> på raden längst ner i dialogrutan. Klicka på den för att fortsätta.</para>
</step>
</substeps>
</step>

<step>
<para
>Det för dig till dialogsidan <guilabel
>Projektinställningar</guilabel
>. Försäkra dig om att textrutorna <guilabel
>Upphovsman</guilabel
> och <guilabel
>E-post</guilabel
> är riktigt ifyllda. Oftast är de förinställda till de allmänna användarinställningarna i &kde; som anges i dialogrutan <guilabel
>Lösenord och användarkonto</guilabel
> i &kde;:s inställningscentral. Om de inte är det, ändra dem till värden som du föredrar för programmet.</para>

<screenshot id="gettingstarted-new-setup-options">
<mediaobject>
<imageobject>
<imagedata fileref="tutorial-hello-options.png" format="PNG"/>
</imageobject>
<caption>
<para
>Ange ditt namn och (valfritt) e-postaddress.</para>
</caption>
</mediaobject>
</screenshot>

<note>
<para
>Du måste åtminstone ange namn för <guilabel
>Upphovsman</guilabel
>. Det krävs för inställning av programmets filer.</para>
</note>

<para
>Om allt är riktigt, är knappen <guibutton
>Nästa</guibutton
> aktiverad. Klicka på den för att gå vidare igen.</para>
</step>

<step>
<para
>Följande dialogsidor, <guilabel
>Versionskontrollsystem</guilabel
>, <guilabel
>Mall för .h-filer</guilabel
> och <guilabel
>Mall för .cpp-filer</guilabel
>, är inte intressanta för tillfället. Hoppa över dem genom att klicka på knappen <guibutton
>Nästa</guibutton
>, och till sist knappen <guibutton
>Slutför</guibutton
>.</para>
</step>
</procedure>

<para
>Det var allt! Programguiden tar över och skapar en uppsättning ursprungliga filer i katalogen <guilabel
>Slutgiltig plats</guilabel
> du tillhandahöll i steg 2c ovan.</para>

<para
>När fasen att skapa filer är klar, öppnar &tdevelop; ett redigeringsfönster med implementeringsfilen för <emphasis
>programmets huvudfönster</emphasis
> (som är <filename
>hello.cpp</filename
> i vårt exempel), så att du enkelt kan gå vidare.</para>
</sect2>

<sect2 id="gettingstarted-new-files">
<title
>Ursprungliga projektfiler</title>

<para
>Även om vårt exempelprojekt Hello är ganska enkelt, skapade programguiden en hel mängd källkod och projekthanteringsfiler. Det enklaste sättet att lista dem är att öppna verktygsvyn <guilabel
>Filträd</guilabel
> längst ner till vänster. Då visas en fillista som liknar den nedan.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="tutorial-hello-new.png" format="PNG"/>
</imageobject>
<caption>
<para
>Ursprungliga filer i projektet <quote
>Hello World</quote
></para>
</caption>
</mediaobject>
</screenshot>

<para
>För att förevisa de huvudsakliga filerna som programguiden skapade, visar vi de flesta kataloggrenarna i verktygsvyn <guilabel
>Filträd</guilabel
> till vänster. Klicka bara på grenarnas namn i trädet för att se själv.</para>

<para
>Dessutom, enbart i demonstrationssyfte, visar vi också de flesta grenarna i verktygsvyn <guilabel
>Hantering av automake</guilabel
> till höger, där några av projektets källfiler också listas.</para>

<sect3 id="gettingstarted-new-files-copyright">
<title
>Anmärkningar om copyright</title>

<para
>Alla program som uppfyller kraven enligt &GNU; måste ha en copyright. Det finns två nivåer där copyright krävs, <emphasis
>i enskilda källkodsfiler</emphasis
> och <emphasis
>vid programkörning</emphasis
>. Programguiden har redan lagt till lämplig copyright- och licensinformation i projektfiler.</para>

<formalpara>
<title
>Copyright på källkodsnivå</title>
<para
>Kommer du ihåg dialogsidan <link linkend="gettingstarted-new-setup-options"
> <guilabel
>Projektinställningar</guilabel
></link
> när det nya projektet skapades? Där var du tvungen att ange ditt (utvecklarens) namn och en valfri e-postadress. Titta nu längst upp i redigeringsfönstret <guilabel
>hello.cpp</guilabel
> som för närvarande visas på arbetsytan. Programguiden skrev in denna text längst upp i licenshuvudet för varje källkodsfil som skapades.</para>
</formalpara>

<programlisting
>/***************************************************************************
 *   Copyright (C) 2006 by Ditt Namn   *
 *   ditt.namn@adress.se   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
</programlisting>

<para
>Du hittar exakt samma texthuvuden i varje källkodsfil som skapas inne i &tdevelop; (under förutsättning att du använder lämpliga inbyggda verktyg för att skapa filer). &tdevelop; kommer ihåg inställningarna i några mallfiler som du hittar i katalogen <filename class="directory"
>templates</filename
>.</para>

<formalpara>
<title
>Copyright när programmet körs</title>
<para
>När väl &kde;-programmet kör, kan användaren visa data <guilabel
>Om</guilabel
> programmet, oftast via menyn <guimenu
>Hjälp</guimenu
>. Programguiden tog också hand om det. Om du tar en titt i filen <filename
>main.cpp</filename
> hittar du en post som liknar den nedan.</para>
</formalpara>

<programlisting
>int main(int argc, char **argv)
{
    KAboutData about("hello", I18N_NOOP("Hello"), version, description,
                     KAboutData::License_GPL, "(C) 2006 Ditt Namn", 0, 0,
                     "ditt.namn@adress.se");
    about.addAuthor( "Ditt Namn", 0, "ditt.namn@adress.se" );
</programlisting>

<para
>Det lägger till huvudutvecklarens namn (<quote
>Ditt Namn</quote
> i vårt fall) och e-postadress på copyrightsidan <guilabel
>Om</guilabel
> när den visas, och dessutom ange namnet och adressen på sidan <guilabel
>Upphovsmän</guilabel
>.</para>

<important>
<para
>Så snart du gör betydande ändringar i ett befintligt projekt, försäkra dig om att skriva in ditt namn och e-postadress i copyrightmeddelandet för varje fil du ändrar, och även i copyrightmeddelandet som visas när programmet körs. Var inte tveksam. Du hjälper samfundet för öppen källkod betydligt om du gör det.</para>
</important>
</sect3>

<sect3 id="gettingstarted-new-files-source">
<title
>Ursprungliga källkodsfiler</title>

<para
>Programguiden placerade källkodsfiler i underkatalogen <filename class="directory"
>src</filename
> i projektets katalog. Du hittar filerna <filename
>main.cpp</filename
>, <filename
>hello.h</filename
> och <filename
>hello.cpp</filename
> där, som du kanske förväntade dig.</para>

<para
>Det finns ytterligare några filer som du ofta hittar i ett typiskt &kde;-program, närmare bestämt:</para>

<itemizedlist>
<listitem>
<para
><filename
>hello.desktop</filename
> innehåller en del metadata som &tdevelop; använder för att hantera och starta programmet.</para>
</listitem>

<listitem>
<para
><filename
>hi16-app-hello.png</filename
> och <filename
>hi32-app-hello.png</filename
> innehåller några ursprungliga standardikoner, som &tdevelop; använder för att visa programmet.</para>
</listitem>

<listitem>
<para
>Till sist, innehåller <filename
>helloui.rc</filename
> en beskrivning av programmets användargränssnitt, för närvarande menyerna som programmet tillhandahåller.</para>
</listitem>
</itemizedlist>
</sect3>

<sect3 id="gettingstarted-new-files-doc">
<title
>Ursprunglig programdokumentation</title>

<para
>I projektets underkatalog <filename class="directory"
>doc/en</filename
> hittar du filen <filename
>index.docbook</filename
>. Det är en standardmall som kan vara utgångspunkt för att börja skriva lämplig användardokumentation.</para>
</sect3>

<sect3 id="gettingstarted-new-files-project">
<title
>Projektfiler och andra filer</title>

<para
>Du har säkert märkt att filerna vi hittills har introducerat anges med fetstil i verktygsvyn <guilabel
>Filträd</guilabel
>, medan de flesta andra filer inte gör det. Det illustrerar den väsentligt annorlunda användning dessa filer har. Innehållet i filer som anges med fetstil påverkar programmet direkt. Källkodsfiler skapar koden som ska köras, andra filer tillhandahåller nödvändig data eller dokumentation. Filerna måste hanteras och behandlas av projektet under byggetapperna, och kallas därför <emphasis
>projektfiler</emphasis
>.</para>

<para
>Om du tar en titt på det nedre fönstret i <guilabel
>Hantering av automake</guilabel
> till höger på arbetsytan ser du också alla projektfiler listade. Verktyget Hantering av automake använder denna kunskap för att ta hand om bygghantering, som vi inom kort kommer att se.</para>

<para
>De andra filerna utan fetstil är mer av stödnatur. De tillhör flera särpräglade klasser, enligt följande:</para>

<itemizedlist>
<listitem>
<formalpara>
<title
>Bygghantering av projekt</title>
<para
>Dessa filer styr processer för kompilering, installation, skapade av dokumentation, etc. Om projektet använder &GNU; <application
>autotools</application
>, som vårt exempel, hittar du filen <filename
>Makefile.am</filename
> i varje projektkatalog. De är en sorts grundläggande kärnfiler för att bygga projektet, som innehåller styrkommandon, och som behandlas tillsammans med diverse <filename
>configure</filename
>-filer under byggetapperna. En sådan byggprocess skapar slutligen <filename
>Makefile</filename
> i varje katalog. Från dessa bygger verktyget <application
>make</application
> slutligen programmets binärfiler.</para>
</formalpara>

<para
><filename
>Makefile.am</filename
>-filerna måste underhållas genom hela utvecklingsprocessen. Tursamt nog, befriar &tdevelop; dig från det mesta av denna börda med verkyget Hantering av automake, som i grunden är ett grafiskt gränssnitt för att underhålla innehållet i <filename
>Makefile.am</filename
>-filerna.</para>

<para
>Andra filer som styr projektets byggprocess som för närvarande listas är <filename
>configure.in.in</filename
> och <filename
>subdirs</filename
> i projektets rotkatalog. De behandlas av några av filerna i den &kde;-specifika administrationskatalogen <filename class="directory"
>admin</filename
> för att skapa fler filer av typen <filename
>configure</filename
> och <filename
>Makefile</filename
>, och slutligen programmets binärfiler.</para>
</listitem>

<listitem>
<formalpara>
<title
>Administrationsfiler för &tdevelop;</title>
<para
>&tdevelop; behöver viss egen hanterings- och administrationsdata. Den är placerad i projektets rotkatalog, i vårt exempel <filename
>hello.tdevelop</filename
>, <filename
>hello.tdevelop.pcs</filename
>, och <filename
>hello.kdevses</filename
>.</para>
</formalpara>

<para
>Filen <filename
>xxx.tdevelop</filename
> (där <quote
>xxx</quote
> anger projektnamnet) är särskilt viktig. Den är <emphasis
>huvudsaklig projektfil</emphasis
> i KDevelop 3, och behövs om du senare vill ladda projektet i den integrerade utvecklingsmiljön.</para>

<warning>
<para
>Försök aldrig ändra, byta namn eller ta bort någon av administrationsfilerna i &tdevelop; själv. Den integrerade utvecklingsmiljön fungerar sannolikt inte på rätt sätt för ditt projekt efteråt.</para>
</warning>
</listitem>

<listitem>
<formalpara>
<title
>Filer för projektbeskrivning enligt GNU</title>
<para
>Några filer i projektets rotkatalog krävs för alla program som uppfyller kraven enligt &GNU;. De är <filename
>AUTHORS</filename
>, <filename
>ChangeLog</filename
>, <filename
>INSTALL</filename
>, <filename
>COPYING</filename
> (som innehåller GNU GENERAL PUBLIC LICENSE), <filename
>INSTALL</filename
>, <filename
>NEWS</filename
>, <filename
>README</filename
> och <filename
>TODO</filename
>.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Andra filer</title>
<para
>Några andra filer som ännu inte nämnts är:</para>
</formalpara>

<itemizedlist>
<listitem>
<para
><filename
>Doxyfile</filename
> styr hur den projektspecifika dokumentationen av det interna programmeringsgränssnittet skapas.</para>
</listitem>

<listitem>
<para
>Katalogen <filename class="directory"
>templates</filename
> innehåller filmallar som den integrerade utvecklingsmiljön använder som grund när nya källkodsfiler skapas. Du kan redigera mallarna när som helst. Det nya innehållet syns i nästa källkodsfil av motsvarande typ som du skapar.</para>

<para
>Du kanske vill justera asteriskerna till höger på raderna med copyright som programguiden infogade i mallfilerna för <filename
>cpp</filename
> och <filename
>h</filename
>, så att källkodsfilerna som skapas med dem ser mindre aviga ut.</para>
</listitem>

<listitem>
<para
>Katalogen <filename class="directory"
>po</filename
> används i översättningssyfte. Den är väsentligen en del av projektfilerna (innehåller <filename
>Makefile.am</filename
>), men kommer i huvudsak att användas vid behandling av översättningar. Den är dock inte så intressant för programutvecklaren.</para>
</listitem>

<listitem>
<para
>Till sist krävs katalogen <filename class="directory"
>admin</filename
> särskilt av &kde;-baserade program. Den tillhandahåller en mängd filer som är nödvändiga för att underhålla programmets källkod och binärfiler så att de kan integreras på ett riktigt sätt i &kde;-miljön.</para>
</listitem>
</itemizedlist>

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

<sect2 id="gettingstarted-new-toolviews">
<title
>Ytterligare verktygsvyer</title>

<para
>Som du märkte visades flera ytterligare verktygsvyer så fort programguiden var klar med det nya projektet. De är bara vettiga under utveckling av projektet, och erbjuder i korthet följande funktioner:</para>

<note>
<para
>Vilka verktygsvyer som verkligen syns beror på insticksprogrammen som för närvarande är laddade i &tdevelop;. Det finns sätt att styra det. Se kapitlet <link linkend="setup-plugins"
>Insticksverktyg</link
> för instruktioner.</para>
</note>

<sect3 id="gettingstarted-new-toolviews-left">
<title
>Navigerings- och urvalsverktyg (vänster sida)</title>

<itemizedlist>
<listitem>
<formalpara>
<title
>Bokmärken</title>
<para
>Du kan markera vilken rad som helst i en textfil för att snabbt komma tillbaka till positionen varifrån som helst. &tdevelop; kommer ihåg alla sådana <emphasis
>bokmärken</emphasis
>, även om du senare stänger redigeringsfönstret. Verktygsvyn <guilabel
>Bokmärken</guilabel
> listar alla bokmärken enligt filnamn och radnummer. Du behöver bara klicka på en sådan post för att öppna motsvarande redigeringsfönster och placera markören på angiven rad.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Klasser</title>
<para
>Listar klasser, metoder, etc. kända i projektet. Att klicka på en post öppnar lämplig deklarationsfil eller källkodsfil i ett redigeringsfönster och placerar markören på respektive deklaration eller definition.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Filgrupper</title>
<para
>Sorterar projektets filer i diverse grupper enligt användningsområde, t.ex. Sources (källkod), User Interface (användargränssnitt), Icons (ikoner), Translations (översättningar) och Others (övriga).</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Variabler</title>
<para
>Används av avlusningsverktyget för att visa, utvärdera och bevaka variabler när avlusaren körs.</para>
</formalpara>
</listitem>
</itemizedlist>
</sect3>

<sect3 id="gettingstarted-new-toolviews-bottom">
<title
>Meddelanden (längst ner)</title>

<itemizedlist>
<listitem>
<formalpara>
<title
>Valgrind</title>
<para
><application
>Valgrind</application
> är ett analysverktyg för program som körs. Verktygsvyn listar resultatet av en sådan analyskörning. Det används till exempel för att hitta minnesläckor.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Säkerhetsproblem</title>
<para
>Det finns ett insticksverktyg i &tdevelop; för <guilabel
>säkerhetskontroll</guilabel
>. Det analyserar källkodsfilen som för närvarande redigeras, för att hitta flera vanliga säkerhetsproblem som kan uppstå i programmet och underrättar användaren om dem i verktygsvyns fönster.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Brytpunkter</title>
<para
>Verktygsvyn möjliggör att explicit sätta, ta bort och hantera brytpunkter för avlusaren i programmets källkodsfiler. Den används i samband med avlusning.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Ctags</title>
<para
>Gör det möjligt att skapa databaser med index av identifierare med det populära programmet <application
>Ctags</application
>. Databasen med taggar kan därefter användas från verktygsvyns fönster för att slå upp alla identifierare som behövs i projektets källkod. Genom att klicka på en rad med ett sådant funnet objekt, öppnar ett redigeringsfönster och placerar markören på motsvarande identifierar i fönstret.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Problem</title>
<para
>&tdevelop; håller reda på vanliga programmeringsproblem i källkodsfilen som för närvarande redigeras, och underrättar användaren om dem i verktygsvyns fönster.</para>
</formalpara>
</listitem>
</itemizedlist>
</sect3>
  
<sect3 id="gettingstarted-new-toolviews-right">
<title
>Källkodshantering (höger sida)</title>
      
<itemizedlist>
<listitem>
<formalpara>
<title
>Hantering av automake</title>
<para
>Verktyget Hantering av automake är egentligen ett grafiskt gränssnitt för att hantera innehållet i <filename
>Makefile.am</filename
>-filer i varje projektkatalog. Verktygsvyn använder två fönster för att styra arbetet. Det övre fönstret speglar en del av projektets underkataloger, närmare bestämt de som explicit innehåller <emphasis
>projektfiler</emphasis
>. Varje underkatalog av denna typ måste innehålla en <filename
>Makefile.am</filename
>-fil, och kallas ett <emphasis
>delprojekt</emphasis
> i samband med Hantering av automake.</para>
</formalpara>

<para
>Genom att klicka på ett delprojekt öppnas en lämplig vy av delprojektets projektfiler i det undre fönstret. Filerna som listas här är grupperade enligt sin funktion i <filename
>Makefile.am</filename
> för detta delprojekt.</para>

<para
>Hantering av automake är ett mycket kraftfullt verktyg för att hantera projektet och dess delprojekt, samt de roller projektfiler spelar när programmet byggs. Vi tar en snabbtitt på några viktigare delar <link linkend="gettingstarted-extend-automake"
>nedan</link
>. Se kapitlet <link linkend="project-management"
>Bygga och projekthantering</link
> för en utförligare beskrivning.</para>
</listitem>
</itemizedlist>
</sect3>
</sect2>
</sect1>


<sect1 id="gettingstarted-edit">
<title
>Några tips om hur man hanterar dokument</title>

<para
>I vårt exempelprojekt lämnade programguiden filen <filename
>hello.cpp</filename
> öppen i ett redigeringsfönster, så att du omedelbart kan börja arbeta med den. Vi förutsätter att du har god kunskap om hur man använder en editor, så vi säger inte så mycket om det här. Det finns dock ett antal praktiska funktioner i &tdevelop; för att hantera redigeringsfönster med flikar och dokumenten du arbetar med. Vi ger en kortfattad beskrivning av några, närmare bestämt:</para>

<simplelist>
<member
><link linkend="gettingstarted-edit-headers"
>Hur man enkelt byter mellan deklarationsfiler och implementeringsfiler.</link
></member>
<member
><link linkend="gettingstarted-edit-defs"
>Hur man snabbt kommer åt deklarationer och definitioner.</link
></member>
<member
><link linkend="gettingstarted-edit-arrange"
>Hur man arrangerar om redigeringsfönster efter aktuellt behov.</link
></member>
<member
><link linkend="gettingstarted-edit-problems"
>Hur man håller ett öga på vanliga problem.</link
></member>
</simplelist>

<sect2 id="gettingstarted-edit-headers">
<title
>Byta mellan deklarationsfiler och implementeringsfiler</title>

<para
>&tdevelop; tillhandahåller ett snabbt och enkelt sätt att byta från en given implementeringsfil (<filename
>.cpp</filename
>) till motsvarande deklarationsfil (<filename
>.h</filename
>) och vice versa. Högerklicka bara på redigeringsfönstret du vill byta. En meny som liknar den följande dyker upp.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="editor-switch-header.png" format="PNG"/>
</imageobject>
<caption
><para
>Hur man byter mellan implementeringsfiler och deklarationsfiler.</para
></caption>
</mediaobject>
</screenshot>

<para
>Leta rätt på alternativet <guimenuitem
>Byt till deklaration/implementation</guimenuitem
> och välj det. &tdevelop; slår upp motsvarande deklarationsfil eller implementeringsfil och öppnar den i ett annat redigeringsfönster. I vårt exempel, om du högerklickade i källkoden <filename
>hello.cpp</filename
>, visas filen <filename
>hello.h</filename
> och markören placeras där.</para>

<para
>Det finns mer än så. Om du högerklickar inne i en klassimplementeringstext, placerar &tdevelop; markören på motsvarande deklarationsrad i deklarationsfilen. Det omvända fallet, ett högerklick på en deklarationsrad, tar dig till motsvarande klassimplementering.</para>

<para
>Om redigeringsfönstret med filen att byta till redan finns, aktiverar &tdevelop; förstås det och placerar markören i det om det behövs.</para>
</sect2>

<sect2 id="gettingstarted-edit-defs">
<title
>Hur man kommer åt deklarationer och definitioner</title>

<para
>Men ifall du arbetar med en källkodsfil och vill slå upp deklarationen eller definitionen av en identifierare du just hittade i den? Jo, det kan åstadkommas lika lätt. Det enda du egentligen måste göra är att högerklicka på identifieraren ifråga.</para>

<para
>Det finns dock två olika fall att ta hänsyn till, nämligen:</para>
<simplelist>
<member
><link linkend="gettingstarted-edit-defs-external"
>Komma åt externt definierade identifierare</link
>, och</member>
<member
><link linkend="gettingstarted-edit-defs-project"
>hantera projektinterna textobjekt</link
>.</member>
</simplelist>

<sect3 id="gettingstarted-edit-defs-external">
<title
>Externa deklarationer och definitioner</title>

<para
>Det vanligaste fallet är att du vill slå upp en identifierare som definierats utanför projektet. I &kde;-projekt är sådana identiferare troligen dokumenterade i olika &kde;- eller &Qt;-bibliotek. Om &kde; och &tdevelop; är riktigt installerade, kan &tdevelop; komma åt sådan så kallad dokumentation av programmeringsgränssnitt, och kunna söka efter identifierare av denna typ.</para>

<para
>Låt oss titta på ett exempel. Leta rätt på följande rader i redigeringsfönstret <filename
>hello.cpp</filename
>.</para>

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

<para
>Högerklicka på <classname
>KMainWindow</classname
>. En meny dyker upp. Välj där alternativet <guimenuitem
>Sök i dokumentationen: KMainWindow</guimenuitem
> och släpp musknappen. Nu öppnas verktygsvyn <guilabel
>Dokumentation</guilabel
>, med värdet <classname
>KMainWindow</classname
> som sökbegrepp på sidan <guilabel
>Sök</guilabel
>. Därefter öppnas ett annat redigeringsfönster på arbetsytan som visar KDE:s referenssida i programmeringsgränssnittet för klassen <classname
>KMainWindow</classname
>.</para>

<para
>Allt detta ser ut som följer. (Vi öppnade med avsikt redan sidan <guilabel
>Dokumentation</guilabel
> <guilabel
>Sök</guilabel
> för att åskådliggöra resultatet av menyvalet.)</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="editor-search-doc.png" format="PNG"/>
</imageobject>
<caption
><para
>Hur man slår upp en externt dokumenterad identifierare.</para
></caption>
</mediaobject>
</screenshot>

<para
>Du kan lika väl välja <guimenuitem
>Sök efter dokumentation: KMainWindow</guimenuitem
>. I detta fall visas sidan <guilabel
>Sökning</guilabel
> i verktygsvyn <guilabel
>Dokumentation</guilabel
>, som oftast tillhandahåller ett urval sidor som innehåller sökbegreppet. (I vårt exempel är det troligen klasserna <classname
>KMainWindow</classname
> och <classname
>KMainWindowInterface</classname
>.) Välj den du är intresserad av så visas motsvarande dokumentation i ett redigeringsfönster.</para>

<note>
<para
>Om det inte fungerade, finns det förmodligen inget dokumentindex ännu. Initierade du indexet enligt <link linkend="gettingstarted-configure-search"
>ovan</link
>? Om inte, gör det först, och kom sedan tillbaka hit för ett nytt försök.</para>
</note>
</sect3>

<sect3 id="gettingstarted-edit-defs-project">
<title
>Projektinterna deklarationer och definitioner</title>

<para
>Sådana sökfunktioner i extern dokumentation har dock sina begränsningar. Man kan förstås inte slå upp en extern identifierare om den bara definieras och används inne i det aktuella projektet. Men det finns hjälp för det. &tdevelop; kan använda index skapade av programmet <application
>Ctags</application
> för att söka i projektets källkod.</para>

<para
>Innan vi kan använda det i vårt eget exempelprojekt Hello, måste vi först skapa ett lämpligt index. Det görs i verktygsvyn <guilabel
>Ctags</guilabel
> längst ner på arbetsytan.</para>

<para
>När du klickar på fliken <guibutton
>Ctags</guibutton
> öppnas en dialogruta där du hittar följande text i nedre högra hörnet:</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="editor-ctags-regenerate.png" format="PNG"/>
</imageobject>
<caption
><para
>Bygg ett Ctags-index med knappen <guibutton
>Skapa om</guibutton
>.</para
></caption>
</mediaobject>
</screenshot>

<para
>Klicka på knappen <guibutton
>Skapa om</guibutton
> och vänta några sekunder. Då ersätts <guilabel
>Ingen Ctags-databas hittades</guilabel
> med dagens datum. Nu är du redo att slå upp några identifierare i projektets källkod.</para>

<tip>
<para
>Datumet intill knappen <guilabel
>Skapa om</guilabel
> finns där för att påminna dig om index som möjligtvis kan vara för gamla. Så fort du uppenbarligen inte kan slå upp en identifierare i projektet, fundera på att skapa om indexet. I stora projekt kan det ta en avsevärd tid, men du bör ta för vana att skapa om indexet regelbundet efter större ändringar i källkodsfiler.</para>
</tip>

<para
>Det finns flera möjligheter att slå upp en identifierare i projektets källkod.</para>

<itemizedlist>
<listitem>
<formalpara>
<title
>Använd verktygsvyn Ctags</title>
<para
>Det är enkelt. Börja bara skriva namnet på identifieraren som du är intresserad av i inmatningsfältet <guilabel
>Uppslagning</guilabel
> längst ner till vänster. &tdevelop; försöker komplettera ordet du har skrivit så långt, och visa alla förekomster av identifierare som inleds med teckenföljden.</para>
</formalpara>

<para
>Om du till exempel vill veta om identifieraren <quote
>Hello</quote
> används i vårt exempelprojekt, skriv in "H" i inmatningsfältet <guilabel
>Uppslagning</guilabel
>. &tdevelop; börjar omedelbart arbeta och visar ett liknande resultat:</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="editor-ctags-lookup.png" format="PNG"/>
</imageobject>
<caption
><para
>Hur en identifierare slås upp i verktygsvyn <guilabel
>Ctags</guilabel
>.</para
></caption>
</mediaobject>
</screenshot>

<para
>Om du klickar på en av de listade posterna, öppnar &tdevelop; ett redigeringsfönster med filen och placerar markören på lämplig plats.</para>
</listitem>

<listitem>
<formalpara>
<title
>Använda en sammanhangsberoende meny i en källkodsfil</title>
<para
>Det är bekvämt om du arbetar med en viss källkodsfil. Antag att du studerar filen <filename
>main.cpp</filename
> i vårt exempelprojekt Hello. Där hittar du följande rad:</para>
</formalpara>
<programlisting
>Hello *mainWin = 0;
</programlisting>
<para
>Du undrar kanske vad <quote
>Hello</quote
> användes för i programmet. För att ta reda på det, högerklicka helt enkelt på identifieraren Hello. En meny dyker upp som svar på högerklicket, med följande rader nära slutet.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="editor-ctags-menu.png" format="PNG"/>
</imageobject>
<caption
><para
>Hämta <application
>Ctags</application
>-information om en av projektets interna identifierare.</para
></caption>
</mediaobject>
</screenshot>

<para
>Klicka på det du är intresserad av, låt oss säga <guilabel
>Ctags - Gå till definition: Hello</guilabel
>, så visar &tdevelop; omedelbart redigeringsfönstret <filename
>hello.cpp</filename
> och placerar markören precis framför klassdefinitionen:</para>
<programlisting
>Hello::Hello()
    : KMainWindow( 0, "Hello" )
{
</programlisting>
</listitem>

<listitem>
<formalpara>
<title
>Gör en allmän sökning</title>
<para
>Det är särskilt användbart om du vill slå upp godtycklig text i projektets källkod. Det finns två möjligheter att starta en allmän sökning inne i &tdevelop;.</para>
</formalpara>
<itemizedlist>
<listitem>
<para
>Starta en allmän sökning med menyalternativet <menuchoice
><guimenu
>Redigera</guimenu
> <guimenuitem
>Sök i filer...</guimenuitem
></menuchoice
>. Eller</para>
</listitem>
<listitem>
<para
>Direkt använda den sammanhangsberoende menyn med ett högerklick av musen i redigeringsfönstret.</para>
</listitem>
</itemizedlist>

<para
>Vi åskådliggör den andra möjligheten i exempelprojektet Hello. Slutresultatet av menyanropet är i stort sett likadant. Låt oss anta att du studerar källkodsfilen <filename
>hello.cpp</filename
> och har placerat markören på den första förekomsten av Hello i den. Nu undrar du var ordet <quote
>Hello</quote
> användes i projektets källkod, och hur många förekomster det finns. Det är ett typiskt fall då &tdevelop;s allmänna sökfunktion bör användas.</para>

<para
>Medan du nu fortfarande håller pekaren någonstans över <quote
>Hello</quote
> i källtexten, klicka med höger musknapp. Den vid det här laget välkända sammanhangsberoende menyn dyker upp, där du ska välja alternativet <guilabel
>Flerfilsökning: Hello</guilabel
>.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="editor-find-menu.png" format="PNG"/>
</imageobject>
<caption
><para
>Initiera en allmän sökning inifrån ett redigeringsfönster.</para
></caption>
</mediaobject>
</screenshot>

<para
>Det gör att följande dialogruta <guilabel
>Sök i filer</guilabel
> dyker upp (exakt samma som om du använt menyn<menuchoice
><guimenu
>Redigera</guimenu
> <guimenuitem
>Sök i filer...</guimenuitem
></menuchoice
>).</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="find-in-files.png" format="PNG"/>
</imageobject>
<caption
><para
>Ett flexibelt grafiskt gränssnitt för att utföra allmänna sökningar i projektet.</para
></caption>
</mediaobject>
</screenshot>

<para
>Som du märker är det ett mycket flexibelt verktyg för att starta sökningar med <application
>find</application
> och <application
>grep</application
> i hela projektet. Vi går inte in på fler detaljer här, men du kan experimentera på egen hand. För ögonblicket, ska <quote
>Hello</quote
> redan vara markerat i fältet <guilabel
>Mönster</guilabel
>. Om det inte är det, skriv bara in det, och klicka därefter på knappen <guibutton
>Sök</guibutton
> längst ner till höger.</para>

<para
>Nu öppnas verktygsvyn <guilabel
>Sök i filer</guilabel
> längst ner, och visar filnamn och rader för alla förekomster av <quote
>Hello</quote
> i vårt exempelprojekt. Som vanligt, om du klickar på en rad, går &tdevelop; till den exakta platsen i ett redigeringsfönster på arbetsytan.</para>

<para
>Det finns två särskilt intressanta rader i verktygsvyns fönster.</para>
<itemizedlist>
<listitem>
<para
>Längst upp hittar du kommandosekvenserna som &tdevelop; i själva verket använde för att utföra sökningen. Det är användbart för att noggrannare styra sökningens resultat.</para>
</listitem>

<listitem>
<para
>Längst ner anges antal förekomster som hittas när en sökning utförs. I vårt exempel ska det vara <quote
>*** 11 träffar hittades ***</quote
>.</para>
</listitem>
</itemizedlist>

<para
>&tdevelop; kommer ihåg sökresultatet under hela sessionen som kör. Om du startar en ny allmän sökning, visas dess resultat med ett annat flikfönster i verktygsvyn <guilabel
>Sök i filer</guilabel
>.</para>
</listitem>
</itemizedlist>
</sect3>
</sect2>

<sect2 id="gettingstarted-edit-arrange">
<title
>Arrangera redigeringsfönster</title>

<para
>När du arbetar med stora komplexa projekt råkar du ofta ut för att ha en hel mängd flikar med redigeringsfönster i flikraden. Det gör det nödvändigt att ha särskilda funktioner för att rensa, ordna och gruppera alla redigeringsflikarna. &tdevelop; tillhandahåller flera sätt att göra det. Vi tar en snabbtitt på några av dem.</para>
<simplelist>
<member
><link linkend="gettingstarted-edit-arrange-clean"
>Hur man tar bort flikar som inte behövs.</link
></member>
<member
><link linkend="gettingstarted-edit-arrange-tabs"
>Hur man arrangerar om flikarna.</link
></member>
<member
><link linkend="gettingstarted-edit-arrange-split"
>Hur man visar flera filer samtidigt på arbetsytan.</link
></member>
<member
><link
linkend="gettingstarted-edit-arrange-sourceheader"
>Hur man redigerar C++ källkodsfiler och deklarationsfiler samtidigt</link
></member>
<member
><link linkend="gettingstarted-edit-arrange-group"
>Hur man grupperar källkodsfiler i utvecklingssessioner.</link
></member>
</simplelist>

<sect3 id="gettingstarted-edit-arrange-clean">
<title
>Städa upp i flikraden</title>

<para
>Om ett enormt antal flikar med redigeringsfönster på något sätt blir dåligt arrangerade, vill man oftast stänga alla flikar som inte längre behövs. &tdevelop; tillhandahåller flera funktioner för att göra det, det vanliga sättet att totalt stänga alla öppna redigeringsfönster, och ett mer specifikt sätt där du uttryckligen kan bestämma vilka som ska stängas och vilka som ska behållas öppna.</para>

<formalpara>
<title
>Stänga flera flikar på en gång</title>
<para
>Det här är en sorts totalmetod för att stänga onödiga öppna flikar, som du också kan hitta i andra &kde;-program. Du kan använda menyn <guimenu
>Fönster</guimenu
> eller högerklicka på en flik, för att antingen</para>
</formalpara>
<itemizedlist>
<listitem>
<para
>stänga redigeringsfönstret som för närvarande är valt,</para>
</listitem>
<listitem>
<para
>stänga alla andra öppna redigeringsfönster, eller</para>
</listitem>
<listitem>
<para
>stänga alla redigeringsfönster på en gång (bara tillgängligt i menyn <guimenu
>Fönster</guimenu
>).</para>
</listitem>
</itemizedlist>

<formalpara>
<title
>Stänga markerade uppsättningar flikar</title>
<para
>Sättet att steg för steg stänga enskilda flikar med redigeringsfönster kan bli krånglig om det finns en stor mängd flikar och du fortfarande vill lämna flera öppna. Istället för att leta rätt på och stänga en flik åt gången, erbjuder &tdevelop; möjligheten att välja kandidater i en lista och enbart stänga dem, med ett enda musklick.</para>
</formalpara>

<para
>Låt oss illustrera det med ett enkelt exempel. Låt oss anta att det finns flera filer öppna för redigering i vårt exempelprojekt Hello: <filename
>hello.cpp</filename
>, <filename
>hello.h</filename
>, <filename
>helloui.rc</filename
>, <filename
>hello.desktop</filename
> och <filename
>main.cpp</filename
>. Du vill nu stänga alla utom <filename
>hello.cpp</filename
> och <filename
>hello.h</filename
>. Det enklaste sättet att göra det är med verktygsvyn <filename
>Fillista</filename
>. Eftersom denna lista med öppna filer är alfabetiskt ordnad, är det enklare att hitta de du vill stänga. Fortsätt enligt följande:</para>

<procedure>
<step>
<para
>Öppna <guilabel
>Fillista</guilabel
>, håll nere tangenten <keycap
>Ctrl</keycap
>, och klicka på filerna du vill stänga i listan.</para>
</step>
<step>
<para
>Klicka därefter med höger musknapp, medan du håller muspekaren på ett filnamn i listan.</para>
</step>
<step>
<para
>Välj <guimenuitem
>Stäng markerade</guimenuitem
> från den sammanhangsberoende menyn i <guimenu
>Fillistan</guimenu
>.</para>
</step>
</procedure>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="file-list-close-selected.png" format="PNG"/>
</imageobject>
<caption
><para
>Hur markerade redigeringsfönster kan stängas på en gång.</para
></caption>
</mediaobject>
</screenshot>
<para
>Det är det hela. &tdevelop; har stängt alla redigeringsfönster som du önskade, och du är klar att fortsätta igen med en rensad flikrad.</para>
</sect3>

<sect3 id="gettingstarted-edit-arrange-tabs">
<title
>Hur redigeringsfönstrets flikar kan arrangeras om</title>

<para
>Även om du bara har de redigeringsfönster som verkligen behövs öppna, kanske du ändå vill arrangera flikarna på något logiskt sätt. &tdevelop; erbjuder några vanliga sätt att göra det. I korthet:</para>

<formalpara>
<title
>Grundläggande inställning: Var nya flikar ska placeras</title>

<para
>I normalfall, när ett nytt redigeringsfönster öppnas, infogas fliken till höger om fliken för redigeringsfönstret som för närvarande används. Det kan ändras så att den nya fliken öppnas längst till höger på flikraden.</para>
</formalpara>
<para
>Du måste ändra en grundläggande inställning i &tdevelop;s användargränssnitt för att aktivera beteendet.</para>
<procedure>
<step>
<para
>Välj <menuchoice
><guimenu
>Inställningar</guimenu
> <guimenuitem
> Anpassa KDevelop...</guimenuitem
></menuchoice
></para>
</step>
<step>
<para
>Klicka på ikonen <guilabel
>Användargränssnitt</guilabel
> i ikonraden till vänster i dialogrutan. Dialogsidan <guilabel
>Användargränssnitt</guilabel
> visas nu.</para>
</step>
<step>
<para
>Hitta rutan som heter <guilabel
>Bläddring med flikar</guilabel
>. Ta bort markeringen av kryssrutan på raden <guilabel
>Öppna ny flik efter nuvarande flik</guilabel
>.</para>
</step>
<step>
<para
>Stäng &tdevelop; och starta om det. Nu öppnas flikarna för nya redigeringsfönster längst bort till höger i nuvarande flikrad.</para>
</step>
</procedure>

<para
>Tyvärr kan inte inställningen ändras i farten under en utvecklingssession. Du måste bestämma dig för vilket beteende du föredrar i det långa loppet, och därefter hålla dig till det, åtminstone till nästa gång &tdevelop; startas.</para>

<formalpara>
<title
>Hur flikarna kan arrangeras om</title>
<para
>Eftersom utvecklingsuppgifer varierar med tiden, kommer behov att arrangera om flikarna för redigeringsfönster uppstå då och då. Det kan enkelt åstadkommas i &tdevelop;.</para>
</formalpara>
<para
>Klicka bara på fliken du vill flytta med musens mittenknapp och flytta musen lite grand. Markören ändras till ett mönster med korsande pilar. Nu kan du dra fliken, medan du håller nere mittenknappen, till det hoppar på plats där du vill ha det.</para>
</sect3>

<sect3 id="gettingstarted-edit-arrange-split">
<title
>Visa flera filer samtidigt</title>

<para
>Vid första påseende finns det aldrig mer än ett enda redigeringsfönster öppet för att arbeta med en källkodsfil. Även om du snabbt kan byta mellan flikar, finns det tillfällen då du vill ha flera filer öppna på en gång, t.ex. för referenssyfte eller för att få bättre kontroll av komplexa uppgifter. För att åstadkomma det, tillhandahåller &tdevelop; ett sätt att dela arbetsytan i olika delar som syns samtidigt, och var och en kan innehålla en egen följd av flikar.</para>

<para
>Det finns två delningskommandon som du antingen kan nå via menyn <guimenu
>Fönster</guimenu
>, eller genom att högerklicka i ett fönster som hör till en flik eller på själva fliken. Vi beskriver också delningsbeteendet utgående från vårt exempelprojekt Hello.</para>

<para
>Antag att det finns två källkodsfiler öppna i flikraden: <filename
>hello.cpp</filename
> and <filename
>hello.h</filename
>. Medan du arbetar med källkoden i <filename
>hello.cpp</filename
> behöver du ofta titta på deklarationerna i filen <filename
>hello.h</filename
>, så du vill ha båda filerna öppna samtidigt.</para>

<para
>För att få det gjort, högerklicka till exempel på fliken för <filename
>hello.h</filename
>. Följande meny dyker då upp:</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="split-workspace.png" format="PNG"/>
</imageobject>
<caption
><para
>Hur den aktuella arbetsytan kan delas i två delar.</para
></caption>
</mediaobject>
</screenshot>

<para
>Välj alternativet <guimenuitem
>Dela horisontellt</guimenuitem
>. Det delar arbetsytan på mitten och flyttar redigeringsfönstret som innehåller filen <filename
>hello.h</filename
> till den nedre delen.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="split-windows.png"/>
</imageobject>
<caption
><para
>Arbetsytan har delats horisontellt.</para
></caption>
</mediaobject>
</screenshot>

<para
>Observera den streckade skiljelinjen mellan de båda fönstren. Du kan ta tag i den med musen och justera redigeringsfönstrens höjd efter dina behov.</para>

<para
>Det finns ett antal saker att lägga märke till.</para>
<itemizedlist>
<listitem>
<para
>De delade arbetsytorna fungerar helt och hållet på egen hand. Det betyder att nya flikfönster öppnas i arbetsytan som innehåller redigeringsfönstret som för närvarande är aktivt. Du kan också dela alla delområden igen som du önskar, och på så sätt ha så många fönster öppna samtidigt som du behöver.</para>
</listitem>

<listitem>
<para
>Varje delning flyttar redigeringsfönstret som för närvarande är aktivt till den nya delarbetsytan, antingen neråt eller åt höger. Övriga flikfönster förblir alla där de var. Du kan inte direkt flytta flikfönster mellan delade områden, utan istället måste du explicit stänga fönstret på en arbetsyta och öppna det igen på en annan, för att gruppera om.</para>
</listitem>

<listitem>
<para
>Det finns heller inget direkt sätt att stänga ett delat område igen. Det stängs automatiskt, när väl det sista fönstret med en flik i det stängs.</para>
</listitem>
</itemizedlist>
</sect3>

<sect3 id="gettingstarted-edit-arrange-sourceheader">
<title
>Redigera C++ källkod och deklarationsfiler samtidigt</title>

<para
>Det finns en trevlig användning av den ovannämnda funktionen med delade arbetsytor inbyggd i &tdevelop;. Den låter dig automatiskt ha en källkodsfil, <filename
>.cpp</filename
>, och dess tillhörande deklarationsfil, <filename
>.h</filename
>, öppna sida vid sida på arbetsytan. Dessutom tillåter den valfritt att arbeta synkront med filerna, på så sätt att vid markering av en deklaration i deklarationsfilen går &tdevelop; till motsvarande definition i källkodsfilen och omvänt.</para>

<para
>Funktionen är dock normalt inte aktiverad. Om du vill använda den i projektet måste du aktivera den.</para>

<para
>Välj <menuchoice
><guibutton
>Projekt</guibutton
> <guimenuitem
>Projektinställningar</guimenuitem
></menuchoice
>. Dialogrutan <guilabel
>Projektinställningar</guilabel
> dyker upp. Välj <guiicon
>C++ stöd</guiicon
> i ikonraden till vänster, och därefter fliken <guilabel
>Navigering</guilabel
> på dialogsidan som visas till höger.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="split-source-header.png" format="PNG"/>
</imageobject>
<caption
><para
>Låta C++ källkod och deklarationsfiler visas sida vid sida.</para
></caption>
</mediaobject>
</screenshot>

<para
>Markera nu rutan <guilabel
>Aktivera delning av deklarationsfiler och källkodsfiler</guilabel
>. Det aktiverar normalt <guilabel
>Automatisk synkronisering</guilabel
> och <guilabel
>Vertikal</guilabel
>. Behåll inställningarna för tillfället och klicka på <guibutton
>Ok</guibutton
>.</para>

<para
>Stäng nu båda redigeringsfönstren <filename
>hello.cpp</filename
> och <filename
>hello.h</filename
> i vårt exempelprojekt Hello, om det behövs. Välj därefter <filename
>hello.cpp</filename
> igen i projektets underkatalog <filename class="directory"
>src</filename
>. Redigeringsfönstret öppnas som vanligt, men om du nu öppnar tillhörande <filename
>hello.h</filename
>, delar &tdevelop; automatiskt arbetsytan och öppnar deklarationsfilens redigeringsfönster precis under fönstret <filename
>hello.cpp</filename
>.</para>

<para
>Det finns ännu mer, som vi redan nämnt. Leta till exempel rätt på definitionsraden för följande konstruktor i fönstret <filename
>hello.cpp</filename
></para>
<programlisting
>Hello::Hello()
</programlisting>
<para
>och placera markören där. Titta därefter i fönstret <filename
>hello.h</filename
> nedanför och observera hur &tdevelop; gick till motsvarande deklarationsrad för konstruktorn.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="split-source-header-navigate.png" format="PNG"/>
</imageobject>
<caption
><para
>&tdevelop; går automatiskt till konstruktorns deklaration.</para
></caption>
</mediaobject>
</screenshot>

<para
>Det fungerar också omvänt. Så fort du placerar markören någonstans i en konstruktor i ett redigeringsfönster, går &tdevelop; till motsvarande konstruktor i det andra.</para>
</sect3>

<sect3 id="gettingstarted-edit-arrange-group">
<title
>Gruppera källkodsfiler i utvecklingssessioner</title>

<para
>När projektet växer sig större, och utvecklingsuppgifterna blir mer och mer komplexa, tvingar det dig att ofta byta mellan olika, till och med distinkta, uppsättningar filer. Nu är det dags att organisera utvecklingsarbetet i skilda sessioner. Verktygsvyn <guilabel
>Fillista</guilabel
> i &tdevelop; tillåter dig att göra precis det.</para>

<para
>Längst upp i fönstret för verktygsvyn <guilabel
>Fillista</guilabel
> finns en verktygsrad där du kan skapa, spara, välja och ta bort sådana sessioner. Använd alternativt undermenyn <menuchoice
><guimenu
>Visa</guimenu
> <guimenuitem
>Sessioner</guimenuitem
></menuchoice
>.</para>

<para
>Vi beskriver också funktionen utgående från vårt exempelprojekt Hello. Antag att du alltid vill öppna filerna <filename
>hello.cpp</filename
>, <filename
>hello.h</filename
> och <filename
>main.cpp</filename
> med ett steg, oberoende av vilken utvecklingsuppgift du precis utförde i projektet. Du måste först skapa en ny utvecklingssession, som exempelvis kallas <quote
>källkod</quote
>, för att åstadkomma det.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="file-list-session-create.png" format="PNG"/>
</imageobject>
<caption
><para
>Använda utvecklingssessioner för att komma ihåg filgrupper.</para
></caption>
</mediaobject>
</screenshot>

<para
>Det är en procedur i flera steg, enligt följande:</para>
<procedure>
<step>
<para
>Skapa en ny session</para>
<substeps>
<step>
<para
>Klicka på ikonen <guiicon
>Ny session</guiicon
> längst upp till vänster i verktygsvyn <guilabel
>Fillista</guilabel
>.</para>
</step>
<step>
<para
>En dialogruta dyker upp. Ge den nya sessionen ett namn i inmatningsfältet <guilabel
>Skriv in sessionens namn</guilabel
>, t.ex. <quote
>källkod</quote
>.</para>
</step>
<step>
<para
>Stäng dialogrutan med <guibutton
>Ok</guibutton
>. Den nya sessionen anges nu i kombinationsrutan i verktygsraden.</para>
</step>
</substeps>
</step>
<step>
<para
>Den nya sessionen är tom från början. Du måste lägga till filerna du vill ska ingå i den.</para>
<substeps>
<step>
<para
>Öppna alla filer du vill ska grupperas i utvecklingssessionen. I vårt exempel bestämde vi oss för att behålla <filename
>hello.cpp</filename
>, <filename
>hello.h</filename
> och <filename
>main.cpp</filename
> som planerat.</para>
</step>
<step>
<para
>När fillistan väl är fullständig, klicka på ikonen <guiicon
>Spara session</guiicon
> i verktygsraden. Hoppa inte över detta steg. Annars glömmer &tdevelop; bort fillistan.</para>
</step>
</substeps>
</step>
</procedure>

<para
>Det är allt. Så fort du väljer sessionen <guilabel
>källkod</guilabel
> i kombinationsrutan <guilabel
>Öppna session</guilabel
>, stänger &tdevelop; alla redigeringsfönster som för närvarande är öppna, och öppnar de ihågkomna istället (<filename
>hello.cpp</filename
>, <filename
>hello.h</filename
> och <filename
>main.cpp</filename
> i vårt exempel).</para>

<para
>Du kan definiera hur många sessioner som du vill i samband med projektet. Om du vill ändra sessionernas innehåll, uppdatera bara den ihågkomna fillistan med ett klick på <guiicon
>Spara session</guiicon
>. Och om du vill bli av med en session, välj den i kombinationsrutan, och klicka därefter på ikonen <guiicon
>Ta bort session</guiicon
> till höger i verktygsraden.</para>

<para
>Du kan göra ännu mer. Du kan tvinga &tdevelop; att öppna en given förvald session när projektet laddas. Välj bara sessionen i kombinationsrutan på inställningssidan <menuchoice
><guimenu
>Projekt</guimenu
> <guimenuitem
>Projektinställningar</guimenuitem
><guimenuitem
>Fillista</guimenuitem
></menuchoice
> i projektinställningarna.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="file-list-session-default.png" format="PNG"/>
</imageobject>
<caption
><para
>Låt &tdevelop; öppna en specifik session när projektet laddas.</para
></caption>
</mediaobject>
</screenshot>
</sect3>
</sect2>

<sect2 id="gettingstarted-edit-problems">
<title
>Hålla ögonen på vanliga problem</title>

<para
>När ett redigeringsfönster som innehåller en källkodsfil öppnas, tolkar &tdevelop; dess innehåll. Det gör det möjligt för den inbyggda <emphasis
>problemrapportören</emphasis
> att söka i källkodstexten efter några vanliga fel som den känner till. Den kan också informera användaren om olika platser som har markerats för specialbehandling.</para>

<para
>Låt oss åskådliggöra funktionen med vårt exempelprojekt Hello.</para>

<itemizedlist>
<listitem>
<para
>Öppna ett editorfönster med källkodsfilen <filename
>main.cpp</filename
>.</para>
</listitem>

<listitem>
<para
>Försäkra dig om att det fortfarande innehåller följande rad någonstans nära slutet:</para>
<programlisting
>/// @todo do something with the command line args here
</programlisting>
<para
>Det infogades av programguiden när projektet Hello skapades i kapitlet <link linkend="gettingstarted-new"
>Starta ett nytt projekt</link
> ovan.</para>
</listitem>

<listitem>
<para
>Öppna nu verktygsvyn <guilabel
>Problem</guilabel
> i raden med flikar längst ner. Om allt har fungerat, rapporterar den för närvarande följande uppgift:</para>
<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="problem-report-todo.png"/>
</imageobject>
<caption
><para
>&tdevelop; informerar om att en källkodsrad innehåller markeringen todo.</para
></caption>
</mediaobject>
</screenshot>
</listitem>
</itemizedlist>

<para
>Formatet på kommandot <computeroutput
>/// @todo</computeroutput
> är till för särskild behandling av verktyget för koddokumentation, <application
>Doxygen</application
>, som vi tar en snabb titt på i avsnittet <link linkend="gettingstarted-doc"
>Dokumentation</link
> nedan. Det krävs inte att du använder detta format, de vanligare kommentarerna <computeroutput
>TODO</computeroutput
> och <computeroutput
>FIXME</computeroutput
> känns också igen.</para>

<para
>Om du till exempel infogar följande kommentarrader med <computeroutput
>TODO</computeroutput
> och <computeroutput
>FIXME</computeroutput
> i vår exempelfil <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
>ser du dem också angivna i verktygsvyn <guilabel
>Problem</guilabel
>:</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="problem-report-marks.png" format="PNG"/>
</imageobject>
<caption
><para
>Problemrapporten som anger rader som kräver uppmärksamhet i nuvarande fil som redigeras.</para
></caption>
</mediaobject>
</screenshot>

<para
>Observera övriga flikar i verktygsvyn <guilabel
>Problem</guilabel
>, i synnerhet <guilabel
>Fixa</guilabel
> och <guilabel
>Uppgift</guilabel
>. Om du öppnar den ser du alla rader markerade med <computeroutput
>FIXME</computeroutput
> och <computeroutput
>TODO</computeroutput
> som &tdevelop; hittills har hittat i sessionen. Informationen om <computeroutput
>TODO</computeroutput
> set för närvarande ut på följande sätt:</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="problem-report-all-todos.png" format="PNG"/>
</imageobject>
<caption
><para
>Problemrapporten har samlat information om <computeroutput
>TODO</computeroutput
>.</para
></caption>
</mediaobject>
</screenshot>

<para
>Fliken <guilabel
>Fel</guilabel
> listar dock inte varje kodningsfel som du gör. Det arbetet utförs av andra verktyg under byggprocessen. Här hittar du information om några vanliga programmeringsmisstag, som troligen annars skulle förbli obemärkta och troligen med svårighet hittas via komplicerade avlusningssessioner.</para>

<para
>Du kommer att märka att problemrapportfunktionen i &tdevelop; är ett mycket värdefullt verktyg, så kontrollera verktygsvyn <guilabel
>Problem</guilabel
> regelbundet under utvecklingsprocessen.</para>
</sect2>
</sect1>

<sect1 id="gettingstarted-compile">
<title
>Hur man kompilerar ett projekt</title>

<para
>Att kompilera ett projekt i &tdevelop; kräver flera inställningssteg och därefter att programmet byggs. Allt detta är tillgängligt via menyn <guimenu
>Bygg</guimenu
>.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="build-menu.png" format="PNG"/>
</imageobject>
<caption
><para
>Att bygga ett projekt kräver flera steg.</para
></caption>
</mediaobject>
</screenshot>

<para
>För närvarande är vi bara intresserade av menyns övre del. Alternativen är där sorterade efter hur viktiga de är. Därför är kommandot som oftast behövs längst upp, alternativet <guimenuitem
>Bygg projekt</guimenuitem
> som gör att hela projektet initieras, kompileras och länkas efter behov. Andra alternativ finns för att kompilera valda delar av projektet, eller bara en enstaka fil, för att utföra flera olika initieringssekvenser, eller för att installera det färdiga programmets binärfiler.</para>

<para
>För tillfället koncentrerar vi oss på flera funktioner som &tdevelop; tillhandahåller för att ställa in projektet, initiera, bygga och köra programmet. I allmänhet omfattar det:</para>

<simplelist>
<member
><link linkend="gettingstarted-compile-basic"
>Ta en snabb titt på den grundläggande byggcykeln.</link
></member>
<member
><link linkend="gettingstarted-compile-setup"
>Titta på några enkla sätt att anpassa ett projekt.</link
></member>
</simplelist>

<sect2 id="gettingstarted-compile-basic">
<title
>Den grundläggande byggcykeln</title>

<para
>När man väl har skapat ett nytt projekt, vill man oftast kontrollera om allt hittills har gått bra. Det omfattar att bygga projektet för första gången och testköra programmet, vilket vi ska göra nu. För att kompilera ett projekt för första gången finns det flera steg att utföra, som vi tar en snabb titt på:</para>
<simplelist>
<member
><link linkend="gettingstarted-compile-basic-init"
>Hur projektet initieras för att bygga det första gången.</link
></member>
<member
><link linkend="gettingstarted-compile-basic-config"
>Hur de ursprungliga inställningarna görs.</link
></member>
<member
><link linkend="gettingstarted-compile-basic-build"
>Hur man bygger projektet.</link
></member>
<member
><link linkend="gettingstarted-compile-basic-run"
>Hur programmet körs inifrån &tdevelop;.</link
></member>
</simplelist>

<note>
<para
>Beskrivningen förutsätter att projektet är baserat på &GNU; autotools, vilket aktiverar Hantering av automake i &tdevelop;, liksom vårt exempelprojekt Hello. Om du skapar en annan projektttyp, t.ex. för &Qt;-baserad projekthantering med <application
>QMake</application
>, finns andra funktioner tillgängliga i menyerna, eller kanske inte några av dem. Du måste använda respektive leverantörs dokumentation om projekthantering och hur man bygger projekt i dessa fall.</para>
</note>

<sect3 id="gettingstarted-compile-basic-init">
<title
>Initiera projektet så att det kan byggas</title>

<para
>När programguiden skapade vårt exempelprojekt Hello, lämnade den det i ett sorts <quote
>orört</quote
> utgångstillstånd. Verktygskedjan i &GNU; autotools kräver att flera initieringssteg utförs innan programmet verkligen kan kompileras och länkas. Om du försöker bygga ett projekt när det är i detta utgångstillstånd, t.ex. genom att välja <menuchoice
><guimenu
>Bygg</guimenu
> <guimenuitem
>Bygg projekt</guimenuitem
></menuchoice
> eller trycka på funktionstangenten <keycap
>F8</keycap
>, får du följande varning:</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="raw-project-warning.png" format="PNG"/>
</imageobject>
<caption
><para
>Försöker bygga ett obehandlat projekt baserat på automake.</para
></caption>
</mediaobject>
</screenshot>

<para
>Du kan klicka på knappen <guibutton
>Kör dem</guibutton
>, vilket gör att &tdevelop; automatiskt försöker köra alla inställningssteg som krävs innan programmet kompileras och länkas. Men vi ska titta på de inledande stegen i följd, så avbryt dialogrutan genom att klicka på <guibutton
>Kör inte</guibutton
>. </para>

<para
>Som redan har nämnts utförs kompilering och länkning av programmet via menyn <guimenu
>Bygg</guimenu
>. Visa den och välj <guimenuitem
>Kör automake och besläktade program</guimenuitem
>.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="build-menu-automake.png" format="PNG"/>
</imageobject>
<caption
><para
>Starta en grundläggande initieringskörning.</para
></caption>
</mediaobject>
</screenshot>

<para
>&tdevelop; öppnar nu verktygsvyn <guilabel
>Meddelanden</guilabel
> längst ner och visa en följd av meddelanden som skapas av flera olika byggverktyg. Om allting gick bra, ska den sista raden lyda: <quote
><computeroutput
>*** Lyckades ***</computeroutput
></quote
>.</para>

<para
>Om du rullar tillbaka längst upp, hittar du kommandoraden som &tdevelop; utförde för att anropa verktygen i bakgrunden:</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
>Det säger att &tdevelop; först bytte till vårt exempelprojekts rotkatalog. Därefter skapades en särskild miljö, som talar om för byggsystemet vilka versioner av <application
>autoconf</application
> och <application
>automake</application
> som används för initieringen. Till sist instruerades byggverktyget (&GNU; <application
>gmake</application
> i detta fall) att behandla byggfilen <filename
>Makefile.cvs</filename
>.</para>

<para
>Byggfilen skapades automatiskt när projektet Hello skapades.Den innehåller alla kommandon som behövs för att initiera projektet rätt, så att programmet som skapas kan köras i &kde;. I synnerhet skapar den skripfilen <filename
>configure</filename
> som är nödvändig för att utföra nästa inställningssteg.</para>
</sect3>

<sect3 id="gettingstarted-compile-basic-config">
<title
>Inledande konfiguration av Hello</title>

<para
>Att konfigurera betyder att anpassa byggprocessen till egenheter hos hårdvaran och programvaran i systemet. Det är ett grundkrav i byggprocesser baserade på &GNU; autotools, som du troligen redan vet.</para>

<para
>Du kan först beordra en konfigureringssekvens när den grundläggande initieringen av automake har avslutats med lyckat resultat, eftersom de nödvändiga <filename
>configure</filename
>-filerna inte är tillgängliga förrän efter den inledande körningen. När den är gjord, välj menyalternativet <menuchoice
><guimenu
>Bygg</guimenu
> <guimenuitem
>Kör configure</guimenuitem
></menuchoice
> för att påbörja konfigureringssekvensen.</para>

<para
>&tdevelop; öppnade verktygsvyn <guilabel
>Meddelanden</guilabel
> igen om det behövdes, och listade meddelanden från körningen av configure i den. Om allt gick bra, är de sista meddelandena <quote
><computeroutput
>Good - your configure finished. Start make now</computeroutput
></quote
> (som skrevs ut av configure) följt av meddelandet <quote
><computeroutput
>*** Lyckades ***</computeroutput
></quote
> från &tdevelop;.</para>

<para id="gettingstarted-compile-basic-config-cmd"
>Längst upp i fönstret <guilabel
>Meddelanden</guilabel
> hittar du åter kommandoraden som &tdevelop; använde för att starta konfigurationen:</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
>Du kan se flera intressanta detaljer i kommandona.</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
>För det första använder &tdevelop; en särskild underkatalog i projektets katalogträd för byggprocessen. Byggkatalogen <filename class="directory"
>debug</filename
> (som visas till vänster) speglar den grundläggande projektstrukturen och innehåller en mängd byggrelaterade filer, som flera <filename
>configure</filename
>-baserade filer och dessutom en <filename
>Makefile</filename
> i varje underkatalog.</para>
</listitem>
<listitem>
<para
>I det närmast följande avsnittet <link linkend="gettingstarted-compile-setup"
>Anpassa projektet</link
> ger vi en kortfattad beskrivning av motiven till att &tdevelop; använder separata byggkataloger i fall som dessa. För ögonblicket är det nog att veta att &tdevelop; skapade katalogen <filename class="directory"
>debug</filename
> (om det behövdes) innan anropet till configure, och att skriptet <filename
>configure</filename
> skapade delstrukturen och alla <filename
>Makefile</filename
> i den.</para>
</listitem>
<listitem>
<para
>Därefter, anropade &tdevelop; skriptet <filename
>configure</filename
> inifrån byggkatalogen <filename class="directory"
>debug</filename
> i vårt projekts rotkatalog med en särskild miljö, där argumenten <computeroutput
>CXXFLAGS="-O0 -g3"</computeroutput
> senare talar om för &gcc;-kompilatorn att den inte ska optimera binärfilerna som skapas, och att den ska inkludera fullständig avlusningsinformation i dem.</para>
</listitem>
<listitem>
<para
>Till sist anropas skriptet <filename
>configure</filename
> med alternativet <computeroutput
>--enable-debug=full</computeroutput
> som talar om för det att skapa varje <filename
>Makefile</filename
> så att efterföljande kompilering och länkning får all nödvändig avlusningsinformation inbyggd och användbar.</para>
</listitem>
</itemizedlist>
</entry>
</row
></tbody
></tgroup>
</informaltable>

<para
>Alla inställningarna kan anpassa för varje projekt. Du kommer att lära dig mer om det i kapitlet <link linkend="project-management"
>Projekthantering</link
>.</para>
</sect3>

<sect3 id="gettingstarted-compile-basic-build">
<title
>Bygga projektet</title>

<para
>När du väl har kommit så här långt är du klar att verkligen bygga, dvs. kompilera och länka programmet. Genom att titta i menyn <guimenu
>Bygg</guimenu
>, ser du att det finns tre sådana kompileringsalternativ att välja bland.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="build-commands.png" format="PNG"/>
</imageobject>
<caption
><para
>Kommandon i &tdevelop; för att bygga binärfiler.</para
></caption>
</mediaobject>
</screenshot>

<para
>Nerifrån och uppåt, finns det:</para>
<itemizedlist>
<listitem>
<para
><guimenuitem
>Kompilera fil</guimenuitem
>: Det kompilerar källkodsfilen i redigeringsfönstret som för närvarande är öppet. Används oftast för snabb kontroll av fel.</para>
</listitem>
<listitem>
<para
><guimenuitem
>Bygg aktivt mål</guimenuitem
>: Det används i huvudsak i samband med <link linkend="gettingstarted-extend-automake"
>Hantering av automake</link
>, som vi tar en snabb titt på nedan.</para>
</listitem>
<listitem>
<para
><guimenuitem
>Bygg projekt</guimenuitem
>: Det är vad vi nu är intresserade av. Det går igenom hela projektet, kompilerar och länkar filer där det är nödvändigt.</para>
</listitem>
</itemizedlist>

<para
>Det kan vara intressant att se vad som händer med katalogen <filename class="directory"
>debug</filename
> som skapades under föregående körning av <filename
>configure</filename
>. Därför är det bäst att behålla den öppen med alla underkataloger synliga, som visas ovan. Välj därefter <menuchoice
><guimenu
>Bygg</guimenu
> <guimenuitem
>Bygg projekt</guimenuitem
></menuchoice
> (eller tryck på tangenten <keycap
>F8</keycap
>) för att påbörja byggsekvensen. Som tidigare öppnas verktygsvyn <guilabel
>Meddelanden</guilabel
> längst ner och listar resultatet av byggkörningen. Dessutom dyker några filer upp i underkatalogträdet <filename class="directory"
>debug</filename
>.</para>

<para id="gettingstarted-compile-basic-build-cmd"
>Det finns inte många källkodsfiler i vårt exempelprojekt Hello, alltså kommer fönstret <guilabel
>Meddelanden</guilabel
> bara innehålla några få rader. Leta återigen rätt på kommandoraden ovanför dem som &tdevelop; skickade till skalet i bakgrunden.</para>

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

<para
>&tdevelop; bytte till <filename class="directory"
>debug</filename
>-delträdets rot, vilket inte borde vara förvånande, för att köra filen <filename
>Makefile</filename
> som finns där. En särskild delmiljö skapades igen, som tidigare i <link linkend="gettingstarted-compile-basic-init"
>initieringssteget</link
>, i vilken verktyget <application
>gmake</application
> anropades.</para>

<para
>Observera väljaren <computeroutput
>-k</computeroutput
> i anropet av <application
>gmake</application
>. Den tvingar byggprocessen att fortsätta till sitt slut, även om fel skulle uppstå. Det är vettigt eftersom &tdevelop; kommer att lista alla felmeddelanden i fönstret <guilabel
>Meddelanden</guilabel
>. Om det finns några, dra nytta av fördelarna med den integrerade utvecklingsmiljön: klicka bara på felmeddelandet i fönstret <guilabel
>Meddelanden</guilabel
> så går &tdevelop; till det exakta stället där felet uppstod i källkodsfilen.</para>

<para
>Och vad hände inne i delträdet <filename class="directory"
>debug</filename
>? Inte så mycket. Några få filer dök upp i grenarna <filename class="directory"
>doc/en</filename
> och <filename class="directory"
>src</filename
>, i synnerhet filen <filename
>hello</filename
> i <filename class="directory"
>/home/devel/projects/hello/debug/src/</filename
>. Den är, till sist, programmets binärfil som vi sökte. Allt som är kvar att göra i vår inledande kontroll av projektet är att köra <filename
>hello</filename
>.</para>
</sect3>

<sect3 id="gettingstarted-compile-basic-run">
<title
>Köra programmet</title>

<para
>Det finns inte några extra steg inblandade för att köra det nya programmet hello. Välj antingen <menuchoice
><guimenu
>Bygg</guimenu
> <guimenuitem
>Kör program</guimenuitem
></menuchoice
>, tryck på <keycombo
><keycap
>Skift</keycap
> <keycap
>F9</keycap
></keycombo
> eller använd knappen <guibutton
>Kör program</guibutton
> i <guilabel
>byggverktygsraden</guilabel
> som visas nedan.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="run-button.png"/>
</imageobject>
<caption
><para
>Köra ett program från <guilabel
>Byggverktygsraden</guilabel
>.</para>
</caption>
</mediaobject>
</screenshot>

<para
>Det är allt. &tdevelop; startar nu det nya programmet i ett särskilt terminalfönster som verktygsvyn <guilabel
>Program</guilabel
> längst ner. Där visas kommandot som &tdevelop; utförde för att köra programmet på raden längst upp:</para>

<programlisting
>./hello
</programlisting>

<para
>som visar att den integrerade utvecklingsmiljön har en uppfattning om var programmet som ska köras finns. Denna uppfattning kan ställas in på många sätt. Se mer om detta i kapitlet <link linkend="project-management"
>Projekthantering</link
>.</para>

<para
>Raden <computeroutput
>./hello</computeroutput
> följs troligen av ett varningsmeddelande. Ignorera det för tillfället. Det förhindrar inte att vårt program <application
>hello</application
> kör.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="hello-world-app.png" format="PNG"/>
</imageobject>
<caption>
<para
>Vårt ursprungliga <application
>Hello</application
>-program.</para>
</caption>
</mediaobject>
</screenshot>

<para
>Stäng programfönstret <application
>Hello</application
> som vanligt. Om inga fel uppstod rapporterar &tdevelop; det som <quote
><computeroutput
>*** Avslutade normalt ***</computeroutput
></quote
> i verktygsvyn <guilabel
>Program</guilabel
>.</para>
</sect3>
</sect2>

<sect2 id="gettingstarted-compile-setup">
<title
>Anpassa projektet</title>

<para
>Det finns åtskilliga sätt att hantera ett projekt i &tdevelop;. Beteendet kan ställas in för varje projekt, och är mest intressant för avancerade utvecklare. Det finns dock några få projektspecifika inställningar som du bör känna till ända från början. </para>

<simplelist>
<member
><link linkend="gettingstarted-compile-setup-build"
>Varför är bygginställningar användbara?</link
></member>

<member
><link linkend="gettingstarted-compile-setup-config"
>Var beteendet hos skriptet <filename
>configure</filename
> ska definieras.</link
></member>

<member
><link linkend="gettingstarted-compile-setup-make"
>Några överväganden om hur <application
>make</application
> ska köras.</link
></member>

<member
><link linkend="gettingstarted-compile-setup-run"
>Var ska det körbara programmet finnas, och vad ska det heta?</link
></member>
</simplelist>

<sect3 id="gettingstarted-compile-setup-build">
<title
>Bygginställningar</title>

<para
>När vi körde skriptet <filename
>configure</filename
> i avsnittet <link linkend="gettingstarted-compile-basic-config"
>Inledande konfiguration av Hello</link
> ovan, noterade vi att &tdevelop; hade skapat den särskilda underkatalogen <filename class="directory"
>debug</filename
> för detta syfte. I detta avsnitt behandlar vi kortfattat några konsekvenser av denna funktion.</para>

<para
>För det första använder &tdevelop; inte nödvändigtvis särskilda byggkataloger skilda från källkoden. Förberedelser för att automatiskt använda särskilda bygginställningar görs via de mallar som programguiden använder när ett nytt projekt skapas.</para>

<para
>För att ta reda på vilka bygginställningar som för närvarande är tillgängliga, ta en titt på menyn <menuchoice
><guimenu
>Projekt</guimenu
> <guisubmenu
>Bygginställning</guisubmenu
></menuchoice
>.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="build-configurations.png" format="PNG"/>
</imageobject>
<caption
><para
>Det finns olika bygginställningar tillgängliga i projektet.</para
></caption>
</mediaobject>
</screenshot>

<para
>I detta fall, som i vårt exempelprojekt Hello, finns det tre olika tillgängliga bygginställningar. I andra fall kanske det bara finns en sådan bygginställning från början, nämligen <guimenuitem
>default</guimenuitem
>.</para>

<para
>Bygginställningen som för närvarande används har en bock till vänster. Välj helt enkelt menyalternativet för att byta till en annan bygginställning.</para>

<para
>Låt oss nu ta en snabbtitt på vad bygginställningarna tillhandahåller.</para>

<variablelist id="gettingstarted-compile-setup-build-configs">
<varlistentry>
<term
><guimenuitem
>debug</guimenuitem
></term>
<listitem>
<para
>Du bör använda bygginställningen som standard under utvecklingsprocessen. Den byggs separat från källkodskatalogerna i den särskilda underkatalogen <filename class="directory"
>debug</filename
>, dvs. alla objektfiler, extrafiler och körbara filer placeras i dess underkataloger istället för motsvarande kataloger i projektets rot. Skriptet <filename
>configure</filename
> får väljaren <computeroutput
>--enable-debug=full</computeroutput
> och argumentet <computeroutput
>CXXFLAGS="-O0 -g3"</computeroutput
> talar om för &gcc;-kompilatorn att inte optimera koden och att infoga omfattande avlusningsinformation i de binärfiler som skapas.</para>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenuitem
>optimized</guimenuitem
></term>
<listitem>
<para
>Den här används för att bygga det slutliga C++ programmet. Den byggs separat från källkodskatalogerna i den särskilda underkatalogen <filename class="directory"
>optimized</filename
>. Skriptet <filename class="directory"
>configure</filename
> har inga särskilda förinställda väljare, medan <computeroutput
>CXXFLAGS="-O2 -g0"</computeroutput
> talar om för &gcc;-kompilatorn att optimera koden och inte infoga avlusningsinformation i de binärfiler som skapas.</para>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenuitem
>default</guimenuitem
></term>
<listitem>
<para
>Beteckningen <quote
>default</quote
> anger standardinställningen när ett program byggs i en terminal med t.ex. &GNU; byggverktygen <application
>configure</application
> och <application
>make</application
>/<application
>gmake</application
> på kommandoraden. I motsats till <guimenuitem
>debug</guimenuitem
> eller <guimenuitem
>optimized</guimenuitem
> används ingen särskild byggkatalog. Programmet byggs istället normalt i källkodskatalogerna. Inga särskilda konfigurationsväljare är fördefinierade. När programmet byggs och körs används de underliggande verktygens standardinställningar (t.ex. &gcc;, etc.).</para>

<warning>
<para
>Tänk efter ordentligt innan du bestämmer dig för att använda bygginställningen <guimenuitem
>default</guimenuitem
>.</para>

<para
>Den kan inte användas parallellt med de särskilda inställningarna <guimenuitem
>debug</guimenuitem
> och <guimenuitem
>optimized</guimenuitem
>. <emphasis
>Alla byggåtgärder som använder <guimenuitem
>default</guimenuitem
> gör att de båda andra bygginställningarna blir oanvändbara.</emphasis
> Det beror på några egenheter hos processen som skapar <filename
>Makefile</filename
> med mekanismerna i <application
>automake</application
> och <application
>autoconf</application
>, som inte är enkelt att få bukt med.</para>
</warning>
</listitem>
</varlistentry>
</variablelist>

<para
>Varför vill man då använda olika bygginställningar överhuvudtaget, när de till och med inte verkar fungera tillsammans? Svaret är att det förenklar cykler med redigering, kompilering och avlusning. De extra avlusningsinstruktionerna som infogas i binärfilerna samt alla de subtila strukturändringarna som görs av programkoden under optimering påverkar beteendet när det körs för programmet som skapas. När den logiska strukturen hos en viss rutin verkar vara riktig, borde du testa om den fortfarande beter sig riktigt under mer realistiska förhållanden.</para>

<para
>Det är då bygginställningarna i &tdevelop; gör nytta. Eftersom byggobjekt och körbara filer i varje särskild byggkatalog, och byggkommandon, hålls åtskilda från varandra behöver bara ändringar av källkod hanteras när du byter mellan bygginställningarna.</para>

<para
>Istället för att rensa och kompilera om allt från början med andra inställningar, behöver du alltså bara byta från bygginställningen <guimenuitem
>debug</guimenuitem
> till <guimenuitem
>optimize</guimenuitem
>, kompilera ändringarna av källkoden och därefter starta om programmet under dessa förhållanden. Om något olämpligt visar sig, byt helt enkelt tillbaka till <guimenuitem
>debug</guimenuitem
>, och fortsätt omedelbart arbeta där.</para>

<para
>En sista anmärkning: Många bygginställningar kan anpassas. Du kan till och med definiera dina egna bygginställningar om utvecklingsprocessen kräver det. Vi tar en snabb titt på dessa möjligheter i nästa avsnitt.</para>
</sect3>

<sect3 id="gettingstarted-compile-setup-config">
<title
>Konfigurationsalternativ för projektet</title>

<para
>Att konfigurera programmet riktigt är livsviktigt i byggkedjan baserad på &GNU; autotools. Det styrs ofta av väljare för skriptet <filename
>configure</filename
> och/eller särskilda argumentinställningar i miljön innan <filename
>configure</filename
> körs, som t.ex. <computeroutput
>CXXFLAGS</computeroutput
> i vår tidigare beskrivning.</para>

<para
>Du kan ställa in de flesta konfigurationsalternativen för ett givet projekt från &tdevelop;s grafiska gränssnitt. Välj <menuchoice
><guimenu
>Projekt</guimenu
> <guimenuitem
>Projektinställningar</guimenuitem
></menuchoice
> och därefter ikonen <guiicon
>Inställning av configure</guiicon
> på ikonraden till vänster i dialogrutan. Sidan <guilabel
>Inställning av configure</guilabel
> som innehåller flera flikfönster visas till höger.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="configure-project-configure.png" format="PNG"/>
</imageobject>
<caption
><para
>De flesta inställningarna av configure kan anges här.</para
></caption>
</mediaobject>
</screenshot>

<para
>Som du märker, finns det ett ganska stort antal alternativ som kan anges i dialogrutan. För tillfället tittar vi kortfattat på ett fåtal av dem med avseende på vårt exempelprojekt Hello. För detaljerade instruktioner, se kapitlet <link linkend="projects-configure"
>Konfigurera projekt</link
>. Om du vill veta mer om betydelsen hos olika argument som kan anges, slå upp <command
>info make</command
> i en terminal (eller <command
>info:make</command
> inne i &konqueror;) och titta i avsnittet <menuchoice
><guimenu
>Implicit Rules</guimenu
> <guimenuitem
>Implicit Variables</guimenuitem
></menuchoice
>.</para>

<para
>Det finns flera inställningsfönster med flikar i dialogrutan, där det första, <guilabel
>Allmän</guilabel
>, visar ofta använda inställningar, medan de övriga är ganska kompilatorspecifika. Under alla omständigheter, styrs dock det verkliga innehållet i dialogrutorna av angiven bygginställning.</para>

<para
>Du väljer bygginställningen vars inställningsalternativ ska definieras i kombinationsrutan <guilabel
>Inställning</guilabel
> längst upp i dialogrutan <guilabel
>Inställning av configure</guilabel
>.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="configure-project-buildconfig.png" format="PNG"/>
</imageobject>
<caption
><para
>Välj bygginställning vars inställningar ska definieras.</para
></caption>
</mediaobject>
</screenshot>

<para
>Välj nu en annan bygginställning i kombinationsrutan och observera hur innehållet i t.ex. textrutorna <guilabel
>Configure-argument</guilabel
> och <guilabel
>Byggkatalog</guilabel
> ändras enligt inställningarna vi nämnde för <link linkend="gettingstarted-compile-setup-build-configs"
>bygginställningslistan</link
> ovan.</para>

<sect4 id="gettingstarted-compile-setup-config-general">
<title
>Allmänna konfigurationsinställningar</title>

<para
>Följande inställningsalternativ kan definieras på sidan <guilabel
>Allmänt</guilabel
> i dialogrutan:</para>

<itemizedlist>
<listitem>
<formalpara>
<title
>Configure-argument</title>
<para
>Detta är alternativen som &tdevelop; tilldelar till anropet av skriptet <filename
>configure</filename
> i byggprocessen. Se <link linkend="gettingstarted-compile-basic-config-cmd"
>exemplet</link
> i avsnittet <quote
>Inledande konfiguration av Hello</quote
> ovan.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Byggkatalog</title>
<para
>Detta är underkatalogen i nuvarande projektrot, där &tdevelop; placerar alla filer som skapas under byggprocessen. Idealiskt borde det motsvara namnet på bygginställningen som används, men du har möjlighet att använda vilket namn du vill, under förutsättning att det är annorlunda än alla andra byggkataloger.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Övre källkatalog</title>
<para
>Du behöver inte den här ofta. Dess standardvärde är projektets rotkatalog, och den behöver bara definieras om om projektets källkod är placerad någon annanstans.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>C/C++ preprocessorargument(CPPFLAGS)</title>
<para
>Skriv in särskilda instruktioner för preprocessorn här. &tdevelop; använder det för att skapa en tillfällig miljö innan själva byggverktyget anropas. Se återigen <link linkend="gettingstarted-compile-basic-config-cmd"
>exemplet</link
> i avsnittet <quote
>Inledande konfiguration av Hello</quote
> ovan hur det görs.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Länkargument (LDFLAGS)</title>
<para
>Det här är extra information för länkarverktyget <application
>ld</application
>, om var det ska leta efter ytterligare bibliotek. Den används också för att skapa den tillfälliga byggmiljön.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Miljövariabler</title>
<para
>Här kan du definiera ytterligare variabler som ska ställas in i den tillfälliga byggmiljön som &tdevelop; skapar innan respektive byggverktyg anropas. Återigen, måste du definiera miljövariablerna för varje bygginställning där de ska användas.</para>
</formalpara>
</listitem>
</itemizedlist>
</sect4>

<sect4 id="gettingstarted-compile-setup-config-spec">
<title
>Kompilatorspecifika inställningar</title>

<para
>Övriga flikar på dialogsidan <guilabel
>Inställning av configure</guilabel
> är till för kompilatorspecifika inställningar. De är strukturerade på liknande sätt, så det är tillräckligt att snabbt titta på sidan <guilabel
>C++</guilabel
>.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="configure-project-cpp.png" format="PNG"/>
</imageobject>
<caption
><para
>Välj kompilator som &tdevelop; ska använda och dess arbetsomgivning här.</para
></caption>
</mediaobject>
</screenshot>

<para
>Här kan du ställa in följande:</para>

<itemizedlist>
<listitem>
<formalpara>
<title
>C++ kompilator</title>
<para
>Välj den C++ kompilator som &tdevelop; normalt ska använda i kombinationsrutan. Den listar dock bara de kompilatorer som &tdevelop; redan känner till.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Kompilatorkommando (CXX)</title>
<para
>Bara för experter. Det behövs bara om en annan C++ kompilator än standardkompilatorn används. Skriv in namnet som den anropas med här.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Kompilatorargument (CXXFLAGS)</title>
<para
>Här kan du skriva in eventuella extra alternativ som &tdevelop; ska skicka till kompilatorn (via <filename
>Makefile</filename
>). Vissa alternativvärden är förinställda enligt bygginställning som valts med kombinationsrutan <guilabel
>Inställning</guilabel
>.</para>
</formalpara>

<para
>Observera att många vanliga kompilatoralternativ kan väljas i en dialogruta som dyker upp när du klickar på knappen <guibutton
>...</guibutton
> till höger om textrutan.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="configure-project-cppoptions.png" format="PNG"/>
</imageobject>
<caption
><para
>Använd dialogrutan för att definiera beteendet hos &GNU; C++ kompilatorn.</para
></caption>
</mediaobject>
</screenshot>

<para
>Vi valda med avsikt fliken <guilabel
>Optimering</guilabel
> här. Observera att alternativet <guilabel
>Ingen optimering</guilabel
> är förvald (enligt det förinställda alternativet <guilabel
>-O0</guilabel
> i bygginställningen <computeroutput
>debug</computeroutput
>).</para>

<para
>Tyvärr kan du för närvarande inte välja alla alternativ från dialogrutan  Exempelvis alternativet <computeroutput
>-g3</computeroutput
> som används av bygginställningen <computeroutput
>debug</computeroutput
> måste ändras för hand om det någonsin behövs.</para>
</listitem>
</itemizedlist>
</sect4>
</sect3>

<sect3 id="gettingstarted-compile-setup-make">
<title
>Hur programmet ska byggas av make</title>

<para
>Du kan dessutom anpassa sättet som &tdevelop; anropar verktyget <application
>make</application
> när projektet byggs. Välj <menuchoice
><guimenu
>Projekt</guimenu
> <guimenuitem
>Projektinställningar</guimenuitem
></menuchoice
> och därefter ikonen <guiicon
>Bygginställningar</guiicon
> till vänster i dialogfönstret. Dialogsidan <guilabel
>Bygginställningar</guilabel
> visas då till höger.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="configure-project-make.png" format="PNG"/>
</imageobject>
<caption
><para
>Definiera hur &tdevelop; anropar verktyget <application
>make</application
>.</para
></caption>
</mediaobject>
</screenshot>

<para
>Det finns inte så mycket att göra här just nu. Den enda intressanta inställningen i de flesta fall är alternativet <guilabel
>Avbryt vid första fel</guilabel
>. Du kommer att märka att den är inaktiverad i de flesta projekt. Den motsvarar väljaren <computeroutput
>-k</computeroutput
> i anropet till <application
>gmake</application
> som vi hittade den första gången som exempelprojektet Hello <link linkend="gettingstarted-compile-basic-build-cmd"
>byggdes</link
>.</para>

<para
>Det är vettigt i en integrerad utvecklingsmiljö som &tdevelop;, där alla felmeddelanden under byggningen lagras. Efter byggprocessen kan du enkelt gå till vilket felmeddelande som helst i verkygsfönstret <guilabel
>Meddelanden</guilabel
>. Använd <menuchoice
><guimenu
>Visa</guimenu
> <guimenuitem
>Nästa fel</guimenuitem
></menuchoice
> och <menuchoice
><guimenu
>Visa</guimenu
> <guimenuitem
>Föregående fel</guimenuitem
></menuchoice
> eller tangenterna <keycap
>F4</keycap
> och <keycombo
><keycap
>Skift</keycap
> <keycap
>F4</keycap
></keycombo
> för att göra det. &tdevelop; aktiverar automatiskt redigeringsfönstret för källkodsfilen i fråga och placerar markören på den felaktiga raden.</para>

<para
>Om du å andra sidan hellre vill att byggningen ska stoppas så snart ett fel uppstår, markera alternativet <guilabel
>Avbryt vid första fel</guilabel
> i dialogrutan. &tdevelop; anropar du <application
>gmake</application
> utan väljaren <computeroutput
>-k</computeroutput
>.</para>
</sect3>

<sect3 id="gettingstarted-compile-setup-run">
<title
>Hur det körbara programmet startas</title>

<para
>När byggningen väl är färdig, kan du enkelt köra programmet inifrån &tdevelop;. Använd antingen <menuchoice
><guimenu
>Bygg</guimenu
> <guimenuitem
>Kör program</guimenuitem
></menuchoice
>, snabbtangenten <keycombo
><keycap
>Skift</keycap
> <keycap
>F9</keycap
></keycombo
> eller knappen <guibutton
>Kör program</guibutton
> i &tdevelop;s <guilabel
>byggverktygsrad</guilabel
>.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="run-button.png" format="PNG"/>
</imageobject>
<caption
><para
>Kör programmet här.</para
></caption>
</mediaobject>
</screenshot>

<para
>Men var finns det körbara programmet som ska köras? Hur får man &tdevelop; att lägga till väljare i anropet? Eller hur kan man få programmet att köras i en egen terminal för att testa interaktivt beteende i terminalen?</para>

<para
>Allt det kan lösas genom att ställa in några projektorienterade köralternativ i &tdevelop;. Välj <menuchoice
><guimenu
>Projekt</guimenu
> <guimenuitem
>Projektinställningar</guimenuitem
></menuchoice
> och därefter ikonen <guiicon
>Körinställningar</guiicon
> i ikonraden till vänster i dialogfönstret. Dialogsidan <guilabel
>Körinställningar</guilabel
> visas till höger.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="configure-project-run.png" format="PNG"/>
</imageobject>
<caption
><para
>Definiera var och hur programmet ska köras.</para
></caption>
</mediaobject>
</screenshot>

<para
>Det finns en hel del som kan ställas in i dialogrutan. Det finns egentligen fyra grupper av inställningsalternativ.</para>

<itemizedlist>
<listitem>
<formalpara>
<title
>Katalog</title>
<para
>Talar om för &tdevelop; vad det ska förutsätta att det körbara programmet kallas. Det finns tre möjligheter att välja bland.</para>
</formalpara>

<para
>Observera dock att bara rotkataloger definieras här. &tdevelop; letar oftast efter det körbara programmet i någon underkatalog som anges i följande grupp av inställningar.</para>

<itemizedlist>
<listitem>
<para
>Kör från katalogen där det körbara programmet senast byggdes. Det är normalvärdet. Du kan behålla det för ögonblicket.</para>
</listitem>

<listitem>
<para
>Kör från byggkatalogen enligt <link linkend="gettingstarted-compile-setup-build"
>bygginställning</link
> som för närvarande är vald. Katalognamnet ställdes in på dialogsidan <link linkend="gettingstarted-compile-setup-config-general"
>Allmän</link
>.</para>

<para
>Detta är rotkatalogen där &tdevelop; ska hitta det körbara programmet. Den ändras automatiskt enligt valet du gjorde i menyn <menuchoice
><guimenu
>Projekt</guimenu
> <guisubmenu
>Bygginställningar</guisubmenu
></menuchoice
>. Prova det.</para>

<para
>Förutom att alltid köra det senast byggda körbara programmet enligt inställningen ovan, låter det dig byta program att köra genom att helt enkelt välja en annan bygginställning i menyn <guimenu
>Projekt</guimenu
>.</para>
</listitem>

<listitem>
<para
>Kör programmet som hittas i en fast egen katalog. Återigen är det bara rotkatalogen där själva den körbara filen finns.</para>

<para
>Använd det om du t.ex. vill köra programmet som verkligen har installerats istället för versionen som finns i projektkatalogen.</para>
</listitem>
</itemizedlist>
</listitem>

<listitem>
<formalpara>
<title
>Program</title>
<para
>Detta talar om relativ plats och namn på programmet som verkligen ska anropas för &tdevelop;. Det är relativt i förhållande till rotkatalogen som definieras i inställningsgruppen ovan. Dessutom kan du definiera alla argument som &tdevelop; ska skicka till programmet när det verkligen anropas.</para>
</formalpara>

<note>
<para
>Om textrutan <guilabel
>Huvudprogram</guilabel
> lämnas tom, används inställningen av <emphasis
>aktivt mål</emphasis
> i Hantering av automake. Även om detta är en expertinställning, är en vanlig orsak till problem att detta inmatningsfält har lämnats tomt. Kontrollera inställningen om &tdevelop; inte verkar anropa det körbara program du ville.</para>
</note>
</listitem>

<listitem>
<formalpara>
<title
>Miljövariabler</title>
<para
>&tdevelop; skapar en särskild skalmiljö att köra programmet i. Definiera eventuella extra miljövariabler i denna grupp av inställningar.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Diverse</title>
<para
>Ytterligare två kryssrutor finns längst ner på dialogsidan.</para>
</formalpara>

<itemizedlist>
<listitem>
<para
><guilabel
>Kompilera automatiskt innan körning</guilabel
> är oftast praktiskt. &tdevelop; kontrollerar om projektet har ändrats och utför nödvändiga konfigurerings- och byggsteg åt dig så snart du ger kommandot att köra programmet.</para>

<para
>Avmarkera det om du vill köra en programversion tidigare än den senaste ändringen.</para>
</listitem>

<listitem>
<para
><guilabel
>Starta i extern terminal</guilabel
> är intressant om du vill prova in- och utmatningsbeteende för program utan grafiskt gränssnitt i ett terminalprogram. Det är normalt inte markerat, så &tdevelop; startar programmet i ett eget fönster utan in- och utmatningsmöjlighet via en terminal.</para>
</listitem>
</itemizedlist>
</listitem>
</itemizedlist>
</sect3>
</sect2
> 
</sect1>

<sect1 id="gettingstarted-extend">
<title
>Hur ett projekt kan utökas: Hantering av automake</title>

<para
>(ännu inte skrivet ...)</para>

<sect2 id="gettingstarted-extend-automake">
<title
>En snabbtitt på maskineriet i automake</title>

<para
>(ännu inte skrivet ...)</para>
</sect2
> 

<sect2 id="gettingstarted-extend-pics">
<title
>Hur man placerar ikoner i en separat katalog</title>

<para
>(ännu inte skrivet ...)</para>
</sect2
> 

<sect2 id="gettingstarted-extend-class">
<title
>Hur man lägger till nya klasser</title>

<para
>(ännu inte skrivet ...)</para>

<caution
><para
>Var försiktig när du väljer filnamn för klasser. Det är extremt svårt att ändra dem senare.</para
></caution>
</sect2
> 

<sect2 id="gettingstarted-extend-subproject">
<title
>Vad finns i ett delprojekt?</title>

<para
>(ännu inte skrivet ...)</para>

<sect3 id="gettingstarted-extend-subproject-active">
<title
>Koncentrera dig på ditt arbete: Det aktiva målet</title>

<para
>(ännu inte skrivet ...)</para>
</sect3
> 
</sect2
> 

<sect2 id="gettingstarted-extend-restructure">
<title
>Några steg för att strukturera om ett projekt</title>

<para
>(ännu inte skrivet ...)</para>
</sect2
> 
</sect1>


<sect1 id="gettingstarted-debug">
<title
>Hur man avlusar</title>

<para
>(ännu inte skrivet ...)</para>
</sect1
> 


<sect1 id="gettingstarted-doc">
<title
>En anmärkning om projektdokumentationen</title>

<para
>&kde;-projektet använder <ulink url="http://www.docbook.org/tdg5/en/html/docbook.html"
>docbook</ulink
> för att skapa projektets handbok (dvs. användarmanualen). Hanboken är tillgänglig via programmets menyrad genom att välja <menuchoice
><guimenu
>Hjälp</guimenu
> <guimenuitem
>Handbok <replaceable
>programnamn</replaceable
></guimenuitem
></menuchoice
> när programmets grafiska gränssnitt visas i &kde;. Efter att projektet har byggts, visas handboken i &kde;:s Hjälpcentral. Den ska förklara för användaren hur programmet fungerar, vilka huvudfunktionerna är och hur det anpassas. Den ska också förklara avancerade funktioner, om några sådana finns. </para>
<para
>Alla &kde;-baserade mallar i &tdevelop; har underkatalogen doc, som innehåller mallen <filename
>index.docbook</filename
> i katalogen en, för att komma igång med att skriva användarhandboken. Du redigerar <filename
>index.docbook</filename
> i &tdevelop;, och börjar med att ändra personlig information som namn, e-post, etc. Titta på kommentarerna i filen och försök följa anvisningarna för att påbörja programdokumentationen. Bygg om projektet för att se ändringarna i Hjälpcentralen.</para>
<note
><para
>Du måste installera projektet med <menuchoice
><guimenu
>Bygg</guimenu
> <guimenuitem
>Installera</guimenuitem
></menuchoice
> eller <guimenuitem
>Installera (som systemadministratör)</guimenuitem
> i &tdevelop; för att kunna se handboken i hjälpcentralen.</para
></note>
<para
>Du hittar mer information om syntaxen för docbook på <ulink url="http://l10n.kde.org/docs/markup/index.html"
>&kde;:s webbplats för dokumentation</ulink
>.</para>
</sect1>

<sect1 id="gettingstarted-keys">
<title
>Sist men inte minst, snabbtangenter</title>

<para
>(ännu inte skrivet ...)</para>
</sect1>

<sect1 id="gettingstarted-whereto">
<title
>Hur går man vidare</title>

<para
>(ännu inte skrivet ...)</para>

<sect2 id="gettingstarted-whereto-faq">
<title
>Problem som man ofta stöter på</title>

<simplelist>
<member
>Kapitlet I korthet</member>
<member
>Sidor med vanliga frågor</member>
<member
>Forum</member>
<member
>E-postlistor</member>
</simplelist>
</sect2>

<sect2 id="gettingstarted-whereto-projects">
<title
>Arbeta med projekt</title>

<para
>(ännu inte skrivet ...)</para>

<sect3 id="gettingstarted-whereto-projects-open">
<title
>Använda befintliga &tdevelop;-projekt</title>

<para
>(ännu inte skrivet ...)</para>
</sect3>

<sect3 id="gettingstarted-whereto-projects-import">
<title
>Importera externa projekt</title>

<para
>(ännu inte skrivet ...)</para>
</sect3>
</sect2>
</sect1>

</chapter>