tde-i18n/tde-i18n-nl/docs/tdewebdev/kommander/basics.docbook

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

<chapter id="kmdr-basics">
<chapterinfo>
<title
>De basis van &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>

&Sander.Koning; 

</authorgroup>
</chapterinfo>

<title
>De basis van &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
>Concepten</title>


<para
>&kommander; werd oorspronkelijk ontworpen rondom een simpel concept dat ietwat revolutionair bleek uit te pakken tussen de andere hulpmiddelen voor visueel ontwerpen. Deze hulpmiddelen bieden u typisch de mogelijkheid om dialoogvensters en wellicht hoofdvensterinterfaces te maken. Een hoofdvensterinterface is natuurlijk het belangrijkste venster van een programma, dat typisch menu's, werkbalken, een statusbalk en een toepassingsgebied bevat. Dialoogvensters zijn subvensters die typisch geen menu's bevatten en worden zo genoemd omdat hun doel is om <quote
>een dialoog te voeren</quote
> of informatie uit te wisselen tussen u en de hoofdtoepassing. De elementen op een dialoogvenster worden <quote
>widgets</quote
> genoemd en u haakt uw programma in deze widgets. &kommander; is verschillend omdat het hier inherent nonprogrammatisch is. Het gebruikt het concept van het associëren van tekst met de widgets op het dialoogvenster. In eerste instantie werd dit <quote
>geassocieerde tekst</quote
> genoemd maar nu wordt het <quote
>&kommander; Text</quote
> genoemd. Widgets op dialoogvensters in &kommander; kunnen de inhoud van andere widgets via een verwijzing bevatten en een widget kan naar zijn eigen inhoud verwijzen door een <quote
>Special</quote
> te gebruiken die er uitziet als @widgetText. Specials zijn opdrachten met een speciale betekenis in &kommander;. Dus als u een dialoogvenster hebt gemaakt met twee LineEdit-widgets en de eerste <quote
>Voornaam</quote
> en de tweede <quote
>Achternaam</quote
> hebt genoemd, kunt u een opdrachtknop maken en de &kommander;-tekst daarvan <quote
>Mijn naam is @Voornaam @Achternaam</quote
> laten zijn. U moet dan wel @widgetText in de widgets voor voor- en achternaam instellen. Weet u het nog? We moeten &kommander; vertellen dat de tekst in de widgets verkregen moet worden. U kunt dit vanuit een <application
>Konsole</application
> uitvoeren en u zult dan de tekenreeks als uitvoer krijgen. De voornaam wordt dus als volgt verkregen: @Voornaam -> verkrijg het widget dat Voornaam heet (@Voornaam) -> @widgetText -> verkrijg de inhoud van het LineEdit-widget. Dus in dit geval retourneert @Voornaam <quote
>Eric</quote
>: @Voornaam -> @widgetText -> <quote
>Eric</quote
>. </para>

<para
>Dat is de eenvoudige kern van &kommander;. Wat u hiermee kunt doen is waar het interessant wordt. Allereerst is het nuttig om op te merken dat, vergeleken met de normale benadering van een taalgebaseerd hulpmiddel, &kommander; geen programmeeropdrachten nodig heeft om deze operaties te definiëren. Dit maakt &kommander; snel voor ontwikkelaars. Voor eindgebruikers is het veel eenvoudiger dan taalconstructies leren. Voor iedereen betekent het dat u zich op uw taak kunt richten in plaats van steeds uw referentiemateriaal bij de hand te moeten hebben. In eerste instantie is de eerste vraag als mensen een hulpmiddel als &kommander; te zien krijgen: <quote
>Waar kan ik een gaaf gereedschap als dit voor gebruiken?</quote
> Zoals blijkt, wordt het manipuleren van tekenreeksen ongeveer overal gebruikt waar u naar kijkt. </para>

<para
>Dus wat kan &kommander; doen? Hier is een lijst, uitgesplitst naar de basisoperaties. &kommander; kan: </para>

<orderedlist>
<listitem
><para
>Tekenreeksen naar het aanroepende programma doorgeven via stdout (standaarduitvoer).</para
></listitem>
<listitem
><para
>Uitvoerbare programma's aanroepen.</para
></listitem>
<listitem
><para
>&DCOP; gebruiken om met &kde;-programma's te communiceren.</para
></listitem>
</orderedlist>

<para
>Als u geen programmeur bent wilt u dit wellicht in lekentaal. In het eerste geval, als u &kommander; vanuit een console opstart, is de console het aanroepende programma. Er is daar een ouder-kind relatie te zien. Een bericht naar de console wordt gedaan via de standaarduitvoer (stdout) van het kindprogramma, zo geheten omdat er ook foutuitvoer is. Dit is interessant omdat sommige programma's, zoals &quantaplus;, stdout gebruiken om informatie te ontvangen van programma's die ze opstarten. Dus de dialoogvensters van &kommander; kunnen hun tekenreeksen direct naar de editor van &quantaplus; doorsturen als ze vanuit &quantaplus; worden aangeroepen. Dit betekent dat dialoogvensters van &kommander; nuttige uitbreidingen van programma's kunnen zijn. </para>

