path: root/tde-i18n-sv/docs/tdewebdev/kommander/tutorials.docbook

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

<chapter id="tutorials">
<chapterinfo>
<title
>Tips och handledningar</title>
<authorgroup>
<author
><firstname
>Eric</firstname
> <surname
>Laffoon</surname
> <affiliation
><address
> <email
>eric@tdewebdev.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
>Tips om användning av &kommander;</title>
<para
>I det här avsnittet går vi vidare från att bara lista grafiska komponenter till att verkligen använda &kommander;. Om du vill skaffa dig god erfarenhet kommer det här avsnittet att vara till stor hjälp.</para>

<sect1 id="tutorial-editor">
<title
>Använda editorn</title>
<para
>Vid en första titt ser editorn ganska självklar ut, och på många sätt är den det. Klicka på ikonen för att skapa ett nytt formulär, klicka därefter på en grafisk komponent och klicka, eller klicka och dra, på formuläret. Komponentgreppen finns där, som är bekanta för alla som någonsin lagt till en bild i ett dokument i en ordbehandlare. Vad som inte är lika uppenbart är småsaker. En sak som bör nämnas från början är namngivning av komponenter. Namn måste vara unika, och &kommander; använder en namngivningsmetod med det formella komponentnamnet och ett nummer unikt för komponenttypen. Du kan ändra namn på en komponent, och &kommander; tillåter inte ett duplicerat namn. Om du dock skapar en komplex dialogruta och bestämmer dig för att börja ändra namn, kommer du att få problem. Signaler och slots hanterar namngivning åt dig, och alla komponenter du ändrar kommer att speglas i anslutningarna av signaler och slots. Tyvärr har den funktionen aldrig lagts till i komponentfunktionerna. Alltså blir alla anrop till komponenten fel. Du skulle kunna stänga dialogrutan och öppna den i en texteditor som Kwrite och använda sök och ersätt. En bättre lösning är att börja med en viss idé om vilka beskrivande namn du vill ge till nyckelkomponenter. Det kan vara slöseri med tid att namnge etiketter, men det visar sig snabbt vara ett misstag att inte namnge skript och omgivande komponeter. Du kan också ange ikoner för skript, vilket gör det ännu snabbare att identifera dem visuellt. </para>


<sect2 id="tutorial-editor-tools">
<title
>Editorverktyg</title>
<para
>Det första du märker är ett egenskapsfönster, i allmänhet placerat till vänster. Utforska det! Här hittar du många användbara inställningar av formulär och grafiska komponenter. Vissa av dem är layoutinställningar, ikoner, om någonting är aktivt, text med mera. Om du till exempel lägger till en trädkomponent i ett formulär kan du ändra förvald sökvägsavskiljare, vilket är användbart om den innehåller data. Det är lätt hänt att ett snedstreck skapar ett delobjekt av misstag. Här hittar du också väljarlägen, om hela raden i komponenter med flera kolumner ska markeras, med mera. </para>
<para
>Om du leker med en layout och förlorar en grafisk komponent bakom en annan, eller utanför formuläret, är objektutforskaren praktisk. Den är också bra för att se strukturen. Nästa mycket användbara vy är loggvyn, som visar standardutmatning och standardfelutmatning. Felvyn är ovärderlig. Det är här dina debug()-kommandon skrivs ut, och stället där du får detaljerad information. Exempelvis, när du använder databasinsticksprogrammet ger det ytterligare information vid datafel. Det visar också alla skalanrop med mera. Standardutmatningsvyn låter dig se vad som skulle visas av skalet eller ett program som använder detta, som Quanta. Dialogvyn är inte särskilt användbar, om du inte har många dialogrutor öppna. Åtgärdsvyn är bara aktiv vid användning med ett huvudfönster, och är i detta fall det enda sättet att lägga till åtgärder, menyer och objekt i verktygsrader. </para>
</sect2>

