<?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
>Körprogrammet</title>

<para
>Körprogrammet, 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. <warning
><para
>Från och med version 1.3, varnar körprogrammet om skriptfilen inte är körbar. Det är en extra säkerhetsfunktion som försöker få användaren att tänka på de möjliga negativa konsekvenserna av att köra ett skript från en opålitlig källa. Användaren kan bekräfta att dialogrutan ska köras, eller om källan är pålitlig, kan skriptet göras körbart för att helt bli av med varningen.</para
></warning>
<note
><para
>Version 1.3 stöder inledningen med <emphasis
>#!/sökväg/kmdr-executor</emphasis
> i .kmdr-skriptfiler (ersätt sökväg med sökvägen till körprogrammet). Sådana filer, om de görs körbara, kan köras från kommandoraden precis som vilket annat körbart program som helst, utan behov att skicka skriptet till kmdr-executor som väljare.</para>
<para
>Kom ihåg att när väl tecknen #! har lagts till i filens början, kan inte dialogrutan köras eller redigeras med äldre versioner av &kommander;.</para>
<para
>Den rekommenderade användningen är <screen>
#!/usr/bin/kommander
</screen
> och skapa en symbolisk länk från kmdr-executor till /usr/bin/kommander.</para>
<para
>Teckenföljden #! kan läggas till i en dialogruta direkt från editorn, genom att ändra egenskaperna <guilabel
>useShebang</guilabel
> och <guilabel
>shebang</guilabel
> för huvuddialogrutan.</para>

</note>
</para>

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

<para
>C++ utvecklare kan enkelt använda klassen Instance 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>
<para
>En annan metod är att använda <emphasis
>kommander_part</emphasis
> KReadOnlyPart. Detta KPart-delprogram kan ladda och köra vilken &kommander;-dialogruta som helst inne i ett annat KDE-program.</para>
</sect2>

</sect1>

<sect1 id="create-dialog">
<title
>Skapa en dialogruta</title>
<para
>För att lära dig hur en dialogruta skapas, hur grafiska komponenter läggs till, hur en layout används, och hur komponentegenskaper ändras, titta i handboken för &Qt; Designer (version 3.x). Du kan komma åt den genom att köra <command
>designer</command
> från kommandoraden eller skrivbordsmenyn. </para>
<para
>Extrafunktionen som &kommander; erbjuder är <guilabel
>Kommander Text</guilabel
> som hör ihop med varje grafisk komponent. Texterna är den körbara delen av dialogrutan (skriptet), antingen skriven på ett skriptspråk (med den gamla &kommander;-syntaxen) eller med det interna &kommander;-språket, den så kallade nya tolken. </para>
<para
>För att lära dig mer om språksyntax, kommandon och hur texteditorn används, läs följande kapitel och ta en titt på exemplen som levereras med &kommander;s källkod.</para>
</sect1>

<sect1 id="exec-bit">
<title
>Körbar bit - nytt i 1.3</title>
<para
>Av säkerhetsskäl introducerade vi kravet på körbar bit i version 1.3. Vissa kommer att ge sitt bifall till detta, som sedan länge förväntat. Andra kommer att anse att det är hemskt irriterande, eller till och med för skrämmande för att använda. Problemet är att man kan ladda ner en Kommander-dialogruta var som helst, eller få en med e-post, och klicka på den och köra den av misstag. Eftersom Kommander kan köra skalskript har det på sätt och vis en ovanlig ställning. Medan andra program inte besvärar dig på detta sätt, var du faktiskt tvungen att installera dem, och alltså känner du dig säker och har för avsikt att köra dem. En enda rad i ett skalskript skulle kunna radera din hemkatalog permanent. Vår avsikt är att eliminera möjligheten att klicka på en opålitlig dialogruta av misstag. Vi ber om ursäkt för eventuella olägenheter, men det finns inget sätt att göra detta så att till och med utvecklaren är övertygad om att det inte irriterar dig medan du förblir säker. </para>
<para
>Du förhindras inte att köra dialogrutan, utan blir bara påmind. Du kan få påminnelsen att försvinna genom att använda filhanteraren eller ett skal för att sätta den körbara biten. Högerklicka på dialogrutan i Konqueror, välj egenskaper i menyn, välj fliken Skydd och markera kryssrutan <quote
>Körbar</quote
>. Nu försvinner påminnelsen från dialogrutan för alltid. Titta på vår webbplats efter ett verktyg som söker efter &kommander;-dialogrutor, låter dig granska dem, och välja om någon eller alla ska ha biten satt. Använd följande kommando för att göra alla &kommander;-dialogrutor i en katalog körbara i en terminal: </para>
<screen
>chmod u+x *.kmdr
</screen>
<warning
><para
>Ställ inte in dialogrutor som körbara om du inte är säker på deras ursprung.</para
></warning>
</sect1>

</chapter>