<para
>Het tweede geval is het aanroepen van een uitvoerbaar bestand. Elk programma dat op uw systeem draait is een uitvoerbaar bestand. Zelfs een scriptprogramma wordt door de interpreter van het script gedraaid, dus wordt dit technisch gezien ook uitgevoerd. &kommander; kan net als de console opdrachten uitvoeren, zelfs als u het vanuit het menu opstart. Dus als u bijvoobeeld &GIMP; wilt openen, kunt u een knop de tekenreeks <quote
>gimp</quote
> laten genereren en dit in een special zetten: @exec(gimp). Op die manier ziet u &GIMP; opstarten als u de knop gebruikt. U kunt ook <quote
>ls -l</quote
> uitvoeren, maar u ziet de uitvoer alleen als u vanuit een console aan het werken bent. </para>

<para
>Het derde geval is erg interessant. &DCOP; is de afkorting van &kde;'s <emphasis
>D</emphasis
>esktop <emphasis
>CO</emphasis
>mmunicatie <emphasis
>P</emphasis
>rotocol en is zeer krachtig. Ga uw gang en start de toepassing <application
>kdcop</application
> en kijk eens rond. U zult snel zien dat elke &kde;-toepassing die volgens standaarden is gebouwd, dingen laat gebeuren in &DCOP;, en in de goed ontworpen toepassingen gebeurt veel. Met &DCOP; kunt u allerlei soorten informatie opvragen, widgetwaarden instellen en meer. Deze handleiding bevat een sectie over het gebruik van &DCOP;. &kommander; kan &DCOP; naar elk &kde;-programma sturen en door &DCOP; bestuurd worden. In feite kunt u &DCOP; vanaf de opdrachtregel naar elk &kde;-programma sturen. Dus wat heeft u hieraan? Als u enig redelijk aantal opdrachten wilt uitvoeren begint u te beseffen dat opdrachtregel-&DCOP; voldoende is voor korte opdrachten, maar dat het vertragingen kan verzorgen als het bijvoorbeeld honderden keren vanuit een lus wordt aangeroepen. Daarom heeft &kommander; een special @dcop, omdat deze ruwweg 1000 maal sneller is. Omdat &kommander; &DCOP; kan sturen en ontvangen, kan &DCOP; gebruikt worden om &kommander; aan te sturen. Daarom hebben we ook een lokale &DCOP;-special, @ldcop, waardoor u een stuk minder hoeft te typen om een opdracht te geven. </para>

<para
>Zijn dat alle kernconcepten in &kommander;? Nee, maar dit zou u moeten helpen te begrijpen hoe het werkt, zodat hetgeen wat beschreven wordt niet als een vreemde taal op u overkomt. Er zijn er nog een paar. Signalen en slots zijn de manier waarop &kommander; gebeurtenissen afhandelt. Een gebeurtenis in een programma betekent in feite <quote
>dat er iets gebeurde</quote
> zoals het aanmaken van een widget of het veranderen van de tekst ervan. Deze veranderingen <quote
>zenden signalen uit</quote
> en u kunt deze signalen met een ontvangend slot verbinden dat dan iets zal doen als de gebeurtenis optreedt. Een voorbeeldgebruik hiervan in &kommander; is het broertje van &kommander; Text, <quote
>Population Text</quote
>. Population Text "bevolkt" een widget als deze aangeroepen wordt. Net als &kommander; Text, kan Population Text tekenreeksen of scripts bevatten. </para>

<para
>Dat zou u de basisconcepten moeten geven om &kommander; te gaan gebruiken. We proberen het aantal specials laag t ehouden en we gebruiken veel &DCOP;. Het idee is dat we de kracht van &kommander; zo consistent en gestroomlijnd mogelijk willen houden. U zult ontdekken dat u kunt elke scripttaal in &kommander; kunt gebruiken waar u dat wilt, of zelfs meerdere scripttalen in een dialoog. De rest van de informatie in de document gaat er vanuit dat u bekend bent met de concepten en termen die hier gegeven zijn. De voorbeelden en oefeningen zijn oko erg nuttig om te begrijpen wat er met &kommander; gedaan kan worden. </para>
</sect1>
&editor; <sect1 id="executor">
<title
>De uitvoerder</title>

<para
>De uitvoerder, <application
>kmdr-executor</application
> geheten, voert &kommander;-scripts uit. Het laadt <literal role="extension"
>.kmdr</literal
>-bestanden en produceert dynamisch een volledig functioneel dialoogvenster. </para>

<sect2 id="executor-for-programmers">
<title
>De uitvoerder voor prgorammeurs</title>

<para
>C++-ontwikkelaars kunnen eenvoudig de klasse KmdrDialogInstance in hun C++-programma;'s gebruiken zodat de uitvoeringsfunctionaliteit ingebed is in hun programma, hetgeen de noodzaak voor het uitvoeren van de externe uitvoerder wegneemt. Voor standaarddialoogvensters is de extra benodigde tijd voor het aanmaken van het dialoogvenster minimaal, mar het aanmaken van de &kde;-toepassing kan het dialoogvenster ongeveer een seconde vertragen. </para>
</sect2>

</sect1>

<sect1 id="create-dialog">
<title
>Een dialoogvenster aanmaken</title>

<para
></para>
</sect1>

</chapter>