<sect2 id="tututorial-add-tools">
<title
>Lägga till egna verktyg</title>
<para
>&kommander; gör det enkelt att lägga till egna verktyg i editorn, som du kan utveckla med &kommander;. Vi kommer att leverera några med &kommander;, samt göra några tillgängliga för nerladdning. Du kan enkelt lägga till egna. Ta först en titt och se var de finns. Om de är installerade, finns de i verktygsmenyn under avdelaren. Menyn i &kommander; ger tillgång till grafiska komponenter. Menyn Egna ger tillgång till installerade insticksprogram. Menyn Editor är stället där dina egna verktyg hamnar. För att lägga till ett verktyg för hand, bestäm dig först för om det ska vara tillgängligt för hela systemet eller bara ditt skrivbord. För hela systemet används katalogen som KDE är installerad i. För skrivbordet används den dolda KDE-katalogen i din hemkatalog, oftast ~/.kde. Därifrån är sökvägen /share/apps/kmdr-editor/editor/ i båda fallen. Om dialogrutan du lägger till behöver komma åt verktyg eller filer, kan du lägga dem i en underkatalog. Vilka &kommander;-dialogrutor du än lägger till där, kommer att kännas igen och läggas till i menyn vid start. Genom att klicka på menyalternativet laddas dialogrutan. Du bör också notera att det finns en mallkatalog där, och du kan lägga till nya mallar för nya dialogrutor. </para>
</sect2>

<sect2 id="included-tools">
<title
>Egna verktyg som ingår</title>
<para
>Flera verktyg ingår i den här utgåvan, och är redan installerade i editorns verktygsmeny. Fler verktyg för projekthantering, gränssnitt för databasutveckling, kodsnuttar, med mera, håller på att utvecklas. Det viktigaste och mest användbara verktyget att titta på är dialogrutan med exempel. Eftersom editorn inte längre utvecklas för KDE3, kan den inte infoga en dialogruta i den aktuella editorn, utan dialogruta som väljes öppnas i en ny instans av editorn. Det finns gamla dialogrutor från &kommander;s barndom, handledningar från senare utveckling och det aktuella avsnittet, som visar nya funktioner i den här utgåvan. Att titta på dessa bör vara till hjälp. Håll ett öga på vår webbsida för mer. </para>
</sect2>

