<?xml version="1.0"  encoding="UTF-8" ?>

<chapter id="kmdr-basics">
<chapterinfo>
<title
>Grunderna i &kommander;</title>
<authorgroup>
<author
><firstname
>Tamara</firstname
> <surname
>King</surname
> <affiliation
><address
> <email
>tik@acm.org</email>
</address
></affiliation>
</author>
<author
><firstname
>Eric</firstname
> <surname
>Laffoon</surname
> <affiliation
><address
> <email
>sequitur@kde.org</email>
</address
></affiliation>
</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
>Grunderna i &kommander;</title>

<!-- This chapter should tell the user how to use your app. You should use as
many sections (Chapter, Sect1, Sect3, etc...) as is necessary to fully document
your application. -->

<sect1 id="concepts">
<title
>Begrepp</title>


<para
>&kommander; konstruerades ursprungligen baserat på ett enkelt begrepp som har visat sig vara i viss mån revolutionerande bland visuella designverktyg. Typiskt låter sådana verktyg dig skapa dialogrutor och kanske gränssnitt med huvudfönster. Ett gränssnitt med huvudfönster är huvudprogramfönstret som oftast har menyer, verktygsrader, statusrad och programområde. Dialogrutor är underordnade fönster som oftast inte har menyer och heter så eftersom deras syfte är att <quote
>utföra en dialog</quote
> eller utbyta information mellan dig och huvudprogrammet. Elementen i en dialogruta kallas för <quote
>grafiska komponenter</quote
>, och du kopplar ditt program till komponenterna. &kommander; är annorlunda eftersom det i grunden är programmeringsfritt här. Det använder begreppet att associera text med de grafiska komponenterna i dialogrutan. Ursprungligen kallades detta <quote
>associerad text</quote
>, men nu kallas det <quote
>&kommander; text</quote
>. Grafiska komponenter i &kommander; dialogrutor kan inkludera innehållet i andra grafiska komponenter genom att referera till det, och en komponent kan referera till sitt eget innehåll med ett <quote
>Specialvärde</quote
> som ser ut så här: @widgetText. Specialvärden är kommandon med en speciell betydelse i &kommander;. Om du skapade en dialogruta med två radeditorkomponenter och kallade den första <quote
>Förnamn</quote
> och den andra <quote
>Efternamn</quote
>, skulle du kunna skapa en knapp och ange dess &kommander; text som <quote
>Mitt namn är @Förnamn @Efternamn</quote
>. Du skulle behöva ange @widgetText i komponenterna för förnamn och efternamn. Kommer du ihåg? Man måste tala om för &kommander; att referera till texten i dem. Du skulle kunna köra det från en <application
>terminal</application
> och det skulle skriva ut strängen åt dig. Det skulle referera till förnamnet på följande sätt: @Förnamn -> hämta komponenten som heter Förnamn(@Förnamn) -> @widgetText -> hämta innehållet i radeditorkomponenten. I detta fall returnerar @Förnamn <quote
>Eric</quote
>. </para>

<para
>Det är &kommander;s enkla kärna. Vad du kan göra med det, är vad som är intressant. För det första är det värt att observera att jämfört med det vanliga angreppssättet i ett språkbaserat verktyg, behöver inte &kommander; programsatser för att definiera operationerna. Det gör &kommander; snabb för utvecklare. För slutanvändare är det mycket enklare än att lära sig språkkonstruktioner. För alla betyder det att det går att fokusera på uppgiften istället för att ständigt ha referensdokumentation tillhands. När någon stöter på ett verktyg som &kommander; för första gången, är den vanliga frågan: <quote
>Var kan jag hitta en användning för det här häftiga verktyget?</quote
> I själva verket används behandling av strängar nästan var man än ser. </para>

<para
>Vad kan &kommander; alltså göra? Här är den renodlade listan med grundfunktionerna. &kommander; kan: </para>

<orderedlist>
<listitem
><para
>Skicka strängar till det anropande programmet via standardutmatningen.</para
></listitem>
<listitem
><para
>Anropa körbara program.</para
></listitem>
<listitem
><para
>Använda &DCOP; för att kommunicera med &kde;-program</para
></listitem>
</orderedlist>

<para
>Om du inte är en programmerare, kanske du vill ha det förklarat så en lekman förstår. I det första fallet, när du startar &kommander; från en terminal, är terminalen det anropande programmet. Det finns ett förhållande mellan det anropande programmet och det skapade här. Att skicka ett meddelande till terminalen görs i det skapade programmet med standardutmatningen, som benämns så eftersom det också finns felutmatning. Detta är intressant eftersom vissa program, som &quantaplus;, använder standardutmatningen för att ta emot information från program som de startar. Så &kommander; dialogrutor kan mata ut sina textsträngar direkt till editorn i &quantaplus; om de anropas från &quantaplus;. Det betyder att &kommander; dialogrutor kan vara användbara utökningar för program. </para>