<sect2 id="tutorial-layout">
<title
>Använda en layout</title>
<para
>Många tycker om att dela med sig av sina &kommander;-dialogrutor. Nästan utan undantag, känner de inte till hur man hanterar layouter. Skapa en dialogruta och försök därefter ändra storleken, så ser du vad som händer. Vore det inte trevligare om den skulle bete sig som den borde istället för att lämna de grafiska komponenterna oförändrade? Det blir värre när du delar med dig av den, och skillnader i teckensnitt, bildskärm och upplösning i bildpunkter samverkar för att få ditt mästerverk att se ut som om det var ihopsatt av en treåring med tuggummi och häftstift. Använd alltid, alltid, alltid en layout i dina dialogrutor! </para>
<para
>Ok, du är övertygad, och vill inte få besviken e-post från mig som ber dig att använda en layout i din dialogruta. Hur gör man det då? Det finns layoutknappar i verktygsraden och alternativ i den sammanhangsberoende menyn. Eftersom &kommander; är baserad på en äldre version av Qt Designer, kan du titta på Qt Designers dokumentation och handledningar. Några grunder och ett antal tips är allt som nämns här. </para>
<itemizedlist>
<listitem
><para
>Använd rutnätet. Det placerar allting på platser som är <quote
>goda gissningar</quote
>.</para
></listitem>
<listitem
><para
>Kom ihåg att omgivande komponenter är separata. En flikkomponent, gruppruta eller layoutgrupp har sin egen layout. Glöm alltså inte bort fönstret.</para
></listitem>
<listitem
><para
>Komponenter som inte är synliga under körning kan orsaka att en layout verkar mer utmanande. Vad ska man göra med dem? Jag rekommenderar att de grupperas i en egen layout intill eller under huvudlayouten. De synliga komponenterna knuffar helt enkelt undan dem, och ger dig ett förutsägbart resultat.</para
></listitem>
<listitem
><para
>Titta på egenskaperna, där du kan ställa in en komponent att expanderas eller andra saker, samt minimal och maximal storlek. Några experiment lär dig en hel del. Du kan också ställa in mindre mellanrum här.</para
></listitem>
</itemizedlist>
<para
>Nu följer ett antal trick och tips.</para>
<itemizedlist>
<listitem
><para
>Tillsammans med grundläggande layouter kan du använda avdelare. När dialogrutan kör kan du dra avdelaren uppåt och neråt, eller åt höger och åt vänster för att se saker bättre. Det kan verka som om det finns en begränsning här eller att det inte fungerar, men det fungerar och har inga begränsningar. Försäkra dig bara om att placera olika komponenter i två layouter, och högerklicka för att få layouten och inte bara en underliggande komponent. Du har full frihet att skapa en labyrint med avdelare, under förutsättning att du följer reglerna.</para
></listitem>
<listitem
><para
>Dolda rutor kan användas. Skapa en gruppruta och släpp komponenter på den. Placera den i layouten så att andra komponenter eller layouter expanderas för att uppta dess plats när den är dold. Ändra nu synligheten med en knapp eller en meny. </para
></listitem>
<listitem
><para
>Trick med verktygslådan: Verktygslådan har ett fel i editorn som gör att man inte kan lägga till komponentrutor i editorn utan att bli tokig. Resultatet är att man måste lägga till dem vid körning. Dock letar den efter en komponent, och om du vill ha någonting komplicerat bör du använda en gruppruta med en layout, och skapa en layout i dialogrutan med grupprutan längst ut, även om den hamnar utanför fönstrets kanter. Ladda den nu vid initiering i verktygslådan. Fönsterlayouten hoppar då på plats.</para
></listitem>
<listitem
><para
>Layoutproblem kan uppstå där komponenter som är inställda till något som liknar minimalt/expanderande kan råka bli dolda innan fönstrets layout är klar. Layoutsystemet lyder dina konstigheter, och kan krympas så att rullningslister och annat döljs. Försäkra dig om att allt är synligt innan du gör färdigt layouten, och fundera på att inte använda minimalt i detta fall.</para
></listitem>
</itemizedlist>
<para
>För mer om detta slå upp Qt Designer dokumentation för Qt 3.x.</para>
</sect2>

<sect2 id="signals-slots">
<title
>Signaler och slots</title>
<para
>En av de många användbara funktionerna som ärvdes av Qt Designer är signaler och slots. Naturligtvis har gränssnittet konstruerats om i ett försök att göra det lämpligt för &kommander;. Signaler och slots hanterar styrning av interna händelser i Qt- och KDE-program. Vi försöker anpassa det så att du inte behöver kunna skillnaden mellan datatyper i C++, men om du använder de nya funktionerna för att skapa anslutningar i farten är det praktiskt att kunna kopiera informationen från anslutningsverktyget. Låt oss ta en titt på vad det betyder. Någonting inträffar i en av dina komponenter. Den kanske tar emot ett klick, ett dubbelklick, får sitt värde ändrat, något markeras, eller en meny begärs. Det är bara några av de möjliga händelser som skulle göra att en signal skickas. Du kanske vill ändra listan i en listruta om en ny markering görs i en kombinationsruta. Det är en användbar funktion i ett avancerat program, och det enda sättet att göra det utan att därefter behöva klicka på en knapp, är att ha en signal ansluten till en slot. En sådan slot kan vara i ett skript eller en knapp. När en signal tas emot ser denna slot till att göra vad den blev ombedd. Det finns ett verktyg för att redigera anslutningarna. Var uppmärksam när du gör detta, eftersom det finns ett stort antal ärvda signaler och slots. Att tala om för ett skript, som är osynligt när dialorgutan körs, att justera sin storlek när du istället ville köra det, får dig säkert att undra vad som hände. </para>
<para
>Du kan öppna anslutningsverktyget genom att högerklicka var som helst i dialogrutan och välja det i menyn. Klicka på menyn så ser du en lista med gjorda anslutningar längst ner. Ovanför visas två listor med signaler och slots, och ovanför dem respektive sändare och mottagare som är vald. Ett enkelt sätt att skapa anslutningar är visuellt. Titta i verktygsraden eller i verktygsmenyn. Där finns tre objekt i en grupp. En pekare, anslutningar av signaler och slots, och flikordningen eller komponenterna. För de nyfikna: att välja den ställer in anslutningsläget. Klicka på komponenten för att skicka signalen och dra den till komponenten som ska ta emot den i en slot. När du gör det ser du en linje och en indikering om var du släpper på komponenten under musen. Editorns statusrad talar om för dig vad som kommer att anslutas. </para>
<note
><para
>I &kommander; version 1.3 finns funktionen connect() som låter dig ansluta signaler och slots i farten. Det är användbart om du just har använt createWidget. Naturligtvis kan du inte använda dialogrutan för något som &kommander; ännu inte vet existerar. Tyvärr finns det för många kombinationer för att lista, så du måste skriva in signaler och slots. <emphasis
>De måste skrivas exakt rätt, annars fungerar de inte.</emphasis
> Här är anslutningsverktyget återigen praktiskt. Öppna det och välj två komponenter som motsvarar de du vill ansluta, och läs av anslutningsinformationen. Om den lyder <command
>execute(const QString&amp;)</command
>, är det exakt vad du måste skriva in.</para
></note>
</sect2>

<sect2 id="slot-functions">
<title
>Slotfunktioner</title>
<para
>Från &kommander; version 1.3 har slot-funktioner lagts till. Det kan du se i funktionsbläddraren, som ovanligt nog inte ger så bra beskrivningar i detta fall. Vad &kommander; gör är att läsa in varje slot som är registrerad i en given komponent, och direkt göra dem tillgängliga. Det är mycket användbart. Tabellkomponenten har till exempel inte en standardmetod för att automatiskt justera kolumnbredden. Du kan tycka att det är irriterande, men titta bara under slots så hittar du den. Texteditorn saknar också inbyggda funktioner för någon verklig redigering, men titta under slots så finns allt du kan önska. Du kan behöva titta i några dokument, eller bara experimentera. Det är helt enkelt för svårt att dokumentera varje slot tillgänglig i inbyggda komponenter och insticksprogram. De flesta är dock självförklarliga. </para>
</sect2>
</sect1>

<sect1 id="tutorial-basics">
<title
>Grundhandledningar</title>
<para
>Det mesta av informationen i det här avsnittet är baserat på dialogrutor med exempel från länge sedan, vilka tyvärr inte var allmänt tillgängliga, eftersom de levererades med källkoden men inte installerades. Du hittar dem i verktygsmenyn under exempel i <quote
>handledningsdelen</quote
>. Kom ihåg att de flesta av dessa exempel använder den gamla tolken. Det är varken bra eller dåligt. De flesta av funktionerna i &kommander; delas mellan båda tolkarna. Nu använder &kommander; normalt den nya tolken, men du kan ställa in vilken som helst. Se <link linkend="new_parserdocs"
>dokumentationen om den nya tolken</link
> för mer information om de två tolkarna. </para>
<para
>När du betraktar exempeldialogrutorna, kom då ihåg att titta på följande ställen för att se hur saker är gjorda. </para>
<itemizedlist>
<listitem
><para
>Dialoginitiering: Klicka med mittenknappen på dialogrutans yta, eller högerklicka och välj &kommander; text. Här ser du vad som körs när dialogrutan startar.</para
></listitem>
<listitem
><para
>Knappar: Klicka med mittenknappen på knappen, eller högerklicka. Typiskt finns det skript här.</para
></listitem>
<listitem
><para
>Komponenter: Vissa komponenter som tidtagning och konsol innehåller instruktioner.</para
></listitem>
<listitem
><para
><link linkend="signals-slots"
>Signaler och slots</link
>: Det är sättet som Qt- och KDE-program kommunicerar internt. </para
></listitem>
</itemizedlist>
<para
>Följande lista med dialogrutor kan vara korta för att fokusera på var mer information krävs för att förklara mer komplexa uppgifter som är möjliga med &kommander;. De är kopierade från Michals anteckningar. </para>