<para
>Det andra fallet är att anropa ett körbart program. Alla program som kör på ditt system är körbara. Till och med ett skriptprogram körs av skriptets tolk, så tekniskt sett körs det också. &kommander; kan köra kommandon precis som terminalen även om du kör från en meny. Så om du till exempel skulle vilja att det öppnade &GIMP;, skulle du låta en knapp härleda strängen <quote
>gimp</quote
> och placera den i ett specialvärde så här: @exec(gimp). Med bara detta ser du att &GIMP; startas när det används. Du skulle också kunna köra <quote
>ls -l</quote
>, men du skulle bara se utmatningen om du körde från en terminal. </para>

<para
>Det tredje fallet är verkligen mycket intressant. &DCOP; är en förkortning av &kde;:s <emphasis
>D</emphasis
>esktop <emphasis
>CO</emphasis
>mmunication <emphasis
>P</emphasis
>rotocol (protokoll för skrivbordskommunikation) och det är mycket kraftfullt. Ta och kör programmet <application
>kdcop</application
> och ta en titt. Du ser snabbt att alla &kde;-program som följer standarden har saker på gång i &DCOP;, och de bra konstruerade har mycket på gång. Du kan begära alla typer av information i &DCOP;, samt ändra värden på grafiska komponenter med mera. Det finns ett avsnitt om hur &DCOP; används i den här handboken. &kommander; kan skicka &DCOP;-anrop till alla &kde;-program, samt styras från &DCOP;. I själva verket kan du skicka &DCOP; från kommandoraden till alla &kde;-program. Så vad är vitsen med detta? Vitsen är att om du vill utföra en större mängd kommandon, inser du snart att &DCOP; från kommandoraden är tillräckligt för korta kommandon, men kan orsaka fördröjningar om det anropas flera hundra gånger från en snurra. Det är därför &kommander; har ett @dcop specialvärde, eftersom det är ungefär 1000 gånger snabbare. Eftersom &kommander; kan skicka och ta emot &DCOP;, kan &DCOP; användas för att styra &kommander;. Det är därför det också finns ett specialvärde för lokal &DCOP;, @ldcop, som låter dig skriva betydligt mindre för att ge ett kommando. </para>

<para
>Är det alla huvudbegrepp i &kommander;? Nej, men det bör hjälpa dig att få en känsla för hur det fungerar, så att det som beskrivs inte ser ut som ett främmande språk för dig. Det finns några fler begrepp. Signaler och slots är sättet som &kommander; hanterar händelser. En händelse i ett program betyder egentligen bara <quote
>något hände</quote
>, som att en grafisk komponent skapades eller dess text ändrades. Dessa ändringar <quote
>skickar ut signaler</quote
> och du kan ansluta signalerna till en mottagande slot som då utför något när händelsen inträffar. En användning av detta i &kommander; är grannen till &kommander; text, <quote
>Ifyllnadstext</quote
>. Ifyllnadstext fyller i en komponent när den anropas. Precis som &kommander; text, kan ifyllnadstext innehålla textsträngar eller skript. </para>

<para
>Det bör ha givit dig grundbegreppen för att kunna börja använda &kommander;. Vi försöker hålla antalet specialvärden lågt, och vi använder &DCOP; i stor utsträckning. Idén är att vi vill hålla &kommander;s styrka så konsekvent och strömlinjeformat som möjligt. Du kommer att märka att du kan inlemma vilket skriptspråk som helst i &kommander; var du än behöver, och till och med flera skriptspråk i en dialogruta. Resten av informationen i det här dokumentet antar att du känner till begreppen och terminologin som presenterats här. Exemplen och handledningarna är också mycket användbara för att förstå vad som kan göras med &kommander;. </para>
</sect1>
&editor; <sect1 id="executor">
<title
>Executor</title>

<para
>Programmet Executor, som kallas <application
>kmdr-executor</application
>, kör &kommander; skript. Det laddar <literal role="extension"
>.kmdr</literal
>-filer och skapar dynamiskt en dialogruta med fullständig funktion. </para>

<sect2 id="executor-for-programmers">
<title
>Executor för programmerare</title>

<para
>C++ utvecklare kan enkelt använda klassen KmdrDialogInstance i sina C++ program, så att körfunktionerna är inbäddade i deras program, vilket gör det överflödigt att köra det externa programmet Executor. För vanliga dialogrutor är den extra tid det tar att skapa dialogrutan minimal, men att skapa &kde;-programmet kan fördröja dialogrutan omkring en sekund. </para>
</sect2>

</sect1>

<sect1 id="create-dialog">
<title
>Skapa en dialogruta</title>

<para
></para>
</sect1>

</chapter>