<sect2 id="tutorial-globals">
<title
>Globals</title>
<para
>Visar hur &DCOP;-anropen global och setGlobal används för att tillhandahålla globala variabler för skript.</para>
<blockquote
><para
>Funktioner, koncept: global - setGlobal - changeWidgetText </para
></blockquote>
</sect2>

<sect2 id="tutorial-dcop">
<title
>&DCOP;</title>
<para
>Visar hur både lokala och externa &DCOP;-anrop används för att kommunicera med externa program (här Kmail).</para>
<blockquote
><para
>Funktioner, koncept: extern DCOP - addListItem - enableWidget - @selectedWidgetText - @widgetText </para
></blockquote>
</sect2>

<sect2 id="tutorlal-slots">
<title
>Slots</title>
<para
>Visar hur anslutningar och slots används för att hantera händelser. Både ifyllnads- och vanliga slots används.</para>
<note
><para
>Ifyllnadstext utvecklades ursprungligen innan DCOP, specialvärden och skript i &kommander;. Eftersom allt den gör kan göras på andra sätt, och att det är lätt att glömma bort att leta efter problem här, samt den inneboende svårigheten att introducera ett ytterligare beteende att förklara, avråds funktionen från att användas. Den finns kvar av illustrationssyfte, och även om det kommer att vara enkelt att anpassa &kommander; dialogrutor till KDE 4, garanteras inte att den här funktionen kommer att fortsätta fungera i framtiden. <emphasis
>Använd den inte!</emphasis
> </para
></note>
<blockquote
><para
>Vanliga slots används. slots och anslutningar - populate() </para
></blockquote>
</sect2>

<sect2 id="tutorial-settings">
<title
>Settings</title>
<para
>Visar hur funktionerna @readSetting och @writeSetting används för att skriva och återställa komponentinnehåll. Visar också hur ifyllnadslots används för att initiera komponentinnehåll.</para>
<blockquote
><para
>Funktioner, koncept: @readSetting - @writeSetting - populate() - slots och anslutningar - destroy </para
></blockquote>
</sect2>

<sect2 id="tutorial-append">
<title
>Append</title>
<para
>Visar hur du kan lägga till text i Texteditor och hur du kan använda den för att visa formaterad text. Se också nyare exempel på hur slots används för att editera formaterad text samt nya dialogrutor för teckensnitt och färg.</para>
<blockquote
><para
>Funktioner, koncept: changeWidetText - RichTextEdit </para
></blockquote>
</sect2>

<sect2 id="tutorial-cmdline">
<title
>Command Line</title>
<para
>Visar hur du kan skicka parametrar till &kommander; dialogrutor via kommandoraden. Visar också hur innehåll i listor och knapptexter kan ändras. Se avsnittet om <link linkend="passargs"
>hur man skickar argument</link
> med den nya tolken för mer om detta.</para>
<blockquote
><para
>Funktioner, koncept: kommandoradsväljare - global - changeWidgetText - addListItem - clearList </para
></blockquote>
</sect2>

<sect2 id="tutorial-initialize">
<title
>Initialize</title>
<para
>Visar hur du använder skripten 'initialization' och 'destroy' i huvuddialogrutan för att initiera och lagra vissa inställningar. </para>
<blockquote
><para
>Funktioner, koncept: initialization - destroy - readSetting - writeSetting </para
></blockquote>
</sect2>

<sect2 id="tutorial-array">
<title
>Array</title>
<para
>Visar hur associativa fält används för att lagra och återställa information som hör ihop med omgivande objekt.</para>
<blockquote
><para
>Funktioner, koncept: @Array funktioner </para
></blockquote>
</sect2>

<sect2 id="tutorial-strings">
<title
>Strings</title>
<para
>Visar hur funktioner för stränghantering används </para>
<blockquote
><para
>Funktioner, koncept: @String funktioner - rik texteditor </para
></blockquote>
</sect2>

<sect2 id="tutorial-tree">
<title
>Tree</title>
<para
>Visar hur en grafisk trädkomponent används </para>
<blockquote
><para
>trädkomponent - filväljare - initialization - env </para
></blockquote>
</sect2>

<sect2 id="tutorial-widgets">
<title
>Widgets</title>
<para
>Visar hur man hämtar komponentinformation </para>
<blockquote
><para
>metoden type - metoden children </para
></blockquote>
</sect2>

<sect2 id="tutorial-statusbar">
<title
>StatusBar</title>
<para
>Visar hur den grafiska komponenten statusrad används </para>
<blockquote
><para
>komponenten statusrad - populate </para
></blockquote>
</sect2>

<sect2 id="tutorial-loop">
<title
>Loop</title>
<para
>Visar hur interna snurror används </para>
<blockquote
><para
>for - forEach </para
></blockquote>
</sect2>

<sect2 id="tutorial-calc">
<title
>Calc</title>
<para
>Visar hur funktionen @expr används för att göra några beräkningar </para>
<blockquote
><para
>expr - String.replace </para
></blockquote>
<note
><para
>Funktionen @expr() behövs inte längre i den nya tolken eftersom uttryck direkt kan tolkas var som helst där du logiskt vill använda dem.</para
></note>
</sect2>

<sect2 id="tutorial-picview">
<title
>Picview</title>
<para
>Visar hur komponenten punktavbildningsetikett använder funktionen populate() </para>
<blockquote
><para
>punktavbildningsetikett - populate - filväljare - slots och anslutningar </para
></blockquote>
</sect2>

<sect2 id="tutorial-table">
<title
>Table</title>
<para
>Visar hur en grafisk tabellkomponent används </para>
<blockquote
><para
>insertRow - insertColumn - currentRow - currentColumn - setColumnCaption - setRowCaption - removeRow - removeColumn </para
></blockquote>
</sect2>

</sect1>

<sect1 id="examples">
<title
>Aktuella exempel</title>
<para
>Följande exempel speglar de senaste utvecklingarna av &kommander;. I dess nuvarande skick har &kommander; få begränsningar vid utveckling av små till medelstora program. Det är definitivt inte lämpad att utveckla en ny version av Kword, men för en enkel editor, ett databasgränssnitt, ett grafiskt gränssnitt för ett kommandoradsprogram eller något annat program som följer andemeningen i Unix och Linux med små program, är det ett bra val. Avsikten med de exempel som presenteras här är att visa potentialen, samt hur man går runt begränsningar. Några användbara trick ingår i dem, om du vill skapa ett mer kapabelt program med &kommander;. Kom ihåg att &kommander; inte är avsett att göra allt, utan att göra det mesta. Med detta i åtanke, bör du kunna bygga något i &kommander; snabbare än med andra alternativ, och lägga till ett grafiskt gränssnitt till skriptspråk som inte stöds på annat sätt i KDE. </para>
<note
><para
>Exemplen är installerade under <command
>$TDEDIR/share/apps/kmdr-editor/editor</command
>. Ifall du inte har dem där, hämta dem på <ulink url="http://kommander.tdewebdev.org"
> vår hemsida</ulink
>, genom att ladda ner den senaste utgåvan. </para>
</note>

<sect2 id="editor-poc">
<title
>editor-poc.kmdr</title>
<para
>Den lilla dialogrutan som växte till ett huvudfönster. Eftersom &kommander; inte har en inbyggd grafisk komponent för huvudfönster har det antagits att bara dialogrutor kan hanteras. I själva verket stöds bara dialogrutor officiellt, men du kan köra huvudfönster i &kommander;. Det här är ett exempel på en editor. Om du vill skapa ett program med ett huvudfönster i &kommander;, starta bara Qt Designer och skapa ett. Byt därefter namn på *.ui-filen till en *.kmdr-fil. Öppna den nu i &kommander; och gör vad du skulle gjort i vanliga fall. </para>
<note
><para
>När det här skrivs är det känt att det inte fungerar att skriva eller läsa inställningar under &kommander;. Initialize och Destroy finns inte, eftersom det inte finns någon &kommander;-text, men det finns dock signaler för dem i fönstret, så funktionen är intakt. Under huvudfönstret är det inte möjligt att använda några åtgärder via DCOP, eftersom de är QActions från Designer, och KActions härleds inte från QActions i KDE 3.x. Det betyder att ett DCOP-anrop för att lista åtgärder eller ange tillstånd inte fungerar. Det är inte heller möjligt att komma åt statusraden. Inte heller undermenyer i menyraden eller kombinationsåtgärder i verktygsraden fungerar. Även om detta inte är en grafisk komponent i &kommander;, eller något som officiellt stöds, verkar det lämpligt för användning i många små program.</para
></note>
<para
>Det finns en dialogruta för snabbhjälp som editorn visar, som grundligt beskriver vad som händer inuti. </para>
</sect2>

<sect2 id="example-key-value">
<title
>kevaluecombo.kmdr</title>
<para
>&kommander; kan användas med databaser, och har ett valfritt <ulink url="http://kommander.tdewebdev.org/releases.php#plugins"
>databasinsticksprogram</ulink
>. En svaghet är att man inte kan lagra par av nycklar och värden i kombinationsrutan. Ett klurigt trick hanterar detta. Det kräver bara att innehållet i kombinationsrutan inte ändras utan att det görs via fälten som hör ihop med den. Eftersom detta oftast används med SQL i små datamängder, går det rätt snabbt att till och med ladda om hela kombinationsrutan. Det inneboende problemet är att &kommander; normalt inte har internt indexerade fält. Det förvärras av det faktum att för att hantera skalkommandon som returnerar rader åtskilda med nyradstecken, laddar &kommander;s fältfunktioner vad som i själva verket är ett fält av nycklar. Sådana fält kan bara kommas åt via en foreach-snurra. Det är orsaken att nya indexerade fältfunktioner har lagts till. Det är viktigt att komma ihåg att dessa fält inte hanteras av sig självt, men deras funktioner för att infoga och ta bort värden hjälper dig med det. </para>
<para
>För att återgå till kombinationsrutan, så returnerar den markerad text, men den returnerar också aktuellt index. Den hanterar strikt ett nollbaserat fält i en följd. Det är nyckeln. Vi går igenom en datamängd med en nollbaserad indexräknare och skapar två fält, eftersom &kommander; inte heller kan skapa fält bestående av fält. Den kan dock använda ett fältvärde för att representera en nyckel, precis som vilket värde som helst skulle kunna göra. Om du tar en titt på dialogrutan som ingår, finns koden som faktiskt hanterar detta i <quote
>ScriptObject36</quote
>. Vi visar ett utdrag av koden här. </para>
<screen
>c = ListBox1.count-1
for i = 0 to c do
  array_indexedFromString("x", ListBox1.item(i))
  _a[x[0]] = x[1]
  _b[i] = x[0]
  ComboBox10.insertItem(_a[_b[i]], i)
end
</screen>
<para
>Det är mer som sker, som kontroll av duplicerade nycklar, men detta är kärnan. Du kan högerklicka på listrutan och prova menyalternativen. Slutresultatet är att den använder nyckelindex via en proxy, och returnerar både nyckel och värde. Använd koden om du vill vara 100 % säker på att förhållandet mellan nyckel och värde är exakt. </para>
</sect2>

<sect2 id="kpart-demo">
<title
>Demonstration av KPart</title>
<para
>Från Kommander 1.3, skapar Kommander automatiskt KPart-delprogram med libkommander_part.la. Förutom det finns ett KPart-insticksprogram som låter Kommander ladda insticksprogram. Eftersom vi är nyfikna utvecklare, försökte vi ladda ett Kommander-delprogram i Kommander. Varför ska man göra det? Ja, varför inte? Resultatet var intressant, och demonstreras här. En intressant sak är att det omgivande delprogrammet direkt kan komma åt allt i det inladdade delprogrammet. Även om det är praktiskt, har det en nackdel. Alla underliggande komponenter med samma namn som i det omgivande delprogrammet orsakar en låsning. Dessutom skapas DCOP-gränssnittet om igen för delprogrammet, vilket suddar ut gränssnittet i det omgivande delprogrammet, och inaktiverar stora delar av den gamla tolkens funktion, samt Kommander-specifik DCOP för det omgivande delprogrammet. Det är för svårt att rätta under KDE 3-versionens återstående livstid. Även med dessa begränsningar och varningar, kan det vara användbart, om det används med försiktighet. Exempelfilerna som använder sig av det finns bland de aktuella exemplen i kpartmwframe.kmdr och kpartpart.kmdr. Kom ihåg att du behöver KPart-insticksprogrammet för att kunna köra exemplet fullständigt. </para>
<para
>Du kan också ladda Kmail, Korganizer och många andra KDE-program direkt i Kommander, naturligtvis utan problem. KHTML och KDE:s filhanteringskomponenter verkar inte ha vissa funktioner, men det finns ett särskilt KHTML-insticksprogram om du verkligen vill inkludera en webbläsare. </para>
</sect2>
<sect2 id="example-passed-params">
<title
>passvariables.kmdr</title>
<para
>Från &kommander; 1.3 kan du skicka och returnera variabler med skript. Den här dialogrutan demonstrerar det. Titta noga på knapparnas innehåll. Du märker att ingen av knapparna skriver direkt i någon av radeditorrutorna som tar emot text från skriptet. Medan en skrivs direkt från skriptet, skrivs en annan med innehållet som skickas från knappen. Den tredje skrivs inte alls, men skickas tillbaka med funktionen return(), där den tas emot av knappen och skrivs. Det visas också på höger sida med PHP, så du ser hur det skulle kunna fungera med Python, Ruby, Perl eller till och med ett mindre vanligt språk som Rexx. Språk som hanterar DCOP kan också göra mycket mer i &kommander;. Demonstrationens syfte är att visa friheten som erbjuds. &kommander; har inte funktioner, men ändå finns de. Skapa ett skript, deklarera några globala variabler om du vill, skicka några parametrar till ett annat skript och returnera ett värde. För ett med avsikt förenklat skriptverktyg för grafiska användargränssnitt är det ett kapabelt beteende. Beteendet finns bara i den nya tolken, och dokumenteras <link linkend="passargs"
>här</link
>. </para>
</sect2>

<sect2 id="tableselect">
<title
>tableselect.kmdr</title>
<para
>Exemplet demonstrerar hur den nya markeringsfunktionen används i tabellkomponenten. Det är nu möjligt att få fyra koordinater för att göra det möjligt att markera ett block. Det visar också hur man hade varit tvungen att göra innan den nya funktionen, och hur parametrarna som skickas till ett skript används. Dessutom demonstrerar det en enkel blockkopierings- och inklistringsfunktion för en tabell, samt en sammanfattning av ett block. </para>
</sect2>

</sect1>
</chapter>